bin.gen_ndr/default/librpc/gen_ndr/ndr_samr.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "bin/default/librpc/gen_ndr/ndr_samr.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 #include "librpc/gen_ndr/ndr_lsa.h"
   8 #include "librpc/gen_ndr/ndr_security.h"
   9 _PUBLIC_ enum ndr_err_code ndr_push_samr_AcctFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  10 {
  11         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  12         return NDR_ERR_SUCCESS;
  13 }
  14
  15 _PUBLIC_ enum ndr_err_code ndr_pull_samr_AcctFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  16 {
  17         uint32_t v;
  18         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  19         *r = v;
  20         return NDR_ERR_SUCCESS;
  21 }
  22
  23 _PUBLIC_ void ndr_print_samr_AcctFlags(struct ndr_print *ndr, const char *name, uint32_t r)
  24 {
  25         ndr_print_uint32(ndr, name, r);
  26         ndr->depth++;
  27         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_DISABLED", ACB_DISABLED, r);
  28         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_HOMDIRREQ", ACB_HOMDIRREQ, r);
  29         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_PWNOTREQ", ACB_PWNOTREQ, r);
  30         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_TEMPDUP", ACB_TEMPDUP, r);
  31         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_NORMAL", ACB_NORMAL, r);
  32         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_MNS", ACB_MNS, r);
  33         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_DOMTRUST", ACB_DOMTRUST, r);
  34         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_WSTRUST", ACB_WSTRUST, r);
  35         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_SVRTRUST", ACB_SVRTRUST, r);
  36         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_PWNOEXP", ACB_PWNOEXP, r);
  37         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_AUTOLOCK", ACB_AUTOLOCK, r);
  38         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_ENC_TXT_PWD_ALLOWED", ACB_ENC_TXT_PWD_ALLOWED, r);
  39         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_SMARTCARD_REQUIRED", ACB_SMARTCARD_REQUIRED, r);
  40         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_TRUSTED_FOR_DELEGATION", ACB_TRUSTED_FOR_DELEGATION, r);
  41         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_NOT_DELEGATED", ACB_NOT_DELEGATED, r);
  42         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_USE_DES_KEY_ONLY", ACB_USE_DES_KEY_ONLY, r);
  43         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_DONT_REQUIRE_PREAUTH", ACB_DONT_REQUIRE_PREAUTH, r);
  44         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_PW_EXPIRED", ACB_PW_EXPIRED, r);
  45         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_TRUSTED_TO_AUTHENTICATE_FOR_DELEGATION", ACB_TRUSTED_TO_AUTHENTICATE_FOR_DELEGATION, r);
  46         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_NO_AUTH_DATA_REQD", ACB_NO_AUTH_DATA_REQD, r);
  47         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_PARTIAL_SECRETS_ACCOUNT", ACB_PARTIAL_SECRETS_ACCOUNT, r);
  48         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_USE_AES_KEYS", ACB_USE_AES_KEYS, r);
  49         ndr->depth--;
  50 }
  51
  52 static enum ndr_err_code ndr_push_samr_ConnectAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  53 {
  54         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  55         return NDR_ERR_SUCCESS;
  56 }
  57
  58 static enum ndr_err_code ndr_pull_samr_ConnectAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  59 {
  60         uint32_t v;
  61         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  62         *r = v;
  63         return NDR_ERR_SUCCESS;
  64 }
  65
  66 _PUBLIC_ void ndr_print_samr_ConnectAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
  67 {
  68         ndr_print_uint32(ndr, name, r);
  69         ndr->depth++;
  70         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_CONNECT_TO_SERVER", SAMR_ACCESS_CONNECT_TO_SERVER, r);
  71         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_SHUTDOWN_SERVER", SAMR_ACCESS_SHUTDOWN_SERVER, r);
  72         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_INITIALIZE_SERVER", SAMR_ACCESS_INITIALIZE_SERVER, r);
  73         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_CREATE_DOMAIN", SAMR_ACCESS_CREATE_DOMAIN, r);
  74         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_ENUM_DOMAINS", SAMR_ACCESS_ENUM_DOMAINS, r);
  75         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_LOOKUP_DOMAIN", SAMR_ACCESS_LOOKUP_DOMAIN, r);
  76         ndr->depth--;
  77 }
  78
  79 static enum ndr_err_code ndr_push_samr_UserAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  80 {
  81         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  82         return NDR_ERR_SUCCESS;
  83 }
  84
  85 static enum ndr_err_code ndr_pull_samr_UserAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  86 {
  87         uint32_t v;
  88         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  89         *r = v;
  90         return NDR_ERR_SUCCESS;
  91 }
  92
  93 _PUBLIC_ void ndr_print_samr_UserAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
  94 {
  95         ndr_print_uint32(ndr, name, r);
  96         ndr->depth++;
  97         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_NAME_ETC", SAMR_USER_ACCESS_GET_NAME_ETC, r);
  98         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_LOCALE", SAMR_USER_ACCESS_GET_LOCALE, r);
  99         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_SET_LOC_COM", SAMR_USER_ACCESS_SET_LOC_COM, r);
 100         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_LOGONINFO", SAMR_USER_ACCESS_GET_LOGONINFO, r);
 101         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_ATTRIBUTES", SAMR_USER_ACCESS_GET_ATTRIBUTES, r);
 102         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_SET_ATTRIBUTES", SAMR_USER_ACCESS_SET_ATTRIBUTES, r);
 103         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_CHANGE_PASSWORD", SAMR_USER_ACCESS_CHANGE_PASSWORD, r);
 104         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_SET_PASSWORD", SAMR_USER_ACCESS_SET_PASSWORD, r);
 105         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_GROUPS", SAMR_USER_ACCESS_GET_GROUPS, r);
 106         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_GROUP_MEMBERSHIP", SAMR_USER_ACCESS_GET_GROUP_MEMBERSHIP, r);
 107         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_CHANGE_GROUP_MEMBERSHIP", SAMR_USER_ACCESS_CHANGE_GROUP_MEMBERSHIP, r);
 108         ndr->depth--;
 109 }
 110
 111 static enum ndr_err_code ndr_push_samr_DomainAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 112 {
 113         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 114         return NDR_ERR_SUCCESS;
 115 }
 116
 117 static enum ndr_err_code ndr_pull_samr_DomainAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 118 {
 119         uint32_t v;
 120         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 121         *r = v;
 122         return NDR_ERR_SUCCESS;
 123 }
 124
 125 _PUBLIC_ void ndr_print_samr_DomainAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 126 {
 127         ndr_print_uint32(ndr, name, r);
 128         ndr->depth++;
 129         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1", SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1, r);
 130         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_SET_INFO_1", SAMR_DOMAIN_ACCESS_SET_INFO_1, r);
 131         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2", SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2, r);
 132         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_SET_INFO_2", SAMR_DOMAIN_ACCESS_SET_INFO_2, r);
 133         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_CREATE_USER", SAMR_DOMAIN_ACCESS_CREATE_USER, r);
 134         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_CREATE_GROUP", SAMR_DOMAIN_ACCESS_CREATE_GROUP, r);
 135         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_CREATE_ALIAS", SAMR_DOMAIN_ACCESS_CREATE_ALIAS, r);
 136         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS", SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS, r);
 137         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS", SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS, r);
 138         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT", SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT, r);
 139         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_SET_INFO_3", SAMR_DOMAIN_ACCESS_SET_INFO_3, r);
 140         ndr->depth--;
 141 }
 142
 143 static enum ndr_err_code ndr_push_samr_GroupAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 144 {
 145         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 146         return NDR_ERR_SUCCESS;
 147 }
 148
 149 static enum ndr_err_code ndr_pull_samr_GroupAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 150 {
 151         uint32_t v;
 152         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 153         *r = v;
 154         return NDR_ERR_SUCCESS;
 155 }
 156
 157 _PUBLIC_ void ndr_print_samr_GroupAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 158 {
 159         ndr_print_uint32(ndr, name, r);
 160         ndr->depth++;
 161         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_LOOKUP_INFO", SAMR_GROUP_ACCESS_LOOKUP_INFO, r);
 162         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_SET_INFO", SAMR_GROUP_ACCESS_SET_INFO, r);
 163         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_ADD_MEMBER", SAMR_GROUP_ACCESS_ADD_MEMBER, r);
 164         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_REMOVE_MEMBER", SAMR_GROUP_ACCESS_REMOVE_MEMBER, r);
 165         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_GET_MEMBERS", SAMR_GROUP_ACCESS_GET_MEMBERS, r);
 166         ndr->depth--;
 167 }
 168
 169 static enum ndr_err_code ndr_push_samr_AliasAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 170 {
 171         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 172         return NDR_ERR_SUCCESS;
 173 }
 174
 175 static enum ndr_err_code ndr_pull_samr_AliasAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 176 {
 177         uint32_t v;
 178         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 179         *r = v;
 180         return NDR_ERR_SUCCESS;
 181 }
 182
 183 _PUBLIC_ void ndr_print_samr_AliasAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 184 {
 185         ndr_print_uint32(ndr, name, r);
 186         ndr->depth++;
 187         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_ADD_MEMBER", SAMR_ALIAS_ACCESS_ADD_MEMBER, r);
 188         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_REMOVE_MEMBER", SAMR_ALIAS_ACCESS_REMOVE_MEMBER, r);
 189         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_GET_MEMBERS", SAMR_ALIAS_ACCESS_GET_MEMBERS, r);
 190         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_LOOKUP_INFO", SAMR_ALIAS_ACCESS_LOOKUP_INFO, r);
 191         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_SET_INFO", SAMR_ALIAS_ACCESS_SET_INFO, r);
 192         ndr->depth--;
 193 }
 194
 195 static enum ndr_err_code ndr_push_samr_SamEntry(struct ndr_push *ndr, int ndr_flags, const struct samr_SamEntry *r)
 196 {
 197         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 198         if (ndr_flags & NDR_SCALARS) {
 199                 NDR_CHECK(ndr_push_align(ndr, 5));
 200                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
 201                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
 202                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 203         }
 204         if (ndr_flags & NDR_BUFFERS) {
 205                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
 206         }
 207         return NDR_ERR_SUCCESS;
 208 }
 209
 210 static enum ndr_err_code ndr_pull_samr_SamEntry(struct ndr_pull *ndr, int ndr_flags, struct samr_SamEntry *r)
 211 {
 212         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 213         if (ndr_flags & NDR_SCALARS) {
 214                 NDR_CHECK(ndr_pull_align(ndr, 5));
 215                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
 216                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
 217                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 218         }
 219         if (ndr_flags & NDR_BUFFERS) {
 220                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
 221         }
 222         return NDR_ERR_SUCCESS;
 223 }
 224
 225 _PUBLIC_ void ndr_print_samr_SamEntry(struct ndr_print *ndr, const char *name, const struct samr_SamEntry *r)
 226 {
 227         ndr_print_struct(ndr, name, "samr_SamEntry");
 228         if (r == NULL) { ndr_print_null(ndr); return; }
 229         ndr->depth++;
 230         ndr_print_uint32(ndr, "idx", r->idx);
 231         ndr_print_lsa_String(ndr, "name", &r->name);
 232         ndr->depth--;
 233 }
 234
 235 static enum ndr_err_code ndr_push_samr_SamArray(struct ndr_push *ndr, int ndr_flags, const struct samr_SamArray *r)
 236 {
 237         uint32_t cntr_entries_1;
 238         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 239         if (ndr_flags & NDR_SCALARS) {
 240                 NDR_CHECK(ndr_push_align(ndr, 5));
 241                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 242                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
 243                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 244         }
 245         if (ndr_flags & NDR_BUFFERS) {
 246                 if (r->entries) {
 247                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
 248                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 249                                 NDR_CHECK(ndr_push_samr_SamEntry(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 250                         }
 251                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 252                                 NDR_CHECK(ndr_push_samr_SamEntry(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 253                         }
 254                 }
 255         }
 256         return NDR_ERR_SUCCESS;
 257 }
 258
 259 static enum ndr_err_code ndr_pull_samr_SamArray(struct ndr_pull *ndr, int ndr_flags, struct samr_SamArray *r)
 260 {
 261         uint32_t _ptr_entries;
 262         uint32_t size_entries_1 = 0;
 263         uint32_t cntr_entries_1;
 264         TALLOC_CTX *_mem_save_entries_0;
 265         TALLOC_CTX *_mem_save_entries_1;
 266         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 267         if (ndr_flags & NDR_SCALARS) {
 268                 NDR_CHECK(ndr_pull_align(ndr, 5));
 269                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 270                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
 271                 if (_ptr_entries) {
 272                         NDR_PULL_ALLOC(ndr, r->entries);
 273                 } else {
 274                         r->entries = NULL;
 275                 }
 276                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 277         }
 278         if (ndr_flags & NDR_BUFFERS) {
 279                 if (r->entries) {
 280                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
 281                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 282                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
 283                         size_entries_1 = ndr_get_array_size(ndr, &r->entries);
 284                         NDR_PULL_ALLOC_N(ndr, r->entries, size_entries_1);
 285                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
 286                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 287                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
 288                                 NDR_CHECK(ndr_pull_samr_SamEntry(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 289                         }
 290                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
 291                                 NDR_CHECK(ndr_pull_samr_SamEntry(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 292                         }
 293                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
 294                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
 295                 }
 296                 if (r->entries) {
 297                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
 298                 }
 299         }
 300         return NDR_ERR_SUCCESS;
 301 }
 302
 303 _PUBLIC_ void ndr_print_samr_SamArray(struct ndr_print *ndr, const char *name, const struct samr_SamArray *r)
 304 {
 305         uint32_t cntr_entries_1;
 306         ndr_print_struct(ndr, name, "samr_SamArray");
 307         if (r == NULL) { ndr_print_null(ndr); return; }
 308         ndr->depth++;
 309         ndr_print_uint32(ndr, "count", r->count);
 310         ndr_print_ptr(ndr, "entries", r->entries);
 311         ndr->depth++;
 312         if (r->entries) {
 313                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
 314                 ndr->depth++;
 315                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
 316                         ndr_print_samr_SamEntry(ndr, "entries", &r->entries[cntr_entries_1]);
 317                 }
 318                 ndr->depth--;
 319         }
 320         ndr->depth--;
 321         ndr->depth--;
 322 }
 323
 324 static enum ndr_err_code ndr_push_samr_DomainInfoClass(struct ndr_push *ndr, int ndr_flags, enum samr_DomainInfoClass r)
 325 {
 326         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 327         return NDR_ERR_SUCCESS;
 328 }
 329
 330 static enum ndr_err_code ndr_pull_samr_DomainInfoClass(struct ndr_pull *ndr, int ndr_flags, enum samr_DomainInfoClass *r)
 331 {
 332         uint16_t v;
 333         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 334         *r = v;
 335         return NDR_ERR_SUCCESS;
 336 }
 337
 338 _PUBLIC_ void ndr_print_samr_DomainInfoClass(struct ndr_print *ndr, const char *name, enum samr_DomainInfoClass r)
 339 {
 340         const char *val = NULL;
 341
 342         switch (r) {
 343                 case DomainPasswordInformation: val = "DomainPasswordInformation"; break;
 344                 case DomainGeneralInformation: val = "DomainGeneralInformation"; break;
 345                 case DomainLogoffInformation: val = "DomainLogoffInformation"; break;
 346                 case DomainOemInformation: val = "DomainOemInformation"; break;
 347                 case DomainNameInformation: val = "DomainNameInformation"; break;
 348                 case DomainReplicationInformation: val = "DomainReplicationInformation"; break;
 349                 case DomainServerRoleInformation: val = "DomainServerRoleInformation"; break;
 350                 case DomainModifiedInformation: val = "DomainModifiedInformation"; break;
 351                 case DomainStateInformation: val = "DomainStateInformation"; break;
 352                 case DomainUasInformation: val = "DomainUasInformation"; break;
 353                 case DomainGeneralInformation2: val = "DomainGeneralInformation2"; break;
 354                 case DomainLockoutInformation: val = "DomainLockoutInformation"; break;
 355                 case DomainModifiedInformation2: val = "DomainModifiedInformation2"; break;
 356         }
 357         ndr_print_enum(ndr, name, "ENUM", val, r);
 358 }
 359
 360 static enum ndr_err_code ndr_push_samr_Role(struct ndr_push *ndr, int ndr_flags, enum samr_Role r)
 361 {
 362         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 363         return NDR_ERR_SUCCESS;
 364 }
 365
 366 static enum ndr_err_code ndr_pull_samr_Role(struct ndr_pull *ndr, int ndr_flags, enum samr_Role *r)
 367 {
 368         uint32_t v;
 369         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 370         *r = v;
 371         return NDR_ERR_SUCCESS;
 372 }
 373
 374 _PUBLIC_ void ndr_print_samr_Role(struct ndr_print *ndr, const char *name, enum samr_Role r)
 375 {
 376         const char *val = NULL;
 377
 378         switch (r) {
 379                 case SAMR_ROLE_STANDALONE: val = "SAMR_ROLE_STANDALONE"; break;
 380                 case SAMR_ROLE_DOMAIN_MEMBER: val = "SAMR_ROLE_DOMAIN_MEMBER"; break;
 381                 case SAMR_ROLE_DOMAIN_BDC: val = "SAMR_ROLE_DOMAIN_BDC"; break;
 382                 case SAMR_ROLE_DOMAIN_PDC: val = "SAMR_ROLE_DOMAIN_PDC"; break;
 383         }
 384         ndr_print_enum(ndr, name, "ENUM", val, r);
 385 }
 386
 387 _PUBLIC_ enum ndr_err_code ndr_push_samr_PasswordProperties(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 388 {
 389         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 390         return NDR_ERR_SUCCESS;
 391 }
 392
 393 _PUBLIC_ enum ndr_err_code ndr_pull_samr_PasswordProperties(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 394 {
 395         uint32_t v;
 396         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 397         *r = v;
 398         return NDR_ERR_SUCCESS;
 399 }
 400
 401 _PUBLIC_ void ndr_print_samr_PasswordProperties(struct ndr_print *ndr, const char *name, uint32_t r)
 402 {
 403         ndr_print_uint32(ndr, name, r);
 404         ndr->depth++;
 405         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_COMPLEX", DOMAIN_PASSWORD_COMPLEX, r);
 406         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_NO_ANON_CHANGE", DOMAIN_PASSWORD_NO_ANON_CHANGE, r);
 407         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_NO_CLEAR_CHANGE", DOMAIN_PASSWORD_NO_CLEAR_CHANGE, r);
 408         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_LOCKOUT_ADMINS", DOMAIN_PASSWORD_LOCKOUT_ADMINS, r);
 409         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_STORE_CLEARTEXT", DOMAIN_PASSWORD_STORE_CLEARTEXT, r);
 410         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_REFUSE_PASSWORD_CHANGE", DOMAIN_REFUSE_PASSWORD_CHANGE, r);
 411         ndr->depth--;
 412 }
 413
 414 static enum ndr_err_code ndr_push_samr_DomainServerState(struct ndr_push *ndr, int ndr_flags, enum samr_DomainServerState r)
 415 {
 416         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 417         return NDR_ERR_SUCCESS;
 418 }
 419
 420 static enum ndr_err_code ndr_pull_samr_DomainServerState(struct ndr_pull *ndr, int ndr_flags, enum samr_DomainServerState *r)
 421 {
 422         uint32_t v;
 423         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 424         *r = v;
 425         return NDR_ERR_SUCCESS;
 426 }
 427
 428 _PUBLIC_ void ndr_print_samr_DomainServerState(struct ndr_print *ndr, const char *name, enum samr_DomainServerState r)
 429 {
 430         const char *val = NULL;
 431
 432         switch (r) {
 433                 case DOMAIN_SERVER_ENABLED: val = "DOMAIN_SERVER_ENABLED"; break;
 434                 case DOMAIN_SERVER_DISABLED: val = "DOMAIN_SERVER_DISABLED"; break;
 435         }
 436         ndr_print_enum(ndr, name, "ENUM", val, r);
 437 }
 438
 439 static enum ndr_err_code ndr_push_samr_DomInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo1 *r)
 440 {
 441         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 442         if (ndr_flags & NDR_SCALARS) {
 443                 NDR_CHECK(ndr_push_align(ndr, 4));
 444                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->min_password_length));
 445                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->password_history_length));
 446                 NDR_CHECK(ndr_push_samr_PasswordProperties(ndr, NDR_SCALARS, r->password_properties));
 447                 NDR_CHECK(ndr_push_dlong(ndr, NDR_SCALARS, r->max_password_age));
 448                 NDR_CHECK(ndr_push_dlong(ndr, NDR_SCALARS, r->min_password_age));
 449                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 450         }
 451         if (ndr_flags & NDR_BUFFERS) {
 452         }
 453         return NDR_ERR_SUCCESS;
 454 }
 455
 456 static enum ndr_err_code ndr_pull_samr_DomInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo1 *r)
 457 {
 458         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 459         if (ndr_flags & NDR_SCALARS) {
 460                 NDR_CHECK(ndr_pull_align(ndr, 4));
 461                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->min_password_length));
 462                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->password_history_length));
 463                 NDR_CHECK(ndr_pull_samr_PasswordProperties(ndr, NDR_SCALARS, &r->password_properties));
 464                 NDR_CHECK(ndr_pull_dlong(ndr, NDR_SCALARS, &r->max_password_age));
 465                 NDR_CHECK(ndr_pull_dlong(ndr, NDR_SCALARS, &r->min_password_age));
 466                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 467         }
 468         if (ndr_flags & NDR_BUFFERS) {
 469         }
 470         return NDR_ERR_SUCCESS;
 471 }
 472
 473 _PUBLIC_ void ndr_print_samr_DomInfo1(struct ndr_print *ndr, const char *name, const struct samr_DomInfo1 *r)
 474 {
 475         ndr_print_struct(ndr, name, "samr_DomInfo1");
 476         if (r == NULL) { ndr_print_null(ndr); return; }
 477         ndr->depth++;
 478         ndr_print_uint16(ndr, "min_password_length", r->min_password_length);
 479         ndr_print_uint16(ndr, "password_history_length", r->password_history_length);
 480         ndr_print_samr_PasswordProperties(ndr, "password_properties", r->password_properties);
 481         ndr_print_dlong(ndr, "max_password_age", r->max_password_age);
 482         ndr_print_dlong(ndr, "min_password_age", r->min_password_age);
 483         ndr->depth--;
 484 }
 485
 486 static enum ndr_err_code ndr_push_samr_DomGeneralInformation(struct ndr_push *ndr, int ndr_flags, const struct samr_DomGeneralInformation *r)
 487 {
 488         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 489         if (ndr_flags & NDR_SCALARS) {
 490                 NDR_CHECK(ndr_push_align(ndr, 5));
 491                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_logoff_time));
 492                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 493                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 494                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->primary));
 495                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->sequence_num));
 496                 NDR_CHECK(ndr_push_samr_DomainServerState(ndr, NDR_SCALARS, r->domain_server_state));
 497                 NDR_CHECK(ndr_push_samr_Role(ndr, NDR_SCALARS, r->role));
 498                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
 499                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_users));
 500                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_groups));
 501                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_aliases));
 502                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 503         }
 504         if (ndr_flags & NDR_BUFFERS) {
 505                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 506                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 507                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 508         }
 509         return NDR_ERR_SUCCESS;
 510 }
 511
 512 static enum ndr_err_code ndr_pull_samr_DomGeneralInformation(struct ndr_pull *ndr, int ndr_flags, struct samr_DomGeneralInformation *r)
 513 {
 514         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 515         if (ndr_flags & NDR_SCALARS) {
 516                 NDR_CHECK(ndr_pull_align(ndr, 5));
 517                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_logoff_time));
 518                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 519                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 520                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->primary));
 521                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->sequence_num));
 522                 NDR_CHECK(ndr_pull_samr_DomainServerState(ndr, NDR_SCALARS, &r->domain_server_state));
 523                 NDR_CHECK(ndr_pull_samr_Role(ndr, NDR_SCALARS, &r->role));
 524                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
 525                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_users));
 526                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_groups));
 527                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_aliases));
 528                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 529         }
 530         if (ndr_flags & NDR_BUFFERS) {
 531                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 532                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 533                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 534         }
 535         return NDR_ERR_SUCCESS;
 536 }
 537
 538 _PUBLIC_ void ndr_print_samr_DomGeneralInformation(struct ndr_print *ndr, const char *name, const struct samr_DomGeneralInformation *r)
 539 {
 540         ndr_print_struct(ndr, name, "samr_DomGeneralInformation");
 541         if (r == NULL) { ndr_print_null(ndr); return; }
 542         ndr->depth++;
 543         ndr_print_NTTIME(ndr, "force_logoff_time", r->force_logoff_time);
 544         ndr_print_lsa_String(ndr, "oem_information", &r->oem_information);
 545         ndr_print_lsa_String(ndr, "domain_name", &r->domain_name);
 546         ndr_print_lsa_String(ndr, "primary", &r->primary);
 547         ndr_print_udlong(ndr, "sequence_num", r->sequence_num);
 548         ndr_print_samr_DomainServerState(ndr, "domain_server_state", r->domain_server_state);
 549         ndr_print_samr_Role(ndr, "role", r->role);
 550         ndr_print_uint32(ndr, "unknown3", r->unknown3);
 551         ndr_print_uint32(ndr, "num_users", r->num_users);
 552         ndr_print_uint32(ndr, "num_groups", r->num_groups);
 553         ndr_print_uint32(ndr, "num_aliases", r->num_aliases);
 554         ndr->depth--;
 555 }
 556
 557 static enum ndr_err_code ndr_push_samr_DomInfo3(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo3 *r)
 558 {
 559         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 560         if (ndr_flags & NDR_SCALARS) {
 561                 NDR_CHECK(ndr_push_align(ndr, 4));
 562                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_logoff_time));
 563                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 564         }
 565         if (ndr_flags & NDR_BUFFERS) {
 566         }
 567         return NDR_ERR_SUCCESS;
 568 }
 569
 570 static enum ndr_err_code ndr_pull_samr_DomInfo3(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo3 *r)
 571 {
 572         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 573         if (ndr_flags & NDR_SCALARS) {
 574                 NDR_CHECK(ndr_pull_align(ndr, 4));
 575                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_logoff_time));
 576                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 577         }
 578         if (ndr_flags & NDR_BUFFERS) {
 579         }
 580         return NDR_ERR_SUCCESS;
 581 }
 582
 583 _PUBLIC_ void ndr_print_samr_DomInfo3(struct ndr_print *ndr, const char *name, const struct samr_DomInfo3 *r)
 584 {
 585         ndr_print_struct(ndr, name, "samr_DomInfo3");
 586         if (r == NULL) { ndr_print_null(ndr); return; }
 587         ndr->depth++;
 588         ndr_print_NTTIME(ndr, "force_logoff_time", r->force_logoff_time);
 589         ndr->depth--;
 590 }
 591
 592 static enum ndr_err_code ndr_push_samr_DomOEMInformation(struct ndr_push *ndr, int ndr_flags, const struct samr_DomOEMInformation *r)
 593 {
 594         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 595         if (ndr_flags & NDR_SCALARS) {
 596                 NDR_CHECK(ndr_push_align(ndr, 5));
 597                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 598                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 599         }
 600         if (ndr_flags & NDR_BUFFERS) {
 601                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 602         }
 603         return NDR_ERR_SUCCESS;
 604 }
 605
 606 static enum ndr_err_code ndr_pull_samr_DomOEMInformation(struct ndr_pull *ndr, int ndr_flags, struct samr_DomOEMInformation *r)
 607 {
 608         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 609         if (ndr_flags & NDR_SCALARS) {
 610                 NDR_CHECK(ndr_pull_align(ndr, 5));
 611                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 612                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 613         }
 614         if (ndr_flags & NDR_BUFFERS) {
 615                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 616         }
 617         return NDR_ERR_SUCCESS;
 618 }
 619
 620 _PUBLIC_ void ndr_print_samr_DomOEMInformation(struct ndr_print *ndr, const char *name, const struct samr_DomOEMInformation *r)
 621 {
 622         ndr_print_struct(ndr, name, "samr_DomOEMInformation");
 623         if (r == NULL) { ndr_print_null(ndr); return; }
 624         ndr->depth++;
 625         ndr_print_lsa_String(ndr, "oem_information", &r->oem_information);
 626         ndr->depth--;
 627 }
 628
 629 static enum ndr_err_code ndr_push_samr_DomInfo5(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo5 *r)
 630 {
 631         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 632         if (ndr_flags & NDR_SCALARS) {
 633                 NDR_CHECK(ndr_push_align(ndr, 5));
 634                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 635                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 636         }
 637         if (ndr_flags & NDR_BUFFERS) {
 638                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 639         }
 640         return NDR_ERR_SUCCESS;
 641 }
 642
 643 static enum ndr_err_code ndr_pull_samr_DomInfo5(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo5 *r)
 644 {
 645         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 646         if (ndr_flags & NDR_SCALARS) {
 647                 NDR_CHECK(ndr_pull_align(ndr, 5));
 648                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 649                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 650         }
 651         if (ndr_flags & NDR_BUFFERS) {
 652                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 653         }
 654         return NDR_ERR_SUCCESS;
 655 }
 656
 657 _PUBLIC_ void ndr_print_samr_DomInfo5(struct ndr_print *ndr, const char *name, const struct samr_DomInfo5 *r)
 658 {
 659         ndr_print_struct(ndr, name, "samr_DomInfo5");
 660         if (r == NULL) { ndr_print_null(ndr); return; }
 661         ndr->depth++;
 662         ndr_print_lsa_String(ndr, "domain_name", &r->domain_name);
 663         ndr->depth--;
 664 }
 665
 666 static enum ndr_err_code ndr_push_samr_DomInfo6(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo6 *r)
 667 {
 668         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 669         if (ndr_flags & NDR_SCALARS) {
 670                 NDR_CHECK(ndr_push_align(ndr, 5));
 671                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->primary));
 672                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 673         }
 674         if (ndr_flags & NDR_BUFFERS) {
 675                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 676         }
 677         return NDR_ERR_SUCCESS;
 678 }
 679
 680 static enum ndr_err_code ndr_pull_samr_DomInfo6(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo6 *r)
 681 {
 682         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 683         if (ndr_flags & NDR_SCALARS) {
 684                 NDR_CHECK(ndr_pull_align(ndr, 5));
 685                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->primary));
 686                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 687         }
 688         if (ndr_flags & NDR_BUFFERS) {
 689                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 690         }
 691         return NDR_ERR_SUCCESS;
 692 }
 693
 694 _PUBLIC_ void ndr_print_samr_DomInfo6(struct ndr_print *ndr, const char *name, const struct samr_DomInfo6 *r)
 695 {
 696         ndr_print_struct(ndr, name, "samr_DomInfo6");
 697         if (r == NULL) { ndr_print_null(ndr); return; }
 698         ndr->depth++;
 699         ndr_print_lsa_String(ndr, "primary", &r->primary);
 700         ndr->depth--;
 701 }
 702
 703 static enum ndr_err_code ndr_push_samr_DomInfo7(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo7 *r)
 704 {
 705         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 706         if (ndr_flags & NDR_SCALARS) {
 707                 NDR_CHECK(ndr_push_align(ndr, 4));
 708                 NDR_CHECK(ndr_push_samr_Role(ndr, NDR_SCALARS, r->role));
 709                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 710         }
 711         if (ndr_flags & NDR_BUFFERS) {
 712         }
 713         return NDR_ERR_SUCCESS;
 714 }
 715
 716 static enum ndr_err_code ndr_pull_samr_DomInfo7(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo7 *r)
 717 {
 718         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 719         if (ndr_flags & NDR_SCALARS) {
 720                 NDR_CHECK(ndr_pull_align(ndr, 4));
 721                 NDR_CHECK(ndr_pull_samr_Role(ndr, NDR_SCALARS, &r->role));
 722                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 723         }
 724         if (ndr_flags & NDR_BUFFERS) {
 725         }
 726         return NDR_ERR_SUCCESS;
 727 }
 728
 729 _PUBLIC_ void ndr_print_samr_DomInfo7(struct ndr_print *ndr, const char *name, const struct samr_DomInfo7 *r)
 730 {
 731         ndr_print_struct(ndr, name, "samr_DomInfo7");
 732         if (r == NULL) { ndr_print_null(ndr); return; }
 733         ndr->depth++;
 734         ndr_print_samr_Role(ndr, "role", r->role);
 735         ndr->depth--;
 736 }
 737
 738 static enum ndr_err_code ndr_push_samr_DomInfo8(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo8 *r)
 739 {
 740         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 741         if (ndr_flags & NDR_SCALARS) {
 742                 NDR_CHECK(ndr_push_align(ndr, 8));
 743                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->sequence_num));
 744                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->domain_create_time));
 745                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 746         }
 747         if (ndr_flags & NDR_BUFFERS) {
 748         }
 749         return NDR_ERR_SUCCESS;
 750 }
 751
 752 static enum ndr_err_code ndr_pull_samr_DomInfo8(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo8 *r)
 753 {
 754         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 755         if (ndr_flags & NDR_SCALARS) {
 756                 NDR_CHECK(ndr_pull_align(ndr, 8));
 757                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->sequence_num));
 758                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->domain_create_time));
 759                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 760         }
 761         if (ndr_flags & NDR_BUFFERS) {
 762         }
 763         return NDR_ERR_SUCCESS;
 764 }
 765
 766 _PUBLIC_ void ndr_print_samr_DomInfo8(struct ndr_print *ndr, const char *name, const struct samr_DomInfo8 *r)
 767 {
 768         ndr_print_struct(ndr, name, "samr_DomInfo8");
 769         if (r == NULL) { ndr_print_null(ndr); return; }
 770         ndr->depth++;
 771         ndr_print_hyper(ndr, "sequence_num", r->sequence_num);
 772         ndr_print_NTTIME(ndr, "domain_create_time", r->domain_create_time);
 773         ndr->depth--;
 774 }
 775
 776 static enum ndr_err_code ndr_push_samr_DomInfo9(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo9 *r)
 777 {
 778         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 779         if (ndr_flags & NDR_SCALARS) {
 780                 NDR_CHECK(ndr_push_align(ndr, 4));
 781                 NDR_CHECK(ndr_push_samr_DomainServerState(ndr, NDR_SCALARS, r->domain_server_state));
 782                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 783         }
 784         if (ndr_flags & NDR_BUFFERS) {
 785         }
 786         return NDR_ERR_SUCCESS;
 787 }
 788
 789 static enum ndr_err_code ndr_pull_samr_DomInfo9(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo9 *r)
 790 {
 791         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 792         if (ndr_flags & NDR_SCALARS) {
 793                 NDR_CHECK(ndr_pull_align(ndr, 4));
 794                 NDR_CHECK(ndr_pull_samr_DomainServerState(ndr, NDR_SCALARS, &r->domain_server_state));
 795                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 796         }
 797         if (ndr_flags & NDR_BUFFERS) {
 798         }
 799         return NDR_ERR_SUCCESS;
 800 }
 801
 802 _PUBLIC_ void ndr_print_samr_DomInfo9(struct ndr_print *ndr, const char *name, const struct samr_DomInfo9 *r)
 803 {
 804         ndr_print_struct(ndr, name, "samr_DomInfo9");
 805         if (r == NULL) { ndr_print_null(ndr); return; }
 806         ndr->depth++;
 807         ndr_print_samr_DomainServerState(ndr, "domain_server_state", r->domain_server_state);
 808         ndr->depth--;
 809 }
 810
 811 static enum ndr_err_code ndr_push_samr_DomGeneralInformation2(struct ndr_push *ndr, int ndr_flags, const struct samr_DomGeneralInformation2 *r)
 812 {
 813         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 814         if (ndr_flags & NDR_SCALARS) {
 815                 NDR_CHECK(ndr_push_align(ndr, 8));
 816                 NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 817                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_duration));
 818                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_window));
 819                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lockout_threshold));
 820                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 821         }
 822         if (ndr_flags & NDR_BUFFERS) {
 823                 NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
 824         }
 825         return NDR_ERR_SUCCESS;
 826 }
 827
 828 static enum ndr_err_code ndr_pull_samr_DomGeneralInformation2(struct ndr_pull *ndr, int ndr_flags, struct samr_DomGeneralInformation2 *r)
 829 {
 830         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 831         if (ndr_flags & NDR_SCALARS) {
 832                 NDR_CHECK(ndr_pull_align(ndr, 8));
 833                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 834                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_duration));
 835                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_window));
 836                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lockout_threshold));
 837                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 838         }
 839         if (ndr_flags & NDR_BUFFERS) {
 840                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
 841         }
 842         return NDR_ERR_SUCCESS;
 843 }
 844
 845 _PUBLIC_ void ndr_print_samr_DomGeneralInformation2(struct ndr_print *ndr, const char *name, const struct samr_DomGeneralInformation2 *r)
 846 {
 847         ndr_print_struct(ndr, name, "samr_DomGeneralInformation2");
 848         if (r == NULL) { ndr_print_null(ndr); return; }
 849         ndr->depth++;
 850         ndr_print_samr_DomGeneralInformation(ndr, "general", &r->general);
 851         ndr_print_hyper(ndr, "lockout_duration", r->lockout_duration);
 852         ndr_print_hyper(ndr, "lockout_window", r->lockout_window);
 853         ndr_print_uint16(ndr, "lockout_threshold", r->lockout_threshold);
 854         ndr->depth--;
 855 }
 856
 857 static enum ndr_err_code ndr_push_samr_DomInfo12(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo12 *r)
 858 {
 859         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 860         if (ndr_flags & NDR_SCALARS) {
 861                 NDR_CHECK(ndr_push_align(ndr, 8));
 862                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_duration));
 863                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_window));
 864                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lockout_threshold));
 865                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 866         }
 867         if (ndr_flags & NDR_BUFFERS) {
 868         }
 869         return NDR_ERR_SUCCESS;
 870 }
 871
 872 static enum ndr_err_code ndr_pull_samr_DomInfo12(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo12 *r)
 873 {
 874         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 875         if (ndr_flags & NDR_SCALARS) {
 876                 NDR_CHECK(ndr_pull_align(ndr, 8));
 877                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_duration));
 878                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_window));
 879                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lockout_threshold));
 880                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 881         }
 882         if (ndr_flags & NDR_BUFFERS) {
 883         }
 884         return NDR_ERR_SUCCESS;
 885 }
 886
 887 _PUBLIC_ void ndr_print_samr_DomInfo12(struct ndr_print *ndr, const char *name, const struct samr_DomInfo12 *r)
 888 {
 889         ndr_print_struct(ndr, name, "samr_DomInfo12");
 890         if (r == NULL) { ndr_print_null(ndr); return; }
 891         ndr->depth++;
 892         ndr_print_hyper(ndr, "lockout_duration", r->lockout_duration);
 893         ndr_print_hyper(ndr, "lockout_window", r->lockout_window);
 894         ndr_print_uint16(ndr, "lockout_threshold", r->lockout_threshold);
 895         ndr->depth--;
 896 }
 897
 898 static enum ndr_err_code ndr_push_samr_DomInfo13(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo13 *r)
 899 {
 900         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 901         if (ndr_flags & NDR_SCALARS) {
 902                 NDR_CHECK(ndr_push_align(ndr, 8));
 903                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->sequence_num));
 904                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->domain_create_time));
 905                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->modified_count_at_last_promotion));
 906                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 907         }
 908         if (ndr_flags & NDR_BUFFERS) {
 909         }
 910         return NDR_ERR_SUCCESS;
 911 }
 912
 913 static enum ndr_err_code ndr_pull_samr_DomInfo13(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo13 *r)
 914 {
 915         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 916         if (ndr_flags & NDR_SCALARS) {
 917                 NDR_CHECK(ndr_pull_align(ndr, 8));
 918                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->sequence_num));
 919                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->domain_create_time));
 920                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->modified_count_at_last_promotion));
 921                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 922         }
 923         if (ndr_flags & NDR_BUFFERS) {
 924         }
 925         return NDR_ERR_SUCCESS;
 926 }
 927
 928 _PUBLIC_ void ndr_print_samr_DomInfo13(struct ndr_print *ndr, const char *name, const struct samr_DomInfo13 *r)
 929 {
 930         ndr_print_struct(ndr, name, "samr_DomInfo13");
 931         if (r == NULL) { ndr_print_null(ndr); return; }
 932         ndr->depth++;
 933         ndr_print_hyper(ndr, "sequence_num", r->sequence_num);
 934         ndr_print_NTTIME(ndr, "domain_create_time", r->domain_create_time);
 935         ndr_print_hyper(ndr, "modified_count_at_last_promotion", r->modified_count_at_last_promotion);
 936         ndr->depth--;
 937 }
 938
 939 static enum ndr_err_code ndr_push_samr_DomainInfo(struct ndr_push *ndr, int ndr_flags, const union samr_DomainInfo *r)
 940 {
 941         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 942         if (ndr_flags & NDR_SCALARS) {
 943                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 944                 NDR_CHECK(ndr_push_union_align(ndr, 8));
 945                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
 946                 NDR_CHECK(ndr_push_union_align(ndr, 8));
 947                 switch (level) {
 948                         case 1: {
 949                                 NDR_CHECK(ndr_push_samr_DomInfo1(ndr, NDR_SCALARS, &r->info1));
 950                         break; }
 951
 952                         case 2: {
 953                                 NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 954                         break; }
 955
 956                         case 3: {
 957                                 NDR_CHECK(ndr_push_samr_DomInfo3(ndr, NDR_SCALARS, &r->info3));
 958                         break; }
 959
 960                         case 4: {
 961                                 NDR_CHECK(ndr_push_samr_DomOEMInformation(ndr, NDR_SCALARS, &r->oem));
 962                         break; }
 963
 964                         case 5: {
 965                                 NDR_CHECK(ndr_push_samr_DomInfo5(ndr, NDR_SCALARS, &r->info5));
 966                         break; }
 967
 968                         case 6: {
 969                                 NDR_CHECK(ndr_push_samr_DomInfo6(ndr, NDR_SCALARS, &r->info6));
 970                         break; }
 971
 972                         case 7: {
 973                                 NDR_CHECK(ndr_push_samr_DomInfo7(ndr, NDR_SCALARS, &r->info7));
 974                         break; }
 975
 976                         case 8: {
 977                                 NDR_CHECK(ndr_push_samr_DomInfo8(ndr, NDR_SCALARS, &r->info8));
 978                         break; }
 979
 980                         case 9: {
 981                                 NDR_CHECK(ndr_push_samr_DomInfo9(ndr, NDR_SCALARS, &r->info9));
 982                         break; }
 983
 984                         case 11: {
 985                                 NDR_CHECK(ndr_push_samr_DomGeneralInformation2(ndr, NDR_SCALARS, &r->general2));
 986                         break; }
 987
 988                         case 12: {
 989                                 NDR_CHECK(ndr_push_samr_DomInfo12(ndr, NDR_SCALARS, &r->info12));
 990                         break; }
 991
 992                         case 13: {
 993                                 NDR_CHECK(ndr_push_samr_DomInfo13(ndr, NDR_SCALARS, &r->info13));
 994                         break; }
 995
 996                         default:
 997                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 998                 }
 999         }
1000         if (ndr_flags & NDR_BUFFERS) {
1001                 uint32_t level = ndr_push_get_switch_value(ndr, r);
1002                 switch (level) {
1003                         case 1:
1004                         break;
1005
1006                         case 2:
1007                                 NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
1008                         break;
1009
1010                         case 3:
1011                         break;
1012
1013                         case 4:
1014                                 NDR_CHECK(ndr_push_samr_DomOEMInformation(ndr, NDR_BUFFERS, &r->oem));
1015                         break;
1016
1017                         case 5:
1018                                 NDR_CHECK(ndr_push_samr_DomInfo5(ndr, NDR_BUFFERS, &r->info5));
1019                         break;
1020
1021                         case 6:
1022                                 NDR_CHECK(ndr_push_samr_DomInfo6(ndr, NDR_BUFFERS, &r->info6));
1023                         break;
1024
1025                         case 7:
1026                         break;
1027
1028                         case 8:
1029                         break;
1030
1031                         case 9:
1032                         break;
1033
1034                         case 11:
1035                                 NDR_CHECK(ndr_push_samr_DomGeneralInformation2(ndr, NDR_BUFFERS, &r->general2));
1036                         break;
1037
1038                         case 12:
1039                         break;
1040
1041                         case 13:
1042                         break;
1043
1044                         default:
1045                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1046                 }
1047         }
1048         return NDR_ERR_SUCCESS;
1049 }
1050
1051 static enum ndr_err_code ndr_pull_samr_DomainInfo(struct ndr_pull *ndr, int ndr_flags, union samr_DomainInfo *r)
1052 {
1053         uint32_t level;
1054         uint16_t _level;
1055         level = ndr_pull_get_switch_value(ndr, r);
1056         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1057         if (ndr_flags & NDR_SCALARS) {
1058                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
1059                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
1060                 if (_level != level) {
1061                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1062                 }
1063                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
1064                 switch (level) {
1065                         case 1: {
1066                                 NDR_CHECK(ndr_pull_samr_DomInfo1(ndr, NDR_SCALARS, &r->info1));
1067                         break; }
1068
1069                         case 2: {
1070                                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
1071                         break; }
1072
1073                         case 3: {
1074                                 NDR_CHECK(ndr_pull_samr_DomInfo3(ndr, NDR_SCALARS, &r->info3));
1075                         break; }
1076
1077                         case 4: {
1078                                 NDR_CHECK(ndr_pull_samr_DomOEMInformation(ndr, NDR_SCALARS, &r->oem));
1079                         break; }
1080
1081                         case 5: {
1082                                 NDR_CHECK(ndr_pull_samr_DomInfo5(ndr, NDR_SCALARS, &r->info5));
1083                         break; }
1084
1085                         case 6: {
1086                                 NDR_CHECK(ndr_pull_samr_DomInfo6(ndr, NDR_SCALARS, &r->info6));
1087                         break; }
1088
1089                         case 7: {
1090                                 NDR_CHECK(ndr_pull_samr_DomInfo7(ndr, NDR_SCALARS, &r->info7));
1091                         break; }
1092
1093                         case 8: {
1094                                 NDR_CHECK(ndr_pull_samr_DomInfo8(ndr, NDR_SCALARS, &r->info8));
1095                         break; }
1096
1097                         case 9: {
1098                                 NDR_CHECK(ndr_pull_samr_DomInfo9(ndr, NDR_SCALARS, &r->info9));
1099                         break; }
1100
1101                         case 11: {
1102                                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation2(ndr, NDR_SCALARS, &r->general2));
1103                         break; }
1104
1105                         case 12: {
1106                                 NDR_CHECK(ndr_pull_samr_DomInfo12(ndr, NDR_SCALARS, &r->info12));
1107                         break; }
1108
1109                         case 13: {
1110                                 NDR_CHECK(ndr_pull_samr_DomInfo13(ndr, NDR_SCALARS, &r->info13));
1111                         break; }
1112
1113                         default:
1114                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1115                 }
1116         }
1117         if (ndr_flags & NDR_BUFFERS) {
1118                 switch (level) {
1119                         case 1:
1120                         break;
1121
1122                         case 2:
1123                                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
1124                         break;
1125
1126                         case 3:
1127                         break;
1128
1129                         case 4:
1130                                 NDR_CHECK(ndr_pull_samr_DomOEMInformation(ndr, NDR_BUFFERS, &r->oem));
1131                         break;
1132
1133                         case 5:
1134                                 NDR_CHECK(ndr_pull_samr_DomInfo5(ndr, NDR_BUFFERS, &r->info5));
1135                         break;
1136
1137                         case 6:
1138                                 NDR_CHECK(ndr_pull_samr_DomInfo6(ndr, NDR_BUFFERS, &r->info6));
1139                         break;
1140
1141                         case 7:
1142                         break;
1143
1144                         case 8:
1145                         break;
1146
1147                         case 9:
1148                         break;
1149
1150                         case 11:
1151                                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation2(ndr, NDR_BUFFERS, &r->general2));
1152                         break;
1153
1154                         case 12:
1155                         break;
1156
1157                         case 13:
1158                         break;
1159
1160                         default:
1161                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1162                 }
1163         }
1164         return NDR_ERR_SUCCESS;
1165 }
1166
1167 _PUBLIC_ void ndr_print_samr_DomainInfo(struct ndr_print *ndr, const char *name, const union samr_DomainInfo *r)
1168 {
1169         uint32_t level;
1170         level = ndr_print_get_switch_value(ndr, r);
1171         ndr_print_union(ndr, name, level, "samr_DomainInfo");
1172         switch (level) {
1173                 case 1:
1174                         ndr_print_samr_DomInfo1(ndr, "info1", &r->info1);
1175                 break;
1176
1177                 case 2:
1178                         ndr_print_samr_DomGeneralInformation(ndr, "general", &r->general);
1179                 break;
1180
1181                 case 3:
1182                         ndr_print_samr_DomInfo3(ndr, "info3", &r->info3);
1183                 break;
1184
1185                 case 4:
1186                         ndr_print_samr_DomOEMInformation(ndr, "oem", &r->oem);
1187                 break;
1188
1189                 case 5:
1190                         ndr_print_samr_DomInfo5(ndr, "info5", &r->info5);
1191                 break;
1192
1193                 case 6:
1194                         ndr_print_samr_DomInfo6(ndr, "info6", &r->info6);
1195                 break;
1196
1197                 case 7:
1198                         ndr_print_samr_DomInfo7(ndr, "info7", &r->info7);
1199                 break;
1200
1201                 case 8:
1202                         ndr_print_samr_DomInfo8(ndr, "info8", &r->info8);
1203                 break;
1204
1205                 case 9:
1206                         ndr_print_samr_DomInfo9(ndr, "info9", &r->info9);
1207                 break;
1208
1209                 case 11:
1210                         ndr_print_samr_DomGeneralInformation2(ndr, "general2", &r->general2);
1211                 break;
1212
1213                 case 12:
1214                         ndr_print_samr_DomInfo12(ndr, "info12", &r->info12);
1215                 break;
1216
1217                 case 13:
1218                         ndr_print_samr_DomInfo13(ndr, "info13", &r->info13);
1219                 break;
1220
1221                 default:
1222                         ndr_print_bad_level(ndr, name, level);
1223         }
1224 }
1225
1226 static enum ndr_err_code ndr_push_samr_Ids(struct ndr_push *ndr, int ndr_flags, const struct samr_Ids *r)
1227 {
1228         uint32_t cntr_ids_1;
1229         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1230         if (ndr_flags & NDR_SCALARS) {
1231                 NDR_CHECK(ndr_push_align(ndr, 5));
1232                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1233                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ids));
1234                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1235         }
1236         if (ndr_flags & NDR_BUFFERS) {
1237                 if (r->ids) {
1238                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
1239                         for (cntr_ids_1 = 0; cntr_ids_1 < r->count; cntr_ids_1++) {
1240                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ids[cntr_ids_1]));
1241                         }
1242                 }
1243         }
1244         return NDR_ERR_SUCCESS;
1245 }
1246
1247 static enum ndr_err_code ndr_pull_samr_Ids(struct ndr_pull *ndr, int ndr_flags, struct samr_Ids *r)
1248 {
1249         uint32_t _ptr_ids;
1250         uint32_t size_ids_1 = 0;
1251         uint32_t cntr_ids_1;
1252         TALLOC_CTX *_mem_save_ids_0;
1253         TALLOC_CTX *_mem_save_ids_1;
1254         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1255         if (ndr_flags & NDR_SCALARS) {
1256                 NDR_CHECK(ndr_pull_align(ndr, 5));
1257                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1258                 if (r->count > 1024) {
1259                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1260                 }
1261                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ids));
1262                 if (_ptr_ids) {
1263                         NDR_PULL_ALLOC(ndr, r->ids);
1264                 } else {
1265                         r->ids = NULL;
1266                 }
1267                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1268         }
1269         if (ndr_flags & NDR_BUFFERS) {
1270                 if (r->ids) {
1271                         _mem_save_ids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1272                         NDR_PULL_SET_MEM_CTX(ndr, r->ids, 0);
1273                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ids));
1274                         size_ids_1 = ndr_get_array_size(ndr, &r->ids);
1275                         NDR_PULL_ALLOC_N(ndr, r->ids, size_ids_1);
1276                         _mem_save_ids_1 = NDR_PULL_GET_MEM_CTX(ndr);
1277                         NDR_PULL_SET_MEM_CTX(ndr, r->ids, 0);
1278                         for (cntr_ids_1 = 0; cntr_ids_1 < size_ids_1; cntr_ids_1++) {
1279                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ids[cntr_ids_1]));
1280                         }
1281                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ids_1, 0);
1282                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ids_0, 0);
1283                 }
1284                 if (r->ids) {
1285                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->ids, r->count));
1286                 }
1287         }
1288         return NDR_ERR_SUCCESS;
1289 }
1290
1291 _PUBLIC_ void ndr_print_samr_Ids(struct ndr_print *ndr, const char *name, const struct samr_Ids *r)
1292 {
1293         uint32_t cntr_ids_1;
1294         ndr_print_struct(ndr, name, "samr_Ids");
1295         if (r == NULL) { ndr_print_null(ndr); return; }
1296         ndr->depth++;
1297         ndr_print_uint32(ndr, "count", r->count);
1298         ndr_print_ptr(ndr, "ids", r->ids);
1299         ndr->depth++;
1300         if (r->ids) {
1301                 ndr->print(ndr, "%s: ARRAY(%d)", "ids", (int)r->count);
1302                 ndr->depth++;
1303                 for (cntr_ids_1=0;cntr_ids_1<r->count;cntr_ids_1++) {
1304                         ndr_print_uint32(ndr, "ids", r->ids[cntr_ids_1]);
1305                 }
1306                 ndr->depth--;
1307         }
1308         ndr->depth--;
1309         ndr->depth--;
1310 }
1311
1312 _PUBLIC_ enum ndr_err_code ndr_push_samr_GroupAttrs(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1313 {
1314         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1315         return NDR_ERR_SUCCESS;
1316 }
1317
1318 _PUBLIC_ enum ndr_err_code ndr_pull_samr_GroupAttrs(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1319 {
1320         uint32_t v;
1321         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1322         *r = v;
1323         return NDR_ERR_SUCCESS;
1324 }
1325
1326 _PUBLIC_ void ndr_print_samr_GroupAttrs(struct ndr_print *ndr, const char *name, uint32_t r)
1327 {
1328         ndr_print_uint32(ndr, name, r);
1329         ndr->depth++;
1330         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_MANDATORY", SE_GROUP_MANDATORY, r);
1331         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_ENABLED_BY_DEFAULT", SE_GROUP_ENABLED_BY_DEFAULT, r);
1332         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_ENABLED", SE_GROUP_ENABLED, r);
1333         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_OWNER", SE_GROUP_OWNER, r);
1334         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_USE_FOR_DENY_ONLY", SE_GROUP_USE_FOR_DENY_ONLY, r);
1335         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_RESOURCE", SE_GROUP_RESOURCE, r);
1336         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_LOGON_ID", SE_GROUP_LOGON_ID, r);
1337         ndr->depth--;
1338 }
1339
1340 static enum ndr_err_code ndr_push_samr_GroupInfoAll(struct ndr_push *ndr, int ndr_flags, const struct samr_GroupInfoAll *r)
1341 {
1342         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1343         if (ndr_flags & NDR_SCALARS) {
1344                 NDR_CHECK(ndr_push_align(ndr, 5));
1345                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1346                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
1347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_members));
1348                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1349                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1350         }
1351         if (ndr_flags & NDR_BUFFERS) {
1352                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1353                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1354         }
1355         return NDR_ERR_SUCCESS;
1356 }
1357
1358 static enum ndr_err_code ndr_pull_samr_GroupInfoAll(struct ndr_pull *ndr, int ndr_flags, struct samr_GroupInfoAll *r)
1359 {
1360         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1361         if (ndr_flags & NDR_SCALARS) {
1362                 NDR_CHECK(ndr_pull_align(ndr, 5));
1363                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1364                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
1365                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_members));
1366                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1367                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1368         }
1369         if (ndr_flags & NDR_BUFFERS) {
1370                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1371                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1372         }
1373         return NDR_ERR_SUCCESS;
1374 }
1375
1376 _PUBLIC_ void ndr_print_samr_GroupInfoAll(struct ndr_print *ndr, const char *name, const struct samr_GroupInfoAll *r)
1377 {
1378         ndr_print_struct(ndr, name, "samr_GroupInfoAll");
1379         if (r == NULL) { ndr_print_null(ndr); return; }
1380         ndr->depth++;
1381         ndr_print_lsa_String(ndr, "name", &r->name);
1382         ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);
1383         ndr_print_uint32(ndr, "num_members", r->num_members);
1384         ndr_print_lsa_String(ndr, "description", &r->description);
1385         ndr->depth--;
1386 }
1387
1388 static enum ndr_err_code ndr_push_samr_GroupInfoAttributes(struct ndr_push *ndr, int ndr_flags, const struct samr_GroupInfoAttributes *r)
1389 {
1390         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1391         if (ndr_flags & NDR_SCALARS) {
1392                 NDR_CHECK(ndr_push_align(ndr, 4));
1393                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
1394                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1395         }
1396         if (ndr_flags & NDR_BUFFERS) {
1397         }
1398         return NDR_ERR_SUCCESS;
1399 }
1400
1401 static enum ndr_err_code ndr_pull_samr_GroupInfoAttributes(struct ndr_pull *ndr, int ndr_flags, struct samr_GroupInfoAttributes *r)
1402 {
1403         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1404         if (ndr_flags & NDR_SCALARS) {
1405                 NDR_CHECK(ndr_pull_align(ndr, 4));
1406                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
1407                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1408         }
1409         if (ndr_flags & NDR_BUFFERS) {
1410         }
1411         return NDR_ERR_SUCCESS;
1412 }
1413
1414 _PUBLIC_ void ndr_print_samr_GroupInfoAttributes(struct ndr_print *ndr, const char *name, const struct samr_GroupInfoAttributes *r)
1415 {
1416         ndr_print_struct(ndr, name, "samr_GroupInfoAttributes");
1417         if (r == NULL) { ndr_print_null(ndr); return; }
1418         ndr->depth++;
1419         ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);
1420         ndr->depth--;
1421 }
1422
1423 static enum ndr_err_code ndr_push_samr_GroupInfoEnum(struct ndr_push *ndr, int ndr_flags, enum samr_GroupInfoEnum r)
1424 {
1425         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
1426         return NDR_ERR_SUCCESS;
1427 }
1428
1429 static enum ndr_err_code ndr_pull_samr_GroupInfoEnum(struct ndr_pull *ndr, int ndr_flags, enum samr_GroupInfoEnum *r)
1430 {
1431         uint16_t v;
1432         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
1433         *r = v;
1434         return NDR_ERR_SUCCESS;
1435 }
1436
1437 _PUBLIC_ void ndr_print_samr_GroupInfoEnum(struct ndr_print *ndr, const char *name, enum samr_GroupInfoEnum r)
1438 {
1439         const char *val = NULL;
1440
1441         switch (r) {
1442                 case GROUPINFOALL: val = "GROUPINFOALL"; break;
1443                 case GROUPINFONAME: val = "GROUPINFONAME"; break;
1444                 case GROUPINFOATTRIBUTES: val = "GROUPINFOATTRIBUTES"; break;
1445                 case GROUPINFODESCRIPTION: val = "GROUPINFODESCRIPTION"; break;
1446                 case GROUPINFOALL2: val = "GROUPINFOALL2"; break;
1447         }
1448         ndr_print_enum(ndr, name, "ENUM", val, r);
1449 }
1450
1451 static enum ndr_err_code ndr_push_samr_GroupInfo(struct ndr_push *ndr, int ndr_flags, const union samr_GroupInfo *r)
1452 {
1453         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1454         if (ndr_flags & NDR_SCALARS) {
1455                 uint32_t level = ndr_push_get_switch_value(ndr, r);
1456                 NDR_CHECK(ndr_push_union_align(ndr, 5));
1457                 NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, level));
1458                 NDR_CHECK(ndr_push_union_align(ndr, 5));
1459                 switch (level) {
1460                         case GROUPINFOALL: {
1461                                 NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all));
1462                         break; }
1463
1464                         case GROUPINFONAME: {
1465                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1466                         break; }
1467
1468                         case GROUPINFOATTRIBUTES: {
1469                                 NDR_CHECK(ndr_push_samr_GroupInfoAttributes(ndr, NDR_SCALARS, &r->attributes));
1470                         break; }
1471
1472                         case GROUPINFODESCRIPTION: {
1473                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1474                         break; }
1475
1476                         case GROUPINFOALL2: {
1477                                 NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all2));
1478                         break; }
1479
1480                         default:
1481                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1482                 }
1483         }
1484         if (ndr_flags & NDR_BUFFERS) {
1485                 uint32_t level = ndr_push_get_switch_value(ndr, r);
1486                 switch (level) {
1487                         case GROUPINFOALL:
1488                                 NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all));
1489                         break;
1490
1491                         case GROUPINFONAME:
1492                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1493                         break;
1494
1495                         case GROUPINFOATTRIBUTES:
1496                         break;
1497
1498                         case GROUPINFODESCRIPTION:
1499                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1500                         break;
1501
1502                         case GROUPINFOALL2:
1503                                 NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all2));
1504                         break;
1505
1506                         default:
1507                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1508                 }
1509         }
1510         return NDR_ERR_SUCCESS;
1511 }
1512
1513 static enum ndr_err_code ndr_pull_samr_GroupInfo(struct ndr_pull *ndr, int ndr_flags, union samr_GroupInfo *r)
1514 {
1515         uint32_t level;
1516         uint16_t _level;
1517         level = ndr_pull_get_switch_value(ndr, r);
1518         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1519         if (ndr_flags & NDR_SCALARS) {
1520                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
1521                 NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
1522                 if (_level != level) {
1523                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1524                 }
1525                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
1526                 switch (level) {
1527                         case GROUPINFOALL: {
1528                                 NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all));
1529                         break; }
1530
1531                         case GROUPINFONAME: {
1532                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1533                         break; }
1534
1535                         case GROUPINFOATTRIBUTES: {
1536                                 NDR_CHECK(ndr_pull_samr_GroupInfoAttributes(ndr, NDR_SCALARS, &r->attributes));
1537                         break; }
1538
1539                         case GROUPINFODESCRIPTION: {
1540                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1541                         break; }
1542
1543                         case GROUPINFOALL2: {
1544                                 NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all2));
1545                         break; }
1546
1547                         default:
1548                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1549                 }
1550         }
1551         if (ndr_flags & NDR_BUFFERS) {
1552                 switch (level) {
1553                         case GROUPINFOALL:
1554                                 NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all));
1555                         break;
1556
1557                         case GROUPINFONAME:
1558                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1559                         break;
1560
1561                         case GROUPINFOATTRIBUTES:
1562                         break;
1563
1564                         case GROUPINFODESCRIPTION:
1565                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1566                         break;
1567
1568                         case GROUPINFOALL2:
1569                                 NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all2));
1570                         break;
1571
1572                         default:
1573                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1574                 }
1575         }
1576         return NDR_ERR_SUCCESS;
1577 }
1578
1579 _PUBLIC_ void ndr_print_samr_GroupInfo(struct ndr_print *ndr, const char *name, const union samr_GroupInfo *r)
1580 {
1581         uint32_t level;
1582         level = ndr_print_get_switch_value(ndr, r);
1583         ndr_print_union(ndr, name, level, "samr_GroupInfo");
1584         switch (level) {
1585                 case GROUPINFOALL:
1586                         ndr_print_samr_GroupInfoAll(ndr, "all", &r->all);
1587                 break;
1588
1589                 case GROUPINFONAME:
1590                         ndr_print_lsa_String(ndr, "name", &r->name);
1591                 break;
1592
1593                 case GROUPINFOATTRIBUTES:
1594                         ndr_print_samr_GroupInfoAttributes(ndr, "attributes", &r->attributes);
1595                 break;
1596
1597                 case GROUPINFODESCRIPTION:
1598                         ndr_print_lsa_String(ndr, "description", &r->description);
1599                 break;
1600
1601                 case GROUPINFOALL2:
1602                         ndr_print_samr_GroupInfoAll(ndr, "all2", &r->all2);
1603                 break;
1604
1605                 default:
1606                         ndr_print_bad_level(ndr, name, level);
1607         }
1608 }
1609
1610 static enum ndr_err_code ndr_push_samr_RidAttrArray(struct ndr_push *ndr, int ndr_flags, const struct samr_RidAttrArray *r)
1611 {
1612         uint32_t cntr_rids_1;
1613         uint32_t cntr_attributes_1;
1614         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1615         if (ndr_flags & NDR_SCALARS) {
1616                 NDR_CHECK(ndr_push_align(ndr, 5));
1617                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1618                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->rids));
1619                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attributes));
1620                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1621         }
1622         if (ndr_flags & NDR_BUFFERS) {
1623                 if (r->rids) {
1624                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
1625                         for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {
1626                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rids[cntr_rids_1]));
1627                         }
1628                 }
1629                 if (r->attributes) {
1630                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
1631                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->count; cntr_attributes_1++) {
1632                                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes[cntr_attributes_1]));
1633                         }
1634                 }
1635         }
1636         return NDR_ERR_SUCCESS;
1637 }
1638
1639 static enum ndr_err_code ndr_pull_samr_RidAttrArray(struct ndr_pull *ndr, int ndr_flags, struct samr_RidAttrArray *r)
1640 {
1641         uint32_t _ptr_rids;
1642         uint32_t size_rids_1 = 0;
1643         uint32_t cntr_rids_1;
1644         TALLOC_CTX *_mem_save_rids_0;
1645         TALLOC_CTX *_mem_save_rids_1;
1646         uint32_t _ptr_attributes;
1647         uint32_t size_attributes_1 = 0;
1648         uint32_t cntr_attributes_1;
1649         TALLOC_CTX *_mem_save_attributes_0;
1650         TALLOC_CTX *_mem_save_attributes_1;
1651         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1652         if (ndr_flags & NDR_SCALARS) {
1653                 NDR_CHECK(ndr_pull_align(ndr, 5));
1654                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1655                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
1656                 if (_ptr_rids) {
1657                         NDR_PULL_ALLOC(ndr, r->rids);
1658                 } else {
1659                         r->rids = NULL;
1660                 }
1661                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attributes));
1662                 if (_ptr_attributes) {
1663                         NDR_PULL_ALLOC(ndr, r->attributes);
1664                 } else {
1665                         r->attributes = NULL;
1666                 }
1667                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1668         }
1669         if (ndr_flags & NDR_BUFFERS) {
1670                 if (r->rids) {
1671                         _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1672                         NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
1673                         NDR_CHECK(ndr_pull_array_size(ndr, &r->rids));
1674                         size_rids_1 = ndr_get_array_size(ndr, &r->rids);
1675                         NDR_PULL_ALLOC_N(ndr, r->rids, size_rids_1);
1676                         _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
1677                         NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
1678                         for (cntr_rids_1 = 0; cntr_rids_1 < size_rids_1; cntr_rids_1++) {
1679                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));
1680                         }
1681                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
1682                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
1683                 }
1684                 if (r->attributes) {
1685                         _mem_save_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
1686                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
1687                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attributes));
1688                         size_attributes_1 = ndr_get_array_size(ndr, &r->attributes);
1689                         NDR_PULL_ALLOC_N(ndr, r->attributes, size_attributes_1);
1690                         _mem_save_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
1691                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
1692                         for (cntr_attributes_1 = 0; cntr_attributes_1 < size_attributes_1; cntr_attributes_1++) {
1693                                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
1694                         }
1695                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_1, 0);
1696                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_0, 0);
1697                 }
1698                 if (r->rids) {
1699                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->rids, r->count));
1700                 }
1701                 if (r->attributes) {
1702                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attributes, r->count));
1703                 }
1704         }
1705         return NDR_ERR_SUCCESS;
1706 }
1707
1708 _PUBLIC_ void ndr_print_samr_RidAttrArray(struct ndr_print *ndr, const char *name, const struct samr_RidAttrArray *r)
1709 {
1710         uint32_t cntr_rids_1;
1711         uint32_t cntr_attributes_1;
1712         ndr_print_struct(ndr, name, "samr_RidAttrArray");
1713         if (r == NULL) { ndr_print_null(ndr); return; }
1714         ndr->depth++;
1715         ndr_print_uint32(ndr, "count", r->count);
1716         ndr_print_ptr(ndr, "rids", r->rids);
1717         ndr->depth++;
1718         if (r->rids) {
1719                 ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->count);
1720                 ndr->depth++;
1721                 for (cntr_rids_1=0;cntr_rids_1<r->count;cntr_rids_1++) {
1722                         ndr_print_uint32(ndr, "rids", r->rids[cntr_rids_1]);
1723                 }
1724                 ndr->depth--;
1725         }
1726         ndr->depth--;
1727         ndr_print_ptr(ndr, "attributes", r->attributes);
1728         ndr->depth++;
1729         if (r->attributes) {
1730                 ndr->print(ndr, "%s: ARRAY(%d)", "attributes", (int)r->count);
1731                 ndr->depth++;
1732                 for (cntr_attributes_1=0;cntr_attributes_1<r->count;cntr_attributes_1++) {
1733                         ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes[cntr_attributes_1]);
1734                 }
1735                 ndr->depth--;
1736         }
1737         ndr->depth--;
1738         ndr->depth--;
1739 }
1740
1741 static enum ndr_err_code ndr_push_samr_AliasInfoAll(struct ndr_push *ndr, int ndr_flags, const struct samr_AliasInfoAll *r)
1742 {
1743         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1744         if (ndr_flags & NDR_SCALARS) {
1745                 NDR_CHECK(ndr_push_align(ndr, 5));
1746                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1747                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_members));
1748                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1749                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1750         }
1751         if (ndr_flags & NDR_BUFFERS) {
1752                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1753                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1754         }
1755         return NDR_ERR_SUCCESS;
1756 }
1757
1758 static enum ndr_err_code ndr_pull_samr_AliasInfoAll(struct ndr_pull *ndr, int ndr_flags, struct samr_AliasInfoAll *r)
1759 {
1760         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1761         if (ndr_flags & NDR_SCALARS) {
1762                 NDR_CHECK(ndr_pull_align(ndr, 5));
1763                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1764                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_members));
1765                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1766                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1767         }
1768         if (ndr_flags & NDR_BUFFERS) {
1769                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1770                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1771         }
1772         return NDR_ERR_SUCCESS;
1773 }
1774
1775 _PUBLIC_ void ndr_print_samr_AliasInfoAll(struct ndr_print *ndr, const char *name, const struct samr_AliasInfoAll *r)
1776 {
1777         ndr_print_struct(ndr, name, "samr_AliasInfoAll");
1778         if (r == NULL) { ndr_print_null(ndr); return; }
1779         ndr->depth++;
1780         ndr_print_lsa_String(ndr, "name", &r->name);
1781         ndr_print_uint32(ndr, "num_members", r->num_members);
1782         ndr_print_lsa_String(ndr, "description", &r->description);
1783         ndr->depth--;
1784 }
1785
1786 static enum ndr_err_code ndr_push_samr_AliasInfoEnum(struct ndr_push *ndr, int ndr_flags, enum samr_AliasInfoEnum r)
1787 {
1788         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
1789         return NDR_ERR_SUCCESS;
1790 }
1791
1792 static enum ndr_err_code ndr_pull_samr_AliasInfoEnum(struct ndr_pull *ndr, int ndr_flags, enum samr_AliasInfoEnum *r)
1793 {
1794         uint16_t v;
1795         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
1796         *r = v;
1797         return NDR_ERR_SUCCESS;
1798 }
1799
1800 _PUBLIC_ void ndr_print_samr_AliasInfoEnum(struct ndr_print *ndr, const char *name, enum samr_AliasInfoEnum r)
1801 {
1802         const char *val = NULL;
1803
1804         switch (r) {
1805                 case ALIASINFOALL: val = "ALIASINFOALL"; break;
1806                 case ALIASINFONAME: val = "ALIASINFONAME"; break;
1807                 case ALIASINFODESCRIPTION: val = "ALIASINFODESCRIPTION"; break;
1808         }
1809         ndr_print_enum(ndr, name, "ENUM", val, r);
1810 }
1811
1812 static enum ndr_err_code ndr_push_samr_AliasInfo(struct ndr_push *ndr, int ndr_flags, const union samr_AliasInfo *r)
1813 {
1814         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1815         if (ndr_flags & NDR_SCALARS) {
1816                 uint32_t level = ndr_push_get_switch_value(ndr, r);
1817                 NDR_CHECK(ndr_push_union_align(ndr, 5));
1818                 NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, level));
1819                 NDR_CHECK(ndr_push_union_align(ndr, 5));
1820                 switch (level) {
1821                         case ALIASINFOALL: {
1822                                 NDR_CHECK(ndr_push_samr_AliasInfoAll(ndr, NDR_SCALARS, &r->all));
1823                         break; }
1824
1825                         case ALIASINFONAME: {
1826                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1827                         break; }
1828
1829                         case ALIASINFODESCRIPTION: {
1830                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1831                         break; }
1832
1833                         default:
1834                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1835                 }
1836         }
1837         if (ndr_flags & NDR_BUFFERS) {
1838                 uint32_t level = ndr_push_get_switch_value(ndr, r);
1839                 switch (level) {
1840                         case ALIASINFOALL:
1841                                 NDR_CHECK(ndr_push_samr_AliasInfoAll(ndr, NDR_BUFFERS, &r->all));
1842                         break;
1843
1844                         case ALIASINFONAME:
1845                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1846                         break;
1847
1848                         case ALIASINFODESCRIPTION:
1849                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1850                         break;
1851
1852                         default:
1853                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1854                 }
1855         }
1856         return NDR_ERR_SUCCESS;
1857 }
1858
1859 static enum ndr_err_code ndr_pull_samr_AliasInfo(struct ndr_pull *ndr, int ndr_flags, union samr_AliasInfo *r)
1860 {
1861         uint32_t level;
1862         uint16_t _level;
1863         level = ndr_pull_get_switch_value(ndr, r);
1864         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1865         if (ndr_flags & NDR_SCALARS) {
1866                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
1867                 NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
1868                 if (_level != level) {
1869                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1870                 }
1871                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
1872                 switch (level) {
1873                         case ALIASINFOALL: {
1874                                 NDR_CHECK(ndr_pull_samr_AliasInfoAll(ndr, NDR_SCALARS, &r->all));
1875                         break; }
1876
1877                         case ALIASINFONAME: {
1878                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1879                         break; }
1880
1881                         case ALIASINFODESCRIPTION: {
1882                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1883                         break; }
1884
1885                         default:
1886                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1887                 }
1888         }
1889         if (ndr_flags & NDR_BUFFERS) {
1890                 switch (level) {
1891                         case ALIASINFOALL:
1892                                 NDR_CHECK(ndr_pull_samr_AliasInfoAll(ndr, NDR_BUFFERS, &r->all));
1893                         break;
1894
1895                         case ALIASINFONAME:
1896                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1897                         break;
1898
1899                         case ALIASINFODESCRIPTION:
1900                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1901                         break;
1902
1903                         default:
1904                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1905                 }
1906         }
1907         return NDR_ERR_SUCCESS;
1908 }
1909
1910 _PUBLIC_ void ndr_print_samr_AliasInfo(struct ndr_print *ndr, const char *name, const union samr_AliasInfo *r)
1911 {
1912         uint32_t level;
1913         level = ndr_print_get_switch_value(ndr, r);
1914         ndr_print_union(ndr, name, level, "samr_AliasInfo");
1915         switch (level) {
1916                 case ALIASINFOALL:
1917                         ndr_print_samr_AliasInfoAll(ndr, "all", &r->all);
1918                 break;
1919
1920                 case ALIASINFONAME:
1921                         ndr_print_lsa_String(ndr, "name", &r->name);
1922                 break;
1923
1924                 case ALIASINFODESCRIPTION:
1925                         ndr_print_lsa_String(ndr, "description", &r->description);
1926                 break;
1927
1928                 default:
1929                         ndr_print_bad_level(ndr, name, level);
1930         }
1931 }
1932
1933 static enum ndr_err_code ndr_push_samr_UserInfoLevel(struct ndr_push *ndr, int ndr_flags, enum samr_UserInfoLevel r)
1934 {
1935         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
1936         return NDR_ERR_SUCCESS;
1937 }
1938
1939 static enum ndr_err_code ndr_pull_samr_UserInfoLevel(struct ndr_pull *ndr, int ndr_flags, enum samr_UserInfoLevel *r)
1940 {
1941         uint16_t v;
1942         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
1943         *r = v;
1944         return NDR_ERR_SUCCESS;
1945 }
1946
1947 _PUBLIC_ void ndr_print_samr_UserInfoLevel(struct ndr_print *ndr, const char *name, enum samr_UserInfoLevel r)
1948 {
1949         const char *val = NULL;
1950
1951         switch (r) {
1952                 case UserGeneralInformation: val = "UserGeneralInformation"; break;
1953                 case UserPreferencesInformation: val = "UserPreferencesInformation"; break;
1954                 case UserLogonInformation: val = "UserLogonInformation"; break;
1955                 case UserLogonHoursInformation: val = "UserLogonHoursInformation"; break;
1956                 case UserAccountInformation: val = "UserAccountInformation"; break;
1957                 case UserNameInformation: val = "UserNameInformation"; break;
1958                 case UserAccountNameInformation: val = "UserAccountNameInformation"; break;
1959                 case UserFullNameInformation: val = "UserFullNameInformation"; break;
1960                 case UserPrimaryGroupInformation: val = "UserPrimaryGroupInformation"; break;
1961                 case UserHomeInformation: val = "UserHomeInformation"; break;
1962                 case UserScriptInformation: val = "UserScriptInformation"; break;
1963                 case UserProfileInformation: val = "UserProfileInformation"; break;
1964                 case UserAdminCommentInformation: val = "UserAdminCommentInformation"; break;
1965                 case UserWorkStationsInformation: val = "UserWorkStationsInformation"; break;
1966                 case UserControlInformation: val = "UserControlInformation"; break;
1967                 case UserExpiresInformation: val = "UserExpiresInformation"; break;
1968                 case UserInternal1Information: val = "UserInternal1Information"; break;
1969                 case UserParametersInformation: val = "UserParametersInformation"; break;
1970                 case UserAllInformation: val = "UserAllInformation"; break;
1971                 case UserInternal4Information: val = "UserInternal4Information"; break;
1972                 case UserInternal5Information: val = "UserInternal5Information"; break;
1973                 case UserInternal4InformationNew: val = "UserInternal4InformationNew"; break;
1974                 case UserInternal5InformationNew: val = "UserInternal5InformationNew"; break;
1975         }
1976         ndr_print_enum(ndr, name, "ENUM", val, r);
1977 }
1978
1979 static enum ndr_err_code ndr_push_samr_UserInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo1 *r)
1980 {
1981         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1982         if (ndr_flags & NDR_SCALARS) {
1983                 NDR_CHECK(ndr_push_align(ndr, 5));
1984                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
1985                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
1986                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
1987                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1988                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));
1989                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1990         }
1991         if (ndr_flags & NDR_BUFFERS) {
1992                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
1993                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
1994                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1995                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));
1996         }
1997         return NDR_ERR_SUCCESS;
1998 }
1999
2000 static enum ndr_err_code ndr_pull_samr_UserInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo1 *r)
2001 {
2002         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2003         if (ndr_flags & NDR_SCALARS) {
2004                 NDR_CHECK(ndr_pull_align(ndr, 5));
2005                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2006                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2007                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
2008                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
2009                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));
2010                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2011         }
2012         if (ndr_flags & NDR_BUFFERS) {
2013                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2014                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2015                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
2016                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));
2017         }
2018         return NDR_ERR_SUCCESS;
2019 }
2020
2021 _PUBLIC_ void ndr_print_samr_UserInfo1(struct ndr_print *ndr, const char *name, const struct samr_UserInfo1 *r)
2022 {
2023         ndr_print_struct(ndr, name, "samr_UserInfo1");
2024         if (r == NULL) { ndr_print_null(ndr); return; }
2025         ndr->depth++;
2026         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2027         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2028         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
2029         ndr_print_lsa_String(ndr, "description", &r->description);
2030         ndr_print_lsa_String(ndr, "comment", &r->comment);
2031         ndr->depth--;
2032 }
2033
2034 static enum ndr_err_code ndr_push_samr_UserInfo2(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo2 *r)
2035 {
2036         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2037         if (ndr_flags & NDR_SCALARS) {
2038                 NDR_CHECK(ndr_push_align(ndr, 5));
2039                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));
2040                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->reserved));
2041                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->country_code));
2042                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->code_page));
2043                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2044         }
2045         if (ndr_flags & NDR_BUFFERS) {
2046                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));
2047                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->reserved));
2048         }
2049         return NDR_ERR_SUCCESS;
2050 }
2051
2052 static enum ndr_err_code ndr_pull_samr_UserInfo2(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo2 *r)
2053 {
2054         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2055         if (ndr_flags & NDR_SCALARS) {
2056                 NDR_CHECK(ndr_pull_align(ndr, 5));
2057                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));
2058                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->reserved));
2059                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->country_code));
2060                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->code_page));
2061                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2062         }
2063         if (ndr_flags & NDR_BUFFERS) {
2064                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));
2065                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->reserved));
2066         }
2067         return NDR_ERR_SUCCESS;
2068 }
2069
2070 _PUBLIC_ void ndr_print_samr_UserInfo2(struct ndr_print *ndr, const char *name, const struct samr_UserInfo2 *r)
2071 {
2072         ndr_print_struct(ndr, name, "samr_UserInfo2");
2073         if (r == NULL) { ndr_print_null(ndr); return; }
2074         ndr->depth++;
2075         ndr_print_lsa_String(ndr, "comment", &r->comment);
2076         ndr_print_lsa_String(ndr, "reserved", &r->reserved);
2077         ndr_print_uint16(ndr, "country_code", r->country_code);
2078         ndr_print_uint16(ndr, "code_page", r->code_page);
2079         ndr->depth--;
2080 }
2081
2082 _PUBLIC_ enum ndr_err_code ndr_push_samr_LogonHours(struct ndr_push *ndr, int ndr_flags, const struct samr_LogonHours *r)
2083 {
2084         {
2085                 uint32_t _flags_save_STRUCT = ndr->flags;
2086                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2087                 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2088                 if (ndr_flags & NDR_SCALARS) {
2089                         NDR_CHECK(ndr_push_align(ndr, 5));
2090                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->units_per_week));
2091                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->bits));
2092                         NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2093                 }
2094                 if (ndr_flags & NDR_BUFFERS) {
2095                         if (r->bits) {
2096                                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 1260));
2097                                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2098                                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->units_per_week / 8));
2099                                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->bits, r->units_per_week / 8));
2100                         }
2101                 }
2102                 ndr->flags = _flags_save_STRUCT;
2103         }
2104         return NDR_ERR_SUCCESS;
2105 }
2106
2107 _PUBLIC_ enum ndr_err_code ndr_pull_samr_LogonHours(struct ndr_pull *ndr, int ndr_flags, struct samr_LogonHours *r)
2108 {
2109         uint32_t _ptr_bits;
2110         uint32_t size_bits_1 = 0;
2111         uint32_t length_bits_1 = 0;
2112         TALLOC_CTX *_mem_save_bits_0;
2113         {
2114                 uint32_t _flags_save_STRUCT = ndr->flags;
2115                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2116                 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2117                 if (ndr_flags & NDR_SCALARS) {
2118                         NDR_CHECK(ndr_pull_align(ndr, 5));
2119                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->units_per_week));
2120                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bits));
2121                         if (_ptr_bits) {
2122                                 NDR_PULL_ALLOC(ndr, r->bits);
2123                         } else {
2124                                 r->bits = NULL;
2125                         }
2126                         NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2127                 }
2128                 if (ndr_flags & NDR_BUFFERS) {
2129                         if (r->bits) {
2130                                 _mem_save_bits_0 = NDR_PULL_GET_MEM_CTX(ndr);
2131                                 NDR_PULL_SET_MEM_CTX(ndr, r->bits, 0);
2132                                 NDR_CHECK(ndr_pull_array_size(ndr, &r->bits));
2133                                 NDR_CHECK(ndr_pull_array_length(ndr, &r->bits));
2134                                 size_bits_1 = ndr_get_array_size(ndr, &r->bits);
2135                                 length_bits_1 = ndr_get_array_length(ndr, &r->bits);
2136                                 if (length_bits_1 > size_bits_1) {
2137                                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_bits_1, length_bits_1);
2138                                 }
2139                                 NDR_PULL_ALLOC_N(ndr, r->bits, size_bits_1);
2140                                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->bits, length_bits_1));
2141                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bits_0, 0);
2142                         }
2143                         if (r->bits) {
2144                                 NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->bits, 1260));
2145                         }
2146                         if (r->bits) {
2147                                 NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->bits, r->units_per_week / 8));
2148                         }
2149                 }
2150                 ndr->flags = _flags_save_STRUCT;
2151         }
2152         return NDR_ERR_SUCCESS;
2153 }
2154
2155 _PUBLIC_ void ndr_print_samr_LogonHours(struct ndr_print *ndr, const char *name, const struct samr_LogonHours *r)
2156 {
2157         ndr_print_struct(ndr, name, "samr_LogonHours");
2158         if (r == NULL) { ndr_print_null(ndr); return; }
2159         {
2160                 uint32_t _flags_save_STRUCT = ndr->flags;
2161                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2162                 ndr->depth++;
2163                 ndr_print_uint16(ndr, "units_per_week", r->units_per_week);
2164                 ndr_print_ptr(ndr, "bits", r->bits);
2165                 ndr->depth++;
2166                 if (r->bits) {
2167                         ndr_print_array_uint8(ndr, "bits", r->bits, r->units_per_week / 8);
2168                 }
2169                 ndr->depth--;
2170                 ndr->depth--;
2171                 ndr->flags = _flags_save_STRUCT;
2172         }
2173 }
2174
2175 static enum ndr_err_code ndr_push_samr_UserInfo3(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo3 *r)
2176 {
2177         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2178         if (ndr_flags & NDR_SCALARS) {
2179                 NDR_CHECK(ndr_push_align(ndr, 5));
2180                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2181                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2182                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
2183                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
2184                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2185                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2186                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2187                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2188                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2189                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));
2190                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));
2191                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));
2192                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->allow_password_change));
2193                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_password_change));
2194                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2195                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));
2196                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
2197                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
2198                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2199         }
2200         if (ndr_flags & NDR_BUFFERS) {
2201                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2202                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2203                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2204                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2205                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2206                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2207                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2208                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2209         }
2210         return NDR_ERR_SUCCESS;
2211 }
2212
2213 static enum ndr_err_code ndr_pull_samr_UserInfo3(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo3 *r)
2214 {
2215         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2216         if (ndr_flags & NDR_SCALARS) {
2217                 NDR_CHECK(ndr_pull_align(ndr, 5));
2218                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2219                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2220                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
2221                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
2222                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2223                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2224                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2225                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2226                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2227                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));
2228                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));
2229                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));
2230                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->allow_password_change));
2231                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_password_change));
2232                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2233                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));
2234                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
2235                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
2236                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2237         }
2238         if (ndr_flags & NDR_BUFFERS) {
2239                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2240                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2241                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2242                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2243                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2244                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2245                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2246                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2247         }
2248         return NDR_ERR_SUCCESS;
2249 }
2250
2251 _PUBLIC_ void ndr_print_samr_UserInfo3(struct ndr_print *ndr, const char *name, const struct samr_UserInfo3 *r)
2252 {
2253         ndr_print_struct(ndr, name, "samr_UserInfo3");
2254         if (r == NULL) { ndr_print_null(ndr); return; }
2255         ndr->depth++;
2256         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2257         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2258         ndr_print_uint32(ndr, "rid", r->rid);
2259         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
2260         ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
2261         ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
2262         ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
2263         ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
2264         ndr_print_lsa_String(ndr, "workstations", &r->workstations);
2265         ndr_print_NTTIME(ndr, "last_logon", r->last_logon);
2266         ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);
2267         ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);
2268         ndr_print_NTTIME(ndr, "allow_password_change", r->allow_password_change);
2269         ndr_print_NTTIME(ndr, "force_password_change", r->force_password_change);
2270         ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
2271         ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);
2272         ndr_print_uint16(ndr, "logon_count", r->logon_count);
2273         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
2274         ndr->depth--;
2275 }
2276
2277 static enum ndr_err_code ndr_push_samr_UserInfo4(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo4 *r)
2278 {
2279         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2280         if (ndr_flags & NDR_SCALARS) {
2281                 NDR_CHECK(ndr_push_align(ndr, 5));
2282                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2283                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2284         }
2285         if (ndr_flags & NDR_BUFFERS) {
2286                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2287         }
2288         return NDR_ERR_SUCCESS;
2289 }
2290
2291 static enum ndr_err_code ndr_pull_samr_UserInfo4(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo4 *r)
2292 {
2293         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2294         if (ndr_flags & NDR_SCALARS) {
2295                 NDR_CHECK(ndr_pull_align(ndr, 5));
2296                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2297                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2298         }
2299         if (ndr_flags & NDR_BUFFERS) {
2300                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2301         }
2302         return NDR_ERR_SUCCESS;
2303 }
2304
2305 _PUBLIC_ void ndr_print_samr_UserInfo4(struct ndr_print *ndr, const char *name, const struct samr_UserInfo4 *r)
2306 {
2307         ndr_print_struct(ndr, name, "samr_UserInfo4");
2308         if (r == NULL) { ndr_print_null(ndr); return; }
2309         ndr->depth++;
2310         ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
2311         ndr->depth--;
2312 }
2313
2314 static enum ndr_err_code ndr_push_samr_UserInfo5(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo5 *r)
2315 {
2316         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2317         if (ndr_flags & NDR_SCALARS) {
2318                 NDR_CHECK(ndr_push_align(ndr, 5));
2319                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2320                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2321                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
2322                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
2323                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2324                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2325                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2326                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2327                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
2328                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2329                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));
2330                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));
2331                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2332                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));
2333                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
2334                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));
2335                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
2336                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
2337                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2338         }
2339         if (ndr_flags & NDR_BUFFERS) {
2340                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2341                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2342                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2343                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2344                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2345                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2346                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
2347                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2348                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2349         }
2350         return NDR_ERR_SUCCESS;
2351 }
2352
2353 static enum ndr_err_code ndr_pull_samr_UserInfo5(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo5 *r)
2354 {
2355         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2356         if (ndr_flags & NDR_SCALARS) {
2357                 NDR_CHECK(ndr_pull_align(ndr, 5));
2358                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2359                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2360                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
2361                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
2362                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2363                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2364                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2365                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2366                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
2367                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2368                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));
2369                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));
2370                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2371                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));
2372                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
2373                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));
2374                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
2375                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
2376                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2377         }
2378         if (ndr_flags & NDR_BUFFERS) {
2379                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2380                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2381                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2382                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2383                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2384                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2385                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
2386                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2387                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2388         }
2389         return NDR_ERR_SUCCESS;
2390 }
2391
2392 _PUBLIC_ void ndr_print_samr_UserInfo5(struct ndr_print *ndr, const char *name, const struct samr_UserInfo5 *r)
2393 {
2394         ndr_print_struct(ndr, name, "samr_UserInfo5");
2395         if (r == NULL) { ndr_print_null(ndr); return; }
2396         ndr->depth++;
2397         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2398         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2399         ndr_print_uint32(ndr, "rid", r->rid);
2400         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
2401         ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
2402         ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
2403         ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
2404         ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
2405         ndr_print_lsa_String(ndr, "description", &r->description);
2406         ndr_print_lsa_String(ndr, "workstations", &r->workstations);
2407         ndr_print_NTTIME(ndr, "last_logon", r->last_logon);
2408         ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);
2409         ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
2410         ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);
2411         ndr_print_uint16(ndr, "logon_count", r->logon_count);
2412         ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);
2413         ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);
2414         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
2415         ndr->depth--;
2416 }
2417
2418 static enum ndr_err_code ndr_push_samr_UserInfo6(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo6 *r)
2419 {
2420         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2421         if (ndr_flags & NDR_SCALARS) {
2422                 NDR_CHECK(ndr_push_align(ndr, 5));
2423                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2424                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2425                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2426         }
2427         if (ndr_flags & NDR_BUFFERS) {
2428                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2429                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2430         }
2431         return NDR_ERR_SUCCESS;
2432 }
2433
2434 static enum ndr_err_code ndr_pull_samr_UserInfo6(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo6 *r)
2435 {
2436         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2437         if (ndr_flags & NDR_SCALARS) {
2438                 NDR_CHECK(ndr_pull_align(ndr, 5));
2439                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2440                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2441                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2442         }
2443         if (ndr_flags & NDR_BUFFERS) {
2444                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2445                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2446         }
2447         return NDR_ERR_SUCCESS;
2448 }
2449
2450 _PUBLIC_ void ndr_print_samr_UserInfo6(struct ndr_print *ndr, const char *name, const struct samr_UserInfo6 *r)
2451 {
2452         ndr_print_struct(ndr, name, "samr_UserInfo6");
2453         if (r == NULL) { ndr_print_null(ndr); return; }
2454         ndr->depth++;
2455         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2456         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2457         ndr->depth--;
2458 }
2459
2460 static enum ndr_err_code ndr_push_samr_UserInfo7(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo7 *r)
2461 {
2462         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2463         if (ndr_flags & NDR_SCALARS) {
2464                 NDR_CHECK(ndr_push_align(ndr, 5));
2465                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2466                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2467         }
2468         if (ndr_flags & NDR_BUFFERS) {
2469                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2470         }
2471         return NDR_ERR_SUCCESS;
2472 }
2473
2474 static enum ndr_err_code ndr_pull_samr_UserInfo7(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo7 *r)
2475 {
2476         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2477         if (ndr_flags & NDR_SCALARS) {
2478                 NDR_CHECK(ndr_pull_align(ndr, 5));
2479                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2480                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2481         }
2482         if (ndr_flags & NDR_BUFFERS) {
2483                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2484         }
2485         return NDR_ERR_SUCCESS;
2486 }
2487
2488 _PUBLIC_ void ndr_print_samr_UserInfo7(struct ndr_print *ndr, const char *name, const struct samr_UserInfo7 *r)
2489 {
2490         ndr_print_struct(ndr, name, "samr_UserInfo7");
2491         if (r == NULL) { ndr_print_null(ndr); return; }
2492         ndr->depth++;
2493         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2494         ndr->depth--;
2495 }
2496
2497 static enum ndr_err_code ndr_push_samr_UserInfo8(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo8 *r)
2498 {
2499         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2500         if (ndr_flags & NDR_SCALARS) {
2501                 NDR_CHECK(ndr_push_align(ndr, 5));
2502                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2503                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2504         }
2505         if (ndr_flags & NDR_BUFFERS) {
2506                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2507         }
2508         return NDR_ERR_SUCCESS;
2509 }
2510
2511 static enum ndr_err_code ndr_pull_samr_UserInfo8(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo8 *r)
2512 {
2513         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2514         if (ndr_flags & NDR_SCALARS) {
2515                 NDR_CHECK(ndr_pull_align(ndr, 5));
2516                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2517                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2518         }
2519         if (ndr_flags & NDR_BUFFERS) {
2520                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2521         }
2522         return NDR_ERR_SUCCESS;
2523 }
2524
2525 _PUBLIC_ void ndr_print_samr_UserInfo8(struct ndr_print *ndr, const char *name, const struct samr_UserInfo8 *r)
2526 {
2527         ndr_print_struct(ndr, name, "samr_UserInfo8");
2528         if (r == NULL) { ndr_print_null(ndr); return; }
2529         ndr->depth++;
2530         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2531         ndr->depth--;
2532 }
2533
2534 static enum ndr_err_code ndr_push_samr_UserInfo9(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo9 *r)
2535 {
2536         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2537         if (ndr_flags & NDR_SCALARS) {
2538                 NDR_CHECK(ndr_push_align(ndr, 4));
2539                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
2540                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2541         }
2542         if (ndr_flags & NDR_BUFFERS) {
2543         }
2544         return NDR_ERR_SUCCESS;
2545 }
2546
2547 static enum ndr_err_code ndr_pull_samr_UserInfo9(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo9 *r)
2548 {
2549         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2550         if (ndr_flags & NDR_SCALARS) {
2551                 NDR_CHECK(ndr_pull_align(ndr, 4));
2552                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
2553                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2554         }
2555         if (ndr_flags & NDR_BUFFERS) {
2556         }
2557         return NDR_ERR_SUCCESS;
2558 }
2559
2560 _PUBLIC_ void ndr_print_samr_UserInfo9(struct ndr_print *ndr, const char *name, const struct samr_UserInfo9 *r)
2561 {
2562         ndr_print_struct(ndr, name, "samr_UserInfo9");
2563         if (r == NULL) { ndr_print_null(ndr); return; }
2564         ndr->depth++;
2565         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
2566         ndr->depth--;
2567 }
2568
2569 static enum ndr_err_code ndr_push_samr_UserInfo10(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo10 *r)
2570 {
2571         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2572         if (ndr_flags & NDR_SCALARS) {
2573                 NDR_CHECK(ndr_push_align(ndr, 5));
2574                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2575                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2576                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2577         }
2578         if (ndr_flags & NDR_BUFFERS) {
2579                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2580                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2581         }
2582         return NDR_ERR_SUCCESS;
2583 }
2584
2585 static enum ndr_err_code ndr_pull_samr_UserInfo10(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo10 *r)
2586 {
2587         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2588         if (ndr_flags & NDR_SCALARS) {
2589                 NDR_CHECK(ndr_pull_align(ndr, 5));
2590                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2591                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2592                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2593         }
2594         if (ndr_flags & NDR_BUFFERS) {
2595                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2596                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2597         }
2598         return NDR_ERR_SUCCESS;
2599 }
2600
2601 _PUBLIC_ void ndr_print_samr_UserInfo10(struct ndr_print *ndr, const char *name, const struct samr_UserInfo10 *r)
2602 {
2603         ndr_print_struct(ndr, name, "samr_UserInfo10");
2604         if (r == NULL) { ndr_print_null(ndr); return; }
2605         ndr->depth++;
2606         ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
2607         ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
2608         ndr->depth--;
2609 }
2610
2611 static enum ndr_err_code ndr_push_samr_UserInfo11(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo11 *r)
2612 {
2613         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2614         if (ndr_flags & NDR_SCALARS) {
2615                 NDR_CHECK(ndr_push_align(ndr, 5));
2616                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2617                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2618         }
2619         if (ndr_flags & NDR_BUFFERS) {
2620                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2621         }
2622         return NDR_ERR_SUCCESS;
2623 }
2624
2625 static enum ndr_err_code ndr_pull_samr_UserInfo11(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo11 *r)
2626 {
2627         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2628         if (ndr_flags & NDR_SCALARS) {
2629                 NDR_CHECK(ndr_pull_align(ndr, 5));
2630                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2631                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2632         }
2633         if (ndr_flags & NDR_BUFFERS) {
2634                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2635         }
2636         return NDR_ERR_SUCCESS;
2637 }
2638
2639 _PUBLIC_ void ndr_print_samr_UserInfo11(struct ndr_print *ndr, const char *name, const struct samr_UserInfo11 *r)
2640 {
2641         ndr_print_struct(ndr, name, "samr_UserInfo11");
2642         if (r == NULL) { ndr_print_null(ndr); return; }
2643         ndr->depth++;
2644         ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
2645         ndr->depth--;
2646 }
2647
2648 static enum ndr_err_code ndr_push_samr_UserInfo12(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo12 *r)
2649 {
2650         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2651         if (ndr_flags & NDR_SCALARS) {
2652                 NDR_CHECK(ndr_push_align(ndr, 5));
2653                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2654                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2655         }
2656         if (ndr_flags & NDR_BUFFERS) {
2657                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2658         }
2659         return NDR_ERR_SUCCESS;
2660 }
2661
2662 static enum ndr_err_code ndr_pull_samr_UserInfo12(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo12 *r)
2663 {
2664         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2665         if (ndr_flags & NDR_SCALARS) {
2666                 NDR_CHECK(ndr_pull_align(ndr, 5));
2667                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2668                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2669         }
2670         if (ndr_flags & NDR_BUFFERS) {
2671                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2672         }
2673         return NDR_ERR_SUCCESS;
2674 }
2675
2676 _PUBLIC_ void ndr_print_samr_UserInfo12(struct ndr_print *ndr, const char *name, const struct samr_UserInfo12 *r)
2677 {
2678         ndr_print_struct(ndr, name, "samr_UserInfo12");
2679         if (r == NULL) { ndr_print_null(ndr); return; }
2680         ndr->depth++;
2681         ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
2682         ndr->depth--;
2683 }
2684
2685 static enum ndr_err_code ndr_push_samr_UserInfo13(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo13 *r)
2686 {
2687         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2688         if (ndr_flags & NDR_SCALARS) {
2689                 NDR_CHECK(ndr_push_align(ndr, 5));
2690                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
2691                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2692         }
2693         if (ndr_flags & NDR_BUFFERS) {
2694                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
2695         }
2696         return NDR_ERR_SUCCESS;
2697 }
2698
2699 static enum ndr_err_code ndr_pull_samr_UserInfo13(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo13 *r)
2700 {
2701         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2702         if (ndr_flags & NDR_SCALARS) {
2703                 NDR_CHECK(ndr_pull_align(ndr, 5));
2704                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
2705                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2706         }
2707         if (ndr_flags & NDR_BUFFERS) {
2708                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
2709         }
2710         return NDR_ERR_SUCCESS;
2711 }
2712
2713 _PUBLIC_ void ndr_print_samr_UserInfo13(struct ndr_print *ndr, const char *name, const struct samr_UserInfo13 *r)
2714 {
2715         ndr_print_struct(ndr, name, "samr_UserInfo13");
2716         if (r == NULL) { ndr_print_null(ndr); return; }
2717         ndr->depth++;
2718         ndr_print_lsa_String(ndr, "description", &r->description);
2719         ndr->depth--;
2720 }
2721
2722 static enum ndr_err_code ndr_push_samr_UserInfo14(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo14 *r)
2723 {
2724         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2725         if (ndr_flags & NDR_SCALARS) {
2726                 NDR_CHECK(ndr_push_align(ndr, 5));
2727                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2728                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2729         }
2730         if (ndr_flags & NDR_BUFFERS) {
2731                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2732         }
2733         return NDR_ERR_SUCCESS;
2734 }
2735
2736 static enum ndr_err_code ndr_pull_samr_UserInfo14(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo14 *r)
2737 {
2738         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2739         if (ndr_flags & NDR_SCALARS) {
2740                 NDR_CHECK(ndr_pull_align(ndr, 5));
2741                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2742                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2743         }
2744         if (ndr_flags & NDR_BUFFERS) {
2745                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2746         }
2747         return NDR_ERR_SUCCESS;
2748 }
2749
2750 _PUBLIC_ void ndr_print_samr_UserInfo14(struct ndr_print *ndr, const char *name, const struct samr_UserInfo14 *r)
2751 {
2752         ndr_print_struct(ndr, name, "samr_UserInfo14");
2753         if (r == NULL) { ndr_print_null(ndr); return; }
2754         ndr->depth++;
2755         ndr_print_lsa_String(ndr, "workstations", &r->workstations);
2756         ndr->depth--;
2757 }
2758
2759 static enum ndr_err_code ndr_push_samr_UserInfo16(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo16 *r)
2760 {
2761         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2762         if (ndr_flags & NDR_SCALARS) {
2763                 NDR_CHECK(ndr_push_align(ndr, 4));
2764                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
2765                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2766         }
2767         if (ndr_flags & NDR_BUFFERS) {
2768         }
2769         return NDR_ERR_SUCCESS;
2770 }
2771
2772 static enum ndr_err_code ndr_pull_samr_UserInfo16(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo16 *r)
2773 {
2774         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2775         if (ndr_flags & NDR_SCALARS) {
2776                 NDR_CHECK(ndr_pull_align(ndr, 4));
2777                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
2778                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2779         }
2780         if (ndr_flags & NDR_BUFFERS) {
2781         }
2782         return NDR_ERR_SUCCESS;
2783 }
2784
2785 _PUBLIC_ void ndr_print_samr_UserInfo16(struct ndr_print *ndr, const char *name, const struct samr_UserInfo16 *r)
2786 {
2787         ndr_print_struct(ndr, name, "samr_UserInfo16");
2788         if (r == NULL) { ndr_print_null(ndr); return; }
2789         ndr->depth++;
2790         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
2791         ndr->depth--;
2792 }
2793
2794 static enum ndr_err_code ndr_push_samr_UserInfo17(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo17 *r)
2795 {
2796         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2797         if (ndr_flags & NDR_SCALARS) {
2798                 NDR_CHECK(ndr_push_align(ndr, 4));
2799                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
2800                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2801         }
2802         if (ndr_flags & NDR_BUFFERS) {
2803         }
2804         return NDR_ERR_SUCCESS;
2805 }
2806
2807 static enum ndr_err_code ndr_pull_samr_UserInfo17(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo17 *r)
2808 {
2809         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2810         if (ndr_flags & NDR_SCALARS) {
2811                 NDR_CHECK(ndr_pull_align(ndr, 4));
2812                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
2813                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2814         }
2815         if (ndr_flags & NDR_BUFFERS) {
2816         }
2817         return NDR_ERR_SUCCESS;
2818 }
2819
2820 _PUBLIC_ void ndr_print_samr_UserInfo17(struct ndr_print *ndr, const char *name, const struct samr_UserInfo17 *r)
2821 {
2822         ndr_print_struct(ndr, name, "samr_UserInfo17");
2823         if (r == NULL) { ndr_print_null(ndr); return; }
2824         ndr->depth++;
2825         ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);
2826         ndr->depth--;
2827 }
2828
2829 _PUBLIC_ enum ndr_err_code ndr_push_samr_Password(struct ndr_push *ndr, int ndr_flags, const struct samr_Password *r)
2830 {
2831         {
2832                 uint32_t _flags_save_STRUCT = ndr->flags;
2833                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2834                 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2835                 if (ndr_flags & NDR_SCALARS) {
2836                         NDR_CHECK(ndr_push_align(ndr, 1));
2837                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
2838                         NDR_CHECK(ndr_push_trailer_align(ndr, 1));
2839                 }
2840                 if (ndr_flags & NDR_BUFFERS) {
2841                 }
2842                 ndr->flags = _flags_save_STRUCT;
2843         }
2844         return NDR_ERR_SUCCESS;
2845 }
2846
2847 _PUBLIC_ enum ndr_err_code ndr_pull_samr_Password(struct ndr_pull *ndr, int ndr_flags, struct samr_Password *r)
2848 {
2849         uint32_t size_hash_0 = 0;
2850         {
2851                 uint32_t _flags_save_STRUCT = ndr->flags;
2852                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2853                 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2854                 if (ndr_flags & NDR_SCALARS) {
2855                         NDR_CHECK(ndr_pull_align(ndr, 1));
2856                         size_hash_0 = 16;
2857                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->hash, size_hash_0));
2858                         NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
2859                 }
2860                 if (ndr_flags & NDR_BUFFERS) {
2861                 }
2862                 ndr->flags = _flags_save_STRUCT;
2863         }
2864         return NDR_ERR_SUCCESS;
2865 }
2866
2867 _PUBLIC_ void ndr_print_samr_Password(struct ndr_print *ndr, const char *name, const struct samr_Password *r)
2868 {
2869         ndr_print_struct(ndr, name, "samr_Password");
2870         if (r == NULL) { ndr_print_null(ndr); return; }
2871         {
2872                 uint32_t _flags_save_STRUCT = ndr->flags;
2873                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2874                 ndr->depth++;
2875                 ndr_print_array_uint8(ndr, "hash", r->hash, 16);
2876                 ndr->depth--;
2877                 ndr->flags = _flags_save_STRUCT;
2878         }
2879 }
2880
2881 static enum ndr_err_code ndr_push_samr_UserInfo18(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo18 *r)
2882 {
2883         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2884         if (ndr_flags & NDR_SCALARS) {
2885                 NDR_CHECK(ndr_push_align(ndr, 1));
2886                 NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->nt_pwd));
2887                 NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->lm_pwd));
2888                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->nt_pwd_active));
2889                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->lm_pwd_active));
2890                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
2891                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
2892         }
2893         if (ndr_flags & NDR_BUFFERS) {
2894         }
2895         return NDR_ERR_SUCCESS;
2896 }
2897
2898 static enum ndr_err_code ndr_pull_samr_UserInfo18(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo18 *r)
2899 {
2900         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2901         if (ndr_flags & NDR_SCALARS) {
2902                 NDR_CHECK(ndr_pull_align(ndr, 1));
2903                 NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->nt_pwd));
2904                 NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->lm_pwd));
2905                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->nt_pwd_active));
2906                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->lm_pwd_active));
2907                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
2908                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
2909         }
2910         if (ndr_flags & NDR_BUFFERS) {
2911         }
2912         return NDR_ERR_SUCCESS;
2913 }
2914
2915 _PUBLIC_ void ndr_print_samr_UserInfo18(struct ndr_print *ndr, const char *name, const struct samr_UserInfo18 *r)
2916 {
2917         ndr_print_struct(ndr, name, "samr_UserInfo18");
2918         if (r == NULL) { ndr_print_null(ndr); return; }
2919         ndr->depth++;
2920         ndr_print_samr_Password(ndr, "nt_pwd", &r->nt_pwd);
2921         ndr_print_samr_Password(ndr, "lm_pwd", &r->lm_pwd);
2922         ndr_print_uint8(ndr, "nt_pwd_active", r->nt_pwd_active);
2923         ndr_print_uint8(ndr, "lm_pwd_active", r->lm_pwd_active);
2924         ndr_print_uint8(ndr, "password_expired", r->password_expired);
2925         ndr->depth--;
2926 }
2927
2928 static enum ndr_err_code ndr_push_samr_UserInfo20(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo20 *r)
2929 {
2930         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2931         if (ndr_flags & NDR_SCALARS) {
2932                 NDR_CHECK(ndr_push_align(ndr, 5));
2933                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
2934                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2935         }
2936         if (ndr_flags & NDR_BUFFERS) {
2937                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
2938         }
2939         return NDR_ERR_SUCCESS;
2940 }
2941
2942 static enum ndr_err_code ndr_pull_samr_UserInfo20(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo20 *r)
2943 {
2944         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2945         if (ndr_flags & NDR_SCALARS) {
2946                 NDR_CHECK(ndr_pull_align(ndr, 5));
2947                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
2948                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2949         }
2950         if (ndr_flags & NDR_BUFFERS) {
2951                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
2952         }
2953         return NDR_ERR_SUCCESS;
2954 }
2955
2956 _PUBLIC_ void ndr_print_samr_UserInfo20(struct ndr_print *ndr, const char *name, const struct samr_UserInfo20 *r)
2957 {
2958         ndr_print_struct(ndr, name, "samr_UserInfo20");
2959         if (r == NULL) { ndr_print_null(ndr); return; }
2960         ndr->depth++;
2961         ndr_print_lsa_BinaryString(ndr, "parameters", &r->parameters);
2962         ndr->depth--;
2963 }
2964
2965 static enum ndr_err_code ndr_push_samr_FieldsPresent(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2966 {
2967         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2968         return NDR_ERR_SUCCESS;
2969 }
2970
2971 static enum ndr_err_code ndr_pull_samr_FieldsPresent(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2972 {
2973         uint32_t v;
2974         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2975         *r = v;
2976         return NDR_ERR_SUCCESS;
2977 }
2978
2979 _PUBLIC_ void ndr_print_samr_FieldsPresent(struct ndr_print *ndr, const char *name, uint32_t r)
2980 {
2981         ndr_print_uint32(ndr, name, r);
2982         ndr->depth++;
2983         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCOUNT_NAME", SAMR_FIELD_ACCOUNT_NAME, r);
2984         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_FULL_NAME", SAMR_FIELD_FULL_NAME, r);
2985         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_RID", SAMR_FIELD_RID, r);
2986         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PRIMARY_GID", SAMR_FIELD_PRIMARY_GID, r);
2987         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_DESCRIPTION", SAMR_FIELD_DESCRIPTION, r);
2988         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_COMMENT", SAMR_FIELD_COMMENT, r);
2989         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_HOME_DIRECTORY", SAMR_FIELD_HOME_DIRECTORY, r);
2990         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_HOME_DRIVE", SAMR_FIELD_HOME_DRIVE, r);
2991         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LOGON_SCRIPT", SAMR_FIELD_LOGON_SCRIPT, r);
2992         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PROFILE_PATH", SAMR_FIELD_PROFILE_PATH, r);
2993         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_WORKSTATIONS", SAMR_FIELD_WORKSTATIONS, r);
2994         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_LOGON", SAMR_FIELD_LAST_LOGON, r);
2995         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_LOGOFF", SAMR_FIELD_LAST_LOGOFF, r);
2996         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LOGON_HOURS", SAMR_FIELD_LOGON_HOURS, r);
2997         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_BAD_PWD_COUNT", SAMR_FIELD_BAD_PWD_COUNT, r);
2998         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_NUM_LOGONS", SAMR_FIELD_NUM_LOGONS, r);
2999         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ALLOW_PWD_CHANGE", SAMR_FIELD_ALLOW_PWD_CHANGE, r);
3000         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_FORCE_PWD_CHANGE", SAMR_FIELD_FORCE_PWD_CHANGE, r);
3001         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_PWD_CHANGE", SAMR_FIELD_LAST_PWD_CHANGE, r);
3002         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCT_EXPIRY", SAMR_FIELD_ACCT_EXPIRY, r);
3003         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCT_FLAGS", SAMR_FIELD_ACCT_FLAGS, r);
3004         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PARAMETERS", SAMR_FIELD_PARAMETERS, r);
3005         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_COUNTRY_CODE", SAMR_FIELD_COUNTRY_CODE, r);
3006         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_CODE_PAGE", SAMR_FIELD_CODE_PAGE, r);
3007         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_NT_PASSWORD_PRESENT", SAMR_FIELD_NT_PASSWORD_PRESENT, r);
3008         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LM_PASSWORD_PRESENT", SAMR_FIELD_LM_PASSWORD_PRESENT, r);
3009         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PRIVATE_DATA", SAMR_FIELD_PRIVATE_DATA, r);
3010         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_EXPIRED_FLAG", SAMR_FIELD_EXPIRED_FLAG, r);
3011         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_SEC_DESC", SAMR_FIELD_SEC_DESC, r);
3012         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_OWF_PWD", SAMR_FIELD_OWF_PWD, r);
3013         ndr->depth--;
3014 }
3015
3016 static enum ndr_err_code ndr_push_samr_UserInfo21(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo21 *r)
3017 {
3018         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3019         if (ndr_flags & NDR_SCALARS) {
3020                 NDR_CHECK(ndr_push_align(ndr, 5));
3021                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));
3022                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));
3023                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));
3024                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
3025                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->allow_password_change));
3026                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_password_change));
3027                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
3028                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
3029                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
3030                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
3031                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
3032                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
3033                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
3034                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
3035                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));
3036                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
3037                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->lm_owf_password));
3038                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->nt_owf_password));
3039                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->private_data));
3040                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_count));
3041                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->buffer));
3042                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
3043                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
3044                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
3045                 NDR_CHECK(ndr_push_samr_FieldsPresent(ndr, NDR_SCALARS, r->fields_present));
3046                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
3047                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));
3048                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
3049                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->country_code));
3050                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->code_page));
3051                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->lm_password_set));
3052                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->nt_password_set));
3053                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
3054                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->private_data_sensitive));
3055                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3056         }
3057         if (ndr_flags & NDR_BUFFERS) {
3058                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
3059                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
3060                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
3061                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
3062                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
3063                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
3064                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
3065                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
3066                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));
3067                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
3068                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->lm_owf_password));
3069                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->nt_owf_password));
3070                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->private_data));
3071                 if (r->buffer) {
3072                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->buf_count));
3073                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->buffer, r->buf_count));
3074                 }
3075                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
3076         }
3077         return NDR_ERR_SUCCESS;
3078 }
3079
3080 static enum ndr_err_code ndr_pull_samr_UserInfo21(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo21 *r)
3081 {
3082         uint32_t _ptr_buffer;
3083         uint32_t size_buffer_1 = 0;
3084         TALLOC_CTX *_mem_save_buffer_0;
3085         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3086         if (ndr_flags & NDR_SCALARS) {
3087                 NDR_CHECK(ndr_pull_align(ndr, 5));
3088                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));
3089                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));
3090                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));
3091                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
3092                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->allow_password_change));
3093                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_password_change));
3094                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
3095                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
3096                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
3097                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
3098                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
3099                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
3100                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
3101                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
3102                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));
3103                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
3104                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->lm_owf_password));
3105                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->nt_owf_password));
3106                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->private_data));
3107                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_count));
3108                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
3109                 if (_ptr_buffer) {
3110                         NDR_PULL_ALLOC(ndr, r->buffer);
3111                 } else {
3112                         r->buffer = NULL;
3113                 }
3114                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
3115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
3116                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
3117                 NDR_CHECK(ndr_pull_samr_FieldsPresent(ndr, NDR_SCALARS, &r->fields_present));
3118                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
3119                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));
3120                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
3121                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->country_code));
3122                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->code_page));
3123                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->lm_password_set));
3124                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->nt_password_set));
3125                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
3126                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->private_data_sensitive));
3127                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3128         }
3129         if (ndr_flags & NDR_BUFFERS) {
3130                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
3131                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
3132                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
3133                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
3134                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
3135                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
3136                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
3137                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
3138                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));
3139                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
3140                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->lm_owf_password));
3141                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->nt_owf_password));
3142                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->private_data));
3143                 if (r->buffer) {
3144                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
3145                         NDR_PULL_SET_MEM_CTX(ndr, r->buffer, 0);
3146                         NDR_CHECK(ndr_pull_array_size(ndr, &r->buffer));
3147                         size_buffer_1 = ndr_get_array_size(ndr, &r->buffer);
3148                         NDR_PULL_ALLOC_N(ndr, r->buffer, size_buffer_1);
3149                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->buffer, size_buffer_1));
3150                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
3151                 }
3152                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
3153                 if (r->buffer) {
3154                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->buffer, r->buf_count));
3155                 }
3156         }
3157         return NDR_ERR_SUCCESS;
3158 }
3159
3160 _PUBLIC_ void ndr_print_samr_UserInfo21(struct ndr_print *ndr, const char *name, const struct samr_UserInfo21 *r)
3161 {
3162         ndr_print_struct(ndr, name, "samr_UserInfo21");
3163         if (r == NULL) { ndr_print_null(ndr); return; }
3164         ndr->depth++;
3165         ndr_print_NTTIME(ndr, "last_logon", r->last_logon);
3166         ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);
3167         ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);
3168         ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);
3169         ndr_print_NTTIME(ndr, "allow_password_change", r->allow_password_change);
3170         ndr_print_NTTIME(ndr, "force_password_change", r->force_password_change);
3171         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
3172         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
3173         ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
3174         ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
3175         ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
3176         ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
3177         ndr_print_lsa_String(ndr, "description", &r->description);
3178         ndr_print_lsa_String(ndr, "workstations", &r->workstations);
3179         ndr_print_lsa_String(ndr, "comment", &r->comment);
3180         ndr_print_lsa_BinaryString(ndr, "parameters", &r->parameters);
3181         ndr_print_lsa_BinaryString(ndr, "lm_owf_password", &r->lm_owf_password);
3182         ndr_print_lsa_BinaryString(ndr, "nt_owf_password", &r->nt_owf_password);
3183         ndr_print_lsa_String(ndr, "private_data", &r->private_data);
3184         ndr_print_uint32(ndr, "buf_count", r->buf_count);
3185         ndr_print_ptr(ndr, "buffer", r->buffer);
3186         ndr->depth++;
3187         if (r->buffer) {
3188                 ndr_print_array_uint8(ndr, "buffer", r->buffer, r->buf_count);
3189         }
3190         ndr->depth--;
3191         ndr_print_uint32(ndr, "rid", r->rid);
3192         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
3193         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
3194         ndr_print_samr_FieldsPresent(ndr, "fields_present", r->fields_present);
3195         ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
3196         ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);
3197         ndr_print_uint16(ndr, "logon_count", r->logon_count);
3198         ndr_print_uint16(ndr, "country_code", r->country_code);
3199         ndr_print_uint16(ndr, "code_page", r->code_page);
3200         ndr_print_uint8(ndr, "lm_password_set", r->lm_password_set);
3201         ndr_print_uint8(ndr, "nt_password_set", r->nt_password_set);
3202         ndr_print_uint8(ndr, "password_expired", r->password_expired);
3203         ndr_print_uint8(ndr, "private_data_sensitive", r->private_data_sensitive);
3204         ndr->depth--;
3205 }
3206
3207 _PUBLIC_ enum ndr_err_code ndr_push_samr_CryptPassword(struct ndr_push *ndr, int ndr_flags, const struct samr_CryptPassword *r)
3208 {
3209         {
3210                 uint32_t _flags_save_STRUCT = ndr->flags;
3211                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3212                 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3213                 if (ndr_flags & NDR_SCALARS) {
3214                         NDR_CHECK(ndr_push_align(ndr, 1));
3215                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 516));
3216                         NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3217                 }
3218                 if (ndr_flags & NDR_BUFFERS) {
3219                 }
3220                 ndr->flags = _flags_save_STRUCT;
3221         }
3222         return NDR_ERR_SUCCESS;
3223 }
3224
3225 _PUBLIC_ enum ndr_err_code ndr_pull_samr_CryptPassword(struct ndr_pull *ndr, int ndr_flags, struct samr_CryptPassword *r)
3226 {
3227         uint32_t size_data_0 = 0;
3228         {
3229                 uint32_t _flags_save_STRUCT = ndr->flags;
3230                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3231                 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3232                 if (ndr_flags & NDR_SCALARS) {
3233                         NDR_CHECK(ndr_pull_align(ndr, 1));
3234                         size_data_0 = 516;
3235                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, size_data_0));
3236                         NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3237                 }
3238                 if (ndr_flags & NDR_BUFFERS) {
3239                 }
3240                 ndr->flags = _flags_save_STRUCT;
3241         }
3242         return NDR_ERR_SUCCESS;
3243 }
3244
3245 _PUBLIC_ void ndr_print_samr_CryptPassword(struct ndr_print *ndr, const char *name, const struct samr_CryptPassword *r)
3246 {
3247         ndr_print_struct(ndr, name, "samr_CryptPassword");
3248         if (r == NULL) { ndr_print_null(ndr); return; }
3249         {
3250                 uint32_t _flags_save_STRUCT = ndr->flags;
3251                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3252                 ndr->depth++;
3253                 ndr_print_array_uint8(ndr, "data", r->data, 516);
3254                 ndr->depth--;
3255                 ndr->flags = _flags_save_STRUCT;
3256         }
3257 }
3258
3259 static enum ndr_err_code ndr_push_samr_UserInfo23(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo23 *r)
3260 {
3261         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3262         if (ndr_flags & NDR_SCALARS) {
3263                 NDR_CHECK(ndr_push_align(ndr, 5));
3264                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
3265                 NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
3266                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3267         }
3268         if (ndr_flags & NDR_BUFFERS) {
3269                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
3270         }
3271         return NDR_ERR_SUCCESS;
3272 }
3273
3274 static enum ndr_err_code ndr_pull_samr_UserInfo23(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo23 *r)
3275 {
3276         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3277         if (ndr_flags & NDR_SCALARS) {
3278                 NDR_CHECK(ndr_pull_align(ndr, 5));
3279                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
3280                 NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
3281                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3282         }
3283         if (ndr_flags & NDR_BUFFERS) {
3284                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
3285         }
3286         return NDR_ERR_SUCCESS;
3287 }
3288
3289 _PUBLIC_ void ndr_print_samr_UserInfo23(struct ndr_print *ndr, const char *name, const struct samr_UserInfo23 *r)
3290 {
3291         ndr_print_struct(ndr, name, "samr_UserInfo23");
3292         if (r == NULL) { ndr_print_null(ndr); return; }
3293         ndr->depth++;
3294         ndr_print_samr_UserInfo21(ndr, "info", &r->info);
3295         ndr_print_samr_CryptPassword(ndr, "password", &r->password);
3296         ndr->depth--;
3297 }
3298
3299 static enum ndr_err_code ndr_push_samr_UserInfo24(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo24 *r)
3300 {
3301         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3302         if (ndr_flags & NDR_SCALARS) {
3303                 NDR_CHECK(ndr_push_align(ndr, 1));
3304                 NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
3305                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
3306                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3307         }
3308         if (ndr_flags & NDR_BUFFERS) {
3309         }
3310         return NDR_ERR_SUCCESS;
3311 }
3312
3313 static enum ndr_err_code ndr_pull_samr_UserInfo24(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo24 *r)
3314 {
3315         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3316         if (ndr_flags & NDR_SCALARS) {
3317                 NDR_CHECK(ndr_pull_align(ndr, 1));
3318                 NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
3319                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
3320                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3321         }
3322         if (ndr_flags & NDR_BUFFERS) {
3323         }
3324         return NDR_ERR_SUCCESS;
3325 }
3326
3327 _PUBLIC_ void ndr_print_samr_UserInfo24(struct ndr_print *ndr, const char *name, const struct samr_UserInfo24 *r)
3328 {
3329         ndr_print_struct(ndr, name, "samr_UserInfo24");
3330         if (r == NULL) { ndr_print_null(ndr); return; }
3331         ndr->depth++;
3332         ndr_print_samr_CryptPassword(ndr, "password", &r->password);
3333         ndr_print_uint8(ndr, "password_expired", r->password_expired);
3334         ndr->depth--;
3335 }
3336
3337 static enum ndr_err_code ndr_push_samr_CryptPasswordEx(struct ndr_push *ndr, int ndr_flags, const struct samr_CryptPasswordEx *r)
3338 {
3339         {
3340                 uint32_t _flags_save_STRUCT = ndr->flags;
3341                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3342                 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3343                 if (ndr_flags & NDR_SCALARS) {
3344                         NDR_CHECK(ndr_push_align(ndr, 1));
3345                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 532));
3346                         NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3347                 }
3348                 if (ndr_flags & NDR_BUFFERS) {
3349                 }
3350                 ndr->flags = _flags_save_STRUCT;
3351         }
3352         return NDR_ERR_SUCCESS;
3353 }
3354
3355 static enum ndr_err_code ndr_pull_samr_CryptPasswordEx(struct ndr_pull *ndr, int ndr_flags, struct samr_CryptPasswordEx *r)
3356 {
3357         uint32_t size_data_0 = 0;
3358         {
3359                 uint32_t _flags_save_STRUCT = ndr->flags;
3360                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3361                 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3362                 if (ndr_flags & NDR_SCALARS) {
3363                         NDR_CHECK(ndr_pull_align(ndr, 1));
3364                         size_data_0 = 532;
3365                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, size_data_0));
3366                         NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3367                 }
3368                 if (ndr_flags & NDR_BUFFERS) {
3369                 }
3370                 ndr->flags = _flags_save_STRUCT;
3371         }
3372         return NDR_ERR_SUCCESS;
3373 }
3374
3375 _PUBLIC_ void ndr_print_samr_CryptPasswordEx(struct ndr_print *ndr, const char *name, const struct samr_CryptPasswordEx *r)
3376 {
3377         ndr_print_struct(ndr, name, "samr_CryptPasswordEx");
3378         if (r == NULL) { ndr_print_null(ndr); return; }
3379         {
3380                 uint32_t _flags_save_STRUCT = ndr->flags;
3381                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3382                 ndr->depth++;
3383                 ndr_print_array_uint8(ndr, "data", r->data, 532);
3384                 ndr->depth--;
3385                 ndr->flags = _flags_save_STRUCT;
3386         }
3387 }
3388
3389 static enum ndr_err_code ndr_push_samr_UserInfo25(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo25 *r)
3390 {
3391         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3392         if (ndr_flags & NDR_SCALARS) {
3393                 NDR_CHECK(ndr_push_align(ndr, 5));
3394                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
3395                 NDR_CHECK(ndr_push_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
3396                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3397         }
3398         if (ndr_flags & NDR_BUFFERS) {
3399                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
3400         }
3401         return NDR_ERR_SUCCESS;
3402 }
3403
3404 static enum ndr_err_code ndr_pull_samr_UserInfo25(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo25 *r)
3405 {
3406         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3407         if (ndr_flags & NDR_SCALARS) {
3408                 NDR_CHECK(ndr_pull_align(ndr, 5));
3409                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
3410                 NDR_CHECK(ndr_pull_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
3411                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3412         }
3413         if (ndr_flags & NDR_BUFFERS) {
3414                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
3415         }
3416         return NDR_ERR_SUCCESS;
3417 }
3418
3419 _PUBLIC_ void ndr_print_samr_UserInfo25(struct ndr_print *ndr, const char *name, const struct samr_UserInfo25 *r)
3420 {
3421         ndr_print_struct(ndr, name, "samr_UserInfo25");
3422         if (r == NULL) { ndr_print_null(ndr); return; }
3423         ndr->depth++;
3424         ndr_print_samr_UserInfo21(ndr, "info", &r->info);
3425         ndr_print_samr_CryptPasswordEx(ndr, "password", &r->password);
3426         ndr->depth--;
3427 }
3428
3429 static enum ndr_err_code ndr_push_samr_UserInfo26(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo26 *r)
3430 {
3431         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3432         if (ndr_flags & NDR_SCALARS) {
3433                 NDR_CHECK(ndr_push_align(ndr, 1));
3434                 NDR_CHECK(ndr_push_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
3435                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
3436                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3437         }
3438         if (ndr_flags & NDR_BUFFERS) {
3439         }
3440         return NDR_ERR_SUCCESS;
3441 }
3442
3443 static enum ndr_err_code ndr_pull_samr_UserInfo26(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo26 *r)
3444 {
3445         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3446         if (ndr_flags & NDR_SCALARS) {
3447                 NDR_CHECK(ndr_pull_align(ndr, 1));
3448                 NDR_CHECK(ndr_pull_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
3449                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
3450                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3451         }
3452         if (ndr_flags & NDR_BUFFERS) {
3453         }
3454         return NDR_ERR_SUCCESS;
3455 }
3456
3457 _PUBLIC_ void ndr_print_samr_UserInfo26(struct ndr_print *ndr, const char *name, const struct samr_UserInfo26 *r)
3458 {
3459         ndr_print_struct(ndr, name, "samr_UserInfo26");
3460         if (r == NULL) { ndr_print_null(ndr); return; }
3461         ndr->depth++;
3462         ndr_print_samr_CryptPasswordEx(ndr, "password", &r->password);
3463         ndr_print_uint8(ndr, "password_expired", r->password_expired);
3464         ndr->depth--;
3465 }
3466
3467 static enum ndr_err_code ndr_push_samr_UserInfo(struct ndr_push *ndr, int ndr_flags, const union samr_UserInfo *r)
3468 {
3469         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3470         if (ndr_flags & NDR_SCALARS) {
3471                 uint32_t level = ndr_push_get_switch_value(ndr, r);
3472                 NDR_CHECK(ndr_push_union_align(ndr, 5));
3473                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
3474                 NDR_CHECK(ndr_push_union_align(ndr, 5));
3475                 switch (level) {
3476                         case 1: {
3477                                 NDR_CHECK(ndr_push_samr_UserInfo1(ndr, NDR_SCALARS, &r->info1));
3478                         break; }
3479
3480                         case 2: {
3481                                 NDR_CHECK(ndr_push_samr_UserInfo2(ndr, NDR_SCALARS, &r->info2));
3482                         break; }
3483
3484                         case 3: {
3485                                 NDR_CHECK(ndr_push_samr_UserInfo3(ndr, NDR_SCALARS, &r->info3));
3486                         break; }
3487
3488                         case 4: {
3489                                 NDR_CHECK(ndr_push_samr_UserInfo4(ndr, NDR_SCALARS, &r->info4));
3490                         break; }
3491
3492                         case 5: {
3493                                 NDR_CHECK(ndr_push_samr_UserInfo5(ndr, NDR_SCALARS, &r->info5));
3494                         break; }
3495
3496                         case 6: {
3497                                 NDR_CHECK(ndr_push_samr_UserInfo6(ndr, NDR_SCALARS, &r->info6));
3498                         break; }
3499
3500                         case 7: {
3501                                 NDR_CHECK(ndr_push_samr_UserInfo7(ndr, NDR_SCALARS, &r->info7));
3502                         break; }
3503
3504                         case 8: {
3505                                 NDR_CHECK(ndr_push_samr_UserInfo8(ndr, NDR_SCALARS, &r->info8));
3506                         break; }
3507
3508                         case 9: {
3509                                 NDR_CHECK(ndr_push_samr_UserInfo9(ndr, NDR_SCALARS, &r->info9));
3510                         break; }
3511
3512                         case 10: {
3513                                 NDR_CHECK(ndr_push_samr_UserInfo10(ndr, NDR_SCALARS, &r->info10));
3514                         break; }
3515
3516                         case 11: {
3517                                 NDR_CHECK(ndr_push_samr_UserInfo11(ndr, NDR_SCALARS, &r->info11));
3518                         break; }
3519
3520                         case 12: {
3521                                 NDR_CHECK(ndr_push_samr_UserInfo12(ndr, NDR_SCALARS, &r->info12));
3522                         break; }
3523
3524                         case 13: {
3525                                 NDR_CHECK(ndr_push_samr_UserInfo13(ndr, NDR_SCALARS, &r->info13));
3526                         break; }
3527
3528                         case 14: {
3529                                 NDR_CHECK(ndr_push_samr_UserInfo14(ndr, NDR_SCALARS, &r->info14));
3530                         break; }
3531
3532                         case 16: {
3533                                 NDR_CHECK(ndr_push_samr_UserInfo16(ndr, NDR_SCALARS, &r->info16));
3534                         break; }
3535
3536                         case 17: {
3537                                 NDR_CHECK(ndr_push_samr_UserInfo17(ndr, NDR_SCALARS, &r->info17));
3538                         break; }
3539
3540                         case 18: {
3541                                 NDR_CHECK(ndr_push_samr_UserInfo18(ndr, NDR_SCALARS, &r->info18));
3542                         break; }
3543
3544                         case 20: {
3545                                 NDR_CHECK(ndr_push_samr_UserInfo20(ndr, NDR_SCALARS, &r->info20));
3546                         break; }
3547
3548                         case 21: {
3549                                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info21));
3550                         break; }
3551
3552                         case 23: {
3553                                 NDR_CHECK(ndr_push_samr_UserInfo23(ndr, NDR_SCALARS, &r->info23));
3554                         break; }
3555
3556                         case 24: {
3557                                 NDR_CHECK(ndr_push_samr_UserInfo24(ndr, NDR_SCALARS, &r->info24));
3558                         break; }
3559
3560                         case 25: {
3561                                 NDR_CHECK(ndr_push_samr_UserInfo25(ndr, NDR_SCALARS, &r->info25));
3562                         break; }
3563
3564                         case 26: {
3565                                 NDR_CHECK(ndr_push_samr_UserInfo26(ndr, NDR_SCALARS, &r->info26));
3566                         break; }
3567
3568                         default:
3569                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3570                 }
3571         }
3572         if (ndr_flags & NDR_BUFFERS) {
3573                 uint32_t level = ndr_push_get_switch_value(ndr, r);
3574                 switch (level) {
3575                         case 1:
3576                                 NDR_CHECK(ndr_push_samr_UserInfo1(ndr, NDR_BUFFERS, &r->info1));
3577                         break;
3578
3579                         case 2:
3580                                 NDR_CHECK(ndr_push_samr_UserInfo2(ndr, NDR_BUFFERS, &r->info2));
3581                         break;
3582
3583                         case 3:
3584                                 NDR_CHECK(ndr_push_samr_UserInfo3(ndr, NDR_BUFFERS, &r->info3));
3585                         break;
3586
3587                         case 4:
3588                                 NDR_CHECK(ndr_push_samr_UserInfo4(ndr, NDR_BUFFERS, &r->info4));
3589                         break;
3590
3591                         case 5:
3592                                 NDR_CHECK(ndr_push_samr_UserInfo5(ndr, NDR_BUFFERS, &r->info5));
3593                         break;
3594
3595                         case 6:
3596                                 NDR_CHECK(ndr_push_samr_UserInfo6(ndr, NDR_BUFFERS, &r->info6));
3597                         break;
3598
3599                         case 7:
3600                                 NDR_CHECK(ndr_push_samr_UserInfo7(ndr, NDR_BUFFERS, &r->info7));
3601                         break;
3602
3603                         case 8:
3604                                 NDR_CHECK(ndr_push_samr_UserInfo8(ndr, NDR_BUFFERS, &r->info8));
3605                         break;
3606
3607                         case 9:
3608                         break;
3609
3610                         case 10:
3611                                 NDR_CHECK(ndr_push_samr_UserInfo10(ndr, NDR_BUFFERS, &r->info10));
3612                         break;
3613
3614                         case 11:
3615                                 NDR_CHECK(ndr_push_samr_UserInfo11(ndr, NDR_BUFFERS, &r->info11));
3616                         break;
3617
3618                         case 12:
3619                                 NDR_CHECK(ndr_push_samr_UserInfo12(ndr, NDR_BUFFERS, &r->info12));
3620                         break;
3621
3622                         case 13:
3623                                 NDR_CHECK(ndr_push_samr_UserInfo13(ndr, NDR_BUFFERS, &r->info13));
3624                         break;
3625
3626                         case 14:
3627                                 NDR_CHECK(ndr_push_samr_UserInfo14(ndr, NDR_BUFFERS, &r->info14));
3628                         break;
3629
3630                         case 16:
3631                         break;
3632
3633                         case 17:
3634                         break;
3635
3636                         case 18:
3637                         break;
3638
3639                         case 20:
3640                                 NDR_CHECK(ndr_push_samr_UserInfo20(ndr, NDR_BUFFERS, &r->info20));
3641                         break;
3642
3643                         case 21:
3644                                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info21));
3645                         break;
3646
3647                         case 23:
3648                                 NDR_CHECK(ndr_push_samr_UserInfo23(ndr, NDR_BUFFERS, &r->info23));
3649                         break;
3650
3651                         case 24:
3652                         break;
3653
3654                         case 25:
3655                                 NDR_CHECK(ndr_push_samr_UserInfo25(ndr, NDR_BUFFERS, &r->info25));
3656                         break;
3657
3658                         case 26:
3659                         break;
3660
3661                         default:
3662                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3663                 }
3664         }
3665         return NDR_ERR_SUCCESS;
3666 }
3667
3668 static enum ndr_err_code ndr_pull_samr_UserInfo(struct ndr_pull *ndr, int ndr_flags, union samr_UserInfo *r)
3669 {
3670         uint32_t level;
3671         uint16_t _level;
3672         level = ndr_pull_get_switch_value(ndr, r);
3673         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3674         if (ndr_flags & NDR_SCALARS) {
3675                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
3676                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
3677                 if (_level != level) {
3678                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3679                 }
3680                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
3681                 switch (level) {
3682                         case 1: {
3683                                 NDR_CHECK(ndr_pull_samr_UserInfo1(ndr, NDR_SCALARS, &r->info1));
3684                         break; }
3685
3686                         case 2: {
3687                                 NDR_CHECK(ndr_pull_samr_UserInfo2(ndr, NDR_SCALARS, &r->info2));
3688                         break; }
3689
3690                         case 3: {
3691                                 NDR_CHECK(ndr_pull_samr_UserInfo3(ndr, NDR_SCALARS, &r->info3));
3692                         break; }
3693
3694                         case 4: {
3695                                 NDR_CHECK(ndr_pull_samr_UserInfo4(ndr, NDR_SCALARS, &r->info4));
3696                         break; }
3697
3698                         case 5: {
3699                                 NDR_CHECK(ndr_pull_samr_UserInfo5(ndr, NDR_SCALARS, &r->info5));
3700                         break; }
3701
3702                         case 6: {
3703                                 NDR_CHECK(ndr_pull_samr_UserInfo6(ndr, NDR_SCALARS, &r->info6));
3704                         break; }
3705
3706                         case 7: {
3707                                 NDR_CHECK(ndr_pull_samr_UserInfo7(ndr, NDR_SCALARS, &r->info7));
3708                         break; }
3709
3710                         case 8: {
3711                                 NDR_CHECK(ndr_pull_samr_UserInfo8(ndr, NDR_SCALARS, &r->info8));
3712                         break; }
3713
3714                         case 9: {
3715                                 NDR_CHECK(ndr_pull_samr_UserInfo9(ndr, NDR_SCALARS, &r->info9));
3716                         break; }
3717
3718                         case 10: {
3719                                 NDR_CHECK(ndr_pull_samr_UserInfo10(ndr, NDR_SCALARS, &r->info10));
3720                         break; }
3721
3722                         case 11: {
3723                                 NDR_CHECK(ndr_pull_samr_UserInfo11(ndr, NDR_SCALARS, &r->info11));
3724                         break; }
3725
3726                         case 12: {
3727                                 NDR_CHECK(ndr_pull_samr_UserInfo12(ndr, NDR_SCALARS, &r->info12));
3728                         break; }
3729
3730                         case 13: {
3731                                 NDR_CHECK(ndr_pull_samr_UserInfo13(ndr, NDR_SCALARS, &r->info13));
3732                         break; }
3733
3734                         case 14: {
3735                                 NDR_CHECK(ndr_pull_samr_UserInfo14(ndr, NDR_SCALARS, &r->info14));
3736                         break; }
3737
3738                         case 16: {
3739                                 NDR_CHECK(ndr_pull_samr_UserInfo16(ndr, NDR_SCALARS, &r->info16));
3740                         break; }
3741
3742                         case 17: {
3743                                 NDR_CHECK(ndr_pull_samr_UserInfo17(ndr, NDR_SCALARS, &r->info17));
3744                         break; }
3745
3746                         case 18: {
3747                                 NDR_CHECK(ndr_pull_samr_UserInfo18(ndr, NDR_SCALARS, &r->info18));
3748                         break; }
3749
3750                         case 20: {
3751                                 NDR_CHECK(ndr_pull_samr_UserInfo20(ndr, NDR_SCALARS, &r->info20));
3752                         break; }
3753
3754                         case 21: {
3755                                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info21));
3756                         break; }
3757
3758                         case 23: {
3759                                 NDR_CHECK(ndr_pull_samr_UserInfo23(ndr, NDR_SCALARS, &r->info23));
3760                         break; }
3761
3762                         case 24: {
3763                                 NDR_CHECK(ndr_pull_samr_UserInfo24(ndr, NDR_SCALARS, &r->info24));
3764                         break; }
3765
3766                         case 25: {
3767                                 NDR_CHECK(ndr_pull_samr_UserInfo25(ndr, NDR_SCALARS, &r->info25));
3768                         break; }
3769
3770                         case 26: {
3771                                 NDR_CHECK(ndr_pull_samr_UserInfo26(ndr, NDR_SCALARS, &r->info26));
3772                         break; }
3773
3774                         default:
3775                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3776                 }
3777         }
3778         if (ndr_flags & NDR_BUFFERS) {
3779                 switch (level) {
3780                         case 1:
3781                                 NDR_CHECK(ndr_pull_samr_UserInfo1(ndr, NDR_BUFFERS, &r->info1));
3782                         break;
3783
3784                         case 2:
3785                                 NDR_CHECK(ndr_pull_samr_UserInfo2(ndr, NDR_BUFFERS, &r->info2));
3786                         break;
3787
3788                         case 3:
3789                                 NDR_CHECK(ndr_pull_samr_UserInfo3(ndr, NDR_BUFFERS, &r->info3));
3790                         break;
3791
3792                         case 4:
3793                                 NDR_CHECK(ndr_pull_samr_UserInfo4(ndr, NDR_BUFFERS, &r->info4));
3794                         break;
3795
3796                         case 5:
3797                                 NDR_CHECK(ndr_pull_samr_UserInfo5(ndr, NDR_BUFFERS, &r->info5));
3798                         break;
3799
3800                         case 6:
3801                                 NDR_CHECK(ndr_pull_samr_UserInfo6(ndr, NDR_BUFFERS, &r->info6));
3802                         break;
3803
3804                         case 7:
3805                                 NDR_CHECK(ndr_pull_samr_UserInfo7(ndr, NDR_BUFFERS, &r->info7));
3806                         break;
3807
3808                         case 8:
3809                                 NDR_CHECK(ndr_pull_samr_UserInfo8(ndr, NDR_BUFFERS, &r->info8));
3810                         break;
3811
3812                         case 9:
3813                         break;
3814
3815                         case 10:
3816                                 NDR_CHECK(ndr_pull_samr_UserInfo10(ndr, NDR_BUFFERS, &r->info10));
3817                         break;
3818
3819                         case 11:
3820                                 NDR_CHECK(ndr_pull_samr_UserInfo11(ndr, NDR_BUFFERS, &r->info11));
3821                         break;
3822
3823                         case 12:
3824                                 NDR_CHECK(ndr_pull_samr_UserInfo12(ndr, NDR_BUFFERS, &r->info12));
3825                         break;
3826
3827                         case 13:
3828                                 NDR_CHECK(ndr_pull_samr_UserInfo13(ndr, NDR_BUFFERS, &r->info13));
3829                         break;
3830
3831                         case 14:
3832                                 NDR_CHECK(ndr_pull_samr_UserInfo14(ndr, NDR_BUFFERS, &r->info14));
3833                         break;
3834
3835                         case 16:
3836                         break;
3837
3838                         case 17:
3839                         break;
3840
3841                         case 18:
3842                         break;
3843
3844                         case 20:
3845                                 NDR_CHECK(ndr_pull_samr_UserInfo20(ndr, NDR_BUFFERS, &r->info20));
3846                         break;
3847
3848                         case 21:
3849                                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info21));
3850                         break;
3851
3852                         case 23:
3853                                 NDR_CHECK(ndr_pull_samr_UserInfo23(ndr, NDR_BUFFERS, &r->info23));
3854                         break;
3855
3856                         case 24:
3857                         break;
3858
3859                         case 25:
3860                                 NDR_CHECK(ndr_pull_samr_UserInfo25(ndr, NDR_BUFFERS, &r->info25));
3861                         break;
3862
3863                         case 26:
3864                         break;
3865
3866                         default:
3867                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3868                 }
3869         }
3870         return NDR_ERR_SUCCESS;
3871 }
3872
3873 _PUBLIC_ void ndr_print_samr_UserInfo(struct ndr_print *ndr, const char *name, const union samr_UserInfo *r)
3874 {
3875         uint32_t level;
3876         level = ndr_print_get_switch_value(ndr, r);
3877         ndr_print_union(ndr, name, level, "samr_UserInfo");
3878         switch (level) {
3879                 case 1:
3880                         ndr_print_samr_UserInfo1(ndr, "info1", &r->info1);
3881                 break;
3882
3883                 case 2:
3884                         ndr_print_samr_UserInfo2(ndr, "info2", &r->info2);
3885                 break;
3886
3887                 case 3:
3888                         ndr_print_samr_UserInfo3(ndr, "info3", &r->info3);
3889                 break;
3890
3891                 case 4:
3892                         ndr_print_samr_UserInfo4(ndr, "info4", &r->info4);
3893                 break;
3894
3895                 case 5:
3896                         ndr_print_samr_UserInfo5(ndr, "info5", &r->info5);
3897                 break;
3898
3899                 case 6:
3900                         ndr_print_samr_UserInfo6(ndr, "info6", &r->info6);
3901                 break;
3902
3903                 case 7:
3904                         ndr_print_samr_UserInfo7(ndr, "info7", &r->info7);
3905                 break;
3906
3907                 case 8:
3908                         ndr_print_samr_UserInfo8(ndr, "info8", &r->info8);
3909                 break;
3910
3911                 case 9:
3912                         ndr_print_samr_UserInfo9(ndr, "info9", &r->info9);
3913                 break;
3914
3915                 case 10:
3916                         ndr_print_samr_UserInfo10(ndr, "info10", &r->info10);
3917                 break;
3918
3919                 case 11:
3920                         ndr_print_samr_UserInfo11(ndr, "info11", &r->info11);
3921                 break;
3922
3923                 case 12:
3924                         ndr_print_samr_UserInfo12(ndr, "info12", &r->info12);
3925                 break;
3926
3927                 case 13:
3928                         ndr_print_samr_UserInfo13(ndr, "info13", &r->info13);
3929                 break;
3930
3931                 case 14:
3932                         ndr_print_samr_UserInfo14(ndr, "info14", &r->info14);
3933                 break;
3934
3935                 case 16:
3936                         ndr_print_samr_UserInfo16(ndr, "info16", &r->info16);
3937                 break;
3938
3939                 case 17:
3940                         ndr_print_samr_UserInfo17(ndr, "info17", &r->info17);
3941                 break;
3942
3943                 case 18:
3944                         ndr_print_samr_UserInfo18(ndr, "info18", &r->info18);
3945                 break;
3946
3947                 case 20:
3948                         ndr_print_samr_UserInfo20(ndr, "info20", &r->info20);
3949                 break;
3950
3951                 case 21:
3952                         ndr_print_samr_UserInfo21(ndr, "info21", &r->info21);
3953                 break;
3954
3955                 case 23:
3956                         ndr_print_samr_UserInfo23(ndr, "info23", &r->info23);
3957                 break;
3958
3959                 case 24:
3960                         ndr_print_samr_UserInfo24(ndr, "info24", &r->info24);
3961                 break;
3962
3963                 case 25:
3964                         ndr_print_samr_UserInfo25(ndr, "info25", &r->info25);
3965                 break;
3966
3967                 case 26:
3968                         ndr_print_samr_UserInfo26(ndr, "info26", &r->info26);
3969                 break;
3970
3971                 default:
3972                         ndr_print_bad_level(ndr, name, level);
3973         }
3974 }
3975
3976 _PUBLIC_ enum ndr_err_code ndr_push_samr_RidWithAttribute(struct ndr_push *ndr, int ndr_flags, const struct samr_RidWithAttribute *r)
3977 {
3978         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3979         if (ndr_flags & NDR_SCALARS) {
3980                 NDR_CHECK(ndr_push_align(ndr, 4));
3981                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
3982                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
3983                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
3984         }
3985         if (ndr_flags & NDR_BUFFERS) {
3986         }
3987         return NDR_ERR_SUCCESS;
3988 }
3989
3990 _PUBLIC_ enum ndr_err_code ndr_pull_samr_RidWithAttribute(struct ndr_pull *ndr, int ndr_flags, struct samr_RidWithAttribute *r)
3991 {
3992         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3993         if (ndr_flags & NDR_SCALARS) {
3994                 NDR_CHECK(ndr_pull_align(ndr, 4));
3995                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
3996                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
3997                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
3998         }
3999         if (ndr_flags & NDR_BUFFERS) {
4000         }
4001         return NDR_ERR_SUCCESS;
4002 }
4003
4004 _PUBLIC_ void ndr_print_samr_RidWithAttribute(struct ndr_print *ndr, const char *name, const struct samr_RidWithAttribute *r)
4005 {
4006         ndr_print_struct(ndr, name, "samr_RidWithAttribute");
4007         if (r == NULL) { ndr_print_null(ndr); return; }
4008         ndr->depth++;
4009         ndr_print_uint32(ndr, "rid", r->rid);
4010         ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);
4011         ndr->depth--;
4012 }
4013
4014 _PUBLIC_ enum ndr_err_code ndr_push_samr_RidWithAttributeArray(struct ndr_push *ndr, int ndr_flags, const struct samr_RidWithAttributeArray *r)
4015 {
4016         uint32_t cntr_rids_1;
4017         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
4018         if (ndr_flags & NDR_SCALARS) {
4019                 NDR_CHECK(ndr_push_align(ndr, 5));
4020                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4021                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->rids));
4022                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4023         }
4024         if (ndr_flags & NDR_BUFFERS) {
4025                 if (r->rids) {
4026                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
4027                         for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {
4028                                 NDR_CHECK(ndr_push_samr_RidWithAttribute(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));
4029                         }
4030                 }
4031         }
4032         return NDR_ERR_SUCCESS;
4033 }
4034
4035 _PUBLIC_ enum ndr_err_code ndr_pull_samr_RidWithAttributeArray(struct ndr_pull *ndr, int ndr_flags, struct samr_RidWithAttributeArray *r)
4036 {
4037         uint32_t _ptr_rids;
4038         uint32_t size_rids_1 = 0;
4039         uint32_t cntr_rids_1;
4040         TALLOC_CTX *_mem_save_rids_0;
4041         TALLOC_CTX *_mem_save_rids_1;
4042         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
4043         if (ndr_flags & NDR_SCALARS) {
4044                 NDR_CHECK(ndr_pull_align(ndr, 5));
4045                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4046                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
4047                 if (_ptr_rids) {
4048                         NDR_PULL_ALLOC(ndr, r->rids);
4049                 } else {
4050                         r->rids = NULL;
4051                 }
4052                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4053         }
4054         if (ndr_flags & NDR_BUFFERS) {
4055                 if (r->rids) {
4056                         _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
4057                         NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
4058                         NDR_CHECK(ndr_pull_array_size(ndr, &r->rids));
4059                         size_rids_1 = ndr_get_array_size(ndr, &r->rids);
4060                         NDR_PULL_ALLOC_N(ndr, r->rids, size_rids_1);
4061                         _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
4062                         NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
4063                         for (cntr_rids_1 = 0; cntr_rids_1 < size_rids_1; cntr_rids_1++) {
4064                                 NDR_CHECK(ndr_pull_samr_RidWithAttribute(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));
4065                         }
4066                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
4067                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
4068                 }
4069                 if (r->rids) {
4070                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->rids, r->count));
4071                 }
4072         }
4073         return NDR_ERR_SUCCESS;
4074 }
4075
4076 _PUBLIC_ void ndr_print_samr_RidWithAttributeArray(struct ndr_print *ndr, const char *name, const struct samr_RidWithAttributeArray *r)
4077 {
4078         uint32_t cntr_rids_1;
4079         ndr_print_struct(ndr, name, "samr_RidWithAttributeArray");
4080         if (r == NULL) { ndr_print_null(ndr); return; }
4081         ndr->depth++;
4082         ndr_print_uint32(ndr, "count", r->count);
4083         ndr_print_ptr(ndr, "rids", r->rids);
4084         ndr->depth++;
4085         if (r->rids) {
4086                 ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->count);
4087                 ndr->depth++;
4088                 for (cntr_rids_1=0;cntr_rids_1<r->count;cntr_rids_1++) {
4089                         ndr_print_samr_RidWithAttribute(ndr, "rids", &r->rids[cntr_rids_1]);
4090                 }
4091                 ndr->depth--;
4092         }
4093         ndr->depth--;
4094         ndr->depth--;
4095 }
4096
4097 static enum ndr_err_code ndr_push_samr_DispEntryGeneral(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryGeneral *r)
4098 {
4099         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
4100         if (ndr_flags & NDR_SCALARS) {
4101                 NDR_CHECK(ndr_push_align(ndr, 5));
4102                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
4103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
4104                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
4105                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
4106                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
4107                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
4108                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4109         }
4110         if (ndr_flags & NDR_BUFFERS) {
4111                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
4112                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
4113                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
4114         }
4115         return NDR_ERR_SUCCESS;
4116 }
4117
4118 static enum ndr_err_code ndr_pull_samr_DispEntryGeneral(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryGeneral *r)
4119 {
4120         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
4121         if (ndr_flags & NDR_SCALARS) {
4122                 NDR_CHECK(ndr_pull_align(ndr, 5));
4123                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
4124                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
4125                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
4126                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
4127                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
4128                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
4129                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4130         }
4131         if (ndr_flags & NDR_BUFFERS) {
4132                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
4133                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
4134                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
4135         }
4136         return NDR_ERR_SUCCESS;
4137 }
4138
4139 _PUBLIC_ void ndr_print_samr_DispEntryGeneral(struct ndr_print *ndr, const char *name, const struct samr_DispEntryGeneral *r)
4140 {
4141         ndr_print_struct(ndr, name, "samr_DispEntryGeneral");
4142         if (r == NULL) { ndr_print_null(ndr); return; }
4143         ndr->depth++;
4144         ndr_print_uint32(ndr, "idx", r->idx);
4145         ndr_print_uint32(ndr, "rid", r->rid);
4146         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
4147         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
4148         ndr_print_lsa_String(ndr, "description", &r->description);
4149         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
4150         ndr->depth--;
4151 }
4152
4153 static enum ndr_err_code ndr_push_samr_DispInfoGeneral(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoGeneral *r)
4154 {
4155         uint32_t cntr_entries_1;
4156         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
4157         if (ndr_flags & NDR_SCALARS) {
4158                 NDR_CHECK(ndr_push_align(ndr, 5));
4159                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4160                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
4161                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4162         }
4163         if (ndr_flags & NDR_BUFFERS) {
4164                 if (r->entries) {
4165                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
4166                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4167                                 NDR_CHECK(ndr_push_samr_DispEntryGeneral(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4168                         }
4169                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4170                                 NDR_CHECK(ndr_push_samr_DispEntryGeneral(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4171                         }
4172                 }
4173         }
4174         return NDR_ERR_SUCCESS;
4175 }
4176
4177 static enum ndr_err_code ndr_pull_samr_DispInfoGeneral(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoGeneral *r)
4178 {
4179         uint32_t _ptr_entries;
4180         uint32_t size_entries_1 = 0;
4181         uint32_t cntr_entries_1;
4182         TALLOC_CTX *_mem_save_entries_0;
4183         TALLOC_CTX *_mem_save_entries_1;
4184         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
4185         if (ndr_flags & NDR_SCALARS) {
4186                 NDR_CHECK(ndr_pull_align(ndr, 5));
4187                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4188                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
4189                 if (_ptr_entries) {
4190                         NDR_PULL_ALLOC(ndr, r->entries);
4191                 } else {
4192                         r->entries = NULL;
4193                 }
4194                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4195         }
4196         if (ndr_flags & NDR_BUFFERS) {
4197                 if (r->entries) {
4198                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
4199                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4200                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
4201                         size_entries_1 = ndr_get_array_size(ndr, &r->entries);
4202                         NDR_PULL_ALLOC_N(ndr, r->entries, size_entries_1);
4203                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
4204                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4205                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
4206                                 NDR_CHECK(ndr_pull_samr_DispEntryGeneral(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4207                         }
4208                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
4209                                 NDR_CHECK(ndr_pull_samr_DispEntryGeneral(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4210                         }
4211                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
4212                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
4213                 }
4214                 if (r->entries) {
4215                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
4216                 }
4217         }
4218         return NDR_ERR_SUCCESS;
4219 }
4220
4221 _PUBLIC_ void ndr_print_samr_DispInfoGeneral(struct ndr_print *ndr, const char *name, const struct samr_DispInfoGeneral *r)
4222 {
4223         uint32_t cntr_entries_1;
4224         ndr_print_struct(ndr, name, "samr_DispInfoGeneral");
4225         if (r == NULL) { ndr_print_null(ndr); return; }
4226         ndr->depth++;
4227         ndr_print_uint32(ndr, "count", r->count);
4228         ndr_print_ptr(ndr, "entries", r->entries);
4229         ndr->depth++;
4230         if (r->entries) {
4231                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
4232                 ndr->depth++;
4233                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
4234                         ndr_print_samr_DispEntryGeneral(ndr, "entries", &r->entries[cntr_entries_1]);
4235                 }
4236                 ndr->depth--;
4237         }
4238         ndr->depth--;
4239         ndr->depth--;
4240 }
4241
4242 static enum ndr_err_code ndr_push_samr_DispEntryFull(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryFull *r)
4243 {
4244         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
4245         if (ndr_flags & NDR_SCALARS) {
4246                 NDR_CHECK(ndr_push_align(ndr, 5));
4247                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
4248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
4249                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
4250                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
4251                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
4252                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4253         }
4254         if (ndr_flags & NDR_BUFFERS) {
4255                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
4256                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
4257         }
4258         return NDR_ERR_SUCCESS;
4259 }
4260
4261 static enum ndr_err_code ndr_pull_samr_DispEntryFull(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryFull *r)
4262 {
4263         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
4264         if (ndr_flags & NDR_SCALARS) {
4265                 NDR_CHECK(ndr_pull_align(ndr, 5));
4266                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
4267                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
4268                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
4269                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
4270                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
4271                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4272         }
4273         if (ndr_flags & NDR_BUFFERS) {
4274                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
4275                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
4276         }
4277         return NDR_ERR_SUCCESS;
4278 }
4279
4280 _PUBLIC_ void ndr_print_samr_DispEntryFull(struct ndr_print *ndr, const char *name, const struct samr_DispEntryFull *r)
4281 {
4282         ndr_print_struct(ndr, name, "samr_DispEntryFull");
4283         if (r == NULL) { ndr_print_null(ndr); return; }
4284         ndr->depth++;
4285         ndr_print_uint32(ndr, "idx", r->idx);
4286         ndr_print_uint32(ndr, "rid", r->rid);
4287         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
4288         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
4289         ndr_print_lsa_String(ndr, "description", &r->description);
4290         ndr->depth--;
4291 }
4292
4293 static enum ndr_err_code ndr_push_samr_DispInfoFull(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoFull *r)
4294 {
4295         uint32_t cntr_entries_1;
4296         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
4297         if (ndr_flags & NDR_SCALARS) {
4298                 NDR_CHECK(ndr_push_align(ndr, 5));
4299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4300                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
4301                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4302         }
4303         if (ndr_flags & NDR_BUFFERS) {
4304                 if (r->entries) {
4305                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
4306                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4307                                 NDR_CHECK(ndr_push_samr_DispEntryFull(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4308                         }
4309                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4310                                 NDR_CHECK(ndr_push_samr_DispEntryFull(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4311                         }
4312                 }
4313         }
4314         return NDR_ERR_SUCCESS;
4315 }
4316
4317 static enum ndr_err_code ndr_pull_samr_DispInfoFull(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoFull *r)
4318 {
4319         uint32_t _ptr_entries;
4320         uint32_t size_entries_1 = 0;
4321         uint32_t cntr_entries_1;
4322         TALLOC_CTX *_mem_save_entries_0;
4323         TALLOC_CTX *_mem_save_entries_1;
4324         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
4325         if (ndr_flags & NDR_SCALARS) {
4326                 NDR_CHECK(ndr_pull_align(ndr, 5));
4327                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4328                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
4329                 if (_ptr_entries) {
4330                         NDR_PULL_ALLOC(ndr, r->entries);
4331                 } else {
4332                         r->entries = NULL;
4333                 }
4334                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4335         }
4336         if (ndr_flags & NDR_BUFFERS) {
4337                 if (r->entries) {
4338                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
4339                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4340                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
4341                         size_entries_1 = ndr_get_array_size(ndr, &r->entries);
4342                         NDR_PULL_ALLOC_N(ndr, r->entries, size_entries_1);
4343                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
4344                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4345                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
4346                                 NDR_CHECK(ndr_pull_samr_DispEntryFull(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4347                         }
4348                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
4349                                 NDR_CHECK(ndr_pull_samr_DispEntryFull(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4350                         }
4351                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
4352                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
4353                 }
4354                 if (r->entries) {
4355                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
4356                 }
4357         }
4358         return NDR_ERR_SUCCESS;
4359 }
4360
4361 _PUBLIC_ void ndr_print_samr_DispInfoFull(struct ndr_print *ndr, const char *name, const struct samr_DispInfoFull *r)
4362 {
4363         uint32_t cntr_entries_1;
4364         ndr_print_struct(ndr, name, "samr_DispInfoFull");
4365         if (r == NULL) { ndr_print_null(ndr); return; }
4366         ndr->depth++;
4367         ndr_print_uint32(ndr, "count", r->count);
4368         ndr_print_ptr(ndr, "entries", r->entries);
4369         ndr->depth++;
4370         if (r->entries) {
4371                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
4372                 ndr->depth++;
4373                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
4374                         ndr_print_samr_DispEntryFull(ndr, "entries", &r->entries[cntr_entries_1]);
4375                 }
4376                 ndr->depth--;
4377         }
4378         ndr->depth--;
4379         ndr->depth--;
4380 }
4381
4382 static enum ndr_err_code ndr_push_samr_DispEntryFullGroup(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryFullGroup *r)
4383 {
4384         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
4385         if (ndr_flags & NDR_SCALARS) {
4386                 NDR_CHECK(ndr_push_align(ndr, 5));
4387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
4388                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
4389                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->acct_flags));
4390                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
4391                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
4392                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4393         }
4394         if (ndr_flags & NDR_BUFFERS) {
4395                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
4396                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
4397         }
4398         return NDR_ERR_SUCCESS;
4399 }
4400
4401 static enum ndr_err_code ndr_pull_samr_DispEntryFullGroup(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryFullGroup *r)
4402 {
4403         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
4404         if (ndr_flags & NDR_SCALARS) {
4405                 NDR_CHECK(ndr_pull_align(ndr, 5));
4406                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
4407                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
4408                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->acct_flags));
4409                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
4410                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
4411                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4412         }
4413         if (ndr_flags & NDR_BUFFERS) {
4414                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
4415                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
4416         }
4417         return NDR_ERR_SUCCESS;
4418 }
4419
4420 _PUBLIC_ void ndr_print_samr_DispEntryFullGroup(struct ndr_print *ndr, const char *name, const struct samr_DispEntryFullGroup *r)
4421 {
4422         ndr_print_struct(ndr, name, "samr_DispEntryFullGroup");
4423         if (r == NULL) { ndr_print_null(ndr); return; }
4424         ndr->depth++;
4425         ndr_print_uint32(ndr, "idx", r->idx);
4426         ndr_print_uint32(ndr, "rid", r->rid);
4427         ndr_print_samr_GroupAttrs(ndr, "acct_flags", r->acct_flags);
4428         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
4429         ndr_print_lsa_String(ndr, "description", &r->description);
4430         ndr->depth--;
4431 }
4432
4433 static enum ndr_err_code ndr_push_samr_DispInfoFullGroups(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoFullGroups *r)
4434 {
4435         uint32_t cntr_entries_1;
4436         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
4437         if (ndr_flags & NDR_SCALARS) {
4438                 NDR_CHECK(ndr_push_align(ndr, 5));
4439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4440                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
4441                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4442         }
4443         if (ndr_flags & NDR_BUFFERS) {
4444                 if (r->entries) {
4445                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
4446                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4447                                 NDR_CHECK(ndr_push_samr_DispEntryFullGroup(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4448                         }
4449                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4450                                 NDR_CHECK(ndr_push_samr_DispEntryFullGroup(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4451                         }
4452                 }
4453         }
4454         return NDR_ERR_SUCCESS;
4455 }
4456
4457 static enum ndr_err_code ndr_pull_samr_DispInfoFullGroups(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoFullGroups *r)
4458 {
4459         uint32_t _ptr_entries;
4460         uint32_t size_entries_1 = 0;
4461         uint32_t cntr_entries_1;
4462         TALLOC_CTX *_mem_save_entries_0;
4463         TALLOC_CTX *_mem_save_entries_1;
4464         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
4465         if (ndr_flags & NDR_SCALARS) {
4466                 NDR_CHECK(ndr_pull_align(ndr, 5));
4467                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4468                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
4469                 if (_ptr_entries) {
4470                         NDR_PULL_ALLOC(ndr, r->entries);
4471                 } else {
4472                         r->entries = NULL;
4473                 }
4474                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4475         }
4476         if (ndr_flags & NDR_BUFFERS) {
4477                 if (r->entries) {
4478                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
4479                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4480                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
4481                         size_entries_1 = ndr_get_array_size(ndr, &r->entries);
4482                         NDR_PULL_ALLOC_N(ndr, r->entries, size_entries_1);
4483                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
4484                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4485                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
4486                                 NDR_CHECK(ndr_pull_samr_DispEntryFullGroup(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4487                         }
4488                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
4489                                 NDR_CHECK(ndr_pull_samr_DispEntryFullGroup(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4490                         }
4491                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
4492                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
4493                 }
4494                 if (r->entries) {
4495                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
4496                 }
4497         }
4498         return NDR_ERR_SUCCESS;
4499 }
4500
4501 _PUBLIC_ void ndr_print_samr_DispInfoFullGroups(struct ndr_print *ndr, const char *name, const struct samr_DispInfoFullGroups *r)
4502 {
4503         uint32_t cntr_entries_1;
4504         ndr_print_struct(ndr, name, "samr_DispInfoFullGroups");
4505         if (r == NULL) { ndr_print_null(ndr); return; }
4506         ndr->depth++;
4507         ndr_print_uint32(ndr, "count", r->count);
4508         ndr_print_ptr(ndr, "entries", r->entries);
4509         ndr->depth++;
4510         if (r->entries) {
4511                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
4512                 ndr->depth++;
4513                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
4514                         ndr_print_samr_DispEntryFullGroup(ndr, "entries", &r->entries[cntr_entries_1]);
4515                 }
4516                 ndr->depth--;
4517         }
4518         ndr->depth--;
4519         ndr->depth--;
4520 }
4521
4522 static enum ndr_err_code ndr_push_samr_DispEntryAscii(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryAscii *r)
4523 {
4524         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
4525         if (ndr_flags & NDR_SCALARS) {
4526                 NDR_CHECK(ndr_push_align(ndr, 5));
4527                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
4528                 NDR_CHECK(ndr_push_lsa_AsciiStringLarge(ndr, NDR_SCALARS, &r->account_name));
4529                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4530         }
4531         if (ndr_flags & NDR_BUFFERS) {
4532                 NDR_CHECK(ndr_push_lsa_AsciiStringLarge(ndr, NDR_BUFFERS, &r->account_name));
4533         }
4534         return NDR_ERR_SUCCESS;
4535 }
4536
4537 static enum ndr_err_code ndr_pull_samr_DispEntryAscii(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryAscii *r)
4538 {
4539         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
4540         if (ndr_flags & NDR_SCALARS) {
4541                 NDR_CHECK(ndr_pull_align(ndr, 5));
4542                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
4543                 NDR_CHECK(ndr_pull_lsa_AsciiStringLarge(ndr, NDR_SCALARS, &r->account_name));
4544                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4545         }
4546         if (ndr_flags & NDR_BUFFERS) {
4547                 NDR_CHECK(ndr_pull_lsa_AsciiStringLarge(ndr, NDR_BUFFERS, &r->account_name));
4548         }
4549         return NDR_ERR_SUCCESS;
4550 }
4551
4552 _PUBLIC_ void ndr_print_samr_DispEntryAscii(struct ndr_print *ndr, const char *name, const struct samr_DispEntryAscii *r)
4553 {
4554         ndr_print_struct(ndr, name, "samr_DispEntryAscii");
4555         if (r == NULL) { ndr_print_null(ndr); return; }
4556         ndr->depth++;
4557         ndr_print_uint32(ndr, "idx", r->idx);
4558         ndr_print_lsa_AsciiStringLarge(ndr, "account_name", &r->account_name);
4559         ndr->depth--;
4560 }
4561
4562 static enum ndr_err_code ndr_push_samr_DispInfoAscii(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoAscii *r)
4563 {
4564         uint32_t cntr_entries_1;
4565         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
4566         if (ndr_flags & NDR_SCALARS) {
4567                 NDR_CHECK(ndr_push_align(ndr, 5));
4568                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4569                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
4570                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4571         }
4572         if (ndr_flags & NDR_BUFFERS) {
4573                 if (r->entries) {
4574                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
4575                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4576                                 NDR_CHECK(ndr_push_samr_DispEntryAscii(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4577                         }
4578                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4579                                 NDR_CHECK(ndr_push_samr_DispEntryAscii(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4580                         }
4581                 }
4582         }
4583         return NDR_ERR_SUCCESS;
4584 }
4585
4586 static enum ndr_err_code ndr_pull_samr_DispInfoAscii(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoAscii *r)
4587 {
4588         uint32_t _ptr_entries;
4589         uint32_t size_entries_1 = 0;
4590         uint32_t cntr_entries_1;
4591         TALLOC_CTX *_mem_save_entries_0;
4592         TALLOC_CTX *_mem_save_entries_1;
4593         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
4594         if (ndr_flags & NDR_SCALARS) {
4595                 NDR_CHECK(ndr_pull_align(ndr, 5));
4596                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4597                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
4598                 if (_ptr_entries) {
4599                         NDR_PULL_ALLOC(ndr, r->entries);
4600                 } else {
4601                         r->entries = NULL;
4602                 }
4603                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4604         }
4605         if (ndr_flags & NDR_BUFFERS) {
4606                 if (r->entries) {
4607                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
4608                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4609                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
4610                         size_entries_1 = ndr_get_array_size(ndr, &r->entries);
4611                         NDR_PULL_ALLOC_N(ndr, r->entries, size_entries_1);
4612                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
4613                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4614                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
4615                                 NDR_CHECK(ndr_pull_samr_DispEntryAscii(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4616                         }
4617                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
4618                                 NDR_CHECK(ndr_pull_samr_DispEntryAscii(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4619                         }
4620                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
4621                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
4622                 }
4623                 if (r->entries) {
4624                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
4625                 }
4626         }
4627         return NDR_ERR_SUCCESS;
4628 }
4629
4630 _PUBLIC_ void ndr_print_samr_DispInfoAscii(struct ndr_print *ndr, const char *name, const struct samr_DispInfoAscii *r)
4631 {
4632         uint32_t cntr_entries_1;
4633         ndr_print_struct(ndr, name, "samr_DispInfoAscii");
4634         if (r == NULL) { ndr_print_null(ndr); return; }
4635         ndr->depth++;
4636         ndr_print_uint32(ndr, "count", r->count);
4637         ndr_print_ptr(ndr, "entries", r->entries);
4638         ndr->depth++;
4639         if (r->entries) {
4640                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
4641                 ndr->depth++;
4642                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
4643                         ndr_print_samr_DispEntryAscii(ndr, "entries", &r->entries[cntr_entries_1]);
4644                 }
4645                 ndr->depth--;
4646         }
4647         ndr->depth--;
4648         ndr->depth--;
4649 }
4650
4651 static enum ndr_err_code ndr_push_samr_DispInfo(struct ndr_push *ndr, int ndr_flags, const union samr_DispInfo *r)
4652 {
4653         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
4654         if (ndr_flags & NDR_SCALARS) {
4655                 uint32_t level = ndr_push_get_switch_value(ndr, r);
4656                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4657                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
4658                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4659                 switch (level) {
4660                         case 1: {
4661                                 NDR_CHECK(ndr_push_samr_DispInfoGeneral(ndr, NDR_SCALARS, &r->info1));
4662                         break; }
4663
4664                         case 2: {
4665                                 NDR_CHECK(ndr_push_samr_DispInfoFull(ndr, NDR_SCALARS, &r->info2));
4666                         break; }
4667
4668                         case 3: {
4669                                 NDR_CHECK(ndr_push_samr_DispInfoFullGroups(ndr, NDR_SCALARS, &r->info3));
4670                         break; }
4671
4672                         case 4: {
4673                                 NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info4));
4674                         break; }
4675
4676                         case 5: {
4677                                 NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info5));
4678                         break; }
4679
4680                         default:
4681                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4682                 }
4683         }
4684         if (ndr_flags & NDR_BUFFERS) {
4685                 uint32_t level = ndr_push_get_switch_value(ndr, r);
4686                 switch (level) {
4687                         case 1:
4688                                 NDR_CHECK(ndr_push_samr_DispInfoGeneral(ndr, NDR_BUFFERS, &r->info1));
4689                         break;
4690
4691                         case 2:
4692                                 NDR_CHECK(ndr_push_samr_DispInfoFull(ndr, NDR_BUFFERS, &r->info2));
4693                         break;
4694
4695                         case 3:
4696                                 NDR_CHECK(ndr_push_samr_DispInfoFullGroups(ndr, NDR_BUFFERS, &r->info3));
4697                         break;
4698
4699                         case 4:
4700                                 NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info4));
4701                         break;
4702
4703                         case 5:
4704                                 NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info5));
4705                         break;
4706
4707                         default:
4708                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4709                 }
4710         }
4711         return NDR_ERR_SUCCESS;
4712 }
4713
4714 static enum ndr_err_code ndr_pull_samr_DispInfo(struct ndr_pull *ndr, int ndr_flags, union samr_DispInfo *r)
4715 {
4716         uint32_t level;
4717         uint16_t _level;
4718         level = ndr_pull_get_switch_value(ndr, r);
4719         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
4720         if (ndr_flags & NDR_SCALARS) {
4721                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4722                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
4723                 if (_level != level) {
4724                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4725                 }
4726                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4727                 switch (level) {
4728                         case 1: {
4729                                 NDR_CHECK(ndr_pull_samr_DispInfoGeneral(ndr, NDR_SCALARS, &r->info1));
4730                         break; }
4731
4732                         case 2: {
4733                                 NDR_CHECK(ndr_pull_samr_DispInfoFull(ndr, NDR_SCALARS, &r->info2));
4734                         break; }
4735
4736                         case 3: {
4737                                 NDR_CHECK(ndr_pull_samr_DispInfoFullGroups(ndr, NDR_SCALARS, &r->info3));
4738                         break; }
4739
4740                         case 4: {
4741                                 NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info4));
4742                         break; }
4743
4744                         case 5: {
4745                                 NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info5));
4746                         break; }
4747
4748                         default:
4749                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4750                 }
4751         }
4752         if (ndr_flags & NDR_BUFFERS) {
4753                 switch (level) {
4754                         case 1:
4755                                 NDR_CHECK(ndr_pull_samr_DispInfoGeneral(ndr, NDR_BUFFERS, &r->info1));
4756                         break;
4757
4758                         case 2:
4759                                 NDR_CHECK(ndr_pull_samr_DispInfoFull(ndr, NDR_BUFFERS, &r->info2));
4760                         break;
4761
4762                         case 3:
4763                                 NDR_CHECK(ndr_pull_samr_DispInfoFullGroups(ndr, NDR_BUFFERS, &r->info3));
4764                         break;
4765
4766                         case 4:
4767                                 NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info4));
4768                         break;
4769
4770                         case 5:
4771                                 NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info5));
4772                         break;
4773
4774                         default:
4775                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4776                 }
4777         }
4778         return NDR_ERR_SUCCESS;
4779 }
4780
4781 _PUBLIC_ void ndr_print_samr_DispInfo(struct ndr_print *ndr, const char *name, const union samr_DispInfo *r)
4782 {
4783         uint32_t level;
4784         level = ndr_print_get_switch_value(ndr, r);
4785         ndr_print_union(ndr, name, level, "samr_DispInfo");
4786         switch (level) {
4787                 case 1:
4788                         ndr_print_samr_DispInfoGeneral(ndr, "info1", &r->info1);
4789                 break;
4790
4791                 case 2:
4792                         ndr_print_samr_DispInfoFull(ndr, "info2", &r->info2);
4793                 break;
4794
4795                 case 3:
4796                         ndr_print_samr_DispInfoFullGroups(ndr, "info3", &r->info3);
4797                 break;
4798
4799                 case 4:
4800                         ndr_print_samr_DispInfoAscii(ndr, "info4", &r->info4);
4801                 break;
4802
4803                 case 5:
4804                         ndr_print_samr_DispInfoAscii(ndr, "info5", &r->info5);
4805                 break;
4806
4807                 default:
4808                         ndr_print_bad_level(ndr, name, level);
4809         }
4810 }
4811
4812 static enum ndr_err_code ndr_push_samr_PwInfo(struct ndr_push *ndr, int ndr_flags, const struct samr_PwInfo *r)
4813 {
4814         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
4815         if (ndr_flags & NDR_SCALARS) {
4816                 NDR_CHECK(ndr_push_align(ndr, 4));
4817                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->min_password_length));
4818                 NDR_CHECK(ndr_push_samr_PasswordProperties(ndr, NDR_SCALARS, r->password_properties));
4819                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4820         }
4821         if (ndr_flags & NDR_BUFFERS) {
4822         }
4823         return NDR_ERR_SUCCESS;
4824 }
4825
4826 static enum ndr_err_code ndr_pull_samr_PwInfo(struct ndr_pull *ndr, int ndr_flags, struct samr_PwInfo *r)
4827 {
4828         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
4829         if (ndr_flags & NDR_SCALARS) {
4830                 NDR_CHECK(ndr_pull_align(ndr, 4));
4831                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->min_password_length));
4832                 NDR_CHECK(ndr_pull_samr_PasswordProperties(ndr, NDR_SCALARS, &r->password_properties));
4833                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4834         }
4835         if (ndr_flags & NDR_BUFFERS) {
4836         }
4837         return NDR_ERR_SUCCESS;
4838 }
4839
4840 _PUBLIC_ void ndr_print_samr_PwInfo(struct ndr_print *ndr, const char *name, const struct samr_PwInfo *r)
4841 {
4842         ndr_print_struct(ndr, name, "samr_PwInfo");
4843         if (r == NULL) { ndr_print_null(ndr); return; }
4844         ndr->depth++;
4845         ndr_print_uint16(ndr, "min_password_length", r->min_password_length);
4846         ndr_print_samr_PasswordProperties(ndr, "password_properties", r->password_properties);
4847         ndr->depth--;
4848 }
4849
4850 static enum ndr_err_code ndr_push_samr_ConnectVersion(struct ndr_push *ndr, int ndr_flags, enum samr_ConnectVersion r)
4851 {
4852         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
4853         return NDR_ERR_SUCCESS;
4854 }
4855
4856 static enum ndr_err_code ndr_pull_samr_ConnectVersion(struct ndr_pull *ndr, int ndr_flags, enum samr_ConnectVersion *r)
4857 {
4858         uint32_t v;
4859         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
4860         *r = v;
4861         return NDR_ERR_SUCCESS;
4862 }
4863
4864 _PUBLIC_ void ndr_print_samr_ConnectVersion(struct ndr_print *ndr, const char *name, enum samr_ConnectVersion r)
4865 {
4866         const char *val = NULL;
4867
4868         switch (r) {
4869                 case SAMR_CONNECT_PRE_W2K: val = "SAMR_CONNECT_PRE_W2K"; break;
4870                 case SAMR_CONNECT_W2K: val = "SAMR_CONNECT_W2K"; break;
4871                 case SAMR_CONNECT_AFTER_W2K: val = "SAMR_CONNECT_AFTER_W2K"; break;
4872         }
4873         ndr_print_enum(ndr, name, "ENUM", val, r);
4874 }
4875
4876 _PUBLIC_ enum ndr_err_code ndr_push_samPwdChangeReason(struct ndr_push *ndr, int ndr_flags, enum samPwdChangeReason r)
4877 {
4878         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
4879         return NDR_ERR_SUCCESS;
4880 }
4881
4882 _PUBLIC_ enum ndr_err_code ndr_pull_samPwdChangeReason(struct ndr_pull *ndr, int ndr_flags, enum samPwdChangeReason *r)
4883 {
4884         uint32_t v;
4885         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
4886         *r = v;
4887         return NDR_ERR_SUCCESS;
4888 }
4889
4890 _PUBLIC_ void ndr_print_samPwdChangeReason(struct ndr_print *ndr, const char *name, enum samPwdChangeReason r)
4891 {
4892         const char *val = NULL;
4893
4894         switch (r) {
4895                 case SAM_PWD_CHANGE_NO_ERROR: val = "SAM_PWD_CHANGE_NO_ERROR"; break;
4896                 case SAM_PWD_CHANGE_PASSWORD_TOO_SHORT: val = "SAM_PWD_CHANGE_PASSWORD_TOO_SHORT"; break;
4897                 case SAM_PWD_CHANGE_PWD_IN_HISTORY: val = "SAM_PWD_CHANGE_PWD_IN_HISTORY"; break;
4898                 case SAM_PWD_CHANGE_USERNAME_IN_PASSWORD: val = "SAM_PWD_CHANGE_USERNAME_IN_PASSWORD"; break;
4899                 case SAM_PWD_CHANGE_FULLNAME_IN_PASSWORD: val = "SAM_PWD_CHANGE_FULLNAME_IN_PASSWORD"; break;
4900                 case SAM_PWD_CHANGE_NOT_COMPLEX: val = "SAM_PWD_CHANGE_NOT_COMPLEX"; break;
4901                 case SAM_PWD_CHANGE_MACHINE_NOT_DEFAULT: val = "SAM_PWD_CHANGE_MACHINE_NOT_DEFAULT"; break;
4902                 case SAM_PWD_CHANGE_FAILED_BY_FILTER: val = "SAM_PWD_CHANGE_FAILED_BY_FILTER"; break;
4903                 case SAM_PWD_CHANGE_PASSWORD_TOO_LONG: val = "SAM_PWD_CHANGE_PASSWORD_TOO_LONG"; break;
4904         }
4905         ndr_print_enum(ndr, name, "ENUM", val, r);
4906 }
4907
4908 static enum ndr_err_code ndr_push_userPwdChangeFailureInformation(struct ndr_push *ndr, int ndr_flags, const struct userPwdChangeFailureInformation *r)
4909 {
4910         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
4911         if (ndr_flags & NDR_SCALARS) {
4912                 NDR_CHECK(ndr_push_align(ndr, 5));
4913                 NDR_CHECK(ndr_push_samPwdChangeReason(ndr, NDR_SCALARS, r->extendedFailureReason));
4914                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->filterModuleName));
4915                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4916         }
4917         if (ndr_flags & NDR_BUFFERS) {
4918                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->filterModuleName));
4919         }
4920         return NDR_ERR_SUCCESS;
4921 }
4922
4923 static enum ndr_err_code ndr_pull_userPwdChangeFailureInformation(struct ndr_pull *ndr, int ndr_flags, struct userPwdChangeFailureInformation *r)
4924 {
4925         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
4926         if (ndr_flags & NDR_SCALARS) {
4927                 NDR_CHECK(ndr_pull_align(ndr, 5));
4928                 NDR_CHECK(ndr_pull_samPwdChangeReason(ndr, NDR_SCALARS, &r->extendedFailureReason));
4929                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->filterModuleName));
4930                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4931         }
4932         if (ndr_flags & NDR_BUFFERS) {
4933                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->filterModuleName));
4934         }
4935         return NDR_ERR_SUCCESS;
4936 }
4937
4938 _PUBLIC_ void ndr_print_userPwdChangeFailureInformation(struct ndr_print *ndr, const char *name, const struct userPwdChangeFailureInformation *r)
4939 {
4940         ndr_print_struct(ndr, name, "userPwdChangeFailureInformation");
4941         if (r == NULL) { ndr_print_null(ndr); return; }
4942         ndr->depth++;
4943         ndr_print_samPwdChangeReason(ndr, "extendedFailureReason", r->extendedFailureReason);
4944         ndr_print_lsa_String(ndr, "filterModuleName", &r->filterModuleName);
4945         ndr->depth--;
4946 }
4947
4948 static enum ndr_err_code ndr_push_samr_ConnectInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_ConnectInfo1 *r)
4949 {
4950         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
4951         if (ndr_flags & NDR_SCALARS) {
4952                 NDR_CHECK(ndr_push_align(ndr, 4));
4953                 NDR_CHECK(ndr_push_samr_ConnectVersion(ndr, NDR_SCALARS, r->client_version));
4954                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
4955                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4956         }
4957         if (ndr_flags & NDR_BUFFERS) {
4958         }
4959         return NDR_ERR_SUCCESS;
4960 }
4961
4962 static enum ndr_err_code ndr_pull_samr_ConnectInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_ConnectInfo1 *r)
4963 {
4964         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
4965         if (ndr_flags & NDR_SCALARS) {
4966                 NDR_CHECK(ndr_pull_align(ndr, 4));
4967                 NDR_CHECK(ndr_pull_samr_ConnectVersion(ndr, NDR_SCALARS, &r->client_version));
4968                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
4969                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4970         }
4971         if (ndr_flags & NDR_BUFFERS) {
4972         }
4973         return NDR_ERR_SUCCESS;
4974 }
4975
4976 _PUBLIC_ void ndr_print_samr_ConnectInfo1(struct ndr_print *ndr, const char *name, const struct samr_ConnectInfo1 *r)
4977 {
4978         ndr_print_struct(ndr, name, "samr_ConnectInfo1");
4979         if (r == NULL) { ndr_print_null(ndr); return; }
4980         ndr->depth++;
4981         ndr_print_samr_ConnectVersion(ndr, "client_version", r->client_version);
4982         ndr_print_uint32(ndr, "unknown2", r->unknown2);
4983         ndr->depth--;
4984 }
4985
4986 static enum ndr_err_code ndr_push_samr_ConnectInfo(struct ndr_push *ndr, int ndr_flags, const union samr_ConnectInfo *r)
4987 {
4988         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
4989         if (ndr_flags & NDR_SCALARS) {
4990                 uint32_t level = ndr_push_get_switch_value(ndr, r);
4991                 NDR_CHECK(ndr_push_union_align(ndr, 4));
4992                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4993                 NDR_CHECK(ndr_push_union_align(ndr, 4));
4994                 switch (level) {
4995                         case 1: {
4996                                 NDR_CHECK(ndr_push_samr_ConnectInfo1(ndr, NDR_SCALARS, &r->info1));
4997                         break; }
4998
4999                         default:
5000                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5001                 }
5002         }
5003         if (ndr_flags & NDR_BUFFERS) {
5004                 uint32_t level = ndr_push_get_switch_value(ndr, r);
5005                 switch (level) {
5006                         case 1:
5007                         break;
5008
5009                         default:
5010                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5011                 }
5012         }
5013         return NDR_ERR_SUCCESS;
5014 }
5015
5016 static enum ndr_err_code ndr_pull_samr_ConnectInfo(struct ndr_pull *ndr, int ndr_flags, union samr_ConnectInfo *r)
5017 {
5018         uint32_t level;
5019         uint32_t _level;
5020         level = ndr_pull_get_switch_value(ndr, r);
5021         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
5022         if (ndr_flags & NDR_SCALARS) {
5023                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
5024                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5025                 if (_level != level) {
5026                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5027                 }
5028                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
5029                 switch (level) {
5030                         case 1: {
5031                                 NDR_CHECK(ndr_pull_samr_ConnectInfo1(ndr, NDR_SCALARS, &r->info1));
5032                         break; }
5033
5034                         default:
5035                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5036                 }
5037         }
5038         if (ndr_flags & NDR_BUFFERS) {
5039                 switch (level) {
5040                         case 1:
5041                         break;
5042
5043                         default:
5044                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5045                 }
5046         }
5047         return NDR_ERR_SUCCESS;
5048 }
5049
5050 _PUBLIC_ void ndr_print_samr_ConnectInfo(struct ndr_print *ndr, const char *name, const union samr_ConnectInfo *r)
5051 {
5052         uint32_t level;
5053         level = ndr_print_get_switch_value(ndr, r);
5054         ndr_print_union(ndr, name, level, "samr_ConnectInfo");
5055         switch (level) {
5056                 case 1:
5057                         ndr_print_samr_ConnectInfo1(ndr, "info1", &r->info1);
5058                 break;
5059
5060                 default:
5061                         ndr_print_bad_level(ndr, name, level);
5062         }
5063 }
5064
5065 static enum ndr_err_code ndr_push_samr_ValidateFieldsPresent(struct ndr_push *ndr, int ndr_flags, uint32_t r)
5066 {
5067         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5068         return NDR_ERR_SUCCESS;
5069 }
5070
5071 static enum ndr_err_code ndr_pull_samr_ValidateFieldsPresent(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
5072 {
5073         uint32_t v;
5074         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5075         *r = v;
5076         return NDR_ERR_SUCCESS;
5077 }
5078
5079 _PUBLIC_ void ndr_print_samr_ValidateFieldsPresent(struct ndr_print *ndr, const char *name, uint32_t r)
5080 {
5081         ndr_print_uint32(ndr, name, r);
5082         ndr->depth++;
5083         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_LAST_SET", SAMR_VALIDATE_FIELD_PASSWORD_LAST_SET, r);
5084         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_BAD_PASSWORD_TIME", SAMR_VALIDATE_FIELD_BAD_PASSWORD_TIME, r);
5085         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_LOCKOUT_TIME", SAMR_VALIDATE_FIELD_LOCKOUT_TIME, r);
5086         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_BAD_PASSWORD_COUNT", SAMR_VALIDATE_FIELD_BAD_PASSWORD_COUNT, r);
5087         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_HISTORY_LENGTH", SAMR_VALIDATE_FIELD_PASSWORD_HISTORY_LENGTH, r);
5088         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_HISTORY", SAMR_VALIDATE_FIELD_PASSWORD_HISTORY, r);
5089         ndr->depth--;
5090 }
5091
5092 static enum ndr_err_code ndr_push_samr_ValidatePasswordLevel(struct ndr_push *ndr, int ndr_flags, enum samr_ValidatePasswordLevel r)
5093 {
5094         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
5095         return NDR_ERR_SUCCESS;
5096 }
5097
5098 static enum ndr_err_code ndr_pull_samr_ValidatePasswordLevel(struct ndr_pull *ndr, int ndr_flags, enum samr_ValidatePasswordLevel *r)
5099 {
5100         uint16_t v;
5101         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
5102         *r = v;
5103         return NDR_ERR_SUCCESS;
5104 }
5105
5106 _PUBLIC_ void ndr_print_samr_ValidatePasswordLevel(struct ndr_print *ndr, const char *name, enum samr_ValidatePasswordLevel r)
5107 {
5108         const char *val = NULL;
5109
5110         switch (r) {
5111                 case NetValidateAuthentication: val = "NetValidateAuthentication"; break;
5112                 case NetValidatePasswordChange: val = "NetValidatePasswordChange"; break;
5113                 case NetValidatePasswordReset: val = "NetValidatePasswordReset"; break;
5114         }
5115         ndr_print_enum(ndr, name, "ENUM", val, r);
5116 }
5117
5118 static enum ndr_err_code ndr_push_samr_ValidationStatus(struct ndr_push *ndr, int ndr_flags, enum samr_ValidationStatus r)
5119 {
5120         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
5121         return NDR_ERR_SUCCESS;
5122 }
5123
5124 static enum ndr_err_code ndr_pull_samr_ValidationStatus(struct ndr_pull *ndr, int ndr_flags, enum samr_ValidationStatus *r)
5125 {
5126         uint16_t v;
5127         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
5128         *r = v;
5129         return NDR_ERR_SUCCESS;
5130 }
5131
5132 _PUBLIC_ void ndr_print_samr_ValidationStatus(struct ndr_print *ndr, const char *name, enum samr_ValidationStatus r)
5133 {
5134         const char *val = NULL;
5135
5136         switch (r) {
5137                 case SAMR_VALIDATION_STATUS_SUCCESS: val = "SAMR_VALIDATION_STATUS_SUCCESS"; break;
5138                 case SAMR_VALIDATION_STATUS_PASSWORD_MUST_CHANGE: val = "SAMR_VALIDATION_STATUS_PASSWORD_MUST_CHANGE"; break;
5139                 case SAMR_VALIDATION_STATUS_ACCOUNT_LOCKED_OUT: val = "SAMR_VALIDATION_STATUS_ACCOUNT_LOCKED_OUT"; break;
5140                 case SAMR_VALIDATION_STATUS_PASSWORD_EXPIRED: val = "SAMR_VALIDATION_STATUS_PASSWORD_EXPIRED"; break;
5141                 case SAMR_VALIDATION_STATUS_BAD_PASSWORD: val = "SAMR_VALIDATION_STATUS_BAD_PASSWORD"; break;
5142                 case SAMR_VALIDATION_STATUS_PWD_HISTORY_CONFLICT: val = "SAMR_VALIDATION_STATUS_PWD_HISTORY_CONFLICT"; break;
5143                 case SAMR_VALIDATION_STATUS_PWD_TOO_SHORT: val = "SAMR_VALIDATION_STATUS_PWD_TOO_SHORT"; break;
5144                 case SAMR_VALIDATION_STATUS_PWD_TOO_LONG: val = "SAMR_VALIDATION_STATUS_PWD_TOO_LONG"; break;
5145                 case SAMR_VALIDATION_STATUS_NOT_COMPLEX_ENOUGH: val = "SAMR_VALIDATION_STATUS_NOT_COMPLEX_ENOUGH"; break;
5146                 case SAMR_VALIDATION_STATUS_PASSWORD_TOO_RECENT: val = "SAMR_VALIDATION_STATUS_PASSWORD_TOO_RECENT"; break;
5147                 case SAMR_VALIDATION_STATUS_PASSWORD_FILTER_ERROR: val = "SAMR_VALIDATION_STATUS_PASSWORD_FILTER_ERROR"; break;
5148         }
5149         ndr_print_enum(ndr, name, "ENUM", val, r);
5150 }
5151
5152 static enum ndr_err_code ndr_push_samr_ValidationBlob(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidationBlob *r)
5153 {
5154         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
5155         if (ndr_flags & NDR_SCALARS) {
5156                 NDR_CHECK(ndr_push_align(ndr, 5));
5157                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
5158                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
5159                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5160         }
5161         if (ndr_flags & NDR_BUFFERS) {
5162                 if (r->data) {
5163                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
5164                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
5165                 }
5166         }
5167         return NDR_ERR_SUCCESS;
5168 }
5169
5170 static enum ndr_err_code ndr_pull_samr_ValidationBlob(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidationBlob *r)
5171 {
5172         uint32_t _ptr_data;
5173         uint32_t size_data_1 = 0;
5174         TALLOC_CTX *_mem_save_data_0;
5175         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
5176         if (ndr_flags & NDR_SCALARS) {
5177                 NDR_CHECK(ndr_pull_align(ndr, 5));
5178                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
5179                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
5180                 if (_ptr_data) {
5181                         NDR_PULL_ALLOC(ndr, r->data);
5182                 } else {
5183                         r->data = NULL;
5184                 }
5185                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5186         }
5187         if (ndr_flags & NDR_BUFFERS) {
5188                 if (r->data) {
5189                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
5190                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
5191                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
5192                         size_data_1 = ndr_get_array_size(ndr, &r->data);
5193                         NDR_PULL_ALLOC_N(ndr, r->data, size_data_1);
5194                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, size_data_1));
5195                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
5196                 }
5197                 if (r->data) {
5198                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
5199                 }
5200         }
5201         return NDR_ERR_SUCCESS;
5202 }
5203
5204 _PUBLIC_ void ndr_print_samr_ValidationBlob(struct ndr_print *ndr, const char *name, const struct samr_ValidationBlob *r)
5205 {
5206         ndr_print_struct(ndr, name, "samr_ValidationBlob");
5207         if (r == NULL) { ndr_print_null(ndr); return; }
5208         ndr->depth++;
5209         ndr_print_uint32(ndr, "length", r->length);
5210         ndr_print_ptr(ndr, "data", r->data);
5211         ndr->depth++;
5212         if (r->data) {
5213                 ndr_print_array_uint8(ndr, "data", r->data, r->length);
5214         }
5215         ndr->depth--;
5216         ndr->depth--;
5217 }
5218
5219 static enum ndr_err_code ndr_push_samr_ValidatePasswordInfo(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordInfo *r)
5220 {
5221         uint32_t cntr_pwd_history_1;
5222         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
5223         if (ndr_flags & NDR_SCALARS) {
5224                 NDR_CHECK(ndr_push_align(ndr, 8));
5225                 NDR_CHECK(ndr_push_samr_ValidateFieldsPresent(ndr, NDR_SCALARS, r->fields_present));
5226                 NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->last_password_change));
5227                 NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->bad_password_time));
5228                 NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->lockout_time));
5229                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bad_pwd_count));
5230                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pwd_history_len));
5231                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pwd_history));
5232                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
5233         }
5234         if (ndr_flags & NDR_BUFFERS) {
5235                 if (r->pwd_history) {
5236                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->pwd_history_len));
5237                         for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {
5238                                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->pwd_history[cntr_pwd_history_1]));
5239                         }
5240                         for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {
5241                                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->pwd_history[cntr_pwd_history_1]));
5242                         }
5243                 }
5244         }
5245         return NDR_ERR_SUCCESS;
5246 }
5247
5248 static enum ndr_err_code ndr_pull_samr_ValidatePasswordInfo(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordInfo *r)
5249 {
5250         uint32_t _ptr_pwd_history;
5251         uint32_t size_pwd_history_1 = 0;
5252         uint32_t cntr_pwd_history_1;
5253         TALLOC_CTX *_mem_save_pwd_history_0;
5254         TALLOC_CTX *_mem_save_pwd_history_1;
5255         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
5256         if (ndr_flags & NDR_SCALARS) {
5257                 NDR_CHECK(ndr_pull_align(ndr, 8));
5258                 NDR_CHECK(ndr_pull_samr_ValidateFieldsPresent(ndr, NDR_SCALARS, &r->fields_present));
5259                 NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->last_password_change));
5260                 NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->bad_password_time));
5261                 NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->lockout_time));
5262                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bad_pwd_count));
5263                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pwd_history_len));
5264                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pwd_history));
5265                 if (_ptr_pwd_history) {
5266                         NDR_PULL_ALLOC(ndr, r->pwd_history);
5267                 } else {
5268                         r->pwd_history = NULL;
5269                 }
5270                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
5271         }
5272         if (ndr_flags & NDR_BUFFERS) {
5273                 if (r->pwd_history) {
5274                         _mem_save_pwd_history_0 = NDR_PULL_GET_MEM_CTX(ndr);
5275                         NDR_PULL_SET_MEM_CTX(ndr, r->pwd_history, 0);
5276                         NDR_CHECK(ndr_pull_array_size(ndr, &r->pwd_history));
5277                         size_pwd_history_1 = ndr_get_array_size(ndr, &r->pwd_history);
5278                         NDR_PULL_ALLOC_N(ndr, r->pwd_history, size_pwd_history_1);
5279                         _mem_save_pwd_history_1 = NDR_PULL_GET_MEM_CTX(ndr);
5280                         NDR_PULL_SET_MEM_CTX(ndr, r->pwd_history, 0);
5281                         for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < size_pwd_history_1; cntr_pwd_history_1++) {
5282                                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->pwd_history[cntr_pwd_history_1]));
5283                         }
5284                         for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < size_pwd_history_1; cntr_pwd_history_1++) {
5285                                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->pwd_history[cntr_pwd_history_1]));
5286                         }
5287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pwd_history_1, 0);
5288                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pwd_history_0, 0);
5289                 }
5290                 if (r->pwd_history) {
5291                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->pwd_history, r->pwd_history_len));
5292                 }
5293         }
5294         return NDR_ERR_SUCCESS;
5295 }
5296
5297 _PUBLIC_ void ndr_print_samr_ValidatePasswordInfo(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordInfo *r)
5298 {
5299         uint32_t cntr_pwd_history_1;
5300         ndr_print_struct(ndr, name, "samr_ValidatePasswordInfo");
5301         if (r == NULL) { ndr_print_null(ndr); return; }
5302         ndr->depth++;
5303         ndr_print_samr_ValidateFieldsPresent(ndr, "fields_present", r->fields_present);
5304         ndr_print_NTTIME_hyper(ndr, "last_password_change", r->last_password_change);
5305         ndr_print_NTTIME_hyper(ndr, "bad_password_time", r->bad_password_time);
5306         ndr_print_NTTIME_hyper(ndr, "lockout_time", r->lockout_time);
5307         ndr_print_uint32(ndr, "bad_pwd_count", r->bad_pwd_count);
5308         ndr_print_uint32(ndr, "pwd_history_len", r->pwd_history_len);
5309         ndr_print_ptr(ndr, "pwd_history", r->pwd_history);
5310         ndr->depth++;
5311         if (r->pwd_history) {
5312                 ndr->print(ndr, "%s: ARRAY(%d)", "pwd_history", (int)r->pwd_history_len);
5313                 ndr->depth++;
5314                 for (cntr_pwd_history_1=0;cntr_pwd_history_1<r->pwd_history_len;cntr_pwd_history_1++) {
5315                         ndr_print_samr_ValidationBlob(ndr, "pwd_history", &r->pwd_history[cntr_pwd_history_1]);
5316                 }
5317                 ndr->depth--;
5318         }
5319         ndr->depth--;
5320         ndr->depth--;
5321 }
5322
5323 static enum ndr_err_code ndr_push_samr_ValidatePasswordRepCtr(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordRepCtr *r)
5324 {
5325         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
5326         if (ndr_flags & NDR_SCALARS) {
5327                 NDR_CHECK(ndr_push_align(ndr, 8));
5328                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5329                 NDR_CHECK(ndr_push_samr_ValidationStatus(ndr, NDR_SCALARS, r->status));
5330                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
5331         }
5332         if (ndr_flags & NDR_BUFFERS) {
5333                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5334         }
5335         return NDR_ERR_SUCCESS;
5336 }
5337
5338 static enum ndr_err_code ndr_pull_samr_ValidatePasswordRepCtr(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordRepCtr *r)
5339 {
5340         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
5341         if (ndr_flags & NDR_SCALARS) {
5342                 NDR_CHECK(ndr_pull_align(ndr, 8));
5343                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5344                 NDR_CHECK(ndr_pull_samr_ValidationStatus(ndr, NDR_SCALARS, &r->status));
5345                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
5346         }
5347         if (ndr_flags & NDR_BUFFERS) {
5348                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5349         }
5350         return NDR_ERR_SUCCESS;
5351 }
5352
5353 _PUBLIC_ void ndr_print_samr_ValidatePasswordRepCtr(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordRepCtr *r)
5354 {
5355         ndr_print_struct(ndr, name, "samr_ValidatePasswordRepCtr");
5356         if (r == NULL) { ndr_print_null(ndr); return; }
5357         ndr->depth++;
5358         ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
5359         ndr_print_samr_ValidationStatus(ndr, "status", r->status);
5360         ndr->depth--;
5361 }
5362
5363 static enum ndr_err_code ndr_push_samr_ValidatePasswordRep(struct ndr_push *ndr, int ndr_flags, const union samr_ValidatePasswordRep *r)
5364 {
5365         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
5366         if (ndr_flags & NDR_SCALARS) {
5367                 uint32_t level = ndr_push_get_switch_value(ndr, r);
5368                 NDR_CHECK(ndr_push_union_align(ndr, 8));
5369                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
5370                 NDR_CHECK(ndr_push_union_align(ndr, 8));
5371                 switch (level) {
5372                         case 1: {
5373                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr1));
5374                         break; }
5375
5376                         case 2: {
5377                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr2));
5378                         break; }
5379
5380                         case 3: {
5381                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr3));
5382                         break; }
5383
5384                         default:
5385                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5386                 }
5387         }
5388         if (ndr_flags & NDR_BUFFERS) {
5389                 uint32_t level = ndr_push_get_switch_value(ndr, r);
5390                 switch (level) {
5391                         case 1:
5392                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr1));
5393                         break;
5394
5395                         case 2:
5396                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr2));
5397                         break;
5398
5399                         case 3:
5400                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr3));
5401                         break;
5402
5403                         default:
5404                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5405                 }
5406         }
5407         return NDR_ERR_SUCCESS;
5408 }
5409
5410 static enum ndr_err_code ndr_pull_samr_ValidatePasswordRep(struct ndr_pull *ndr, int ndr_flags, union samr_ValidatePasswordRep *r)
5411 {
5412         uint32_t level;
5413         uint16_t _level;
5414         level = ndr_pull_get_switch_value(ndr, r);
5415         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
5416         if (ndr_flags & NDR_SCALARS) {
5417                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
5418                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
5419                 if (_level != level) {
5420                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5421                 }
5422                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
5423                 switch (level) {
5424                         case 1: {
5425                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr1));
5426                         break; }
5427
5428                         case 2: {
5429                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr2));
5430                         break; }
5431
5432                         case 3: {
5433                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr3));
5434                         break; }
5435
5436                         default:
5437                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5438                 }
5439         }
5440         if (ndr_flags & NDR_BUFFERS) {
5441                 switch (level) {
5442                         case 1:
5443                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr1));
5444                         break;
5445
5446                         case 2:
5447                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr2));
5448                         break;
5449
5450                         case 3:
5451                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr3));
5452                         break;
5453
5454                         default:
5455                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5456                 }
5457         }
5458         return NDR_ERR_SUCCESS;
5459 }
5460
5461 _PUBLIC_ void ndr_print_samr_ValidatePasswordRep(struct ndr_print *ndr, const char *name, const union samr_ValidatePasswordRep *r)
5462 {
5463         uint32_t level;
5464         level = ndr_print_get_switch_value(ndr, r);
5465         ndr_print_union(ndr, name, level, "samr_ValidatePasswordRep");
5466         switch (level) {
5467                 case 1:
5468                         ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr1", &r->ctr1);
5469                 break;
5470
5471                 case 2:
5472                         ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr2", &r->ctr2);
5473                 break;
5474
5475                 case 3:
5476                         ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr3", &r->ctr3);
5477                 break;
5478
5479                 default:
5480                         ndr_print_bad_level(ndr, name, level);
5481         }
5482 }
5483
5484 static enum ndr_err_code ndr_push_samr_ValidatePasswordReq3(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq3 *r)
5485 {
5486         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
5487         if (ndr_flags & NDR_SCALARS) {
5488                 NDR_CHECK(ndr_push_align(ndr, 8));
5489                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5490                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
5491                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
5492                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
5493                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->pwd_must_change_at_next_logon));
5494                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->clear_lockout));
5495                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
5496         }
5497         if (ndr_flags & NDR_BUFFERS) {
5498                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5499                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
5500                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
5501                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
5502         }
5503         return NDR_ERR_SUCCESS;
5504 }
5505
5506 static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq3(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq3 *r)
5507 {
5508         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
5509         if (ndr_flags & NDR_SCALARS) {
5510                 NDR_CHECK(ndr_pull_align(ndr, 8));
5511                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5512                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
5513                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
5514                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
5515                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->pwd_must_change_at_next_logon));
5516                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->clear_lockout));
5517                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
5518         }
5519         if (ndr_flags & NDR_BUFFERS) {
5520                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5521                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
5522                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
5523                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
5524         }
5525         return NDR_ERR_SUCCESS;
5526 }
5527
5528 _PUBLIC_ void ndr_print_samr_ValidatePasswordReq3(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq3 *r)
5529 {
5530         ndr_print_struct(ndr, name, "samr_ValidatePasswordReq3");
5531         if (r == NULL) { ndr_print_null(ndr); return; }
5532         ndr->depth++;
5533         ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
5534         ndr_print_lsa_StringLarge(ndr, "password", &r->password);
5535         ndr_print_lsa_StringLarge(ndr, "account", &r->account);
5536         ndr_print_samr_ValidationBlob(ndr, "hash", &r->hash);
5537         ndr_print_uint8(ndr, "pwd_must_change_at_next_logon", r->pwd_must_change_at_next_logon);
5538         ndr_print_uint8(ndr, "clear_lockout", r->clear_lockout);
5539         ndr->depth--;
5540 }
5541
5542 static enum ndr_err_code ndr_push_samr_ValidatePasswordReq2(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq2 *r)
5543 {
5544         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
5545         if (ndr_flags & NDR_SCALARS) {
5546                 NDR_CHECK(ndr_push_align(ndr, 8));
5547                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5548                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
5549                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
5550                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
5551                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_matched));
5552                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
5553         }
5554         if (ndr_flags & NDR_BUFFERS) {
5555                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5556                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
5557                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
5558                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
5559         }
5560         return NDR_ERR_SUCCESS;
5561 }
5562
5563 static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq2(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq2 *r)
5564 {
5565         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
5566         if (ndr_flags & NDR_SCALARS) {
5567                 NDR_CHECK(ndr_pull_align(ndr, 8));
5568                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5569                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
5570                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
5571                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
5572                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_matched));
5573                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
5574         }
5575         if (ndr_flags & NDR_BUFFERS) {
5576                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5577                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
5578                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
5579                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
5580         }
5581         return NDR_ERR_SUCCESS;
5582 }
5583
5584 _PUBLIC_ void ndr_print_samr_ValidatePasswordReq2(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq2 *r)
5585 {
5586         ndr_print_struct(ndr, name, "samr_ValidatePasswordReq2");
5587         if (r == NULL) { ndr_print_null(ndr); return; }
5588         ndr->depth++;
5589         ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
5590         ndr_print_lsa_StringLarge(ndr, "password", &r->password);
5591         ndr_print_lsa_StringLarge(ndr, "account", &r->account);
5592         ndr_print_samr_ValidationBlob(ndr, "hash", &r->hash);
5593         ndr_print_uint8(ndr, "password_matched", r->password_matched);
5594         ndr->depth--;
5595 }
5596
5597 static enum ndr_err_code ndr_push_samr_ValidatePasswordReq1(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq1 *r)
5598 {
5599         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
5600         if (ndr_flags & NDR_SCALARS) {
5601                 NDR_CHECK(ndr_push_align(ndr, 8));
5602                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5603                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_matched));
5604                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
5605         }
5606         if (ndr_flags & NDR_BUFFERS) {
5607                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5608         }
5609         return NDR_ERR_SUCCESS;
5610 }
5611
5612 static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq1(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq1 *r)
5613 {
5614         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
5615         if (ndr_flags & NDR_SCALARS) {
5616                 NDR_CHECK(ndr_pull_align(ndr, 8));
5617                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5618                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_matched));
5619                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
5620         }
5621         if (ndr_flags & NDR_BUFFERS) {
5622                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5623         }
5624         return NDR_ERR_SUCCESS;
5625 }
5626
5627 _PUBLIC_ void ndr_print_samr_ValidatePasswordReq1(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq1 *r)
5628 {
5629         ndr_print_struct(ndr, name, "samr_ValidatePasswordReq1");
5630         if (r == NULL) { ndr_print_null(ndr); return; }
5631         ndr->depth++;
5632         ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
5633         ndr_print_uint8(ndr, "password_matched", r->password_matched);
5634         ndr->depth--;
5635 }
5636
5637 static enum ndr_err_code ndr_push_samr_ValidatePasswordReq(struct ndr_push *ndr, int ndr_flags, const union samr_ValidatePasswordReq *r)
5638 {
5639         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
5640         if (ndr_flags & NDR_SCALARS) {
5641                 uint32_t level = ndr_push_get_switch_value(ndr, r);
5642                 NDR_CHECK(ndr_push_union_align(ndr, 8));
5643                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
5644                 NDR_CHECK(ndr_push_union_align(ndr, 8));
5645                 switch (level) {
5646                         case 1: {
5647                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq1(ndr, NDR_SCALARS, &r->req1));
5648                         break; }
5649
5650                         case 2: {
5651                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq2(ndr, NDR_SCALARS, &r->req2));
5652                         break; }
5653
5654                         case 3: {
5655                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq3(ndr, NDR_SCALARS, &r->req3));
5656                         break; }
5657
5658                         default:
5659                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5660                 }
5661         }
5662         if (ndr_flags & NDR_BUFFERS) {
5663                 uint32_t level = ndr_push_get_switch_value(ndr, r);
5664                 switch (level) {
5665                         case 1:
5666                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq1(ndr, NDR_BUFFERS, &r->req1));
5667                         break;
5668
5669                         case 2:
5670                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq2(ndr, NDR_BUFFERS, &r->req2));
5671                         break;
5672
5673                         case 3:
5674                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq3(ndr, NDR_BUFFERS, &r->req3));
5675                         break;
5676
5677                         default:
5678                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5679                 }
5680         }
5681         return NDR_ERR_SUCCESS;
5682 }
5683
5684 static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq(struct ndr_pull *ndr, int ndr_flags, union samr_ValidatePasswordReq *r)
5685 {
5686         uint32_t level;
5687         uint16_t _level;
5688         level = ndr_pull_get_switch_value(ndr, r);
5689         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
5690         if (ndr_flags & NDR_SCALARS) {
5691                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
5692                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
5693                 if (_level != level) {
5694                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5695                 }
5696                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
5697                 switch (level) {
5698                         case 1: {
5699                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq1(ndr, NDR_SCALARS, &r->req1));
5700                         break; }
5701
5702                         case 2: {
5703                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq2(ndr, NDR_SCALARS, &r->req2));
5704                         break; }
5705
5706                         case 3: {
5707                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq3(ndr, NDR_SCALARS, &r->req3));
5708                         break; }
5709
5710                         default:
5711                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5712                 }
5713         }
5714         if (ndr_flags & NDR_BUFFERS) {
5715                 switch (level) {
5716                         case 1:
5717                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq1(ndr, NDR_BUFFERS, &r->req1));
5718                         break;
5719
5720                         case 2:
5721                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq2(ndr, NDR_BUFFERS, &r->req2));
5722                         break;
5723
5724                         case 3:
5725                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq3(ndr, NDR_BUFFERS, &r->req3));
5726                         break;
5727
5728                         default:
5729                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5730                 }
5731         }
5732         return NDR_ERR_SUCCESS;
5733 }
5734
5735 _PUBLIC_ void ndr_print_samr_ValidatePasswordReq(struct ndr_print *ndr, const char *name, const union samr_ValidatePasswordReq *r)
5736 {
5737         uint32_t level;
5738         level = ndr_print_get_switch_value(ndr, r);
5739         ndr_print_union(ndr, name, level, "samr_ValidatePasswordReq");
5740         switch (level) {
5741                 case 1:
5742                         ndr_print_samr_ValidatePasswordReq1(ndr, "req1", &r->req1);
5743                 break;
5744
5745                 case 2:
5746                         ndr_print_samr_ValidatePasswordReq2(ndr, "req2", &r->req2);
5747                 break;
5748
5749                 case 3:
5750                         ndr_print_samr_ValidatePasswordReq3(ndr, "req3", &r->req3);
5751                 break;
5752
5753                 default:
5754                         ndr_print_bad_level(ndr, name, level);
5755         }
5756 }
5757
5758 static enum ndr_err_code ndr_push_samr_Connect(struct ndr_push *ndr, int flags, const struct samr_Connect *r)
5759 {
5760         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
5761         if (flags & NDR_IN) {
5762                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
5763                 if (r->in.system_name) {
5764                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
5765                 }
5766                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
5767         }
5768         if (flags & NDR_OUT) {
5769                 if (r->out.connect_handle == NULL) {
5770                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5771                 }
5772                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
5773                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5774         }
5775         return NDR_ERR_SUCCESS;
5776 }
5777
5778 static enum ndr_err_code ndr_pull_samr_Connect(struct ndr_pull *ndr, int flags, struct samr_Connect *r)
5779 {
5780         uint32_t _ptr_system_name;
5781         TALLOC_CTX *_mem_save_system_name_0;
5782         TALLOC_CTX *_mem_save_connect_handle_0;
5783         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
5784         if (flags & NDR_IN) {
5785                 ZERO_STRUCT(r->out);
5786
5787                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
5788                 if (_ptr_system_name) {
5789                         NDR_PULL_ALLOC(ndr, r->in.system_name);
5790                 } else {
5791                         r->in.system_name = NULL;
5792                 }
5793                 if (r->in.system_name) {
5794                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5795                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
5796                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
5797                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
5798                 }
5799                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
5800                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
5801                 ZERO_STRUCTP(r->out.connect_handle);
5802         }
5803         if (flags & NDR_OUT) {
5804                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5805                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
5806                 }
5807                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5808                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
5809                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
5810                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
5811                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5812         }
5813         return NDR_ERR_SUCCESS;
5814 }
5815
5816 _PUBLIC_ void ndr_print_samr_Connect(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect *r)
5817 {
5818         ndr_print_struct(ndr, name, "samr_Connect");
5819         if (r == NULL) { ndr_print_null(ndr); return; }
5820         ndr->depth++;
5821         if (flags & NDR_SET_VALUES) {
5822                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5823         }
5824         if (flags & NDR_IN) {
5825                 ndr_print_struct(ndr, "in", "samr_Connect");
5826                 ndr->depth++;
5827                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
5828                 ndr->depth++;
5829                 if (r->in.system_name) {
5830                         ndr_print_uint16(ndr, "system_name", *r->in.system_name);
5831                 }
5832                 ndr->depth--;
5833                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
5834                 ndr->depth--;
5835         }
5836         if (flags & NDR_OUT) {
5837                 ndr_print_struct(ndr, "out", "samr_Connect");
5838                 ndr->depth++;
5839                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
5840                 ndr->depth++;
5841                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
5842                 ndr->depth--;
5843                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5844                 ndr->depth--;
5845         }
5846         ndr->depth--;
5847 }
5848
5849 _PUBLIC_ enum ndr_err_code ndr_push_samr_Close(struct ndr_push *ndr, int flags, const struct samr_Close *r)
5850 {
5851         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
5852         if (flags & NDR_IN) {
5853                 if (r->in.handle == NULL) {
5854                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5855                 }
5856                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5857         }
5858         if (flags & NDR_OUT) {
5859                 if (r->out.handle == NULL) {
5860                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5861                 }
5862                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
5863                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5864         }
5865         return NDR_ERR_SUCCESS;
5866 }
5867
5868 _PUBLIC_ enum ndr_err_code ndr_pull_samr_Close(struct ndr_pull *ndr, int flags, struct samr_Close *r)
5869 {
5870         TALLOC_CTX *_mem_save_handle_0;
5871         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
5872         if (flags & NDR_IN) {
5873                 ZERO_STRUCT(r->out);
5874
5875                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5876                         NDR_PULL_ALLOC(ndr, r->in.handle);
5877                 }
5878                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5879                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5880                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5881                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5882                 NDR_PULL_ALLOC(ndr, r->out.handle);
5883                 *r->out.handle = *r->in.handle;
5884         }
5885         if (flags & NDR_OUT) {
5886                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5887                         NDR_PULL_ALLOC(ndr, r->out.handle);
5888                 }
5889                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5890                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
5891                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
5892                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5893                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5894         }
5895         return NDR_ERR_SUCCESS;
5896 }
5897
5898 _PUBLIC_ void ndr_print_samr_Close(struct ndr_print *ndr, const char *name, int flags, const struct samr_Close *r)
5899 {
5900         ndr_print_struct(ndr, name, "samr_Close");
5901         if (r == NULL) { ndr_print_null(ndr); return; }
5902         ndr->depth++;
5903         if (flags & NDR_SET_VALUES) {
5904                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5905         }
5906         if (flags & NDR_IN) {
5907                 ndr_print_struct(ndr, "in", "samr_Close");
5908                 ndr->depth++;
5909                 ndr_print_ptr(ndr, "handle", r->in.handle);
5910                 ndr->depth++;
5911                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5912                 ndr->depth--;
5913                 ndr->depth--;
5914         }
5915         if (flags & NDR_OUT) {
5916                 ndr_print_struct(ndr, "out", "samr_Close");
5917                 ndr->depth++;
5918                 ndr_print_ptr(ndr, "handle", r->out.handle);
5919                 ndr->depth++;
5920                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
5921                 ndr->depth--;
5922                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5923                 ndr->depth--;
5924         }
5925         ndr->depth--;
5926 }
5927
5928 static enum ndr_err_code ndr_push_samr_SetSecurity(struct ndr_push *ndr, int flags, const struct samr_SetSecurity *r)
5929 {
5930         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
5931         if (flags & NDR_IN) {
5932                 if (r->in.handle == NULL) {
5933                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5934                 }
5935                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5936                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
5937                 if (r->in.sdbuf == NULL) {
5938                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5939                 }
5940                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sdbuf));
5941         }
5942         if (flags & NDR_OUT) {
5943                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5944         }
5945         return NDR_ERR_SUCCESS;
5946 }
5947
5948 static enum ndr_err_code ndr_pull_samr_SetSecurity(struct ndr_pull *ndr, int flags, struct samr_SetSecurity *r)
5949 {
5950         TALLOC_CTX *_mem_save_handle_0;
5951         TALLOC_CTX *_mem_save_sdbuf_0;
5952         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
5953         if (flags & NDR_IN) {
5954                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5955                         NDR_PULL_ALLOC(ndr, r->in.handle);
5956                 }
5957                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5958                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5959                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5960                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5961                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
5962                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5963                         NDR_PULL_ALLOC(ndr, r->in.sdbuf);
5964                 }
5965                 _mem_save_sdbuf_0 = NDR_PULL_GET_MEM_CTX(ndr);
5966                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sdbuf, LIBNDR_FLAG_REF_ALLOC);
5967                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sdbuf));
5968                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_0, LIBNDR_FLAG_REF_ALLOC);
5969         }
5970         if (flags & NDR_OUT) {
5971                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5972         }
5973         return NDR_ERR_SUCCESS;
5974 }
5975
5976 _PUBLIC_ void ndr_print_samr_SetSecurity(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetSecurity *r)
5977 {
5978         ndr_print_struct(ndr, name, "samr_SetSecurity");
5979         if (r == NULL) { ndr_print_null(ndr); return; }
5980         ndr->depth++;
5981         if (flags & NDR_SET_VALUES) {
5982                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5983         }
5984         if (flags & NDR_IN) {
5985                 ndr_print_struct(ndr, "in", "samr_SetSecurity");
5986                 ndr->depth++;
5987                 ndr_print_ptr(ndr, "handle", r->in.handle);
5988                 ndr->depth++;
5989                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5990                 ndr->depth--;
5991                 ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
5992                 ndr_print_ptr(ndr, "sdbuf", r->in.sdbuf);
5993                 ndr->depth++;
5994                 ndr_print_sec_desc_buf(ndr, "sdbuf", r->in.sdbuf);
5995                 ndr->depth--;
5996                 ndr->depth--;
5997         }
5998         if (flags & NDR_OUT) {
5999                 ndr_print_struct(ndr, "out", "samr_SetSecurity");
6000                 ndr->depth++;
6001                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6002                 ndr->depth--;
6003         }
6004         ndr->depth--;
6005 }
6006
6007 static enum ndr_err_code ndr_push_samr_QuerySecurity(struct ndr_push *ndr, int flags, const struct samr_QuerySecurity *r)
6008 {
6009         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
6010         if (flags & NDR_IN) {
6011                 if (r->in.handle == NULL) {
6012                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6013                 }
6014                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6015                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
6016         }
6017         if (flags & NDR_OUT) {
6018                 if (r->out.sdbuf == NULL) {
6019                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6020                 }
6021                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sdbuf));
6022                 if (*r->out.sdbuf) {
6023                         NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sdbuf));
6024                 }
6025                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6026         }
6027         return NDR_ERR_SUCCESS;
6028 }
6029
6030 static enum ndr_err_code ndr_pull_samr_QuerySecurity(struct ndr_pull *ndr, int flags, struct samr_QuerySecurity *r)
6031 {
6032         uint32_t _ptr_sdbuf;
6033         TALLOC_CTX *_mem_save_handle_0;
6034         TALLOC_CTX *_mem_save_sdbuf_0;
6035         TALLOC_CTX *_mem_save_sdbuf_1;
6036         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
6037         if (flags & NDR_IN) {
6038                 ZERO_STRUCT(r->out);
6039
6040                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6041                         NDR_PULL_ALLOC(ndr, r->in.handle);
6042                 }
6043                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6044                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6045                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6046                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6047                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
6048                 NDR_PULL_ALLOC(ndr, r->out.sdbuf);
6049                 ZERO_STRUCTP(r->out.sdbuf);
6050         }
6051         if (flags & NDR_OUT) {
6052                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6053                         NDR_PULL_ALLOC(ndr, r->out.sdbuf);
6054                 }
6055                 _mem_save_sdbuf_0 = NDR_PULL_GET_MEM_CTX(ndr);
6056                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sdbuf, LIBNDR_FLAG_REF_ALLOC);
6057                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sdbuf));
6058                 if (_ptr_sdbuf) {
6059                         NDR_PULL_ALLOC(ndr, *r->out.sdbuf);
6060                 } else {
6061                         *r->out.sdbuf = NULL;
6062                 }
6063                 if (*r->out.sdbuf) {
6064                         _mem_save_sdbuf_1 = NDR_PULL_GET_MEM_CTX(ndr);
6065                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sdbuf, 0);
6066                         NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sdbuf));
6067                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_1, 0);
6068                 }
6069                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_0, LIBNDR_FLAG_REF_ALLOC);
6070                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6071         }
6072         return NDR_ERR_SUCCESS;
6073 }
6074
6075 _PUBLIC_ void ndr_print_samr_QuerySecurity(struct ndr_print *ndr, const char *name, int flags, const struct samr_QuerySecurity *r)
6076 {
6077         ndr_print_struct(ndr, name, "samr_QuerySecurity");
6078         if (r == NULL) { ndr_print_null(ndr); return; }
6079         ndr->depth++;
6080         if (flags & NDR_SET_VALUES) {
6081                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6082         }
6083         if (flags & NDR_IN) {
6084                 ndr_print_struct(ndr, "in", "samr_QuerySecurity");
6085                 ndr->depth++;
6086                 ndr_print_ptr(ndr, "handle", r->in.handle);
6087                 ndr->depth++;
6088                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6089                 ndr->depth--;
6090                 ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
6091                 ndr->depth--;
6092         }
6093         if (flags & NDR_OUT) {
6094                 ndr_print_struct(ndr, "out", "samr_QuerySecurity");
6095                 ndr->depth++;
6096                 ndr_print_ptr(ndr, "sdbuf", r->out.sdbuf);
6097                 ndr->depth++;
6098                 ndr_print_ptr(ndr, "sdbuf", *r->out.sdbuf);
6099                 ndr->depth++;
6100                 if (*r->out.sdbuf) {
6101                         ndr_print_sec_desc_buf(ndr, "sdbuf", *r->out.sdbuf);
6102                 }
6103                 ndr->depth--;
6104                 ndr->depth--;
6105                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6106                 ndr->depth--;
6107         }
6108         ndr->depth--;
6109 }
6110
6111 static enum ndr_err_code ndr_push_samr_Shutdown(struct ndr_push *ndr, int flags, const struct samr_Shutdown *r)
6112 {
6113         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
6114         if (flags & NDR_IN) {
6115                 if (r->in.connect_handle == NULL) {
6116                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6117                 }
6118                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
6119         }
6120         if (flags & NDR_OUT) {
6121                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6122         }
6123         return NDR_ERR_SUCCESS;
6124 }
6125
6126 static enum ndr_err_code ndr_pull_samr_Shutdown(struct ndr_pull *ndr, int flags, struct samr_Shutdown *r)
6127 {
6128         TALLOC_CTX *_mem_save_connect_handle_0;
6129         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
6130         if (flags & NDR_IN) {
6131                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6132                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
6133                 }
6134                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6135                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
6136                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
6137                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
6138         }
6139         if (flags & NDR_OUT) {
6140                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6141         }
6142         return NDR_ERR_SUCCESS;
6143 }
6144
6145 _PUBLIC_ void ndr_print_samr_Shutdown(struct ndr_print *ndr, const char *name, int flags, const struct samr_Shutdown *r)
6146 {
6147         ndr_print_struct(ndr, name, "samr_Shutdown");
6148         if (r == NULL) { ndr_print_null(ndr); return; }
6149         ndr->depth++;
6150         if (flags & NDR_SET_VALUES) {
6151                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6152         }
6153         if (flags & NDR_IN) {
6154                 ndr_print_struct(ndr, "in", "samr_Shutdown");
6155                 ndr->depth++;
6156                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
6157                 ndr->depth++;
6158                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
6159                 ndr->depth--;
6160                 ndr->depth--;
6161         }
6162         if (flags & NDR_OUT) {
6163                 ndr_print_struct(ndr, "out", "samr_Shutdown");
6164                 ndr->depth++;
6165                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6166                 ndr->depth--;
6167         }
6168         ndr->depth--;
6169 }
6170
6171 static enum ndr_err_code ndr_push_samr_LookupDomain(struct ndr_push *ndr, int flags, const struct samr_LookupDomain *r)
6172 {
6173         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
6174         if (flags & NDR_IN) {
6175                 if (r->in.connect_handle == NULL) {
6176                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6177                 }
6178                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
6179                 if (r->in.domain_name == NULL) {
6180                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6181                 }
6182                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
6183         }
6184         if (flags & NDR_OUT) {
6185                 if (r->out.sid == NULL) {
6186                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6187                 }
6188                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sid));
6189                 if (*r->out.sid) {
6190                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
6191                 }
6192                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6193         }
6194         return NDR_ERR_SUCCESS;
6195 }
6196
6197 static enum ndr_err_code ndr_pull_samr_LookupDomain(struct ndr_pull *ndr, int flags, struct samr_LookupDomain *r)
6198 {
6199         uint32_t _ptr_sid;
6200         TALLOC_CTX *_mem_save_connect_handle_0;
6201         TALLOC_CTX *_mem_save_domain_name_0;
6202         TALLOC_CTX *_mem_save_sid_0;
6203         TALLOC_CTX *_mem_save_sid_1;
6204         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
6205         if (flags & NDR_IN) {
6206                 ZERO_STRUCT(r->out);
6207
6208                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6209                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
6210                 }
6211                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6212                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
6213                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
6214                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
6215                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6216                         NDR_PULL_ALLOC(ndr, r->in.domain_name);
6217                 }
6218                 _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6219                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_name, LIBNDR_FLAG_REF_ALLOC);
6220                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
6221                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, LIBNDR_FLAG_REF_ALLOC);
6222                 NDR_PULL_ALLOC(ndr, r->out.sid);
6223                 ZERO_STRUCTP(r->out.sid);
6224         }
6225         if (flags & NDR_OUT) {
6226                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6227                         NDR_PULL_ALLOC(ndr, r->out.sid);
6228                 }
6229                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6230                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);
6231                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
6232                 if (_ptr_sid) {
6233                         NDR_PULL_ALLOC(ndr, *r->out.sid);
6234                 } else {
6235                         *r->out.sid = NULL;
6236                 }
6237                 if (*r->out.sid) {
6238                         _mem_save_sid_1 = NDR_PULL_GET_MEM_CTX(ndr);
6239                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sid, 0);
6240                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
6241                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_1, 0);
6242                 }
6243                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
6244                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6245         }
6246         return NDR_ERR_SUCCESS;
6247 }
6248
6249 _PUBLIC_ void ndr_print_samr_LookupDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupDomain *r)
6250 {
6251         ndr_print_struct(ndr, name, "samr_LookupDomain");
6252         if (r == NULL) { ndr_print_null(ndr); return; }
6253         ndr->depth++;
6254         if (flags & NDR_SET_VALUES) {
6255                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6256         }
6257         if (flags & NDR_IN) {
6258                 ndr_print_struct(ndr, "in", "samr_LookupDomain");
6259                 ndr->depth++;
6260                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
6261                 ndr->depth++;
6262                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
6263                 ndr->depth--;
6264                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
6265                 ndr->depth++;
6266                 ndr_print_lsa_String(ndr, "domain_name", r->in.domain_name);
6267                 ndr->depth--;
6268                 ndr->depth--;
6269         }
6270         if (flags & NDR_OUT) {
6271                 ndr_print_struct(ndr, "out", "samr_LookupDomain");
6272                 ndr->depth++;
6273                 ndr_print_ptr(ndr, "sid", r->out.sid);
6274                 ndr->depth++;
6275                 ndr_print_ptr(ndr, "sid", *r->out.sid);
6276                 ndr->depth++;
6277                 if (*r->out.sid) {
6278                         ndr_print_dom_sid2(ndr, "sid", *r->out.sid);
6279                 }
6280                 ndr->depth--;
6281                 ndr->depth--;
6282                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6283                 ndr->depth--;
6284         }
6285         ndr->depth--;
6286 }
6287
6288 static enum ndr_err_code ndr_push_samr_EnumDomains(struct ndr_push *ndr, int flags, const struct samr_EnumDomains *r)
6289 {
6290         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
6291         if (flags & NDR_IN) {
6292                 if (r->in.connect_handle == NULL) {
6293                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6294                 }
6295                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
6296                 if (r->in.resume_handle == NULL) {
6297                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6298                 }
6299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6300                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
6301         }
6302         if (flags & NDR_OUT) {
6303                 if (r->out.resume_handle == NULL) {
6304                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6305                 }
6306                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6307                 if (r->out.sam == NULL) {
6308                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6309                 }
6310                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
6311                 if (*r->out.sam) {
6312                         NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6313                 }
6314                 if (r->out.num_entries == NULL) {
6315                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6316                 }
6317                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
6318                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6319         }
6320         return NDR_ERR_SUCCESS;
6321 }
6322
6323 static enum ndr_err_code ndr_pull_samr_EnumDomains(struct ndr_pull *ndr, int flags, struct samr_EnumDomains *r)
6324 {
6325         uint32_t _ptr_sam;
6326         TALLOC_CTX *_mem_save_connect_handle_0;
6327         TALLOC_CTX *_mem_save_resume_handle_0;
6328         TALLOC_CTX *_mem_save_sam_0;
6329         TALLOC_CTX *_mem_save_sam_1;
6330         TALLOC_CTX *_mem_save_num_entries_0;
6331         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
6332         if (flags & NDR_IN) {
6333                 ZERO_STRUCT(r->out);
6334
6335                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6336                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
6337                 }
6338                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6339                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
6340                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
6341                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
6342                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6343                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
6344                 }
6345                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6346                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6348                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6349                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
6350                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6351                 *r->out.resume_handle = *r->in.resume_handle;
6352                 NDR_PULL_ALLOC(ndr, r->out.sam);
6353                 ZERO_STRUCTP(r->out.sam);
6354                 NDR_PULL_ALLOC(ndr, r->out.num_entries);
6355                 ZERO_STRUCTP(r->out.num_entries);
6356         }
6357         if (flags & NDR_OUT) {
6358                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6359                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6360                 }
6361                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6362                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6363                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6364                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6365                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6366                         NDR_PULL_ALLOC(ndr, r->out.sam);
6367                 }
6368                 _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
6369                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
6370                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
6371                 if (_ptr_sam) {
6372                         NDR_PULL_ALLOC(ndr, *r->out.sam);
6373                 } else {
6374                         *r->out.sam = NULL;
6375                 }
6376                 if (*r->out.sam) {
6377                         _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
6378                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
6379                         NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6380                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
6381                 }
6382                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
6383                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6384                         NDR_PULL_ALLOC(ndr, r->out.num_entries);
6385                 }
6386                 _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
6387                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
6388                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
6389                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
6390                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6391         }
6392         return NDR_ERR_SUCCESS;
6393 }
6394
6395 _PUBLIC_ void ndr_print_samr_EnumDomains(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomains *r)
6396 {
6397         ndr_print_struct(ndr, name, "samr_EnumDomains");
6398         if (r == NULL) { ndr_print_null(ndr); return; }
6399         ndr->depth++;
6400         if (flags & NDR_SET_VALUES) {
6401                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6402         }
6403         if (flags & NDR_IN) {
6404                 ndr_print_struct(ndr, "in", "samr_EnumDomains");
6405                 ndr->depth++;
6406                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
6407                 ndr->depth++;
6408                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
6409                 ndr->depth--;
6410                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6411                 ndr->depth++;
6412                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6413                 ndr->depth--;
6414                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
6415                 ndr->depth--;
6416         }
6417         if (flags & NDR_OUT) {
6418                 ndr_print_struct(ndr, "out", "samr_EnumDomains");
6419                 ndr->depth++;
6420                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6421                 ndr->depth++;
6422                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6423                 ndr->depth--;
6424                 ndr_print_ptr(ndr, "sam", r->out.sam);
6425                 ndr->depth++;
6426                 ndr_print_ptr(ndr, "sam", *r->out.sam);
6427                 ndr->depth++;
6428                 if (*r->out.sam) {
6429                         ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
6430                 }
6431                 ndr->depth--;
6432                 ndr->depth--;
6433                 ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
6434                 ndr->depth++;
6435                 ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
6436                 ndr->depth--;
6437                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6438                 ndr->depth--;
6439         }
6440         ndr->depth--;
6441 }
6442
6443 _PUBLIC_ enum ndr_err_code ndr_push_samr_OpenDomain(struct ndr_push *ndr, int flags, const struct samr_OpenDomain *r)
6444 {
6445         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
6446         if (flags & NDR_IN) {
6447                 if (r->in.connect_handle == NULL) {
6448                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6449                 }
6450                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
6451                 NDR_CHECK(ndr_push_samr_DomainAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
6452                 if (r->in.sid == NULL) {
6453                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6454                 }
6455                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
6456         }
6457         if (flags & NDR_OUT) {
6458                 if (r->out.domain_handle == NULL) {
6459                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6460                 }
6461                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.domain_handle));
6462                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6463         }
6464         return NDR_ERR_SUCCESS;
6465 }
6466
6467 _PUBLIC_ enum ndr_err_code ndr_pull_samr_OpenDomain(struct ndr_pull *ndr, int flags, struct samr_OpenDomain *r)
6468 {
6469         TALLOC_CTX *_mem_save_connect_handle_0;
6470         TALLOC_CTX *_mem_save_sid_0;
6471         TALLOC_CTX *_mem_save_domain_handle_0;
6472         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
6473         if (flags & NDR_IN) {
6474                 ZERO_STRUCT(r->out);
6475
6476                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6477                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
6478                 }
6479                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6480                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
6481                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
6482                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
6483                 NDR_CHECK(ndr_pull_samr_DomainAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
6484                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6485                         NDR_PULL_ALLOC(ndr, r->in.sid);
6486                 }
6487                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6488                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
6489                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
6490                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
6491                 NDR_PULL_ALLOC(ndr, r->out.domain_handle);
6492                 ZERO_STRUCTP(r->out.domain_handle);
6493         }
6494         if (flags & NDR_OUT) {
6495                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6496                         NDR_PULL_ALLOC(ndr, r->out.domain_handle);
6497                 }
6498                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6499                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6500                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.domain_handle));
6501                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6502                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6503         }
6504         return NDR_ERR_SUCCESS;
6505 }
6506
6507 _PUBLIC_ void ndr_print_samr_OpenDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenDomain *r)
6508 {
6509         ndr_print_struct(ndr, name, "samr_OpenDomain");
6510         if (r == NULL) { ndr_print_null(ndr); return; }
6511         ndr->depth++;
6512         if (flags & NDR_SET_VALUES) {
6513                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6514         }
6515         if (flags & NDR_IN) {
6516                 ndr_print_struct(ndr, "in", "samr_OpenDomain");
6517                 ndr->depth++;
6518                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
6519                 ndr->depth++;
6520                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
6521                 ndr->depth--;
6522                 ndr_print_samr_DomainAccessMask(ndr, "access_mask", r->in.access_mask);
6523                 ndr_print_ptr(ndr, "sid", r->in.sid);
6524                 ndr->depth++;
6525                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
6526                 ndr->depth--;
6527                 ndr->depth--;
6528         }
6529         if (flags & NDR_OUT) {
6530                 ndr_print_struct(ndr, "out", "samr_OpenDomain");
6531                 ndr->depth++;
6532                 ndr_print_ptr(ndr, "domain_handle", r->out.domain_handle);
6533                 ndr->depth++;
6534                 ndr_print_policy_handle(ndr, "domain_handle", r->out.domain_handle);
6535                 ndr->depth--;
6536                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6537                 ndr->depth--;
6538         }
6539         ndr->depth--;
6540 }
6541
6542 static enum ndr_err_code ndr_push_samr_QueryDomainInfo(struct ndr_push *ndr, int flags, const struct samr_QueryDomainInfo *r)
6543 {
6544         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
6545         if (flags & NDR_IN) {
6546                 if (r->in.domain_handle == NULL) {
6547                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6548                 }
6549                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6550                 NDR_CHECK(ndr_push_samr_DomainInfoClass(ndr, NDR_SCALARS, r->in.level));
6551         }
6552         if (flags & NDR_OUT) {
6553                 if (r->out.info == NULL) {
6554                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6555                 }
6556                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
6557                 if (*r->out.info) {
6558                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
6559                         NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
6560                 }
6561                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6562         }
6563         return NDR_ERR_SUCCESS;
6564 }
6565
6566 static enum ndr_err_code ndr_pull_samr_QueryDomainInfo(struct ndr_pull *ndr, int flags, struct samr_QueryDomainInfo *r)
6567 {
6568         uint32_t _ptr_info;
6569         TALLOC_CTX *_mem_save_domain_handle_0;
6570         TALLOC_CTX *_mem_save_info_0;
6571         TALLOC_CTX *_mem_save_info_1;
6572         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
6573         if (flags & NDR_IN) {
6574                 ZERO_STRUCT(r->out);
6575
6576                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6577                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6578                 }
6579                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6580                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6581                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6582                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6583                 NDR_CHECK(ndr_pull_samr_DomainInfoClass(ndr, NDR_SCALARS, &r->in.level));
6584                 NDR_PULL_ALLOC(ndr, r->out.info);
6585                 ZERO_STRUCTP(r->out.info);
6586         }
6587         if (flags & NDR_OUT) {
6588                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6589                         NDR_PULL_ALLOC(ndr, r->out.info);
6590                 }
6591                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6592                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
6593                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
6594                 if (_ptr_info) {
6595                         NDR_PULL_ALLOC(ndr, *r->out.info);
6596                 } else {
6597                         *r->out.info = NULL;
6598                 }
6599                 if (*r->out.info) {
6600                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
6601                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
6602                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
6603                         NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
6604                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
6605                 }
6606                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6607                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6608         }
6609         return NDR_ERR_SUCCESS;
6610 }
6611
6612 _PUBLIC_ void ndr_print_samr_QueryDomainInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDomainInfo *r)
6613 {
6614         ndr_print_struct(ndr, name, "samr_QueryDomainInfo");
6615         if (r == NULL) { ndr_print_null(ndr); return; }
6616         ndr->depth++;
6617         if (flags & NDR_SET_VALUES) {
6618                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6619         }
6620         if (flags & NDR_IN) {
6621                 ndr_print_struct(ndr, "in", "samr_QueryDomainInfo");
6622                 ndr->depth++;
6623                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6624                 ndr->depth++;
6625                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6626                 ndr->depth--;
6627                 ndr_print_samr_DomainInfoClass(ndr, "level", r->in.level);
6628                 ndr->depth--;
6629         }
6630         if (flags & NDR_OUT) {
6631                 ndr_print_struct(ndr, "out", "samr_QueryDomainInfo");
6632                 ndr->depth++;
6633                 ndr_print_ptr(ndr, "info", r->out.info);
6634                 ndr->depth++;
6635                 ndr_print_ptr(ndr, "info", *r->out.info);
6636                 ndr->depth++;
6637                 if (*r->out.info) {
6638                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
6639                         ndr_print_samr_DomainInfo(ndr, "info", *r->out.info);
6640                 }
6641                 ndr->depth--;
6642                 ndr->depth--;
6643                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6644                 ndr->depth--;
6645         }
6646         ndr->depth--;
6647 }
6648
6649 static enum ndr_err_code ndr_push_samr_SetDomainInfo(struct ndr_push *ndr, int flags, const struct samr_SetDomainInfo *r)
6650 {
6651         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
6652         if (flags & NDR_IN) {
6653                 if (r->in.domain_handle == NULL) {
6654                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6655                 }
6656                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6657                 NDR_CHECK(ndr_push_samr_DomainInfoClass(ndr, NDR_SCALARS, r->in.level));
6658                 if (r->in.info == NULL) {
6659                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6660                 }
6661                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
6662                 NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6663         }
6664         if (flags & NDR_OUT) {
6665                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6666         }
6667         return NDR_ERR_SUCCESS;
6668 }
6669
6670 static enum ndr_err_code ndr_pull_samr_SetDomainInfo(struct ndr_pull *ndr, int flags, struct samr_SetDomainInfo *r)
6671 {
6672         TALLOC_CTX *_mem_save_domain_handle_0;
6673         TALLOC_CTX *_mem_save_info_0;
6674         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
6675         if (flags & NDR_IN) {
6676                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6677                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6678                 }
6679                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6680                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6681                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6682                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6683                 NDR_CHECK(ndr_pull_samr_DomainInfoClass(ndr, NDR_SCALARS, &r->in.level));
6684                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6685                         NDR_PULL_ALLOC(ndr, r->in.info);
6686                 }
6687                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6688                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
6689                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
6690                 NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6691                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6692         }
6693         if (flags & NDR_OUT) {
6694                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6695         }
6696         return NDR_ERR_SUCCESS;
6697 }
6698
6699 _PUBLIC_ void ndr_print_samr_SetDomainInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetDomainInfo *r)
6700 {
6701         ndr_print_struct(ndr, name, "samr_SetDomainInfo");
6702         if (r == NULL) { ndr_print_null(ndr); return; }
6703         ndr->depth++;
6704         if (flags & NDR_SET_VALUES) {
6705                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6706         }
6707         if (flags & NDR_IN) {
6708                 ndr_print_struct(ndr, "in", "samr_SetDomainInfo");
6709                 ndr->depth++;
6710                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6711                 ndr->depth++;
6712                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6713                 ndr->depth--;
6714                 ndr_print_samr_DomainInfoClass(ndr, "level", r->in.level);
6715                 ndr_print_ptr(ndr, "info", r->in.info);
6716                 ndr->depth++;
6717                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
6718                 ndr_print_samr_DomainInfo(ndr, "info", r->in.info);
6719                 ndr->depth--;
6720                 ndr->depth--;
6721         }
6722         if (flags & NDR_OUT) {
6723                 ndr_print_struct(ndr, "out", "samr_SetDomainInfo");
6724                 ndr->depth++;
6725                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6726                 ndr->depth--;
6727         }
6728         ndr->depth--;
6729 }
6730
6731 static enum ndr_err_code ndr_push_samr_CreateDomainGroup(struct ndr_push *ndr, int flags, const struct samr_CreateDomainGroup *r)
6732 {
6733         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
6734         if (flags & NDR_IN) {
6735                 if (r->in.domain_handle == NULL) {
6736                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6737                 }
6738                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6739                 if (r->in.name == NULL) {
6740                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6741                 }
6742                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
6743                 NDR_CHECK(ndr_push_samr_GroupAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
6744         }
6745         if (flags & NDR_OUT) {
6746                 if (r->out.group_handle == NULL) {
6747                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6748                 }
6749                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
6750                 if (r->out.rid == NULL) {
6751                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6752                 }
6753                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
6754                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6755         }
6756         return NDR_ERR_SUCCESS;
6757 }
6758
6759 static enum ndr_err_code ndr_pull_samr_CreateDomainGroup(struct ndr_pull *ndr, int flags, struct samr_CreateDomainGroup *r)
6760 {
6761         TALLOC_CTX *_mem_save_domain_handle_0;
6762         TALLOC_CTX *_mem_save_name_0;
6763         TALLOC_CTX *_mem_save_group_handle_0;
6764         TALLOC_CTX *_mem_save_rid_0;
6765         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
6766         if (flags & NDR_IN) {
6767                 ZERO_STRUCT(r->out);
6768
6769                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6770                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6771                 }
6772                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6773                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6774                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6775                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6776                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6777                         NDR_PULL_ALLOC(ndr, r->in.name);
6778                 }
6779                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6780                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
6781                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
6782                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
6783                 NDR_CHECK(ndr_pull_samr_GroupAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
6784                 NDR_PULL_ALLOC(ndr, r->out.group_handle);
6785                 ZERO_STRUCTP(r->out.group_handle);
6786                 NDR_PULL_ALLOC(ndr, r->out.rid);
6787                 ZERO_STRUCTP(r->out.rid);
6788         }
6789         if (flags & NDR_OUT) {
6790                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6791                         NDR_PULL_ALLOC(ndr, r->out.group_handle);
6792                 }
6793                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6794                 NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);
6795                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
6796                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
6797                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6798                         NDR_PULL_ALLOC(ndr, r->out.rid);
6799                 }
6800                 _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6801                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
6802                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
6803                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
6804                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6805         }
6806         return NDR_ERR_SUCCESS;
6807 }
6808
6809 _PUBLIC_ void ndr_print_samr_CreateDomainGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateDomainGroup *r)
6810 {
6811         ndr_print_struct(ndr, name, "samr_CreateDomainGroup");
6812         if (r == NULL) { ndr_print_null(ndr); return; }
6813         ndr->depth++;
6814         if (flags & NDR_SET_VALUES) {
6815                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6816         }
6817         if (flags & NDR_IN) {
6818                 ndr_print_struct(ndr, "in", "samr_CreateDomainGroup");
6819                 ndr->depth++;
6820                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6821                 ndr->depth++;
6822                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6823                 ndr->depth--;
6824                 ndr_print_ptr(ndr, "name", r->in.name);
6825                 ndr->depth++;
6826                 ndr_print_lsa_String(ndr, "name", r->in.name);
6827                 ndr->depth--;
6828                 ndr_print_samr_GroupAccessMask(ndr, "access_mask", r->in.access_mask);
6829                 ndr->depth--;
6830         }
6831         if (flags & NDR_OUT) {
6832                 ndr_print_struct(ndr, "out", "samr_CreateDomainGroup");
6833                 ndr->depth++;
6834                 ndr_print_ptr(ndr, "group_handle", r->out.group_handle);
6835                 ndr->depth++;
6836                 ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);
6837                 ndr->depth--;
6838                 ndr_print_ptr(ndr, "rid", r->out.rid);
6839                 ndr->depth++;
6840                 ndr_print_uint32(ndr, "rid", *r->out.rid);
6841                 ndr->depth--;
6842                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6843                 ndr->depth--;
6844         }
6845         ndr->depth--;
6846 }
6847
6848 static enum ndr_err_code ndr_push_samr_EnumDomainGroups(struct ndr_push *ndr, int flags, const struct samr_EnumDomainGroups *r)
6849 {
6850         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
6851         if (flags & NDR_IN) {
6852                 if (r->in.domain_handle == NULL) {
6853                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6854                 }
6855                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6856                 if (r->in.resume_handle == NULL) {
6857                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6858                 }
6859                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6860                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
6861         }
6862         if (flags & NDR_OUT) {
6863                 if (r->out.resume_handle == NULL) {
6864                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6865                 }
6866                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6867                 if (r->out.sam == NULL) {
6868                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6869                 }
6870                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
6871                 if (*r->out.sam) {
6872                         NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6873                 }
6874                 if (r->out.num_entries == NULL) {
6875                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6876                 }
6877                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
6878                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6879         }
6880         return NDR_ERR_SUCCESS;
6881 }
6882
6883 static enum ndr_err_code ndr_pull_samr_EnumDomainGroups(struct ndr_pull *ndr, int flags, struct samr_EnumDomainGroups *r)
6884 {
6885         uint32_t _ptr_sam;
6886         TALLOC_CTX *_mem_save_domain_handle_0;
6887         TALLOC_CTX *_mem_save_resume_handle_0;
6888         TALLOC_CTX *_mem_save_sam_0;
6889         TALLOC_CTX *_mem_save_sam_1;
6890         TALLOC_CTX *_mem_save_num_entries_0;
6891         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
6892         if (flags & NDR_IN) {
6893                 ZERO_STRUCT(r->out);
6894
6895                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6896                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6897                 }
6898                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6899                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6900                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6901                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6902                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6903                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
6904                 }
6905                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6906                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6907                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6908                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6909                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
6910                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6911                 *r->out.resume_handle = *r->in.resume_handle;
6912                 NDR_PULL_ALLOC(ndr, r->out.sam);
6913                 ZERO_STRUCTP(r->out.sam);
6914                 NDR_PULL_ALLOC(ndr, r->out.num_entries);
6915                 ZERO_STRUCTP(r->out.num_entries);
6916         }
6917         if (flags & NDR_OUT) {
6918                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6919                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6920                 }
6921                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6922                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6923                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6924                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6925                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6926                         NDR_PULL_ALLOC(ndr, r->out.sam);
6927                 }
6928                 _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
6929                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
6930                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
6931                 if (_ptr_sam) {
6932                         NDR_PULL_ALLOC(ndr, *r->out.sam);
6933                 } else {
6934                         *r->out.sam = NULL;
6935                 }
6936                 if (*r->out.sam) {
6937                         _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
6938                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
6939                         NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6940                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
6941                 }
6942                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
6943                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6944                         NDR_PULL_ALLOC(ndr, r->out.num_entries);
6945                 }
6946                 _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
6947                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
6948                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
6949                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
6950                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6951         }
6952         return NDR_ERR_SUCCESS;
6953 }
6954
6955 _PUBLIC_ void ndr_print_samr_EnumDomainGroups(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainGroups *r)
6956 {
6957         ndr_print_struct(ndr, name, "samr_EnumDomainGroups");
6958         if (r == NULL) { ndr_print_null(ndr); return; }
6959         ndr->depth++;
6960         if (flags & NDR_SET_VALUES) {
6961                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6962         }
6963         if (flags & NDR_IN) {
6964                 ndr_print_struct(ndr, "in", "samr_EnumDomainGroups");
6965                 ndr->depth++;
6966                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6967                 ndr->depth++;
6968                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6969                 ndr->depth--;
6970                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6971                 ndr->depth++;
6972                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6973                 ndr->depth--;
6974                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
6975                 ndr->depth--;
6976         }
6977         if (flags & NDR_OUT) {
6978                 ndr_print_struct(ndr, "out", "samr_EnumDomainGroups");
6979                 ndr->depth++;
6980                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6981                 ndr->depth++;
6982                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6983                 ndr->depth--;
6984                 ndr_print_ptr(ndr, "sam", r->out.sam);
6985                 ndr->depth++;
6986                 ndr_print_ptr(ndr, "sam", *r->out.sam);
6987                 ndr->depth++;
6988                 if (*r->out.sam) {
6989                         ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
6990                 }
6991                 ndr->depth--;
6992                 ndr->depth--;
6993                 ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
6994                 ndr->depth++;
6995                 ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
6996                 ndr->depth--;
6997                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6998                 ndr->depth--;
6999         }
7000         ndr->depth--;
7001 }
7002
7003 static enum ndr_err_code ndr_push_samr_CreateUser(struct ndr_push *ndr, int flags, const struct samr_CreateUser *r)
7004 {
7005         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
7006         if (flags & NDR_IN) {
7007                 if (r->in.domain_handle == NULL) {
7008                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7009                 }
7010                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7011                 if (r->in.account_name == NULL) {
7012                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7013                 }
7014                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
7015                 NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
7016         }
7017         if (flags & NDR_OUT) {
7018                 if (r->out.user_handle == NULL) {
7019                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7020                 }
7021                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
7022                 if (r->out.rid == NULL) {
7023                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7024                 }
7025                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
7026                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7027         }
7028         return NDR_ERR_SUCCESS;
7029 }
7030
7031 static enum ndr_err_code ndr_pull_samr_CreateUser(struct ndr_pull *ndr, int flags, struct samr_CreateUser *r)
7032 {
7033         TALLOC_CTX *_mem_save_domain_handle_0;
7034         TALLOC_CTX *_mem_save_account_name_0;
7035         TALLOC_CTX *_mem_save_user_handle_0;
7036         TALLOC_CTX *_mem_save_rid_0;
7037         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
7038         if (flags & NDR_IN) {
7039                 ZERO_STRUCT(r->out);
7040
7041                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7042                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7043                 }
7044                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7045                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7046                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7047                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7048                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7049                         NDR_PULL_ALLOC(ndr, r->in.account_name);
7050                 }
7051                 _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7052                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account_name, LIBNDR_FLAG_REF_ALLOC);
7053                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
7054                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, LIBNDR_FLAG_REF_ALLOC);
7055                 NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
7056                 NDR_PULL_ALLOC(ndr, r->out.user_handle);
7057                 ZERO_STRUCTP(r->out.user_handle);
7058                 NDR_PULL_ALLOC(ndr, r->out.rid);
7059                 ZERO_STRUCTP(r->out.rid);
7060         }
7061         if (flags & NDR_OUT) {
7062                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7063                         NDR_PULL_ALLOC(ndr, r->out.user_handle);
7064                 }
7065                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7066                 NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
7067                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
7068                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
7069                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7070                         NDR_PULL_ALLOC(ndr, r->out.rid);
7071                 }
7072                 _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7073                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
7074                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
7075                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
7076                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7077         }
7078         return NDR_ERR_SUCCESS;
7079 }
7080
7081 _PUBLIC_ void ndr_print_samr_CreateUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateUser *r)
7082 {
7083         ndr_print_struct(ndr, name, "samr_CreateUser");
7084         if (r == NULL) { ndr_print_null(ndr); return; }
7085         ndr->depth++;
7086         if (flags & NDR_SET_VALUES) {
7087                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7088         }
7089         if (flags & NDR_IN) {
7090                 ndr_print_struct(ndr, "in", "samr_CreateUser");
7091                 ndr->depth++;
7092                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7093                 ndr->depth++;
7094                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7095                 ndr->depth--;
7096                 ndr_print_ptr(ndr, "account_name", r->in.account_name);
7097                 ndr->depth++;
7098                 ndr_print_lsa_String(ndr, "account_name", r->in.account_name);
7099                 ndr->depth--;
7100                 ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);
7101                 ndr->depth--;
7102         }
7103         if (flags & NDR_OUT) {
7104                 ndr_print_struct(ndr, "out", "samr_CreateUser");
7105                 ndr->depth++;
7106                 ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
7107                 ndr->depth++;
7108                 ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
7109                 ndr->depth--;
7110                 ndr_print_ptr(ndr, "rid", r->out.rid);
7111                 ndr->depth++;
7112                 ndr_print_uint32(ndr, "rid", *r->out.rid);
7113                 ndr->depth--;
7114                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7115                 ndr->depth--;
7116         }
7117         ndr->depth--;
7118 }
7119
7120 static enum ndr_err_code ndr_push_samr_EnumDomainUsers(struct ndr_push *ndr, int flags, const struct samr_EnumDomainUsers *r)
7121 {
7122         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
7123         if (flags & NDR_IN) {
7124                 if (r->in.domain_handle == NULL) {
7125                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7126                 }
7127                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7128                 if (r->in.resume_handle == NULL) {
7129                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7130                 }
7131                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
7132                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->in.acct_flags));
7133                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
7134         }
7135         if (flags & NDR_OUT) {
7136                 if (r->out.resume_handle == NULL) {
7137                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7138                 }
7139                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
7140                 if (r->out.sam == NULL) {
7141                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7142                 }
7143                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
7144                 if (*r->out.sam) {
7145                         NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
7146                 }
7147                 if (r->out.num_entries == NULL) {
7148                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7149                 }
7150                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
7151                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7152         }
7153         return NDR_ERR_SUCCESS;
7154 }
7155
7156 static enum ndr_err_code ndr_pull_samr_EnumDomainUsers(struct ndr_pull *ndr, int flags, struct samr_EnumDomainUsers *r)
7157 {
7158         uint32_t _ptr_sam;
7159         TALLOC_CTX *_mem_save_domain_handle_0;
7160         TALLOC_CTX *_mem_save_resume_handle_0;
7161         TALLOC_CTX *_mem_save_sam_0;
7162         TALLOC_CTX *_mem_save_sam_1;
7163         TALLOC_CTX *_mem_save_num_entries_0;
7164         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
7165         if (flags & NDR_IN) {
7166                 ZERO_STRUCT(r->out);
7167
7168                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7169                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7170                 }
7171                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7172                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7173                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7174                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7175                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7176                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
7177                 }
7178                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7179                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
7180                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
7181                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
7182                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->in.acct_flags));
7183                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
7184                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
7185                 *r->out.resume_handle = *r->in.resume_handle;
7186                 NDR_PULL_ALLOC(ndr, r->out.sam);
7187                 ZERO_STRUCTP(r->out.sam);
7188                 NDR_PULL_ALLOC(ndr, r->out.num_entries);
7189                 ZERO_STRUCTP(r->out.num_entries);
7190         }
7191         if (flags & NDR_OUT) {
7192                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7193                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
7194                 }
7195                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7196                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
7197                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
7198                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
7199                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7200                         NDR_PULL_ALLOC(ndr, r->out.sam);
7201                 }
7202                 _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
7203                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
7204                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
7205                 if (_ptr_sam) {
7206                         NDR_PULL_ALLOC(ndr, *r->out.sam);
7207                 } else {
7208                         *r->out.sam = NULL;
7209                 }
7210                 if (*r->out.sam) {
7211                         _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
7212                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
7213                         NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
7214                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
7215                 }
7216                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
7217                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7218                         NDR_PULL_ALLOC(ndr, r->out.num_entries);
7219                 }
7220                 _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
7221                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
7222                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
7223                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
7224                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7225         }
7226         return NDR_ERR_SUCCESS;
7227 }
7228
7229 _PUBLIC_ void ndr_print_samr_EnumDomainUsers(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainUsers *r)
7230 {
7231         ndr_print_struct(ndr, name, "samr_EnumDomainUsers");
7232         if (r == NULL) { ndr_print_null(ndr); return; }
7233         ndr->depth++;
7234         if (flags & NDR_SET_VALUES) {
7235                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7236         }
7237         if (flags & NDR_IN) {
7238                 ndr_print_struct(ndr, "in", "samr_EnumDomainUsers");
7239                 ndr->depth++;
7240                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7241                 ndr->depth++;
7242                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7243                 ndr->depth--;
7244                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
7245                 ndr->depth++;
7246                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
7247                 ndr->depth--;
7248                 ndr_print_samr_AcctFlags(ndr, "acct_flags", r->in.acct_flags);
7249                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
7250                 ndr->depth--;
7251         }
7252         if (flags & NDR_OUT) {
7253                 ndr_print_struct(ndr, "out", "samr_EnumDomainUsers");
7254                 ndr->depth++;
7255                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
7256                 ndr->depth++;
7257                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
7258                 ndr->depth--;
7259                 ndr_print_ptr(ndr, "sam", r->out.sam);
7260                 ndr->depth++;
7261                 ndr_print_ptr(ndr, "sam", *r->out.sam);
7262                 ndr->depth++;
7263                 if (*r->out.sam) {
7264                         ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
7265                 }
7266                 ndr->depth--;
7267                 ndr->depth--;
7268                 ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
7269                 ndr->depth++;
7270                 ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
7271                 ndr->depth--;
7272                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7273                 ndr->depth--;
7274         }
7275         ndr->depth--;
7276 }
7277
7278 static enum ndr_err_code ndr_push_samr_CreateDomAlias(struct ndr_push *ndr, int flags, const struct samr_CreateDomAlias *r)
7279 {
7280         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
7281         if (flags & NDR_IN) {
7282                 if (r->in.domain_handle == NULL) {
7283                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7284                 }
7285                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7286                 if (r->in.alias_name == NULL) {
7287                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7288                 }
7289                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.alias_name));
7290                 NDR_CHECK(ndr_push_samr_AliasAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
7291         }
7292         if (flags & NDR_OUT) {
7293                 if (r->out.alias_handle == NULL) {
7294                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7295                 }
7296                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
7297                 if (r->out.rid == NULL) {
7298                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7299                 }
7300                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
7301                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7302         }
7303         return NDR_ERR_SUCCESS;
7304 }
7305
7306 static enum ndr_err_code ndr_pull_samr_CreateDomAlias(struct ndr_pull *ndr, int flags, struct samr_CreateDomAlias *r)
7307 {
7308         TALLOC_CTX *_mem_save_domain_handle_0;
7309         TALLOC_CTX *_mem_save_alias_name_0;
7310         TALLOC_CTX *_mem_save_alias_handle_0;
7311         TALLOC_CTX *_mem_save_rid_0;
7312         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
7313         if (flags & NDR_IN) {
7314                 ZERO_STRUCT(r->out);
7315
7316                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7317                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7318                 }
7319                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7320                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7321                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7322                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7323                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7324                         NDR_PULL_ALLOC(ndr, r->in.alias_name);
7325                 }
7326                 _mem_save_alias_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7327                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_name, LIBNDR_FLAG_REF_ALLOC);
7328                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.alias_name));
7329                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_name_0, LIBNDR_FLAG_REF_ALLOC);
7330                 NDR_CHECK(ndr_pull_samr_AliasAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
7331                 NDR_PULL_ALLOC(ndr, r->out.alias_handle);
7332                 ZERO_STRUCTP(r->out.alias_handle);
7333                 NDR_PULL_ALLOC(ndr, r->out.rid);
7334                 ZERO_STRUCTP(r->out.rid);
7335         }
7336         if (flags & NDR_OUT) {
7337                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7338                         NDR_PULL_ALLOC(ndr, r->out.alias_handle);
7339                 }
7340                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7341                 NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);
7342                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
7343                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
7344                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7345                         NDR_PULL_ALLOC(ndr, r->out.rid);
7346                 }
7347                 _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7348                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
7349                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
7350                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
7351                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7352         }
7353         return NDR_ERR_SUCCESS;
7354 }
7355
7356 _PUBLIC_ void ndr_print_samr_CreateDomAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateDomAlias *r)
7357 {
7358         ndr_print_struct(ndr, name, "samr_CreateDomAlias");
7359         if (r == NULL) { ndr_print_null(ndr); return; }
7360         ndr->depth++;
7361         if (flags & NDR_SET_VALUES) {
7362                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7363         }
7364         if (flags & NDR_IN) {
7365                 ndr_print_struct(ndr, "in", "samr_CreateDomAlias");
7366                 ndr->depth++;
7367                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7368                 ndr->depth++;
7369                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7370                 ndr->depth--;
7371                 ndr_print_ptr(ndr, "alias_name", r->in.alias_name);
7372                 ndr->depth++;
7373                 ndr_print_lsa_String(ndr, "alias_name", r->in.alias_name);
7374                 ndr->depth--;
7375                 ndr_print_samr_AliasAccessMask(ndr, "access_mask", r->in.access_mask);
7376                 ndr->depth--;
7377         }
7378         if (flags & NDR_OUT) {
7379                 ndr_print_struct(ndr, "out", "samr_CreateDomAlias");
7380                 ndr->depth++;
7381                 ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);
7382                 ndr->depth++;
7383                 ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);
7384                 ndr->depth--;
7385                 ndr_print_ptr(ndr, "rid", r->out.rid);
7386                 ndr->depth++;
7387                 ndr_print_uint32(ndr, "rid", *r->out.rid);
7388                 ndr->depth--;
7389                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7390                 ndr->depth--;
7391         }
7392         ndr->depth--;
7393 }
7394
7395 static enum ndr_err_code ndr_push_samr_EnumDomainAliases(struct ndr_push *ndr, int flags, const struct samr_EnumDomainAliases *r)
7396 {
7397         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
7398         if (flags & NDR_IN) {
7399                 if (r->in.domain_handle == NULL) {
7400                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7401                 }
7402                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7403                 if (r->in.resume_handle == NULL) {
7404                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7405                 }
7406                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
7407                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
7408         }
7409         if (flags & NDR_OUT) {
7410                 if (r->out.resume_handle == NULL) {
7411                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7412                 }
7413                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
7414                 if (r->out.sam == NULL) {
7415                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7416                 }
7417                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
7418                 if (*r->out.sam) {
7419                         NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
7420                 }
7421                 if (r->out.num_entries == NULL) {
7422                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7423                 }
7424                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
7425                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7426         }
7427         return NDR_ERR_SUCCESS;
7428 }
7429
7430 static enum ndr_err_code ndr_pull_samr_EnumDomainAliases(struct ndr_pull *ndr, int flags, struct samr_EnumDomainAliases *r)
7431 {
7432         uint32_t _ptr_sam;
7433         TALLOC_CTX *_mem_save_domain_handle_0;
7434         TALLOC_CTX *_mem_save_resume_handle_0;
7435         TALLOC_CTX *_mem_save_sam_0;
7436         TALLOC_CTX *_mem_save_sam_1;
7437         TALLOC_CTX *_mem_save_num_entries_0;
7438         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
7439         if (flags & NDR_IN) {
7440                 ZERO_STRUCT(r->out);
7441
7442                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7443                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7444                 }
7445                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7446                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7447                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7448                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7449                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7450                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
7451                 }
7452                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7453                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
7454                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
7455                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
7456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
7457                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
7458                 *r->out.resume_handle = *r->in.resume_handle;
7459                 NDR_PULL_ALLOC(ndr, r->out.sam);
7460                 ZERO_STRUCTP(r->out.sam);
7461                 NDR_PULL_ALLOC(ndr, r->out.num_entries);
7462                 ZERO_STRUCTP(r->out.num_entries);
7463         }
7464         if (flags & NDR_OUT) {
7465                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7466                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
7467                 }
7468                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7469                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
7470                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
7471                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
7472                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7473                         NDR_PULL_ALLOC(ndr, r->out.sam);
7474                 }
7475                 _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
7476                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
7477                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
7478                 if (_ptr_sam) {
7479                         NDR_PULL_ALLOC(ndr, *r->out.sam);
7480                 } else {
7481                         *r->out.sam = NULL;
7482                 }
7483                 if (*r->out.sam) {
7484                         _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
7485                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
7486                         NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
7487                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
7488                 }
7489                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
7490                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7491                         NDR_PULL_ALLOC(ndr, r->out.num_entries);
7492                 }
7493                 _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
7494                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
7495                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
7496                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
7497                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7498         }
7499         return NDR_ERR_SUCCESS;
7500 }
7501
7502 _PUBLIC_ void ndr_print_samr_EnumDomainAliases(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainAliases *r)
7503 {
7504         ndr_print_struct(ndr, name, "samr_EnumDomainAliases");
7505         if (r == NULL) { ndr_print_null(ndr); return; }
7506         ndr->depth++;
7507         if (flags & NDR_SET_VALUES) {
7508                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7509         }
7510         if (flags & NDR_IN) {
7511                 ndr_print_struct(ndr, "in", "samr_EnumDomainAliases");
7512                 ndr->depth++;
7513                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7514                 ndr->depth++;
7515                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7516                 ndr->depth--;
7517                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
7518                 ndr->depth++;
7519                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
7520                 ndr->depth--;
7521                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
7522                 ndr->depth--;
7523         }
7524         if (flags & NDR_OUT) {
7525                 ndr_print_struct(ndr, "out", "samr_EnumDomainAliases");
7526                 ndr->depth++;
7527                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
7528                 ndr->depth++;
7529                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
7530                 ndr->depth--;
7531                 ndr_print_ptr(ndr, "sam", r->out.sam);
7532                 ndr->depth++;
7533                 ndr_print_ptr(ndr, "sam", *r->out.sam);
7534                 ndr->depth++;
7535                 if (*r->out.sam) {
7536                         ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
7537                 }
7538                 ndr->depth--;
7539                 ndr->depth--;
7540                 ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
7541                 ndr->depth++;
7542                 ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
7543                 ndr->depth--;
7544                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7545                 ndr->depth--;
7546         }
7547         ndr->depth--;
7548 }
7549
7550 static enum ndr_err_code ndr_push_samr_GetAliasMembership(struct ndr_push *ndr, int flags, const struct samr_GetAliasMembership *r)
7551 {
7552         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
7553         if (flags & NDR_IN) {
7554                 if (r->in.domain_handle == NULL) {
7555                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7556                 }
7557                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7558                 if (r->in.sids == NULL) {
7559                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7560                 }
7561                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
7562         }
7563         if (flags & NDR_OUT) {
7564                 if (r->out.rids == NULL) {
7565                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7566                 }
7567                 NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
7568                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7569         }
7570         return NDR_ERR_SUCCESS;
7571 }
7572
7573 static enum ndr_err_code ndr_pull_samr_GetAliasMembership(struct ndr_pull *ndr, int flags, struct samr_GetAliasMembership *r)
7574 {
7575         TALLOC_CTX *_mem_save_domain_handle_0;
7576         TALLOC_CTX *_mem_save_sids_0;
7577         TALLOC_CTX *_mem_save_rids_0;
7578         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
7579         if (flags & NDR_IN) {
7580                 ZERO_STRUCT(r->out);
7581
7582                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7583                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7584                 }
7585                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7586                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7587                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7588                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7589                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7590                         NDR_PULL_ALLOC(ndr, r->in.sids);
7591                 }
7592                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7593                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
7594                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
7595                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
7596                 NDR_PULL_ALLOC(ndr, r->out.rids);
7597                 ZERO_STRUCTP(r->out.rids);
7598         }
7599         if (flags & NDR_OUT) {
7600                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7601                         NDR_PULL_ALLOC(ndr, r->out.rids);
7602                 }
7603                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7604                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
7605                 NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
7606                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
7607                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7608         }
7609         return NDR_ERR_SUCCESS;
7610 }
7611
7612 _PUBLIC_ void ndr_print_samr_GetAliasMembership(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetAliasMembership *r)
7613 {
7614         ndr_print_struct(ndr, name, "samr_GetAliasMembership");
7615         if (r == NULL) { ndr_print_null(ndr); return; }
7616         ndr->depth++;
7617         if (flags & NDR_SET_VALUES) {
7618                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7619         }
7620         if (flags & NDR_IN) {
7621                 ndr_print_struct(ndr, "in", "samr_GetAliasMembership");
7622                 ndr->depth++;
7623                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7624                 ndr->depth++;
7625                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7626                 ndr->depth--;
7627                 ndr_print_ptr(ndr, "sids", r->in.sids);
7628                 ndr->depth++;
7629                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
7630                 ndr->depth--;
7631                 ndr->depth--;
7632         }
7633         if (flags & NDR_OUT) {
7634                 ndr_print_struct(ndr, "out", "samr_GetAliasMembership");
7635                 ndr->depth++;
7636                 ndr_print_ptr(ndr, "rids", r->out.rids);
7637                 ndr->depth++;
7638                 ndr_print_samr_Ids(ndr, "rids", r->out.rids);
7639                 ndr->depth--;
7640                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7641                 ndr->depth--;
7642         }
7643         ndr->depth--;
7644 }
7645
7646 _PUBLIC_ enum ndr_err_code ndr_push_samr_LookupNames(struct ndr_push *ndr, int flags, const struct samr_LookupNames *r)
7647 {
7648         uint32_t cntr_names_0;
7649         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
7650         if (flags & NDR_IN) {
7651                 if (r->in.domain_handle == NULL) {
7652                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7653                 }
7654                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7655                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
7656                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 1000));
7657                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7658                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_names));
7659                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
7660                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
7661                 }
7662                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
7663                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
7664                 }
7665         }
7666         if (flags & NDR_OUT) {
7667                 if (r->out.rids == NULL) {
7668                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7669                 }
7670                 NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
7671                 if (r->out.types == NULL) {
7672                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7673                 }
7674                 NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
7675                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7676         }
7677         return NDR_ERR_SUCCESS;
7678 }
7679
7680 _PUBLIC_ enum ndr_err_code ndr_pull_samr_LookupNames(struct ndr_pull *ndr, int flags, struct samr_LookupNames *r)
7681 {
7682         uint32_t size_names_0 = 0;
7683         uint32_t length_names_0 = 0;
7684         uint32_t cntr_names_0;
7685         TALLOC_CTX *_mem_save_domain_handle_0;
7686         TALLOC_CTX *_mem_save_names_0;
7687         TALLOC_CTX *_mem_save_rids_0;
7688         TALLOC_CTX *_mem_save_types_0;
7689         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
7690         if (flags & NDR_IN) {
7691                 ZERO_STRUCT(r->out);
7692
7693                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7694                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7695                 }
7696                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7697                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7698                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7699                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7700                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
7701                 if (r->in.num_names > 1000) {
7702                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7703                 }
7704                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
7705                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.names));
7706                 size_names_0 = ndr_get_array_size(ndr, &r->in.names);
7707                 length_names_0 = ndr_get_array_length(ndr, &r->in.names);
7708                 if (length_names_0 > size_names_0) {
7709                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_names_0, length_names_0);
7710                 }
7711                 NDR_PULL_ALLOC_N(ndr, r->in.names, size_names_0);
7712                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
7713                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
7714                 for (cntr_names_0 = 0; cntr_names_0 < length_names_0; cntr_names_0++) {
7715                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
7716                 }
7717                 for (cntr_names_0 = 0; cntr_names_0 < length_names_0; cntr_names_0++) {
7718                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
7719                 }
7720                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
7721                 NDR_PULL_ALLOC(ndr, r->out.rids);
7722                 ZERO_STRUCTP(r->out.rids);
7723                 NDR_PULL_ALLOC(ndr, r->out.types);
7724                 ZERO_STRUCTP(r->out.types);
7725                 if (r->in.names) {
7726                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, 1000));
7727                 }
7728                 if (r->in.names) {
7729                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.names, r->in.num_names));
7730                 }
7731         }
7732         if (flags & NDR_OUT) {
7733                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7734                         NDR_PULL_ALLOC(ndr, r->out.rids);
7735                 }
7736                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7737                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
7738                 NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
7739                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
7740                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7741                         NDR_PULL_ALLOC(ndr, r->out.types);
7742                 }
7743                 _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
7744                 NDR_PULL_SET_MEM_CTX(ndr, r->out.types, LIBNDR_FLAG_REF_ALLOC);
7745                 NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
7746                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, LIBNDR_FLAG_REF_ALLOC);
7747                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7748         }
7749         return NDR_ERR_SUCCESS;
7750 }
7751
7752 _PUBLIC_ void ndr_print_samr_LookupNames(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupNames *r)
7753 {
7754         uint32_t cntr_names_0;
7755         ndr_print_struct(ndr, name, "samr_LookupNames");
7756         if (r == NULL) { ndr_print_null(ndr); return; }
7757         ndr->depth++;
7758         if (flags & NDR_SET_VALUES) {
7759                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7760         }
7761         if (flags & NDR_IN) {
7762                 ndr_print_struct(ndr, "in", "samr_LookupNames");
7763                 ndr->depth++;
7764                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7765                 ndr->depth++;
7766                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7767                 ndr->depth--;
7768                 ndr_print_uint32(ndr, "num_names", r->in.num_names);
7769                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->in.num_names);
7770                 ndr->depth++;
7771                 for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
7772                         ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
7773                 }
7774                 ndr->depth--;
7775                 ndr->depth--;
7776         }
7777         if (flags & NDR_OUT) {
7778                 ndr_print_struct(ndr, "out", "samr_LookupNames");
7779                 ndr->depth++;
7780                 ndr_print_ptr(ndr, "rids", r->out.rids);
7781                 ndr->depth++;
7782                 ndr_print_samr_Ids(ndr, "rids", r->out.rids);
7783                 ndr->depth--;
7784                 ndr_print_ptr(ndr, "types", r->out.types);
7785                 ndr->depth++;
7786                 ndr_print_samr_Ids(ndr, "types", r->out.types);
7787                 ndr->depth--;
7788                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7789                 ndr->depth--;
7790         }
7791         ndr->depth--;
7792 }
7793
7794 static enum ndr_err_code ndr_push_samr_LookupRids(struct ndr_push *ndr, int flags, const struct samr_LookupRids *r)
7795 {
7796         uint32_t cntr_rids_0;
7797         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
7798         if (flags & NDR_IN) {
7799                 if (r->in.domain_handle == NULL) {
7800                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7801                 }
7802                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7803                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_rids));
7804                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 1000));
7805                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7806                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_rids));
7807                 for (cntr_rids_0 = 0; cntr_rids_0 < r->in.num_rids; cntr_rids_0++) {
7808                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rids[cntr_rids_0]));
7809                 }
7810         }
7811         if (flags & NDR_OUT) {
7812                 if (r->out.names == NULL) {
7813                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7814                 }
7815                 NDR_CHECK(ndr_push_lsa_Strings(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
7816                 if (r->out.types == NULL) {
7817                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7818                 }
7819                 NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
7820                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7821         }
7822         return NDR_ERR_SUCCESS;
7823 }
7824
7825 static enum ndr_err_code ndr_pull_samr_LookupRids(struct ndr_pull *ndr, int flags, struct samr_LookupRids *r)
7826 {
7827         uint32_t size_rids_0 = 0;
7828         uint32_t length_rids_0 = 0;
7829         uint32_t cntr_rids_0;
7830         TALLOC_CTX *_mem_save_domain_handle_0;
7831         TALLOC_CTX *_mem_save_rids_0;
7832         TALLOC_CTX *_mem_save_names_0;
7833         TALLOC_CTX *_mem_save_types_0;
7834         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
7835         if (flags & NDR_IN) {
7836                 ZERO_STRUCT(r->out);
7837
7838                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7839                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7840                 }
7841                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7842                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7843                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7844                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7845                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_rids));
7846                 if (r->in.num_rids > 1000) {
7847                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7848                 }
7849                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.rids));
7850                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.rids));
7851                 size_rids_0 = ndr_get_array_size(ndr, &r->in.rids);
7852                 length_rids_0 = ndr_get_array_length(ndr, &r->in.rids);
7853                 if (length_rids_0 > size_rids_0) {
7854                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_rids_0, length_rids_0);
7855                 }
7856                 NDR_PULL_ALLOC_N(ndr, r->in.rids, size_rids_0);
7857                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7858                 NDR_PULL_SET_MEM_CTX(ndr, r->in.rids, 0);
7859                 for (cntr_rids_0 = 0; cntr_rids_0 < length_rids_0; cntr_rids_0++) {
7860                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rids[cntr_rids_0]));
7861                 }
7862                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
7863                 NDR_PULL_ALLOC(ndr, r->out.names);
7864                 ZERO_STRUCTP(r->out.names);
7865                 NDR_PULL_ALLOC(ndr, r->out.types);
7866                 ZERO_STRUCTP(r->out.types);
7867                 if (r->in.rids) {
7868                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.rids, 1000));
7869                 }
7870                 if (r->in.rids) {
7871                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.rids, r->in.num_rids));
7872                 }
7873         }
7874         if (flags & NDR_OUT) {
7875                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7876                         NDR_PULL_ALLOC(ndr, r->out.names);
7877                 }
7878                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
7879                 NDR_PULL_SET_MEM_CTX(ndr, r->out.names, LIBNDR_FLAG_REF_ALLOC);
7880                 NDR_CHECK(ndr_pull_lsa_Strings(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
7881                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
7882                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7883                         NDR_PULL_ALLOC(ndr, r->out.types);
7884                 }
7885                 _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
7886                 NDR_PULL_SET_MEM_CTX(ndr, r->out.types, LIBNDR_FLAG_REF_ALLOC);
7887                 NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
7888                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, LIBNDR_FLAG_REF_ALLOC);
7889                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7890         }
7891         return NDR_ERR_SUCCESS;
7892 }
7893
7894 _PUBLIC_ void ndr_print_samr_LookupRids(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupRids *r)
7895 {
7896         uint32_t cntr_rids_0;
7897         ndr_print_struct(ndr, name, "samr_LookupRids");
7898         if (r == NULL) { ndr_print_null(ndr); return; }
7899         ndr->depth++;
7900         if (flags & NDR_SET_VALUES) {
7901                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7902         }
7903         if (flags & NDR_IN) {
7904                 ndr_print_struct(ndr, "in", "samr_LookupRids");
7905                 ndr->depth++;
7906                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7907                 ndr->depth++;
7908                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7909                 ndr->depth--;
7910                 ndr_print_uint32(ndr, "num_rids", r->in.num_rids);
7911                 ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->in.num_rids);
7912                 ndr->depth++;
7913                 for (cntr_rids_0=0;cntr_rids_0<r->in.num_rids;cntr_rids_0++) {
7914                         ndr_print_uint32(ndr, "rids", r->in.rids[cntr_rids_0]);
7915                 }
7916                 ndr->depth--;
7917                 ndr->depth--;
7918         }
7919         if (flags & NDR_OUT) {
7920                 ndr_print_struct(ndr, "out", "samr_LookupRids");
7921                 ndr->depth++;
7922                 ndr_print_ptr(ndr, "names", r->out.names);
7923                 ndr->depth++;
7924                 ndr_print_lsa_Strings(ndr, "names", r->out.names);
7925                 ndr->depth--;
7926                 ndr_print_ptr(ndr, "types", r->out.types);
7927                 ndr->depth++;
7928                 ndr_print_samr_Ids(ndr, "types", r->out.types);
7929                 ndr->depth--;
7930                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7931                 ndr->depth--;
7932         }
7933         ndr->depth--;
7934 }
7935
7936 static enum ndr_err_code ndr_push_samr_OpenGroup(struct ndr_push *ndr, int flags, const struct samr_OpenGroup *r)
7937 {
7938         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
7939         if (flags & NDR_IN) {
7940                 if (r->in.domain_handle == NULL) {
7941                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7942                 }
7943                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7944                 NDR_CHECK(ndr_push_samr_GroupAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
7945                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
7946         }
7947         if (flags & NDR_OUT) {
7948                 if (r->out.group_handle == NULL) {
7949                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7950                 }
7951                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
7952                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7953         }
7954         return NDR_ERR_SUCCESS;
7955 }
7956
7957 static enum ndr_err_code ndr_pull_samr_OpenGroup(struct ndr_pull *ndr, int flags, struct samr_OpenGroup *r)
7958 {
7959         TALLOC_CTX *_mem_save_domain_handle_0;
7960         TALLOC_CTX *_mem_save_group_handle_0;
7961         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
7962         if (flags & NDR_IN) {
7963                 ZERO_STRUCT(r->out);
7964
7965                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7966                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7967                 }
7968                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7969                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7970                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7971                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7972                 NDR_CHECK(ndr_pull_samr_GroupAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
7973                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
7974                 NDR_PULL_ALLOC(ndr, r->out.group_handle);
7975                 ZERO_STRUCTP(r->out.group_handle);
7976         }
7977         if (flags & NDR_OUT) {
7978                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7979                         NDR_PULL_ALLOC(ndr, r->out.group_handle);
7980                 }
7981                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7982                 NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);
7983                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
7984                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7985                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7986         }
7987         return NDR_ERR_SUCCESS;
7988 }
7989
7990 _PUBLIC_ void ndr_print_samr_OpenGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenGroup *r)
7991 {
7992         ndr_print_struct(ndr, name, "samr_OpenGroup");
7993         if (r == NULL) { ndr_print_null(ndr); return; }
7994         ndr->depth++;
7995         if (flags & NDR_SET_VALUES) {
7996                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7997         }
7998         if (flags & NDR_IN) {
7999                 ndr_print_struct(ndr, "in", "samr_OpenGroup");
8000                 ndr->depth++;
8001                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
8002                 ndr->depth++;
8003                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
8004                 ndr->depth--;
8005                 ndr_print_samr_GroupAccessMask(ndr, "access_mask", r->in.access_mask);
8006                 ndr_print_uint32(ndr, "rid", r->in.rid);
8007                 ndr->depth--;
8008         }
8009         if (flags & NDR_OUT) {
8010                 ndr_print_struct(ndr, "out", "samr_OpenGroup");
8011                 ndr->depth++;
8012                 ndr_print_ptr(ndr, "group_handle", r->out.group_handle);
8013                 ndr->depth++;
8014                 ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);
8015                 ndr->depth--;
8016                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8017                 ndr->depth--;
8018         }
8019         ndr->depth--;
8020 }
8021
8022 static enum ndr_err_code ndr_push_samr_QueryGroupInfo(struct ndr_push *ndr, int flags, const struct samr_QueryGroupInfo *r)
8023 {
8024         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
8025         if (flags & NDR_IN) {
8026                 if (r->in.group_handle == NULL) {
8027                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8028                 }
8029                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8030                 NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, r->in.level));
8031         }
8032         if (flags & NDR_OUT) {
8033                 if (r->out.info == NULL) {
8034                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8035                 }
8036                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
8037                 if (*r->out.info) {
8038                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
8039                         NDR_CHECK(ndr_push_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8040                 }
8041                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8042         }
8043         return NDR_ERR_SUCCESS;
8044 }
8045
8046 static enum ndr_err_code ndr_pull_samr_QueryGroupInfo(struct ndr_pull *ndr, int flags, struct samr_QueryGroupInfo *r)
8047 {
8048         uint32_t _ptr_info;
8049         TALLOC_CTX *_mem_save_group_handle_0;
8050         TALLOC_CTX *_mem_save_info_0;
8051         TALLOC_CTX *_mem_save_info_1;
8052         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
8053         if (flags & NDR_IN) {
8054                 ZERO_STRUCT(r->out);
8055
8056                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8057                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
8058                 }
8059                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8060                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
8061                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8062                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
8063                 NDR_CHECK(ndr_pull_samr_GroupInfoEnum(ndr, NDR_SCALARS, &r->in.level));
8064                 NDR_PULL_ALLOC(ndr, r->out.info);
8065                 ZERO_STRUCTP(r->out.info);
8066         }
8067         if (flags & NDR_OUT) {
8068                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8069                         NDR_PULL_ALLOC(ndr, r->out.info);
8070                 }
8071                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8072                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
8073                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8074                 if (_ptr_info) {
8075                         NDR_PULL_ALLOC(ndr, *r->out.info);
8076                 } else {
8077                         *r->out.info = NULL;
8078                 }
8079                 if (*r->out.info) {
8080                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
8081                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
8082                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
8083                         NDR_CHECK(ndr_pull_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8084                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
8085                 }
8086                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
8087                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8088         }
8089         return NDR_ERR_SUCCESS;
8090 }
8091
8092 _PUBLIC_ void ndr_print_samr_QueryGroupInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryGroupInfo *r)
8093 {
8094         ndr_print_struct(ndr, name, "samr_QueryGroupInfo");
8095         if (r == NULL) { ndr_print_null(ndr); return; }
8096         ndr->depth++;
8097         if (flags & NDR_SET_VALUES) {
8098                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8099         }
8100         if (flags & NDR_IN) {
8101                 ndr_print_struct(ndr, "in", "samr_QueryGroupInfo");
8102                 ndr->depth++;
8103                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
8104                 ndr->depth++;
8105                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
8106                 ndr->depth--;
8107                 ndr_print_samr_GroupInfoEnum(ndr, "level", r->in.level);
8108                 ndr->depth--;
8109         }
8110         if (flags & NDR_OUT) {
8111                 ndr_print_struct(ndr, "out", "samr_QueryGroupInfo");
8112                 ndr->depth++;
8113                 ndr_print_ptr(ndr, "info", r->out.info);
8114                 ndr->depth++;
8115                 ndr_print_ptr(ndr, "info", *r->out.info);
8116                 ndr->depth++;
8117                 if (*r->out.info) {
8118                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
8119                         ndr_print_samr_GroupInfo(ndr, "info", *r->out.info);
8120                 }
8121                 ndr->depth--;
8122                 ndr->depth--;
8123                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8124                 ndr->depth--;
8125         }
8126         ndr->depth--;
8127 }
8128
8129 static enum ndr_err_code ndr_push_samr_SetGroupInfo(struct ndr_push *ndr, int flags, const struct samr_SetGroupInfo *r)
8130 {
8131         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
8132         if (flags & NDR_IN) {
8133                 if (r->in.group_handle == NULL) {
8134                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8135                 }
8136                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8137                 NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, r->in.level));
8138                 if (r->in.info == NULL) {
8139                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8140                 }
8141                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
8142                 NDR_CHECK(ndr_push_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8143         }
8144         if (flags & NDR_OUT) {
8145                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8146         }
8147         return NDR_ERR_SUCCESS;
8148 }
8149
8150 static enum ndr_err_code ndr_pull_samr_SetGroupInfo(struct ndr_pull *ndr, int flags, struct samr_SetGroupInfo *r)
8151 {
8152         TALLOC_CTX *_mem_save_group_handle_0;
8153         TALLOC_CTX *_mem_save_info_0;
8154         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
8155         if (flags & NDR_IN) {
8156                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8157                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
8158                 }
8159                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8160                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
8161                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8162                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
8163                 NDR_CHECK(ndr_pull_samr_GroupInfoEnum(ndr, NDR_SCALARS, &r->in.level));
8164                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8165                         NDR_PULL_ALLOC(ndr, r->in.info);
8166                 }
8167                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8168                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
8169                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
8170                 NDR_CHECK(ndr_pull_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8171                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
8172         }
8173         if (flags & NDR_OUT) {
8174                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8175         }
8176         return NDR_ERR_SUCCESS;
8177 }
8178
8179 _PUBLIC_ void ndr_print_samr_SetGroupInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetGroupInfo *r)
8180 {
8181         ndr_print_struct(ndr, name, "samr_SetGroupInfo");
8182         if (r == NULL) { ndr_print_null(ndr); return; }
8183         ndr->depth++;
8184         if (flags & NDR_SET_VALUES) {
8185                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8186         }
8187         if (flags & NDR_IN) {
8188                 ndr_print_struct(ndr, "in", "samr_SetGroupInfo");
8189                 ndr->depth++;
8190                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
8191                 ndr->depth++;
8192                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
8193                 ndr->depth--;
8194                 ndr_print_samr_GroupInfoEnum(ndr, "level", r->in.level);
8195                 ndr_print_ptr(ndr, "info", r->in.info);
8196                 ndr->depth++;
8197                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
8198                 ndr_print_samr_GroupInfo(ndr, "info", r->in.info);
8199                 ndr->depth--;
8200                 ndr->depth--;
8201         }
8202         if (flags & NDR_OUT) {
8203                 ndr_print_struct(ndr, "out", "samr_SetGroupInfo");
8204                 ndr->depth++;
8205                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8206                 ndr->depth--;
8207         }
8208         ndr->depth--;
8209 }
8210
8211 static enum ndr_err_code ndr_push_samr_AddGroupMember(struct ndr_push *ndr, int flags, const struct samr_AddGroupMember *r)
8212 {
8213         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
8214         if (flags & NDR_IN) {
8215                 if (r->in.group_handle == NULL) {
8216                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8217                 }
8218                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8219                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
8220                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
8221         }
8222         if (flags & NDR_OUT) {
8223                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8224         }
8225         return NDR_ERR_SUCCESS;
8226 }
8227
8228 static enum ndr_err_code ndr_pull_samr_AddGroupMember(struct ndr_pull *ndr, int flags, struct samr_AddGroupMember *r)
8229 {
8230         TALLOC_CTX *_mem_save_group_handle_0;
8231         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
8232         if (flags & NDR_IN) {
8233                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8234                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
8235                 }
8236                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8237                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
8238                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8239                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
8240                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
8241                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
8242         }
8243         if (flags & NDR_OUT) {
8244                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8245         }
8246         return NDR_ERR_SUCCESS;
8247 }
8248
8249 _PUBLIC_ void ndr_print_samr_AddGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddGroupMember *r)
8250 {
8251         ndr_print_struct(ndr, name, "samr_AddGroupMember");
8252         if (r == NULL) { ndr_print_null(ndr); return; }
8253         ndr->depth++;
8254         if (flags & NDR_SET_VALUES) {
8255                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8256         }
8257         if (flags & NDR_IN) {
8258                 ndr_print_struct(ndr, "in", "samr_AddGroupMember");
8259                 ndr->depth++;
8260                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
8261                 ndr->depth++;
8262                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
8263                 ndr->depth--;
8264                 ndr_print_uint32(ndr, "rid", r->in.rid);
8265                 ndr_print_uint32(ndr, "flags", r->in.flags);
8266                 ndr->depth--;
8267         }
8268         if (flags & NDR_OUT) {
8269                 ndr_print_struct(ndr, "out", "samr_AddGroupMember");
8270                 ndr->depth++;
8271                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8272                 ndr->depth--;
8273         }
8274         ndr->depth--;
8275 }
8276
8277 static enum ndr_err_code ndr_push_samr_DeleteDomainGroup(struct ndr_push *ndr, int flags, const struct samr_DeleteDomainGroup *r)
8278 {
8279         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
8280         if (flags & NDR_IN) {
8281                 if (r->in.group_handle == NULL) {
8282                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8283                 }
8284                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8285         }
8286         if (flags & NDR_OUT) {
8287                 if (r->out.group_handle == NULL) {
8288                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8289                 }
8290                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
8291                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8292         }
8293         return NDR_ERR_SUCCESS;
8294 }
8295
8296 static enum ndr_err_code ndr_pull_samr_DeleteDomainGroup(struct ndr_pull *ndr, int flags, struct samr_DeleteDomainGroup *r)
8297 {
8298         TALLOC_CTX *_mem_save_group_handle_0;
8299         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
8300         if (flags & NDR_IN) {
8301                 ZERO_STRUCT(r->out);
8302
8303                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8304                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
8305                 }
8306                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8307                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
8308                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8309                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
8310                 NDR_PULL_ALLOC(ndr, r->out.group_handle);
8311                 *r->out.group_handle = *r->in.group_handle;
8312         }
8313         if (flags & NDR_OUT) {
8314                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8315                         NDR_PULL_ALLOC(ndr, r->out.group_handle);
8316                 }
8317                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8318                 NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);
8319                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
8320                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
8321                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8322         }
8323         return NDR_ERR_SUCCESS;
8324 }
8325
8326 _PUBLIC_ void ndr_print_samr_DeleteDomainGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteDomainGroup *r)
8327 {
8328         ndr_print_struct(ndr, name, "samr_DeleteDomainGroup");
8329         if (r == NULL) { ndr_print_null(ndr); return; }
8330         ndr->depth++;
8331         if (flags & NDR_SET_VALUES) {
8332                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8333         }
8334         if (flags & NDR_IN) {
8335                 ndr_print_struct(ndr, "in", "samr_DeleteDomainGroup");
8336                 ndr->depth++;
8337                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
8338                 ndr->depth++;
8339                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
8340                 ndr->depth--;
8341                 ndr->depth--;
8342         }
8343         if (flags & NDR_OUT) {
8344                 ndr_print_struct(ndr, "out", "samr_DeleteDomainGroup");
8345                 ndr->depth++;
8346                 ndr_print_ptr(ndr, "group_handle", r->out.group_handle);
8347                 ndr->depth++;
8348                 ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);
8349                 ndr->depth--;
8350                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8351                 ndr->depth--;
8352         }
8353         ndr->depth--;
8354 }
8355
8356 static enum ndr_err_code ndr_push_samr_DeleteGroupMember(struct ndr_push *ndr, int flags, const struct samr_DeleteGroupMember *r)
8357 {
8358         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
8359         if (flags & NDR_IN) {
8360                 if (r->in.group_handle == NULL) {
8361                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8362                 }
8363                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8364                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
8365         }
8366         if (flags & NDR_OUT) {
8367                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8368         }
8369         return NDR_ERR_SUCCESS;
8370 }
8371
8372 static enum ndr_err_code ndr_pull_samr_DeleteGroupMember(struct ndr_pull *ndr, int flags, struct samr_DeleteGroupMember *r)
8373 {
8374         TALLOC_CTX *_mem_save_group_handle_0;
8375         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
8376         if (flags & NDR_IN) {
8377                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8378                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
8379                 }
8380                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8381                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
8382                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8383                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
8384                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
8385         }
8386         if (flags & NDR_OUT) {
8387                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8388         }
8389         return NDR_ERR_SUCCESS;
8390 }
8391
8392 _PUBLIC_ void ndr_print_samr_DeleteGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteGroupMember *r)
8393 {
8394         ndr_print_struct(ndr, name, "samr_DeleteGroupMember");
8395         if (r == NULL) { ndr_print_null(ndr); return; }
8396         ndr->depth++;
8397         if (flags & NDR_SET_VALUES) {
8398                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8399         }
8400         if (flags & NDR_IN) {
8401                 ndr_print_struct(ndr, "in", "samr_DeleteGroupMember");
8402                 ndr->depth++;
8403                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
8404                 ndr->depth++;
8405                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
8406                 ndr->depth--;
8407                 ndr_print_uint32(ndr, "rid", r->in.rid);
8408                 ndr->depth--;
8409         }
8410         if (flags & NDR_OUT) {
8411                 ndr_print_struct(ndr, "out", "samr_DeleteGroupMember");
8412                 ndr->depth++;
8413                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8414                 ndr->depth--;
8415         }
8416         ndr->depth--;
8417 }
8418
8419 static enum ndr_err_code ndr_push_samr_QueryGroupMember(struct ndr_push *ndr, int flags, const struct samr_QueryGroupMember *r)
8420 {
8421         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
8422         if (flags & NDR_IN) {
8423                 if (r->in.group_handle == NULL) {
8424                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8425                 }
8426                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8427         }
8428         if (flags & NDR_OUT) {
8429                 if (r->out.rids == NULL) {
8430                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8431                 }
8432                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rids));
8433                 if (*r->out.rids) {
8434                         NDR_CHECK(ndr_push_samr_RidAttrArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
8435                 }
8436                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8437         }
8438         return NDR_ERR_SUCCESS;
8439 }
8440
8441 static enum ndr_err_code ndr_pull_samr_QueryGroupMember(struct ndr_pull *ndr, int flags, struct samr_QueryGroupMember *r)
8442 {
8443         uint32_t _ptr_rids;
8444         TALLOC_CTX *_mem_save_group_handle_0;
8445         TALLOC_CTX *_mem_save_rids_0;
8446         TALLOC_CTX *_mem_save_rids_1;
8447         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
8448         if (flags & NDR_IN) {
8449                 ZERO_STRUCT(r->out);
8450
8451                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8452                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
8453                 }
8454                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8455                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
8456                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8457                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
8458                 NDR_PULL_ALLOC(ndr, r->out.rids);
8459                 ZERO_STRUCTP(r->out.rids);
8460         }
8461         if (flags & NDR_OUT) {
8462                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8463                         NDR_PULL_ALLOC(ndr, r->out.rids);
8464                 }
8465                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
8466                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
8467                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
8468                 if (_ptr_rids) {
8469                         NDR_PULL_ALLOC(ndr, *r->out.rids);
8470                 } else {
8471                         *r->out.rids = NULL;
8472                 }
8473                 if (*r->out.rids) {
8474                         _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
8475                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.rids, 0);
8476                         NDR_CHECK(ndr_pull_samr_RidAttrArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
8477                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
8478                 }
8479                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
8480                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8481         }
8482         return NDR_ERR_SUCCESS;
8483 }
8484
8485 _PUBLIC_ void ndr_print_samr_QueryGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryGroupMember *r)
8486 {
8487         ndr_print_struct(ndr, name, "samr_QueryGroupMember");
8488         if (r == NULL) { ndr_print_null(ndr); return; }
8489         ndr->depth++;
8490         if (flags & NDR_SET_VALUES) {
8491                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8492         }
8493         if (flags & NDR_IN) {
8494                 ndr_print_struct(ndr, "in", "samr_QueryGroupMember");
8495                 ndr->depth++;
8496                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
8497                 ndr->depth++;
8498                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
8499                 ndr->depth--;
8500                 ndr->depth--;
8501         }
8502         if (flags & NDR_OUT) {
8503                 ndr_print_struct(ndr, "out", "samr_QueryGroupMember");
8504                 ndr->depth++;
8505                 ndr_print_ptr(ndr, "rids", r->out.rids);
8506                 ndr->depth++;
8507                 ndr_print_ptr(ndr, "rids", *r->out.rids);
8508                 ndr->depth++;
8509                 if (*r->out.rids) {
8510                         ndr_print_samr_RidAttrArray(ndr, "rids", *r->out.rids);
8511                 }
8512                 ndr->depth--;
8513                 ndr->depth--;
8514                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8515                 ndr->depth--;
8516         }
8517         ndr->depth--;
8518 }
8519
8520 static enum ndr_err_code ndr_push_samr_SetMemberAttributesOfGroup(struct ndr_push *ndr, int flags, const struct samr_SetMemberAttributesOfGroup *r)
8521 {
8522         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
8523         if (flags & NDR_IN) {
8524                 if (r->in.group_handle == NULL) {
8525                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8526                 }
8527                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8528                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
8529                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
8530         }
8531         if (flags & NDR_OUT) {
8532                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8533         }
8534         return NDR_ERR_SUCCESS;
8535 }
8536
8537 static enum ndr_err_code ndr_pull_samr_SetMemberAttributesOfGroup(struct ndr_pull *ndr, int flags, struct samr_SetMemberAttributesOfGroup *r)
8538 {
8539         TALLOC_CTX *_mem_save_group_handle_0;
8540         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
8541         if (flags & NDR_IN) {
8542                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8543                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
8544                 }
8545                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8546                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
8547                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8548                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
8549                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
8550                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
8551         }
8552         if (flags & NDR_OUT) {
8553                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8554         }
8555         return NDR_ERR_SUCCESS;
8556 }
8557
8558 _PUBLIC_ void ndr_print_samr_SetMemberAttributesOfGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetMemberAttributesOfGroup *r)
8559 {
8560         ndr_print_struct(ndr, name, "samr_SetMemberAttributesOfGroup");
8561         if (r == NULL) { ndr_print_null(ndr); return; }
8562         ndr->depth++;
8563         if (flags & NDR_SET_VALUES) {
8564                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8565         }
8566         if (flags & NDR_IN) {
8567                 ndr_print_struct(ndr, "in", "samr_SetMemberAttributesOfGroup");
8568                 ndr->depth++;
8569                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
8570                 ndr->depth++;
8571                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
8572                 ndr->depth--;
8573                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
8574                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
8575                 ndr->depth--;
8576         }
8577         if (flags & NDR_OUT) {
8578                 ndr_print_struct(ndr, "out", "samr_SetMemberAttributesOfGroup");
8579                 ndr->depth++;
8580                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8581                 ndr->depth--;
8582         }
8583         ndr->depth--;
8584 }
8585
8586 static enum ndr_err_code ndr_push_samr_OpenAlias(struct ndr_push *ndr, int flags, const struct samr_OpenAlias *r)
8587 {
8588         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
8589         if (flags & NDR_IN) {
8590                 if (r->in.domain_handle == NULL) {
8591                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8592                 }
8593                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
8594                 NDR_CHECK(ndr_push_samr_AliasAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
8595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
8596         }
8597         if (flags & NDR_OUT) {
8598                 if (r->out.alias_handle == NULL) {
8599                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8600                 }
8601                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
8602                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8603         }
8604         return NDR_ERR_SUCCESS;
8605 }
8606
8607 static enum ndr_err_code ndr_pull_samr_OpenAlias(struct ndr_pull *ndr, int flags, struct samr_OpenAlias *r)
8608 {
8609         TALLOC_CTX *_mem_save_domain_handle_0;
8610         TALLOC_CTX *_mem_save_alias_handle_0;
8611         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
8612         if (flags & NDR_IN) {
8613                 ZERO_STRUCT(r->out);
8614
8615                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8616                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
8617                 }
8618                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8619                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
8620                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
8621                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
8622                 NDR_CHECK(ndr_pull_samr_AliasAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
8623                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
8624                 NDR_PULL_ALLOC(ndr, r->out.alias_handle);
8625                 ZERO_STRUCTP(r->out.alias_handle);
8626         }
8627         if (flags & NDR_OUT) {
8628                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8629                         NDR_PULL_ALLOC(ndr, r->out.alias_handle);
8630                 }
8631                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8632                 NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8633                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
8634                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8635                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8636         }
8637         return NDR_ERR_SUCCESS;
8638 }
8639
8640 _PUBLIC_ void ndr_print_samr_OpenAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenAlias *r)
8641 {
8642         ndr_print_struct(ndr, name, "samr_OpenAlias");
8643         if (r == NULL) { ndr_print_null(ndr); return; }
8644         ndr->depth++;
8645         if (flags & NDR_SET_VALUES) {
8646                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8647         }
8648         if (flags & NDR_IN) {
8649                 ndr_print_struct(ndr, "in", "samr_OpenAlias");
8650                 ndr->depth++;
8651                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
8652                 ndr->depth++;
8653                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
8654                 ndr->depth--;
8655                 ndr_print_samr_AliasAccessMask(ndr, "access_mask", r->in.access_mask);
8656                 ndr_print_uint32(ndr, "rid", r->in.rid);
8657                 ndr->depth--;
8658         }
8659         if (flags & NDR_OUT) {
8660                 ndr_print_struct(ndr, "out", "samr_OpenAlias");
8661                 ndr->depth++;
8662                 ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);
8663                 ndr->depth++;
8664                 ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);
8665                 ndr->depth--;
8666                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8667                 ndr->depth--;
8668         }
8669         ndr->depth--;
8670 }
8671
8672 static enum ndr_err_code ndr_push_samr_QueryAliasInfo(struct ndr_push *ndr, int flags, const struct samr_QueryAliasInfo *r)
8673 {
8674         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
8675         if (flags & NDR_IN) {
8676                 if (r->in.alias_handle == NULL) {
8677                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8678                 }
8679                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8680                 NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, r->in.level));
8681         }
8682         if (flags & NDR_OUT) {
8683                 if (r->out.info == NULL) {
8684                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8685                 }
8686                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
8687                 if (*r->out.info) {
8688                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
8689                         NDR_CHECK(ndr_push_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8690                 }
8691                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8692         }
8693         return NDR_ERR_SUCCESS;
8694 }
8695
8696 static enum ndr_err_code ndr_pull_samr_QueryAliasInfo(struct ndr_pull *ndr, int flags, struct samr_QueryAliasInfo *r)
8697 {
8698         uint32_t _ptr_info;
8699         TALLOC_CTX *_mem_save_alias_handle_0;
8700         TALLOC_CTX *_mem_save_info_0;
8701         TALLOC_CTX *_mem_save_info_1;
8702         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
8703         if (flags & NDR_IN) {
8704                 ZERO_STRUCT(r->out);
8705
8706                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8707                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8708                 }
8709                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8710                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8711                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8712                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8713                 NDR_CHECK(ndr_pull_samr_AliasInfoEnum(ndr, NDR_SCALARS, &r->in.level));
8714                 NDR_PULL_ALLOC(ndr, r->out.info);
8715                 ZERO_STRUCTP(r->out.info);
8716         }
8717         if (flags & NDR_OUT) {
8718                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8719                         NDR_PULL_ALLOC(ndr, r->out.info);
8720                 }
8721                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8722                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
8723                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8724                 if (_ptr_info) {
8725                         NDR_PULL_ALLOC(ndr, *r->out.info);
8726                 } else {
8727                         *r->out.info = NULL;
8728                 }
8729                 if (*r->out.info) {
8730                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
8731                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
8732                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
8733                         NDR_CHECK(ndr_pull_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8734                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
8735                 }
8736                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
8737                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8738         }
8739         return NDR_ERR_SUCCESS;
8740 }
8741
8742 _PUBLIC_ void ndr_print_samr_QueryAliasInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryAliasInfo *r)
8743 {
8744         ndr_print_struct(ndr, name, "samr_QueryAliasInfo");
8745         if (r == NULL) { ndr_print_null(ndr); return; }
8746         ndr->depth++;
8747         if (flags & NDR_SET_VALUES) {
8748                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8749         }
8750         if (flags & NDR_IN) {
8751                 ndr_print_struct(ndr, "in", "samr_QueryAliasInfo");
8752                 ndr->depth++;
8753                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8754                 ndr->depth++;
8755                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8756                 ndr->depth--;
8757                 ndr_print_samr_AliasInfoEnum(ndr, "level", r->in.level);
8758                 ndr->depth--;
8759         }
8760         if (flags & NDR_OUT) {
8761                 ndr_print_struct(ndr, "out", "samr_QueryAliasInfo");
8762                 ndr->depth++;
8763                 ndr_print_ptr(ndr, "info", r->out.info);
8764                 ndr->depth++;
8765                 ndr_print_ptr(ndr, "info", *r->out.info);
8766                 ndr->depth++;
8767                 if (*r->out.info) {
8768                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
8769                         ndr_print_samr_AliasInfo(ndr, "info", *r->out.info);
8770                 }
8771                 ndr->depth--;
8772                 ndr->depth--;
8773                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8774                 ndr->depth--;
8775         }
8776         ndr->depth--;
8777 }
8778
8779 static enum ndr_err_code ndr_push_samr_SetAliasInfo(struct ndr_push *ndr, int flags, const struct samr_SetAliasInfo *r)
8780 {
8781         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
8782         if (flags & NDR_IN) {
8783                 if (r->in.alias_handle == NULL) {
8784                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8785                 }
8786                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8787                 NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, r->in.level));
8788                 if (r->in.info == NULL) {
8789                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8790                 }
8791                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
8792                 NDR_CHECK(ndr_push_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8793         }
8794         if (flags & NDR_OUT) {
8795                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8796         }
8797         return NDR_ERR_SUCCESS;
8798 }
8799
8800 static enum ndr_err_code ndr_pull_samr_SetAliasInfo(struct ndr_pull *ndr, int flags, struct samr_SetAliasInfo *r)
8801 {
8802         TALLOC_CTX *_mem_save_alias_handle_0;
8803         TALLOC_CTX *_mem_save_info_0;
8804         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
8805         if (flags & NDR_IN) {
8806                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8807                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8808                 }
8809                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8810                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8811                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8812                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8813                 NDR_CHECK(ndr_pull_samr_AliasInfoEnum(ndr, NDR_SCALARS, &r->in.level));
8814                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8815                         NDR_PULL_ALLOC(ndr, r->in.info);
8816                 }
8817                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8818                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
8819                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
8820                 NDR_CHECK(ndr_pull_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8821                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
8822         }
8823         if (flags & NDR_OUT) {
8824                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8825         }
8826         return NDR_ERR_SUCCESS;
8827 }
8828
8829 _PUBLIC_ void ndr_print_samr_SetAliasInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetAliasInfo *r)
8830 {
8831         ndr_print_struct(ndr, name, "samr_SetAliasInfo");
8832         if (r == NULL) { ndr_print_null(ndr); return; }
8833         ndr->depth++;
8834         if (flags & NDR_SET_VALUES) {
8835                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8836         }
8837         if (flags & NDR_IN) {
8838                 ndr_print_struct(ndr, "in", "samr_SetAliasInfo");
8839                 ndr->depth++;
8840                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8841                 ndr->depth++;
8842                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8843                 ndr->depth--;
8844                 ndr_print_samr_AliasInfoEnum(ndr, "level", r->in.level);
8845                 ndr_print_ptr(ndr, "info", r->in.info);
8846                 ndr->depth++;
8847                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
8848                 ndr_print_samr_AliasInfo(ndr, "info", r->in.info);
8849                 ndr->depth--;
8850                 ndr->depth--;
8851         }
8852         if (flags & NDR_OUT) {
8853                 ndr_print_struct(ndr, "out", "samr_SetAliasInfo");
8854                 ndr->depth++;
8855                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8856                 ndr->depth--;
8857         }
8858         ndr->depth--;
8859 }
8860
8861 static enum ndr_err_code ndr_push_samr_DeleteDomAlias(struct ndr_push *ndr, int flags, const struct samr_DeleteDomAlias *r)
8862 {
8863         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
8864         if (flags & NDR_IN) {
8865                 if (r->in.alias_handle == NULL) {
8866                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8867                 }
8868                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8869         }
8870         if (flags & NDR_OUT) {
8871                 if (r->out.alias_handle == NULL) {
8872                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8873                 }
8874                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
8875                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8876         }
8877         return NDR_ERR_SUCCESS;
8878 }
8879
8880 static enum ndr_err_code ndr_pull_samr_DeleteDomAlias(struct ndr_pull *ndr, int flags, struct samr_DeleteDomAlias *r)
8881 {
8882         TALLOC_CTX *_mem_save_alias_handle_0;
8883         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
8884         if (flags & NDR_IN) {
8885                 ZERO_STRUCT(r->out);
8886
8887                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8888                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8889                 }
8890                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8891                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8892                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8893                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8894                 NDR_PULL_ALLOC(ndr, r->out.alias_handle);
8895                 *r->out.alias_handle = *r->in.alias_handle;
8896         }
8897         if (flags & NDR_OUT) {
8898                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8899                         NDR_PULL_ALLOC(ndr, r->out.alias_handle);
8900                 }
8901                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8902                 NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8903                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
8904                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8905                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8906         }
8907         return NDR_ERR_SUCCESS;
8908 }
8909
8910 _PUBLIC_ void ndr_print_samr_DeleteDomAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteDomAlias *r)
8911 {
8912         ndr_print_struct(ndr, name, "samr_DeleteDomAlias");
8913         if (r == NULL) { ndr_print_null(ndr); return; }
8914         ndr->depth++;
8915         if (flags & NDR_SET_VALUES) {
8916                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8917         }
8918         if (flags & NDR_IN) {
8919                 ndr_print_struct(ndr, "in", "samr_DeleteDomAlias");
8920                 ndr->depth++;
8921                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8922                 ndr->depth++;
8923                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8924                 ndr->depth--;
8925                 ndr->depth--;
8926         }
8927         if (flags & NDR_OUT) {
8928                 ndr_print_struct(ndr, "out", "samr_DeleteDomAlias");
8929                 ndr->depth++;
8930                 ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);
8931                 ndr->depth++;
8932                 ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);
8933                 ndr->depth--;
8934                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8935                 ndr->depth--;
8936         }
8937         ndr->depth--;
8938 }
8939
8940 static enum ndr_err_code ndr_push_samr_AddAliasMember(struct ndr_push *ndr, int flags, const struct samr_AddAliasMember *r)
8941 {
8942         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
8943         if (flags & NDR_IN) {
8944                 if (r->in.alias_handle == NULL) {
8945                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8946                 }
8947                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8948                 if (r->in.sid == NULL) {
8949                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8950                 }
8951                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8952         }
8953         if (flags & NDR_OUT) {
8954                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8955         }
8956         return NDR_ERR_SUCCESS;
8957 }
8958
8959 static enum ndr_err_code ndr_pull_samr_AddAliasMember(struct ndr_pull *ndr, int flags, struct samr_AddAliasMember *r)
8960 {
8961         TALLOC_CTX *_mem_save_alias_handle_0;
8962         TALLOC_CTX *_mem_save_sid_0;
8963         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
8964         if (flags & NDR_IN) {
8965                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8966                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8967                 }
8968                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8969                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8970                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8971                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8972                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8973                         NDR_PULL_ALLOC(ndr, r->in.sid);
8974                 }
8975                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
8976                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
8977                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8978                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
8979         }
8980         if (flags & NDR_OUT) {
8981                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8982         }
8983         return NDR_ERR_SUCCESS;
8984 }
8985
8986 _PUBLIC_ void ndr_print_samr_AddAliasMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddAliasMember *r)
8987 {
8988         ndr_print_struct(ndr, name, "samr_AddAliasMember");
8989         if (r == NULL) { ndr_print_null(ndr); return; }
8990         ndr->depth++;
8991         if (flags & NDR_SET_VALUES) {
8992                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8993         }
8994         if (flags & NDR_IN) {
8995                 ndr_print_struct(ndr, "in", "samr_AddAliasMember");
8996                 ndr->depth++;
8997                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8998                 ndr->depth++;
8999                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
9000                 ndr->depth--;
9001                 ndr_print_ptr(ndr, "sid", r->in.sid);
9002                 ndr->depth++;
9003                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
9004                 ndr->depth--;
9005                 ndr->depth--;
9006         }
9007         if (flags & NDR_OUT) {
9008                 ndr_print_struct(ndr, "out", "samr_AddAliasMember");
9009                 ndr->depth++;
9010                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9011                 ndr->depth--;
9012         }
9013         ndr->depth--;
9014 }
9015
9016 static enum ndr_err_code ndr_push_samr_DeleteAliasMember(struct ndr_push *ndr, int flags, const struct samr_DeleteAliasMember *r)
9017 {
9018         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
9019         if (flags & NDR_IN) {
9020                 if (r->in.alias_handle == NULL) {
9021                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9022                 }
9023                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
9024                 if (r->in.sid == NULL) {
9025                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9026                 }
9027                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
9028         }
9029         if (flags & NDR_OUT) {
9030                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9031         }
9032         return NDR_ERR_SUCCESS;
9033 }
9034
9035 static enum ndr_err_code ndr_pull_samr_DeleteAliasMember(struct ndr_pull *ndr, int flags, struct samr_DeleteAliasMember *r)
9036 {
9037         TALLOC_CTX *_mem_save_alias_handle_0;
9038         TALLOC_CTX *_mem_save_sid_0;
9039         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
9040         if (flags & NDR_IN) {
9041                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9042                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
9043                 }
9044                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9045                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
9046                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
9047                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
9048                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9049                         NDR_PULL_ALLOC(ndr, r->in.sid);
9050                 }
9051                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
9052                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
9053                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
9054                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
9055         }
9056         if (flags & NDR_OUT) {
9057                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9058         }
9059         return NDR_ERR_SUCCESS;
9060 }
9061
9062 _PUBLIC_ void ndr_print_samr_DeleteAliasMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteAliasMember *r)
9063 {
9064         ndr_print_struct(ndr, name, "samr_DeleteAliasMember");
9065         if (r == NULL) { ndr_print_null(ndr); return; }
9066         ndr->depth++;
9067         if (flags & NDR_SET_VALUES) {
9068                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9069         }
9070         if (flags & NDR_IN) {
9071                 ndr_print_struct(ndr, "in", "samr_DeleteAliasMember");
9072                 ndr->depth++;
9073                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
9074                 ndr->depth++;
9075                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
9076                 ndr->depth--;
9077                 ndr_print_ptr(ndr, "sid", r->in.sid);
9078                 ndr->depth++;
9079                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
9080                 ndr->depth--;
9081                 ndr->depth--;
9082         }
9083         if (flags & NDR_OUT) {
9084                 ndr_print_struct(ndr, "out", "samr_DeleteAliasMember");
9085                 ndr->depth++;
9086                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9087                 ndr->depth--;
9088         }
9089         ndr->depth--;
9090 }
9091
9092 static enum ndr_err_code ndr_push_samr_GetMembersInAlias(struct ndr_push *ndr, int flags, const struct samr_GetMembersInAlias *r)
9093 {
9094         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
9095         if (flags & NDR_IN) {
9096                 if (r->in.alias_handle == NULL) {
9097                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9098                 }
9099                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
9100         }
9101         if (flags & NDR_OUT) {
9102                 if (r->out.sids == NULL) {
9103                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9104                 }
9105                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
9106                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9107         }
9108         return NDR_ERR_SUCCESS;
9109 }
9110
9111 static enum ndr_err_code ndr_pull_samr_GetMembersInAlias(struct ndr_pull *ndr, int flags, struct samr_GetMembersInAlias *r)
9112 {
9113         TALLOC_CTX *_mem_save_alias_handle_0;
9114         TALLOC_CTX *_mem_save_sids_0;
9115         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
9116         if (flags & NDR_IN) {
9117                 ZERO_STRUCT(r->out);
9118
9119                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9120                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
9121                 }
9122                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9123                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
9124                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
9125                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
9126                 NDR_PULL_ALLOC(ndr, r->out.sids);
9127                 ZERO_STRUCTP(r->out.sids);
9128         }
9129         if (flags & NDR_OUT) {
9130                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9131                         NDR_PULL_ALLOC(ndr, r->out.sids);
9132                 }
9133                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
9134                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
9135                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
9136                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
9137                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9138         }
9139         return NDR_ERR_SUCCESS;
9140 }
9141
9142 _PUBLIC_ void ndr_print_samr_GetMembersInAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetMembersInAlias *r)
9143 {
9144         ndr_print_struct(ndr, name, "samr_GetMembersInAlias");
9145         if (r == NULL) { ndr_print_null(ndr); return; }
9146         ndr->depth++;
9147         if (flags & NDR_SET_VALUES) {
9148                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9149         }
9150         if (flags & NDR_IN) {
9151                 ndr_print_struct(ndr, "in", "samr_GetMembersInAlias");
9152                 ndr->depth++;
9153                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
9154                 ndr->depth++;
9155                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
9156                 ndr->depth--;
9157                 ndr->depth--;
9158         }
9159         if (flags & NDR_OUT) {
9160                 ndr_print_struct(ndr, "out", "samr_GetMembersInAlias");
9161                 ndr->depth++;
9162                 ndr_print_ptr(ndr, "sids", r->out.sids);
9163                 ndr->depth++;
9164                 ndr_print_lsa_SidArray(ndr, "sids", r->out.sids);
9165                 ndr->depth--;
9166                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9167                 ndr->depth--;
9168         }
9169         ndr->depth--;
9170 }
9171
9172 _PUBLIC_ enum ndr_err_code ndr_push_samr_OpenUser(struct ndr_push *ndr, int flags, const struct samr_OpenUser *r)
9173 {
9174         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
9175         if (flags & NDR_IN) {
9176                 if (r->in.domain_handle == NULL) {
9177                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9178                 }
9179                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9180                 NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
9181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
9182         }
9183         if (flags & NDR_OUT) {
9184                 if (r->out.user_handle == NULL) {
9185                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9186                 }
9187                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
9188                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9189         }
9190         return NDR_ERR_SUCCESS;
9191 }
9192
9193 _PUBLIC_ enum ndr_err_code ndr_pull_samr_OpenUser(struct ndr_pull *ndr, int flags, struct samr_OpenUser *r)
9194 {
9195         TALLOC_CTX *_mem_save_domain_handle_0;
9196         TALLOC_CTX *_mem_save_user_handle_0;
9197         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
9198         if (flags & NDR_IN) {
9199                 ZERO_STRUCT(r->out);
9200
9201                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9202                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
9203                 }
9204                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9205                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
9206                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9207                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
9208                 NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
9209                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
9210                 NDR_PULL_ALLOC(ndr, r->out.user_handle);
9211                 ZERO_STRUCTP(r->out.user_handle);
9212         }
9213         if (flags & NDR_OUT) {
9214                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9215                         NDR_PULL_ALLOC(ndr, r->out.user_handle);
9216                 }
9217                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9218                 NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
9219                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
9220                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9221                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9222         }
9223         return NDR_ERR_SUCCESS;
9224 }
9225
9226 _PUBLIC_ void ndr_print_samr_OpenUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenUser *r)
9227 {
9228         ndr_print_struct(ndr, name, "samr_OpenUser");
9229         if (r == NULL) { ndr_print_null(ndr); return; }
9230         ndr->depth++;
9231         if (flags & NDR_SET_VALUES) {
9232                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9233         }
9234         if (flags & NDR_IN) {
9235                 ndr_print_struct(ndr, "in", "samr_OpenUser");
9236                 ndr->depth++;
9237                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
9238                 ndr->depth++;
9239                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
9240                 ndr->depth--;
9241                 ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);
9242                 ndr_print_uint32(ndr, "rid", r->in.rid);
9243                 ndr->depth--;
9244         }
9245         if (flags & NDR_OUT) {
9246                 ndr_print_struct(ndr, "out", "samr_OpenUser");
9247                 ndr->depth++;
9248                 ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
9249                 ndr->depth++;
9250                 ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
9251                 ndr->depth--;
9252                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9253                 ndr->depth--;
9254         }
9255         ndr->depth--;
9256 }
9257
9258 static enum ndr_err_code ndr_push_samr_DeleteUser(struct ndr_push *ndr, int flags, const struct samr_DeleteUser *r)
9259 {
9260         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
9261         if (flags & NDR_IN) {
9262                 if (r->in.user_handle == NULL) {
9263                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9264                 }
9265                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9266         }
9267         if (flags & NDR_OUT) {
9268                 if (r->out.user_handle == NULL) {
9269                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9270                 }
9271                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
9272                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9273         }
9274         return NDR_ERR_SUCCESS;
9275 }
9276
9277 static enum ndr_err_code ndr_pull_samr_DeleteUser(struct ndr_pull *ndr, int flags, struct samr_DeleteUser *r)
9278 {
9279         TALLOC_CTX *_mem_save_user_handle_0;
9280         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
9281         if (flags & NDR_IN) {
9282                 ZERO_STRUCT(r->out);
9283
9284                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9285                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9286                 }
9287                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9288                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9289                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9290                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9291                 NDR_PULL_ALLOC(ndr, r->out.user_handle);
9292                 *r->out.user_handle = *r->in.user_handle;
9293         }
9294         if (flags & NDR_OUT) {
9295                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9296                         NDR_PULL_ALLOC(ndr, r->out.user_handle);
9297                 }
9298                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9299                 NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
9300                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
9301                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9302                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9303         }
9304         return NDR_ERR_SUCCESS;
9305 }
9306
9307 _PUBLIC_ void ndr_print_samr_DeleteUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteUser *r)
9308 {
9309         ndr_print_struct(ndr, name, "samr_DeleteUser");
9310         if (r == NULL) { ndr_print_null(ndr); return; }
9311         ndr->depth++;
9312         if (flags & NDR_SET_VALUES) {
9313                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9314         }
9315         if (flags & NDR_IN) {
9316                 ndr_print_struct(ndr, "in", "samr_DeleteUser");
9317                 ndr->depth++;
9318                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9319                 ndr->depth++;
9320                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9321                 ndr->depth--;
9322                 ndr->depth--;
9323         }
9324         if (flags & NDR_OUT) {
9325                 ndr_print_struct(ndr, "out", "samr_DeleteUser");
9326                 ndr->depth++;
9327                 ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
9328                 ndr->depth++;
9329                 ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
9330                 ndr->depth--;
9331                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9332                 ndr->depth--;
9333         }
9334         ndr->depth--;
9335 }
9336
9337 _PUBLIC_ enum ndr_err_code ndr_push_samr_QueryUserInfo(struct ndr_push *ndr, int flags, const struct samr_QueryUserInfo *r)
9338 {
9339         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
9340         if (flags & NDR_IN) {
9341                 if (r->in.user_handle == NULL) {
9342                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9343                 }
9344                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9345                 NDR_CHECK(ndr_push_samr_UserInfoLevel(ndr, NDR_SCALARS, r->in.level));
9346         }
9347         if (flags & NDR_OUT) {
9348                 if (r->out.info == NULL) {
9349                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9350                 }
9351                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
9352                 if (*r->out.info) {
9353                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
9354                         NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9355                 }
9356                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9357         }
9358         return NDR_ERR_SUCCESS;
9359 }
9360
9361 _PUBLIC_ enum ndr_err_code ndr_pull_samr_QueryUserInfo(struct ndr_pull *ndr, int flags, struct samr_QueryUserInfo *r)
9362 {
9363         uint32_t _ptr_info;
9364         TALLOC_CTX *_mem_save_user_handle_0;
9365         TALLOC_CTX *_mem_save_info_0;
9366         TALLOC_CTX *_mem_save_info_1;
9367         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
9368         if (flags & NDR_IN) {
9369                 ZERO_STRUCT(r->out);
9370
9371                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9372                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9373                 }
9374                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9375                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9376                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9377                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9378                 NDR_CHECK(ndr_pull_samr_UserInfoLevel(ndr, NDR_SCALARS, &r->in.level));
9379                 NDR_PULL_ALLOC(ndr, r->out.info);
9380                 ZERO_STRUCTP(r->out.info);
9381         }
9382         if (flags & NDR_OUT) {
9383                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9384                         NDR_PULL_ALLOC(ndr, r->out.info);
9385                 }
9386                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9387                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9388                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9389                 if (_ptr_info) {
9390                         NDR_PULL_ALLOC(ndr, *r->out.info);
9391                 } else {
9392                         *r->out.info = NULL;
9393                 }
9394                 if (*r->out.info) {
9395                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
9396                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
9397                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
9398                         NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9399                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
9400                 }
9401                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9402                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9403         }
9404         return NDR_ERR_SUCCESS;
9405 }
9406
9407 _PUBLIC_ void ndr_print_samr_QueryUserInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryUserInfo *r)
9408 {
9409         ndr_print_struct(ndr, name, "samr_QueryUserInfo");
9410         if (r == NULL) { ndr_print_null(ndr); return; }
9411         ndr->depth++;
9412         if (flags & NDR_SET_VALUES) {
9413                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9414         }
9415         if (flags & NDR_IN) {
9416                 ndr_print_struct(ndr, "in", "samr_QueryUserInfo");
9417                 ndr->depth++;
9418                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9419                 ndr->depth++;
9420                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9421                 ndr->depth--;
9422                 ndr_print_samr_UserInfoLevel(ndr, "level", r->in.level);
9423                 ndr->depth--;
9424         }
9425         if (flags & NDR_OUT) {
9426                 ndr_print_struct(ndr, "out", "samr_QueryUserInfo");
9427                 ndr->depth++;
9428                 ndr_print_ptr(ndr, "info", r->out.info);
9429                 ndr->depth++;
9430                 ndr_print_ptr(ndr, "info", *r->out.info);
9431                 ndr->depth++;
9432                 if (*r->out.info) {
9433                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
9434                         ndr_print_samr_UserInfo(ndr, "info", *r->out.info);
9435                 }
9436                 ndr->depth--;
9437                 ndr->depth--;
9438                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9439                 ndr->depth--;
9440         }
9441         ndr->depth--;
9442 }
9443
9444 _PUBLIC_ enum ndr_err_code ndr_push_samr_SetUserInfo(struct ndr_push *ndr, int flags, const struct samr_SetUserInfo *r)
9445 {
9446         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
9447         if (flags & NDR_IN) {
9448                 if (r->in.user_handle == NULL) {
9449                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9450                 }
9451                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9452                 NDR_CHECK(ndr_push_samr_UserInfoLevel(ndr, NDR_SCALARS, r->in.level));
9453                 if (r->in.info == NULL) {
9454                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9455                 }
9456                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
9457                 NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
9458         }
9459         if (flags & NDR_OUT) {
9460                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9461         }
9462         return NDR_ERR_SUCCESS;
9463 }
9464
9465 _PUBLIC_ enum ndr_err_code ndr_pull_samr_SetUserInfo(struct ndr_pull *ndr, int flags, struct samr_SetUserInfo *r)
9466 {
9467         TALLOC_CTX *_mem_save_user_handle_0;
9468         TALLOC_CTX *_mem_save_info_0;
9469         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
9470         if (flags & NDR_IN) {
9471                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9472                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9473                 }
9474                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9475                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9476                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9477                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9478                 NDR_CHECK(ndr_pull_samr_UserInfoLevel(ndr, NDR_SCALARS, &r->in.level));
9479                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9480                         NDR_PULL_ALLOC(ndr, r->in.info);
9481                 }
9482                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9483                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
9484                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
9485                 NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
9486                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9487         }
9488         if (flags & NDR_OUT) {
9489                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9490         }
9491         return NDR_ERR_SUCCESS;
9492 }
9493
9494 _PUBLIC_ void ndr_print_samr_SetUserInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetUserInfo *r)
9495 {
9496         ndr_print_struct(ndr, name, "samr_SetUserInfo");
9497         if (r == NULL) { ndr_print_null(ndr); return; }
9498         ndr->depth++;
9499         if (flags & NDR_SET_VALUES) {
9500                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9501         }
9502         if (flags & NDR_IN) {
9503                 ndr_print_struct(ndr, "in", "samr_SetUserInfo");
9504                 ndr->depth++;
9505                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9506                 ndr->depth++;
9507                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9508                 ndr->depth--;
9509                 ndr_print_samr_UserInfoLevel(ndr, "level", r->in.level);
9510                 ndr_print_ptr(ndr, "info", r->in.info);
9511                 ndr->depth++;
9512                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
9513                 ndr_print_samr_UserInfo(ndr, "info", r->in.info);
9514                 ndr->depth--;
9515                 ndr->depth--;
9516         }
9517         if (flags & NDR_OUT) {
9518                 ndr_print_struct(ndr, "out", "samr_SetUserInfo");
9519                 ndr->depth++;
9520                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9521                 ndr->depth--;
9522         }
9523         ndr->depth--;
9524 }
9525
9526 static enum ndr_err_code ndr_push_samr_ChangePasswordUser(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser *r)
9527 {
9528         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
9529         if (flags & NDR_IN) {
9530                 if (r->in.user_handle == NULL) {
9531                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9532                 }
9533                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9534                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_present));
9535                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_lm_crypted));
9536                 if (r->in.old_lm_crypted) {
9537                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.old_lm_crypted));
9538                 }
9539                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_lm_crypted));
9540                 if (r->in.new_lm_crypted) {
9541                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.new_lm_crypted));
9542                 }
9543                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.nt_present));
9544                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_nt_crypted));
9545                 if (r->in.old_nt_crypted) {
9546                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.old_nt_crypted));
9547                 }
9548                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_nt_crypted));
9549                 if (r->in.new_nt_crypted) {
9550                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.new_nt_crypted));
9551                 }
9552                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.cross1_present));
9553                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_cross));
9554                 if (r->in.nt_cross) {
9555                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_cross));
9556                 }
9557                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.cross2_present));
9558                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_cross));
9559                 if (r->in.lm_cross) {
9560                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_cross));
9561                 }
9562         }
9563         if (flags & NDR_OUT) {
9564                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9565         }
9566         return NDR_ERR_SUCCESS;
9567 }
9568
9569 static enum ndr_err_code ndr_pull_samr_ChangePasswordUser(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser *r)
9570 {
9571         uint32_t _ptr_old_lm_crypted;
9572         uint32_t _ptr_new_lm_crypted;
9573         uint32_t _ptr_old_nt_crypted;
9574         uint32_t _ptr_new_nt_crypted;
9575         uint32_t _ptr_nt_cross;
9576         uint32_t _ptr_lm_cross;
9577         TALLOC_CTX *_mem_save_user_handle_0;
9578         TALLOC_CTX *_mem_save_old_lm_crypted_0;
9579         TALLOC_CTX *_mem_save_new_lm_crypted_0;
9580         TALLOC_CTX *_mem_save_old_nt_crypted_0;
9581         TALLOC_CTX *_mem_save_new_nt_crypted_0;
9582         TALLOC_CTX *_mem_save_nt_cross_0;
9583         TALLOC_CTX *_mem_save_lm_cross_0;
9584         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
9585         if (flags & NDR_IN) {
9586                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9587                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9588                 }
9589                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9590                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9591                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9592                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9593                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_present));
9594                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_lm_crypted));
9595                 if (_ptr_old_lm_crypted) {
9596                         NDR_PULL_ALLOC(ndr, r->in.old_lm_crypted);
9597                 } else {
9598                         r->in.old_lm_crypted = NULL;
9599                 }
9600                 if (r->in.old_lm_crypted) {
9601                         _mem_save_old_lm_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
9602                         NDR_PULL_SET_MEM_CTX(ndr, r->in.old_lm_crypted, 0);
9603                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.old_lm_crypted));
9604                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_lm_crypted_0, 0);
9605                 }
9606                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_lm_crypted));
9607                 if (_ptr_new_lm_crypted) {
9608                         NDR_PULL_ALLOC(ndr, r->in.new_lm_crypted);
9609                 } else {
9610                         r->in.new_lm_crypted = NULL;
9611                 }
9612                 if (r->in.new_lm_crypted) {
9613                         _mem_save_new_lm_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
9614                         NDR_PULL_SET_MEM_CTX(ndr, r->in.new_lm_crypted, 0);
9615                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.new_lm_crypted));
9616                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_lm_crypted_0, 0);
9617                 }
9618                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.nt_present));
9619                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_nt_crypted));
9620                 if (_ptr_old_nt_crypted) {
9621                         NDR_PULL_ALLOC(ndr, r->in.old_nt_crypted);
9622                 } else {
9623                         r->in.old_nt_crypted = NULL;
9624                 }
9625                 if (r->in.old_nt_crypted) {
9626                         _mem_save_old_nt_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
9627                         NDR_PULL_SET_MEM_CTX(ndr, r->in.old_nt_crypted, 0);
9628                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.old_nt_crypted));
9629                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_nt_crypted_0, 0);
9630                 }
9631                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_nt_crypted));
9632                 if (_ptr_new_nt_crypted) {
9633                         NDR_PULL_ALLOC(ndr, r->in.new_nt_crypted);
9634                 } else {
9635                         r->in.new_nt_crypted = NULL;
9636                 }
9637                 if (r->in.new_nt_crypted) {
9638                         _mem_save_new_nt_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
9639                         NDR_PULL_SET_MEM_CTX(ndr, r->in.new_nt_crypted, 0);
9640                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.new_nt_crypted));
9641                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_nt_crypted_0, 0);
9642                 }
9643                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.cross1_present));
9644                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_cross));
9645                 if (_ptr_nt_cross) {
9646                         NDR_PULL_ALLOC(ndr, r->in.nt_cross);
9647                 } else {
9648                         r->in.nt_cross = NULL;
9649                 }
9650                 if (r->in.nt_cross) {
9651                         _mem_save_nt_cross_0 = NDR_PULL_GET_MEM_CTX(ndr);
9652                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_cross, 0);
9653                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_cross));
9654                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_cross_0, 0);
9655                 }
9656                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.cross2_present));
9657                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_cross));
9658                 if (_ptr_lm_cross) {
9659                         NDR_PULL_ALLOC(ndr, r->in.lm_cross);
9660                 } else {
9661                         r->in.lm_cross = NULL;
9662                 }
9663                 if (r->in.lm_cross) {
9664                         _mem_save_lm_cross_0 = NDR_PULL_GET_MEM_CTX(ndr);
9665                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_cross, 0);
9666                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_cross));
9667                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_cross_0, 0);
9668                 }
9669         }
9670         if (flags & NDR_OUT) {
9671                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9672         }
9673         return NDR_ERR_SUCCESS;
9674 }
9675
9676 _PUBLIC_ void ndr_print_samr_ChangePasswordUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser *r)
9677 {
9678         ndr_print_struct(ndr, name, "samr_ChangePasswordUser");
9679         if (r == NULL) { ndr_print_null(ndr); return; }
9680         ndr->depth++;
9681         if (flags & NDR_SET_VALUES) {
9682                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9683         }
9684         if (flags & NDR_IN) {
9685                 ndr_print_struct(ndr, "in", "samr_ChangePasswordUser");
9686                 ndr->depth++;
9687                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9688                 ndr->depth++;
9689                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9690                 ndr->depth--;
9691                 ndr_print_uint8(ndr, "lm_present", r->in.lm_present);
9692                 ndr_print_ptr(ndr, "old_lm_crypted", r->in.old_lm_crypted);
9693                 ndr->depth++;
9694                 if (r->in.old_lm_crypted) {
9695                         ndr_print_samr_Password(ndr, "old_lm_crypted", r->in.old_lm_crypted);
9696                 }
9697                 ndr->depth--;
9698                 ndr_print_ptr(ndr, "new_lm_crypted", r->in.new_lm_crypted);
9699                 ndr->depth++;
9700                 if (r->in.new_lm_crypted) {
9701                         ndr_print_samr_Password(ndr, "new_lm_crypted", r->in.new_lm_crypted);
9702                 }
9703                 ndr->depth--;
9704                 ndr_print_uint8(ndr, "nt_present", r->in.nt_present);
9705                 ndr_print_ptr(ndr, "old_nt_crypted", r->in.old_nt_crypted);
9706                 ndr->depth++;
9707                 if (r->in.old_nt_crypted) {
9708                         ndr_print_samr_Password(ndr, "old_nt_crypted", r->in.old_nt_crypted);
9709                 }
9710                 ndr->depth--;
9711                 ndr_print_ptr(ndr, "new_nt_crypted", r->in.new_nt_crypted);
9712                 ndr->depth++;
9713                 if (r->in.new_nt_crypted) {
9714                         ndr_print_samr_Password(ndr, "new_nt_crypted", r->in.new_nt_crypted);
9715                 }
9716                 ndr->depth--;
9717                 ndr_print_uint8(ndr, "cross1_present", r->in.cross1_present);
9718                 ndr_print_ptr(ndr, "nt_cross", r->in.nt_cross);
9719                 ndr->depth++;
9720                 if (r->in.nt_cross) {
9721                         ndr_print_samr_Password(ndr, "nt_cross", r->in.nt_cross);
9722                 }
9723                 ndr->depth--;
9724                 ndr_print_uint8(ndr, "cross2_present", r->in.cross2_present);
9725                 ndr_print_ptr(ndr, "lm_cross", r->in.lm_cross);
9726                 ndr->depth++;
9727                 if (r->in.lm_cross) {
9728                         ndr_print_samr_Password(ndr, "lm_cross", r->in.lm_cross);
9729                 }
9730                 ndr->depth--;
9731                 ndr->depth--;
9732         }
9733         if (flags & NDR_OUT) {
9734                 ndr_print_struct(ndr, "out", "samr_ChangePasswordUser");
9735                 ndr->depth++;
9736                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9737                 ndr->depth--;
9738         }
9739         ndr->depth--;
9740 }
9741
9742 static enum ndr_err_code ndr_push_samr_GetGroupsForUser(struct ndr_push *ndr, int flags, const struct samr_GetGroupsForUser *r)
9743 {
9744         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
9745         if (flags & NDR_IN) {
9746                 if (r->in.user_handle == NULL) {
9747                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9748                 }
9749                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9750         }
9751         if (flags & NDR_OUT) {
9752                 if (r->out.rids == NULL) {
9753                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9754                 }
9755                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rids));
9756                 if (*r->out.rids) {
9757                         NDR_CHECK(ndr_push_samr_RidWithAttributeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
9758                 }
9759                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9760         }
9761         return NDR_ERR_SUCCESS;
9762 }
9763
9764 static enum ndr_err_code ndr_pull_samr_GetGroupsForUser(struct ndr_pull *ndr, int flags, struct samr_GetGroupsForUser *r)
9765 {
9766         uint32_t _ptr_rids;
9767         TALLOC_CTX *_mem_save_user_handle_0;
9768         TALLOC_CTX *_mem_save_rids_0;
9769         TALLOC_CTX *_mem_save_rids_1;
9770         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
9771         if (flags & NDR_IN) {
9772                 ZERO_STRUCT(r->out);
9773
9774                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9775                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9776                 }
9777                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9778                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9779                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9780                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9781                 NDR_PULL_ALLOC(ndr, r->out.rids);
9782                 ZERO_STRUCTP(r->out.rids);
9783         }
9784         if (flags & NDR_OUT) {
9785                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9786                         NDR_PULL_ALLOC(ndr, r->out.rids);
9787                 }
9788                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
9789                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
9790                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
9791                 if (_ptr_rids) {
9792                         NDR_PULL_ALLOC(ndr, *r->out.rids);
9793                 } else {
9794                         *r->out.rids = NULL;
9795                 }
9796                 if (*r->out.rids) {
9797                         _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
9798                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.rids, 0);
9799                         NDR_CHECK(ndr_pull_samr_RidWithAttributeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
9800                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
9801                 }
9802                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
9803                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9804         }
9805         return NDR_ERR_SUCCESS;
9806 }
9807
9808 _PUBLIC_ void ndr_print_samr_GetGroupsForUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetGroupsForUser *r)
9809 {
9810         ndr_print_struct(ndr, name, "samr_GetGroupsForUser");
9811         if (r == NULL) { ndr_print_null(ndr); return; }
9812         ndr->depth++;
9813         if (flags & NDR_SET_VALUES) {
9814                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9815         }
9816         if (flags & NDR_IN) {
9817                 ndr_print_struct(ndr, "in", "samr_GetGroupsForUser");
9818                 ndr->depth++;
9819                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9820                 ndr->depth++;
9821                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9822                 ndr->depth--;
9823                 ndr->depth--;
9824         }
9825         if (flags & NDR_OUT) {
9826                 ndr_print_struct(ndr, "out", "samr_GetGroupsForUser");
9827                 ndr->depth++;
9828                 ndr_print_ptr(ndr, "rids", r->out.rids);
9829                 ndr->depth++;
9830                 ndr_print_ptr(ndr, "rids", *r->out.rids);
9831                 ndr->depth++;
9832                 if (*r->out.rids) {
9833                         ndr_print_samr_RidWithAttributeArray(ndr, "rids", *r->out.rids);
9834                 }
9835                 ndr->depth--;
9836                 ndr->depth--;
9837                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9838                 ndr->depth--;
9839         }
9840         ndr->depth--;
9841 }
9842
9843 static enum ndr_err_code ndr_push_samr_QueryDisplayInfo(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo *r)
9844 {
9845         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
9846         if (flags & NDR_IN) {
9847                 if (r->in.domain_handle == NULL) {
9848                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9849                 }
9850                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9851                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9852                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));
9853                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));
9854                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
9855         }
9856         if (flags & NDR_OUT) {
9857                 if (r->out.total_size == NULL) {
9858                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9859                 }
9860                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));
9861                 if (r->out.returned_size == NULL) {
9862                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9863                 }
9864                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));
9865                 if (r->out.info == NULL) {
9866                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9867                 }
9868                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
9869                 NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
9870                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9871         }
9872         return NDR_ERR_SUCCESS;
9873 }
9874
9875 static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo *r)
9876 {
9877         TALLOC_CTX *_mem_save_domain_handle_0;
9878         TALLOC_CTX *_mem_save_total_size_0;
9879         TALLOC_CTX *_mem_save_returned_size_0;
9880         TALLOC_CTX *_mem_save_info_0;
9881         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
9882         if (flags & NDR_IN) {
9883                 ZERO_STRUCT(r->out);
9884
9885                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9886                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
9887                 }
9888                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9889                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
9890                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9891                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
9892                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
9893                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));
9894                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));
9895                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
9896                 NDR_PULL_ALLOC(ndr, r->out.total_size);
9897                 ZERO_STRUCTP(r->out.total_size);
9898                 NDR_PULL_ALLOC(ndr, r->out.returned_size);
9899                 ZERO_STRUCTP(r->out.returned_size);
9900                 NDR_PULL_ALLOC(ndr, r->out.info);
9901                 ZERO_STRUCTP(r->out.info);
9902         }
9903         if (flags & NDR_OUT) {
9904                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9905                         NDR_PULL_ALLOC(ndr, r->out.total_size);
9906                 }
9907                 _mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
9908                 NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);
9909                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));
9910                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);
9911                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9912                         NDR_PULL_ALLOC(ndr, r->out.returned_size);
9913                 }
9914                 _mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
9915                 NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);
9916                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));
9917                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);
9918                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9919                         NDR_PULL_ALLOC(ndr, r->out.info);
9920                 }
9921                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9922                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9923                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
9924                 NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
9925                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9926                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9927         }
9928         return NDR_ERR_SUCCESS;
9929 }
9930
9931 _PUBLIC_ void ndr_print_samr_QueryDisplayInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo *r)
9932 {
9933         ndr_print_struct(ndr, name, "samr_QueryDisplayInfo");
9934         if (r == NULL) { ndr_print_null(ndr); return; }
9935         ndr->depth++;
9936         if (flags & NDR_SET_VALUES) {
9937                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9938         }
9939         if (flags & NDR_IN) {
9940                 ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo");
9941                 ndr->depth++;
9942                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
9943                 ndr->depth++;
9944                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
9945                 ndr->depth--;
9946                 ndr_print_uint16(ndr, "level", r->in.level);
9947                 ndr_print_uint32(ndr, "start_idx", r->in.start_idx);
9948                 ndr_print_uint32(ndr, "max_entries", r->in.max_entries);
9949                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
9950                 ndr->depth--;
9951         }
9952         if (flags & NDR_OUT) {
9953                 ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo");
9954                 ndr->depth++;
9955                 ndr_print_ptr(ndr, "total_size", r->out.total_size);
9956                 ndr->depth++;
9957                 ndr_print_uint32(ndr, "total_size", *r->out.total_size);
9958                 ndr->depth--;
9959                 ndr_print_ptr(ndr, "returned_size", r->out.returned_size);
9960                 ndr->depth++;
9961                 ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);
9962                 ndr->depth--;
9963                 ndr_print_ptr(ndr, "info", r->out.info);
9964                 ndr->depth++;
9965                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
9966                 ndr_print_samr_DispInfo(ndr, "info", r->out.info);
9967                 ndr->depth--;
9968                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9969                 ndr->depth--;
9970         }
9971         ndr->depth--;
9972 }
9973
9974 static enum ndr_err_code ndr_push_samr_GetDisplayEnumerationIndex(struct ndr_push *ndr, int flags, const struct samr_GetDisplayEnumerationIndex *r)
9975 {
9976         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
9977         if (flags & NDR_IN) {
9978                 if (r->in.domain_handle == NULL) {
9979                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9980                 }
9981                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9982                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9983                 if (r->in.name == NULL) {
9984                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9985                 }
9986                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
9987         }
9988         if (flags & NDR_OUT) {
9989                 if (r->out.idx == NULL) {
9990                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9991                 }
9992                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.idx));
9993                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9994         }
9995         return NDR_ERR_SUCCESS;
9996 }
9997
9998 static enum ndr_err_code ndr_pull_samr_GetDisplayEnumerationIndex(struct ndr_pull *ndr, int flags, struct samr_GetDisplayEnumerationIndex *r)
9999 {
10000         TALLOC_CTX *_mem_save_domain_handle_0;
10001         TALLOC_CTX *_mem_save_name_0;
10002         TALLOC_CTX *_mem_save_idx_0;
10003         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
10004         if (flags & NDR_IN) {
10005                 ZERO_STRUCT(r->out);
10006
10007                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10008                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10009                 }
10010                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10011                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10012                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10013                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10014                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10015                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10016                         NDR_PULL_ALLOC(ndr, r->in.name);
10017                 }
10018                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10019                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
10020                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
10021                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
10022                 NDR_PULL_ALLOC(ndr, r->out.idx);
10023                 ZERO_STRUCTP(r->out.idx);
10024         }
10025         if (flags & NDR_OUT) {
10026                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10027                         NDR_PULL_ALLOC(ndr, r->out.idx);
10028                 }
10029                 _mem_save_idx_0 = NDR_PULL_GET_MEM_CTX(ndr);
10030                 NDR_PULL_SET_MEM_CTX(ndr, r->out.idx, LIBNDR_FLAG_REF_ALLOC);
10031                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.idx));
10032                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_idx_0, LIBNDR_FLAG_REF_ALLOC);
10033                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10034         }
10035         return NDR_ERR_SUCCESS;
10036 }
10037
10038 _PUBLIC_ void ndr_print_samr_GetDisplayEnumerationIndex(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDisplayEnumerationIndex *r)
10039 {
10040         ndr_print_struct(ndr, name, "samr_GetDisplayEnumerationIndex");
10041         if (r == NULL) { ndr_print_null(ndr); return; }
10042         ndr->depth++;
10043         if (flags & NDR_SET_VALUES) {
10044                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10045         }
10046         if (flags & NDR_IN) {
10047                 ndr_print_struct(ndr, "in", "samr_GetDisplayEnumerationIndex");
10048                 ndr->depth++;
10049                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10050                 ndr->depth++;
10051                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10052                 ndr->depth--;
10053                 ndr_print_uint16(ndr, "level", r->in.level);
10054                 ndr_print_ptr(ndr, "name", r->in.name);
10055                 ndr->depth++;
10056                 ndr_print_lsa_String(ndr, "name", r->in.name);
10057                 ndr->depth--;
10058                 ndr->depth--;
10059         }
10060         if (flags & NDR_OUT) {
10061                 ndr_print_struct(ndr, "out", "samr_GetDisplayEnumerationIndex");
10062                 ndr->depth++;
10063                 ndr_print_ptr(ndr, "idx", r->out.idx);
10064                 ndr->depth++;
10065                 ndr_print_uint32(ndr, "idx", *r->out.idx);
10066                 ndr->depth--;
10067                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10068                 ndr->depth--;
10069         }
10070         ndr->depth--;
10071 }
10072
10073 static enum ndr_err_code ndr_push_samr_TestPrivateFunctionsDomain(struct ndr_push *ndr, int flags, const struct samr_TestPrivateFunctionsDomain *r)
10074 {
10075         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
10076         if (flags & NDR_IN) {
10077                 if (r->in.domain_handle == NULL) {
10078                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10079                 }
10080                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10081         }
10082         if (flags & NDR_OUT) {
10083                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10084         }
10085         return NDR_ERR_SUCCESS;
10086 }
10087
10088 static enum ndr_err_code ndr_pull_samr_TestPrivateFunctionsDomain(struct ndr_pull *ndr, int flags, struct samr_TestPrivateFunctionsDomain *r)
10089 {
10090         TALLOC_CTX *_mem_save_domain_handle_0;
10091         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
10092         if (flags & NDR_IN) {
10093                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10094                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10095                 }
10096                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10097                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10098                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10099                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10100         }
10101         if (flags & NDR_OUT) {
10102                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10103         }
10104         return NDR_ERR_SUCCESS;
10105 }
10106
10107 _PUBLIC_ void ndr_print_samr_TestPrivateFunctionsDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_TestPrivateFunctionsDomain *r)
10108 {
10109         ndr_print_struct(ndr, name, "samr_TestPrivateFunctionsDomain");
10110         if (r == NULL) { ndr_print_null(ndr); return; }
10111         ndr->depth++;
10112         if (flags & NDR_SET_VALUES) {
10113                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10114         }
10115         if (flags & NDR_IN) {
10116                 ndr_print_struct(ndr, "in", "samr_TestPrivateFunctionsDomain");
10117                 ndr->depth++;
10118                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10119                 ndr->depth++;
10120                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10121                 ndr->depth--;
10122                 ndr->depth--;
10123         }
10124         if (flags & NDR_OUT) {
10125                 ndr_print_struct(ndr, "out", "samr_TestPrivateFunctionsDomain");
10126                 ndr->depth++;
10127                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10128                 ndr->depth--;
10129         }
10130         ndr->depth--;
10131 }
10132
10133 static enum ndr_err_code ndr_push_samr_TestPrivateFunctionsUser(struct ndr_push *ndr, int flags, const struct samr_TestPrivateFunctionsUser *r)
10134 {
10135         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
10136         if (flags & NDR_IN) {
10137                 if (r->in.user_handle == NULL) {
10138                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10139                 }
10140                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
10141         }
10142         if (flags & NDR_OUT) {
10143                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10144         }
10145         return NDR_ERR_SUCCESS;
10146 }
10147
10148 static enum ndr_err_code ndr_pull_samr_TestPrivateFunctionsUser(struct ndr_pull *ndr, int flags, struct samr_TestPrivateFunctionsUser *r)
10149 {
10150         TALLOC_CTX *_mem_save_user_handle_0;
10151         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
10152         if (flags & NDR_IN) {
10153                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10154                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
10155                 }
10156                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10157                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
10158                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
10159                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
10160         }
10161         if (flags & NDR_OUT) {
10162                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10163         }
10164         return NDR_ERR_SUCCESS;
10165 }
10166
10167 _PUBLIC_ void ndr_print_samr_TestPrivateFunctionsUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_TestPrivateFunctionsUser *r)
10168 {
10169         ndr_print_struct(ndr, name, "samr_TestPrivateFunctionsUser");
10170         if (r == NULL) { ndr_print_null(ndr); return; }
10171         ndr->depth++;
10172         if (flags & NDR_SET_VALUES) {
10173                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10174         }
10175         if (flags & NDR_IN) {
10176                 ndr_print_struct(ndr, "in", "samr_TestPrivateFunctionsUser");
10177                 ndr->depth++;
10178                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
10179                 ndr->depth++;
10180                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
10181                 ndr->depth--;
10182                 ndr->depth--;
10183         }
10184         if (flags & NDR_OUT) {
10185                 ndr_print_struct(ndr, "out", "samr_TestPrivateFunctionsUser");
10186                 ndr->depth++;
10187                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10188                 ndr->depth--;
10189         }
10190         ndr->depth--;
10191 }
10192
10193 _PUBLIC_ enum ndr_err_code ndr_push_samr_GetUserPwInfo(struct ndr_push *ndr, int flags, const struct samr_GetUserPwInfo *r)
10194 {
10195         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
10196         if (flags & NDR_IN) {
10197                 if (r->in.user_handle == NULL) {
10198                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10199                 }
10200                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
10201         }
10202         if (flags & NDR_OUT) {
10203                 if (r->out.info == NULL) {
10204                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10205                 }
10206                 NDR_CHECK(ndr_push_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
10207                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10208         }
10209         return NDR_ERR_SUCCESS;
10210 }
10211
10212 _PUBLIC_ enum ndr_err_code ndr_pull_samr_GetUserPwInfo(struct ndr_pull *ndr, int flags, struct samr_GetUserPwInfo *r)
10213 {
10214         TALLOC_CTX *_mem_save_user_handle_0;
10215         TALLOC_CTX *_mem_save_info_0;
10216         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
10217         if (flags & NDR_IN) {
10218                 ZERO_STRUCT(r->out);
10219
10220                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10221                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
10222                 }
10223                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10224                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
10225                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
10226                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
10227                 NDR_PULL_ALLOC(ndr, r->out.info);
10228                 ZERO_STRUCTP(r->out.info);
10229         }
10230         if (flags & NDR_OUT) {
10231                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10232                         NDR_PULL_ALLOC(ndr, r->out.info);
10233                 }
10234                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10235                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
10236                 NDR_CHECK(ndr_pull_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
10237                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
10238                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10239         }
10240         return NDR_ERR_SUCCESS;
10241 }
10242
10243 _PUBLIC_ void ndr_print_samr_GetUserPwInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetUserPwInfo *r)
10244 {
10245         ndr_print_struct(ndr, name, "samr_GetUserPwInfo");
10246         if (r == NULL) { ndr_print_null(ndr); return; }
10247         ndr->depth++;
10248         if (flags & NDR_SET_VALUES) {
10249                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10250         }
10251         if (flags & NDR_IN) {
10252                 ndr_print_struct(ndr, "in", "samr_GetUserPwInfo");
10253                 ndr->depth++;
10254                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
10255                 ndr->depth++;
10256                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
10257                 ndr->depth--;
10258                 ndr->depth--;
10259         }
10260         if (flags & NDR_OUT) {
10261                 ndr_print_struct(ndr, "out", "samr_GetUserPwInfo");
10262                 ndr->depth++;
10263                 ndr_print_ptr(ndr, "info", r->out.info);
10264                 ndr->depth++;
10265                 ndr_print_samr_PwInfo(ndr, "info", r->out.info);
10266                 ndr->depth--;
10267                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10268                 ndr->depth--;
10269         }
10270         ndr->depth--;
10271 }
10272
10273 static enum ndr_err_code ndr_push_samr_RemoveMemberFromForeignDomain(struct ndr_push *ndr, int flags, const struct samr_RemoveMemberFromForeignDomain *r)
10274 {
10275         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
10276         if (flags & NDR_IN) {
10277                 if (r->in.domain_handle == NULL) {
10278                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10279                 }
10280                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10281                 if (r->in.sid == NULL) {
10282                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10283                 }
10284                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
10285         }
10286         if (flags & NDR_OUT) {
10287                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10288         }
10289         return NDR_ERR_SUCCESS;
10290 }
10291
10292 static enum ndr_err_code ndr_pull_samr_RemoveMemberFromForeignDomain(struct ndr_pull *ndr, int flags, struct samr_RemoveMemberFromForeignDomain *r)
10293 {
10294         TALLOC_CTX *_mem_save_domain_handle_0;
10295         TALLOC_CTX *_mem_save_sid_0;
10296         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
10297         if (flags & NDR_IN) {
10298                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10299                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10300                 }
10301                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10302                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10303                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10304                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10305                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10306                         NDR_PULL_ALLOC(ndr, r->in.sid);
10307                 }
10308                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
10309                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
10310                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
10311                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
10312         }
10313         if (flags & NDR_OUT) {
10314                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10315         }
10316         return NDR_ERR_SUCCESS;
10317 }
10318
10319 _PUBLIC_ void ndr_print_samr_RemoveMemberFromForeignDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_RemoveMemberFromForeignDomain *r)
10320 {
10321         ndr_print_struct(ndr, name, "samr_RemoveMemberFromForeignDomain");
10322         if (r == NULL) { ndr_print_null(ndr); return; }
10323         ndr->depth++;
10324         if (flags & NDR_SET_VALUES) {
10325                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10326         }
10327         if (flags & NDR_IN) {
10328                 ndr_print_struct(ndr, "in", "samr_RemoveMemberFromForeignDomain");
10329                 ndr->depth++;
10330                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10331                 ndr->depth++;
10332                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10333                 ndr->depth--;
10334                 ndr_print_ptr(ndr, "sid", r->in.sid);
10335                 ndr->depth++;
10336                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
10337                 ndr->depth--;
10338                 ndr->depth--;
10339         }
10340         if (flags & NDR_OUT) {
10341                 ndr_print_struct(ndr, "out", "samr_RemoveMemberFromForeignDomain");
10342                 ndr->depth++;
10343                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10344                 ndr->depth--;
10345         }
10346         ndr->depth--;
10347 }
10348
10349 static enum ndr_err_code ndr_push_samr_QueryDomainInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryDomainInfo2 *r)
10350 {
10351         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
10352         if (flags & NDR_IN) {
10353                 if (r->in.domain_handle == NULL) {
10354                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10355                 }
10356                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10357                 NDR_CHECK(ndr_push_samr_DomainInfoClass(ndr, NDR_SCALARS, r->in.level));
10358         }
10359         if (flags & NDR_OUT) {
10360                 if (r->out.info == NULL) {
10361                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10362                 }
10363                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
10364                 if (*r->out.info) {
10365                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
10366                         NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
10367                 }
10368                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10369         }
10370         return NDR_ERR_SUCCESS;
10371 }
10372
10373 static enum ndr_err_code ndr_pull_samr_QueryDomainInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryDomainInfo2 *r)
10374 {
10375         uint32_t _ptr_info;
10376         TALLOC_CTX *_mem_save_domain_handle_0;
10377         TALLOC_CTX *_mem_save_info_0;
10378         TALLOC_CTX *_mem_save_info_1;
10379         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
10380         if (flags & NDR_IN) {
10381                 ZERO_STRUCT(r->out);
10382
10383                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10384                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10385                 }
10386                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10387                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10388                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10389                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10390                 NDR_CHECK(ndr_pull_samr_DomainInfoClass(ndr, NDR_SCALARS, &r->in.level));
10391                 NDR_PULL_ALLOC(ndr, r->out.info);
10392                 ZERO_STRUCTP(r->out.info);
10393         }
10394         if (flags & NDR_OUT) {
10395                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10396                         NDR_PULL_ALLOC(ndr, r->out.info);
10397                 }
10398                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10399                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
10400                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
10401                 if (_ptr_info) {
10402                         NDR_PULL_ALLOC(ndr, *r->out.info);
10403                 } else {
10404                         *r->out.info = NULL;
10405                 }
10406                 if (*r->out.info) {
10407                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
10408                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
10409                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
10410                         NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
10411                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
10412                 }
10413                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
10414                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10415         }
10416         return NDR_ERR_SUCCESS;
10417 }
10418
10419 _PUBLIC_ void ndr_print_samr_QueryDomainInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDomainInfo2 *r)
10420 {
10421         ndr_print_struct(ndr, name, "samr_QueryDomainInfo2");
10422         if (r == NULL) { ndr_print_null(ndr); return; }
10423         ndr->depth++;
10424         if (flags & NDR_SET_VALUES) {
10425                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10426         }
10427         if (flags & NDR_IN) {
10428                 ndr_print_struct(ndr, "in", "samr_QueryDomainInfo2");
10429                 ndr->depth++;
10430                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10431                 ndr->depth++;
10432                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10433                 ndr->depth--;
10434                 ndr_print_samr_DomainInfoClass(ndr, "level", r->in.level);
10435                 ndr->depth--;
10436         }
10437         if (flags & NDR_OUT) {
10438                 ndr_print_struct(ndr, "out", "samr_QueryDomainInfo2");
10439                 ndr->depth++;
10440                 ndr_print_ptr(ndr, "info", r->out.info);
10441                 ndr->depth++;
10442                 ndr_print_ptr(ndr, "info", *r->out.info);
10443                 ndr->depth++;
10444                 if (*r->out.info) {
10445                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
10446                         ndr_print_samr_DomainInfo(ndr, "info", *r->out.info);
10447                 }
10448                 ndr->depth--;
10449                 ndr->depth--;
10450                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10451                 ndr->depth--;
10452         }
10453         ndr->depth--;
10454 }
10455
10456 static enum ndr_err_code ndr_push_samr_QueryUserInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryUserInfo2 *r)
10457 {
10458         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
10459         if (flags & NDR_IN) {
10460                 if (r->in.user_handle == NULL) {
10461                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10462                 }
10463                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
10464                 NDR_CHECK(ndr_push_samr_UserInfoLevel(ndr, NDR_SCALARS, r->in.level));
10465         }
10466         if (flags & NDR_OUT) {
10467                 if (r->out.info == NULL) {
10468                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10469                 }
10470                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
10471                 if (*r->out.info) {
10472                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
10473                         NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
10474                 }
10475                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10476         }
10477         return NDR_ERR_SUCCESS;
10478 }
10479
10480 static enum ndr_err_code ndr_pull_samr_QueryUserInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryUserInfo2 *r)
10481 {
10482         uint32_t _ptr_info;
10483         TALLOC_CTX *_mem_save_user_handle_0;
10484         TALLOC_CTX *_mem_save_info_0;
10485         TALLOC_CTX *_mem_save_info_1;
10486         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
10487         if (flags & NDR_IN) {
10488                 ZERO_STRUCT(r->out);
10489
10490                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10491                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
10492                 }
10493                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10494                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
10495                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
10496                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
10497                 NDR_CHECK(ndr_pull_samr_UserInfoLevel(ndr, NDR_SCALARS, &r->in.level));
10498                 NDR_PULL_ALLOC(ndr, r->out.info);
10499                 ZERO_STRUCTP(r->out.info);
10500         }
10501         if (flags & NDR_OUT) {
10502                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10503                         NDR_PULL_ALLOC(ndr, r->out.info);
10504                 }
10505                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10506                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
10507                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
10508                 if (_ptr_info) {
10509                         NDR_PULL_ALLOC(ndr, *r->out.info);
10510                 } else {
10511                         *r->out.info = NULL;
10512                 }
10513                 if (*r->out.info) {
10514                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
10515                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
10516                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
10517                         NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
10518                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
10519                 }
10520                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
10521                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10522         }
10523         return NDR_ERR_SUCCESS;
10524 }
10525
10526 _PUBLIC_ void ndr_print_samr_QueryUserInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryUserInfo2 *r)
10527 {
10528         ndr_print_struct(ndr, name, "samr_QueryUserInfo2");
10529         if (r == NULL) { ndr_print_null(ndr); return; }
10530         ndr->depth++;
10531         if (flags & NDR_SET_VALUES) {
10532                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10533         }
10534         if (flags & NDR_IN) {
10535                 ndr_print_struct(ndr, "in", "samr_QueryUserInfo2");
10536                 ndr->depth++;
10537                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
10538                 ndr->depth++;
10539                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
10540                 ndr->depth--;
10541                 ndr_print_samr_UserInfoLevel(ndr, "level", r->in.level);
10542                 ndr->depth--;
10543         }
10544         if (flags & NDR_OUT) {
10545                 ndr_print_struct(ndr, "out", "samr_QueryUserInfo2");
10546                 ndr->depth++;
10547                 ndr_print_ptr(ndr, "info", r->out.info);
10548                 ndr->depth++;
10549                 ndr_print_ptr(ndr, "info", *r->out.info);
10550                 ndr->depth++;
10551                 if (*r->out.info) {
10552                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
10553                         ndr_print_samr_UserInfo(ndr, "info", *r->out.info);
10554                 }
10555                 ndr->depth--;
10556                 ndr->depth--;
10557                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10558                 ndr->depth--;
10559         }
10560         ndr->depth--;
10561 }
10562
10563 static enum ndr_err_code ndr_push_samr_QueryDisplayInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo2 *r)
10564 {
10565         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
10566         if (flags & NDR_IN) {
10567                 if (r->in.domain_handle == NULL) {
10568                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10569                 }
10570                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10571                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
10572                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));
10573                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));
10574                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
10575         }
10576         if (flags & NDR_OUT) {
10577                 if (r->out.total_size == NULL) {
10578                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10579                 }
10580                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));
10581                 if (r->out.returned_size == NULL) {
10582                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10583                 }
10584                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));
10585                 if (r->out.info == NULL) {
10586                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10587                 }
10588                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
10589                 NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
10590                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10591         }
10592         return NDR_ERR_SUCCESS;
10593 }
10594
10595 static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo2 *r)
10596 {
10597         TALLOC_CTX *_mem_save_domain_handle_0;
10598         TALLOC_CTX *_mem_save_total_size_0;
10599         TALLOC_CTX *_mem_save_returned_size_0;
10600         TALLOC_CTX *_mem_save_info_0;
10601         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
10602         if (flags & NDR_IN) {
10603                 ZERO_STRUCT(r->out);
10604
10605                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10606                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10607                 }
10608                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10609                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10610                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10611                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10612                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10613                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));
10614                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));
10615                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
10616                 NDR_PULL_ALLOC(ndr, r->out.total_size);
10617                 ZERO_STRUCTP(r->out.total_size);
10618                 NDR_PULL_ALLOC(ndr, r->out.returned_size);
10619                 ZERO_STRUCTP(r->out.returned_size);
10620                 NDR_PULL_ALLOC(ndr, r->out.info);
10621                 ZERO_STRUCTP(r->out.info);
10622         }
10623         if (flags & NDR_OUT) {
10624                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10625                         NDR_PULL_ALLOC(ndr, r->out.total_size);
10626                 }
10627                 _mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
10628                 NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);
10629                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));
10630                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);
10631                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10632                         NDR_PULL_ALLOC(ndr, r->out.returned_size);
10633                 }
10634                 _mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
10635                 NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);
10636                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));
10637                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);
10638                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10639                         NDR_PULL_ALLOC(ndr, r->out.info);
10640                 }
10641                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10642                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
10643                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
10644                 NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
10645                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
10646                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10647         }
10648         return NDR_ERR_SUCCESS;
10649 }
10650
10651 _PUBLIC_ void ndr_print_samr_QueryDisplayInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo2 *r)
10652 {
10653         ndr_print_struct(ndr, name, "samr_QueryDisplayInfo2");
10654         if (r == NULL) { ndr_print_null(ndr); return; }
10655         ndr->depth++;
10656         if (flags & NDR_SET_VALUES) {
10657                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10658         }
10659         if (flags & NDR_IN) {
10660                 ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo2");
10661                 ndr->depth++;
10662                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10663                 ndr->depth++;
10664                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10665                 ndr->depth--;
10666                 ndr_print_uint16(ndr, "level", r->in.level);
10667                 ndr_print_uint32(ndr, "start_idx", r->in.start_idx);
10668                 ndr_print_uint32(ndr, "max_entries", r->in.max_entries);
10669                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
10670                 ndr->depth--;
10671         }
10672         if (flags & NDR_OUT) {
10673                 ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo2");
10674                 ndr->depth++;
10675                 ndr_print_ptr(ndr, "total_size", r->out.total_size);
10676                 ndr->depth++;
10677                 ndr_print_uint32(ndr, "total_size", *r->out.total_size);
10678                 ndr->depth--;
10679                 ndr_print_ptr(ndr, "returned_size", r->out.returned_size);
10680                 ndr->depth++;
10681                 ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);
10682                 ndr->depth--;
10683                 ndr_print_ptr(ndr, "info", r->out.info);
10684                 ndr->depth++;
10685                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
10686                 ndr_print_samr_DispInfo(ndr, "info", r->out.info);
10687                 ndr->depth--;
10688                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10689                 ndr->depth--;
10690         }
10691         ndr->depth--;
10692 }
10693
10694 static enum ndr_err_code ndr_push_samr_GetDisplayEnumerationIndex2(struct ndr_push *ndr, int flags, const struct samr_GetDisplayEnumerationIndex2 *r)
10695 {
10696         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
10697         if (flags & NDR_IN) {
10698                 if (r->in.domain_handle == NULL) {
10699                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10700                 }
10701                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10702                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
10703                 if (r->in.name == NULL) {
10704                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10705                 }
10706                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
10707         }
10708         if (flags & NDR_OUT) {
10709                 if (r->out.idx == NULL) {
10710                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10711                 }
10712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.idx));
10713                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10714         }
10715         return NDR_ERR_SUCCESS;
10716 }
10717
10718 static enum ndr_err_code ndr_pull_samr_GetDisplayEnumerationIndex2(struct ndr_pull *ndr, int flags, struct samr_GetDisplayEnumerationIndex2 *r)
10719 {
10720         TALLOC_CTX *_mem_save_domain_handle_0;
10721         TALLOC_CTX *_mem_save_name_0;
10722         TALLOC_CTX *_mem_save_idx_0;
10723         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
10724         if (flags & NDR_IN) {
10725                 ZERO_STRUCT(r->out);
10726
10727                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10728                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10729                 }
10730                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10731                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10732                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10733                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10734                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10735                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10736                         NDR_PULL_ALLOC(ndr, r->in.name);
10737                 }
10738                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10739                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
10740                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
10741                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
10742                 NDR_PULL_ALLOC(ndr, r->out.idx);
10743                 ZERO_STRUCTP(r->out.idx);
10744         }
10745         if (flags & NDR_OUT) {
10746                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10747                         NDR_PULL_ALLOC(ndr, r->out.idx);
10748                 }
10749                 _mem_save_idx_0 = NDR_PULL_GET_MEM_CTX(ndr);
10750                 NDR_PULL_SET_MEM_CTX(ndr, r->out.idx, LIBNDR_FLAG_REF_ALLOC);
10751                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.idx));
10752                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_idx_0, LIBNDR_FLAG_REF_ALLOC);
10753                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10754         }
10755         return NDR_ERR_SUCCESS;
10756 }
10757
10758 _PUBLIC_ void ndr_print_samr_GetDisplayEnumerationIndex2(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDisplayEnumerationIndex2 *r)
10759 {
10760         ndr_print_struct(ndr, name, "samr_GetDisplayEnumerationIndex2");
10761         if (r == NULL) { ndr_print_null(ndr); return; }
10762         ndr->depth++;
10763         if (flags & NDR_SET_VALUES) {
10764                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10765         }
10766         if (flags & NDR_IN) {
10767                 ndr_print_struct(ndr, "in", "samr_GetDisplayEnumerationIndex2");
10768                 ndr->depth++;
10769                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10770                 ndr->depth++;
10771                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10772                 ndr->depth--;
10773                 ndr_print_uint16(ndr, "level", r->in.level);
10774                 ndr_print_ptr(ndr, "name", r->in.name);
10775                 ndr->depth++;
10776                 ndr_print_lsa_String(ndr, "name", r->in.name);
10777                 ndr->depth--;
10778                 ndr->depth--;
10779         }
10780         if (flags & NDR_OUT) {
10781                 ndr_print_struct(ndr, "out", "samr_GetDisplayEnumerationIndex2");
10782                 ndr->depth++;
10783                 ndr_print_ptr(ndr, "idx", r->out.idx);
10784                 ndr->depth++;
10785                 ndr_print_uint32(ndr, "idx", *r->out.idx);
10786                 ndr->depth--;
10787                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10788                 ndr->depth--;
10789         }
10790         ndr->depth--;
10791 }
10792
10793 static enum ndr_err_code ndr_push_samr_CreateUser2(struct ndr_push *ndr, int flags, const struct samr_CreateUser2 *r)
10794 {
10795         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
10796         if (flags & NDR_IN) {
10797                 if (r->in.domain_handle == NULL) {
10798                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10799                 }
10800                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10801                 if (r->in.account_name == NULL) {
10802                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10803                 }
10804                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
10805                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->in.acct_flags));
10806                 NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
10807         }
10808         if (flags & NDR_OUT) {
10809                 if (r->out.user_handle == NULL) {
10810                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10811                 }
10812                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
10813                 if (r->out.access_granted == NULL) {
10814                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10815                 }
10816                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.access_granted));
10817                 if (r->out.rid == NULL) {
10818                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10819                 }
10820                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
10821                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10822         }
10823         return NDR_ERR_SUCCESS;
10824 }
10825
10826 static enum ndr_err_code ndr_pull_samr_CreateUser2(struct ndr_pull *ndr, int flags, struct samr_CreateUser2 *r)
10827 {
10828         TALLOC_CTX *_mem_save_domain_handle_0;
10829         TALLOC_CTX *_mem_save_account_name_0;
10830         TALLOC_CTX *_mem_save_user_handle_0;
10831         TALLOC_CTX *_mem_save_access_granted_0;
10832         TALLOC_CTX *_mem_save_rid_0;
10833         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
10834         if (flags & NDR_IN) {
10835                 ZERO_STRUCT(r->out);
10836
10837                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10838                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10839                 }
10840                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10841                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10842                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10843                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10844                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10845                         NDR_PULL_ALLOC(ndr, r->in.account_name);
10846                 }
10847                 _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10848                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account_name, LIBNDR_FLAG_REF_ALLOC);
10849                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
10850                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, LIBNDR_FLAG_REF_ALLOC);
10851                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->in.acct_flags));
10852                 NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
10853                 NDR_PULL_ALLOC(ndr, r->out.user_handle);
10854                 ZERO_STRUCTP(r->out.user_handle);
10855                 NDR_PULL_ALLOC(ndr, r->out.access_granted);
10856                 ZERO_STRUCTP(r->out.access_granted);
10857                 NDR_PULL_ALLOC(ndr, r->out.rid);
10858                 ZERO_STRUCTP(r->out.rid);
10859         }
10860         if (flags & NDR_OUT) {
10861                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10862                         NDR_PULL_ALLOC(ndr, r->out.user_handle);
10863                 }
10864                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10865                 NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
10866                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
10867                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
10868                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10869                         NDR_PULL_ALLOC(ndr, r->out.access_granted);
10870                 }
10871                 _mem_save_access_granted_0 = NDR_PULL_GET_MEM_CTX(ndr);
10872                 NDR_PULL_SET_MEM_CTX(ndr, r->out.access_granted, LIBNDR_FLAG_REF_ALLOC);
10873                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.access_granted));
10874                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_access_granted_0, LIBNDR_FLAG_REF_ALLOC);
10875                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10876                         NDR_PULL_ALLOC(ndr, r->out.rid);
10877                 }
10878                 _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
10879                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
10880                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
10881                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
10882                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10883         }
10884         return NDR_ERR_SUCCESS;
10885 }
10886
10887 _PUBLIC_ void ndr_print_samr_CreateUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateUser2 *r)
10888 {
10889         ndr_print_struct(ndr, name, "samr_CreateUser2");
10890         if (r == NULL) { ndr_print_null(ndr); return; }
10891         ndr->depth++;
10892         if (flags & NDR_SET_VALUES) {
10893                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10894         }
10895         if (flags & NDR_IN) {
10896                 ndr_print_struct(ndr, "in", "samr_CreateUser2");
10897                 ndr->depth++;
10898                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10899                 ndr->depth++;
10900                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10901                 ndr->depth--;
10902                 ndr_print_ptr(ndr, "account_name", r->in.account_name);
10903                 ndr->depth++;
10904                 ndr_print_lsa_String(ndr, "account_name", r->in.account_name);
10905                 ndr->depth--;
10906                 ndr_print_samr_AcctFlags(ndr, "acct_flags", r->in.acct_flags);
10907                 ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);
10908                 ndr->depth--;
10909         }
10910         if (flags & NDR_OUT) {
10911                 ndr_print_struct(ndr, "out", "samr_CreateUser2");
10912                 ndr->depth++;
10913                 ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
10914                 ndr->depth++;
10915                 ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
10916                 ndr->depth--;
10917                 ndr_print_ptr(ndr, "access_granted", r->out.access_granted);
10918                 ndr->depth++;
10919                 ndr_print_uint32(ndr, "access_granted", *r->out.access_granted);
10920                 ndr->depth--;
10921                 ndr_print_ptr(ndr, "rid", r->out.rid);
10922                 ndr->depth++;
10923                 ndr_print_uint32(ndr, "rid", *r->out.rid);
10924                 ndr->depth--;
10925                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10926                 ndr->depth--;
10927         }
10928         ndr->depth--;
10929 }
10930
10931 static enum ndr_err_code ndr_push_samr_QueryDisplayInfo3(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo3 *r)
10932 {
10933         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
10934         if (flags & NDR_IN) {
10935                 if (r->in.domain_handle == NULL) {
10936                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10937                 }
10938                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10939                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
10940                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));
10941                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));
10942                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
10943         }
10944         if (flags & NDR_OUT) {
10945                 if (r->out.total_size == NULL) {
10946                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10947                 }
10948                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));
10949                 if (r->out.returned_size == NULL) {
10950                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10951                 }
10952                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));
10953                 if (r->out.info == NULL) {
10954                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10955                 }
10956                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
10957                 NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
10958                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10959         }
10960         return NDR_ERR_SUCCESS;
10961 }
10962
10963 static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo3(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo3 *r)
10964 {
10965         TALLOC_CTX *_mem_save_domain_handle_0;
10966         TALLOC_CTX *_mem_save_total_size_0;
10967         TALLOC_CTX *_mem_save_returned_size_0;
10968         TALLOC_CTX *_mem_save_info_0;
10969         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
10970         if (flags & NDR_IN) {
10971                 ZERO_STRUCT(r->out);
10972
10973                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10974                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10975                 }
10976                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10977                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10978                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10979                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10980                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10981                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));
10982                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));
10983                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
10984                 NDR_PULL_ALLOC(ndr, r->out.total_size);
10985                 ZERO_STRUCTP(r->out.total_size);
10986                 NDR_PULL_ALLOC(ndr, r->out.returned_size);
10987                 ZERO_STRUCTP(r->out.returned_size);
10988                 NDR_PULL_ALLOC(ndr, r->out.info);
10989                 ZERO_STRUCTP(r->out.info);
10990         }
10991         if (flags & NDR_OUT) {
10992                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10993                         NDR_PULL_ALLOC(ndr, r->out.total_size);
10994                 }
10995                 _mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
10996                 NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);
10997                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));
10998                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);
10999                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11000                         NDR_PULL_ALLOC(ndr, r->out.returned_size);
11001                 }
11002                 _mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
11003                 NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);
11004                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));
11005                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);
11006                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11007                         NDR_PULL_ALLOC(ndr, r->out.info);
11008                 }
11009                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
11010                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
11011                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
11012                 NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
11013                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
11014                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11015         }
11016         return NDR_ERR_SUCCESS;
11017 }
11018
11019 _PUBLIC_ void ndr_print_samr_QueryDisplayInfo3(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo3 *r)
11020 {
11021         ndr_print_struct(ndr, name, "samr_QueryDisplayInfo3");
11022         if (r == NULL) { ndr_print_null(ndr); return; }
11023         ndr->depth++;
11024         if (flags & NDR_SET_VALUES) {
11025                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11026         }
11027         if (flags & NDR_IN) {
11028                 ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo3");
11029                 ndr->depth++;
11030                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
11031                 ndr->depth++;
11032                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
11033                 ndr->depth--;
11034                 ndr_print_uint16(ndr, "level", r->in.level);
11035                 ndr_print_uint32(ndr, "start_idx", r->in.start_idx);
11036                 ndr_print_uint32(ndr, "max_entries", r->in.max_entries);
11037                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
11038                 ndr->depth--;
11039         }
11040         if (flags & NDR_OUT) {
11041                 ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo3");
11042                 ndr->depth++;
11043                 ndr_print_ptr(ndr, "total_size", r->out.total_size);
11044                 ndr->depth++;
11045                 ndr_print_uint32(ndr, "total_size", *r->out.total_size);
11046                 ndr->depth--;
11047                 ndr_print_ptr(ndr, "returned_size", r->out.returned_size);
11048                 ndr->depth++;
11049                 ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);
11050                 ndr->depth--;
11051                 ndr_print_ptr(ndr, "info", r->out.info);
11052                 ndr->depth++;
11053                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
11054                 ndr_print_samr_DispInfo(ndr, "info", r->out.info);
11055                 ndr->depth--;
11056                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11057                 ndr->depth--;
11058         }
11059         ndr->depth--;
11060 }
11061
11062 static enum ndr_err_code ndr_push_samr_AddMultipleMembersToAlias(struct ndr_push *ndr, int flags, const struct samr_AddMultipleMembersToAlias *r)
11063 {
11064         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
11065         if (flags & NDR_IN) {
11066                 if (r->in.alias_handle == NULL) {
11067                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11068                 }
11069                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
11070                 if (r->in.sids == NULL) {
11071                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11072                 }
11073                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
11074         }
11075         if (flags & NDR_OUT) {
11076                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11077         }
11078         return NDR_ERR_SUCCESS;
11079 }
11080
11081 static enum ndr_err_code ndr_pull_samr_AddMultipleMembersToAlias(struct ndr_pull *ndr, int flags, struct samr_AddMultipleMembersToAlias *r)
11082 {
11083         TALLOC_CTX *_mem_save_alias_handle_0;
11084         TALLOC_CTX *_mem_save_sids_0;
11085         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
11086         if (flags & NDR_IN) {
11087                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11088                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
11089                 }
11090                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11091                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
11092                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
11093                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
11094                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11095                         NDR_PULL_ALLOC(ndr, r->in.sids);
11096                 }
11097                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
11098                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
11099                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
11100                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
11101         }
11102         if (flags & NDR_OUT) {
11103                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11104         }
11105         return NDR_ERR_SUCCESS;
11106 }
11107
11108 _PUBLIC_ void ndr_print_samr_AddMultipleMembersToAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddMultipleMembersToAlias *r)
11109 {
11110         ndr_print_struct(ndr, name, "samr_AddMultipleMembersToAlias");
11111         if (r == NULL) { ndr_print_null(ndr); return; }
11112         ndr->depth++;
11113         if (flags & NDR_SET_VALUES) {
11114                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11115         }
11116         if (flags & NDR_IN) {
11117                 ndr_print_struct(ndr, "in", "samr_AddMultipleMembersToAlias");
11118                 ndr->depth++;
11119                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
11120                 ndr->depth++;
11121                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
11122                 ndr->depth--;
11123                 ndr_print_ptr(ndr, "sids", r->in.sids);
11124                 ndr->depth++;
11125                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
11126                 ndr->depth--;
11127                 ndr->depth--;
11128         }
11129         if (flags & NDR_OUT) {
11130                 ndr_print_struct(ndr, "out", "samr_AddMultipleMembersToAlias");
11131                 ndr->depth++;
11132                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11133                 ndr->depth--;
11134         }
11135         ndr->depth--;
11136 }
11137
11138 static enum ndr_err_code ndr_push_samr_RemoveMultipleMembersFromAlias(struct ndr_push *ndr, int flags, const struct samr_RemoveMultipleMembersFromAlias *r)
11139 {
11140         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
11141         if (flags & NDR_IN) {
11142                 if (r->in.alias_handle == NULL) {
11143                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11144                 }
11145                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
11146                 if (r->in.sids == NULL) {
11147                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11148                 }
11149                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
11150         }
11151         if (flags & NDR_OUT) {
11152                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11153         }
11154         return NDR_ERR_SUCCESS;
11155 }
11156
11157 static enum ndr_err_code ndr_pull_samr_RemoveMultipleMembersFromAlias(struct ndr_pull *ndr, int flags, struct samr_RemoveMultipleMembersFromAlias *r)
11158 {
11159         TALLOC_CTX *_mem_save_alias_handle_0;
11160         TALLOC_CTX *_mem_save_sids_0;
11161         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
11162         if (flags & NDR_IN) {
11163                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11164                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
11165                 }
11166                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11167                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
11168                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
11169                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
11170                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11171                         NDR_PULL_ALLOC(ndr, r->in.sids);
11172                 }
11173                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
11174                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
11175                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
11176                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
11177         }
11178         if (flags & NDR_OUT) {
11179                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11180         }
11181         return NDR_ERR_SUCCESS;
11182 }
11183
11184 _PUBLIC_ void ndr_print_samr_RemoveMultipleMembersFromAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_RemoveMultipleMembersFromAlias *r)
11185 {
11186         ndr_print_struct(ndr, name, "samr_RemoveMultipleMembersFromAlias");
11187         if (r == NULL) { ndr_print_null(ndr); return; }
11188         ndr->depth++;
11189         if (flags & NDR_SET_VALUES) {
11190                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11191         }
11192         if (flags & NDR_IN) {
11193                 ndr_print_struct(ndr, "in", "samr_RemoveMultipleMembersFromAlias");
11194                 ndr->depth++;
11195                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
11196                 ndr->depth++;
11197                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
11198                 ndr->depth--;
11199                 ndr_print_ptr(ndr, "sids", r->in.sids);
11200                 ndr->depth++;
11201                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
11202                 ndr->depth--;
11203                 ndr->depth--;
11204         }
11205         if (flags & NDR_OUT) {
11206                 ndr_print_struct(ndr, "out", "samr_RemoveMultipleMembersFromAlias");
11207                 ndr->depth++;
11208                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11209                 ndr->depth--;
11210         }
11211         ndr->depth--;
11212 }
11213
11214 static enum ndr_err_code ndr_push_samr_OemChangePasswordUser2(struct ndr_push *ndr, int flags, const struct samr_OemChangePasswordUser2 *r)
11215 {
11216         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
11217         if (flags & NDR_IN) {
11218                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
11219                 if (r->in.server) {
11220                         NDR_CHECK(ndr_push_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
11221                 }
11222                 if (r->in.account == NULL) {
11223                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11224                 }
11225                 NDR_CHECK(ndr_push_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
11226                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
11227                 if (r->in.password) {
11228                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password));
11229                 }
11230                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hash));
11231                 if (r->in.hash) {
11232                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.hash));
11233                 }
11234         }
11235         if (flags & NDR_OUT) {
11236                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11237         }
11238         return NDR_ERR_SUCCESS;
11239 }
11240
11241 static enum ndr_err_code ndr_pull_samr_OemChangePasswordUser2(struct ndr_pull *ndr, int flags, struct samr_OemChangePasswordUser2 *r)
11242 {
11243         uint32_t _ptr_server;
11244         uint32_t _ptr_password;
11245         uint32_t _ptr_hash;
11246         TALLOC_CTX *_mem_save_server_0;
11247         TALLOC_CTX *_mem_save_account_0;
11248         TALLOC_CTX *_mem_save_password_0;
11249         TALLOC_CTX *_mem_save_hash_0;
11250         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
11251         if (flags & NDR_IN) {
11252                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
11253                 if (_ptr_server) {
11254                         NDR_PULL_ALLOC(ndr, r->in.server);
11255                 } else {
11256                         r->in.server = NULL;
11257                 }
11258                 if (r->in.server) {
11259                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
11260                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
11261                         NDR_CHECK(ndr_pull_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
11262                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
11263                 }
11264                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11265                         NDR_PULL_ALLOC(ndr, r->in.account);
11266                 }
11267                 _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
11268                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);
11269                 NDR_CHECK(ndr_pull_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
11270                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);
11271                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
11272                 if (_ptr_password) {
11273                         NDR_PULL_ALLOC(ndr, r->in.password);
11274                 } else {
11275                         r->in.password = NULL;
11276                 }
11277                 if (r->in.password) {
11278                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
11279                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
11280                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password));
11281                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
11282                 }
11283                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hash));
11284                 if (_ptr_hash) {
11285                         NDR_PULL_ALLOC(ndr, r->in.hash);
11286                 } else {
11287                         r->in.hash = NULL;
11288                 }
11289                 if (r->in.hash) {
11290                         _mem_save_hash_0 = NDR_PULL_GET_MEM_CTX(ndr);
11291                         NDR_PULL_SET_MEM_CTX(ndr, r->in.hash, 0);
11292                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.hash));
11293                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hash_0, 0);
11294                 }
11295         }
11296         if (flags & NDR_OUT) {
11297                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11298         }
11299         return NDR_ERR_SUCCESS;
11300 }
11301
11302 _PUBLIC_ void ndr_print_samr_OemChangePasswordUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_OemChangePasswordUser2 *r)
11303 {
11304         ndr_print_struct(ndr, name, "samr_OemChangePasswordUser2");
11305         if (r == NULL) { ndr_print_null(ndr); return; }
11306         ndr->depth++;
11307         if (flags & NDR_SET_VALUES) {
11308                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11309         }
11310         if (flags & NDR_IN) {
11311                 ndr_print_struct(ndr, "in", "samr_OemChangePasswordUser2");
11312                 ndr->depth++;
11313                 ndr_print_ptr(ndr, "server", r->in.server);
11314                 ndr->depth++;
11315                 if (r->in.server) {
11316                         ndr_print_lsa_AsciiString(ndr, "server", r->in.server);
11317                 }
11318                 ndr->depth--;
11319                 ndr_print_ptr(ndr, "account", r->in.account);
11320                 ndr->depth++;
11321                 ndr_print_lsa_AsciiString(ndr, "account", r->in.account);
11322                 ndr->depth--;
11323                 ndr_print_ptr(ndr, "password", r->in.password);
11324                 ndr->depth++;
11325                 if (r->in.password) {
11326                         ndr_print_samr_CryptPassword(ndr, "password", r->in.password);
11327                 }
11328                 ndr->depth--;
11329                 ndr_print_ptr(ndr, "hash", r->in.hash);
11330                 ndr->depth++;
11331                 if (r->in.hash) {
11332                         ndr_print_samr_Password(ndr, "hash", r->in.hash);
11333                 }
11334                 ndr->depth--;
11335                 ndr->depth--;
11336         }
11337         if (flags & NDR_OUT) {
11338                 ndr_print_struct(ndr, "out", "samr_OemChangePasswordUser2");
11339                 ndr->depth++;
11340                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11341                 ndr->depth--;
11342         }
11343         ndr->depth--;
11344 }
11345
11346 static enum ndr_err_code ndr_push_samr_ChangePasswordUser2(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser2 *r)
11347 {
11348         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
11349         if (flags & NDR_IN) {
11350                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
11351                 if (r->in.server) {
11352                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
11353                 }
11354                 if (r->in.account == NULL) {
11355                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11356                 }
11357                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
11358                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_password));
11359                 if (r->in.nt_password) {
11360                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
11361                 }
11362                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_verifier));
11363                 if (r->in.nt_verifier) {
11364                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
11365                 }
11366                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_change));
11367                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_password));
11368                 if (r->in.lm_password) {
11369                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
11370                 }
11371                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_verifier));
11372                 if (r->in.lm_verifier) {
11373                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
11374                 }
11375         }
11376         if (flags & NDR_OUT) {
11377                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11378         }
11379         return NDR_ERR_SUCCESS;
11380 }
11381
11382 static enum ndr_err_code ndr_pull_samr_ChangePasswordUser2(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser2 *r)
11383 {
11384         uint32_t _ptr_server;
11385         uint32_t _ptr_nt_password;
11386         uint32_t _ptr_nt_verifier;
11387         uint32_t _ptr_lm_password;
11388         uint32_t _ptr_lm_verifier;
11389         TALLOC_CTX *_mem_save_server_0;
11390         TALLOC_CTX *_mem_save_account_0;
11391         TALLOC_CTX *_mem_save_nt_password_0;
11392         TALLOC_CTX *_mem_save_nt_verifier_0;
11393         TALLOC_CTX *_mem_save_lm_password_0;
11394         TALLOC_CTX *_mem_save_lm_verifier_0;
11395         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
11396         if (flags & NDR_IN) {
11397                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
11398                 if (_ptr_server) {
11399                         NDR_PULL_ALLOC(ndr, r->in.server);
11400                 } else {
11401                         r->in.server = NULL;
11402                 }
11403                 if (r->in.server) {
11404                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
11405                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
11406                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
11407                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
11408                 }
11409                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11410                         NDR_PULL_ALLOC(ndr, r->in.account);
11411                 }
11412                 _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
11413                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);
11414                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
11415                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);
11416                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_password));
11417                 if (_ptr_nt_password) {
11418                         NDR_PULL_ALLOC(ndr, r->in.nt_password);
11419                 } else {
11420                         r->in.nt_password = NULL;
11421                 }
11422                 if (r->in.nt_password) {
11423                         _mem_save_nt_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
11424                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_password, 0);
11425                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
11426                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_password_0, 0);
11427                 }
11428                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_verifier));
11429                 if (_ptr_nt_verifier) {
11430                         NDR_PULL_ALLOC(ndr, r->in.nt_verifier);
11431                 } else {
11432                         r->in.nt_verifier = NULL;
11433                 }
11434                 if (r->in.nt_verifier) {
11435                         _mem_save_nt_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
11436                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_verifier, 0);
11437                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
11438                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_verifier_0, 0);
11439                 }
11440                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_change));
11441                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_password));
11442                 if (_ptr_lm_password) {
11443                         NDR_PULL_ALLOC(ndr, r->in.lm_password);
11444                 } else {
11445                         r->in.lm_password = NULL;
11446                 }
11447                 if (r->in.lm_password) {
11448                         _mem_save_lm_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
11449                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_password, 0);
11450                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
11451                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_password_0, 0);
11452                 }
11453                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_verifier));
11454                 if (_ptr_lm_verifier) {
11455                         NDR_PULL_ALLOC(ndr, r->in.lm_verifier);
11456                 } else {
11457                         r->in.lm_verifier = NULL;
11458                 }
11459                 if (r->in.lm_verifier) {
11460                         _mem_save_lm_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
11461                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_verifier, 0);
11462                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
11463                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_verifier_0, 0);
11464                 }
11465         }
11466         if (flags & NDR_OUT) {
11467                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11468         }
11469         return NDR_ERR_SUCCESS;
11470 }
11471
11472 _PUBLIC_ void ndr_print_samr_ChangePasswordUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser2 *r)
11473 {
11474         ndr_print_struct(ndr, name, "samr_ChangePasswordUser2");
11475         if (r == NULL) { ndr_print_null(ndr); return; }
11476         ndr->depth++;
11477         if (flags & NDR_SET_VALUES) {
11478                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11479         }
11480         if (flags & NDR_IN) {
11481                 ndr_print_struct(ndr, "in", "samr_ChangePasswordUser2");
11482                 ndr->depth++;
11483                 ndr_print_ptr(ndr, "server", r->in.server);
11484                 ndr->depth++;
11485                 if (r->in.server) {
11486                         ndr_print_lsa_String(ndr, "server", r->in.server);
11487                 }
11488                 ndr->depth--;
11489                 ndr_print_ptr(ndr, "account", r->in.account);
11490                 ndr->depth++;
11491                 ndr_print_lsa_String(ndr, "account", r->in.account);
11492                 ndr->depth--;
11493                 ndr_print_ptr(ndr, "nt_password", r->in.nt_password);
11494                 ndr->depth++;
11495                 if (r->in.nt_password) {
11496                         ndr_print_samr_CryptPassword(ndr, "nt_password", r->in.nt_password);
11497                 }
11498                 ndr->depth--;
11499                 ndr_print_ptr(ndr, "nt_verifier", r->in.nt_verifier);
11500                 ndr->depth++;
11501                 if (r->in.nt_verifier) {
11502                         ndr_print_samr_Password(ndr, "nt_verifier", r->in.nt_verifier);
11503                 }
11504                 ndr->depth--;
11505                 ndr_print_uint8(ndr, "lm_change", r->in.lm_change);
11506                 ndr_print_ptr(ndr, "lm_password", r->in.lm_password);
11507                 ndr->depth++;
11508                 if (r->in.lm_password) {
11509                         ndr_print_samr_CryptPassword(ndr, "lm_password", r->in.lm_password);
11510                 }
11511                 ndr->depth--;
11512                 ndr_print_ptr(ndr, "lm_verifier", r->in.lm_verifier);
11513                 ndr->depth++;
11514                 if (r->in.lm_verifier) {
11515                         ndr_print_samr_Password(ndr, "lm_verifier", r->in.lm_verifier);
11516                 }
11517                 ndr->depth--;
11518                 ndr->depth--;
11519         }
11520         if (flags & NDR_OUT) {
11521                 ndr_print_struct(ndr, "out", "samr_ChangePasswordUser2");
11522                 ndr->depth++;
11523                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11524                 ndr->depth--;
11525         }
11526         ndr->depth--;
11527 }
11528
11529 static enum ndr_err_code ndr_push_samr_GetDomPwInfo(struct ndr_push *ndr, int flags, const struct samr_GetDomPwInfo *r)
11530 {
11531         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
11532         if (flags & NDR_IN) {
11533                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.domain_name));
11534                 if (r->in.domain_name) {
11535                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
11536                 }
11537         }
11538         if (flags & NDR_OUT) {
11539                 if (r->out.info == NULL) {
11540                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11541                 }
11542                 NDR_CHECK(ndr_push_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
11543                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11544         }
11545         return NDR_ERR_SUCCESS;
11546 }
11547
11548 static enum ndr_err_code ndr_pull_samr_GetDomPwInfo(struct ndr_pull *ndr, int flags, struct samr_GetDomPwInfo *r)
11549 {
11550         uint32_t _ptr_domain_name;
11551         TALLOC_CTX *_mem_save_domain_name_0;
11552         TALLOC_CTX *_mem_save_info_0;
11553         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
11554         if (flags & NDR_IN) {
11555                 ZERO_STRUCT(r->out);
11556
11557                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
11558                 if (_ptr_domain_name) {
11559                         NDR_PULL_ALLOC(ndr, r->in.domain_name);
11560                 } else {
11561                         r->in.domain_name = NULL;
11562                 }
11563                 if (r->in.domain_name) {
11564                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11565                         NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_name, 0);
11566                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
11567                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
11568                 }
11569                 NDR_PULL_ALLOC(ndr, r->out.info);
11570                 ZERO_STRUCTP(r->out.info);
11571         }
11572         if (flags & NDR_OUT) {
11573                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11574                         NDR_PULL_ALLOC(ndr, r->out.info);
11575                 }
11576                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
11577                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
11578                 NDR_CHECK(ndr_pull_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
11579                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
11580                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11581         }
11582         return NDR_ERR_SUCCESS;
11583 }
11584
11585 _PUBLIC_ void ndr_print_samr_GetDomPwInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDomPwInfo *r)
11586 {
11587         ndr_print_struct(ndr, name, "samr_GetDomPwInfo");
11588         if (r == NULL) { ndr_print_null(ndr); return; }
11589         ndr->depth++;
11590         if (flags & NDR_SET_VALUES) {
11591                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11592         }
11593         if (flags & NDR_IN) {
11594                 ndr_print_struct(ndr, "in", "samr_GetDomPwInfo");
11595                 ndr->depth++;
11596                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
11597                 ndr->depth++;
11598                 if (r->in.domain_name) {
11599                         ndr_print_lsa_String(ndr, "domain_name", r->in.domain_name);
11600                 }
11601                 ndr->depth--;
11602                 ndr->depth--;
11603         }
11604         if (flags & NDR_OUT) {
11605                 ndr_print_struct(ndr, "out", "samr_GetDomPwInfo");
11606                 ndr->depth++;
11607                 ndr_print_ptr(ndr, "info", r->out.info);
11608                 ndr->depth++;
11609                 ndr_print_samr_PwInfo(ndr, "info", r->out.info);
11610                 ndr->depth--;
11611                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11612                 ndr->depth--;
11613         }
11614         ndr->depth--;
11615 }
11616
11617 static enum ndr_err_code ndr_push_samr_Connect2(struct ndr_push *ndr, int flags, const struct samr_Connect2 *r)
11618 {
11619         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
11620         if (flags & NDR_IN) {
11621                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
11622                 if (r->in.system_name) {
11623                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11624                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11625                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11626                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.system_name, ndr_charset_length(r->in.system_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11627                 }
11628                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
11629         }
11630         if (flags & NDR_OUT) {
11631                 if (r->out.connect_handle == NULL) {
11632                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11633                 }
11634                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11635                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11636         }
11637         return NDR_ERR_SUCCESS;
11638 }
11639
11640 static enum ndr_err_code ndr_pull_samr_Connect2(struct ndr_pull *ndr, int flags, struct samr_Connect2 *r)
11641 {
11642         uint32_t _ptr_system_name;
11643         uint32_t size_system_name_1 = 0;
11644         uint32_t length_system_name_1 = 0;
11645         TALLOC_CTX *_mem_save_system_name_0;
11646         TALLOC_CTX *_mem_save_connect_handle_0;
11647         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
11648         if (flags & NDR_IN) {
11649                 ZERO_STRUCT(r->out);
11650
11651                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
11652                 if (_ptr_system_name) {
11653                         NDR_PULL_ALLOC(ndr, r->in.system_name);
11654                 } else {
11655                         r->in.system_name = NULL;
11656                 }
11657                 if (r->in.system_name) {
11658                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11659                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
11660                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
11661                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
11662                         size_system_name_1 = ndr_get_array_size(ndr, &r->in.system_name);
11663                         length_system_name_1 = ndr_get_array_length(ndr, &r->in.system_name);
11664                         if (length_system_name_1 > size_system_name_1) {
11665                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_system_name_1, length_system_name_1);
11666                         }
11667                         NDR_CHECK(ndr_check_string_terminator(ndr, length_system_name_1, sizeof(uint16_t)));
11668                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, length_system_name_1, sizeof(uint16_t), CH_UTF16));
11669                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
11670                 }
11671                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
11672                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11673                 ZERO_STRUCTP(r->out.connect_handle);
11674         }
11675         if (flags & NDR_OUT) {
11676                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11677                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11678                 }
11679                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11680                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
11681                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11682                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
11683                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11684         }
11685         return NDR_ERR_SUCCESS;
11686 }
11687
11688 _PUBLIC_ void ndr_print_samr_Connect2(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect2 *r)
11689 {
11690         ndr_print_struct(ndr, name, "samr_Connect2");
11691         if (r == NULL) { ndr_print_null(ndr); return; }
11692         ndr->depth++;
11693         if (flags & NDR_SET_VALUES) {
11694                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11695         }
11696         if (flags & NDR_IN) {
11697                 ndr_print_struct(ndr, "in", "samr_Connect2");
11698                 ndr->depth++;
11699                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
11700                 ndr->depth++;
11701                 if (r->in.system_name) {
11702                         ndr_print_string(ndr, "system_name", r->in.system_name);
11703                 }
11704                 ndr->depth--;
11705                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
11706                 ndr->depth--;
11707         }
11708         if (flags & NDR_OUT) {
11709                 ndr_print_struct(ndr, "out", "samr_Connect2");
11710                 ndr->depth++;
11711                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
11712                 ndr->depth++;
11713                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
11714                 ndr->depth--;
11715                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11716                 ndr->depth--;
11717         }
11718         ndr->depth--;
11719 }
11720
11721 _PUBLIC_ enum ndr_err_code ndr_push_samr_SetUserInfo2(struct ndr_push *ndr, int flags, const struct samr_SetUserInfo2 *r)
11722 {
11723         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
11724         if (flags & NDR_IN) {
11725                 if (r->in.user_handle == NULL) {
11726                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11727                 }
11728                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
11729                 NDR_CHECK(ndr_push_samr_UserInfoLevel(ndr, NDR_SCALARS, r->in.level));
11730                 if (r->in.info == NULL) {
11731                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11732                 }
11733                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
11734                 NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
11735         }
11736         if (flags & NDR_OUT) {
11737                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11738         }
11739         return NDR_ERR_SUCCESS;
11740 }
11741
11742 _PUBLIC_ enum ndr_err_code ndr_pull_samr_SetUserInfo2(struct ndr_pull *ndr, int flags, struct samr_SetUserInfo2 *r)
11743 {
11744         TALLOC_CTX *_mem_save_user_handle_0;
11745         TALLOC_CTX *_mem_save_info_0;
11746         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
11747         if (flags & NDR_IN) {
11748                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11749                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
11750                 }
11751                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11752                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
11753                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
11754                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
11755                 NDR_CHECK(ndr_pull_samr_UserInfoLevel(ndr, NDR_SCALARS, &r->in.level));
11756                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11757                         NDR_PULL_ALLOC(ndr, r->in.info);
11758                 }
11759                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
11760                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
11761                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
11762                 NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
11763                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
11764         }
11765         if (flags & NDR_OUT) {
11766                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11767         }
11768         return NDR_ERR_SUCCESS;
11769 }
11770
11771 _PUBLIC_ void ndr_print_samr_SetUserInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetUserInfo2 *r)
11772 {
11773         ndr_print_struct(ndr, name, "samr_SetUserInfo2");
11774         if (r == NULL) { ndr_print_null(ndr); return; }
11775         ndr->depth++;
11776         if (flags & NDR_SET_VALUES) {
11777                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11778         }
11779         if (flags & NDR_IN) {
11780                 ndr_print_struct(ndr, "in", "samr_SetUserInfo2");
11781                 ndr->depth++;
11782                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
11783                 ndr->depth++;
11784                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
11785                 ndr->depth--;
11786                 ndr_print_samr_UserInfoLevel(ndr, "level", r->in.level);
11787                 ndr_print_ptr(ndr, "info", r->in.info);
11788                 ndr->depth++;
11789                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
11790                 ndr_print_samr_UserInfo(ndr, "info", r->in.info);
11791                 ndr->depth--;
11792                 ndr->depth--;
11793         }
11794         if (flags & NDR_OUT) {
11795                 ndr_print_struct(ndr, "out", "samr_SetUserInfo2");
11796                 ndr->depth++;
11797                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11798                 ndr->depth--;
11799         }
11800         ndr->depth--;
11801 }
11802
11803 static enum ndr_err_code ndr_push_samr_SetBootKeyInformation(struct ndr_push *ndr, int flags, const struct samr_SetBootKeyInformation *r)
11804 {
11805         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
11806         if (flags & NDR_IN) {
11807                 if (r->in.connect_handle == NULL) {
11808                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11809                 }
11810                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
11811                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
11812                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
11813                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown3));
11814         }
11815         if (flags & NDR_OUT) {
11816                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11817         }
11818         return NDR_ERR_SUCCESS;
11819 }
11820
11821 static enum ndr_err_code ndr_pull_samr_SetBootKeyInformation(struct ndr_pull *ndr, int flags, struct samr_SetBootKeyInformation *r)
11822 {
11823         TALLOC_CTX *_mem_save_connect_handle_0;
11824         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
11825         if (flags & NDR_IN) {
11826                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11827                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
11828                 }
11829                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11830                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
11831                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
11832                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
11833                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
11834                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
11835                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown3));
11836         }
11837         if (flags & NDR_OUT) {
11838                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11839         }
11840         return NDR_ERR_SUCCESS;
11841 }
11842
11843 _PUBLIC_ void ndr_print_samr_SetBootKeyInformation(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetBootKeyInformation *r)
11844 {
11845         ndr_print_struct(ndr, name, "samr_SetBootKeyInformation");
11846         if (r == NULL) { ndr_print_null(ndr); return; }
11847         ndr->depth++;
11848         if (flags & NDR_SET_VALUES) {
11849                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11850         }
11851         if (flags & NDR_IN) {
11852                 ndr_print_struct(ndr, "in", "samr_SetBootKeyInformation");
11853                 ndr->depth++;
11854                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
11855                 ndr->depth++;
11856                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
11857                 ndr->depth--;
11858                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
11859                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
11860                 ndr_print_uint32(ndr, "unknown3", r->in.unknown3);
11861                 ndr->depth--;
11862         }
11863         if (flags & NDR_OUT) {
11864                 ndr_print_struct(ndr, "out", "samr_SetBootKeyInformation");
11865                 ndr->depth++;
11866                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11867                 ndr->depth--;
11868         }
11869         ndr->depth--;
11870 }
11871
11872 static enum ndr_err_code ndr_push_samr_GetBootKeyInformation(struct ndr_push *ndr, int flags, const struct samr_GetBootKeyInformation *r)
11873 {
11874         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
11875         if (flags & NDR_IN) {
11876                 if (r->in.domain_handle == NULL) {
11877                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11878                 }
11879                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
11880         }
11881         if (flags & NDR_OUT) {
11882                 if (r->out.unknown == NULL) {
11883                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11884                 }
11885                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.unknown));
11886                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11887         }
11888         return NDR_ERR_SUCCESS;
11889 }
11890
11891 static enum ndr_err_code ndr_pull_samr_GetBootKeyInformation(struct ndr_pull *ndr, int flags, struct samr_GetBootKeyInformation *r)
11892 {
11893         TALLOC_CTX *_mem_save_domain_handle_0;
11894         TALLOC_CTX *_mem_save_unknown_0;
11895         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
11896         if (flags & NDR_IN) {
11897                 ZERO_STRUCT(r->out);
11898
11899                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11900                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
11901                 }
11902                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11903                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
11904                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
11905                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
11906                 NDR_PULL_ALLOC(ndr, r->out.unknown);
11907                 ZERO_STRUCTP(r->out.unknown);
11908         }
11909         if (flags & NDR_OUT) {
11910                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11911                         NDR_PULL_ALLOC(ndr, r->out.unknown);
11912                 }
11913                 _mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);
11914                 NDR_PULL_SET_MEM_CTX(ndr, r->out.unknown, LIBNDR_FLAG_REF_ALLOC);
11915                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.unknown));
11916                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, LIBNDR_FLAG_REF_ALLOC);
11917                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11918         }
11919         return NDR_ERR_SUCCESS;
11920 }
11921
11922 _PUBLIC_ void ndr_print_samr_GetBootKeyInformation(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetBootKeyInformation *r)
11923 {
11924         ndr_print_struct(ndr, name, "samr_GetBootKeyInformation");
11925         if (r == NULL) { ndr_print_null(ndr); return; }
11926         ndr->depth++;
11927         if (flags & NDR_SET_VALUES) {
11928                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11929         }
11930         if (flags & NDR_IN) {
11931                 ndr_print_struct(ndr, "in", "samr_GetBootKeyInformation");
11932                 ndr->depth++;
11933                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
11934                 ndr->depth++;
11935                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
11936                 ndr->depth--;
11937                 ndr->depth--;
11938         }
11939         if (flags & NDR_OUT) {
11940                 ndr_print_struct(ndr, "out", "samr_GetBootKeyInformation");
11941                 ndr->depth++;
11942                 ndr_print_ptr(ndr, "unknown", r->out.unknown);
11943                 ndr->depth++;
11944                 ndr_print_uint32(ndr, "unknown", *r->out.unknown);
11945                 ndr->depth--;
11946                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11947                 ndr->depth--;
11948         }
11949         ndr->depth--;
11950 }
11951
11952 static enum ndr_err_code ndr_push_samr_Connect3(struct ndr_push *ndr, int flags, const struct samr_Connect3 *r)
11953 {
11954         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
11955         if (flags & NDR_IN) {
11956                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
11957                 if (r->in.system_name) {
11958                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11959                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11960                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11961                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.system_name, ndr_charset_length(r->in.system_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11962                 }
11963                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
11964                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
11965         }
11966         if (flags & NDR_OUT) {
11967                 if (r->out.connect_handle == NULL) {
11968                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11969                 }
11970                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11971                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11972         }
11973         return NDR_ERR_SUCCESS;
11974 }
11975
11976 static enum ndr_err_code ndr_pull_samr_Connect3(struct ndr_pull *ndr, int flags, struct samr_Connect3 *r)
11977 {
11978         uint32_t _ptr_system_name;
11979         uint32_t size_system_name_1 = 0;
11980         uint32_t length_system_name_1 = 0;
11981         TALLOC_CTX *_mem_save_system_name_0;
11982         TALLOC_CTX *_mem_save_connect_handle_0;
11983         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
11984         if (flags & NDR_IN) {
11985                 ZERO_STRUCT(r->out);
11986
11987                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
11988                 if (_ptr_system_name) {
11989                         NDR_PULL_ALLOC(ndr, r->in.system_name);
11990                 } else {
11991                         r->in.system_name = NULL;
11992                 }
11993                 if (r->in.system_name) {
11994                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11995                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
11996                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
11997                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
11998                         size_system_name_1 = ndr_get_array_size(ndr, &r->in.system_name);
11999                         length_system_name_1 = ndr_get_array_length(ndr, &r->in.system_name);
12000                         if (length_system_name_1 > size_system_name_1) {
12001                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_system_name_1, length_system_name_1);
12002                         }
12003                         NDR_CHECK(ndr_check_string_terminator(ndr, length_system_name_1, sizeof(uint16_t)));
12004                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, length_system_name_1, sizeof(uint16_t), CH_UTF16));
12005                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
12006                 }
12007                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
12008                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
12009                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
12010                 ZERO_STRUCTP(r->out.connect_handle);
12011         }
12012         if (flags & NDR_OUT) {
12013                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12014                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
12015                 }
12016                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12017                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
12018                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
12019                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
12020                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12021         }
12022         return NDR_ERR_SUCCESS;
12023 }
12024
12025 _PUBLIC_ void ndr_print_samr_Connect3(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect3 *r)
12026 {
12027         ndr_print_struct(ndr, name, "samr_Connect3");
12028         if (r == NULL) { ndr_print_null(ndr); return; }
12029         ndr->depth++;
12030         if (flags & NDR_SET_VALUES) {
12031                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12032         }
12033         if (flags & NDR_IN) {
12034                 ndr_print_struct(ndr, "in", "samr_Connect3");
12035                 ndr->depth++;
12036                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
12037                 ndr->depth++;
12038                 if (r->in.system_name) {
12039                         ndr_print_string(ndr, "system_name", r->in.system_name);
12040                 }
12041                 ndr->depth--;
12042                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
12043                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
12044                 ndr->depth--;
12045         }
12046         if (flags & NDR_OUT) {
12047                 ndr_print_struct(ndr, "out", "samr_Connect3");
12048                 ndr->depth++;
12049                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
12050                 ndr->depth++;
12051                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
12052                 ndr->depth--;
12053                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12054                 ndr->depth--;
12055         }
12056         ndr->depth--;
12057 }
12058
12059 static enum ndr_err_code ndr_push_samr_Connect4(struct ndr_push *ndr, int flags, const struct samr_Connect4 *r)
12060 {
12061         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
12062         if (flags & NDR_IN) {
12063                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
12064                 if (r->in.system_name) {
12065                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
12066                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
12067                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
12068                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.system_name, ndr_charset_length(r->in.system_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12069                 }
12070                 NDR_CHECK(ndr_push_samr_ConnectVersion(ndr, NDR_SCALARS, r->in.client_version));
12071                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
12072         }
12073         if (flags & NDR_OUT) {
12074                 if (r->out.connect_handle == NULL) {
12075                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12076                 }
12077                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
12078                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12079         }
12080         return NDR_ERR_SUCCESS;
12081 }
12082
12083 static enum ndr_err_code ndr_pull_samr_Connect4(struct ndr_pull *ndr, int flags, struct samr_Connect4 *r)
12084 {
12085         uint32_t _ptr_system_name;
12086         uint32_t size_system_name_1 = 0;
12087         uint32_t length_system_name_1 = 0;
12088         TALLOC_CTX *_mem_save_system_name_0;
12089         TALLOC_CTX *_mem_save_connect_handle_0;
12090         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
12091         if (flags & NDR_IN) {
12092                 ZERO_STRUCT(r->out);
12093
12094                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
12095                 if (_ptr_system_name) {
12096                         NDR_PULL_ALLOC(ndr, r->in.system_name);
12097                 } else {
12098                         r->in.system_name = NULL;
12099                 }
12100                 if (r->in.system_name) {
12101                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12102                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
12103                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
12104                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
12105                         size_system_name_1 = ndr_get_array_size(ndr, &r->in.system_name);
12106                         length_system_name_1 = ndr_get_array_length(ndr, &r->in.system_name);
12107                         if (length_system_name_1 > size_system_name_1) {
12108                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_system_name_1, length_system_name_1);
12109                         }
12110                         NDR_CHECK(ndr_check_string_terminator(ndr, length_system_name_1, sizeof(uint16_t)));
12111                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, length_system_name_1, sizeof(uint16_t), CH_UTF16));
12112                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
12113                 }
12114                 NDR_CHECK(ndr_pull_samr_ConnectVersion(ndr, NDR_SCALARS, &r->in.client_version));
12115                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
12116                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
12117                 ZERO_STRUCTP(r->out.connect_handle);
12118         }
12119         if (flags & NDR_OUT) {
12120                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12121                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
12122                 }
12123                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12124                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
12125                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
12126                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
12127                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12128         }
12129         return NDR_ERR_SUCCESS;
12130 }
12131
12132 _PUBLIC_ void ndr_print_samr_Connect4(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect4 *r)
12133 {
12134         ndr_print_struct(ndr, name, "samr_Connect4");
12135         if (r == NULL) { ndr_print_null(ndr); return; }
12136         ndr->depth++;
12137         if (flags & NDR_SET_VALUES) {
12138                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12139         }
12140         if (flags & NDR_IN) {
12141                 ndr_print_struct(ndr, "in", "samr_Connect4");
12142                 ndr->depth++;
12143                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
12144                 ndr->depth++;
12145                 if (r->in.system_name) {
12146                         ndr_print_string(ndr, "system_name", r->in.system_name);
12147                 }
12148                 ndr->depth--;
12149                 ndr_print_samr_ConnectVersion(ndr, "client_version", r->in.client_version);
12150                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
12151                 ndr->depth--;
12152         }
12153         if (flags & NDR_OUT) {
12154                 ndr_print_struct(ndr, "out", "samr_Connect4");
12155                 ndr->depth++;
12156                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
12157                 ndr->depth++;
12158                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
12159                 ndr->depth--;
12160                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12161                 ndr->depth--;
12162         }
12163         ndr->depth--;
12164 }
12165
12166 _PUBLIC_ enum ndr_err_code ndr_push_samr_ChangePasswordUser3(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser3 *r)
12167 {
12168         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
12169         if (flags & NDR_IN) {
12170                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
12171                 if (r->in.server) {
12172                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
12173                 }
12174                 if (r->in.account == NULL) {
12175                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12176                 }
12177                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
12178                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_password));
12179                 if (r->in.nt_password) {
12180                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
12181                 }
12182                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_verifier));
12183                 if (r->in.nt_verifier) {
12184                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
12185                 }
12186                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_change));
12187                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_password));
12188                 if (r->in.lm_password) {
12189                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
12190                 }
12191                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_verifier));
12192                 if (r->in.lm_verifier) {
12193                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
12194                 }
12195                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password3));
12196                 if (r->in.password3) {
12197                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password3));
12198                 }
12199         }
12200         if (flags & NDR_OUT) {
12201                 if (r->out.dominfo == NULL) {
12202                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12203                 }
12204                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.dominfo));
12205                 if (*r->out.dominfo) {
12206                         NDR_CHECK(ndr_push_samr_DomInfo1(ndr, NDR_SCALARS, *r->out.dominfo));
12207                 }
12208                 if (r->out.reject == NULL) {
12209                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12210                 }
12211                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.reject));
12212                 if (*r->out.reject) {
12213                         NDR_CHECK(ndr_push_userPwdChangeFailureInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.reject));
12214                 }
12215                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12216         }
12217         return NDR_ERR_SUCCESS;
12218 }
12219
12220 _PUBLIC_ enum ndr_err_code ndr_pull_samr_ChangePasswordUser3(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser3 *r)
12221 {
12222         uint32_t _ptr_server;
12223         uint32_t _ptr_nt_password;
12224         uint32_t _ptr_nt_verifier;
12225         uint32_t _ptr_lm_password;
12226         uint32_t _ptr_lm_verifier;
12227         uint32_t _ptr_password3;
12228         uint32_t _ptr_dominfo;
12229         uint32_t _ptr_reject;
12230         TALLOC_CTX *_mem_save_server_0;
12231         TALLOC_CTX *_mem_save_account_0;
12232         TALLOC_CTX *_mem_save_nt_password_0;
12233         TALLOC_CTX *_mem_save_nt_verifier_0;
12234         TALLOC_CTX *_mem_save_lm_password_0;
12235         TALLOC_CTX *_mem_save_lm_verifier_0;
12236         TALLOC_CTX *_mem_save_password3_0;
12237         TALLOC_CTX *_mem_save_dominfo_0;
12238         TALLOC_CTX *_mem_save_dominfo_1;
12239         TALLOC_CTX *_mem_save_reject_0;
12240         TALLOC_CTX *_mem_save_reject_1;
12241         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
12242         if (flags & NDR_IN) {
12243                 ZERO_STRUCT(r->out);
12244
12245                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
12246                 if (_ptr_server) {
12247                         NDR_PULL_ALLOC(ndr, r->in.server);
12248                 } else {
12249                         r->in.server = NULL;
12250                 }
12251                 if (r->in.server) {
12252                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
12253                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
12254                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
12255                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
12256                 }
12257                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12258                         NDR_PULL_ALLOC(ndr, r->in.account);
12259                 }
12260                 _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
12261                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);
12262                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
12263                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);
12264                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_password));
12265                 if (_ptr_nt_password) {
12266                         NDR_PULL_ALLOC(ndr, r->in.nt_password);
12267                 } else {
12268                         r->in.nt_password = NULL;
12269                 }
12270                 if (r->in.nt_password) {
12271                         _mem_save_nt_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
12272                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_password, 0);
12273                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
12274                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_password_0, 0);
12275                 }
12276                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_verifier));
12277                 if (_ptr_nt_verifier) {
12278                         NDR_PULL_ALLOC(ndr, r->in.nt_verifier);
12279                 } else {
12280                         r->in.nt_verifier = NULL;
12281                 }
12282                 if (r->in.nt_verifier) {
12283                         _mem_save_nt_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
12284                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_verifier, 0);
12285                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
12286                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_verifier_0, 0);
12287                 }
12288                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_change));
12289                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_password));
12290                 if (_ptr_lm_password) {
12291                         NDR_PULL_ALLOC(ndr, r->in.lm_password);
12292                 } else {
12293                         r->in.lm_password = NULL;
12294                 }
12295                 if (r->in.lm_password) {
12296                         _mem_save_lm_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
12297                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_password, 0);
12298                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
12299                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_password_0, 0);
12300                 }
12301                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_verifier));
12302                 if (_ptr_lm_verifier) {
12303                         NDR_PULL_ALLOC(ndr, r->in.lm_verifier);
12304                 } else {
12305                         r->in.lm_verifier = NULL;
12306                 }
12307                 if (r->in.lm_verifier) {
12308                         _mem_save_lm_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
12309                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_verifier, 0);
12310                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
12311                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_verifier_0, 0);
12312                 }
12313                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password3));
12314                 if (_ptr_password3) {
12315                         NDR_PULL_ALLOC(ndr, r->in.password3);
12316                 } else {
12317                         r->in.password3 = NULL;
12318                 }
12319                 if (r->in.password3) {
12320                         _mem_save_password3_0 = NDR_PULL_GET_MEM_CTX(ndr);
12321                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password3, 0);
12322                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password3));
12323                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password3_0, 0);
12324                 }
12325                 NDR_PULL_ALLOC(ndr, r->out.dominfo);
12326                 ZERO_STRUCTP(r->out.dominfo);
12327                 NDR_PULL_ALLOC(ndr, r->out.reject);
12328                 ZERO_STRUCTP(r->out.reject);
12329         }
12330         if (flags & NDR_OUT) {
12331                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12332                         NDR_PULL_ALLOC(ndr, r->out.dominfo);
12333                 }
12334                 _mem_save_dominfo_0 = NDR_PULL_GET_MEM_CTX(ndr);
12335                 NDR_PULL_SET_MEM_CTX(ndr, r->out.dominfo, LIBNDR_FLAG_REF_ALLOC);
12336                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dominfo));
12337                 if (_ptr_dominfo) {
12338                         NDR_PULL_ALLOC(ndr, *r->out.dominfo);
12339                 } else {
12340                         *r->out.dominfo = NULL;
12341                 }
12342                 if (*r->out.dominfo) {
12343                         _mem_save_dominfo_1 = NDR_PULL_GET_MEM_CTX(ndr);
12344                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.dominfo, 0);
12345                         NDR_CHECK(ndr_pull_samr_DomInfo1(ndr, NDR_SCALARS, *r->out.dominfo));
12346                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dominfo_1, 0);
12347                 }
12348                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dominfo_0, LIBNDR_FLAG_REF_ALLOC);
12349                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12350                         NDR_PULL_ALLOC(ndr, r->out.reject);
12351                 }
12352                 _mem_save_reject_0 = NDR_PULL_GET_MEM_CTX(ndr);
12353                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reject, LIBNDR_FLAG_REF_ALLOC);
12354                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_reject));
12355                 if (_ptr_reject) {
12356                         NDR_PULL_ALLOC(ndr, *r->out.reject);
12357                 } else {
12358                         *r->out.reject = NULL;
12359                 }
12360                 if (*r->out.reject) {
12361                         _mem_save_reject_1 = NDR_PULL_GET_MEM_CTX(ndr);
12362                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.reject, 0);
12363                         NDR_CHECK(ndr_pull_userPwdChangeFailureInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.reject));
12364                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reject_1, 0);
12365                 }
12366                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reject_0, LIBNDR_FLAG_REF_ALLOC);
12367                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12368         }
12369         return NDR_ERR_SUCCESS;
12370 }
12371
12372 _PUBLIC_ void ndr_print_samr_ChangePasswordUser3(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser3 *r)
12373 {
12374         ndr_print_struct(ndr, name, "samr_ChangePasswordUser3");
12375         if (r == NULL) { ndr_print_null(ndr); return; }
12376         ndr->depth++;
12377         if (flags & NDR_SET_VALUES) {
12378                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12379         }
12380         if (flags & NDR_IN) {
12381                 ndr_print_struct(ndr, "in", "samr_ChangePasswordUser3");
12382                 ndr->depth++;
12383                 ndr_print_ptr(ndr, "server", r->in.server);
12384                 ndr->depth++;
12385                 if (r->in.server) {
12386                         ndr_print_lsa_String(ndr, "server", r->in.server);
12387                 }
12388                 ndr->depth--;
12389                 ndr_print_ptr(ndr, "account", r->in.account);
12390                 ndr->depth++;
12391                 ndr_print_lsa_String(ndr, "account", r->in.account);
12392                 ndr->depth--;
12393                 ndr_print_ptr(ndr, "nt_password", r->in.nt_password);
12394                 ndr->depth++;
12395                 if (r->in.nt_password) {
12396                         ndr_print_samr_CryptPassword(ndr, "nt_password", r->in.nt_password);
12397                 }
12398                 ndr->depth--;
12399                 ndr_print_ptr(ndr, "nt_verifier", r->in.nt_verifier);
12400                 ndr->depth++;
12401                 if (r->in.nt_verifier) {
12402                         ndr_print_samr_Password(ndr, "nt_verifier", r->in.nt_verifier);
12403                 }
12404                 ndr->depth--;
12405                 ndr_print_uint8(ndr, "lm_change", r->in.lm_change);
12406                 ndr_print_ptr(ndr, "lm_password", r->in.lm_password);
12407                 ndr->depth++;
12408                 if (r->in.lm_password) {
12409                         ndr_print_samr_CryptPassword(ndr, "lm_password", r->in.lm_password);
12410                 }
12411                 ndr->depth--;
12412                 ndr_print_ptr(ndr, "lm_verifier", r->in.lm_verifier);
12413                 ndr->depth++;
12414                 if (r->in.lm_verifier) {
12415                         ndr_print_samr_Password(ndr, "lm_verifier", r->in.lm_verifier);
12416                 }
12417                 ndr->depth--;
12418                 ndr_print_ptr(ndr, "password3", r->in.password3);
12419                 ndr->depth++;
12420                 if (r->in.password3) {
12421                         ndr_print_samr_CryptPassword(ndr, "password3", r->in.password3);
12422                 }
12423                 ndr->depth--;
12424                 ndr->depth--;
12425         }
12426         if (flags & NDR_OUT) {
12427                 ndr_print_struct(ndr, "out", "samr_ChangePasswordUser3");
12428                 ndr->depth++;
12429                 ndr_print_ptr(ndr, "dominfo", r->out.dominfo);
12430                 ndr->depth++;
12431                 ndr_print_ptr(ndr, "dominfo", *r->out.dominfo);
12432                 ndr->depth++;
12433                 if (*r->out.dominfo) {
12434                         ndr_print_samr_DomInfo1(ndr, "dominfo", *r->out.dominfo);
12435                 }
12436                 ndr->depth--;
12437                 ndr->depth--;
12438                 ndr_print_ptr(ndr, "reject", r->out.reject);
12439                 ndr->depth++;
12440                 ndr_print_ptr(ndr, "reject", *r->out.reject);
12441                 ndr->depth++;
12442                 if (*r->out.reject) {
12443                         ndr_print_userPwdChangeFailureInformation(ndr, "reject", *r->out.reject);
12444                 }
12445                 ndr->depth--;
12446                 ndr->depth--;
12447                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12448                 ndr->depth--;
12449         }
12450         ndr->depth--;
12451 }
12452
12453 _PUBLIC_ enum ndr_err_code ndr_push_samr_Connect5(struct ndr_push *ndr, int flags, const struct samr_Connect5 *r)
12454 {
12455         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
12456         if (flags & NDR_IN) {
12457                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
12458                 if (r->in.system_name) {
12459                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
12460                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
12461                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
12462                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.system_name, ndr_charset_length(r->in.system_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12463                 }
12464                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
12465                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level_in));
12466                 if (r->in.info_in == NULL) {
12467                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12468                 }
12469                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info_in, r->in.level_in));
12470                 NDR_CHECK(ndr_push_samr_ConnectInfo(ndr, NDR_SCALARS, r->in.info_in));
12471         }
12472         if (flags & NDR_OUT) {
12473                 if (r->out.level_out == NULL) {
12474                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12475                 }
12476                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
12477                 if (r->out.info_out == NULL) {
12478                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12479                 }
12480                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info_out, *r->out.level_out));
12481                 NDR_CHECK(ndr_push_samr_ConnectInfo(ndr, NDR_SCALARS, r->out.info_out));
12482                 if (r->out.connect_handle == NULL) {
12483                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12484                 }
12485                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
12486                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12487         }
12488         return NDR_ERR_SUCCESS;
12489 }
12490
12491 _PUBLIC_ enum ndr_err_code ndr_pull_samr_Connect5(struct ndr_pull *ndr, int flags, struct samr_Connect5 *r)
12492 {
12493         uint32_t _ptr_system_name;
12494         uint32_t size_system_name_1 = 0;
12495         uint32_t length_system_name_1 = 0;
12496         TALLOC_CTX *_mem_save_system_name_0;
12497         TALLOC_CTX *_mem_save_info_in_0;
12498         TALLOC_CTX *_mem_save_level_out_0;
12499         TALLOC_CTX *_mem_save_info_out_0;
12500         TALLOC_CTX *_mem_save_connect_handle_0;
12501         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
12502         if (flags & NDR_IN) {
12503                 ZERO_STRUCT(r->out);
12504
12505                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
12506                 if (_ptr_system_name) {
12507                         NDR_PULL_ALLOC(ndr, r->in.system_name);
12508                 } else {
12509                         r->in.system_name = NULL;
12510                 }
12511                 if (r->in.system_name) {
12512                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12513                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
12514                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
12515                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
12516                         size_system_name_1 = ndr_get_array_size(ndr, &r->in.system_name);
12517                         length_system_name_1 = ndr_get_array_length(ndr, &r->in.system_name);
12518                         if (length_system_name_1 > size_system_name_1) {
12519                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_system_name_1, length_system_name_1);
12520                         }
12521                         NDR_CHECK(ndr_check_string_terminator(ndr, length_system_name_1, sizeof(uint16_t)));
12522                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, length_system_name_1, sizeof(uint16_t), CH_UTF16));
12523                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
12524                 }
12525                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
12526                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level_in));
12527                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12528                         NDR_PULL_ALLOC(ndr, r->in.info_in);
12529                 }
12530                 _mem_save_info_in_0 = NDR_PULL_GET_MEM_CTX(ndr);
12531                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_in, LIBNDR_FLAG_REF_ALLOC);
12532                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info_in, r->in.level_in));
12533                 NDR_CHECK(ndr_pull_samr_ConnectInfo(ndr, NDR_SCALARS, r->in.info_in));
12534                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_in_0, LIBNDR_FLAG_REF_ALLOC);
12535                 NDR_PULL_ALLOC(ndr, r->out.level_out);
12536                 ZERO_STRUCTP(r->out.level_out);
12537                 NDR_PULL_ALLOC(ndr, r->out.info_out);
12538                 ZERO_STRUCTP(r->out.info_out);
12539                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
12540                 ZERO_STRUCTP(r->out.connect_handle);
12541         }
12542         if (flags & NDR_OUT) {
12543                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12544                         NDR_PULL_ALLOC(ndr, r->out.level_out);
12545                 }
12546                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
12547                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
12548                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
12549                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
12550                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12551                         NDR_PULL_ALLOC(ndr, r->out.info_out);
12552                 }
12553                 _mem_save_info_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
12554                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_out, LIBNDR_FLAG_REF_ALLOC);
12555                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info_out, *r->out.level_out));
12556                 NDR_CHECK(ndr_pull_samr_ConnectInfo(ndr, NDR_SCALARS, r->out.info_out));
12557                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_out_0, LIBNDR_FLAG_REF_ALLOC);
12558                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12559                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
12560                 }
12561                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12562                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
12563                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
12564                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
12565                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12566         }
12567         return NDR_ERR_SUCCESS;
12568 }
12569
12570 _PUBLIC_ void ndr_print_samr_Connect5(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect5 *r)
12571 {
12572         ndr_print_struct(ndr, name, "samr_Connect5");
12573         if (r == NULL) { ndr_print_null(ndr); return; }
12574         ndr->depth++;
12575         if (flags & NDR_SET_VALUES) {
12576                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12577         }
12578         if (flags & NDR_IN) {
12579                 ndr_print_struct(ndr, "in", "samr_Connect5");
12580                 ndr->depth++;
12581                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
12582                 ndr->depth++;
12583                 if (r->in.system_name) {
12584                         ndr_print_string(ndr, "system_name", r->in.system_name);
12585                 }
12586                 ndr->depth--;
12587                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
12588                 ndr_print_uint32(ndr, "level_in", r->in.level_in);
12589                 ndr_print_ptr(ndr, "info_in", r->in.info_in);
12590                 ndr->depth++;
12591                 ndr_print_set_switch_value(ndr, r->in.info_in, r->in.level_in);
12592                 ndr_print_samr_ConnectInfo(ndr, "info_in", r->in.info_in);
12593                 ndr->depth--;
12594                 ndr->depth--;
12595         }
12596         if (flags & NDR_OUT) {
12597                 ndr_print_struct(ndr, "out", "samr_Connect5");
12598                 ndr->depth++;
12599                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
12600                 ndr->depth++;
12601                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
12602                 ndr->depth--;
12603                 ndr_print_ptr(ndr, "info_out", r->out.info_out);
12604                 ndr->depth++;
12605                 ndr_print_set_switch_value(ndr, r->out.info_out, *r->out.level_out);
12606                 ndr_print_samr_ConnectInfo(ndr, "info_out", r->out.info_out);
12607                 ndr->depth--;
12608                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
12609                 ndr->depth++;
12610                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
12611                 ndr->depth--;
12612                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12613                 ndr->depth--;
12614         }
12615         ndr->depth--;
12616 }
12617
12618 static enum ndr_err_code ndr_push_samr_RidToSid(struct ndr_push *ndr, int flags, const struct samr_RidToSid *r)
12619 {
12620         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
12621         if (flags & NDR_IN) {
12622                 if (r->in.domain_handle == NULL) {
12623                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12624                 }
12625                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
12626                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
12627         }
12628         if (flags & NDR_OUT) {
12629                 if (r->out.sid == NULL) {
12630                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12631                 }
12632                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sid));
12633                 if (*r->out.sid) {
12634                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
12635                 }
12636                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12637         }
12638         return NDR_ERR_SUCCESS;
12639 }
12640
12641 static enum ndr_err_code ndr_pull_samr_RidToSid(struct ndr_pull *ndr, int flags, struct samr_RidToSid *r)
12642 {
12643         uint32_t _ptr_sid;
12644         TALLOC_CTX *_mem_save_domain_handle_0;
12645         TALLOC_CTX *_mem_save_sid_0;
12646         TALLOC_CTX *_mem_save_sid_1;
12647         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
12648         if (flags & NDR_IN) {
12649                 ZERO_STRUCT(r->out);
12650
12651                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12652                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
12653                 }
12654                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12655                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
12656                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
12657                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
12658                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
12659                 NDR_PULL_ALLOC(ndr, r->out.sid);
12660                 ZERO_STRUCTP(r->out.sid);
12661         }
12662         if (flags & NDR_OUT) {
12663                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12664                         NDR_PULL_ALLOC(ndr, r->out.sid);
12665                 }
12666                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
12667                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);
12668                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
12669                 if (_ptr_sid) {
12670                         NDR_PULL_ALLOC(ndr, *r->out.sid);
12671                 } else {
12672                         *r->out.sid = NULL;
12673                 }
12674                 if (*r->out.sid) {
12675                         _mem_save_sid_1 = NDR_PULL_GET_MEM_CTX(ndr);
12676                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sid, 0);
12677                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
12678                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_1, 0);
12679                 }
12680                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
12681                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12682         }
12683         return NDR_ERR_SUCCESS;
12684 }
12685
12686 _PUBLIC_ void ndr_print_samr_RidToSid(struct ndr_print *ndr, const char *name, int flags, const struct samr_RidToSid *r)
12687 {
12688         ndr_print_struct(ndr, name, "samr_RidToSid");
12689         if (r == NULL) { ndr_print_null(ndr); return; }
12690         ndr->depth++;
12691         if (flags & NDR_SET_VALUES) {
12692                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12693         }
12694         if (flags & NDR_IN) {
12695                 ndr_print_struct(ndr, "in", "samr_RidToSid");
12696                 ndr->depth++;
12697                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
12698                 ndr->depth++;
12699                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
12700                 ndr->depth--;
12701                 ndr_print_uint32(ndr, "rid", r->in.rid);
12702                 ndr->depth--;
12703         }
12704         if (flags & NDR_OUT) {
12705                 ndr_print_struct(ndr, "out", "samr_RidToSid");
12706                 ndr->depth++;
12707                 ndr_print_ptr(ndr, "sid", r->out.sid);
12708                 ndr->depth++;
12709                 ndr_print_ptr(ndr, "sid", *r->out.sid);
12710                 ndr->depth++;
12711                 if (*r->out.sid) {
12712                         ndr_print_dom_sid2(ndr, "sid", *r->out.sid);
12713                 }
12714                 ndr->depth--;
12715                 ndr->depth--;
12716                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12717                 ndr->depth--;
12718         }
12719         ndr->depth--;
12720 }
12721
12722 static enum ndr_err_code ndr_push_samr_SetDsrmPassword(struct ndr_push *ndr, int flags, const struct samr_SetDsrmPassword *r)
12723 {
12724         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
12725         if (flags & NDR_IN) {
12726                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.name));
12727                 if (r->in.name) {
12728                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
12729                 }
12730                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
12731                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hash));
12732                 if (r->in.hash) {
12733                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.hash));
12734                 }
12735         }
12736         if (flags & NDR_OUT) {
12737                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12738         }
12739         return NDR_ERR_SUCCESS;
12740 }
12741
12742 static enum ndr_err_code ndr_pull_samr_SetDsrmPassword(struct ndr_pull *ndr, int flags, struct samr_SetDsrmPassword *r)
12743 {
12744         uint32_t _ptr_name;
12745         uint32_t _ptr_hash;
12746         TALLOC_CTX *_mem_save_name_0;
12747         TALLOC_CTX *_mem_save_hash_0;
12748         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
12749         if (flags & NDR_IN) {
12750                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
12751                 if (_ptr_name) {
12752                         NDR_PULL_ALLOC(ndr, r->in.name);
12753                 } else {
12754                         r->in.name = NULL;
12755                 }
12756                 if (r->in.name) {
12757                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12758                         NDR_PULL_SET_MEM_CTX(ndr, r->in.name, 0);
12759                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
12760                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
12761                 }
12762                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
12763                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hash));
12764                 if (_ptr_hash) {
12765                         NDR_PULL_ALLOC(ndr, r->in.hash);
12766                 } else {
12767                         r->in.hash = NULL;
12768                 }
12769                 if (r->in.hash) {
12770                         _mem_save_hash_0 = NDR_PULL_GET_MEM_CTX(ndr);
12771                         NDR_PULL_SET_MEM_CTX(ndr, r->in.hash, 0);
12772                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.hash));
12773                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hash_0, 0);
12774                 }
12775         }
12776         if (flags & NDR_OUT) {
12777                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12778         }
12779         return NDR_ERR_SUCCESS;
12780 }
12781
12782 _PUBLIC_ void ndr_print_samr_SetDsrmPassword(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetDsrmPassword *r)
12783 {
12784         ndr_print_struct(ndr, name, "samr_SetDsrmPassword");
12785         if (r == NULL) { ndr_print_null(ndr); return; }
12786         ndr->depth++;
12787         if (flags & NDR_SET_VALUES) {
12788                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12789         }
12790         if (flags & NDR_IN) {
12791                 ndr_print_struct(ndr, "in", "samr_SetDsrmPassword");
12792                 ndr->depth++;
12793                 ndr_print_ptr(ndr, "name", r->in.name);
12794                 ndr->depth++;
12795                 if (r->in.name) {
12796                         ndr_print_lsa_String(ndr, "name", r->in.name);
12797                 }
12798                 ndr->depth--;
12799                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
12800                 ndr_print_ptr(ndr, "hash", r->in.hash);
12801                 ndr->depth++;
12802                 if (r->in.hash) {
12803                         ndr_print_samr_Password(ndr, "hash", r->in.hash);
12804                 }
12805                 ndr->depth--;
12806                 ndr->depth--;
12807         }
12808         if (flags & NDR_OUT) {
12809                 ndr_print_struct(ndr, "out", "samr_SetDsrmPassword");
12810                 ndr->depth++;
12811                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12812                 ndr->depth--;
12813         }
12814         ndr->depth--;
12815 }
12816
12817 static enum ndr_err_code ndr_push_samr_ValidatePassword(struct ndr_push *ndr, int flags, const struct samr_ValidatePassword *r)
12818 {
12819         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
12820         if (flags & NDR_IN) {
12821                 NDR_CHECK(ndr_push_samr_ValidatePasswordLevel(ndr, NDR_SCALARS, r->in.level));
12822                 if (r->in.req == NULL) {
12823                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12824                 }
12825                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
12826                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
12827         }
12828         if (flags & NDR_OUT) {
12829                 if (r->out.rep == NULL) {
12830                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12831                 }
12832                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rep));
12833                 if (*r->out.rep) {
12834                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.rep, r->in.level));
12835                         NDR_CHECK(ndr_push_samr_ValidatePasswordRep(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rep));
12836                 }
12837                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12838         }
12839         return NDR_ERR_SUCCESS;
12840 }
12841
12842 static enum ndr_err_code ndr_pull_samr_ValidatePassword(struct ndr_pull *ndr, int flags, struct samr_ValidatePassword *r)
12843 {
12844         uint32_t _ptr_rep;
12845         TALLOC_CTX *_mem_save_req_0;
12846         TALLOC_CTX *_mem_save_rep_0;
12847         TALLOC_CTX *_mem_save_rep_1;
12848         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
12849         if (flags & NDR_IN) {
12850                 ZERO_STRUCT(r->out);
12851
12852                 NDR_CHECK(ndr_pull_samr_ValidatePasswordLevel(ndr, NDR_SCALARS, &r->in.level));
12853                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12854                         NDR_PULL_ALLOC(ndr, r->in.req);
12855                 }
12856                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
12857                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
12858                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
12859                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
12860                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
12861                 NDR_PULL_ALLOC(ndr, r->out.rep);
12862                 ZERO_STRUCTP(r->out.rep);
12863         }
12864         if (flags & NDR_OUT) {
12865                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12866                         NDR_PULL_ALLOC(ndr, r->out.rep);
12867                 }
12868                 _mem_save_rep_0 = NDR_PULL_GET_MEM_CTX(ndr);
12869                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rep, LIBNDR_FLAG_REF_ALLOC);
12870                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rep));
12871                 if (_ptr_rep) {
12872                         NDR_PULL_ALLOC(ndr, *r->out.rep);
12873                 } else {
12874                         *r->out.rep = NULL;
12875                 }
12876                 if (*r->out.rep) {
12877                         _mem_save_rep_1 = NDR_PULL_GET_MEM_CTX(ndr);
12878                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.rep, 0);
12879                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.rep, r->in.level));
12880                         NDR_CHECK(ndr_pull_samr_ValidatePasswordRep(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rep));
12881                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rep_1, 0);
12882                 }
12883                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rep_0, LIBNDR_FLAG_REF_ALLOC);
12884                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12885         }
12886         return NDR_ERR_SUCCESS;
12887 }
12888
12889 _PUBLIC_ void ndr_print_samr_ValidatePassword(struct ndr_print *ndr, const char *name, int flags, const struct samr_ValidatePassword *r)
12890 {
12891         ndr_print_struct(ndr, name, "samr_ValidatePassword");
12892         if (r == NULL) { ndr_print_null(ndr); return; }
12893         ndr->depth++;
12894         if (flags & NDR_SET_VALUES) {
12895                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12896         }
12897         if (flags & NDR_IN) {
12898                 ndr_print_struct(ndr, "in", "samr_ValidatePassword");
12899                 ndr->depth++;
12900                 ndr_print_samr_ValidatePasswordLevel(ndr, "level", r->in.level);
12901                 ndr_print_ptr(ndr, "req", r->in.req);
12902                 ndr->depth++;
12903                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
12904                 ndr_print_samr_ValidatePasswordReq(ndr, "req", r->in.req);
12905                 ndr->depth--;
12906                 ndr->depth--;
12907         }
12908         if (flags & NDR_OUT) {
12909                 ndr_print_struct(ndr, "out", "samr_ValidatePassword");
12910                 ndr->depth++;
12911                 ndr_print_ptr(ndr, "rep", r->out.rep);
12912                 ndr->depth++;
12913                 ndr_print_ptr(ndr, "rep", *r->out.rep);
12914                 ndr->depth++;
12915                 if (*r->out.rep) {
12916                         ndr_print_set_switch_value(ndr, *r->out.rep, r->in.level);
12917                         ndr_print_samr_ValidatePasswordRep(ndr, "rep", *r->out.rep);
12918                 }
12919                 ndr->depth--;
12920                 ndr->depth--;
12921                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12922                 ndr->depth--;
12923         }
12924         ndr->depth--;
12925 }
12926
12927 static const struct ndr_interface_call samr_calls[] = {
12928         {
12929                 "samr_Connect",
12930                 sizeof(struct samr_Connect),
12931                 (ndr_push_flags_fn_t) ndr_push_samr_Connect,
12932                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect,
12933                 (ndr_print_function_t) ndr_print_samr_Connect,
12934                 { 0, NULL },
12935                 { 0, NULL },
12936         },
12937         {
12938                 "samr_Close",
12939                 sizeof(struct samr_Close),
12940                 (ndr_push_flags_fn_t) ndr_push_samr_Close,
12941                 (ndr_pull_flags_fn_t) ndr_pull_samr_Close,
12942                 (ndr_print_function_t) ndr_print_samr_Close,
12943                 { 0, NULL },
12944                 { 0, NULL },
12945         },
12946         {
12947                 "samr_SetSecurity",
12948                 sizeof(struct samr_SetSecurity),
12949                 (ndr_push_flags_fn_t) ndr_push_samr_SetSecurity,
12950                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetSecurity,
12951                 (ndr_print_function_t) ndr_print_samr_SetSecurity,
12952                 { 0, NULL },
12953                 { 0, NULL },
12954         },
12955         {
12956                 "samr_QuerySecurity",
12957                 sizeof(struct samr_QuerySecurity),
12958                 (ndr_push_flags_fn_t) ndr_push_samr_QuerySecurity,
12959                 (ndr_pull_flags_fn_t) ndr_pull_samr_QuerySecurity,
12960                 (ndr_print_function_t) ndr_print_samr_QuerySecurity,
12961                 { 0, NULL },
12962                 { 0, NULL },
12963         },
12964         {
12965                 "samr_Shutdown",
12966                 sizeof(struct samr_Shutdown),
12967                 (ndr_push_flags_fn_t) ndr_push_samr_Shutdown,
12968                 (ndr_pull_flags_fn_t) ndr_pull_samr_Shutdown,
12969                 (ndr_print_function_t) ndr_print_samr_Shutdown,
12970                 { 0, NULL },
12971                 { 0, NULL },
12972         },
12973         {
12974                 "samr_LookupDomain",
12975                 sizeof(struct samr_LookupDomain),
12976                 (ndr_push_flags_fn_t) ndr_push_samr_LookupDomain,
12977                 (ndr_pull_flags_fn_t) ndr_pull_samr_LookupDomain,
12978                 (ndr_print_function_t) ndr_print_samr_LookupDomain,
12979                 { 0, NULL },
12980                 { 0, NULL },
12981         },
12982         {
12983                 "samr_EnumDomains",
12984                 sizeof(struct samr_EnumDomains),
12985                 (ndr_push_flags_fn_t) ndr_push_samr_EnumDomains,
12986                 (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomains,
12987                 (ndr_print_function_t) ndr_print_samr_EnumDomains,
12988                 { 0, NULL },
12989                 { 0, NULL },
12990         },
12991         {
12992                 "samr_OpenDomain",
12993                 sizeof(struct samr_OpenDomain),
12994                 (ndr_push_flags_fn_t) ndr_push_samr_OpenDomain,
12995                 (ndr_pull_flags_fn_t) ndr_pull_samr_OpenDomain,
12996                 (ndr_print_function_t) ndr_print_samr_OpenDomain,
12997                 { 0, NULL },
12998                 { 0, NULL },
12999         },
13000         {
13001                 "samr_QueryDomainInfo",
13002                 sizeof(struct samr_QueryDomainInfo),
13003                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDomainInfo,
13004                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDomainInfo,
13005                 (ndr_print_function_t) ndr_print_samr_QueryDomainInfo,
13006                 { 0, NULL },
13007                 { 0, NULL },
13008         },
13009         {
13010                 "samr_SetDomainInfo",
13011                 sizeof(struct samr_SetDomainInfo),
13012                 (ndr_push_flags_fn_t) ndr_push_samr_SetDomainInfo,
13013                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetDomainInfo,
13014                 (ndr_print_function_t) ndr_print_samr_SetDomainInfo,
13015                 { 0, NULL },
13016                 { 0, NULL },
13017         },
13018         {
13019                 "samr_CreateDomainGroup",
13020                 sizeof(struct samr_CreateDomainGroup),
13021                 (ndr_push_flags_fn_t) ndr_push_samr_CreateDomainGroup,
13022                 (ndr_pull_flags_fn_t) ndr_pull_samr_CreateDomainGroup,
13023                 (ndr_print_function_t) ndr_print_samr_CreateDomainGroup,
13024                 { 0, NULL },
13025                 { 0, NULL },
13026         },
13027         {
13028                 "samr_EnumDomainGroups",
13029                 sizeof(struct samr_EnumDomainGroups),
13030                 (ndr_push_flags_fn_t) ndr_push_samr_EnumDomainGroups,
13031                 (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainGroups,
13032                 (ndr_print_function_t) ndr_print_samr_EnumDomainGroups,
13033                 { 0, NULL },
13034                 { 0, NULL },
13035         },
13036         {
13037                 "samr_CreateUser",
13038                 sizeof(struct samr_CreateUser),
13039                 (ndr_push_flags_fn_t) ndr_push_samr_CreateUser,
13040                 (ndr_pull_flags_fn_t) ndr_pull_samr_CreateUser,
13041                 (ndr_print_function_t) ndr_print_samr_CreateUser,
13042                 { 0, NULL },
13043                 { 0, NULL },
13044         },
13045         {
13046                 "samr_EnumDomainUsers",
13047                 sizeof(struct samr_EnumDomainUsers),
13048                 (ndr_push_flags_fn_t) ndr_push_samr_EnumDomainUsers,
13049                 (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainUsers,
13050                 (ndr_print_function_t) ndr_print_samr_EnumDomainUsers,
13051                 { 0, NULL },
13052                 { 0, NULL },
13053         },
13054         {
13055                 "samr_CreateDomAlias",
13056                 sizeof(struct samr_CreateDomAlias),
13057                 (ndr_push_flags_fn_t) ndr_push_samr_CreateDomAlias,
13058                 (ndr_pull_flags_fn_t) ndr_pull_samr_CreateDomAlias,
13059                 (ndr_print_function_t) ndr_print_samr_CreateDomAlias,
13060                 { 0, NULL },
13061                 { 0, NULL },
13062         },
13063         {
13064                 "samr_EnumDomainAliases",
13065                 sizeof(struct samr_EnumDomainAliases),
13066                 (ndr_push_flags_fn_t) ndr_push_samr_EnumDomainAliases,
13067                 (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainAliases,
13068                 (ndr_print_function_t) ndr_print_samr_EnumDomainAliases,
13069                 { 0, NULL },
13070                 { 0, NULL },
13071         },
13072         {
13073                 "samr_GetAliasMembership",
13074                 sizeof(struct samr_GetAliasMembership),
13075                 (ndr_push_flags_fn_t) ndr_push_samr_GetAliasMembership,
13076                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetAliasMembership,
13077                 (ndr_print_function_t) ndr_print_samr_GetAliasMembership,
13078                 { 0, NULL },
13079                 { 0, NULL },
13080         },
13081         {
13082                 "samr_LookupNames",
13083                 sizeof(struct samr_LookupNames),
13084                 (ndr_push_flags_fn_t) ndr_push_samr_LookupNames,
13085                 (ndr_pull_flags_fn_t) ndr_pull_samr_LookupNames,
13086                 (ndr_print_function_t) ndr_print_samr_LookupNames,
13087                 { 0, NULL },
13088                 { 0, NULL },
13089         },
13090         {
13091                 "samr_LookupRids",
13092                 sizeof(struct samr_LookupRids),
13093                 (ndr_push_flags_fn_t) ndr_push_samr_LookupRids,
13094                 (ndr_pull_flags_fn_t) ndr_pull_samr_LookupRids,
13095                 (ndr_print_function_t) ndr_print_samr_LookupRids,
13096                 { 0, NULL },
13097                 { 0, NULL },
13098         },
13099         {
13100                 "samr_OpenGroup",
13101                 sizeof(struct samr_OpenGroup),
13102                 (ndr_push_flags_fn_t) ndr_push_samr_OpenGroup,
13103                 (ndr_pull_flags_fn_t) ndr_pull_samr_OpenGroup,
13104                 (ndr_print_function_t) ndr_print_samr_OpenGroup,
13105                 { 0, NULL },
13106                 { 0, NULL },
13107         },
13108         {
13109                 "samr_QueryGroupInfo",
13110                 sizeof(struct samr_QueryGroupInfo),
13111                 (ndr_push_flags_fn_t) ndr_push_samr_QueryGroupInfo,
13112                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryGroupInfo,
13113                 (ndr_print_function_t) ndr_print_samr_QueryGroupInfo,
13114                 { 0, NULL },
13115                 { 0, NULL },
13116         },
13117         {
13118                 "samr_SetGroupInfo",
13119                 sizeof(struct samr_SetGroupInfo),
13120                 (ndr_push_flags_fn_t) ndr_push_samr_SetGroupInfo,
13121                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetGroupInfo,
13122                 (ndr_print_function_t) ndr_print_samr_SetGroupInfo,
13123                 { 0, NULL },
13124                 { 0, NULL },
13125         },
13126         {
13127                 "samr_AddGroupMember",
13128                 sizeof(struct samr_AddGroupMember),
13129                 (ndr_push_flags_fn_t) ndr_push_samr_AddGroupMember,
13130                 (ndr_pull_flags_fn_t) ndr_pull_samr_AddGroupMember,
13131                 (ndr_print_function_t) ndr_print_samr_AddGroupMember,
13132                 { 0, NULL },
13133                 { 0, NULL },
13134         },
13135         {
13136                 "samr_DeleteDomainGroup",
13137                 sizeof(struct samr_DeleteDomainGroup),
13138                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteDomainGroup,
13139                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteDomainGroup,
13140                 (ndr_print_function_t) ndr_print_samr_DeleteDomainGroup,
13141                 { 0, NULL },
13142                 { 0, NULL },
13143         },
13144         {
13145                 "samr_DeleteGroupMember",
13146                 sizeof(struct samr_DeleteGroupMember),
13147                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteGroupMember,
13148                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteGroupMember,
13149                 (ndr_print_function_t) ndr_print_samr_DeleteGroupMember,
13150                 { 0, NULL },
13151                 { 0, NULL },
13152         },
13153         {
13154                 "samr_QueryGroupMember",
13155                 sizeof(struct samr_QueryGroupMember),
13156                 (ndr_push_flags_fn_t) ndr_push_samr_QueryGroupMember,
13157                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryGroupMember,
13158                 (ndr_print_function_t) ndr_print_samr_QueryGroupMember,
13159                 { 0, NULL },
13160                 { 0, NULL },
13161         },
13162         {
13163                 "samr_SetMemberAttributesOfGroup",
13164                 sizeof(struct samr_SetMemberAttributesOfGroup),
13165                 (ndr_push_flags_fn_t) ndr_push_samr_SetMemberAttributesOfGroup,
13166                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetMemberAttributesOfGroup,
13167                 (ndr_print_function_t) ndr_print_samr_SetMemberAttributesOfGroup,
13168                 { 0, NULL },
13169                 { 0, NULL },
13170         },
13171         {
13172                 "samr_OpenAlias",
13173                 sizeof(struct samr_OpenAlias),
13174                 (ndr_push_flags_fn_t) ndr_push_samr_OpenAlias,
13175                 (ndr_pull_flags_fn_t) ndr_pull_samr_OpenAlias,
13176                 (ndr_print_function_t) ndr_print_samr_OpenAlias,
13177                 { 0, NULL },
13178                 { 0, NULL },
13179         },
13180         {
13181                 "samr_QueryAliasInfo",
13182                 sizeof(struct samr_QueryAliasInfo),
13183                 (ndr_push_flags_fn_t) ndr_push_samr_QueryAliasInfo,
13184                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryAliasInfo,
13185                 (ndr_print_function_t) ndr_print_samr_QueryAliasInfo,
13186                 { 0, NULL },
13187                 { 0, NULL },
13188         },
13189         {
13190                 "samr_SetAliasInfo",
13191                 sizeof(struct samr_SetAliasInfo),
13192                 (ndr_push_flags_fn_t) ndr_push_samr_SetAliasInfo,
13193                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetAliasInfo,
13194                 (ndr_print_function_t) ndr_print_samr_SetAliasInfo,
13195                 { 0, NULL },
13196                 { 0, NULL },
13197         },
13198         {
13199                 "samr_DeleteDomAlias",
13200                 sizeof(struct samr_DeleteDomAlias),
13201                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteDomAlias,
13202                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteDomAlias,
13203                 (ndr_print_function_t) ndr_print_samr_DeleteDomAlias,
13204                 { 0, NULL },
13205                 { 0, NULL },
13206         },
13207         {
13208                 "samr_AddAliasMember",
13209                 sizeof(struct samr_AddAliasMember),
13210                 (ndr_push_flags_fn_t) ndr_push_samr_AddAliasMember,
13211                 (ndr_pull_flags_fn_t) ndr_pull_samr_AddAliasMember,
13212                 (ndr_print_function_t) ndr_print_samr_AddAliasMember,
13213                 { 0, NULL },
13214                 { 0, NULL },
13215         },
13216         {
13217                 "samr_DeleteAliasMember",
13218                 sizeof(struct samr_DeleteAliasMember),
13219                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteAliasMember,
13220                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteAliasMember,
13221                 (ndr_print_function_t) ndr_print_samr_DeleteAliasMember,
13222                 { 0, NULL },
13223                 { 0, NULL },
13224         },
13225         {
13226                 "samr_GetMembersInAlias",
13227                 sizeof(struct samr_GetMembersInAlias),
13228                 (ndr_push_flags_fn_t) ndr_push_samr_GetMembersInAlias,
13229                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetMembersInAlias,
13230                 (ndr_print_function_t) ndr_print_samr_GetMembersInAlias,
13231                 { 0, NULL },
13232                 { 0, NULL },
13233         },
13234         {
13235                 "samr_OpenUser",
13236                 sizeof(struct samr_OpenUser),
13237                 (ndr_push_flags_fn_t) ndr_push_samr_OpenUser,
13238                 (ndr_pull_flags_fn_t) ndr_pull_samr_OpenUser,
13239                 (ndr_print_function_t) ndr_print_samr_OpenUser,
13240                 { 0, NULL },
13241                 { 0, NULL },
13242         },
13243         {
13244                 "samr_DeleteUser",
13245                 sizeof(struct samr_DeleteUser),
13246                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteUser,
13247                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteUser,
13248                 (ndr_print_function_t) ndr_print_samr_DeleteUser,
13249                 { 0, NULL },
13250                 { 0, NULL },
13251         },
13252         {
13253                 "samr_QueryUserInfo",
13254                 sizeof(struct samr_QueryUserInfo),
13255                 (ndr_push_flags_fn_t) ndr_push_samr_QueryUserInfo,
13256                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryUserInfo,
13257                 (ndr_print_function_t) ndr_print_samr_QueryUserInfo,
13258                 { 0, NULL },
13259                 { 0, NULL },
13260         },
13261         {
13262                 "samr_SetUserInfo",
13263                 sizeof(struct samr_SetUserInfo),
13264                 (ndr_push_flags_fn_t) ndr_push_samr_SetUserInfo,
13265                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetUserInfo,
13266                 (ndr_print_function_t) ndr_print_samr_SetUserInfo,
13267                 { 0, NULL },
13268                 { 0, NULL },
13269         },
13270         {
13271                 "samr_ChangePasswordUser",
13272                 sizeof(struct samr_ChangePasswordUser),
13273                 (ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser,
13274                 (ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser,
13275                 (ndr_print_function_t) ndr_print_samr_ChangePasswordUser,
13276                 { 0, NULL },
13277                 { 0, NULL },
13278         },
13279         {
13280                 "samr_GetGroupsForUser",
13281                 sizeof(struct samr_GetGroupsForUser),
13282                 (ndr_push_flags_fn_t) ndr_push_samr_GetGroupsForUser,
13283                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetGroupsForUser,
13284                 (ndr_print_function_t) ndr_print_samr_GetGroupsForUser,
13285                 { 0, NULL },
13286                 { 0, NULL },
13287         },
13288         {
13289                 "samr_QueryDisplayInfo",
13290                 sizeof(struct samr_QueryDisplayInfo),
13291                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo,
13292                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo,
13293                 (ndr_print_function_t) ndr_print_samr_QueryDisplayInfo,
13294                 { 0, NULL },
13295                 { 0, NULL },
13296         },
13297         {
13298                 "samr_GetDisplayEnumerationIndex",
13299                 sizeof(struct samr_GetDisplayEnumerationIndex),
13300                 (ndr_push_flags_fn_t) ndr_push_samr_GetDisplayEnumerationIndex,
13301                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetDisplayEnumerationIndex,
13302                 (ndr_print_function_t) ndr_print_samr_GetDisplayEnumerationIndex,
13303                 { 0, NULL },
13304                 { 0, NULL },
13305         },
13306         {
13307                 "samr_TestPrivateFunctionsDomain",
13308                 sizeof(struct samr_TestPrivateFunctionsDomain),
13309                 (ndr_push_flags_fn_t) ndr_push_samr_TestPrivateFunctionsDomain,
13310                 (ndr_pull_flags_fn_t) ndr_pull_samr_TestPrivateFunctionsDomain,
13311                 (ndr_print_function_t) ndr_print_samr_TestPrivateFunctionsDomain,
13312                 { 0, NULL },
13313                 { 0, NULL },
13314         },
13315         {
13316                 "samr_TestPrivateFunctionsUser",
13317                 sizeof(struct samr_TestPrivateFunctionsUser),
13318                 (ndr_push_flags_fn_t) ndr_push_samr_TestPrivateFunctionsUser,
13319                 (ndr_pull_flags_fn_t) ndr_pull_samr_TestPrivateFunctionsUser,
13320                 (ndr_print_function_t) ndr_print_samr_TestPrivateFunctionsUser,
13321                 { 0, NULL },
13322                 { 0, NULL },
13323         },
13324         {
13325                 "samr_GetUserPwInfo",
13326                 sizeof(struct samr_GetUserPwInfo),
13327                 (ndr_push_flags_fn_t) ndr_push_samr_GetUserPwInfo,
13328                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetUserPwInfo,
13329                 (ndr_print_function_t) ndr_print_samr_GetUserPwInfo,
13330                 { 0, NULL },
13331                 { 0, NULL },
13332         },
13333         {
13334                 "samr_RemoveMemberFromForeignDomain",
13335                 sizeof(struct samr_RemoveMemberFromForeignDomain),
13336                 (ndr_push_flags_fn_t) ndr_push_samr_RemoveMemberFromForeignDomain,
13337                 (ndr_pull_flags_fn_t) ndr_pull_samr_RemoveMemberFromForeignDomain,
13338                 (ndr_print_function_t) ndr_print_samr_RemoveMemberFromForeignDomain,
13339                 { 0, NULL },
13340                 { 0, NULL },
13341         },
13342         {
13343                 "samr_QueryDomainInfo2",
13344                 sizeof(struct samr_QueryDomainInfo2),
13345                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDomainInfo2,
13346                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDomainInfo2,
13347                 (ndr_print_function_t) ndr_print_samr_QueryDomainInfo2,
13348                 { 0, NULL },
13349                 { 0, NULL },
13350         },
13351         {
13352                 "samr_QueryUserInfo2",
13353                 sizeof(struct samr_QueryUserInfo2),
13354                 (ndr_push_flags_fn_t) ndr_push_samr_QueryUserInfo2,
13355                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryUserInfo2,
13356                 (ndr_print_function_t) ndr_print_samr_QueryUserInfo2,
13357                 { 0, NULL },
13358                 { 0, NULL },
13359         },
13360         {
13361                 "samr_QueryDisplayInfo2",
13362                 sizeof(struct samr_QueryDisplayInfo2),
13363                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo2,
13364                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo2,
13365                 (ndr_print_function_t) ndr_print_samr_QueryDisplayInfo2,
13366                 { 0, NULL },
13367                 { 0, NULL },
13368         },
13369         {
13370                 "samr_GetDisplayEnumerationIndex2",
13371                 sizeof(struct samr_GetDisplayEnumerationIndex2),
13372                 (ndr_push_flags_fn_t) ndr_push_samr_GetDisplayEnumerationIndex2,
13373                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetDisplayEnumerationIndex2,
13374                 (ndr_print_function_t) ndr_print_samr_GetDisplayEnumerationIndex2,
13375                 { 0, NULL },
13376                 { 0, NULL },
13377         },
13378         {
13379                 "samr_CreateUser2",
13380                 sizeof(struct samr_CreateUser2),
13381                 (ndr_push_flags_fn_t) ndr_push_samr_CreateUser2,
13382                 (ndr_pull_flags_fn_t) ndr_pull_samr_CreateUser2,
13383                 (ndr_print_function_t) ndr_print_samr_CreateUser2,
13384                 { 0, NULL },
13385                 { 0, NULL },
13386         },
13387         {
13388                 "samr_QueryDisplayInfo3",
13389                 sizeof(struct samr_QueryDisplayInfo3),
13390                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo3,
13391                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo3,
13392                 (ndr_print_function_t) ndr_print_samr_QueryDisplayInfo3,
13393                 { 0, NULL },
13394                 { 0, NULL },
13395         },
13396         {
13397                 "samr_AddMultipleMembersToAlias",
13398                 sizeof(struct samr_AddMultipleMembersToAlias),
13399                 (ndr_push_flags_fn_t) ndr_push_samr_AddMultipleMembersToAlias,
13400                 (ndr_pull_flags_fn_t) ndr_pull_samr_AddMultipleMembersToAlias,
13401                 (ndr_print_function_t) ndr_print_samr_AddMultipleMembersToAlias,
13402                 { 0, NULL },
13403                 { 0, NULL },
13404         },
13405         {
13406                 "samr_RemoveMultipleMembersFromAlias",
13407                 sizeof(struct samr_RemoveMultipleMembersFromAlias),
13408                 (ndr_push_flags_fn_t) ndr_push_samr_RemoveMultipleMembersFromAlias,
13409                 (ndr_pull_flags_fn_t) ndr_pull_samr_RemoveMultipleMembersFromAlias,
13410                 (ndr_print_function_t) ndr_print_samr_RemoveMultipleMembersFromAlias,
13411                 { 0, NULL },
13412                 { 0, NULL },
13413         },
13414         {
13415                 "samr_OemChangePasswordUser2",
13416                 sizeof(struct samr_OemChangePasswordUser2),
13417                 (ndr_push_flags_fn_t) ndr_push_samr_OemChangePasswordUser2,
13418                 (ndr_pull_flags_fn_t) ndr_pull_samr_OemChangePasswordUser2,
13419                 (ndr_print_function_t) ndr_print_samr_OemChangePasswordUser2,
13420                 { 0, NULL },
13421                 { 0, NULL },
13422         },
13423         {
13424                 "samr_ChangePasswordUser2",
13425                 sizeof(struct samr_ChangePasswordUser2),
13426                 (ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser2,
13427                 (ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser2,
13428                 (ndr_print_function_t) ndr_print_samr_ChangePasswordUser2,
13429                 { 0, NULL },
13430                 { 0, NULL },
13431         },
13432         {
13433                 "samr_GetDomPwInfo",
13434                 sizeof(struct samr_GetDomPwInfo),
13435                 (ndr_push_flags_fn_t) ndr_push_samr_GetDomPwInfo,
13436                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetDomPwInfo,
13437                 (ndr_print_function_t) ndr_print_samr_GetDomPwInfo,
13438                 { 0, NULL },
13439                 { 0, NULL },
13440         },
13441         {
13442                 "samr_Connect2",
13443                 sizeof(struct samr_Connect2),
13444                 (ndr_push_flags_fn_t) ndr_push_samr_Connect2,
13445                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect2,
13446                 (ndr_print_function_t) ndr_print_samr_Connect2,
13447                 { 0, NULL },
13448                 { 0, NULL },
13449         },
13450         {
13451                 "samr_SetUserInfo2",
13452                 sizeof(struct samr_SetUserInfo2),
13453                 (ndr_push_flags_fn_t) ndr_push_samr_SetUserInfo2,
13454                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetUserInfo2,
13455                 (ndr_print_function_t) ndr_print_samr_SetUserInfo2,
13456                 { 0, NULL },
13457                 { 0, NULL },
13458         },
13459         {
13460                 "samr_SetBootKeyInformation",
13461                 sizeof(struct samr_SetBootKeyInformation),
13462                 (ndr_push_flags_fn_t) ndr_push_samr_SetBootKeyInformation,
13463                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetBootKeyInformation,
13464                 (ndr_print_function_t) ndr_print_samr_SetBootKeyInformation,
13465                 { 0, NULL },
13466                 { 0, NULL },
13467         },
13468         {
13469                 "samr_GetBootKeyInformation",
13470                 sizeof(struct samr_GetBootKeyInformation),
13471                 (ndr_push_flags_fn_t) ndr_push_samr_GetBootKeyInformation,
13472                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetBootKeyInformation,
13473                 (ndr_print_function_t) ndr_print_samr_GetBootKeyInformation,
13474                 { 0, NULL },
13475                 { 0, NULL },
13476         },
13477         {
13478                 "samr_Connect3",
13479                 sizeof(struct samr_Connect3),
13480                 (ndr_push_flags_fn_t) ndr_push_samr_Connect3,
13481                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect3,
13482                 (ndr_print_function_t) ndr_print_samr_Connect3,
13483                 { 0, NULL },
13484                 { 0, NULL },
13485         },
13486         {
13487                 "samr_Connect4",
13488                 sizeof(struct samr_Connect4),
13489                 (ndr_push_flags_fn_t) ndr_push_samr_Connect4,
13490                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect4,
13491                 (ndr_print_function_t) ndr_print_samr_Connect4,
13492                 { 0, NULL },
13493                 { 0, NULL },
13494         },
13495         {
13496                 "samr_ChangePasswordUser3",
13497                 sizeof(struct samr_ChangePasswordUser3),
13498                 (ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser3,
13499                 (ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser3,
13500                 (ndr_print_function_t) ndr_print_samr_ChangePasswordUser3,
13501                 { 0, NULL },
13502                 { 0, NULL },
13503         },
13504         {
13505                 "samr_Connect5",
13506                 sizeof(struct samr_Connect5),
13507                 (ndr_push_flags_fn_t) ndr_push_samr_Connect5,
13508                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect5,
13509                 (ndr_print_function_t) ndr_print_samr_Connect5,
13510                 { 0, NULL },
13511                 { 0, NULL },
13512         },
13513         {
13514                 "samr_RidToSid",
13515                 sizeof(struct samr_RidToSid),
13516                 (ndr_push_flags_fn_t) ndr_push_samr_RidToSid,
13517                 (ndr_pull_flags_fn_t) ndr_pull_samr_RidToSid,
13518                 (ndr_print_function_t) ndr_print_samr_RidToSid,
13519                 { 0, NULL },
13520                 { 0, NULL },
13521         },
13522         {
13523                 "samr_SetDsrmPassword",
13524                 sizeof(struct samr_SetDsrmPassword),
13525                 (ndr_push_flags_fn_t) ndr_push_samr_SetDsrmPassword,
13526                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetDsrmPassword,
13527                 (ndr_print_function_t) ndr_print_samr_SetDsrmPassword,
13528                 { 0, NULL },
13529                 { 0, NULL },
13530         },
13531         {
13532                 "samr_ValidatePassword",
13533                 sizeof(struct samr_ValidatePassword),
13534                 (ndr_push_flags_fn_t) ndr_push_samr_ValidatePassword,
13535                 (ndr_pull_flags_fn_t) ndr_pull_samr_ValidatePassword,
13536                 (ndr_print_function_t) ndr_print_samr_ValidatePassword,
13537                 { 0, NULL },
13538                 { 0, NULL },
13539         },
13540         { NULL, 0, NULL, NULL, NULL }
13541 };
13542
13543 static const char * const samr_endpoint_strings[] = {
13544         "ncacn_np:[\\pipe\\samr]",
13545         "ncacn_ip_tcp:",
13546         "ncalrpc:",
13547 };
13548
13549 static const struct ndr_interface_string_array samr_endpoints = {
13550         .count  = 3,
13551         .names  = samr_endpoint_strings
13552 };
13553
13554 static const char * const samr_authservice_strings[] = {
13555         "host",
13556 };
13557
13558 static const struct ndr_interface_string_array samr_authservices = {
13559         .count  = 1,
13560         .names  = samr_authservice_strings
13561 };
13562
13563
13564 const struct ndr_interface_table ndr_table_samr = {
13565         .name           = "samr",
13566         .syntax_id      = {
13567                 {0x12345778,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xac}},
13568                 NDR_SAMR_VERSION
13569         },
13570         .helpstring     = NDR_SAMR_HELPSTRING,
13571         .num_calls      = 68,
13572         .calls          = samr_calls,
13573         .endpoints      = &samr_endpoints,
13574         .authservices   = &samr_authservices
13575 };
13576