librpc/gen_ndr/ndr_samr.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../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_netr_SamDatabaseID(struct ndr_push *ndr, int ndr_flags, enum netr_SamDatabaseID r)
  10 {
  11         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
  12         return NDR_ERR_SUCCESS;
  13 }
  14
  15 _PUBLIC_ enum ndr_err_code ndr_pull_netr_SamDatabaseID(struct ndr_pull *ndr, int ndr_flags, enum netr_SamDatabaseID *r)
  16 {
  17         uint32_t v;
  18         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
  19         *r = v;
  20         return NDR_ERR_SUCCESS;
  21 }
  22
  23 _PUBLIC_ void ndr_print_netr_SamDatabaseID(struct ndr_print *ndr, const char *name, enum netr_SamDatabaseID r)
  24 {
  25         const char *val = NULL;
  26
  27         switch (r) {
  28                 case SAM_DATABASE_DOMAIN: val = "SAM_DATABASE_DOMAIN"; break;
  29                 case SAM_DATABASE_BUILTIN: val = "SAM_DATABASE_BUILTIN"; break;
  30                 case SAM_DATABASE_PRIVS: val = "SAM_DATABASE_PRIVS"; break;
  31         }
  32         ndr_print_enum(ndr, name, "ENUM", val, r);
  33 }
  34
  35 _PUBLIC_ enum ndr_err_code ndr_push_samr_RejectReason(struct ndr_push *ndr, int ndr_flags, enum samr_RejectReason r)
  36 {
  37         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
  38         return NDR_ERR_SUCCESS;
  39 }
  40
  41 _PUBLIC_ enum ndr_err_code ndr_pull_samr_RejectReason(struct ndr_pull *ndr, int ndr_flags, enum samr_RejectReason *r)
  42 {
  43         uint32_t v;
  44         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
  45         *r = v;
  46         return NDR_ERR_SUCCESS;
  47 }
  48
  49 _PUBLIC_ void ndr_print_samr_RejectReason(struct ndr_print *ndr, const char *name, enum samr_RejectReason r)
  50 {
  51         const char *val = NULL;
  52
  53         switch (r) {
  54                 case SAMR_REJECT_OTHER: val = "SAMR_REJECT_OTHER"; break;
  55                 case SAMR_REJECT_TOO_SHORT: val = "SAMR_REJECT_TOO_SHORT"; break;
  56                 case SAMR_REJECT_IN_HISTORY: val = "SAMR_REJECT_IN_HISTORY"; break;
  57                 case SAMR_REJECT_COMPLEXITY: val = "SAMR_REJECT_COMPLEXITY"; break;
  58         }
  59         ndr_print_enum(ndr, name, "ENUM", val, r);
  60 }
  61
  62 _PUBLIC_ enum ndr_err_code ndr_push_samr_AcctFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  63 {
  64         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  65         return NDR_ERR_SUCCESS;
  66 }
  67
  68 _PUBLIC_ enum ndr_err_code ndr_pull_samr_AcctFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  69 {
  70         uint32_t v;
  71         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  72         *r = v;
  73         return NDR_ERR_SUCCESS;
  74 }
  75
  76 _PUBLIC_ void ndr_print_samr_AcctFlags(struct ndr_print *ndr, const char *name, uint32_t r)
  77 {
  78         ndr_print_uint32(ndr, name, r);
  79         ndr->depth++;
  80         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_DISABLED", ACB_DISABLED, r);
  81         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_HOMDIRREQ", ACB_HOMDIRREQ, r);
  82         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_PWNOTREQ", ACB_PWNOTREQ, r);
  83         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_TEMPDUP", ACB_TEMPDUP, r);
  84         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_NORMAL", ACB_NORMAL, r);
  85         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_MNS", ACB_MNS, r);
  86         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_DOMTRUST", ACB_DOMTRUST, r);
  87         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_WSTRUST", ACB_WSTRUST, r);
  88         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_SVRTRUST", ACB_SVRTRUST, r);
  89         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_PWNOEXP", ACB_PWNOEXP, r);
  90         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_AUTOLOCK", ACB_AUTOLOCK, r);
  91         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_ENC_TXT_PWD_ALLOWED", ACB_ENC_TXT_PWD_ALLOWED, r);
  92         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_SMARTCARD_REQUIRED", ACB_SMARTCARD_REQUIRED, r);
  93         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_TRUSTED_FOR_DELEGATION", ACB_TRUSTED_FOR_DELEGATION, r);
  94         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_NOT_DELEGATED", ACB_NOT_DELEGATED, r);
  95         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_USE_DES_KEY_ONLY", ACB_USE_DES_KEY_ONLY, r);
  96         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_DONT_REQUIRE_PREAUTH", ACB_DONT_REQUIRE_PREAUTH, r);
  97         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_PW_EXPIRED", ACB_PW_EXPIRED, r);
  98         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_NO_AUTH_DATA_REQD", ACB_NO_AUTH_DATA_REQD, r);
  99         ndr->depth--;
 100 }
 101
 102 static enum ndr_err_code ndr_push_samr_ConnectAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 103 {
 104         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 105         return NDR_ERR_SUCCESS;
 106 }
 107
 108 static enum ndr_err_code ndr_pull_samr_ConnectAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 109 {
 110         uint32_t v;
 111         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 112         *r = v;
 113         return NDR_ERR_SUCCESS;
 114 }
 115
 116 _PUBLIC_ void ndr_print_samr_ConnectAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 117 {
 118         ndr_print_uint32(ndr, name, r);
 119         ndr->depth++;
 120         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_CONNECT_TO_SERVER", SAMR_ACCESS_CONNECT_TO_SERVER, r);
 121         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_SHUTDOWN_SERVER", SAMR_ACCESS_SHUTDOWN_SERVER, r);
 122         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_INITIALIZE_SERVER", SAMR_ACCESS_INITIALIZE_SERVER, r);
 123         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_CREATE_DOMAIN", SAMR_ACCESS_CREATE_DOMAIN, r);
 124         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_ENUM_DOMAINS", SAMR_ACCESS_ENUM_DOMAINS, r);
 125         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_LOOKUP_DOMAIN", SAMR_ACCESS_LOOKUP_DOMAIN, r);
 126         ndr->depth--;
 127 }
 128
 129 static enum ndr_err_code ndr_push_samr_UserAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 130 {
 131         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 132         return NDR_ERR_SUCCESS;
 133 }
 134
 135 static enum ndr_err_code ndr_pull_samr_UserAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 136 {
 137         uint32_t v;
 138         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 139         *r = v;
 140         return NDR_ERR_SUCCESS;
 141 }
 142
 143 _PUBLIC_ void ndr_print_samr_UserAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 144 {
 145         ndr_print_uint32(ndr, name, r);
 146         ndr->depth++;
 147         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_NAME_ETC", SAMR_USER_ACCESS_GET_NAME_ETC, r);
 148         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_LOCALE", SAMR_USER_ACCESS_GET_LOCALE, r);
 149         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_SET_LOC_COM", SAMR_USER_ACCESS_SET_LOC_COM, r);
 150         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_LOGONINFO", SAMR_USER_ACCESS_GET_LOGONINFO, r);
 151         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_ATTRIBUTES", SAMR_USER_ACCESS_GET_ATTRIBUTES, r);
 152         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_SET_ATTRIBUTES", SAMR_USER_ACCESS_SET_ATTRIBUTES, r);
 153         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_CHANGE_PASSWORD", SAMR_USER_ACCESS_CHANGE_PASSWORD, r);
 154         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_SET_PASSWORD", SAMR_USER_ACCESS_SET_PASSWORD, r);
 155         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_GROUPS", SAMR_USER_ACCESS_GET_GROUPS, r);
 156         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_GROUP_MEMBERSHIP", SAMR_USER_ACCESS_GET_GROUP_MEMBERSHIP, r);
 157         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_CHANGE_GROUP_MEMBERSHIP", SAMR_USER_ACCESS_CHANGE_GROUP_MEMBERSHIP, r);
 158         ndr->depth--;
 159 }
 160
 161 static enum ndr_err_code ndr_push_samr_DomainAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 162 {
 163         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 164         return NDR_ERR_SUCCESS;
 165 }
 166
 167 static enum ndr_err_code ndr_pull_samr_DomainAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 168 {
 169         uint32_t v;
 170         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 171         *r = v;
 172         return NDR_ERR_SUCCESS;
 173 }
 174
 175 _PUBLIC_ void ndr_print_samr_DomainAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 176 {
 177         ndr_print_uint32(ndr, name, r);
 178         ndr->depth++;
 179         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1", SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1, r);
 180         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_SET_INFO_1", SAMR_DOMAIN_ACCESS_SET_INFO_1, r);
 181         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2", SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2, r);
 182         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_SET_INFO_2", SAMR_DOMAIN_ACCESS_SET_INFO_2, r);
 183         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_CREATE_USER", SAMR_DOMAIN_ACCESS_CREATE_USER, r);
 184         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_CREATE_GROUP", SAMR_DOMAIN_ACCESS_CREATE_GROUP, r);
 185         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_CREATE_ALIAS", SAMR_DOMAIN_ACCESS_CREATE_ALIAS, r);
 186         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS", SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS, r);
 187         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS", SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS, r);
 188         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT", SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT, r);
 189         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_SET_INFO_3", SAMR_DOMAIN_ACCESS_SET_INFO_3, r);
 190         ndr->depth--;
 191 }
 192
 193 static enum ndr_err_code ndr_push_samr_GroupAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 194 {
 195         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 196         return NDR_ERR_SUCCESS;
 197 }
 198
 199 static enum ndr_err_code ndr_pull_samr_GroupAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 200 {
 201         uint32_t v;
 202         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 203         *r = v;
 204         return NDR_ERR_SUCCESS;
 205 }
 206
 207 _PUBLIC_ void ndr_print_samr_GroupAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 208 {
 209         ndr_print_uint32(ndr, name, r);
 210         ndr->depth++;
 211         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_LOOKUP_INFO", SAMR_GROUP_ACCESS_LOOKUP_INFO, r);
 212         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_SET_INFO", SAMR_GROUP_ACCESS_SET_INFO, r);
 213         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_ADD_MEMBER", SAMR_GROUP_ACCESS_ADD_MEMBER, r);
 214         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_REMOVE_MEMBER", SAMR_GROUP_ACCESS_REMOVE_MEMBER, r);
 215         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_GET_MEMBERS", SAMR_GROUP_ACCESS_GET_MEMBERS, r);
 216         ndr->depth--;
 217 }
 218
 219 static enum ndr_err_code ndr_push_samr_AliasAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 220 {
 221         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 222         return NDR_ERR_SUCCESS;
 223 }
 224
 225 static enum ndr_err_code ndr_pull_samr_AliasAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 226 {
 227         uint32_t v;
 228         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 229         *r = v;
 230         return NDR_ERR_SUCCESS;
 231 }
 232
 233 _PUBLIC_ void ndr_print_samr_AliasAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 234 {
 235         ndr_print_uint32(ndr, name, r);
 236         ndr->depth++;
 237         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_ADD_MEMBER", SAMR_ALIAS_ACCESS_ADD_MEMBER, r);
 238         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_REMOVE_MEMBER", SAMR_ALIAS_ACCESS_REMOVE_MEMBER, r);
 239         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_GET_MEMBERS", SAMR_ALIAS_ACCESS_GET_MEMBERS, r);
 240         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_LOOKUP_INFO", SAMR_ALIAS_ACCESS_LOOKUP_INFO, r);
 241         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_SET_INFO", SAMR_ALIAS_ACCESS_SET_INFO, r);
 242         ndr->depth--;
 243 }
 244
 245 static enum ndr_err_code ndr_push_samr_SamEntry(struct ndr_push *ndr, int ndr_flags, const struct samr_SamEntry *r)
 246 {
 247         if (ndr_flags & NDR_SCALARS) {
 248                 NDR_CHECK(ndr_push_align(ndr, 5));
 249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
 250                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
 251         }
 252         if (ndr_flags & NDR_BUFFERS) {
 253                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
 254         }
 255         return NDR_ERR_SUCCESS;
 256 }
 257
 258 static enum ndr_err_code ndr_pull_samr_SamEntry(struct ndr_pull *ndr, int ndr_flags, struct samr_SamEntry *r)
 259 {
 260         if (ndr_flags & NDR_SCALARS) {
 261                 NDR_CHECK(ndr_pull_align(ndr, 5));
 262                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
 263                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
 264         }
 265         if (ndr_flags & NDR_BUFFERS) {
 266                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
 267         }
 268         return NDR_ERR_SUCCESS;
 269 }
 270
 271 _PUBLIC_ void ndr_print_samr_SamEntry(struct ndr_print *ndr, const char *name, const struct samr_SamEntry *r)
 272 {
 273         ndr_print_struct(ndr, name, "samr_SamEntry");
 274         ndr->depth++;
 275         ndr_print_uint32(ndr, "idx", r->idx);
 276         ndr_print_lsa_String(ndr, "name", &r->name);
 277         ndr->depth--;
 278 }
 279
 280 static enum ndr_err_code ndr_push_samr_SamArray(struct ndr_push *ndr, int ndr_flags, const struct samr_SamArray *r)
 281 {
 282         uint32_t cntr_entries_1;
 283         if (ndr_flags & NDR_SCALARS) {
 284                 NDR_CHECK(ndr_push_align(ndr, 5));
 285                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 286                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
 287         }
 288         if (ndr_flags & NDR_BUFFERS) {
 289                 if (r->entries) {
 290                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
 291                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 292                                 NDR_CHECK(ndr_push_samr_SamEntry(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 293                         }
 294                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 295                                 NDR_CHECK(ndr_push_samr_SamEntry(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 296                         }
 297                 }
 298         }
 299         return NDR_ERR_SUCCESS;
 300 }
 301
 302 static enum ndr_err_code ndr_pull_samr_SamArray(struct ndr_pull *ndr, int ndr_flags, struct samr_SamArray *r)
 303 {
 304         uint32_t _ptr_entries;
 305         uint32_t cntr_entries_1;
 306         TALLOC_CTX *_mem_save_entries_0;
 307         TALLOC_CTX *_mem_save_entries_1;
 308         if (ndr_flags & NDR_SCALARS) {
 309                 NDR_CHECK(ndr_pull_align(ndr, 5));
 310                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 311                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
 312                 if (_ptr_entries) {
 313                         NDR_PULL_ALLOC(ndr, r->entries);
 314                 } else {
 315                         r->entries = NULL;
 316                 }
 317         }
 318         if (ndr_flags & NDR_BUFFERS) {
 319                 if (r->entries) {
 320                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
 321                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 322                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
 323                         NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
 324                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
 325                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 326                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 327                                 NDR_CHECK(ndr_pull_samr_SamEntry(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 328                         }
 329                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 330                                 NDR_CHECK(ndr_pull_samr_SamEntry(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 331                         }
 332                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
 333                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
 334                 }
 335                 if (r->entries) {
 336                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
 337                 }
 338         }
 339         return NDR_ERR_SUCCESS;
 340 }
 341
 342 _PUBLIC_ void ndr_print_samr_SamArray(struct ndr_print *ndr, const char *name, const struct samr_SamArray *r)
 343 {
 344         uint32_t cntr_entries_1;
 345         ndr_print_struct(ndr, name, "samr_SamArray");
 346         ndr->depth++;
 347         ndr_print_uint32(ndr, "count", r->count);
 348         ndr_print_ptr(ndr, "entries", r->entries);
 349         ndr->depth++;
 350         if (r->entries) {
 351                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
 352                 ndr->depth++;
 353                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
 354                         char *idx_1=NULL;
 355                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
 356                                 ndr_print_samr_SamEntry(ndr, "entries", &r->entries[cntr_entries_1]);
 357                                 free(idx_1);
 358                         }
 359                 }
 360                 ndr->depth--;
 361         }
 362         ndr->depth--;
 363         ndr->depth--;
 364 }
 365
 366 static enum ndr_err_code ndr_push_samr_DomainInfoClass(struct ndr_push *ndr, int ndr_flags, enum samr_DomainInfoClass r)
 367 {
 368         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 369         return NDR_ERR_SUCCESS;
 370 }
 371
 372 static enum ndr_err_code ndr_pull_samr_DomainInfoClass(struct ndr_pull *ndr, int ndr_flags, enum samr_DomainInfoClass *r)
 373 {
 374         uint16_t v;
 375         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 376         *r = v;
 377         return NDR_ERR_SUCCESS;
 378 }
 379
 380 _PUBLIC_ void ndr_print_samr_DomainInfoClass(struct ndr_print *ndr, const char *name, enum samr_DomainInfoClass r)
 381 {
 382         const char *val = NULL;
 383
 384         switch (r) {
 385                 case DomainPasswordInformation: val = "DomainPasswordInformation"; break;
 386                 case DomainGeneralInformation: val = "DomainGeneralInformation"; break;
 387                 case DomainLogoffInformation: val = "DomainLogoffInformation"; break;
 388                 case DomainOemInformation: val = "DomainOemInformation"; break;
 389                 case DomainNameInformation: val = "DomainNameInformation"; break;
 390                 case DomainReplicationInformation: val = "DomainReplicationInformation"; break;
 391                 case DomainServerRoleInformation: val = "DomainServerRoleInformation"; break;
 392                 case DomainModifiedInformation: val = "DomainModifiedInformation"; break;
 393                 case DomainStateInformation: val = "DomainStateInformation"; break;
 394                 case DomainUasInformation: val = "DomainUasInformation"; break;
 395                 case DomainGeneralInformation2: val = "DomainGeneralInformation2"; break;
 396                 case DomainLockoutInformation: val = "DomainLockoutInformation"; break;
 397                 case DomainModifiedInformation2: val = "DomainModifiedInformation2"; break;
 398         }
 399         ndr_print_enum(ndr, name, "ENUM", val, r);
 400 }
 401
 402 static enum ndr_err_code ndr_push_samr_Role(struct ndr_push *ndr, int ndr_flags, enum samr_Role r)
 403 {
 404         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 405         return NDR_ERR_SUCCESS;
 406 }
 407
 408 static enum ndr_err_code ndr_pull_samr_Role(struct ndr_pull *ndr, int ndr_flags, enum samr_Role *r)
 409 {
 410         uint32_t v;
 411         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 412         *r = v;
 413         return NDR_ERR_SUCCESS;
 414 }
 415
 416 _PUBLIC_ void ndr_print_samr_Role(struct ndr_print *ndr, const char *name, enum samr_Role r)
 417 {
 418         const char *val = NULL;
 419
 420         switch (r) {
 421                 case SAMR_ROLE_STANDALONE: val = "SAMR_ROLE_STANDALONE"; break;
 422                 case SAMR_ROLE_DOMAIN_MEMBER: val = "SAMR_ROLE_DOMAIN_MEMBER"; break;
 423                 case SAMR_ROLE_DOMAIN_BDC: val = "SAMR_ROLE_DOMAIN_BDC"; break;
 424                 case SAMR_ROLE_DOMAIN_PDC: val = "SAMR_ROLE_DOMAIN_PDC"; break;
 425         }
 426         ndr_print_enum(ndr, name, "ENUM", val, r);
 427 }
 428
 429 _PUBLIC_ enum ndr_err_code ndr_push_samr_PasswordProperties(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 430 {
 431         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 432         return NDR_ERR_SUCCESS;
 433 }
 434
 435 _PUBLIC_ enum ndr_err_code ndr_pull_samr_PasswordProperties(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 436 {
 437         uint32_t v;
 438         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 439         *r = v;
 440         return NDR_ERR_SUCCESS;
 441 }
 442
 443 _PUBLIC_ void ndr_print_samr_PasswordProperties(struct ndr_print *ndr, const char *name, uint32_t r)
 444 {
 445         ndr_print_uint32(ndr, name, r);
 446         ndr->depth++;
 447         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_COMPLEX", DOMAIN_PASSWORD_COMPLEX, r);
 448         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_NO_ANON_CHANGE", DOMAIN_PASSWORD_NO_ANON_CHANGE, r);
 449         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_NO_CLEAR_CHANGE", DOMAIN_PASSWORD_NO_CLEAR_CHANGE, r);
 450         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_LOCKOUT_ADMINS", DOMAIN_PASSWORD_LOCKOUT_ADMINS, r);
 451         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_STORE_CLEARTEXT", DOMAIN_PASSWORD_STORE_CLEARTEXT, r);
 452         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_REFUSE_PASSWORD_CHANGE", DOMAIN_REFUSE_PASSWORD_CHANGE, r);
 453         ndr->depth--;
 454 }
 455
 456 static enum ndr_err_code ndr_push_samr_DomainServerState(struct ndr_push *ndr, int ndr_flags, enum samr_DomainServerState r)
 457 {
 458         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 459         return NDR_ERR_SUCCESS;
 460 }
 461
 462 static enum ndr_err_code ndr_pull_samr_DomainServerState(struct ndr_pull *ndr, int ndr_flags, enum samr_DomainServerState *r)
 463 {
 464         uint32_t v;
 465         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 466         *r = v;
 467         return NDR_ERR_SUCCESS;
 468 }
 469
 470 _PUBLIC_ void ndr_print_samr_DomainServerState(struct ndr_print *ndr, const char *name, enum samr_DomainServerState r)
 471 {
 472         const char *val = NULL;
 473
 474         switch (r) {
 475                 case DOMAIN_SERVER_ENABLED: val = "DOMAIN_SERVER_ENABLED"; break;
 476                 case DOMAIN_SERVER_DISABLED: val = "DOMAIN_SERVER_DISABLED"; break;
 477         }
 478         ndr_print_enum(ndr, name, "ENUM", val, r);
 479 }
 480
 481 static enum ndr_err_code ndr_push_samr_DomInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo1 *r)
 482 {
 483         if (ndr_flags & NDR_SCALARS) {
 484                 NDR_CHECK(ndr_push_align(ndr, 4));
 485                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->min_password_length));
 486                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->password_history_length));
 487                 NDR_CHECK(ndr_push_samr_PasswordProperties(ndr, NDR_SCALARS, r->password_properties));
 488                 NDR_CHECK(ndr_push_dlong(ndr, NDR_SCALARS, r->max_password_age));
 489                 NDR_CHECK(ndr_push_dlong(ndr, NDR_SCALARS, r->min_password_age));
 490         }
 491         if (ndr_flags & NDR_BUFFERS) {
 492         }
 493         return NDR_ERR_SUCCESS;
 494 }
 495
 496 static enum ndr_err_code ndr_pull_samr_DomInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo1 *r)
 497 {
 498         if (ndr_flags & NDR_SCALARS) {
 499                 NDR_CHECK(ndr_pull_align(ndr, 4));
 500                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->min_password_length));
 501                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->password_history_length));
 502                 NDR_CHECK(ndr_pull_samr_PasswordProperties(ndr, NDR_SCALARS, &r->password_properties));
 503                 NDR_CHECK(ndr_pull_dlong(ndr, NDR_SCALARS, &r->max_password_age));
 504                 NDR_CHECK(ndr_pull_dlong(ndr, NDR_SCALARS, &r->min_password_age));
 505         }
 506         if (ndr_flags & NDR_BUFFERS) {
 507         }
 508         return NDR_ERR_SUCCESS;
 509 }
 510
 511 _PUBLIC_ void ndr_print_samr_DomInfo1(struct ndr_print *ndr, const char *name, const struct samr_DomInfo1 *r)
 512 {
 513         ndr_print_struct(ndr, name, "samr_DomInfo1");
 514         ndr->depth++;
 515         ndr_print_uint16(ndr, "min_password_length", r->min_password_length);
 516         ndr_print_uint16(ndr, "password_history_length", r->password_history_length);
 517         ndr_print_samr_PasswordProperties(ndr, "password_properties", r->password_properties);
 518         ndr_print_dlong(ndr, "max_password_age", r->max_password_age);
 519         ndr_print_dlong(ndr, "min_password_age", r->min_password_age);
 520         ndr->depth--;
 521 }
 522
 523 static enum ndr_err_code ndr_push_samr_DomGeneralInformation(struct ndr_push *ndr, int ndr_flags, const struct samr_DomGeneralInformation *r)
 524 {
 525         if (ndr_flags & NDR_SCALARS) {
 526                 NDR_CHECK(ndr_push_align(ndr, 5));
 527                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_logoff_time));
 528                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 529                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 530                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->primary));
 531                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->sequence_num));
 532                 NDR_CHECK(ndr_push_samr_DomainServerState(ndr, NDR_SCALARS, r->domain_server_state));
 533                 NDR_CHECK(ndr_push_samr_Role(ndr, NDR_SCALARS, r->role));
 534                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
 535                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_users));
 536                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_groups));
 537                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_aliases));
 538         }
 539         if (ndr_flags & NDR_BUFFERS) {
 540                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 541                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 542                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 543         }
 544         return NDR_ERR_SUCCESS;
 545 }
 546
 547 static enum ndr_err_code ndr_pull_samr_DomGeneralInformation(struct ndr_pull *ndr, int ndr_flags, struct samr_DomGeneralInformation *r)
 548 {
 549         if (ndr_flags & NDR_SCALARS) {
 550                 NDR_CHECK(ndr_pull_align(ndr, 5));
 551                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_logoff_time));
 552                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 553                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 554                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->primary));
 555                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->sequence_num));
 556                 NDR_CHECK(ndr_pull_samr_DomainServerState(ndr, NDR_SCALARS, &r->domain_server_state));
 557                 NDR_CHECK(ndr_pull_samr_Role(ndr, NDR_SCALARS, &r->role));
 558                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
 559                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_users));
 560                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_groups));
 561                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_aliases));
 562         }
 563         if (ndr_flags & NDR_BUFFERS) {
 564                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 565                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 566                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 567         }
 568         return NDR_ERR_SUCCESS;
 569 }
 570
 571 _PUBLIC_ void ndr_print_samr_DomGeneralInformation(struct ndr_print *ndr, const char *name, const struct samr_DomGeneralInformation *r)
 572 {
 573         ndr_print_struct(ndr, name, "samr_DomGeneralInformation");
 574         ndr->depth++;
 575         ndr_print_NTTIME(ndr, "force_logoff_time", r->force_logoff_time);
 576         ndr_print_lsa_String(ndr, "oem_information", &r->oem_information);
 577         ndr_print_lsa_String(ndr, "domain_name", &r->domain_name);
 578         ndr_print_lsa_String(ndr, "primary", &r->primary);
 579         ndr_print_udlong(ndr, "sequence_num", r->sequence_num);
 580         ndr_print_samr_DomainServerState(ndr, "domain_server_state", r->domain_server_state);
 581         ndr_print_samr_Role(ndr, "role", r->role);
 582         ndr_print_uint32(ndr, "unknown3", r->unknown3);
 583         ndr_print_uint32(ndr, "num_users", r->num_users);
 584         ndr_print_uint32(ndr, "num_groups", r->num_groups);
 585         ndr_print_uint32(ndr, "num_aliases", r->num_aliases);
 586         ndr->depth--;
 587 }
 588
 589 static enum ndr_err_code ndr_push_samr_DomInfo3(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo3 *r)
 590 {
 591         if (ndr_flags & NDR_SCALARS) {
 592                 NDR_CHECK(ndr_push_align(ndr, 4));
 593                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_logoff_time));
 594         }
 595         if (ndr_flags & NDR_BUFFERS) {
 596         }
 597         return NDR_ERR_SUCCESS;
 598 }
 599
 600 static enum ndr_err_code ndr_pull_samr_DomInfo3(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo3 *r)
 601 {
 602         if (ndr_flags & NDR_SCALARS) {
 603                 NDR_CHECK(ndr_pull_align(ndr, 4));
 604                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_logoff_time));
 605         }
 606         if (ndr_flags & NDR_BUFFERS) {
 607         }
 608         return NDR_ERR_SUCCESS;
 609 }
 610
 611 _PUBLIC_ void ndr_print_samr_DomInfo3(struct ndr_print *ndr, const char *name, const struct samr_DomInfo3 *r)
 612 {
 613         ndr_print_struct(ndr, name, "samr_DomInfo3");
 614         ndr->depth++;
 615         ndr_print_NTTIME(ndr, "force_logoff_time", r->force_logoff_time);
 616         ndr->depth--;
 617 }
 618
 619 static enum ndr_err_code ndr_push_samr_DomOEMInformation(struct ndr_push *ndr, int ndr_flags, const struct samr_DomOEMInformation *r)
 620 {
 621         if (ndr_flags & NDR_SCALARS) {
 622                 NDR_CHECK(ndr_push_align(ndr, 5));
 623                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 624         }
 625         if (ndr_flags & NDR_BUFFERS) {
 626                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 627         }
 628         return NDR_ERR_SUCCESS;
 629 }
 630
 631 static enum ndr_err_code ndr_pull_samr_DomOEMInformation(struct ndr_pull *ndr, int ndr_flags, struct samr_DomOEMInformation *r)
 632 {
 633         if (ndr_flags & NDR_SCALARS) {
 634                 NDR_CHECK(ndr_pull_align(ndr, 5));
 635                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 636         }
 637         if (ndr_flags & NDR_BUFFERS) {
 638                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 639         }
 640         return NDR_ERR_SUCCESS;
 641 }
 642
 643 _PUBLIC_ void ndr_print_samr_DomOEMInformation(struct ndr_print *ndr, const char *name, const struct samr_DomOEMInformation *r)
 644 {
 645         ndr_print_struct(ndr, name, "samr_DomOEMInformation");
 646         ndr->depth++;
 647         ndr_print_lsa_String(ndr, "oem_information", &r->oem_information);
 648         ndr->depth--;
 649 }
 650
 651 static enum ndr_err_code ndr_push_samr_DomInfo5(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo5 *r)
 652 {
 653         if (ndr_flags & NDR_SCALARS) {
 654                 NDR_CHECK(ndr_push_align(ndr, 5));
 655                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 656         }
 657         if (ndr_flags & NDR_BUFFERS) {
 658                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 659         }
 660         return NDR_ERR_SUCCESS;
 661 }
 662
 663 static enum ndr_err_code ndr_pull_samr_DomInfo5(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo5 *r)
 664 {
 665         if (ndr_flags & NDR_SCALARS) {
 666                 NDR_CHECK(ndr_pull_align(ndr, 5));
 667                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 668         }
 669         if (ndr_flags & NDR_BUFFERS) {
 670                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 671         }
 672         return NDR_ERR_SUCCESS;
 673 }
 674
 675 _PUBLIC_ void ndr_print_samr_DomInfo5(struct ndr_print *ndr, const char *name, const struct samr_DomInfo5 *r)
 676 {
 677         ndr_print_struct(ndr, name, "samr_DomInfo5");
 678         ndr->depth++;
 679         ndr_print_lsa_String(ndr, "domain_name", &r->domain_name);
 680         ndr->depth--;
 681 }
 682
 683 static enum ndr_err_code ndr_push_samr_DomInfo6(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo6 *r)
 684 {
 685         if (ndr_flags & NDR_SCALARS) {
 686                 NDR_CHECK(ndr_push_align(ndr, 5));
 687                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->primary));
 688         }
 689         if (ndr_flags & NDR_BUFFERS) {
 690                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 691         }
 692         return NDR_ERR_SUCCESS;
 693 }
 694
 695 static enum ndr_err_code ndr_pull_samr_DomInfo6(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo6 *r)
 696 {
 697         if (ndr_flags & NDR_SCALARS) {
 698                 NDR_CHECK(ndr_pull_align(ndr, 5));
 699                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->primary));
 700         }
 701         if (ndr_flags & NDR_BUFFERS) {
 702                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 703         }
 704         return NDR_ERR_SUCCESS;
 705 }
 706
 707 _PUBLIC_ void ndr_print_samr_DomInfo6(struct ndr_print *ndr, const char *name, const struct samr_DomInfo6 *r)
 708 {
 709         ndr_print_struct(ndr, name, "samr_DomInfo6");
 710         ndr->depth++;
 711         ndr_print_lsa_String(ndr, "primary", &r->primary);
 712         ndr->depth--;
 713 }
 714
 715 static enum ndr_err_code ndr_push_samr_DomInfo7(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo7 *r)
 716 {
 717         if (ndr_flags & NDR_SCALARS) {
 718                 NDR_CHECK(ndr_push_align(ndr, 4));
 719                 NDR_CHECK(ndr_push_samr_Role(ndr, NDR_SCALARS, r->role));
 720         }
 721         if (ndr_flags & NDR_BUFFERS) {
 722         }
 723         return NDR_ERR_SUCCESS;
 724 }
 725
 726 static enum ndr_err_code ndr_pull_samr_DomInfo7(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo7 *r)
 727 {
 728         if (ndr_flags & NDR_SCALARS) {
 729                 NDR_CHECK(ndr_pull_align(ndr, 4));
 730                 NDR_CHECK(ndr_pull_samr_Role(ndr, NDR_SCALARS, &r->role));
 731         }
 732         if (ndr_flags & NDR_BUFFERS) {
 733         }
 734         return NDR_ERR_SUCCESS;
 735 }
 736
 737 _PUBLIC_ void ndr_print_samr_DomInfo7(struct ndr_print *ndr, const char *name, const struct samr_DomInfo7 *r)
 738 {
 739         ndr_print_struct(ndr, name, "samr_DomInfo7");
 740         ndr->depth++;
 741         ndr_print_samr_Role(ndr, "role", r->role);
 742         ndr->depth--;
 743 }
 744
 745 static enum ndr_err_code ndr_push_samr_DomInfo8(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo8 *r)
 746 {
 747         if (ndr_flags & NDR_SCALARS) {
 748                 NDR_CHECK(ndr_push_align(ndr, 8));
 749                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->sequence_num));
 750                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->domain_create_time));
 751         }
 752         if (ndr_flags & NDR_BUFFERS) {
 753         }
 754         return NDR_ERR_SUCCESS;
 755 }
 756
 757 static enum ndr_err_code ndr_pull_samr_DomInfo8(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo8 *r)
 758 {
 759         if (ndr_flags & NDR_SCALARS) {
 760                 NDR_CHECK(ndr_pull_align(ndr, 8));
 761                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->sequence_num));
 762                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->domain_create_time));
 763         }
 764         if (ndr_flags & NDR_BUFFERS) {
 765         }
 766         return NDR_ERR_SUCCESS;
 767 }
 768
 769 _PUBLIC_ void ndr_print_samr_DomInfo8(struct ndr_print *ndr, const char *name, const struct samr_DomInfo8 *r)
 770 {
 771         ndr_print_struct(ndr, name, "samr_DomInfo8");
 772         ndr->depth++;
 773         ndr_print_hyper(ndr, "sequence_num", r->sequence_num);
 774         ndr_print_NTTIME(ndr, "domain_create_time", r->domain_create_time);
 775         ndr->depth--;
 776 }
 777
 778 static enum ndr_err_code ndr_push_samr_DomInfo9(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo9 *r)
 779 {
 780         if (ndr_flags & NDR_SCALARS) {
 781                 NDR_CHECK(ndr_push_align(ndr, 4));
 782                 NDR_CHECK(ndr_push_samr_DomainServerState(ndr, NDR_SCALARS, r->domain_server_state));
 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         if (ndr_flags & NDR_SCALARS) {
 792                 NDR_CHECK(ndr_pull_align(ndr, 4));
 793                 NDR_CHECK(ndr_pull_samr_DomainServerState(ndr, NDR_SCALARS, &r->domain_server_state));
 794         }
 795         if (ndr_flags & NDR_BUFFERS) {
 796         }
 797         return NDR_ERR_SUCCESS;
 798 }
 799
 800 _PUBLIC_ void ndr_print_samr_DomInfo9(struct ndr_print *ndr, const char *name, const struct samr_DomInfo9 *r)
 801 {
 802         ndr_print_struct(ndr, name, "samr_DomInfo9");
 803         ndr->depth++;
 804         ndr_print_samr_DomainServerState(ndr, "domain_server_state", r->domain_server_state);
 805         ndr->depth--;
 806 }
 807
 808 static enum ndr_err_code ndr_push_samr_DomGeneralInformation2(struct ndr_push *ndr, int ndr_flags, const struct samr_DomGeneralInformation2 *r)
 809 {
 810         if (ndr_flags & NDR_SCALARS) {
 811                 NDR_CHECK(ndr_push_align(ndr, 8));
 812                 NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 813                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_duration));
 814                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_window));
 815                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lockout_threshold));
 816         }
 817         if (ndr_flags & NDR_BUFFERS) {
 818                 NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
 819         }
 820         return NDR_ERR_SUCCESS;
 821 }
 822
 823 static enum ndr_err_code ndr_pull_samr_DomGeneralInformation2(struct ndr_pull *ndr, int ndr_flags, struct samr_DomGeneralInformation2 *r)
 824 {
 825         if (ndr_flags & NDR_SCALARS) {
 826                 NDR_CHECK(ndr_pull_align(ndr, 8));
 827                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 828                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_duration));
 829                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_window));
 830                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lockout_threshold));
 831         }
 832         if (ndr_flags & NDR_BUFFERS) {
 833                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
 834         }
 835         return NDR_ERR_SUCCESS;
 836 }
 837
 838 _PUBLIC_ void ndr_print_samr_DomGeneralInformation2(struct ndr_print *ndr, const char *name, const struct samr_DomGeneralInformation2 *r)
 839 {
 840         ndr_print_struct(ndr, name, "samr_DomGeneralInformation2");
 841         ndr->depth++;
 842         ndr_print_samr_DomGeneralInformation(ndr, "general", &r->general);
 843         ndr_print_hyper(ndr, "lockout_duration", r->lockout_duration);
 844         ndr_print_hyper(ndr, "lockout_window", r->lockout_window);
 845         ndr_print_uint16(ndr, "lockout_threshold", r->lockout_threshold);
 846         ndr->depth--;
 847 }
 848
 849 static enum ndr_err_code ndr_push_samr_DomInfo12(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo12 *r)
 850 {
 851         if (ndr_flags & NDR_SCALARS) {
 852                 NDR_CHECK(ndr_push_align(ndr, 8));
 853                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_duration));
 854                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_window));
 855                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lockout_threshold));
 856         }
 857         if (ndr_flags & NDR_BUFFERS) {
 858         }
 859         return NDR_ERR_SUCCESS;
 860 }
 861
 862 static enum ndr_err_code ndr_pull_samr_DomInfo12(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo12 *r)
 863 {
 864         if (ndr_flags & NDR_SCALARS) {
 865                 NDR_CHECK(ndr_pull_align(ndr, 8));
 866                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_duration));
 867                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_window));
 868                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lockout_threshold));
 869         }
 870         if (ndr_flags & NDR_BUFFERS) {
 871         }
 872         return NDR_ERR_SUCCESS;
 873 }
 874
 875 _PUBLIC_ void ndr_print_samr_DomInfo12(struct ndr_print *ndr, const char *name, const struct samr_DomInfo12 *r)
 876 {
 877         ndr_print_struct(ndr, name, "samr_DomInfo12");
 878         ndr->depth++;
 879         ndr_print_hyper(ndr, "lockout_duration", r->lockout_duration);
 880         ndr_print_hyper(ndr, "lockout_window", r->lockout_window);
 881         ndr_print_uint16(ndr, "lockout_threshold", r->lockout_threshold);
 882         ndr->depth--;
 883 }
 884
 885 static enum ndr_err_code ndr_push_samr_DomInfo13(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo13 *r)
 886 {
 887         if (ndr_flags & NDR_SCALARS) {
 888                 NDR_CHECK(ndr_push_align(ndr, 8));
 889                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->sequence_num));
 890                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->domain_create_time));
 891                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->modified_count_at_last_promotion));
 892         }
 893         if (ndr_flags & NDR_BUFFERS) {
 894         }
 895         return NDR_ERR_SUCCESS;
 896 }
 897
 898 static enum ndr_err_code ndr_pull_samr_DomInfo13(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo13 *r)
 899 {
 900         if (ndr_flags & NDR_SCALARS) {
 901                 NDR_CHECK(ndr_pull_align(ndr, 8));
 902                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->sequence_num));
 903                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->domain_create_time));
 904                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->modified_count_at_last_promotion));
 905         }
 906         if (ndr_flags & NDR_BUFFERS) {
 907         }
 908         return NDR_ERR_SUCCESS;
 909 }
 910
 911 _PUBLIC_ void ndr_print_samr_DomInfo13(struct ndr_print *ndr, const char *name, const struct samr_DomInfo13 *r)
 912 {
 913         ndr_print_struct(ndr, name, "samr_DomInfo13");
 914         ndr->depth++;
 915         ndr_print_hyper(ndr, "sequence_num", r->sequence_num);
 916         ndr_print_NTTIME(ndr, "domain_create_time", r->domain_create_time);
 917         ndr_print_hyper(ndr, "modified_count_at_last_promotion", r->modified_count_at_last_promotion);
 918         ndr->depth--;
 919 }
 920
 921 static enum ndr_err_code ndr_push_samr_DomainInfo(struct ndr_push *ndr, int ndr_flags, const union samr_DomainInfo *r)
 922 {
 923         if (ndr_flags & NDR_SCALARS) {
 924                 int level = ndr_push_get_switch_value(ndr, r);
 925                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
 926                 switch (level) {
 927                         case 1: {
 928                                 NDR_CHECK(ndr_push_samr_DomInfo1(ndr, NDR_SCALARS, &r->info1));
 929                         break; }
 930
 931                         case 2: {
 932                                 NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 933                         break; }
 934
 935                         case 3: {
 936                                 NDR_CHECK(ndr_push_samr_DomInfo3(ndr, NDR_SCALARS, &r->info3));
 937                         break; }
 938
 939                         case 4: {
 940                                 NDR_CHECK(ndr_push_samr_DomOEMInformation(ndr, NDR_SCALARS, &r->oem));
 941                         break; }
 942
 943                         case 5: {
 944                                 NDR_CHECK(ndr_push_samr_DomInfo5(ndr, NDR_SCALARS, &r->info5));
 945                         break; }
 946
 947                         case 6: {
 948                                 NDR_CHECK(ndr_push_samr_DomInfo6(ndr, NDR_SCALARS, &r->info6));
 949                         break; }
 950
 951                         case 7: {
 952                                 NDR_CHECK(ndr_push_samr_DomInfo7(ndr, NDR_SCALARS, &r->info7));
 953                         break; }
 954
 955                         case 8: {
 956                                 NDR_CHECK(ndr_push_samr_DomInfo8(ndr, NDR_SCALARS, &r->info8));
 957                         break; }
 958
 959                         case 9: {
 960                                 NDR_CHECK(ndr_push_samr_DomInfo9(ndr, NDR_SCALARS, &r->info9));
 961                         break; }
 962
 963                         case 11: {
 964                                 NDR_CHECK(ndr_push_samr_DomGeneralInformation2(ndr, NDR_SCALARS, &r->general2));
 965                         break; }
 966
 967                         case 12: {
 968                                 NDR_CHECK(ndr_push_samr_DomInfo12(ndr, NDR_SCALARS, &r->info12));
 969                         break; }
 970
 971                         case 13: {
 972                                 NDR_CHECK(ndr_push_samr_DomInfo13(ndr, NDR_SCALARS, &r->info13));
 973                         break; }
 974
 975                         default:
 976                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 977                 }
 978         }
 979         if (ndr_flags & NDR_BUFFERS) {
 980                 int level = ndr_push_get_switch_value(ndr, r);
 981                 switch (level) {
 982                         case 1:
 983                         break;
 984
 985                         case 2:
 986                                 NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
 987                         break;
 988
 989                         case 3:
 990                         break;
 991
 992                         case 4:
 993                                 NDR_CHECK(ndr_push_samr_DomOEMInformation(ndr, NDR_BUFFERS, &r->oem));
 994                         break;
 995
 996                         case 5:
 997                                 NDR_CHECK(ndr_push_samr_DomInfo5(ndr, NDR_BUFFERS, &r->info5));
 998                         break;
 999
1000                         case 6:
1001                                 NDR_CHECK(ndr_push_samr_DomInfo6(ndr, NDR_BUFFERS, &r->info6));
1002                         break;
1003
1004                         case 7:
1005                         break;
1006
1007                         case 8:
1008                         break;
1009
1010                         case 9:
1011                         break;
1012
1013                         case 11:
1014                                 NDR_CHECK(ndr_push_samr_DomGeneralInformation2(ndr, NDR_BUFFERS, &r->general2));
1015                         break;
1016
1017                         case 12:
1018                         break;
1019
1020                         case 13:
1021                         break;
1022
1023                         default:
1024                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1025                 }
1026         }
1027         return NDR_ERR_SUCCESS;
1028 }
1029
1030 static enum ndr_err_code ndr_pull_samr_DomainInfo(struct ndr_pull *ndr, int ndr_flags, union samr_DomainInfo *r)
1031 {
1032         int level;
1033         uint16_t _level;
1034         level = ndr_pull_get_switch_value(ndr, r);
1035         if (ndr_flags & NDR_SCALARS) {
1036                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
1037                 if (_level != level) {
1038                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1039                 }
1040                 switch (level) {
1041                         case 1: {
1042                                 NDR_CHECK(ndr_pull_samr_DomInfo1(ndr, NDR_SCALARS, &r->info1));
1043                         break; }
1044
1045                         case 2: {
1046                                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
1047                         break; }
1048
1049                         case 3: {
1050                                 NDR_CHECK(ndr_pull_samr_DomInfo3(ndr, NDR_SCALARS, &r->info3));
1051                         break; }
1052
1053                         case 4: {
1054                                 NDR_CHECK(ndr_pull_samr_DomOEMInformation(ndr, NDR_SCALARS, &r->oem));
1055                         break; }
1056
1057                         case 5: {
1058                                 NDR_CHECK(ndr_pull_samr_DomInfo5(ndr, NDR_SCALARS, &r->info5));
1059                         break; }
1060
1061                         case 6: {
1062                                 NDR_CHECK(ndr_pull_samr_DomInfo6(ndr, NDR_SCALARS, &r->info6));
1063                         break; }
1064
1065                         case 7: {
1066                                 NDR_CHECK(ndr_pull_samr_DomInfo7(ndr, NDR_SCALARS, &r->info7));
1067                         break; }
1068
1069                         case 8: {
1070                                 NDR_CHECK(ndr_pull_samr_DomInfo8(ndr, NDR_SCALARS, &r->info8));
1071                         break; }
1072
1073                         case 9: {
1074                                 NDR_CHECK(ndr_pull_samr_DomInfo9(ndr, NDR_SCALARS, &r->info9));
1075                         break; }
1076
1077                         case 11: {
1078                                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation2(ndr, NDR_SCALARS, &r->general2));
1079                         break; }
1080
1081                         case 12: {
1082                                 NDR_CHECK(ndr_pull_samr_DomInfo12(ndr, NDR_SCALARS, &r->info12));
1083                         break; }
1084
1085                         case 13: {
1086                                 NDR_CHECK(ndr_pull_samr_DomInfo13(ndr, NDR_SCALARS, &r->info13));
1087                         break; }
1088
1089                         default:
1090                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1091                 }
1092         }
1093         if (ndr_flags & NDR_BUFFERS) {
1094                 switch (level) {
1095                         case 1:
1096                         break;
1097
1098                         case 2:
1099                                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
1100                         break;
1101
1102                         case 3:
1103                         break;
1104
1105                         case 4:
1106                                 NDR_CHECK(ndr_pull_samr_DomOEMInformation(ndr, NDR_BUFFERS, &r->oem));
1107                         break;
1108
1109                         case 5:
1110                                 NDR_CHECK(ndr_pull_samr_DomInfo5(ndr, NDR_BUFFERS, &r->info5));
1111                         break;
1112
1113                         case 6:
1114                                 NDR_CHECK(ndr_pull_samr_DomInfo6(ndr, NDR_BUFFERS, &r->info6));
1115                         break;
1116
1117                         case 7:
1118                         break;
1119
1120                         case 8:
1121                         break;
1122
1123                         case 9:
1124                         break;
1125
1126                         case 11:
1127                                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation2(ndr, NDR_BUFFERS, &r->general2));
1128                         break;
1129
1130                         case 12:
1131                         break;
1132
1133                         case 13:
1134                         break;
1135
1136                         default:
1137                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1138                 }
1139         }
1140         return NDR_ERR_SUCCESS;
1141 }
1142
1143 _PUBLIC_ void ndr_print_samr_DomainInfo(struct ndr_print *ndr, const char *name, const union samr_DomainInfo *r)
1144 {
1145         int level;
1146         level = ndr_print_get_switch_value(ndr, r);
1147         ndr_print_union(ndr, name, level, "samr_DomainInfo");
1148         switch (level) {
1149                 case 1:
1150                         ndr_print_samr_DomInfo1(ndr, "info1", &r->info1);
1151                 break;
1152
1153                 case 2:
1154                         ndr_print_samr_DomGeneralInformation(ndr, "general", &r->general);
1155                 break;
1156
1157                 case 3:
1158                         ndr_print_samr_DomInfo3(ndr, "info3", &r->info3);
1159                 break;
1160
1161                 case 4:
1162                         ndr_print_samr_DomOEMInformation(ndr, "oem", &r->oem);
1163                 break;
1164
1165                 case 5:
1166                         ndr_print_samr_DomInfo5(ndr, "info5", &r->info5);
1167                 break;
1168
1169                 case 6:
1170                         ndr_print_samr_DomInfo6(ndr, "info6", &r->info6);
1171                 break;
1172
1173                 case 7:
1174                         ndr_print_samr_DomInfo7(ndr, "info7", &r->info7);
1175                 break;
1176
1177                 case 8:
1178                         ndr_print_samr_DomInfo8(ndr, "info8", &r->info8);
1179                 break;
1180
1181                 case 9:
1182                         ndr_print_samr_DomInfo9(ndr, "info9", &r->info9);
1183                 break;
1184
1185                 case 11:
1186                         ndr_print_samr_DomGeneralInformation2(ndr, "general2", &r->general2);
1187                 break;
1188
1189                 case 12:
1190                         ndr_print_samr_DomInfo12(ndr, "info12", &r->info12);
1191                 break;
1192
1193                 case 13:
1194                         ndr_print_samr_DomInfo13(ndr, "info13", &r->info13);
1195                 break;
1196
1197                 default:
1198                         ndr_print_bad_level(ndr, name, level);
1199         }
1200 }
1201
1202 static enum ndr_err_code ndr_push_samr_Ids(struct ndr_push *ndr, int ndr_flags, const struct samr_Ids *r)
1203 {
1204         uint32_t cntr_ids_1;
1205         if (ndr_flags & NDR_SCALARS) {
1206                 NDR_CHECK(ndr_push_align(ndr, 5));
1207                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1208                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ids));
1209         }
1210         if (ndr_flags & NDR_BUFFERS) {
1211                 if (r->ids) {
1212                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
1213                         for (cntr_ids_1 = 0; cntr_ids_1 < r->count; cntr_ids_1++) {
1214                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ids[cntr_ids_1]));
1215                         }
1216                 }
1217         }
1218         return NDR_ERR_SUCCESS;
1219 }
1220
1221 static enum ndr_err_code ndr_pull_samr_Ids(struct ndr_pull *ndr, int ndr_flags, struct samr_Ids *r)
1222 {
1223         uint32_t _ptr_ids;
1224         uint32_t cntr_ids_1;
1225         TALLOC_CTX *_mem_save_ids_0;
1226         TALLOC_CTX *_mem_save_ids_1;
1227         if (ndr_flags & NDR_SCALARS) {
1228                 NDR_CHECK(ndr_pull_align(ndr, 5));
1229                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1230                 if (r->count > 1024) {
1231                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1232                 }
1233                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ids));
1234                 if (_ptr_ids) {
1235                         NDR_PULL_ALLOC(ndr, r->ids);
1236                 } else {
1237                         r->ids = NULL;
1238                 }
1239         }
1240         if (ndr_flags & NDR_BUFFERS) {
1241                 if (r->ids) {
1242                         _mem_save_ids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1243                         NDR_PULL_SET_MEM_CTX(ndr, r->ids, 0);
1244                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ids));
1245                         NDR_PULL_ALLOC_N(ndr, r->ids, ndr_get_array_size(ndr, &r->ids));
1246                         _mem_save_ids_1 = NDR_PULL_GET_MEM_CTX(ndr);
1247                         NDR_PULL_SET_MEM_CTX(ndr, r->ids, 0);
1248                         for (cntr_ids_1 = 0; cntr_ids_1 < r->count; cntr_ids_1++) {
1249                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ids[cntr_ids_1]));
1250                         }
1251                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ids_1, 0);
1252                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ids_0, 0);
1253                 }
1254                 if (r->ids) {
1255                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->ids, r->count));
1256                 }
1257         }
1258         return NDR_ERR_SUCCESS;
1259 }
1260
1261 _PUBLIC_ void ndr_print_samr_Ids(struct ndr_print *ndr, const char *name, const struct samr_Ids *r)
1262 {
1263         uint32_t cntr_ids_1;
1264         ndr_print_struct(ndr, name, "samr_Ids");
1265         ndr->depth++;
1266         ndr_print_uint32(ndr, "count", r->count);
1267         ndr_print_ptr(ndr, "ids", r->ids);
1268         ndr->depth++;
1269         if (r->ids) {
1270                 ndr->print(ndr, "%s: ARRAY(%d)", "ids", (int)r->count);
1271                 ndr->depth++;
1272                 for (cntr_ids_1=0;cntr_ids_1<r->count;cntr_ids_1++) {
1273                         char *idx_1=NULL;
1274                         if (asprintf(&idx_1, "[%d]", cntr_ids_1) != -1) {
1275                                 ndr_print_uint32(ndr, "ids", r->ids[cntr_ids_1]);
1276                                 free(idx_1);
1277                         }
1278                 }
1279                 ndr->depth--;
1280         }
1281         ndr->depth--;
1282         ndr->depth--;
1283 }
1284
1285 _PUBLIC_ enum ndr_err_code ndr_push_samr_GroupAttrs(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1286 {
1287         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1288         return NDR_ERR_SUCCESS;
1289 }
1290
1291 _PUBLIC_ enum ndr_err_code ndr_pull_samr_GroupAttrs(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1292 {
1293         uint32_t v;
1294         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1295         *r = v;
1296         return NDR_ERR_SUCCESS;
1297 }
1298
1299 _PUBLIC_ void ndr_print_samr_GroupAttrs(struct ndr_print *ndr, const char *name, uint32_t r)
1300 {
1301         ndr_print_uint32(ndr, name, r);
1302         ndr->depth++;
1303         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_MANDATORY", SE_GROUP_MANDATORY, r);
1304         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_ENABLED_BY_DEFAULT", SE_GROUP_ENABLED_BY_DEFAULT, r);
1305         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_ENABLED", SE_GROUP_ENABLED, r);
1306         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_OWNER", SE_GROUP_OWNER, r);
1307         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_USE_FOR_DENY_ONLY", SE_GROUP_USE_FOR_DENY_ONLY, r);
1308         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_RESOURCE", SE_GROUP_RESOURCE, r);
1309         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_LOGON_ID", SE_GROUP_LOGON_ID, r);
1310         ndr->depth--;
1311 }
1312
1313 static enum ndr_err_code ndr_push_samr_GroupInfoAll(struct ndr_push *ndr, int ndr_flags, const struct samr_GroupInfoAll *r)
1314 {
1315         if (ndr_flags & NDR_SCALARS) {
1316                 NDR_CHECK(ndr_push_align(ndr, 5));
1317                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1318                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
1319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_members));
1320                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1321         }
1322         if (ndr_flags & NDR_BUFFERS) {
1323                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1324                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1325         }
1326         return NDR_ERR_SUCCESS;
1327 }
1328
1329 static enum ndr_err_code ndr_pull_samr_GroupInfoAll(struct ndr_pull *ndr, int ndr_flags, struct samr_GroupInfoAll *r)
1330 {
1331         if (ndr_flags & NDR_SCALARS) {
1332                 NDR_CHECK(ndr_pull_align(ndr, 5));
1333                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1334                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
1335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_members));
1336                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1337         }
1338         if (ndr_flags & NDR_BUFFERS) {
1339                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1340                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1341         }
1342         return NDR_ERR_SUCCESS;
1343 }
1344
1345 _PUBLIC_ void ndr_print_samr_GroupInfoAll(struct ndr_print *ndr, const char *name, const struct samr_GroupInfoAll *r)
1346 {
1347         ndr_print_struct(ndr, name, "samr_GroupInfoAll");
1348         ndr->depth++;
1349         ndr_print_lsa_String(ndr, "name", &r->name);
1350         ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);
1351         ndr_print_uint32(ndr, "num_members", r->num_members);
1352         ndr_print_lsa_String(ndr, "description", &r->description);
1353         ndr->depth--;
1354 }
1355
1356 static enum ndr_err_code ndr_push_samr_GroupInfoAttributes(struct ndr_push *ndr, int ndr_flags, const struct samr_GroupInfoAttributes *r)
1357 {
1358         if (ndr_flags & NDR_SCALARS) {
1359                 NDR_CHECK(ndr_push_align(ndr, 4));
1360                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
1361         }
1362         if (ndr_flags & NDR_BUFFERS) {
1363         }
1364         return NDR_ERR_SUCCESS;
1365 }
1366
1367 static enum ndr_err_code ndr_pull_samr_GroupInfoAttributes(struct ndr_pull *ndr, int ndr_flags, struct samr_GroupInfoAttributes *r)
1368 {
1369         if (ndr_flags & NDR_SCALARS) {
1370                 NDR_CHECK(ndr_pull_align(ndr, 4));
1371                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
1372         }
1373         if (ndr_flags & NDR_BUFFERS) {
1374         }
1375         return NDR_ERR_SUCCESS;
1376 }
1377
1378 _PUBLIC_ void ndr_print_samr_GroupInfoAttributes(struct ndr_print *ndr, const char *name, const struct samr_GroupInfoAttributes *r)
1379 {
1380         ndr_print_struct(ndr, name, "samr_GroupInfoAttributes");
1381         ndr->depth++;
1382         ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);
1383         ndr->depth--;
1384 }
1385
1386 static enum ndr_err_code ndr_push_samr_GroupInfoEnum(struct ndr_push *ndr, int ndr_flags, enum samr_GroupInfoEnum r)
1387 {
1388         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
1389         return NDR_ERR_SUCCESS;
1390 }
1391
1392 static enum ndr_err_code ndr_pull_samr_GroupInfoEnum(struct ndr_pull *ndr, int ndr_flags, enum samr_GroupInfoEnum *r)
1393 {
1394         uint16_t v;
1395         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
1396         *r = v;
1397         return NDR_ERR_SUCCESS;
1398 }
1399
1400 _PUBLIC_ void ndr_print_samr_GroupInfoEnum(struct ndr_print *ndr, const char *name, enum samr_GroupInfoEnum r)
1401 {
1402         const char *val = NULL;
1403
1404         switch (r) {
1405                 case GROUPINFOALL: val = "GROUPINFOALL"; break;
1406                 case GROUPINFONAME: val = "GROUPINFONAME"; break;
1407                 case GROUPINFOATTRIBUTES: val = "GROUPINFOATTRIBUTES"; break;
1408                 case GROUPINFODESCRIPTION: val = "GROUPINFODESCRIPTION"; break;
1409                 case GROUPINFOALL2: val = "GROUPINFOALL2"; break;
1410         }
1411         ndr_print_enum(ndr, name, "ENUM", val, r);
1412 }
1413
1414 static enum ndr_err_code ndr_push_samr_GroupInfo(struct ndr_push *ndr, int ndr_flags, const union samr_GroupInfo *r)
1415 {
1416         if (ndr_flags & NDR_SCALARS) {
1417                 int level = ndr_push_get_switch_value(ndr, r);
1418                 NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, level));
1419                 switch (level) {
1420                         case GROUPINFOALL: {
1421                                 NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all));
1422                         break; }
1423
1424                         case GROUPINFONAME: {
1425                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1426                         break; }
1427
1428                         case GROUPINFOATTRIBUTES: {
1429                                 NDR_CHECK(ndr_push_samr_GroupInfoAttributes(ndr, NDR_SCALARS, &r->attributes));
1430                         break; }
1431
1432                         case GROUPINFODESCRIPTION: {
1433                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1434                         break; }
1435
1436                         case GROUPINFOALL2: {
1437                                 NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all2));
1438                         break; }
1439
1440                         default:
1441                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1442                 }
1443         }
1444         if (ndr_flags & NDR_BUFFERS) {
1445                 int level = ndr_push_get_switch_value(ndr, r);
1446                 switch (level) {
1447                         case GROUPINFOALL:
1448                                 NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all));
1449                         break;
1450
1451                         case GROUPINFONAME:
1452                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1453                         break;
1454
1455                         case GROUPINFOATTRIBUTES:
1456                         break;
1457
1458                         case GROUPINFODESCRIPTION:
1459                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1460                         break;
1461
1462                         case GROUPINFOALL2:
1463                                 NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all2));
1464                         break;
1465
1466                         default:
1467                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1468                 }
1469         }
1470         return NDR_ERR_SUCCESS;
1471 }
1472
1473 static enum ndr_err_code ndr_pull_samr_GroupInfo(struct ndr_pull *ndr, int ndr_flags, union samr_GroupInfo *r)
1474 {
1475         int level;
1476         uint16_t _level;
1477         level = ndr_pull_get_switch_value(ndr, r);
1478         if (ndr_flags & NDR_SCALARS) {
1479                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
1480                 if (_level != level) {
1481                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1482                 }
1483                 switch (level) {
1484                         case GROUPINFOALL: {
1485                                 NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all));
1486                         break; }
1487
1488                         case GROUPINFONAME: {
1489                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1490                         break; }
1491
1492                         case GROUPINFOATTRIBUTES: {
1493                                 NDR_CHECK(ndr_pull_samr_GroupInfoAttributes(ndr, NDR_SCALARS, &r->attributes));
1494                         break; }
1495
1496                         case GROUPINFODESCRIPTION: {
1497                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1498                         break; }
1499
1500                         case GROUPINFOALL2: {
1501                                 NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all2));
1502                         break; }
1503
1504                         default:
1505                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1506                 }
1507         }
1508         if (ndr_flags & NDR_BUFFERS) {
1509                 switch (level) {
1510                         case GROUPINFOALL:
1511                                 NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all));
1512                         break;
1513
1514                         case GROUPINFONAME:
1515                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1516                         break;
1517
1518                         case GROUPINFOATTRIBUTES:
1519                         break;
1520
1521                         case GROUPINFODESCRIPTION:
1522                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1523                         break;
1524
1525                         case GROUPINFOALL2:
1526                                 NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all2));
1527                         break;
1528
1529                         default:
1530                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1531                 }
1532         }
1533         return NDR_ERR_SUCCESS;
1534 }
1535
1536 _PUBLIC_ void ndr_print_samr_GroupInfo(struct ndr_print *ndr, const char *name, const union samr_GroupInfo *r)
1537 {
1538         int level;
1539         level = ndr_print_get_switch_value(ndr, r);
1540         ndr_print_union(ndr, name, level, "samr_GroupInfo");
1541         switch (level) {
1542                 case GROUPINFOALL:
1543                         ndr_print_samr_GroupInfoAll(ndr, "all", &r->all);
1544                 break;
1545
1546                 case GROUPINFONAME:
1547                         ndr_print_lsa_String(ndr, "name", &r->name);
1548                 break;
1549
1550                 case GROUPINFOATTRIBUTES:
1551                         ndr_print_samr_GroupInfoAttributes(ndr, "attributes", &r->attributes);
1552                 break;
1553
1554                 case GROUPINFODESCRIPTION:
1555                         ndr_print_lsa_String(ndr, "description", &r->description);
1556                 break;
1557
1558                 case GROUPINFOALL2:
1559                         ndr_print_samr_GroupInfoAll(ndr, "all2", &r->all2);
1560                 break;
1561
1562                 default:
1563                         ndr_print_bad_level(ndr, name, level);
1564         }
1565 }
1566
1567 static enum ndr_err_code ndr_push_samr_RidTypeArray(struct ndr_push *ndr, int ndr_flags, const struct samr_RidTypeArray *r)
1568 {
1569         uint32_t cntr_rids_1;
1570         uint32_t cntr_types_1;
1571         if (ndr_flags & NDR_SCALARS) {
1572                 NDR_CHECK(ndr_push_align(ndr, 5));
1573                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1574                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->rids));
1575                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
1576         }
1577         if (ndr_flags & NDR_BUFFERS) {
1578                 if (r->rids) {
1579                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
1580                         for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {
1581                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rids[cntr_rids_1]));
1582                         }
1583                 }
1584                 if (r->types) {
1585                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
1586                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
1587                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->types[cntr_types_1]));
1588                         }
1589                 }
1590         }
1591         return NDR_ERR_SUCCESS;
1592 }
1593
1594 static enum ndr_err_code ndr_pull_samr_RidTypeArray(struct ndr_pull *ndr, int ndr_flags, struct samr_RidTypeArray *r)
1595 {
1596         uint32_t _ptr_rids;
1597         uint32_t cntr_rids_1;
1598         TALLOC_CTX *_mem_save_rids_0;
1599         TALLOC_CTX *_mem_save_rids_1;
1600         uint32_t _ptr_types;
1601         uint32_t cntr_types_1;
1602         TALLOC_CTX *_mem_save_types_0;
1603         TALLOC_CTX *_mem_save_types_1;
1604         if (ndr_flags & NDR_SCALARS) {
1605                 NDR_CHECK(ndr_pull_align(ndr, 5));
1606                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1607                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
1608                 if (_ptr_rids) {
1609                         NDR_PULL_ALLOC(ndr, r->rids);
1610                 } else {
1611                         r->rids = NULL;
1612                 }
1613                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
1614                 if (_ptr_types) {
1615                         NDR_PULL_ALLOC(ndr, r->types);
1616                 } else {
1617                         r->types = NULL;
1618                 }
1619         }
1620         if (ndr_flags & NDR_BUFFERS) {
1621                 if (r->rids) {
1622                         _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1623                         NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
1624                         NDR_CHECK(ndr_pull_array_size(ndr, &r->rids));
1625                         NDR_PULL_ALLOC_N(ndr, r->rids, ndr_get_array_size(ndr, &r->rids));
1626                         _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
1627                         NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
1628                         for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {
1629                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));
1630                         }
1631                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
1632                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
1633                 }
1634                 if (r->types) {
1635                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
1636                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
1637                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
1638                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
1639                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
1640                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
1641                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
1642                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
1643                         }
1644                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
1645                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
1646                 }
1647                 if (r->rids) {
1648                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->rids, r->count));
1649                 }
1650                 if (r->types) {
1651                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
1652                 }
1653         }
1654         return NDR_ERR_SUCCESS;
1655 }
1656
1657 _PUBLIC_ void ndr_print_samr_RidTypeArray(struct ndr_print *ndr, const char *name, const struct samr_RidTypeArray *r)
1658 {
1659         uint32_t cntr_rids_1;
1660         uint32_t cntr_types_1;
1661         ndr_print_struct(ndr, name, "samr_RidTypeArray");
1662         ndr->depth++;
1663         ndr_print_uint32(ndr, "count", r->count);
1664         ndr_print_ptr(ndr, "rids", r->rids);
1665         ndr->depth++;
1666         if (r->rids) {
1667                 ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->count);
1668                 ndr->depth++;
1669                 for (cntr_rids_1=0;cntr_rids_1<r->count;cntr_rids_1++) {
1670                         char *idx_1=NULL;
1671                         if (asprintf(&idx_1, "[%d]", cntr_rids_1) != -1) {
1672                                 ndr_print_uint32(ndr, "rids", r->rids[cntr_rids_1]);
1673                                 free(idx_1);
1674                         }
1675                 }
1676                 ndr->depth--;
1677         }
1678         ndr->depth--;
1679         ndr_print_ptr(ndr, "types", r->types);
1680         ndr->depth++;
1681         if (r->types) {
1682                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
1683                 ndr->depth++;
1684                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
1685                         char *idx_1=NULL;
1686                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
1687                                 ndr_print_uint32(ndr, "types", r->types[cntr_types_1]);
1688                                 free(idx_1);
1689                         }
1690                 }
1691                 ndr->depth--;
1692         }
1693         ndr->depth--;
1694         ndr->depth--;
1695 }
1696
1697 static enum ndr_err_code ndr_push_samr_AliasInfoAll(struct ndr_push *ndr, int ndr_flags, const struct samr_AliasInfoAll *r)
1698 {
1699         if (ndr_flags & NDR_SCALARS) {
1700                 NDR_CHECK(ndr_push_align(ndr, 5));
1701                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1702                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_members));
1703                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1704         }
1705         if (ndr_flags & NDR_BUFFERS) {
1706                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1707                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1708         }
1709         return NDR_ERR_SUCCESS;
1710 }
1711
1712 static enum ndr_err_code ndr_pull_samr_AliasInfoAll(struct ndr_pull *ndr, int ndr_flags, struct samr_AliasInfoAll *r)
1713 {
1714         if (ndr_flags & NDR_SCALARS) {
1715                 NDR_CHECK(ndr_pull_align(ndr, 5));
1716                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_members));
1718                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1719         }
1720         if (ndr_flags & NDR_BUFFERS) {
1721                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1722                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1723         }
1724         return NDR_ERR_SUCCESS;
1725 }
1726
1727 _PUBLIC_ void ndr_print_samr_AliasInfoAll(struct ndr_print *ndr, const char *name, const struct samr_AliasInfoAll *r)
1728 {
1729         ndr_print_struct(ndr, name, "samr_AliasInfoAll");
1730         ndr->depth++;
1731         ndr_print_lsa_String(ndr, "name", &r->name);
1732         ndr_print_uint32(ndr, "num_members", r->num_members);
1733         ndr_print_lsa_String(ndr, "description", &r->description);
1734         ndr->depth--;
1735 }
1736
1737 static enum ndr_err_code ndr_push_samr_AliasInfoEnum(struct ndr_push *ndr, int ndr_flags, enum samr_AliasInfoEnum r)
1738 {
1739         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
1740         return NDR_ERR_SUCCESS;
1741 }
1742
1743 static enum ndr_err_code ndr_pull_samr_AliasInfoEnum(struct ndr_pull *ndr, int ndr_flags, enum samr_AliasInfoEnum *r)
1744 {
1745         uint16_t v;
1746         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
1747         *r = v;
1748         return NDR_ERR_SUCCESS;
1749 }
1750
1751 _PUBLIC_ void ndr_print_samr_AliasInfoEnum(struct ndr_print *ndr, const char *name, enum samr_AliasInfoEnum r)
1752 {
1753         const char *val = NULL;
1754
1755         switch (r) {
1756                 case ALIASINFOALL: val = "ALIASINFOALL"; break;
1757                 case ALIASINFONAME: val = "ALIASINFONAME"; break;
1758                 case ALIASINFODESCRIPTION: val = "ALIASINFODESCRIPTION"; break;
1759         }
1760         ndr_print_enum(ndr, name, "ENUM", val, r);
1761 }
1762
1763 static enum ndr_err_code ndr_push_samr_AliasInfo(struct ndr_push *ndr, int ndr_flags, const union samr_AliasInfo *r)
1764 {
1765         if (ndr_flags & NDR_SCALARS) {
1766                 int level = ndr_push_get_switch_value(ndr, r);
1767                 NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, level));
1768                 switch (level) {
1769                         case ALIASINFOALL: {
1770                                 NDR_CHECK(ndr_push_samr_AliasInfoAll(ndr, NDR_SCALARS, &r->all));
1771                         break; }
1772
1773                         case ALIASINFONAME: {
1774                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1775                         break; }
1776
1777                         case ALIASINFODESCRIPTION: {
1778                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1779                         break; }
1780
1781                         default:
1782                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1783                 }
1784         }
1785         if (ndr_flags & NDR_BUFFERS) {
1786                 int level = ndr_push_get_switch_value(ndr, r);
1787                 switch (level) {
1788                         case ALIASINFOALL:
1789                                 NDR_CHECK(ndr_push_samr_AliasInfoAll(ndr, NDR_BUFFERS, &r->all));
1790                         break;
1791
1792                         case ALIASINFONAME:
1793                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1794                         break;
1795
1796                         case ALIASINFODESCRIPTION:
1797                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1798                         break;
1799
1800                         default:
1801                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1802                 }
1803         }
1804         return NDR_ERR_SUCCESS;
1805 }
1806
1807 static enum ndr_err_code ndr_pull_samr_AliasInfo(struct ndr_pull *ndr, int ndr_flags, union samr_AliasInfo *r)
1808 {
1809         int level;
1810         uint16_t _level;
1811         level = ndr_pull_get_switch_value(ndr, r);
1812         if (ndr_flags & NDR_SCALARS) {
1813                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
1814                 if (_level != level) {
1815                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1816                 }
1817                 switch (level) {
1818                         case ALIASINFOALL: {
1819                                 NDR_CHECK(ndr_pull_samr_AliasInfoAll(ndr, NDR_SCALARS, &r->all));
1820                         break; }
1821
1822                         case ALIASINFONAME: {
1823                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1824                         break; }
1825
1826                         case ALIASINFODESCRIPTION: {
1827                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1828                         break; }
1829
1830                         default:
1831                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1832                 }
1833         }
1834         if (ndr_flags & NDR_BUFFERS) {
1835                 switch (level) {
1836                         case ALIASINFOALL:
1837                                 NDR_CHECK(ndr_pull_samr_AliasInfoAll(ndr, NDR_BUFFERS, &r->all));
1838                         break;
1839
1840                         case ALIASINFONAME:
1841                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1842                         break;
1843
1844                         case ALIASINFODESCRIPTION:
1845                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1846                         break;
1847
1848                         default:
1849                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1850                 }
1851         }
1852         return NDR_ERR_SUCCESS;
1853 }
1854
1855 _PUBLIC_ void ndr_print_samr_AliasInfo(struct ndr_print *ndr, const char *name, const union samr_AliasInfo *r)
1856 {
1857         int level;
1858         level = ndr_print_get_switch_value(ndr, r);
1859         ndr_print_union(ndr, name, level, "samr_AliasInfo");
1860         switch (level) {
1861                 case ALIASINFOALL:
1862                         ndr_print_samr_AliasInfoAll(ndr, "all", &r->all);
1863                 break;
1864
1865                 case ALIASINFONAME:
1866                         ndr_print_lsa_String(ndr, "name", &r->name);
1867                 break;
1868
1869                 case ALIASINFODESCRIPTION:
1870                         ndr_print_lsa_String(ndr, "description", &r->description);
1871                 break;
1872
1873                 default:
1874                         ndr_print_bad_level(ndr, name, level);
1875         }
1876 }
1877
1878 static enum ndr_err_code ndr_push_samr_UserInfoLevel(struct ndr_push *ndr, int ndr_flags, enum samr_UserInfoLevel r)
1879 {
1880         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
1881         return NDR_ERR_SUCCESS;
1882 }
1883
1884 static enum ndr_err_code ndr_pull_samr_UserInfoLevel(struct ndr_pull *ndr, int ndr_flags, enum samr_UserInfoLevel *r)
1885 {
1886         uint16_t v;
1887         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
1888         *r = v;
1889         return NDR_ERR_SUCCESS;
1890 }
1891
1892 _PUBLIC_ void ndr_print_samr_UserInfoLevel(struct ndr_print *ndr, const char *name, enum samr_UserInfoLevel r)
1893 {
1894         const char *val = NULL;
1895
1896         switch (r) {
1897                 case UserGeneralInformation: val = "UserGeneralInformation"; break;
1898                 case UserPreferencesInformation: val = "UserPreferencesInformation"; break;
1899                 case UserLogonInformation: val = "UserLogonInformation"; break;
1900                 case UserLogonHoursInformation: val = "UserLogonHoursInformation"; break;
1901                 case UserAccountInformation: val = "UserAccountInformation"; break;
1902                 case UserNameInformation: val = "UserNameInformation"; break;
1903                 case UserAccountNameInformation: val = "UserAccountNameInformation"; break;
1904                 case UserFullNameInformation: val = "UserFullNameInformation"; break;
1905                 case UserPrimaryGroupInformation: val = "UserPrimaryGroupInformation"; break;
1906                 case UserHomeInformation: val = "UserHomeInformation"; break;
1907                 case UserScriptInformation: val = "UserScriptInformation"; break;
1908                 case UserProfileInformation: val = "UserProfileInformation"; break;
1909                 case UserAdminCommentInformation: val = "UserAdminCommentInformation"; break;
1910                 case UserWorkStationsInformation: val = "UserWorkStationsInformation"; break;
1911                 case UserControlInformation: val = "UserControlInformation"; break;
1912                 case UserExpiresInformation: val = "UserExpiresInformation"; break;
1913                 case UserInternal1Information: val = "UserInternal1Information"; break;
1914                 case UserParametersInformation: val = "UserParametersInformation"; break;
1915                 case UserAllInformation: val = "UserAllInformation"; break;
1916                 case UserInternal4Information: val = "UserInternal4Information"; break;
1917                 case UserInternal5Information: val = "UserInternal5Information"; break;
1918                 case UserInternal4InformationNew: val = "UserInternal4InformationNew"; break;
1919                 case UserInternal5InformationNew: val = "UserInternal5InformationNew"; break;
1920         }
1921         ndr_print_enum(ndr, name, "ENUM", val, r);
1922 }
1923
1924 static enum ndr_err_code ndr_push_samr_UserInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo1 *r)
1925 {
1926         if (ndr_flags & NDR_SCALARS) {
1927                 NDR_CHECK(ndr_push_align(ndr, 5));
1928                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
1929                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
1930                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
1931                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1932                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));
1933         }
1934         if (ndr_flags & NDR_BUFFERS) {
1935                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
1936                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
1937                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1938                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));
1939         }
1940         return NDR_ERR_SUCCESS;
1941 }
1942
1943 static enum ndr_err_code ndr_pull_samr_UserInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo1 *r)
1944 {
1945         if (ndr_flags & NDR_SCALARS) {
1946                 NDR_CHECK(ndr_pull_align(ndr, 5));
1947                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
1948                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
1949                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
1950                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1951                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));
1952         }
1953         if (ndr_flags & NDR_BUFFERS) {
1954                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
1955                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
1956                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1957                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));
1958         }
1959         return NDR_ERR_SUCCESS;
1960 }
1961
1962 _PUBLIC_ void ndr_print_samr_UserInfo1(struct ndr_print *ndr, const char *name, const struct samr_UserInfo1 *r)
1963 {
1964         ndr_print_struct(ndr, name, "samr_UserInfo1");
1965         ndr->depth++;
1966         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
1967         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
1968         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
1969         ndr_print_lsa_String(ndr, "description", &r->description);
1970         ndr_print_lsa_String(ndr, "comment", &r->comment);
1971         ndr->depth--;
1972 }
1973
1974 static enum ndr_err_code ndr_push_samr_UserInfo2(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo2 *r)
1975 {
1976         if (ndr_flags & NDR_SCALARS) {
1977                 NDR_CHECK(ndr_push_align(ndr, 5));
1978                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));
1979                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->unknown));
1980                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->country_code));
1981                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->code_page));
1982         }
1983         if (ndr_flags & NDR_BUFFERS) {
1984                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));
1985                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->unknown));
1986         }
1987         return NDR_ERR_SUCCESS;
1988 }
1989
1990 static enum ndr_err_code ndr_pull_samr_UserInfo2(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo2 *r)
1991 {
1992         if (ndr_flags & NDR_SCALARS) {
1993                 NDR_CHECK(ndr_pull_align(ndr, 5));
1994                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));
1995                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->unknown));
1996                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->country_code));
1997                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->code_page));
1998         }
1999         if (ndr_flags & NDR_BUFFERS) {
2000                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));
2001                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->unknown));
2002         }
2003         return NDR_ERR_SUCCESS;
2004 }
2005
2006 _PUBLIC_ void ndr_print_samr_UserInfo2(struct ndr_print *ndr, const char *name, const struct samr_UserInfo2 *r)
2007 {
2008         ndr_print_struct(ndr, name, "samr_UserInfo2");
2009         ndr->depth++;
2010         ndr_print_lsa_String(ndr, "comment", &r->comment);
2011         ndr_print_lsa_String(ndr, "unknown", &r->unknown);
2012         ndr_print_uint16(ndr, "country_code", r->country_code);
2013         ndr_print_uint16(ndr, "code_page", r->code_page);
2014         ndr->depth--;
2015 }
2016
2017 _PUBLIC_ enum ndr_err_code ndr_push_samr_LogonHours(struct ndr_push *ndr, int ndr_flags, const struct samr_LogonHours *r)
2018 {
2019         {
2020                 uint32_t _flags_save_STRUCT = ndr->flags;
2021                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2022                 if (ndr_flags & NDR_SCALARS) {
2023                         NDR_CHECK(ndr_push_align(ndr, 5));
2024                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->units_per_week));
2025                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->bits));
2026                 }
2027                 if (ndr_flags & NDR_BUFFERS) {
2028                         if (r->bits) {
2029                                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 1260));
2030                                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2031                                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->units_per_week / 8));
2032                                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->bits, r->units_per_week / 8));
2033                         }
2034                 }
2035                 ndr->flags = _flags_save_STRUCT;
2036         }
2037         return NDR_ERR_SUCCESS;
2038 }
2039
2040 _PUBLIC_ enum ndr_err_code ndr_pull_samr_LogonHours(struct ndr_pull *ndr, int ndr_flags, struct samr_LogonHours *r)
2041 {
2042         uint32_t _ptr_bits;
2043         TALLOC_CTX *_mem_save_bits_0;
2044         {
2045                 uint32_t _flags_save_STRUCT = ndr->flags;
2046                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2047                 if (ndr_flags & NDR_SCALARS) {
2048                         NDR_CHECK(ndr_pull_align(ndr, 5));
2049                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->units_per_week));
2050                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bits));
2051                         if (_ptr_bits) {
2052                                 NDR_PULL_ALLOC(ndr, r->bits);
2053                         } else {
2054                                 r->bits = NULL;
2055                         }
2056                 }
2057                 if (ndr_flags & NDR_BUFFERS) {
2058                         if (r->bits) {
2059                                 _mem_save_bits_0 = NDR_PULL_GET_MEM_CTX(ndr);
2060                                 NDR_PULL_SET_MEM_CTX(ndr, r->bits, 0);
2061                                 NDR_CHECK(ndr_pull_array_size(ndr, &r->bits));
2062                                 NDR_CHECK(ndr_pull_array_length(ndr, &r->bits));
2063                                 if (ndr_get_array_length(ndr, &r->bits) > ndr_get_array_size(ndr, &r->bits)) {
2064                                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->bits), ndr_get_array_length(ndr, &r->bits));
2065                                 }
2066                                 NDR_PULL_ALLOC_N(ndr, r->bits, ndr_get_array_size(ndr, &r->bits));
2067                                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->bits, ndr_get_array_length(ndr, &r->bits)));
2068                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bits_0, 0);
2069                         }
2070                         if (r->bits) {
2071                                 NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->bits, 1260));
2072                         }
2073                         if (r->bits) {
2074                                 NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->bits, r->units_per_week / 8));
2075                         }
2076                 }
2077                 ndr->flags = _flags_save_STRUCT;
2078         }
2079         return NDR_ERR_SUCCESS;
2080 }
2081
2082 _PUBLIC_ void ndr_print_samr_LogonHours(struct ndr_print *ndr, const char *name, const struct samr_LogonHours *r)
2083 {
2084         ndr_print_struct(ndr, name, "samr_LogonHours");
2085         {
2086                 uint32_t _flags_save_STRUCT = ndr->flags;
2087                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2088                 ndr->depth++;
2089                 ndr_print_uint16(ndr, "units_per_week", r->units_per_week);
2090                 ndr_print_ptr(ndr, "bits", r->bits);
2091                 ndr->depth++;
2092                 if (r->bits) {
2093                         ndr_print_array_uint8(ndr, "bits", r->bits, r->units_per_week / 8);
2094                 }
2095                 ndr->depth--;
2096                 ndr->depth--;
2097                 ndr->flags = _flags_save_STRUCT;
2098         }
2099 }
2100
2101 static enum ndr_err_code ndr_push_samr_UserInfo3(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo3 *r)
2102 {
2103         if (ndr_flags & NDR_SCALARS) {
2104                 NDR_CHECK(ndr_push_align(ndr, 5));
2105                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2106                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2107                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
2108                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
2109                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2110                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2111                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2112                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2113                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2114                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));
2115                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));
2116                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));
2117                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->allow_password_change));
2118                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_password_change));
2119                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2120                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));
2121                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
2122                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
2123         }
2124         if (ndr_flags & NDR_BUFFERS) {
2125                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2126                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2127                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2128                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2129                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2130                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2131                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2132                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2133         }
2134         return NDR_ERR_SUCCESS;
2135 }
2136
2137 static enum ndr_err_code ndr_pull_samr_UserInfo3(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo3 *r)
2138 {
2139         if (ndr_flags & NDR_SCALARS) {
2140                 NDR_CHECK(ndr_pull_align(ndr, 5));
2141                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2142                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2143                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
2144                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
2145                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2146                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2147                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2148                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2149                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2150                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));
2151                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));
2152                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));
2153                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->allow_password_change));
2154                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_password_change));
2155                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2156                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));
2157                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
2158                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
2159         }
2160         if (ndr_flags & NDR_BUFFERS) {
2161                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2162                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2163                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2164                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2165                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2166                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2167                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2168                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2169         }
2170         return NDR_ERR_SUCCESS;
2171 }
2172
2173 _PUBLIC_ void ndr_print_samr_UserInfo3(struct ndr_print *ndr, const char *name, const struct samr_UserInfo3 *r)
2174 {
2175         ndr_print_struct(ndr, name, "samr_UserInfo3");
2176         ndr->depth++;
2177         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2178         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2179         ndr_print_uint32(ndr, "rid", r->rid);
2180         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
2181         ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
2182         ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
2183         ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
2184         ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
2185         ndr_print_lsa_String(ndr, "workstations", &r->workstations);
2186         ndr_print_NTTIME(ndr, "last_logon", r->last_logon);
2187         ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);
2188         ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);
2189         ndr_print_NTTIME(ndr, "allow_password_change", r->allow_password_change);
2190         ndr_print_NTTIME(ndr, "force_password_change", r->force_password_change);
2191         ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
2192         ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);
2193         ndr_print_uint16(ndr, "logon_count", r->logon_count);
2194         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
2195         ndr->depth--;
2196 }
2197
2198 static enum ndr_err_code ndr_push_samr_UserInfo4(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo4 *r)
2199 {
2200         if (ndr_flags & NDR_SCALARS) {
2201                 NDR_CHECK(ndr_push_align(ndr, 5));
2202                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2203         }
2204         if (ndr_flags & NDR_BUFFERS) {
2205                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2206         }
2207         return NDR_ERR_SUCCESS;
2208 }
2209
2210 static enum ndr_err_code ndr_pull_samr_UserInfo4(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo4 *r)
2211 {
2212         if (ndr_flags & NDR_SCALARS) {
2213                 NDR_CHECK(ndr_pull_align(ndr, 5));
2214                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2215         }
2216         if (ndr_flags & NDR_BUFFERS) {
2217                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2218         }
2219         return NDR_ERR_SUCCESS;
2220 }
2221
2222 _PUBLIC_ void ndr_print_samr_UserInfo4(struct ndr_print *ndr, const char *name, const struct samr_UserInfo4 *r)
2223 {
2224         ndr_print_struct(ndr, name, "samr_UserInfo4");
2225         ndr->depth++;
2226         ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
2227         ndr->depth--;
2228 }
2229
2230 static enum ndr_err_code ndr_push_samr_UserInfo5(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo5 *r)
2231 {
2232         if (ndr_flags & NDR_SCALARS) {
2233                 NDR_CHECK(ndr_push_align(ndr, 5));
2234                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2235                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2236                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
2237                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
2238                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2239                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2240                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2241                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2242                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
2243                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2244                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));
2245                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));
2246                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2247                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));
2248                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
2249                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));
2250                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
2251                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
2252         }
2253         if (ndr_flags & NDR_BUFFERS) {
2254                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2255                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2256                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2257                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2258                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2259                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2260                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
2261                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2262                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2263         }
2264         return NDR_ERR_SUCCESS;
2265 }
2266
2267 static enum ndr_err_code ndr_pull_samr_UserInfo5(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo5 *r)
2268 {
2269         if (ndr_flags & NDR_SCALARS) {
2270                 NDR_CHECK(ndr_pull_align(ndr, 5));
2271                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2272                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2273                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
2274                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
2275                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2276                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2277                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2278                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2279                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
2280                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2281                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));
2282                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));
2283                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2284                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));
2285                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
2286                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));
2287                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
2288                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
2289         }
2290         if (ndr_flags & NDR_BUFFERS) {
2291                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2292                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2293                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2294                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2295                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2296                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2297                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
2298                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2299                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2300         }
2301         return NDR_ERR_SUCCESS;
2302 }
2303
2304 _PUBLIC_ void ndr_print_samr_UserInfo5(struct ndr_print *ndr, const char *name, const struct samr_UserInfo5 *r)
2305 {
2306         ndr_print_struct(ndr, name, "samr_UserInfo5");
2307         ndr->depth++;
2308         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2309         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2310         ndr_print_uint32(ndr, "rid", r->rid);
2311         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
2312         ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
2313         ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
2314         ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
2315         ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
2316         ndr_print_lsa_String(ndr, "description", &r->description);
2317         ndr_print_lsa_String(ndr, "workstations", &r->workstations);
2318         ndr_print_NTTIME(ndr, "last_logon", r->last_logon);
2319         ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);
2320         ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
2321         ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);
2322         ndr_print_uint16(ndr, "logon_count", r->logon_count);
2323         ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);
2324         ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);
2325         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
2326         ndr->depth--;
2327 }
2328
2329 static enum ndr_err_code ndr_push_samr_UserInfo6(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo6 *r)
2330 {
2331         if (ndr_flags & NDR_SCALARS) {
2332                 NDR_CHECK(ndr_push_align(ndr, 5));
2333                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2334                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2335         }
2336         if (ndr_flags & NDR_BUFFERS) {
2337                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2338                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2339         }
2340         return NDR_ERR_SUCCESS;
2341 }
2342
2343 static enum ndr_err_code ndr_pull_samr_UserInfo6(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo6 *r)
2344 {
2345         if (ndr_flags & NDR_SCALARS) {
2346                 NDR_CHECK(ndr_pull_align(ndr, 5));
2347                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2348                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2349         }
2350         if (ndr_flags & NDR_BUFFERS) {
2351                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2352                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2353         }
2354         return NDR_ERR_SUCCESS;
2355 }
2356
2357 _PUBLIC_ void ndr_print_samr_UserInfo6(struct ndr_print *ndr, const char *name, const struct samr_UserInfo6 *r)
2358 {
2359         ndr_print_struct(ndr, name, "samr_UserInfo6");
2360         ndr->depth++;
2361         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2362         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2363         ndr->depth--;
2364 }
2365
2366 static enum ndr_err_code ndr_push_samr_UserInfo7(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo7 *r)
2367 {
2368         if (ndr_flags & NDR_SCALARS) {
2369                 NDR_CHECK(ndr_push_align(ndr, 5));
2370                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2371         }
2372         if (ndr_flags & NDR_BUFFERS) {
2373                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2374         }
2375         return NDR_ERR_SUCCESS;
2376 }
2377
2378 static enum ndr_err_code ndr_pull_samr_UserInfo7(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo7 *r)
2379 {
2380         if (ndr_flags & NDR_SCALARS) {
2381                 NDR_CHECK(ndr_pull_align(ndr, 5));
2382                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2383         }
2384         if (ndr_flags & NDR_BUFFERS) {
2385                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2386         }
2387         return NDR_ERR_SUCCESS;
2388 }
2389
2390 _PUBLIC_ void ndr_print_samr_UserInfo7(struct ndr_print *ndr, const char *name, const struct samr_UserInfo7 *r)
2391 {
2392         ndr_print_struct(ndr, name, "samr_UserInfo7");
2393         ndr->depth++;
2394         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2395         ndr->depth--;
2396 }
2397
2398 static enum ndr_err_code ndr_push_samr_UserInfo8(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo8 *r)
2399 {
2400         if (ndr_flags & NDR_SCALARS) {
2401                 NDR_CHECK(ndr_push_align(ndr, 5));
2402                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2403         }
2404         if (ndr_flags & NDR_BUFFERS) {
2405                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2406         }
2407         return NDR_ERR_SUCCESS;
2408 }
2409
2410 static enum ndr_err_code ndr_pull_samr_UserInfo8(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo8 *r)
2411 {
2412         if (ndr_flags & NDR_SCALARS) {
2413                 NDR_CHECK(ndr_pull_align(ndr, 5));
2414                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2415         }
2416         if (ndr_flags & NDR_BUFFERS) {
2417                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2418         }
2419         return NDR_ERR_SUCCESS;
2420 }
2421
2422 _PUBLIC_ void ndr_print_samr_UserInfo8(struct ndr_print *ndr, const char *name, const struct samr_UserInfo8 *r)
2423 {
2424         ndr_print_struct(ndr, name, "samr_UserInfo8");
2425         ndr->depth++;
2426         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2427         ndr->depth--;
2428 }
2429
2430 static enum ndr_err_code ndr_push_samr_UserInfo9(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo9 *r)
2431 {
2432         if (ndr_flags & NDR_SCALARS) {
2433                 NDR_CHECK(ndr_push_align(ndr, 4));
2434                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
2435         }
2436         if (ndr_flags & NDR_BUFFERS) {
2437         }
2438         return NDR_ERR_SUCCESS;
2439 }
2440
2441 static enum ndr_err_code ndr_pull_samr_UserInfo9(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo9 *r)
2442 {
2443         if (ndr_flags & NDR_SCALARS) {
2444                 NDR_CHECK(ndr_pull_align(ndr, 4));
2445                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
2446         }
2447         if (ndr_flags & NDR_BUFFERS) {
2448         }
2449         return NDR_ERR_SUCCESS;
2450 }
2451
2452 _PUBLIC_ void ndr_print_samr_UserInfo9(struct ndr_print *ndr, const char *name, const struct samr_UserInfo9 *r)
2453 {
2454         ndr_print_struct(ndr, name, "samr_UserInfo9");
2455         ndr->depth++;
2456         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
2457         ndr->depth--;
2458 }
2459
2460 static enum ndr_err_code ndr_push_samr_UserInfo10(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo10 *r)
2461 {
2462         if (ndr_flags & NDR_SCALARS) {
2463                 NDR_CHECK(ndr_push_align(ndr, 5));
2464                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2465                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2466         }
2467         if (ndr_flags & NDR_BUFFERS) {
2468                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2469                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2470         }
2471         return NDR_ERR_SUCCESS;
2472 }
2473
2474 static enum ndr_err_code ndr_pull_samr_UserInfo10(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo10 *r)
2475 {
2476         if (ndr_flags & NDR_SCALARS) {
2477                 NDR_CHECK(ndr_pull_align(ndr, 5));
2478                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2479                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2480         }
2481         if (ndr_flags & NDR_BUFFERS) {
2482                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2483                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2484         }
2485         return NDR_ERR_SUCCESS;
2486 }
2487
2488 _PUBLIC_ void ndr_print_samr_UserInfo10(struct ndr_print *ndr, const char *name, const struct samr_UserInfo10 *r)
2489 {
2490         ndr_print_struct(ndr, name, "samr_UserInfo10");
2491         ndr->depth++;
2492         ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
2493         ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
2494         ndr->depth--;
2495 }
2496
2497 static enum ndr_err_code ndr_push_samr_UserInfo11(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo11 *r)
2498 {
2499         if (ndr_flags & NDR_SCALARS) {
2500                 NDR_CHECK(ndr_push_align(ndr, 5));
2501                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2502         }
2503         if (ndr_flags & NDR_BUFFERS) {
2504                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2505         }
2506         return NDR_ERR_SUCCESS;
2507 }
2508
2509 static enum ndr_err_code ndr_pull_samr_UserInfo11(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo11 *r)
2510 {
2511         if (ndr_flags & NDR_SCALARS) {
2512                 NDR_CHECK(ndr_pull_align(ndr, 5));
2513                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2514         }
2515         if (ndr_flags & NDR_BUFFERS) {
2516                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2517         }
2518         return NDR_ERR_SUCCESS;
2519 }
2520
2521 _PUBLIC_ void ndr_print_samr_UserInfo11(struct ndr_print *ndr, const char *name, const struct samr_UserInfo11 *r)
2522 {
2523         ndr_print_struct(ndr, name, "samr_UserInfo11");
2524         ndr->depth++;
2525         ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
2526         ndr->depth--;
2527 }
2528
2529 static enum ndr_err_code ndr_push_samr_UserInfo12(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo12 *r)
2530 {
2531         if (ndr_flags & NDR_SCALARS) {
2532                 NDR_CHECK(ndr_push_align(ndr, 5));
2533                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2534         }
2535         if (ndr_flags & NDR_BUFFERS) {
2536                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2537         }
2538         return NDR_ERR_SUCCESS;
2539 }
2540
2541 static enum ndr_err_code ndr_pull_samr_UserInfo12(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo12 *r)
2542 {
2543         if (ndr_flags & NDR_SCALARS) {
2544                 NDR_CHECK(ndr_pull_align(ndr, 5));
2545                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2546         }
2547         if (ndr_flags & NDR_BUFFERS) {
2548                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2549         }
2550         return NDR_ERR_SUCCESS;
2551 }
2552
2553 _PUBLIC_ void ndr_print_samr_UserInfo12(struct ndr_print *ndr, const char *name, const struct samr_UserInfo12 *r)
2554 {
2555         ndr_print_struct(ndr, name, "samr_UserInfo12");
2556         ndr->depth++;
2557         ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
2558         ndr->depth--;
2559 }
2560
2561 static enum ndr_err_code ndr_push_samr_UserInfo13(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo13 *r)
2562 {
2563         if (ndr_flags & NDR_SCALARS) {
2564                 NDR_CHECK(ndr_push_align(ndr, 5));
2565                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
2566         }
2567         if (ndr_flags & NDR_BUFFERS) {
2568                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
2569         }
2570         return NDR_ERR_SUCCESS;
2571 }
2572
2573 static enum ndr_err_code ndr_pull_samr_UserInfo13(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo13 *r)
2574 {
2575         if (ndr_flags & NDR_SCALARS) {
2576                 NDR_CHECK(ndr_pull_align(ndr, 5));
2577                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
2578         }
2579         if (ndr_flags & NDR_BUFFERS) {
2580                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
2581         }
2582         return NDR_ERR_SUCCESS;
2583 }
2584
2585 _PUBLIC_ void ndr_print_samr_UserInfo13(struct ndr_print *ndr, const char *name, const struct samr_UserInfo13 *r)
2586 {
2587         ndr_print_struct(ndr, name, "samr_UserInfo13");
2588         ndr->depth++;
2589         ndr_print_lsa_String(ndr, "description", &r->description);
2590         ndr->depth--;
2591 }
2592
2593 static enum ndr_err_code ndr_push_samr_UserInfo14(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo14 *r)
2594 {
2595         if (ndr_flags & NDR_SCALARS) {
2596                 NDR_CHECK(ndr_push_align(ndr, 5));
2597                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2598         }
2599         if (ndr_flags & NDR_BUFFERS) {
2600                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2601         }
2602         return NDR_ERR_SUCCESS;
2603 }
2604
2605 static enum ndr_err_code ndr_pull_samr_UserInfo14(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo14 *r)
2606 {
2607         if (ndr_flags & NDR_SCALARS) {
2608                 NDR_CHECK(ndr_pull_align(ndr, 5));
2609                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2610         }
2611         if (ndr_flags & NDR_BUFFERS) {
2612                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2613         }
2614         return NDR_ERR_SUCCESS;
2615 }
2616
2617 _PUBLIC_ void ndr_print_samr_UserInfo14(struct ndr_print *ndr, const char *name, const struct samr_UserInfo14 *r)
2618 {
2619         ndr_print_struct(ndr, name, "samr_UserInfo14");
2620         ndr->depth++;
2621         ndr_print_lsa_String(ndr, "workstations", &r->workstations);
2622         ndr->depth--;
2623 }
2624
2625 static enum ndr_err_code ndr_push_samr_UserInfo16(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo16 *r)
2626 {
2627         if (ndr_flags & NDR_SCALARS) {
2628                 NDR_CHECK(ndr_push_align(ndr, 4));
2629                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
2630         }
2631         if (ndr_flags & NDR_BUFFERS) {
2632         }
2633         return NDR_ERR_SUCCESS;
2634 }
2635
2636 static enum ndr_err_code ndr_pull_samr_UserInfo16(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo16 *r)
2637 {
2638         if (ndr_flags & NDR_SCALARS) {
2639                 NDR_CHECK(ndr_pull_align(ndr, 4));
2640                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
2641         }
2642         if (ndr_flags & NDR_BUFFERS) {
2643         }
2644         return NDR_ERR_SUCCESS;
2645 }
2646
2647 _PUBLIC_ void ndr_print_samr_UserInfo16(struct ndr_print *ndr, const char *name, const struct samr_UserInfo16 *r)
2648 {
2649         ndr_print_struct(ndr, name, "samr_UserInfo16");
2650         ndr->depth++;
2651         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
2652         ndr->depth--;
2653 }
2654
2655 static enum ndr_err_code ndr_push_samr_UserInfo17(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo17 *r)
2656 {
2657         if (ndr_flags & NDR_SCALARS) {
2658                 NDR_CHECK(ndr_push_align(ndr, 4));
2659                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
2660         }
2661         if (ndr_flags & NDR_BUFFERS) {
2662         }
2663         return NDR_ERR_SUCCESS;
2664 }
2665
2666 static enum ndr_err_code ndr_pull_samr_UserInfo17(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo17 *r)
2667 {
2668         if (ndr_flags & NDR_SCALARS) {
2669                 NDR_CHECK(ndr_pull_align(ndr, 4));
2670                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
2671         }
2672         if (ndr_flags & NDR_BUFFERS) {
2673         }
2674         return NDR_ERR_SUCCESS;
2675 }
2676
2677 _PUBLIC_ void ndr_print_samr_UserInfo17(struct ndr_print *ndr, const char *name, const struct samr_UserInfo17 *r)
2678 {
2679         ndr_print_struct(ndr, name, "samr_UserInfo17");
2680         ndr->depth++;
2681         ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);
2682         ndr->depth--;
2683 }
2684
2685 _PUBLIC_ enum ndr_err_code ndr_push_samr_Password(struct ndr_push *ndr, int ndr_flags, const struct samr_Password *r)
2686 {
2687         {
2688                 uint32_t _flags_save_STRUCT = ndr->flags;
2689                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2690                 if (ndr_flags & NDR_SCALARS) {
2691                         NDR_CHECK(ndr_push_align(ndr, 1));
2692                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
2693                 }
2694                 if (ndr_flags & NDR_BUFFERS) {
2695                 }
2696                 ndr->flags = _flags_save_STRUCT;
2697         }
2698         return NDR_ERR_SUCCESS;
2699 }
2700
2701 _PUBLIC_ enum ndr_err_code ndr_pull_samr_Password(struct ndr_pull *ndr, int ndr_flags, struct samr_Password *r)
2702 {
2703         {
2704                 uint32_t _flags_save_STRUCT = ndr->flags;
2705                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2706                 if (ndr_flags & NDR_SCALARS) {
2707                         NDR_CHECK(ndr_pull_align(ndr, 1));
2708                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
2709                 }
2710                 if (ndr_flags & NDR_BUFFERS) {
2711                 }
2712                 ndr->flags = _flags_save_STRUCT;
2713         }
2714         return NDR_ERR_SUCCESS;
2715 }
2716
2717 _PUBLIC_ void ndr_print_samr_Password(struct ndr_print *ndr, const char *name, const struct samr_Password *r)
2718 {
2719         ndr_print_struct(ndr, name, "samr_Password");
2720         {
2721                 uint32_t _flags_save_STRUCT = ndr->flags;
2722                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2723                 ndr->depth++;
2724                 ndr_print_array_uint8(ndr, "hash", r->hash, 16);
2725                 ndr->depth--;
2726                 ndr->flags = _flags_save_STRUCT;
2727         }
2728 }
2729
2730 static enum ndr_err_code ndr_push_samr_UserInfo18(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo18 *r)
2731 {
2732         if (ndr_flags & NDR_SCALARS) {
2733                 NDR_CHECK(ndr_push_align(ndr, 1));
2734                 NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->nt_pwd));
2735                 NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->lm_pwd));
2736                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->nt_pwd_active));
2737                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->lm_pwd_active));
2738                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
2739         }
2740         if (ndr_flags & NDR_BUFFERS) {
2741         }
2742         return NDR_ERR_SUCCESS;
2743 }
2744
2745 static enum ndr_err_code ndr_pull_samr_UserInfo18(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo18 *r)
2746 {
2747         if (ndr_flags & NDR_SCALARS) {
2748                 NDR_CHECK(ndr_pull_align(ndr, 1));
2749                 NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->nt_pwd));
2750                 NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->lm_pwd));
2751                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->nt_pwd_active));
2752                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->lm_pwd_active));
2753                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
2754         }
2755         if (ndr_flags & NDR_BUFFERS) {
2756         }
2757         return NDR_ERR_SUCCESS;
2758 }
2759
2760 _PUBLIC_ void ndr_print_samr_UserInfo18(struct ndr_print *ndr, const char *name, const struct samr_UserInfo18 *r)
2761 {
2762         ndr_print_struct(ndr, name, "samr_UserInfo18");
2763         ndr->depth++;
2764         ndr_print_samr_Password(ndr, "nt_pwd", &r->nt_pwd);
2765         ndr_print_samr_Password(ndr, "lm_pwd", &r->lm_pwd);
2766         ndr_print_uint8(ndr, "nt_pwd_active", r->nt_pwd_active);
2767         ndr_print_uint8(ndr, "lm_pwd_active", r->lm_pwd_active);
2768         ndr_print_uint8(ndr, "password_expired", r->password_expired);
2769         ndr->depth--;
2770 }
2771
2772 static enum ndr_err_code ndr_push_samr_UserInfo20(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo20 *r)
2773 {
2774         if (ndr_flags & NDR_SCALARS) {
2775                 NDR_CHECK(ndr_push_align(ndr, 5));
2776                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
2777         }
2778         if (ndr_flags & NDR_BUFFERS) {
2779                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
2780         }
2781         return NDR_ERR_SUCCESS;
2782 }
2783
2784 static enum ndr_err_code ndr_pull_samr_UserInfo20(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo20 *r)
2785 {
2786         if (ndr_flags & NDR_SCALARS) {
2787                 NDR_CHECK(ndr_pull_align(ndr, 5));
2788                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
2789         }
2790         if (ndr_flags & NDR_BUFFERS) {
2791                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
2792         }
2793         return NDR_ERR_SUCCESS;
2794 }
2795
2796 _PUBLIC_ void ndr_print_samr_UserInfo20(struct ndr_print *ndr, const char *name, const struct samr_UserInfo20 *r)
2797 {
2798         ndr_print_struct(ndr, name, "samr_UserInfo20");
2799         ndr->depth++;
2800         ndr_print_lsa_BinaryString(ndr, "parameters", &r->parameters);
2801         ndr->depth--;
2802 }
2803
2804 static enum ndr_err_code ndr_push_samr_FieldsPresent(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2805 {
2806         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2807         return NDR_ERR_SUCCESS;
2808 }
2809
2810 static enum ndr_err_code ndr_pull_samr_FieldsPresent(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2811 {
2812         uint32_t v;
2813         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2814         *r = v;
2815         return NDR_ERR_SUCCESS;
2816 }
2817
2818 _PUBLIC_ void ndr_print_samr_FieldsPresent(struct ndr_print *ndr, const char *name, uint32_t r)
2819 {
2820         ndr_print_uint32(ndr, name, r);
2821         ndr->depth++;
2822         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCOUNT_NAME", SAMR_FIELD_ACCOUNT_NAME, r);
2823         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_FULL_NAME", SAMR_FIELD_FULL_NAME, r);
2824         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_RID", SAMR_FIELD_RID, r);
2825         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PRIMARY_GID", SAMR_FIELD_PRIMARY_GID, r);
2826         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_DESCRIPTION", SAMR_FIELD_DESCRIPTION, r);
2827         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_COMMENT", SAMR_FIELD_COMMENT, r);
2828         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_HOME_DIRECTORY", SAMR_FIELD_HOME_DIRECTORY, r);
2829         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_HOME_DRIVE", SAMR_FIELD_HOME_DRIVE, r);
2830         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LOGON_SCRIPT", SAMR_FIELD_LOGON_SCRIPT, r);
2831         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PROFILE_PATH", SAMR_FIELD_PROFILE_PATH, r);
2832         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_WORKSTATIONS", SAMR_FIELD_WORKSTATIONS, r);
2833         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_LOGON", SAMR_FIELD_LAST_LOGON, r);
2834         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_LOGOFF", SAMR_FIELD_LAST_LOGOFF, r);
2835         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LOGON_HOURS", SAMR_FIELD_LOGON_HOURS, r);
2836         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_BAD_PWD_COUNT", SAMR_FIELD_BAD_PWD_COUNT, r);
2837         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_NUM_LOGONS", SAMR_FIELD_NUM_LOGONS, r);
2838         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ALLOW_PWD_CHANGE", SAMR_FIELD_ALLOW_PWD_CHANGE, r);
2839         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_FORCE_PWD_CHANGE", SAMR_FIELD_FORCE_PWD_CHANGE, r);
2840         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_PWD_CHANGE", SAMR_FIELD_LAST_PWD_CHANGE, r);
2841         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCT_EXPIRY", SAMR_FIELD_ACCT_EXPIRY, r);
2842         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCT_FLAGS", SAMR_FIELD_ACCT_FLAGS, r);
2843         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PARAMETERS", SAMR_FIELD_PARAMETERS, r);
2844         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_COUNTRY_CODE", SAMR_FIELD_COUNTRY_CODE, r);
2845         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_CODE_PAGE", SAMR_FIELD_CODE_PAGE, r);
2846         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_NT_PASSWORD_PRESENT", SAMR_FIELD_NT_PASSWORD_PRESENT, r);
2847         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LM_PASSWORD_PRESENT", SAMR_FIELD_LM_PASSWORD_PRESENT, r);
2848         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PRIVATE_DATA", SAMR_FIELD_PRIVATE_DATA, r);
2849         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_EXPIRED_FLAG", SAMR_FIELD_EXPIRED_FLAG, r);
2850         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_SEC_DESC", SAMR_FIELD_SEC_DESC, r);
2851         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_OWF_PWD", SAMR_FIELD_OWF_PWD, r);
2852         ndr->depth--;
2853 }
2854
2855 static enum ndr_err_code ndr_push_samr_UserInfo21(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo21 *r)
2856 {
2857         if (ndr_flags & NDR_SCALARS) {
2858                 NDR_CHECK(ndr_push_align(ndr, 5));
2859                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));
2860                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));
2861                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));
2862                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
2863                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->allow_password_change));
2864                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_password_change));
2865                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2866                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2867                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2868                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2869                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2870                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2871                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
2872                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2873                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));
2874                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
2875                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->lm_owf_password));
2876                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->nt_owf_password));
2877                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->unknown3));
2878                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_count));
2879                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->buffer));
2880                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
2881                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
2882                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
2883                 NDR_CHECK(ndr_push_samr_FieldsPresent(ndr, NDR_SCALARS, r->fields_present));
2884                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2885                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));
2886                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
2887                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->country_code));
2888                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->code_page));
2889                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->lm_password_set));
2890                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->nt_password_set));
2891                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
2892                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->unknown4));
2893         }
2894         if (ndr_flags & NDR_BUFFERS) {
2895                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2896                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2897                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2898                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2899                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2900                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2901                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
2902                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2903                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));
2904                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
2905                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->lm_owf_password));
2906                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->nt_owf_password));
2907                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->unknown3));
2908                 if (r->buffer) {
2909                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->buf_count));
2910                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->buffer, r->buf_count));
2911                 }
2912                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2913         }
2914         return NDR_ERR_SUCCESS;
2915 }
2916
2917 static enum ndr_err_code ndr_pull_samr_UserInfo21(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo21 *r)
2918 {
2919         uint32_t _ptr_buffer;
2920         TALLOC_CTX *_mem_save_buffer_0;
2921         if (ndr_flags & NDR_SCALARS) {
2922                 NDR_CHECK(ndr_pull_align(ndr, 5));
2923                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));
2924                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));
2925                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));
2926                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
2927                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->allow_password_change));
2928                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_password_change));
2929                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2930                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2931                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2932                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2933                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2934                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2935                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
2936                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2937                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));
2938                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
2939                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->lm_owf_password));
2940                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->nt_owf_password));
2941                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->unknown3));
2942                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_count));
2943                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
2944                 if (_ptr_buffer) {
2945                         NDR_PULL_ALLOC(ndr, r->buffer);
2946                 } else {
2947                         r->buffer = NULL;
2948                 }
2949                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
2950                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
2951                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
2952                 NDR_CHECK(ndr_pull_samr_FieldsPresent(ndr, NDR_SCALARS, &r->fields_present));
2953                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2954                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));
2955                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
2956                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->country_code));
2957                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->code_page));
2958                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->lm_password_set));
2959                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->nt_password_set));
2960                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
2961                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->unknown4));
2962         }
2963         if (ndr_flags & NDR_BUFFERS) {
2964                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2965                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2966                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2967                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2968                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2969                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2970                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
2971                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2972                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));
2973                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
2974                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->lm_owf_password));
2975                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->nt_owf_password));
2976                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->unknown3));
2977                 if (r->buffer) {
2978                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
2979                         NDR_PULL_SET_MEM_CTX(ndr, r->buffer, 0);
2980                         NDR_CHECK(ndr_pull_array_size(ndr, &r->buffer));
2981                         NDR_PULL_ALLOC_N(ndr, r->buffer, ndr_get_array_size(ndr, &r->buffer));
2982                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->buffer, ndr_get_array_size(ndr, &r->buffer)));
2983                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
2984                 }
2985                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2986                 if (r->buffer) {
2987                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->buffer, r->buf_count));
2988                 }
2989         }
2990         return NDR_ERR_SUCCESS;
2991 }
2992
2993 _PUBLIC_ void ndr_print_samr_UserInfo21(struct ndr_print *ndr, const char *name, const struct samr_UserInfo21 *r)
2994 {
2995         ndr_print_struct(ndr, name, "samr_UserInfo21");
2996         ndr->depth++;
2997         ndr_print_NTTIME(ndr, "last_logon", r->last_logon);
2998         ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);
2999         ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);
3000         ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);
3001         ndr_print_NTTIME(ndr, "allow_password_change", r->allow_password_change);
3002         ndr_print_NTTIME(ndr, "force_password_change", r->force_password_change);
3003         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
3004         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
3005         ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
3006         ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
3007         ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
3008         ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
3009         ndr_print_lsa_String(ndr, "description", &r->description);
3010         ndr_print_lsa_String(ndr, "workstations", &r->workstations);
3011         ndr_print_lsa_String(ndr, "comment", &r->comment);
3012         ndr_print_lsa_BinaryString(ndr, "parameters", &r->parameters);
3013         ndr_print_lsa_BinaryString(ndr, "lm_owf_password", &r->lm_owf_password);
3014         ndr_print_lsa_BinaryString(ndr, "nt_owf_password", &r->nt_owf_password);
3015         ndr_print_lsa_String(ndr, "unknown3", &r->unknown3);
3016         ndr_print_uint32(ndr, "buf_count", r->buf_count);
3017         ndr_print_ptr(ndr, "buffer", r->buffer);
3018         ndr->depth++;
3019         if (r->buffer) {
3020                 ndr_print_array_uint8(ndr, "buffer", r->buffer, r->buf_count);
3021         }
3022         ndr->depth--;
3023         ndr_print_uint32(ndr, "rid", r->rid);
3024         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
3025         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
3026         ndr_print_samr_FieldsPresent(ndr, "fields_present", r->fields_present);
3027         ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
3028         ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);
3029         ndr_print_uint16(ndr, "logon_count", r->logon_count);
3030         ndr_print_uint16(ndr, "country_code", r->country_code);
3031         ndr_print_uint16(ndr, "code_page", r->code_page);
3032         ndr_print_uint8(ndr, "lm_password_set", r->lm_password_set);
3033         ndr_print_uint8(ndr, "nt_password_set", r->nt_password_set);
3034         ndr_print_uint8(ndr, "password_expired", r->password_expired);
3035         ndr_print_uint8(ndr, "unknown4", r->unknown4);
3036         ndr->depth--;
3037 }
3038
3039 _PUBLIC_ enum ndr_err_code ndr_push_samr_CryptPassword(struct ndr_push *ndr, int ndr_flags, const struct samr_CryptPassword *r)
3040 {
3041         {
3042                 uint32_t _flags_save_STRUCT = ndr->flags;
3043                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3044                 if (ndr_flags & NDR_SCALARS) {
3045                         NDR_CHECK(ndr_push_align(ndr, 1));
3046                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 516));
3047                 }
3048                 if (ndr_flags & NDR_BUFFERS) {
3049                 }
3050                 ndr->flags = _flags_save_STRUCT;
3051         }
3052         return NDR_ERR_SUCCESS;
3053 }
3054
3055 _PUBLIC_ enum ndr_err_code ndr_pull_samr_CryptPassword(struct ndr_pull *ndr, int ndr_flags, struct samr_CryptPassword *r)
3056 {
3057         {
3058                 uint32_t _flags_save_STRUCT = ndr->flags;
3059                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3060                 if (ndr_flags & NDR_SCALARS) {
3061                         NDR_CHECK(ndr_pull_align(ndr, 1));
3062                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, 516));
3063                 }
3064                 if (ndr_flags & NDR_BUFFERS) {
3065                 }
3066                 ndr->flags = _flags_save_STRUCT;
3067         }
3068         return NDR_ERR_SUCCESS;
3069 }
3070
3071 _PUBLIC_ void ndr_print_samr_CryptPassword(struct ndr_print *ndr, const char *name, const struct samr_CryptPassword *r)
3072 {
3073         ndr_print_struct(ndr, name, "samr_CryptPassword");
3074         {
3075                 uint32_t _flags_save_STRUCT = ndr->flags;
3076                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3077                 ndr->depth++;
3078                 ndr_print_array_uint8(ndr, "data", r->data, 516);
3079                 ndr->depth--;
3080                 ndr->flags = _flags_save_STRUCT;
3081         }
3082 }
3083
3084 static enum ndr_err_code ndr_push_samr_UserInfo23(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo23 *r)
3085 {
3086         if (ndr_flags & NDR_SCALARS) {
3087                 NDR_CHECK(ndr_push_align(ndr, 5));
3088                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
3089                 NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
3090         }
3091         if (ndr_flags & NDR_BUFFERS) {
3092                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
3093         }
3094         return NDR_ERR_SUCCESS;
3095 }
3096
3097 static enum ndr_err_code ndr_pull_samr_UserInfo23(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo23 *r)
3098 {
3099         if (ndr_flags & NDR_SCALARS) {
3100                 NDR_CHECK(ndr_pull_align(ndr, 5));
3101                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
3102                 NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
3103         }
3104         if (ndr_flags & NDR_BUFFERS) {
3105                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
3106         }
3107         return NDR_ERR_SUCCESS;
3108 }
3109
3110 _PUBLIC_ void ndr_print_samr_UserInfo23(struct ndr_print *ndr, const char *name, const struct samr_UserInfo23 *r)
3111 {
3112         ndr_print_struct(ndr, name, "samr_UserInfo23");
3113         ndr->depth++;
3114         ndr_print_samr_UserInfo21(ndr, "info", &r->info);
3115         ndr_print_samr_CryptPassword(ndr, "password", &r->password);
3116         ndr->depth--;
3117 }
3118
3119 static enum ndr_err_code ndr_push_samr_UserInfo24(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo24 *r)
3120 {
3121         if (ndr_flags & NDR_SCALARS) {
3122                 NDR_CHECK(ndr_push_align(ndr, 1));
3123                 NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
3124                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
3125         }
3126         if (ndr_flags & NDR_BUFFERS) {
3127         }
3128         return NDR_ERR_SUCCESS;
3129 }
3130
3131 static enum ndr_err_code ndr_pull_samr_UserInfo24(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo24 *r)
3132 {
3133         if (ndr_flags & NDR_SCALARS) {
3134                 NDR_CHECK(ndr_pull_align(ndr, 1));
3135                 NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
3136                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
3137         }
3138         if (ndr_flags & NDR_BUFFERS) {
3139         }
3140         return NDR_ERR_SUCCESS;
3141 }
3142
3143 _PUBLIC_ void ndr_print_samr_UserInfo24(struct ndr_print *ndr, const char *name, const struct samr_UserInfo24 *r)
3144 {
3145         ndr_print_struct(ndr, name, "samr_UserInfo24");
3146         ndr->depth++;
3147         ndr_print_samr_CryptPassword(ndr, "password", &r->password);
3148         ndr_print_uint8(ndr, "password_expired", r->password_expired);
3149         ndr->depth--;
3150 }
3151
3152 static enum ndr_err_code ndr_push_samr_CryptPasswordEx(struct ndr_push *ndr, int ndr_flags, const struct samr_CryptPasswordEx *r)
3153 {
3154         {
3155                 uint32_t _flags_save_STRUCT = ndr->flags;
3156                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3157                 if (ndr_flags & NDR_SCALARS) {
3158                         NDR_CHECK(ndr_push_align(ndr, 1));
3159                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 532));
3160                 }
3161                 if (ndr_flags & NDR_BUFFERS) {
3162                 }
3163                 ndr->flags = _flags_save_STRUCT;
3164         }
3165         return NDR_ERR_SUCCESS;
3166 }
3167
3168 static enum ndr_err_code ndr_pull_samr_CryptPasswordEx(struct ndr_pull *ndr, int ndr_flags, struct samr_CryptPasswordEx *r)
3169 {
3170         {
3171                 uint32_t _flags_save_STRUCT = ndr->flags;
3172                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3173                 if (ndr_flags & NDR_SCALARS) {
3174                         NDR_CHECK(ndr_pull_align(ndr, 1));
3175                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, 532));
3176                 }
3177                 if (ndr_flags & NDR_BUFFERS) {
3178                 }
3179                 ndr->flags = _flags_save_STRUCT;
3180         }
3181         return NDR_ERR_SUCCESS;
3182 }
3183
3184 _PUBLIC_ void ndr_print_samr_CryptPasswordEx(struct ndr_print *ndr, const char *name, const struct samr_CryptPasswordEx *r)
3185 {
3186         ndr_print_struct(ndr, name, "samr_CryptPasswordEx");
3187         {
3188                 uint32_t _flags_save_STRUCT = ndr->flags;
3189                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3190                 ndr->depth++;
3191                 ndr_print_array_uint8(ndr, "data", r->data, 532);
3192                 ndr->depth--;
3193                 ndr->flags = _flags_save_STRUCT;
3194         }
3195 }
3196
3197 static enum ndr_err_code ndr_push_samr_UserInfo25(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo25 *r)
3198 {
3199         if (ndr_flags & NDR_SCALARS) {
3200                 NDR_CHECK(ndr_push_align(ndr, 5));
3201                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
3202                 NDR_CHECK(ndr_push_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
3203         }
3204         if (ndr_flags & NDR_BUFFERS) {
3205                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
3206         }
3207         return NDR_ERR_SUCCESS;
3208 }
3209
3210 static enum ndr_err_code ndr_pull_samr_UserInfo25(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo25 *r)
3211 {
3212         if (ndr_flags & NDR_SCALARS) {
3213                 NDR_CHECK(ndr_pull_align(ndr, 5));
3214                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
3215                 NDR_CHECK(ndr_pull_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
3216         }
3217         if (ndr_flags & NDR_BUFFERS) {
3218                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
3219         }
3220         return NDR_ERR_SUCCESS;
3221 }
3222
3223 _PUBLIC_ void ndr_print_samr_UserInfo25(struct ndr_print *ndr, const char *name, const struct samr_UserInfo25 *r)
3224 {
3225         ndr_print_struct(ndr, name, "samr_UserInfo25");
3226         ndr->depth++;
3227         ndr_print_samr_UserInfo21(ndr, "info", &r->info);
3228         ndr_print_samr_CryptPasswordEx(ndr, "password", &r->password);
3229         ndr->depth--;
3230 }
3231
3232 static enum ndr_err_code ndr_push_samr_UserInfo26(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo26 *r)
3233 {
3234         if (ndr_flags & NDR_SCALARS) {
3235                 NDR_CHECK(ndr_push_align(ndr, 1));
3236                 NDR_CHECK(ndr_push_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
3237                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
3238         }
3239         if (ndr_flags & NDR_BUFFERS) {
3240         }
3241         return NDR_ERR_SUCCESS;
3242 }
3243
3244 static enum ndr_err_code ndr_pull_samr_UserInfo26(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo26 *r)
3245 {
3246         if (ndr_flags & NDR_SCALARS) {
3247                 NDR_CHECK(ndr_pull_align(ndr, 1));
3248                 NDR_CHECK(ndr_pull_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
3249                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
3250         }
3251         if (ndr_flags & NDR_BUFFERS) {
3252         }
3253         return NDR_ERR_SUCCESS;
3254 }
3255
3256 _PUBLIC_ void ndr_print_samr_UserInfo26(struct ndr_print *ndr, const char *name, const struct samr_UserInfo26 *r)
3257 {
3258         ndr_print_struct(ndr, name, "samr_UserInfo26");
3259         ndr->depth++;
3260         ndr_print_samr_CryptPasswordEx(ndr, "password", &r->password);
3261         ndr_print_uint8(ndr, "password_expired", r->password_expired);
3262         ndr->depth--;
3263 }
3264
3265 static enum ndr_err_code ndr_push_samr_UserInfo(struct ndr_push *ndr, int ndr_flags, const union samr_UserInfo *r)
3266 {
3267         if (ndr_flags & NDR_SCALARS) {
3268                 int level = ndr_push_get_switch_value(ndr, r);
3269                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
3270                 switch (level) {
3271                         case 1: {
3272                                 NDR_CHECK(ndr_push_samr_UserInfo1(ndr, NDR_SCALARS, &r->info1));
3273                         break; }
3274
3275                         case 2: {
3276                                 NDR_CHECK(ndr_push_samr_UserInfo2(ndr, NDR_SCALARS, &r->info2));
3277                         break; }
3278
3279                         case 3: {
3280                                 NDR_CHECK(ndr_push_samr_UserInfo3(ndr, NDR_SCALARS, &r->info3));
3281                         break; }
3282
3283                         case 4: {
3284                                 NDR_CHECK(ndr_push_samr_UserInfo4(ndr, NDR_SCALARS, &r->info4));
3285                         break; }
3286
3287                         case 5: {
3288                                 NDR_CHECK(ndr_push_samr_UserInfo5(ndr, NDR_SCALARS, &r->info5));
3289                         break; }
3290
3291                         case 6: {
3292                                 NDR_CHECK(ndr_push_samr_UserInfo6(ndr, NDR_SCALARS, &r->info6));
3293                         break; }
3294
3295                         case 7: {
3296                                 NDR_CHECK(ndr_push_samr_UserInfo7(ndr, NDR_SCALARS, &r->info7));
3297                         break; }
3298
3299                         case 8: {
3300                                 NDR_CHECK(ndr_push_samr_UserInfo8(ndr, NDR_SCALARS, &r->info8));
3301                         break; }
3302
3303                         case 9: {
3304                                 NDR_CHECK(ndr_push_samr_UserInfo9(ndr, NDR_SCALARS, &r->info9));
3305                         break; }
3306
3307                         case 10: {
3308                                 NDR_CHECK(ndr_push_samr_UserInfo10(ndr, NDR_SCALARS, &r->info10));
3309                         break; }
3310
3311                         case 11: {
3312                                 NDR_CHECK(ndr_push_samr_UserInfo11(ndr, NDR_SCALARS, &r->info11));
3313                         break; }
3314
3315                         case 12: {
3316                                 NDR_CHECK(ndr_push_samr_UserInfo12(ndr, NDR_SCALARS, &r->info12));
3317                         break; }
3318
3319                         case 13: {
3320                                 NDR_CHECK(ndr_push_samr_UserInfo13(ndr, NDR_SCALARS, &r->info13));
3321                         break; }
3322
3323                         case 14: {
3324                                 NDR_CHECK(ndr_push_samr_UserInfo14(ndr, NDR_SCALARS, &r->info14));
3325                         break; }
3326
3327                         case 16: {
3328                                 NDR_CHECK(ndr_push_samr_UserInfo16(ndr, NDR_SCALARS, &r->info16));
3329                         break; }
3330
3331                         case 17: {
3332                                 NDR_CHECK(ndr_push_samr_UserInfo17(ndr, NDR_SCALARS, &r->info17));
3333                         break; }
3334
3335                         case 18: {
3336                                 NDR_CHECK(ndr_push_samr_UserInfo18(ndr, NDR_SCALARS, &r->info18));
3337                         break; }
3338
3339                         case 20: {
3340                                 NDR_CHECK(ndr_push_samr_UserInfo20(ndr, NDR_SCALARS, &r->info20));
3341                         break; }
3342
3343                         case 21: {
3344                                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info21));
3345                         break; }
3346
3347                         case 23: {
3348                                 NDR_CHECK(ndr_push_samr_UserInfo23(ndr, NDR_SCALARS, &r->info23));
3349                         break; }
3350
3351                         case 24: {
3352                                 NDR_CHECK(ndr_push_samr_UserInfo24(ndr, NDR_SCALARS, &r->info24));
3353                         break; }
3354
3355                         case 25: {
3356                                 NDR_CHECK(ndr_push_samr_UserInfo25(ndr, NDR_SCALARS, &r->info25));
3357                         break; }
3358
3359                         case 26: {
3360                                 NDR_CHECK(ndr_push_samr_UserInfo26(ndr, NDR_SCALARS, &r->info26));
3361                         break; }
3362
3363                         default:
3364                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3365                 }
3366         }
3367         if (ndr_flags & NDR_BUFFERS) {
3368                 int level = ndr_push_get_switch_value(ndr, r);
3369                 switch (level) {
3370                         case 1:
3371                                 NDR_CHECK(ndr_push_samr_UserInfo1(ndr, NDR_BUFFERS, &r->info1));
3372                         break;
3373
3374                         case 2:
3375                                 NDR_CHECK(ndr_push_samr_UserInfo2(ndr, NDR_BUFFERS, &r->info2));
3376                         break;
3377
3378                         case 3:
3379                                 NDR_CHECK(ndr_push_samr_UserInfo3(ndr, NDR_BUFFERS, &r->info3));
3380                         break;
3381
3382                         case 4:
3383                                 NDR_CHECK(ndr_push_samr_UserInfo4(ndr, NDR_BUFFERS, &r->info4));
3384                         break;
3385
3386                         case 5:
3387                                 NDR_CHECK(ndr_push_samr_UserInfo5(ndr, NDR_BUFFERS, &r->info5));
3388                         break;
3389
3390                         case 6:
3391                                 NDR_CHECK(ndr_push_samr_UserInfo6(ndr, NDR_BUFFERS, &r->info6));
3392                         break;
3393
3394                         case 7:
3395                                 NDR_CHECK(ndr_push_samr_UserInfo7(ndr, NDR_BUFFERS, &r->info7));
3396                         break;
3397
3398                         case 8:
3399                                 NDR_CHECK(ndr_push_samr_UserInfo8(ndr, NDR_BUFFERS, &r->info8));
3400                         break;
3401
3402                         case 9:
3403                         break;
3404
3405                         case 10:
3406                                 NDR_CHECK(ndr_push_samr_UserInfo10(ndr, NDR_BUFFERS, &r->info10));
3407                         break;
3408
3409                         case 11:
3410                                 NDR_CHECK(ndr_push_samr_UserInfo11(ndr, NDR_BUFFERS, &r->info11));
3411                         break;
3412
3413                         case 12:
3414                                 NDR_CHECK(ndr_push_samr_UserInfo12(ndr, NDR_BUFFERS, &r->info12));
3415                         break;
3416
3417                         case 13:
3418                                 NDR_CHECK(ndr_push_samr_UserInfo13(ndr, NDR_BUFFERS, &r->info13));
3419                         break;
3420
3421                         case 14:
3422                                 NDR_CHECK(ndr_push_samr_UserInfo14(ndr, NDR_BUFFERS, &r->info14));
3423                         break;
3424
3425                         case 16:
3426                         break;
3427
3428                         case 17:
3429                         break;
3430
3431                         case 18:
3432                         break;
3433
3434                         case 20:
3435                                 NDR_CHECK(ndr_push_samr_UserInfo20(ndr, NDR_BUFFERS, &r->info20));
3436                         break;
3437
3438                         case 21:
3439                                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info21));
3440                         break;
3441
3442                         case 23:
3443                                 NDR_CHECK(ndr_push_samr_UserInfo23(ndr, NDR_BUFFERS, &r->info23));
3444                         break;
3445
3446                         case 24:
3447                         break;
3448
3449                         case 25:
3450                                 NDR_CHECK(ndr_push_samr_UserInfo25(ndr, NDR_BUFFERS, &r->info25));
3451                         break;
3452
3453                         case 26:
3454                         break;
3455
3456                         default:
3457                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3458                 }
3459         }
3460         return NDR_ERR_SUCCESS;
3461 }
3462
3463 static enum ndr_err_code ndr_pull_samr_UserInfo(struct ndr_pull *ndr, int ndr_flags, union samr_UserInfo *r)
3464 {
3465         int level;
3466         uint16_t _level;
3467         level = ndr_pull_get_switch_value(ndr, r);
3468         if (ndr_flags & NDR_SCALARS) {
3469                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
3470                 if (_level != level) {
3471                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3472                 }
3473                 switch (level) {
3474                         case 1: {
3475                                 NDR_CHECK(ndr_pull_samr_UserInfo1(ndr, NDR_SCALARS, &r->info1));
3476                         break; }
3477
3478                         case 2: {
3479                                 NDR_CHECK(ndr_pull_samr_UserInfo2(ndr, NDR_SCALARS, &r->info2));
3480                         break; }
3481
3482                         case 3: {
3483                                 NDR_CHECK(ndr_pull_samr_UserInfo3(ndr, NDR_SCALARS, &r->info3));
3484                         break; }
3485
3486                         case 4: {
3487                                 NDR_CHECK(ndr_pull_samr_UserInfo4(ndr, NDR_SCALARS, &r->info4));
3488                         break; }
3489
3490                         case 5: {
3491                                 NDR_CHECK(ndr_pull_samr_UserInfo5(ndr, NDR_SCALARS, &r->info5));
3492                         break; }
3493
3494                         case 6: {
3495                                 NDR_CHECK(ndr_pull_samr_UserInfo6(ndr, NDR_SCALARS, &r->info6));
3496                         break; }
3497
3498                         case 7: {
3499                                 NDR_CHECK(ndr_pull_samr_UserInfo7(ndr, NDR_SCALARS, &r->info7));
3500                         break; }
3501
3502                         case 8: {
3503                                 NDR_CHECK(ndr_pull_samr_UserInfo8(ndr, NDR_SCALARS, &r->info8));
3504                         break; }
3505
3506                         case 9: {
3507                                 NDR_CHECK(ndr_pull_samr_UserInfo9(ndr, NDR_SCALARS, &r->info9));
3508                         break; }
3509
3510                         case 10: {
3511                                 NDR_CHECK(ndr_pull_samr_UserInfo10(ndr, NDR_SCALARS, &r->info10));
3512                         break; }
3513
3514                         case 11: {
3515                                 NDR_CHECK(ndr_pull_samr_UserInfo11(ndr, NDR_SCALARS, &r->info11));
3516                         break; }
3517
3518                         case 12: {
3519                                 NDR_CHECK(ndr_pull_samr_UserInfo12(ndr, NDR_SCALARS, &r->info12));
3520                         break; }
3521
3522                         case 13: {
3523                                 NDR_CHECK(ndr_pull_samr_UserInfo13(ndr, NDR_SCALARS, &r->info13));
3524                         break; }
3525
3526                         case 14: {
3527                                 NDR_CHECK(ndr_pull_samr_UserInfo14(ndr, NDR_SCALARS, &r->info14));
3528                         break; }
3529
3530                         case 16: {
3531                                 NDR_CHECK(ndr_pull_samr_UserInfo16(ndr, NDR_SCALARS, &r->info16));
3532                         break; }
3533
3534                         case 17: {
3535                                 NDR_CHECK(ndr_pull_samr_UserInfo17(ndr, NDR_SCALARS, &r->info17));
3536                         break; }
3537
3538                         case 18: {
3539                                 NDR_CHECK(ndr_pull_samr_UserInfo18(ndr, NDR_SCALARS, &r->info18));
3540                         break; }
3541
3542                         case 20: {
3543                                 NDR_CHECK(ndr_pull_samr_UserInfo20(ndr, NDR_SCALARS, &r->info20));
3544                         break; }
3545
3546                         case 21: {
3547                                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info21));
3548                         break; }
3549
3550                         case 23: {
3551                                 NDR_CHECK(ndr_pull_samr_UserInfo23(ndr, NDR_SCALARS, &r->info23));
3552                         break; }
3553
3554                         case 24: {
3555                                 NDR_CHECK(ndr_pull_samr_UserInfo24(ndr, NDR_SCALARS, &r->info24));
3556                         break; }
3557
3558                         case 25: {
3559                                 NDR_CHECK(ndr_pull_samr_UserInfo25(ndr, NDR_SCALARS, &r->info25));
3560                         break; }
3561
3562                         case 26: {
3563                                 NDR_CHECK(ndr_pull_samr_UserInfo26(ndr, NDR_SCALARS, &r->info26));
3564                         break; }
3565
3566                         default:
3567                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3568                 }
3569         }
3570         if (ndr_flags & NDR_BUFFERS) {
3571                 switch (level) {
3572                         case 1:
3573                                 NDR_CHECK(ndr_pull_samr_UserInfo1(ndr, NDR_BUFFERS, &r->info1));
3574                         break;
3575
3576                         case 2:
3577                                 NDR_CHECK(ndr_pull_samr_UserInfo2(ndr, NDR_BUFFERS, &r->info2));
3578                         break;
3579
3580                         case 3:
3581                                 NDR_CHECK(ndr_pull_samr_UserInfo3(ndr, NDR_BUFFERS, &r->info3));
3582                         break;
3583
3584                         case 4:
3585                                 NDR_CHECK(ndr_pull_samr_UserInfo4(ndr, NDR_BUFFERS, &r->info4));
3586                         break;
3587
3588                         case 5:
3589                                 NDR_CHECK(ndr_pull_samr_UserInfo5(ndr, NDR_BUFFERS, &r->info5));
3590                         break;
3591
3592                         case 6:
3593                                 NDR_CHECK(ndr_pull_samr_UserInfo6(ndr, NDR_BUFFERS, &r->info6));
3594                         break;
3595
3596                         case 7:
3597                                 NDR_CHECK(ndr_pull_samr_UserInfo7(ndr, NDR_BUFFERS, &r->info7));
3598                         break;
3599
3600                         case 8:
3601                                 NDR_CHECK(ndr_pull_samr_UserInfo8(ndr, NDR_BUFFERS, &r->info8));
3602                         break;
3603
3604                         case 9:
3605                         break;
3606
3607                         case 10:
3608                                 NDR_CHECK(ndr_pull_samr_UserInfo10(ndr, NDR_BUFFERS, &r->info10));
3609                         break;
3610
3611                         case 11:
3612                                 NDR_CHECK(ndr_pull_samr_UserInfo11(ndr, NDR_BUFFERS, &r->info11));
3613                         break;
3614
3615                         case 12:
3616                                 NDR_CHECK(ndr_pull_samr_UserInfo12(ndr, NDR_BUFFERS, &r->info12));
3617                         break;
3618
3619                         case 13:
3620                                 NDR_CHECK(ndr_pull_samr_UserInfo13(ndr, NDR_BUFFERS, &r->info13));
3621                         break;
3622
3623                         case 14:
3624                                 NDR_CHECK(ndr_pull_samr_UserInfo14(ndr, NDR_BUFFERS, &r->info14));
3625                         break;
3626
3627                         case 16:
3628                         break;
3629
3630                         case 17:
3631                         break;
3632
3633                         case 18:
3634                         break;
3635
3636                         case 20:
3637                                 NDR_CHECK(ndr_pull_samr_UserInfo20(ndr, NDR_BUFFERS, &r->info20));
3638                         break;
3639
3640                         case 21:
3641                                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info21));
3642                         break;
3643
3644                         case 23:
3645                                 NDR_CHECK(ndr_pull_samr_UserInfo23(ndr, NDR_BUFFERS, &r->info23));
3646                         break;
3647
3648                         case 24:
3649                         break;
3650
3651                         case 25:
3652                                 NDR_CHECK(ndr_pull_samr_UserInfo25(ndr, NDR_BUFFERS, &r->info25));
3653                         break;
3654
3655                         case 26:
3656                         break;
3657
3658                         default:
3659                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3660                 }
3661         }
3662         return NDR_ERR_SUCCESS;
3663 }
3664
3665 _PUBLIC_ void ndr_print_samr_UserInfo(struct ndr_print *ndr, const char *name, const union samr_UserInfo *r)
3666 {
3667         int level;
3668         level = ndr_print_get_switch_value(ndr, r);
3669         ndr_print_union(ndr, name, level, "samr_UserInfo");
3670         switch (level) {
3671                 case 1:
3672                         ndr_print_samr_UserInfo1(ndr, "info1", &r->info1);
3673                 break;
3674
3675                 case 2:
3676                         ndr_print_samr_UserInfo2(ndr, "info2", &r->info2);
3677                 break;
3678
3679                 case 3:
3680                         ndr_print_samr_UserInfo3(ndr, "info3", &r->info3);
3681                 break;
3682
3683                 case 4:
3684                         ndr_print_samr_UserInfo4(ndr, "info4", &r->info4);
3685                 break;
3686
3687                 case 5:
3688                         ndr_print_samr_UserInfo5(ndr, "info5", &r->info5);
3689                 break;
3690
3691                 case 6:
3692                         ndr_print_samr_UserInfo6(ndr, "info6", &r->info6);
3693                 break;
3694
3695                 case 7:
3696                         ndr_print_samr_UserInfo7(ndr, "info7", &r->info7);
3697                 break;
3698
3699                 case 8:
3700                         ndr_print_samr_UserInfo8(ndr, "info8", &r->info8);
3701                 break;
3702
3703                 case 9:
3704                         ndr_print_samr_UserInfo9(ndr, "info9", &r->info9);
3705                 break;
3706
3707                 case 10:
3708                         ndr_print_samr_UserInfo10(ndr, "info10", &r->info10);
3709                 break;
3710
3711                 case 11:
3712                         ndr_print_samr_UserInfo11(ndr, "info11", &r->info11);
3713                 break;
3714
3715                 case 12:
3716                         ndr_print_samr_UserInfo12(ndr, "info12", &r->info12);
3717                 break;
3718
3719                 case 13:
3720                         ndr_print_samr_UserInfo13(ndr, "info13", &r->info13);
3721                 break;
3722
3723                 case 14:
3724                         ndr_print_samr_UserInfo14(ndr, "info14", &r->info14);
3725                 break;
3726
3727                 case 16:
3728                         ndr_print_samr_UserInfo16(ndr, "info16", &r->info16);
3729                 break;
3730
3731                 case 17:
3732                         ndr_print_samr_UserInfo17(ndr, "info17", &r->info17);
3733                 break;
3734
3735                 case 18:
3736                         ndr_print_samr_UserInfo18(ndr, "info18", &r->info18);
3737                 break;
3738
3739                 case 20:
3740                         ndr_print_samr_UserInfo20(ndr, "info20", &r->info20);
3741                 break;
3742
3743                 case 21:
3744                         ndr_print_samr_UserInfo21(ndr, "info21", &r->info21);
3745                 break;
3746
3747                 case 23:
3748                         ndr_print_samr_UserInfo23(ndr, "info23", &r->info23);
3749                 break;
3750
3751                 case 24:
3752                         ndr_print_samr_UserInfo24(ndr, "info24", &r->info24);
3753                 break;
3754
3755                 case 25:
3756                         ndr_print_samr_UserInfo25(ndr, "info25", &r->info25);
3757                 break;
3758
3759                 case 26:
3760                         ndr_print_samr_UserInfo26(ndr, "info26", &r->info26);
3761                 break;
3762
3763                 default:
3764                         ndr_print_bad_level(ndr, name, level);
3765         }
3766 }
3767
3768 _PUBLIC_ enum ndr_err_code ndr_push_samr_RidWithAttribute(struct ndr_push *ndr, int ndr_flags, const struct samr_RidWithAttribute *r)
3769 {
3770         if (ndr_flags & NDR_SCALARS) {
3771                 NDR_CHECK(ndr_push_align(ndr, 4));
3772                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
3773                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
3774         }
3775         if (ndr_flags & NDR_BUFFERS) {
3776         }
3777         return NDR_ERR_SUCCESS;
3778 }
3779
3780 _PUBLIC_ enum ndr_err_code ndr_pull_samr_RidWithAttribute(struct ndr_pull *ndr, int ndr_flags, struct samr_RidWithAttribute *r)
3781 {
3782         if (ndr_flags & NDR_SCALARS) {
3783                 NDR_CHECK(ndr_pull_align(ndr, 4));
3784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
3785                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
3786         }
3787         if (ndr_flags & NDR_BUFFERS) {
3788         }
3789         return NDR_ERR_SUCCESS;
3790 }
3791
3792 _PUBLIC_ void ndr_print_samr_RidWithAttribute(struct ndr_print *ndr, const char *name, const struct samr_RidWithAttribute *r)
3793 {
3794         ndr_print_struct(ndr, name, "samr_RidWithAttribute");
3795         ndr->depth++;
3796         ndr_print_uint32(ndr, "rid", r->rid);
3797         ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);
3798         ndr->depth--;
3799 }
3800
3801 _PUBLIC_ enum ndr_err_code ndr_push_samr_RidWithAttributeArray(struct ndr_push *ndr, int ndr_flags, const struct samr_RidWithAttributeArray *r)
3802 {
3803         uint32_t cntr_rids_1;
3804         if (ndr_flags & NDR_SCALARS) {
3805                 NDR_CHECK(ndr_push_align(ndr, 5));
3806                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3807                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->rids));
3808         }
3809         if (ndr_flags & NDR_BUFFERS) {
3810                 if (r->rids) {
3811                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
3812                         for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {
3813                                 NDR_CHECK(ndr_push_samr_RidWithAttribute(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));
3814                         }
3815                 }
3816         }
3817         return NDR_ERR_SUCCESS;
3818 }
3819
3820 _PUBLIC_ enum ndr_err_code ndr_pull_samr_RidWithAttributeArray(struct ndr_pull *ndr, int ndr_flags, struct samr_RidWithAttributeArray *r)
3821 {
3822         uint32_t _ptr_rids;
3823         uint32_t cntr_rids_1;
3824         TALLOC_CTX *_mem_save_rids_0;
3825         TALLOC_CTX *_mem_save_rids_1;
3826         if (ndr_flags & NDR_SCALARS) {
3827                 NDR_CHECK(ndr_pull_align(ndr, 5));
3828                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3829                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
3830                 if (_ptr_rids) {
3831                         NDR_PULL_ALLOC(ndr, r->rids);
3832                 } else {
3833                         r->rids = NULL;
3834                 }
3835         }
3836         if (ndr_flags & NDR_BUFFERS) {
3837                 if (r->rids) {
3838                         _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
3839                         NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
3840                         NDR_CHECK(ndr_pull_array_size(ndr, &r->rids));
3841                         NDR_PULL_ALLOC_N(ndr, r->rids, ndr_get_array_size(ndr, &r->rids));
3842                         _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
3843                         NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
3844                         for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {
3845                                 NDR_CHECK(ndr_pull_samr_RidWithAttribute(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));
3846                         }
3847                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
3848                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
3849                 }
3850                 if (r->rids) {
3851                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->rids, r->count));
3852                 }
3853         }
3854         return NDR_ERR_SUCCESS;
3855 }
3856
3857 _PUBLIC_ void ndr_print_samr_RidWithAttributeArray(struct ndr_print *ndr, const char *name, const struct samr_RidWithAttributeArray *r)
3858 {
3859         uint32_t cntr_rids_1;
3860         ndr_print_struct(ndr, name, "samr_RidWithAttributeArray");
3861         ndr->depth++;
3862         ndr_print_uint32(ndr, "count", r->count);
3863         ndr_print_ptr(ndr, "rids", r->rids);
3864         ndr->depth++;
3865         if (r->rids) {
3866                 ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->count);
3867                 ndr->depth++;
3868                 for (cntr_rids_1=0;cntr_rids_1<r->count;cntr_rids_1++) {
3869                         char *idx_1=NULL;
3870                         if (asprintf(&idx_1, "[%d]", cntr_rids_1) != -1) {
3871                                 ndr_print_samr_RidWithAttribute(ndr, "rids", &r->rids[cntr_rids_1]);
3872                                 free(idx_1);
3873                         }
3874                 }
3875                 ndr->depth--;
3876         }
3877         ndr->depth--;
3878         ndr->depth--;
3879 }
3880
3881 static enum ndr_err_code ndr_push_samr_DispEntryGeneral(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryGeneral *r)
3882 {
3883         if (ndr_flags & NDR_SCALARS) {
3884                 NDR_CHECK(ndr_push_align(ndr, 5));
3885                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
3886                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
3887                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
3888                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
3889                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
3890                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
3891         }
3892         if (ndr_flags & NDR_BUFFERS) {
3893                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
3894                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
3895                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
3896         }
3897         return NDR_ERR_SUCCESS;
3898 }
3899
3900 static enum ndr_err_code ndr_pull_samr_DispEntryGeneral(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryGeneral *r)
3901 {
3902         if (ndr_flags & NDR_SCALARS) {
3903                 NDR_CHECK(ndr_pull_align(ndr, 5));
3904                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
3905                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
3906                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
3907                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
3908                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
3909                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
3910         }
3911         if (ndr_flags & NDR_BUFFERS) {
3912                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
3913                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
3914                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
3915         }
3916         return NDR_ERR_SUCCESS;
3917 }
3918
3919 _PUBLIC_ void ndr_print_samr_DispEntryGeneral(struct ndr_print *ndr, const char *name, const struct samr_DispEntryGeneral *r)
3920 {
3921         ndr_print_struct(ndr, name, "samr_DispEntryGeneral");
3922         ndr->depth++;
3923         ndr_print_uint32(ndr, "idx", r->idx);
3924         ndr_print_uint32(ndr, "rid", r->rid);
3925         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
3926         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
3927         ndr_print_lsa_String(ndr, "description", &r->description);
3928         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
3929         ndr->depth--;
3930 }
3931
3932 static enum ndr_err_code ndr_push_samr_DispInfoGeneral(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoGeneral *r)
3933 {
3934         uint32_t cntr_entries_1;
3935         if (ndr_flags & NDR_SCALARS) {
3936                 NDR_CHECK(ndr_push_align(ndr, 5));
3937                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3938                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
3939         }
3940         if (ndr_flags & NDR_BUFFERS) {
3941                 if (r->entries) {
3942                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
3943                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
3944                                 NDR_CHECK(ndr_push_samr_DispEntryGeneral(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
3945                         }
3946                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
3947                                 NDR_CHECK(ndr_push_samr_DispEntryGeneral(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
3948                         }
3949                 }
3950         }
3951         return NDR_ERR_SUCCESS;
3952 }
3953
3954 static enum ndr_err_code ndr_pull_samr_DispInfoGeneral(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoGeneral *r)
3955 {
3956         uint32_t _ptr_entries;
3957         uint32_t cntr_entries_1;
3958         TALLOC_CTX *_mem_save_entries_0;
3959         TALLOC_CTX *_mem_save_entries_1;
3960         if (ndr_flags & NDR_SCALARS) {
3961                 NDR_CHECK(ndr_pull_align(ndr, 5));
3962                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3963                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
3964                 if (_ptr_entries) {
3965                         NDR_PULL_ALLOC(ndr, r->entries);
3966                 } else {
3967                         r->entries = NULL;
3968                 }
3969         }
3970         if (ndr_flags & NDR_BUFFERS) {
3971                 if (r->entries) {
3972                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
3973                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
3974                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
3975                         NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
3976                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
3977                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
3978                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
3979                                 NDR_CHECK(ndr_pull_samr_DispEntryGeneral(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
3980                         }
3981                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
3982                                 NDR_CHECK(ndr_pull_samr_DispEntryGeneral(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
3983                         }
3984                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
3985                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
3986                 }
3987                 if (r->entries) {
3988                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
3989                 }
3990         }
3991         return NDR_ERR_SUCCESS;
3992 }
3993
3994 _PUBLIC_ void ndr_print_samr_DispInfoGeneral(struct ndr_print *ndr, const char *name, const struct samr_DispInfoGeneral *r)
3995 {
3996         uint32_t cntr_entries_1;
3997         ndr_print_struct(ndr, name, "samr_DispInfoGeneral");
3998         ndr->depth++;
3999         ndr_print_uint32(ndr, "count", r->count);
4000         ndr_print_ptr(ndr, "entries", r->entries);
4001         ndr->depth++;
4002         if (r->entries) {
4003                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
4004                 ndr->depth++;
4005                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
4006                         char *idx_1=NULL;
4007                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
4008                                 ndr_print_samr_DispEntryGeneral(ndr, "entries", &r->entries[cntr_entries_1]);
4009                                 free(idx_1);
4010                         }
4011                 }
4012                 ndr->depth--;
4013         }
4014         ndr->depth--;
4015         ndr->depth--;
4016 }
4017
4018 static enum ndr_err_code ndr_push_samr_DispEntryFull(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryFull *r)
4019 {
4020         if (ndr_flags & NDR_SCALARS) {
4021                 NDR_CHECK(ndr_push_align(ndr, 5));
4022                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
4023                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
4024                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
4025                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
4026                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
4027         }
4028         if (ndr_flags & NDR_BUFFERS) {
4029                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
4030                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
4031         }
4032         return NDR_ERR_SUCCESS;
4033 }
4034
4035 static enum ndr_err_code ndr_pull_samr_DispEntryFull(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryFull *r)
4036 {
4037         if (ndr_flags & NDR_SCALARS) {
4038                 NDR_CHECK(ndr_pull_align(ndr, 5));
4039                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
4040                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
4041                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
4042                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
4043                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
4044         }
4045         if (ndr_flags & NDR_BUFFERS) {
4046                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
4047                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
4048         }
4049         return NDR_ERR_SUCCESS;
4050 }
4051
4052 _PUBLIC_ void ndr_print_samr_DispEntryFull(struct ndr_print *ndr, const char *name, const struct samr_DispEntryFull *r)
4053 {
4054         ndr_print_struct(ndr, name, "samr_DispEntryFull");
4055         ndr->depth++;
4056         ndr_print_uint32(ndr, "idx", r->idx);
4057         ndr_print_uint32(ndr, "rid", r->rid);
4058         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
4059         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
4060         ndr_print_lsa_String(ndr, "description", &r->description);
4061         ndr->depth--;
4062 }
4063
4064 static enum ndr_err_code ndr_push_samr_DispInfoFull(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoFull *r)
4065 {
4066         uint32_t cntr_entries_1;
4067         if (ndr_flags & NDR_SCALARS) {
4068                 NDR_CHECK(ndr_push_align(ndr, 5));
4069                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4070                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
4071         }
4072         if (ndr_flags & NDR_BUFFERS) {
4073                 if (r->entries) {
4074                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
4075                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4076                                 NDR_CHECK(ndr_push_samr_DispEntryFull(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4077                         }
4078                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4079                                 NDR_CHECK(ndr_push_samr_DispEntryFull(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4080                         }
4081                 }
4082         }
4083         return NDR_ERR_SUCCESS;
4084 }
4085
4086 static enum ndr_err_code ndr_pull_samr_DispInfoFull(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoFull *r)
4087 {
4088         uint32_t _ptr_entries;
4089         uint32_t cntr_entries_1;
4090         TALLOC_CTX *_mem_save_entries_0;
4091         TALLOC_CTX *_mem_save_entries_1;
4092         if (ndr_flags & NDR_SCALARS) {
4093                 NDR_CHECK(ndr_pull_align(ndr, 5));
4094                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4095                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
4096                 if (_ptr_entries) {
4097                         NDR_PULL_ALLOC(ndr, r->entries);
4098                 } else {
4099                         r->entries = NULL;
4100                 }
4101         }
4102         if (ndr_flags & NDR_BUFFERS) {
4103                 if (r->entries) {
4104                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
4105                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4106                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
4107                         NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
4108                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
4109                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4110                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4111                                 NDR_CHECK(ndr_pull_samr_DispEntryFull(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4112                         }
4113                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4114                                 NDR_CHECK(ndr_pull_samr_DispEntryFull(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4115                         }
4116                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
4117                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
4118                 }
4119                 if (r->entries) {
4120                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
4121                 }
4122         }
4123         return NDR_ERR_SUCCESS;
4124 }
4125
4126 _PUBLIC_ void ndr_print_samr_DispInfoFull(struct ndr_print *ndr, const char *name, const struct samr_DispInfoFull *r)
4127 {
4128         uint32_t cntr_entries_1;
4129         ndr_print_struct(ndr, name, "samr_DispInfoFull");
4130         ndr->depth++;
4131         ndr_print_uint32(ndr, "count", r->count);
4132         ndr_print_ptr(ndr, "entries", r->entries);
4133         ndr->depth++;
4134         if (r->entries) {
4135                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
4136                 ndr->depth++;
4137                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
4138                         char *idx_1=NULL;
4139                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
4140                                 ndr_print_samr_DispEntryFull(ndr, "entries", &r->entries[cntr_entries_1]);
4141                                 free(idx_1);
4142                         }
4143                 }
4144                 ndr->depth--;
4145         }
4146         ndr->depth--;
4147         ndr->depth--;
4148 }
4149
4150 static enum ndr_err_code ndr_push_samr_DispEntryFullGroup(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryFullGroup *r)
4151 {
4152         if (ndr_flags & NDR_SCALARS) {
4153                 NDR_CHECK(ndr_push_align(ndr, 5));
4154                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
4155                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
4156                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->acct_flags));
4157                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
4158                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
4159         }
4160         if (ndr_flags & NDR_BUFFERS) {
4161                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
4162                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
4163         }
4164         return NDR_ERR_SUCCESS;
4165 }
4166
4167 static enum ndr_err_code ndr_pull_samr_DispEntryFullGroup(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryFullGroup *r)
4168 {
4169         if (ndr_flags & NDR_SCALARS) {
4170                 NDR_CHECK(ndr_pull_align(ndr, 5));
4171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
4172                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
4173                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->acct_flags));
4174                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
4175                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
4176         }
4177         if (ndr_flags & NDR_BUFFERS) {
4178                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
4179                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
4180         }
4181         return NDR_ERR_SUCCESS;
4182 }
4183
4184 _PUBLIC_ void ndr_print_samr_DispEntryFullGroup(struct ndr_print *ndr, const char *name, const struct samr_DispEntryFullGroup *r)
4185 {
4186         ndr_print_struct(ndr, name, "samr_DispEntryFullGroup");
4187         ndr->depth++;
4188         ndr_print_uint32(ndr, "idx", r->idx);
4189         ndr_print_uint32(ndr, "rid", r->rid);
4190         ndr_print_samr_GroupAttrs(ndr, "acct_flags", r->acct_flags);
4191         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
4192         ndr_print_lsa_String(ndr, "description", &r->description);
4193         ndr->depth--;
4194 }
4195
4196 static enum ndr_err_code ndr_push_samr_DispInfoFullGroups(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoFullGroups *r)
4197 {
4198         uint32_t cntr_entries_1;
4199         if (ndr_flags & NDR_SCALARS) {
4200                 NDR_CHECK(ndr_push_align(ndr, 5));
4201                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4202                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
4203         }
4204         if (ndr_flags & NDR_BUFFERS) {
4205                 if (r->entries) {
4206                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
4207                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4208                                 NDR_CHECK(ndr_push_samr_DispEntryFullGroup(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4209                         }
4210                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4211                                 NDR_CHECK(ndr_push_samr_DispEntryFullGroup(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4212                         }
4213                 }
4214         }
4215         return NDR_ERR_SUCCESS;
4216 }
4217
4218 static enum ndr_err_code ndr_pull_samr_DispInfoFullGroups(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoFullGroups *r)
4219 {
4220         uint32_t _ptr_entries;
4221         uint32_t cntr_entries_1;
4222         TALLOC_CTX *_mem_save_entries_0;
4223         TALLOC_CTX *_mem_save_entries_1;
4224         if (ndr_flags & NDR_SCALARS) {
4225                 NDR_CHECK(ndr_pull_align(ndr, 5));
4226                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4227                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
4228                 if (_ptr_entries) {
4229                         NDR_PULL_ALLOC(ndr, r->entries);
4230                 } else {
4231                         r->entries = NULL;
4232                 }
4233         }
4234         if (ndr_flags & NDR_BUFFERS) {
4235                 if (r->entries) {
4236                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
4237                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4238                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
4239                         NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
4240                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
4241                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4242                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4243                                 NDR_CHECK(ndr_pull_samr_DispEntryFullGroup(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4244                         }
4245                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4246                                 NDR_CHECK(ndr_pull_samr_DispEntryFullGroup(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4247                         }
4248                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
4249                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
4250                 }
4251                 if (r->entries) {
4252                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
4253                 }
4254         }
4255         return NDR_ERR_SUCCESS;
4256 }
4257
4258 _PUBLIC_ void ndr_print_samr_DispInfoFullGroups(struct ndr_print *ndr, const char *name, const struct samr_DispInfoFullGroups *r)
4259 {
4260         uint32_t cntr_entries_1;
4261         ndr_print_struct(ndr, name, "samr_DispInfoFullGroups");
4262         ndr->depth++;
4263         ndr_print_uint32(ndr, "count", r->count);
4264         ndr_print_ptr(ndr, "entries", r->entries);
4265         ndr->depth++;
4266         if (r->entries) {
4267                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
4268                 ndr->depth++;
4269                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
4270                         char *idx_1=NULL;
4271                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
4272                                 ndr_print_samr_DispEntryFullGroup(ndr, "entries", &r->entries[cntr_entries_1]);
4273                                 free(idx_1);
4274                         }
4275                 }
4276                 ndr->depth--;
4277         }
4278         ndr->depth--;
4279         ndr->depth--;
4280 }
4281
4282 static enum ndr_err_code ndr_push_samr_DispEntryAscii(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryAscii *r)
4283 {
4284         if (ndr_flags & NDR_SCALARS) {
4285                 NDR_CHECK(ndr_push_align(ndr, 5));
4286                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
4287                 NDR_CHECK(ndr_push_lsa_AsciiStringLarge(ndr, NDR_SCALARS, &r->account_name));
4288         }
4289         if (ndr_flags & NDR_BUFFERS) {
4290                 NDR_CHECK(ndr_push_lsa_AsciiStringLarge(ndr, NDR_BUFFERS, &r->account_name));
4291         }
4292         return NDR_ERR_SUCCESS;
4293 }
4294
4295 static enum ndr_err_code ndr_pull_samr_DispEntryAscii(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryAscii *r)
4296 {
4297         if (ndr_flags & NDR_SCALARS) {
4298                 NDR_CHECK(ndr_pull_align(ndr, 5));
4299                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
4300                 NDR_CHECK(ndr_pull_lsa_AsciiStringLarge(ndr, NDR_SCALARS, &r->account_name));
4301         }
4302         if (ndr_flags & NDR_BUFFERS) {
4303                 NDR_CHECK(ndr_pull_lsa_AsciiStringLarge(ndr, NDR_BUFFERS, &r->account_name));
4304         }
4305         return NDR_ERR_SUCCESS;
4306 }
4307
4308 _PUBLIC_ void ndr_print_samr_DispEntryAscii(struct ndr_print *ndr, const char *name, const struct samr_DispEntryAscii *r)
4309 {
4310         ndr_print_struct(ndr, name, "samr_DispEntryAscii");
4311         ndr->depth++;
4312         ndr_print_uint32(ndr, "idx", r->idx);
4313         ndr_print_lsa_AsciiStringLarge(ndr, "account_name", &r->account_name);
4314         ndr->depth--;
4315 }
4316
4317 static enum ndr_err_code ndr_push_samr_DispInfoAscii(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoAscii *r)
4318 {
4319         uint32_t cntr_entries_1;
4320         if (ndr_flags & NDR_SCALARS) {
4321                 NDR_CHECK(ndr_push_align(ndr, 5));
4322                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4323                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
4324         }
4325         if (ndr_flags & NDR_BUFFERS) {
4326                 if (r->entries) {
4327                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
4328                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4329                                 NDR_CHECK(ndr_push_samr_DispEntryAscii(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4330                         }
4331                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4332                                 NDR_CHECK(ndr_push_samr_DispEntryAscii(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4333                         }
4334                 }
4335         }
4336         return NDR_ERR_SUCCESS;
4337 }
4338
4339 static enum ndr_err_code ndr_pull_samr_DispInfoAscii(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoAscii *r)
4340 {
4341         uint32_t _ptr_entries;
4342         uint32_t cntr_entries_1;
4343         TALLOC_CTX *_mem_save_entries_0;
4344         TALLOC_CTX *_mem_save_entries_1;
4345         if (ndr_flags & NDR_SCALARS) {
4346                 NDR_CHECK(ndr_pull_align(ndr, 5));
4347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4348                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
4349                 if (_ptr_entries) {
4350                         NDR_PULL_ALLOC(ndr, r->entries);
4351                 } else {
4352                         r->entries = NULL;
4353                 }
4354         }
4355         if (ndr_flags & NDR_BUFFERS) {
4356                 if (r->entries) {
4357                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
4358                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4359                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
4360                         NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
4361                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
4362                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4363                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4364                                 NDR_CHECK(ndr_pull_samr_DispEntryAscii(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4365                         }
4366                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4367                                 NDR_CHECK(ndr_pull_samr_DispEntryAscii(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4368                         }
4369                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
4370                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
4371                 }
4372                 if (r->entries) {
4373                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
4374                 }
4375         }
4376         return NDR_ERR_SUCCESS;
4377 }
4378
4379 _PUBLIC_ void ndr_print_samr_DispInfoAscii(struct ndr_print *ndr, const char *name, const struct samr_DispInfoAscii *r)
4380 {
4381         uint32_t cntr_entries_1;
4382         ndr_print_struct(ndr, name, "samr_DispInfoAscii");
4383         ndr->depth++;
4384         ndr_print_uint32(ndr, "count", r->count);
4385         ndr_print_ptr(ndr, "entries", r->entries);
4386         ndr->depth++;
4387         if (r->entries) {
4388                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
4389                 ndr->depth++;
4390                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
4391                         char *idx_1=NULL;
4392                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
4393                                 ndr_print_samr_DispEntryAscii(ndr, "entries", &r->entries[cntr_entries_1]);
4394                                 free(idx_1);
4395                         }
4396                 }
4397                 ndr->depth--;
4398         }
4399         ndr->depth--;
4400         ndr->depth--;
4401 }
4402
4403 static enum ndr_err_code ndr_push_samr_DispInfo(struct ndr_push *ndr, int ndr_flags, const union samr_DispInfo *r)
4404 {
4405         if (ndr_flags & NDR_SCALARS) {
4406                 int level = ndr_push_get_switch_value(ndr, r);
4407                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
4408                 switch (level) {
4409                         case 1: {
4410                                 NDR_CHECK(ndr_push_samr_DispInfoGeneral(ndr, NDR_SCALARS, &r->info1));
4411                         break; }
4412
4413                         case 2: {
4414                                 NDR_CHECK(ndr_push_samr_DispInfoFull(ndr, NDR_SCALARS, &r->info2));
4415                         break; }
4416
4417                         case 3: {
4418                                 NDR_CHECK(ndr_push_samr_DispInfoFullGroups(ndr, NDR_SCALARS, &r->info3));
4419                         break; }
4420
4421                         case 4: {
4422                                 NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info4));
4423                         break; }
4424
4425                         case 5: {
4426                                 NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info5));
4427                         break; }
4428
4429                         default:
4430                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4431                 }
4432         }
4433         if (ndr_flags & NDR_BUFFERS) {
4434                 int level = ndr_push_get_switch_value(ndr, r);
4435                 switch (level) {
4436                         case 1:
4437                                 NDR_CHECK(ndr_push_samr_DispInfoGeneral(ndr, NDR_BUFFERS, &r->info1));
4438                         break;
4439
4440                         case 2:
4441                                 NDR_CHECK(ndr_push_samr_DispInfoFull(ndr, NDR_BUFFERS, &r->info2));
4442                         break;
4443
4444                         case 3:
4445                                 NDR_CHECK(ndr_push_samr_DispInfoFullGroups(ndr, NDR_BUFFERS, &r->info3));
4446                         break;
4447
4448                         case 4:
4449                                 NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info4));
4450                         break;
4451
4452                         case 5:
4453                                 NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info5));
4454                         break;
4455
4456                         default:
4457                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4458                 }
4459         }
4460         return NDR_ERR_SUCCESS;
4461 }
4462
4463 static enum ndr_err_code ndr_pull_samr_DispInfo(struct ndr_pull *ndr, int ndr_flags, union samr_DispInfo *r)
4464 {
4465         int level;
4466         uint16_t _level;
4467         level = ndr_pull_get_switch_value(ndr, r);
4468         if (ndr_flags & NDR_SCALARS) {
4469                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
4470                 if (_level != level) {
4471                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4472                 }
4473                 switch (level) {
4474                         case 1: {
4475                                 NDR_CHECK(ndr_pull_samr_DispInfoGeneral(ndr, NDR_SCALARS, &r->info1));
4476                         break; }
4477
4478                         case 2: {
4479                                 NDR_CHECK(ndr_pull_samr_DispInfoFull(ndr, NDR_SCALARS, &r->info2));
4480                         break; }
4481
4482                         case 3: {
4483                                 NDR_CHECK(ndr_pull_samr_DispInfoFullGroups(ndr, NDR_SCALARS, &r->info3));
4484                         break; }
4485
4486                         case 4: {
4487                                 NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info4));
4488                         break; }
4489
4490                         case 5: {
4491                                 NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info5));
4492                         break; }
4493
4494                         default:
4495                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4496                 }
4497         }
4498         if (ndr_flags & NDR_BUFFERS) {
4499                 switch (level) {
4500                         case 1:
4501                                 NDR_CHECK(ndr_pull_samr_DispInfoGeneral(ndr, NDR_BUFFERS, &r->info1));
4502                         break;
4503
4504                         case 2:
4505                                 NDR_CHECK(ndr_pull_samr_DispInfoFull(ndr, NDR_BUFFERS, &r->info2));
4506                         break;
4507
4508                         case 3:
4509                                 NDR_CHECK(ndr_pull_samr_DispInfoFullGroups(ndr, NDR_BUFFERS, &r->info3));
4510                         break;
4511
4512                         case 4:
4513                                 NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info4));
4514                         break;
4515
4516                         case 5:
4517                                 NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info5));
4518                         break;
4519
4520                         default:
4521                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4522                 }
4523         }
4524         return NDR_ERR_SUCCESS;
4525 }
4526
4527 _PUBLIC_ void ndr_print_samr_DispInfo(struct ndr_print *ndr, const char *name, const union samr_DispInfo *r)
4528 {
4529         int level;
4530         level = ndr_print_get_switch_value(ndr, r);
4531         ndr_print_union(ndr, name, level, "samr_DispInfo");
4532         switch (level) {
4533                 case 1:
4534                         ndr_print_samr_DispInfoGeneral(ndr, "info1", &r->info1);
4535                 break;
4536
4537                 case 2:
4538                         ndr_print_samr_DispInfoFull(ndr, "info2", &r->info2);
4539                 break;
4540
4541                 case 3:
4542                         ndr_print_samr_DispInfoFullGroups(ndr, "info3", &r->info3);
4543                 break;
4544
4545                 case 4:
4546                         ndr_print_samr_DispInfoAscii(ndr, "info4", &r->info4);
4547                 break;
4548
4549                 case 5:
4550                         ndr_print_samr_DispInfoAscii(ndr, "info5", &r->info5);
4551                 break;
4552
4553                 default:
4554                         ndr_print_bad_level(ndr, name, level);
4555         }
4556 }
4557
4558 static enum ndr_err_code ndr_push_samr_PwInfo(struct ndr_push *ndr, int ndr_flags, const struct samr_PwInfo *r)
4559 {
4560         if (ndr_flags & NDR_SCALARS) {
4561                 NDR_CHECK(ndr_push_align(ndr, 4));
4562                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->min_password_length));
4563                 NDR_CHECK(ndr_push_samr_PasswordProperties(ndr, NDR_SCALARS, r->password_properties));
4564         }
4565         if (ndr_flags & NDR_BUFFERS) {
4566         }
4567         return NDR_ERR_SUCCESS;
4568 }
4569
4570 static enum ndr_err_code ndr_pull_samr_PwInfo(struct ndr_pull *ndr, int ndr_flags, struct samr_PwInfo *r)
4571 {
4572         if (ndr_flags & NDR_SCALARS) {
4573                 NDR_CHECK(ndr_pull_align(ndr, 4));
4574                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->min_password_length));
4575                 NDR_CHECK(ndr_pull_samr_PasswordProperties(ndr, NDR_SCALARS, &r->password_properties));
4576         }
4577         if (ndr_flags & NDR_BUFFERS) {
4578         }
4579         return NDR_ERR_SUCCESS;
4580 }
4581
4582 _PUBLIC_ void ndr_print_samr_PwInfo(struct ndr_print *ndr, const char *name, const struct samr_PwInfo *r)
4583 {
4584         ndr_print_struct(ndr, name, "samr_PwInfo");
4585         ndr->depth++;
4586         ndr_print_uint16(ndr, "min_password_length", r->min_password_length);
4587         ndr_print_samr_PasswordProperties(ndr, "password_properties", r->password_properties);
4588         ndr->depth--;
4589 }
4590
4591 static enum ndr_err_code ndr_push_samr_ConnectVersion(struct ndr_push *ndr, int ndr_flags, enum samr_ConnectVersion r)
4592 {
4593         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
4594         return NDR_ERR_SUCCESS;
4595 }
4596
4597 static enum ndr_err_code ndr_pull_samr_ConnectVersion(struct ndr_pull *ndr, int ndr_flags, enum samr_ConnectVersion *r)
4598 {
4599         uint32_t v;
4600         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
4601         *r = v;
4602         return NDR_ERR_SUCCESS;
4603 }
4604
4605 _PUBLIC_ void ndr_print_samr_ConnectVersion(struct ndr_print *ndr, const char *name, enum samr_ConnectVersion r)
4606 {
4607         const char *val = NULL;
4608
4609         switch (r) {
4610                 case SAMR_CONNECT_PRE_W2K: val = "SAMR_CONNECT_PRE_W2K"; break;
4611                 case SAMR_CONNECT_W2K: val = "SAMR_CONNECT_W2K"; break;
4612                 case SAMR_CONNECT_AFTER_W2K: val = "SAMR_CONNECT_AFTER_W2K"; break;
4613         }
4614         ndr_print_enum(ndr, name, "ENUM", val, r);
4615 }
4616
4617 static enum ndr_err_code ndr_push_samr_ChangeReject(struct ndr_push *ndr, int ndr_flags, const struct samr_ChangeReject *r)
4618 {
4619         if (ndr_flags & NDR_SCALARS) {
4620                 NDR_CHECK(ndr_push_align(ndr, 4));
4621                 NDR_CHECK(ndr_push_samr_RejectReason(ndr, NDR_SCALARS, r->reason));
4622                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
4623                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
4624         }
4625         if (ndr_flags & NDR_BUFFERS) {
4626         }
4627         return NDR_ERR_SUCCESS;
4628 }
4629
4630 static enum ndr_err_code ndr_pull_samr_ChangeReject(struct ndr_pull *ndr, int ndr_flags, struct samr_ChangeReject *r)
4631 {
4632         if (ndr_flags & NDR_SCALARS) {
4633                 NDR_CHECK(ndr_pull_align(ndr, 4));
4634                 NDR_CHECK(ndr_pull_samr_RejectReason(ndr, NDR_SCALARS, &r->reason));
4635                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
4636                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
4637         }
4638         if (ndr_flags & NDR_BUFFERS) {
4639         }
4640         return NDR_ERR_SUCCESS;
4641 }
4642
4643 _PUBLIC_ void ndr_print_samr_ChangeReject(struct ndr_print *ndr, const char *name, const struct samr_ChangeReject *r)
4644 {
4645         ndr_print_struct(ndr, name, "samr_ChangeReject");
4646         ndr->depth++;
4647         ndr_print_samr_RejectReason(ndr, "reason", r->reason);
4648         ndr_print_uint32(ndr, "unknown1", r->unknown1);
4649         ndr_print_uint32(ndr, "unknown2", r->unknown2);
4650         ndr->depth--;
4651 }
4652
4653 static enum ndr_err_code ndr_push_samr_ConnectInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_ConnectInfo1 *r)
4654 {
4655         if (ndr_flags & NDR_SCALARS) {
4656                 NDR_CHECK(ndr_push_align(ndr, 4));
4657                 NDR_CHECK(ndr_push_samr_ConnectVersion(ndr, NDR_SCALARS, r->client_version));
4658                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
4659         }
4660         if (ndr_flags & NDR_BUFFERS) {
4661         }
4662         return NDR_ERR_SUCCESS;
4663 }
4664
4665 static enum ndr_err_code ndr_pull_samr_ConnectInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_ConnectInfo1 *r)
4666 {
4667         if (ndr_flags & NDR_SCALARS) {
4668                 NDR_CHECK(ndr_pull_align(ndr, 4));
4669                 NDR_CHECK(ndr_pull_samr_ConnectVersion(ndr, NDR_SCALARS, &r->client_version));
4670                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
4671         }
4672         if (ndr_flags & NDR_BUFFERS) {
4673         }
4674         return NDR_ERR_SUCCESS;
4675 }
4676
4677 _PUBLIC_ void ndr_print_samr_ConnectInfo1(struct ndr_print *ndr, const char *name, const struct samr_ConnectInfo1 *r)
4678 {
4679         ndr_print_struct(ndr, name, "samr_ConnectInfo1");
4680         ndr->depth++;
4681         ndr_print_samr_ConnectVersion(ndr, "client_version", r->client_version);
4682         ndr_print_uint32(ndr, "unknown2", r->unknown2);
4683         ndr->depth--;
4684 }
4685
4686 static enum ndr_err_code ndr_push_samr_ConnectInfo(struct ndr_push *ndr, int ndr_flags, const union samr_ConnectInfo *r)
4687 {
4688         if (ndr_flags & NDR_SCALARS) {
4689                 int level = ndr_push_get_switch_value(ndr, r);
4690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4691                 switch (level) {
4692                         case 1: {
4693                                 NDR_CHECK(ndr_push_samr_ConnectInfo1(ndr, NDR_SCALARS, &r->info1));
4694                         break; }
4695
4696                         default:
4697                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4698                 }
4699         }
4700         if (ndr_flags & NDR_BUFFERS) {
4701                 int level = ndr_push_get_switch_value(ndr, r);
4702                 switch (level) {
4703                         case 1:
4704                         break;
4705
4706                         default:
4707                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4708                 }
4709         }
4710         return NDR_ERR_SUCCESS;
4711 }
4712
4713 static enum ndr_err_code ndr_pull_samr_ConnectInfo(struct ndr_pull *ndr, int ndr_flags, union samr_ConnectInfo *r)
4714 {
4715         int level;
4716         uint32_t _level;
4717         level = ndr_pull_get_switch_value(ndr, r);
4718         if (ndr_flags & NDR_SCALARS) {
4719                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4720                 if (_level != level) {
4721                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4722                 }
4723                 switch (level) {
4724                         case 1: {
4725                                 NDR_CHECK(ndr_pull_samr_ConnectInfo1(ndr, NDR_SCALARS, &r->info1));
4726                         break; }
4727
4728                         default:
4729                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4730                 }
4731         }
4732         if (ndr_flags & NDR_BUFFERS) {
4733                 switch (level) {
4734                         case 1:
4735                         break;
4736
4737                         default:
4738                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4739                 }
4740         }
4741         return NDR_ERR_SUCCESS;
4742 }
4743
4744 _PUBLIC_ void ndr_print_samr_ConnectInfo(struct ndr_print *ndr, const char *name, const union samr_ConnectInfo *r)
4745 {
4746         int level;
4747         level = ndr_print_get_switch_value(ndr, r);
4748         ndr_print_union(ndr, name, level, "samr_ConnectInfo");
4749         switch (level) {
4750                 case 1:
4751                         ndr_print_samr_ConnectInfo1(ndr, "info1", &r->info1);
4752                 break;
4753
4754                 default:
4755                         ndr_print_bad_level(ndr, name, level);
4756         }
4757 }
4758
4759 static enum ndr_err_code ndr_push_samr_ValidateFieldsPresent(struct ndr_push *ndr, int ndr_flags, uint32_t r)
4760 {
4761         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4762         return NDR_ERR_SUCCESS;
4763 }
4764
4765 static enum ndr_err_code ndr_pull_samr_ValidateFieldsPresent(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
4766 {
4767         uint32_t v;
4768         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4769         *r = v;
4770         return NDR_ERR_SUCCESS;
4771 }
4772
4773 _PUBLIC_ void ndr_print_samr_ValidateFieldsPresent(struct ndr_print *ndr, const char *name, uint32_t r)
4774 {
4775         ndr_print_uint32(ndr, name, r);
4776         ndr->depth++;
4777         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_LAST_SET", SAMR_VALIDATE_FIELD_PASSWORD_LAST_SET, r);
4778         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_BAD_PASSWORD_TIME", SAMR_VALIDATE_FIELD_BAD_PASSWORD_TIME, r);
4779         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_LOCKOUT_TIME", SAMR_VALIDATE_FIELD_LOCKOUT_TIME, r);
4780         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_BAD_PASSWORD_COUNT", SAMR_VALIDATE_FIELD_BAD_PASSWORD_COUNT, r);
4781         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_HISTORY_LENGTH", SAMR_VALIDATE_FIELD_PASSWORD_HISTORY_LENGTH, r);
4782         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_HISTORY", SAMR_VALIDATE_FIELD_PASSWORD_HISTORY, r);
4783         ndr->depth--;
4784 }
4785
4786 static enum ndr_err_code ndr_push_samr_ValidatePasswordLevel(struct ndr_push *ndr, int ndr_flags, enum samr_ValidatePasswordLevel r)
4787 {
4788         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
4789         return NDR_ERR_SUCCESS;
4790 }
4791
4792 static enum ndr_err_code ndr_pull_samr_ValidatePasswordLevel(struct ndr_pull *ndr, int ndr_flags, enum samr_ValidatePasswordLevel *r)
4793 {
4794         uint16_t v;
4795         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
4796         *r = v;
4797         return NDR_ERR_SUCCESS;
4798 }
4799
4800 _PUBLIC_ void ndr_print_samr_ValidatePasswordLevel(struct ndr_print *ndr, const char *name, enum samr_ValidatePasswordLevel r)
4801 {
4802         const char *val = NULL;
4803
4804         switch (r) {
4805                 case NetValidateAuthentication: val = "NetValidateAuthentication"; break;
4806                 case NetValidatePasswordChange: val = "NetValidatePasswordChange"; break;
4807                 case NetValidatePasswordReset: val = "NetValidatePasswordReset"; break;
4808         }
4809         ndr_print_enum(ndr, name, "ENUM", val, r);
4810 }
4811
4812 static enum ndr_err_code ndr_push_samr_ValidationStatus(struct ndr_push *ndr, int ndr_flags, enum samr_ValidationStatus r)
4813 {
4814         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
4815         return NDR_ERR_SUCCESS;
4816 }
4817
4818 static enum ndr_err_code ndr_pull_samr_ValidationStatus(struct ndr_pull *ndr, int ndr_flags, enum samr_ValidationStatus *r)
4819 {
4820         uint16_t v;
4821         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
4822         *r = v;
4823         return NDR_ERR_SUCCESS;
4824 }
4825
4826 _PUBLIC_ void ndr_print_samr_ValidationStatus(struct ndr_print *ndr, const char *name, enum samr_ValidationStatus r)
4827 {
4828         const char *val = NULL;
4829
4830         switch (r) {
4831                 case SAMR_VALIDATION_STATUS_SUCCESS: val = "SAMR_VALIDATION_STATUS_SUCCESS"; break;
4832                 case SAMR_VALIDATION_STATUS_PASSWORD_MUST_CHANGE: val = "SAMR_VALIDATION_STATUS_PASSWORD_MUST_CHANGE"; break;
4833                 case SAMR_VALIDATION_STATUS_ACCOUNT_LOCKED_OUT: val = "SAMR_VALIDATION_STATUS_ACCOUNT_LOCKED_OUT"; break;
4834                 case SAMR_VALIDATION_STATUS_PASSWORD_EXPIRED: val = "SAMR_VALIDATION_STATUS_PASSWORD_EXPIRED"; break;
4835                 case SAMR_VALIDATION_STATUS_BAD_PASSWORD: val = "SAMR_VALIDATION_STATUS_BAD_PASSWORD"; break;
4836                 case SAMR_VALIDATION_STATUS_PWD_HISTORY_CONFLICT: val = "SAMR_VALIDATION_STATUS_PWD_HISTORY_CONFLICT"; break;
4837                 case SAMR_VALIDATION_STATUS_PWD_TOO_SHORT: val = "SAMR_VALIDATION_STATUS_PWD_TOO_SHORT"; break;
4838                 case SAMR_VALIDATION_STATUS_PWD_TOO_LONG: val = "SAMR_VALIDATION_STATUS_PWD_TOO_LONG"; break;
4839                 case SAMR_VALIDATION_STATUS_NOT_COMPLEX_ENOUGH: val = "SAMR_VALIDATION_STATUS_NOT_COMPLEX_ENOUGH"; break;
4840                 case SAMR_VALIDATION_STATUS_PASSWORD_TOO_RECENT: val = "SAMR_VALIDATION_STATUS_PASSWORD_TOO_RECENT"; break;
4841                 case SAMR_VALIDATION_STATUS_PASSWORD_FILTER_ERROR: val = "SAMR_VALIDATION_STATUS_PASSWORD_FILTER_ERROR"; break;
4842         }
4843         ndr_print_enum(ndr, name, "ENUM", val, r);
4844 }
4845
4846 static enum ndr_err_code ndr_push_samr_ValidationBlob(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidationBlob *r)
4847 {
4848         if (ndr_flags & NDR_SCALARS) {
4849                 NDR_CHECK(ndr_push_align(ndr, 5));
4850                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
4851                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
4852         }
4853         if (ndr_flags & NDR_BUFFERS) {
4854                 if (r->data) {
4855                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
4856                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
4857                 }
4858         }
4859         return NDR_ERR_SUCCESS;
4860 }
4861
4862 static enum ndr_err_code ndr_pull_samr_ValidationBlob(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidationBlob *r)
4863 {
4864         uint32_t _ptr_data;
4865         TALLOC_CTX *_mem_save_data_0;
4866         if (ndr_flags & NDR_SCALARS) {
4867                 NDR_CHECK(ndr_pull_align(ndr, 5));
4868                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
4869                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
4870                 if (_ptr_data) {
4871                         NDR_PULL_ALLOC(ndr, r->data);
4872                 } else {
4873                         r->data = NULL;
4874                 }
4875         }
4876         if (ndr_flags & NDR_BUFFERS) {
4877                 if (r->data) {
4878                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
4879                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
4880                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
4881                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
4882                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
4883                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
4884                 }
4885                 if (r->data) {
4886                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
4887                 }
4888         }
4889         return NDR_ERR_SUCCESS;
4890 }
4891
4892 _PUBLIC_ void ndr_print_samr_ValidationBlob(struct ndr_print *ndr, const char *name, const struct samr_ValidationBlob *r)
4893 {
4894         ndr_print_struct(ndr, name, "samr_ValidationBlob");
4895         ndr->depth++;
4896         ndr_print_uint32(ndr, "length", r->length);
4897         ndr_print_ptr(ndr, "data", r->data);
4898         ndr->depth++;
4899         if (r->data) {
4900                 ndr_print_array_uint8(ndr, "data", r->data, r->length);
4901         }
4902         ndr->depth--;
4903         ndr->depth--;
4904 }
4905
4906 static enum ndr_err_code ndr_push_samr_ValidatePasswordInfo(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordInfo *r)
4907 {
4908         uint32_t cntr_pwd_history_1;
4909         if (ndr_flags & NDR_SCALARS) {
4910                 NDR_CHECK(ndr_push_align(ndr, 8));
4911                 NDR_CHECK(ndr_push_samr_ValidateFieldsPresent(ndr, NDR_SCALARS, r->fields_present));
4912                 NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->last_password_change));
4913                 NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->bad_password_time));
4914                 NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->lockout_time));
4915                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bad_pwd_count));
4916                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pwd_history_len));
4917                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pwd_history));
4918         }
4919         if (ndr_flags & NDR_BUFFERS) {
4920                 if (r->pwd_history) {
4921                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->pwd_history_len));
4922                         for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {
4923                                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->pwd_history[cntr_pwd_history_1]));
4924                         }
4925                         for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {
4926                                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->pwd_history[cntr_pwd_history_1]));
4927                         }
4928                 }
4929         }
4930         return NDR_ERR_SUCCESS;
4931 }
4932
4933 static enum ndr_err_code ndr_pull_samr_ValidatePasswordInfo(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordInfo *r)
4934 {
4935         uint32_t _ptr_pwd_history;
4936         uint32_t cntr_pwd_history_1;
4937         TALLOC_CTX *_mem_save_pwd_history_0;
4938         TALLOC_CTX *_mem_save_pwd_history_1;
4939         if (ndr_flags & NDR_SCALARS) {
4940                 NDR_CHECK(ndr_pull_align(ndr, 8));
4941                 NDR_CHECK(ndr_pull_samr_ValidateFieldsPresent(ndr, NDR_SCALARS, &r->fields_present));
4942                 NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->last_password_change));
4943                 NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->bad_password_time));
4944                 NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->lockout_time));
4945                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bad_pwd_count));
4946                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pwd_history_len));
4947                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pwd_history));
4948                 if (_ptr_pwd_history) {
4949                         NDR_PULL_ALLOC(ndr, r->pwd_history);
4950                 } else {
4951                         r->pwd_history = NULL;
4952                 }
4953         }
4954         if (ndr_flags & NDR_BUFFERS) {
4955                 if (r->pwd_history) {
4956                         _mem_save_pwd_history_0 = NDR_PULL_GET_MEM_CTX(ndr);
4957                         NDR_PULL_SET_MEM_CTX(ndr, r->pwd_history, 0);
4958                         NDR_CHECK(ndr_pull_array_size(ndr, &r->pwd_history));
4959                         NDR_PULL_ALLOC_N(ndr, r->pwd_history, ndr_get_array_size(ndr, &r->pwd_history));
4960                         _mem_save_pwd_history_1 = NDR_PULL_GET_MEM_CTX(ndr);
4961                         NDR_PULL_SET_MEM_CTX(ndr, r->pwd_history, 0);
4962                         for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {
4963                                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->pwd_history[cntr_pwd_history_1]));
4964                         }
4965                         for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {
4966                                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->pwd_history[cntr_pwd_history_1]));
4967                         }
4968                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pwd_history_1, 0);
4969                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pwd_history_0, 0);
4970                 }
4971                 if (r->pwd_history) {
4972                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->pwd_history, r->pwd_history_len));
4973                 }
4974         }
4975         return NDR_ERR_SUCCESS;
4976 }
4977
4978 _PUBLIC_ void ndr_print_samr_ValidatePasswordInfo(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordInfo *r)
4979 {
4980         uint32_t cntr_pwd_history_1;
4981         ndr_print_struct(ndr, name, "samr_ValidatePasswordInfo");
4982         ndr->depth++;
4983         ndr_print_samr_ValidateFieldsPresent(ndr, "fields_present", r->fields_present);
4984         ndr_print_NTTIME_hyper(ndr, "last_password_change", r->last_password_change);
4985         ndr_print_NTTIME_hyper(ndr, "bad_password_time", r->bad_password_time);
4986         ndr_print_NTTIME_hyper(ndr, "lockout_time", r->lockout_time);
4987         ndr_print_uint32(ndr, "bad_pwd_count", r->bad_pwd_count);
4988         ndr_print_uint32(ndr, "pwd_history_len", r->pwd_history_len);
4989         ndr_print_ptr(ndr, "pwd_history", r->pwd_history);
4990         ndr->depth++;
4991         if (r->pwd_history) {
4992                 ndr->print(ndr, "%s: ARRAY(%d)", "pwd_history", (int)r->pwd_history_len);
4993                 ndr->depth++;
4994                 for (cntr_pwd_history_1=0;cntr_pwd_history_1<r->pwd_history_len;cntr_pwd_history_1++) {
4995                         char *idx_1=NULL;
4996                         if (asprintf(&idx_1, "[%d]", cntr_pwd_history_1) != -1) {
4997                                 ndr_print_samr_ValidationBlob(ndr, "pwd_history", &r->pwd_history[cntr_pwd_history_1]);
4998                                 free(idx_1);
4999                         }
5000                 }
5001                 ndr->depth--;
5002         }
5003         ndr->depth--;
5004         ndr->depth--;
5005 }
5006
5007 static enum ndr_err_code ndr_push_samr_ValidatePasswordRepCtr(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordRepCtr *r)
5008 {
5009         if (ndr_flags & NDR_SCALARS) {
5010                 NDR_CHECK(ndr_push_align(ndr, 8));
5011                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5012                 NDR_CHECK(ndr_push_samr_ValidationStatus(ndr, NDR_SCALARS, r->status));
5013         }
5014         if (ndr_flags & NDR_BUFFERS) {
5015                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5016         }
5017         return NDR_ERR_SUCCESS;
5018 }
5019
5020 static enum ndr_err_code ndr_pull_samr_ValidatePasswordRepCtr(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordRepCtr *r)
5021 {
5022         if (ndr_flags & NDR_SCALARS) {
5023                 NDR_CHECK(ndr_pull_align(ndr, 8));
5024                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5025                 NDR_CHECK(ndr_pull_samr_ValidationStatus(ndr, NDR_SCALARS, &r->status));
5026         }
5027         if (ndr_flags & NDR_BUFFERS) {
5028                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5029         }
5030         return NDR_ERR_SUCCESS;
5031 }
5032
5033 _PUBLIC_ void ndr_print_samr_ValidatePasswordRepCtr(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordRepCtr *r)
5034 {
5035         ndr_print_struct(ndr, name, "samr_ValidatePasswordRepCtr");
5036         ndr->depth++;
5037         ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
5038         ndr_print_samr_ValidationStatus(ndr, "status", r->status);
5039         ndr->depth--;
5040 }
5041
5042 static enum ndr_err_code ndr_push_samr_ValidatePasswordRep(struct ndr_push *ndr, int ndr_flags, const union samr_ValidatePasswordRep *r)
5043 {
5044         if (ndr_flags & NDR_SCALARS) {
5045                 int level = ndr_push_get_switch_value(ndr, r);
5046                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
5047                 switch (level) {
5048                         case 1: {
5049                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr1));
5050                         break; }
5051
5052                         case 2: {
5053                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr2));
5054                         break; }
5055
5056                         case 3: {
5057                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr3));
5058                         break; }
5059
5060                         default:
5061                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5062                 }
5063         }
5064         if (ndr_flags & NDR_BUFFERS) {
5065                 int level = ndr_push_get_switch_value(ndr, r);
5066                 switch (level) {
5067                         case 1:
5068                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr1));
5069                         break;
5070
5071                         case 2:
5072                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr2));
5073                         break;
5074
5075                         case 3:
5076                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr3));
5077                         break;
5078
5079                         default:
5080                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5081                 }
5082         }
5083         return NDR_ERR_SUCCESS;
5084 }
5085
5086 static enum ndr_err_code ndr_pull_samr_ValidatePasswordRep(struct ndr_pull *ndr, int ndr_flags, union samr_ValidatePasswordRep *r)
5087 {
5088         int level;
5089         uint16_t _level;
5090         level = ndr_pull_get_switch_value(ndr, r);
5091         if (ndr_flags & NDR_SCALARS) {
5092                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
5093                 if (_level != level) {
5094                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5095                 }
5096                 switch (level) {
5097                         case 1: {
5098                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr1));
5099                         break; }
5100
5101                         case 2: {
5102                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr2));
5103                         break; }
5104
5105                         case 3: {
5106                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr3));
5107                         break; }
5108
5109                         default:
5110                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5111                 }
5112         }
5113         if (ndr_flags & NDR_BUFFERS) {
5114                 switch (level) {
5115                         case 1:
5116                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr1));
5117                         break;
5118
5119                         case 2:
5120                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr2));
5121                         break;
5122
5123                         case 3:
5124                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr3));
5125                         break;
5126
5127                         default:
5128                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5129                 }
5130         }
5131         return NDR_ERR_SUCCESS;
5132 }
5133
5134 _PUBLIC_ void ndr_print_samr_ValidatePasswordRep(struct ndr_print *ndr, const char *name, const union samr_ValidatePasswordRep *r)
5135 {
5136         int level;
5137         level = ndr_print_get_switch_value(ndr, r);
5138         ndr_print_union(ndr, name, level, "samr_ValidatePasswordRep");
5139         switch (level) {
5140                 case 1:
5141                         ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr1", &r->ctr1);
5142                 break;
5143
5144                 case 2:
5145                         ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr2", &r->ctr2);
5146                 break;
5147
5148                 case 3:
5149                         ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr3", &r->ctr3);
5150                 break;
5151
5152                 default:
5153                         ndr_print_bad_level(ndr, name, level);
5154         }
5155 }
5156
5157 static enum ndr_err_code ndr_push_samr_ValidatePasswordReq3(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq3 *r)
5158 {
5159         if (ndr_flags & NDR_SCALARS) {
5160                 NDR_CHECK(ndr_push_align(ndr, 8));
5161                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5162                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
5163                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
5164                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
5165                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->pwd_must_change_at_next_logon));
5166                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->clear_lockout));
5167         }
5168         if (ndr_flags & NDR_BUFFERS) {
5169                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5170                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
5171                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
5172                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
5173         }
5174         return NDR_ERR_SUCCESS;
5175 }
5176
5177 static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq3(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq3 *r)
5178 {
5179         if (ndr_flags & NDR_SCALARS) {
5180                 NDR_CHECK(ndr_pull_align(ndr, 8));
5181                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5182                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
5183                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
5184                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
5185                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->pwd_must_change_at_next_logon));
5186                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->clear_lockout));
5187         }
5188         if (ndr_flags & NDR_BUFFERS) {
5189                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5190                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
5191                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
5192                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
5193         }
5194         return NDR_ERR_SUCCESS;
5195 }
5196
5197 _PUBLIC_ void ndr_print_samr_ValidatePasswordReq3(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq3 *r)
5198 {
5199         ndr_print_struct(ndr, name, "samr_ValidatePasswordReq3");
5200         ndr->depth++;
5201         ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
5202         ndr_print_lsa_StringLarge(ndr, "password", &r->password);
5203         ndr_print_lsa_StringLarge(ndr, "account", &r->account);
5204         ndr_print_samr_ValidationBlob(ndr, "hash", &r->hash);
5205         ndr_print_uint8(ndr, "pwd_must_change_at_next_logon", r->pwd_must_change_at_next_logon);
5206         ndr_print_uint8(ndr, "clear_lockout", r->clear_lockout);
5207         ndr->depth--;
5208 }
5209
5210 static enum ndr_err_code ndr_push_samr_ValidatePasswordReq2(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq2 *r)
5211 {
5212         if (ndr_flags & NDR_SCALARS) {
5213                 NDR_CHECK(ndr_push_align(ndr, 8));
5214                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5215                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
5216                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
5217                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
5218                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_matched));
5219         }
5220         if (ndr_flags & NDR_BUFFERS) {
5221                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5222                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
5223                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
5224                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
5225         }
5226         return NDR_ERR_SUCCESS;
5227 }
5228
5229 static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq2(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq2 *r)
5230 {
5231         if (ndr_flags & NDR_SCALARS) {
5232                 NDR_CHECK(ndr_pull_align(ndr, 8));
5233                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5234                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
5235                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
5236                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
5237                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_matched));
5238         }
5239         if (ndr_flags & NDR_BUFFERS) {
5240                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5241                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
5242                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
5243                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
5244         }
5245         return NDR_ERR_SUCCESS;
5246 }
5247
5248 _PUBLIC_ void ndr_print_samr_ValidatePasswordReq2(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq2 *r)
5249 {
5250         ndr_print_struct(ndr, name, "samr_ValidatePasswordReq2");
5251         ndr->depth++;
5252         ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
5253         ndr_print_lsa_StringLarge(ndr, "password", &r->password);
5254         ndr_print_lsa_StringLarge(ndr, "account", &r->account);
5255         ndr_print_samr_ValidationBlob(ndr, "hash", &r->hash);
5256         ndr_print_uint8(ndr, "password_matched", r->password_matched);
5257         ndr->depth--;
5258 }
5259
5260 static enum ndr_err_code ndr_push_samr_ValidatePasswordReq1(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq1 *r)
5261 {
5262         if (ndr_flags & NDR_SCALARS) {
5263                 NDR_CHECK(ndr_push_align(ndr, 8));
5264                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5265                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_matched));
5266         }
5267         if (ndr_flags & NDR_BUFFERS) {
5268                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5269         }
5270         return NDR_ERR_SUCCESS;
5271 }
5272
5273 static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq1(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq1 *r)
5274 {
5275         if (ndr_flags & NDR_SCALARS) {
5276                 NDR_CHECK(ndr_pull_align(ndr, 8));
5277                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5278                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_matched));
5279         }
5280         if (ndr_flags & NDR_BUFFERS) {
5281                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5282         }
5283         return NDR_ERR_SUCCESS;
5284 }
5285
5286 _PUBLIC_ void ndr_print_samr_ValidatePasswordReq1(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq1 *r)
5287 {
5288         ndr_print_struct(ndr, name, "samr_ValidatePasswordReq1");
5289         ndr->depth++;
5290         ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
5291         ndr_print_uint8(ndr, "password_matched", r->password_matched);
5292         ndr->depth--;
5293 }
5294
5295 static enum ndr_err_code ndr_push_samr_ValidatePasswordReq(struct ndr_push *ndr, int ndr_flags, const union samr_ValidatePasswordReq *r)
5296 {
5297         if (ndr_flags & NDR_SCALARS) {
5298                 int level = ndr_push_get_switch_value(ndr, r);
5299                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
5300                 switch (level) {
5301                         case 1: {
5302                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq1(ndr, NDR_SCALARS, &r->req1));
5303                         break; }
5304
5305                         case 2: {
5306                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq2(ndr, NDR_SCALARS, &r->req2));
5307                         break; }
5308
5309                         case 3: {
5310                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq3(ndr, NDR_SCALARS, &r->req3));
5311                         break; }
5312
5313                         default:
5314                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5315                 }
5316         }
5317         if (ndr_flags & NDR_BUFFERS) {
5318                 int level = ndr_push_get_switch_value(ndr, r);
5319                 switch (level) {
5320                         case 1:
5321                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq1(ndr, NDR_BUFFERS, &r->req1));
5322                         break;
5323
5324                         case 2:
5325                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq2(ndr, NDR_BUFFERS, &r->req2));
5326                         break;
5327
5328                         case 3:
5329                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq3(ndr, NDR_BUFFERS, &r->req3));
5330                         break;
5331
5332                         default:
5333                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5334                 }
5335         }
5336         return NDR_ERR_SUCCESS;
5337 }
5338
5339 static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq(struct ndr_pull *ndr, int ndr_flags, union samr_ValidatePasswordReq *r)
5340 {
5341         int level;
5342         uint16_t _level;
5343         level = ndr_pull_get_switch_value(ndr, r);
5344         if (ndr_flags & NDR_SCALARS) {
5345                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
5346                 if (_level != level) {
5347                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5348                 }
5349                 switch (level) {
5350                         case 1: {
5351                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq1(ndr, NDR_SCALARS, &r->req1));
5352                         break; }
5353
5354                         case 2: {
5355                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq2(ndr, NDR_SCALARS, &r->req2));
5356                         break; }
5357
5358                         case 3: {
5359                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq3(ndr, NDR_SCALARS, &r->req3));
5360                         break; }
5361
5362                         default:
5363                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5364                 }
5365         }
5366         if (ndr_flags & NDR_BUFFERS) {
5367                 switch (level) {
5368                         case 1:
5369                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq1(ndr, NDR_BUFFERS, &r->req1));
5370                         break;
5371
5372                         case 2:
5373                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq2(ndr, NDR_BUFFERS, &r->req2));
5374                         break;
5375
5376                         case 3:
5377                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq3(ndr, NDR_BUFFERS, &r->req3));
5378                         break;
5379
5380                         default:
5381                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5382                 }
5383         }
5384         return NDR_ERR_SUCCESS;
5385 }
5386
5387 _PUBLIC_ void ndr_print_samr_ValidatePasswordReq(struct ndr_print *ndr, const char *name, const union samr_ValidatePasswordReq *r)
5388 {
5389         int level;
5390         level = ndr_print_get_switch_value(ndr, r);
5391         ndr_print_union(ndr, name, level, "samr_ValidatePasswordReq");
5392         switch (level) {
5393                 case 1:
5394                         ndr_print_samr_ValidatePasswordReq1(ndr, "req1", &r->req1);
5395                 break;
5396
5397                 case 2:
5398                         ndr_print_samr_ValidatePasswordReq2(ndr, "req2", &r->req2);
5399                 break;
5400
5401                 case 3:
5402                         ndr_print_samr_ValidatePasswordReq3(ndr, "req3", &r->req3);
5403                 break;
5404
5405                 default:
5406                         ndr_print_bad_level(ndr, name, level);
5407         }
5408 }
5409
5410 static enum ndr_err_code ndr_push_samr_Connect(struct ndr_push *ndr, int flags, const struct samr_Connect *r)
5411 {
5412         if (flags & NDR_IN) {
5413                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
5414                 if (r->in.system_name) {
5415                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
5416                 }
5417                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
5418         }
5419         if (flags & NDR_OUT) {
5420                 if (r->out.connect_handle == NULL) {
5421                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5422                 }
5423                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
5424                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5425         }
5426         return NDR_ERR_SUCCESS;
5427 }
5428
5429 static enum ndr_err_code ndr_pull_samr_Connect(struct ndr_pull *ndr, int flags, struct samr_Connect *r)
5430 {
5431         uint32_t _ptr_system_name;
5432         TALLOC_CTX *_mem_save_system_name_0;
5433         TALLOC_CTX *_mem_save_connect_handle_0;
5434         if (flags & NDR_IN) {
5435                 ZERO_STRUCT(r->out);
5436
5437                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
5438                 if (_ptr_system_name) {
5439                         NDR_PULL_ALLOC(ndr, r->in.system_name);
5440                 } else {
5441                         r->in.system_name = NULL;
5442                 }
5443                 if (r->in.system_name) {
5444                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5445                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
5446                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
5447                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
5448                 }
5449                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
5450                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
5451                 ZERO_STRUCTP(r->out.connect_handle);
5452         }
5453         if (flags & NDR_OUT) {
5454                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5455                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
5456                 }
5457                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5458                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
5459                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
5460                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
5461                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5462         }
5463         return NDR_ERR_SUCCESS;
5464 }
5465
5466 _PUBLIC_ void ndr_print_samr_Connect(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect *r)
5467 {
5468         ndr_print_struct(ndr, name, "samr_Connect");
5469         ndr->depth++;
5470         if (flags & NDR_SET_VALUES) {
5471                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5472         }
5473         if (flags & NDR_IN) {
5474                 ndr_print_struct(ndr, "in", "samr_Connect");
5475                 ndr->depth++;
5476                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
5477                 ndr->depth++;
5478                 if (r->in.system_name) {
5479                         ndr_print_uint16(ndr, "system_name", *r->in.system_name);
5480                 }
5481                 ndr->depth--;
5482                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
5483                 ndr->depth--;
5484         }
5485         if (flags & NDR_OUT) {
5486                 ndr_print_struct(ndr, "out", "samr_Connect");
5487                 ndr->depth++;
5488                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
5489                 ndr->depth++;
5490                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
5491                 ndr->depth--;
5492                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5493                 ndr->depth--;
5494         }
5495         ndr->depth--;
5496 }
5497
5498 _PUBLIC_ enum ndr_err_code ndr_push_samr_Close(struct ndr_push *ndr, int flags, const struct samr_Close *r)
5499 {
5500         if (flags & NDR_IN) {
5501                 if (r->in.handle == NULL) {
5502                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5503                 }
5504                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5505         }
5506         if (flags & NDR_OUT) {
5507                 if (r->out.handle == NULL) {
5508                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5509                 }
5510                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
5511                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5512         }
5513         return NDR_ERR_SUCCESS;
5514 }
5515
5516 _PUBLIC_ enum ndr_err_code ndr_pull_samr_Close(struct ndr_pull *ndr, int flags, struct samr_Close *r)
5517 {
5518         TALLOC_CTX *_mem_save_handle_0;
5519         if (flags & NDR_IN) {
5520                 ZERO_STRUCT(r->out);
5521
5522                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5523                         NDR_PULL_ALLOC(ndr, r->in.handle);
5524                 }
5525                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5526                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5527                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5528                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5529                 NDR_PULL_ALLOC(ndr, r->out.handle);
5530                 *r->out.handle = *r->in.handle;
5531         }
5532         if (flags & NDR_OUT) {
5533                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5534                         NDR_PULL_ALLOC(ndr, r->out.handle);
5535                 }
5536                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5537                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
5538                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
5539                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5540                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5541         }
5542         return NDR_ERR_SUCCESS;
5543 }
5544
5545 _PUBLIC_ void ndr_print_samr_Close(struct ndr_print *ndr, const char *name, int flags, const struct samr_Close *r)
5546 {
5547         ndr_print_struct(ndr, name, "samr_Close");
5548         ndr->depth++;
5549         if (flags & NDR_SET_VALUES) {
5550                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5551         }
5552         if (flags & NDR_IN) {
5553                 ndr_print_struct(ndr, "in", "samr_Close");
5554                 ndr->depth++;
5555                 ndr_print_ptr(ndr, "handle", r->in.handle);
5556                 ndr->depth++;
5557                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5558                 ndr->depth--;
5559                 ndr->depth--;
5560         }
5561         if (flags & NDR_OUT) {
5562                 ndr_print_struct(ndr, "out", "samr_Close");
5563                 ndr->depth++;
5564                 ndr_print_ptr(ndr, "handle", r->out.handle);
5565                 ndr->depth++;
5566                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
5567                 ndr->depth--;
5568                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5569                 ndr->depth--;
5570         }
5571         ndr->depth--;
5572 }
5573
5574 static enum ndr_err_code ndr_push_samr_SetSecurity(struct ndr_push *ndr, int flags, const struct samr_SetSecurity *r)
5575 {
5576         if (flags & NDR_IN) {
5577                 if (r->in.handle == NULL) {
5578                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5579                 }
5580                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5581                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
5582                 if (r->in.sdbuf == NULL) {
5583                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5584                 }
5585                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sdbuf));
5586         }
5587         if (flags & NDR_OUT) {
5588                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5589         }
5590         return NDR_ERR_SUCCESS;
5591 }
5592
5593 static enum ndr_err_code ndr_pull_samr_SetSecurity(struct ndr_pull *ndr, int flags, struct samr_SetSecurity *r)
5594 {
5595         TALLOC_CTX *_mem_save_handle_0;
5596         TALLOC_CTX *_mem_save_sdbuf_0;
5597         if (flags & NDR_IN) {
5598                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5599                         NDR_PULL_ALLOC(ndr, r->in.handle);
5600                 }
5601                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5602                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5603                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5604                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5605                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
5606                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5607                         NDR_PULL_ALLOC(ndr, r->in.sdbuf);
5608                 }
5609                 _mem_save_sdbuf_0 = NDR_PULL_GET_MEM_CTX(ndr);
5610                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sdbuf, LIBNDR_FLAG_REF_ALLOC);
5611                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sdbuf));
5612                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_0, LIBNDR_FLAG_REF_ALLOC);
5613         }
5614         if (flags & NDR_OUT) {
5615                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5616         }
5617         return NDR_ERR_SUCCESS;
5618 }
5619
5620 _PUBLIC_ void ndr_print_samr_SetSecurity(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetSecurity *r)
5621 {
5622         ndr_print_struct(ndr, name, "samr_SetSecurity");
5623         ndr->depth++;
5624         if (flags & NDR_SET_VALUES) {
5625                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5626         }
5627         if (flags & NDR_IN) {
5628                 ndr_print_struct(ndr, "in", "samr_SetSecurity");
5629                 ndr->depth++;
5630                 ndr_print_ptr(ndr, "handle", r->in.handle);
5631                 ndr->depth++;
5632                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5633                 ndr->depth--;
5634                 ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
5635                 ndr_print_ptr(ndr, "sdbuf", r->in.sdbuf);
5636                 ndr->depth++;
5637                 ndr_print_sec_desc_buf(ndr, "sdbuf", r->in.sdbuf);
5638                 ndr->depth--;
5639                 ndr->depth--;
5640         }
5641         if (flags & NDR_OUT) {
5642                 ndr_print_struct(ndr, "out", "samr_SetSecurity");
5643                 ndr->depth++;
5644                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5645                 ndr->depth--;
5646         }
5647         ndr->depth--;
5648 }
5649
5650 static enum ndr_err_code ndr_push_samr_QuerySecurity(struct ndr_push *ndr, int flags, const struct samr_QuerySecurity *r)
5651 {
5652         if (flags & NDR_IN) {
5653                 if (r->in.handle == NULL) {
5654                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5655                 }
5656                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5657                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
5658         }
5659         if (flags & NDR_OUT) {
5660                 if (r->out.sdbuf == NULL) {
5661                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5662                 }
5663                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sdbuf));
5664                 if (*r->out.sdbuf) {
5665                         NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sdbuf));
5666                 }
5667                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5668         }
5669         return NDR_ERR_SUCCESS;
5670 }
5671
5672 static enum ndr_err_code ndr_pull_samr_QuerySecurity(struct ndr_pull *ndr, int flags, struct samr_QuerySecurity *r)
5673 {
5674         uint32_t _ptr_sdbuf;
5675         TALLOC_CTX *_mem_save_handle_0;
5676         TALLOC_CTX *_mem_save_sdbuf_0;
5677         TALLOC_CTX *_mem_save_sdbuf_1;
5678         if (flags & NDR_IN) {
5679                 ZERO_STRUCT(r->out);
5680
5681                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5682                         NDR_PULL_ALLOC(ndr, r->in.handle);
5683                 }
5684                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5685                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5686                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5687                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5688                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
5689                 NDR_PULL_ALLOC(ndr, r->out.sdbuf);
5690                 ZERO_STRUCTP(r->out.sdbuf);
5691         }
5692         if (flags & NDR_OUT) {
5693                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5694                         NDR_PULL_ALLOC(ndr, r->out.sdbuf);
5695                 }
5696                 _mem_save_sdbuf_0 = NDR_PULL_GET_MEM_CTX(ndr);
5697                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sdbuf, LIBNDR_FLAG_REF_ALLOC);
5698                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sdbuf));
5699                 if (_ptr_sdbuf) {
5700                         NDR_PULL_ALLOC(ndr, *r->out.sdbuf);
5701                 } else {
5702                         *r->out.sdbuf = NULL;
5703                 }
5704                 if (*r->out.sdbuf) {
5705                         _mem_save_sdbuf_1 = NDR_PULL_GET_MEM_CTX(ndr);
5706                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sdbuf, 0);
5707                         NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sdbuf));
5708                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_1, 0);
5709                 }
5710                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_0, LIBNDR_FLAG_REF_ALLOC);
5711                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5712         }
5713         return NDR_ERR_SUCCESS;
5714 }
5715
5716 _PUBLIC_ void ndr_print_samr_QuerySecurity(struct ndr_print *ndr, const char *name, int flags, const struct samr_QuerySecurity *r)
5717 {
5718         ndr_print_struct(ndr, name, "samr_QuerySecurity");
5719         ndr->depth++;
5720         if (flags & NDR_SET_VALUES) {
5721                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5722         }
5723         if (flags & NDR_IN) {
5724                 ndr_print_struct(ndr, "in", "samr_QuerySecurity");
5725                 ndr->depth++;
5726                 ndr_print_ptr(ndr, "handle", r->in.handle);
5727                 ndr->depth++;
5728                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5729                 ndr->depth--;
5730                 ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
5731                 ndr->depth--;
5732         }
5733         if (flags & NDR_OUT) {
5734                 ndr_print_struct(ndr, "out", "samr_QuerySecurity");
5735                 ndr->depth++;
5736                 ndr_print_ptr(ndr, "sdbuf", r->out.sdbuf);
5737                 ndr->depth++;
5738                 ndr_print_ptr(ndr, "sdbuf", *r->out.sdbuf);
5739                 ndr->depth++;
5740                 if (*r->out.sdbuf) {
5741                         ndr_print_sec_desc_buf(ndr, "sdbuf", *r->out.sdbuf);
5742                 }
5743                 ndr->depth--;
5744                 ndr->depth--;
5745                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5746                 ndr->depth--;
5747         }
5748         ndr->depth--;
5749 }
5750
5751 static enum ndr_err_code ndr_push_samr_Shutdown(struct ndr_push *ndr, int flags, const struct samr_Shutdown *r)
5752 {
5753         if (flags & NDR_IN) {
5754                 if (r->in.connect_handle == NULL) {
5755                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5756                 }
5757                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5758         }
5759         if (flags & NDR_OUT) {
5760                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5761         }
5762         return NDR_ERR_SUCCESS;
5763 }
5764
5765 static enum ndr_err_code ndr_pull_samr_Shutdown(struct ndr_pull *ndr, int flags, struct samr_Shutdown *r)
5766 {
5767         TALLOC_CTX *_mem_save_connect_handle_0;
5768         if (flags & NDR_IN) {
5769                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5770                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
5771                 }
5772                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5773                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
5774                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5775                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
5776         }
5777         if (flags & NDR_OUT) {
5778                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5779         }
5780         return NDR_ERR_SUCCESS;
5781 }
5782
5783 _PUBLIC_ void ndr_print_samr_Shutdown(struct ndr_print *ndr, const char *name, int flags, const struct samr_Shutdown *r)
5784 {
5785         ndr_print_struct(ndr, name, "samr_Shutdown");
5786         ndr->depth++;
5787         if (flags & NDR_SET_VALUES) {
5788                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5789         }
5790         if (flags & NDR_IN) {
5791                 ndr_print_struct(ndr, "in", "samr_Shutdown");
5792                 ndr->depth++;
5793                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
5794                 ndr->depth++;
5795                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
5796                 ndr->depth--;
5797                 ndr->depth--;
5798         }
5799         if (flags & NDR_OUT) {
5800                 ndr_print_struct(ndr, "out", "samr_Shutdown");
5801                 ndr->depth++;
5802                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5803                 ndr->depth--;
5804         }
5805         ndr->depth--;
5806 }
5807
5808 static enum ndr_err_code ndr_push_samr_LookupDomain(struct ndr_push *ndr, int flags, const struct samr_LookupDomain *r)
5809 {
5810         if (flags & NDR_IN) {
5811                 if (r->in.connect_handle == NULL) {
5812                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5813                 }
5814                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5815                 if (r->in.domain_name == NULL) {
5816                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5817                 }
5818                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
5819         }
5820         if (flags & NDR_OUT) {
5821                 if (r->out.sid == NULL) {
5822                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5823                 }
5824                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sid));
5825                 if (*r->out.sid) {
5826                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
5827                 }
5828                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5829         }
5830         return NDR_ERR_SUCCESS;
5831 }
5832
5833 static enum ndr_err_code ndr_pull_samr_LookupDomain(struct ndr_pull *ndr, int flags, struct samr_LookupDomain *r)
5834 {
5835         uint32_t _ptr_sid;
5836         TALLOC_CTX *_mem_save_connect_handle_0;
5837         TALLOC_CTX *_mem_save_domain_name_0;
5838         TALLOC_CTX *_mem_save_sid_0;
5839         TALLOC_CTX *_mem_save_sid_1;
5840         if (flags & NDR_IN) {
5841                 ZERO_STRUCT(r->out);
5842
5843                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5844                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
5845                 }
5846                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5847                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
5848                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5849                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
5850                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5851                         NDR_PULL_ALLOC(ndr, r->in.domain_name);
5852                 }
5853                 _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5854                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_name, LIBNDR_FLAG_REF_ALLOC);
5855                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
5856                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, LIBNDR_FLAG_REF_ALLOC);
5857                 NDR_PULL_ALLOC(ndr, r->out.sid);
5858                 ZERO_STRUCTP(r->out.sid);
5859         }
5860         if (flags & NDR_OUT) {
5861                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5862                         NDR_PULL_ALLOC(ndr, r->out.sid);
5863                 }
5864                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
5865                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);
5866                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
5867                 if (_ptr_sid) {
5868                         NDR_PULL_ALLOC(ndr, *r->out.sid);
5869                 } else {
5870                         *r->out.sid = NULL;
5871                 }
5872                 if (*r->out.sid) {
5873                         _mem_save_sid_1 = NDR_PULL_GET_MEM_CTX(ndr);
5874                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sid, 0);
5875                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
5876                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_1, 0);
5877                 }
5878                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
5879                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5880         }
5881         return NDR_ERR_SUCCESS;
5882 }
5883
5884 _PUBLIC_ void ndr_print_samr_LookupDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupDomain *r)
5885 {
5886         ndr_print_struct(ndr, name, "samr_LookupDomain");
5887         ndr->depth++;
5888         if (flags & NDR_SET_VALUES) {
5889                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5890         }
5891         if (flags & NDR_IN) {
5892                 ndr_print_struct(ndr, "in", "samr_LookupDomain");
5893                 ndr->depth++;
5894                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
5895                 ndr->depth++;
5896                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
5897                 ndr->depth--;
5898                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
5899                 ndr->depth++;
5900                 ndr_print_lsa_String(ndr, "domain_name", r->in.domain_name);
5901                 ndr->depth--;
5902                 ndr->depth--;
5903         }
5904         if (flags & NDR_OUT) {
5905                 ndr_print_struct(ndr, "out", "samr_LookupDomain");
5906                 ndr->depth++;
5907                 ndr_print_ptr(ndr, "sid", r->out.sid);
5908                 ndr->depth++;
5909                 ndr_print_ptr(ndr, "sid", *r->out.sid);
5910                 ndr->depth++;
5911                 if (*r->out.sid) {
5912                         ndr_print_dom_sid2(ndr, "sid", *r->out.sid);
5913                 }
5914                 ndr->depth--;
5915                 ndr->depth--;
5916                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5917                 ndr->depth--;
5918         }
5919         ndr->depth--;
5920 }
5921
5922 static enum ndr_err_code ndr_push_samr_EnumDomains(struct ndr_push *ndr, int flags, const struct samr_EnumDomains *r)
5923 {
5924         if (flags & NDR_IN) {
5925                 if (r->in.connect_handle == NULL) {
5926                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5927                 }
5928                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5929                 if (r->in.resume_handle == NULL) {
5930                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5931                 }
5932                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
5933                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
5934         }
5935         if (flags & NDR_OUT) {
5936                 if (r->out.resume_handle == NULL) {
5937                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5938                 }
5939                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
5940                 if (r->out.sam == NULL) {
5941                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5942                 }
5943                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
5944                 if (*r->out.sam) {
5945                         NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
5946                 }
5947                 if (r->out.num_entries == NULL) {
5948                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5949                 }
5950                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
5951                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5952         }
5953         return NDR_ERR_SUCCESS;
5954 }
5955
5956 static enum ndr_err_code ndr_pull_samr_EnumDomains(struct ndr_pull *ndr, int flags, struct samr_EnumDomains *r)
5957 {
5958         uint32_t _ptr_sam;
5959         TALLOC_CTX *_mem_save_connect_handle_0;
5960         TALLOC_CTX *_mem_save_resume_handle_0;
5961         TALLOC_CTX *_mem_save_sam_0;
5962         TALLOC_CTX *_mem_save_sam_1;
5963         TALLOC_CTX *_mem_save_num_entries_0;
5964         if (flags & NDR_IN) {
5965                 ZERO_STRUCT(r->out);
5966
5967                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5968                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
5969                 }
5970                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5971                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
5972                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5973                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
5974                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5975                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
5976                 }
5977                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5978                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
5979                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
5980                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
5981                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
5982                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
5983                 *r->out.resume_handle = *r->in.resume_handle;
5984                 NDR_PULL_ALLOC(ndr, r->out.sam);
5985                 ZERO_STRUCTP(r->out.sam);
5986                 NDR_PULL_ALLOC(ndr, r->out.num_entries);
5987                 ZERO_STRUCTP(r->out.num_entries);
5988         }
5989         if (flags & NDR_OUT) {
5990                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5991                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
5992                 }
5993                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5994                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
5995                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
5996                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
5997                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5998                         NDR_PULL_ALLOC(ndr, r->out.sam);
5999                 }
6000                 _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
6001                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
6002                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
6003                 if (_ptr_sam) {
6004                         NDR_PULL_ALLOC(ndr, *r->out.sam);
6005                 } else {
6006                         *r->out.sam = NULL;
6007                 }
6008                 if (*r->out.sam) {
6009                         _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
6010                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
6011                         NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6012                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
6013                 }
6014                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
6015                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6016                         NDR_PULL_ALLOC(ndr, r->out.num_entries);
6017                 }
6018                 _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
6019                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
6020                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
6021                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
6022                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6023         }
6024         return NDR_ERR_SUCCESS;
6025 }
6026
6027 _PUBLIC_ void ndr_print_samr_EnumDomains(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomains *r)
6028 {
6029         ndr_print_struct(ndr, name, "samr_EnumDomains");
6030         ndr->depth++;
6031         if (flags & NDR_SET_VALUES) {
6032                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6033         }
6034         if (flags & NDR_IN) {
6035                 ndr_print_struct(ndr, "in", "samr_EnumDomains");
6036                 ndr->depth++;
6037                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
6038                 ndr->depth++;
6039                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
6040                 ndr->depth--;
6041                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6042                 ndr->depth++;
6043                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6044                 ndr->depth--;
6045                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
6046                 ndr->depth--;
6047         }
6048         if (flags & NDR_OUT) {
6049                 ndr_print_struct(ndr, "out", "samr_EnumDomains");
6050                 ndr->depth++;
6051                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6052                 ndr->depth++;
6053                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6054                 ndr->depth--;
6055                 ndr_print_ptr(ndr, "sam", r->out.sam);
6056                 ndr->depth++;
6057                 ndr_print_ptr(ndr, "sam", *r->out.sam);
6058                 ndr->depth++;
6059                 if (*r->out.sam) {
6060                         ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
6061                 }
6062                 ndr->depth--;
6063                 ndr->depth--;
6064                 ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
6065                 ndr->depth++;
6066                 ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
6067                 ndr->depth--;
6068                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6069                 ndr->depth--;
6070         }
6071         ndr->depth--;
6072 }
6073
6074 _PUBLIC_ enum ndr_err_code ndr_push_samr_OpenDomain(struct ndr_push *ndr, int flags, const struct samr_OpenDomain *r)
6075 {
6076         if (flags & NDR_IN) {
6077                 if (r->in.connect_handle == NULL) {
6078                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6079                 }
6080                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
6081                 NDR_CHECK(ndr_push_samr_DomainAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
6082                 if (r->in.sid == NULL) {
6083                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6084                 }
6085                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
6086         }
6087         if (flags & NDR_OUT) {
6088                 if (r->out.domain_handle == NULL) {
6089                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6090                 }
6091                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.domain_handle));
6092                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6093         }
6094         return NDR_ERR_SUCCESS;
6095 }
6096
6097 _PUBLIC_ enum ndr_err_code ndr_pull_samr_OpenDomain(struct ndr_pull *ndr, int flags, struct samr_OpenDomain *r)
6098 {
6099         TALLOC_CTX *_mem_save_connect_handle_0;
6100         TALLOC_CTX *_mem_save_sid_0;
6101         TALLOC_CTX *_mem_save_domain_handle_0;
6102         if (flags & NDR_IN) {
6103                 ZERO_STRUCT(r->out);
6104
6105                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6106                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
6107                 }
6108                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6109                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
6110                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
6111                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
6112                 NDR_CHECK(ndr_pull_samr_DomainAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
6113                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6114                         NDR_PULL_ALLOC(ndr, r->in.sid);
6115                 }
6116                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6117                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
6118                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
6119                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
6120                 NDR_PULL_ALLOC(ndr, r->out.domain_handle);
6121                 ZERO_STRUCTP(r->out.domain_handle);
6122         }
6123         if (flags & NDR_OUT) {
6124                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6125                         NDR_PULL_ALLOC(ndr, r->out.domain_handle);
6126                 }
6127                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6128                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6129                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.domain_handle));
6130                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6131                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6132         }
6133         return NDR_ERR_SUCCESS;
6134 }
6135
6136 _PUBLIC_ void ndr_print_samr_OpenDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenDomain *r)
6137 {
6138         ndr_print_struct(ndr, name, "samr_OpenDomain");
6139         ndr->depth++;
6140         if (flags & NDR_SET_VALUES) {
6141                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6142         }
6143         if (flags & NDR_IN) {
6144                 ndr_print_struct(ndr, "in", "samr_OpenDomain");
6145                 ndr->depth++;
6146                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
6147                 ndr->depth++;
6148                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
6149                 ndr->depth--;
6150                 ndr_print_samr_DomainAccessMask(ndr, "access_mask", r->in.access_mask);
6151                 ndr_print_ptr(ndr, "sid", r->in.sid);
6152                 ndr->depth++;
6153                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
6154                 ndr->depth--;
6155                 ndr->depth--;
6156         }
6157         if (flags & NDR_OUT) {
6158                 ndr_print_struct(ndr, "out", "samr_OpenDomain");
6159                 ndr->depth++;
6160                 ndr_print_ptr(ndr, "domain_handle", r->out.domain_handle);
6161                 ndr->depth++;
6162                 ndr_print_policy_handle(ndr, "domain_handle", r->out.domain_handle);
6163                 ndr->depth--;
6164                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6165                 ndr->depth--;
6166         }
6167         ndr->depth--;
6168 }
6169
6170 static enum ndr_err_code ndr_push_samr_QueryDomainInfo(struct ndr_push *ndr, int flags, const struct samr_QueryDomainInfo *r)
6171 {
6172         if (flags & NDR_IN) {
6173                 if (r->in.domain_handle == NULL) {
6174                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6175                 }
6176                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6177                 NDR_CHECK(ndr_push_samr_DomainInfoClass(ndr, NDR_SCALARS, r->in.level));
6178         }
6179         if (flags & NDR_OUT) {
6180                 if (r->out.info == NULL) {
6181                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6182                 }
6183                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
6184                 if (*r->out.info) {
6185                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
6186                         NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
6187                 }
6188                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6189         }
6190         return NDR_ERR_SUCCESS;
6191 }
6192
6193 static enum ndr_err_code ndr_pull_samr_QueryDomainInfo(struct ndr_pull *ndr, int flags, struct samr_QueryDomainInfo *r)
6194 {
6195         uint32_t _ptr_info;
6196         TALLOC_CTX *_mem_save_domain_handle_0;
6197         TALLOC_CTX *_mem_save_info_0;
6198         TALLOC_CTX *_mem_save_info_1;
6199         if (flags & NDR_IN) {
6200                 ZERO_STRUCT(r->out);
6201
6202                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6203                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6204                 }
6205                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6206                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6207                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6208                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6209                 NDR_CHECK(ndr_pull_samr_DomainInfoClass(ndr, NDR_SCALARS, &r->in.level));
6210                 NDR_PULL_ALLOC(ndr, r->out.info);
6211                 ZERO_STRUCTP(r->out.info);
6212         }
6213         if (flags & NDR_OUT) {
6214                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6215                         NDR_PULL_ALLOC(ndr, r->out.info);
6216                 }
6217                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6218                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
6219                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
6220                 if (_ptr_info) {
6221                         NDR_PULL_ALLOC(ndr, *r->out.info);
6222                 } else {
6223                         *r->out.info = NULL;
6224                 }
6225                 if (*r->out.info) {
6226                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
6227                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
6228                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
6229                         NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
6230                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
6231                 }
6232                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6233                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6234         }
6235         return NDR_ERR_SUCCESS;
6236 }
6237
6238 _PUBLIC_ void ndr_print_samr_QueryDomainInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDomainInfo *r)
6239 {
6240         ndr_print_struct(ndr, name, "samr_QueryDomainInfo");
6241         ndr->depth++;
6242         if (flags & NDR_SET_VALUES) {
6243                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6244         }
6245         if (flags & NDR_IN) {
6246                 ndr_print_struct(ndr, "in", "samr_QueryDomainInfo");
6247                 ndr->depth++;
6248                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6249                 ndr->depth++;
6250                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6251                 ndr->depth--;
6252                 ndr_print_samr_DomainInfoClass(ndr, "level", r->in.level);
6253                 ndr->depth--;
6254         }
6255         if (flags & NDR_OUT) {
6256                 ndr_print_struct(ndr, "out", "samr_QueryDomainInfo");
6257                 ndr->depth++;
6258                 ndr_print_ptr(ndr, "info", r->out.info);
6259                 ndr->depth++;
6260                 ndr_print_ptr(ndr, "info", *r->out.info);
6261                 ndr->depth++;
6262                 if (*r->out.info) {
6263                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
6264                         ndr_print_samr_DomainInfo(ndr, "info", *r->out.info);
6265                 }
6266                 ndr->depth--;
6267                 ndr->depth--;
6268                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6269                 ndr->depth--;
6270         }
6271         ndr->depth--;
6272 }
6273
6274 static enum ndr_err_code ndr_push_samr_SetDomainInfo(struct ndr_push *ndr, int flags, const struct samr_SetDomainInfo *r)
6275 {
6276         if (flags & NDR_IN) {
6277                 if (r->in.domain_handle == NULL) {
6278                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6279                 }
6280                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6281                 NDR_CHECK(ndr_push_samr_DomainInfoClass(ndr, NDR_SCALARS, r->in.level));
6282                 if (r->in.info == NULL) {
6283                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6284                 }
6285                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
6286                 NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6287         }
6288         if (flags & NDR_OUT) {
6289                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6290         }
6291         return NDR_ERR_SUCCESS;
6292 }
6293
6294 static enum ndr_err_code ndr_pull_samr_SetDomainInfo(struct ndr_pull *ndr, int flags, struct samr_SetDomainInfo *r)
6295 {
6296         TALLOC_CTX *_mem_save_domain_handle_0;
6297         TALLOC_CTX *_mem_save_info_0;
6298         if (flags & NDR_IN) {
6299                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6300                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6301                 }
6302                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6303                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6304                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6305                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6306                 NDR_CHECK(ndr_pull_samr_DomainInfoClass(ndr, NDR_SCALARS, &r->in.level));
6307                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6308                         NDR_PULL_ALLOC(ndr, r->in.info);
6309                 }
6310                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6311                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
6312                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
6313                 NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6314                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6315         }
6316         if (flags & NDR_OUT) {
6317                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6318         }
6319         return NDR_ERR_SUCCESS;
6320 }
6321
6322 _PUBLIC_ void ndr_print_samr_SetDomainInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetDomainInfo *r)
6323 {
6324         ndr_print_struct(ndr, name, "samr_SetDomainInfo");
6325         ndr->depth++;
6326         if (flags & NDR_SET_VALUES) {
6327                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6328         }
6329         if (flags & NDR_IN) {
6330                 ndr_print_struct(ndr, "in", "samr_SetDomainInfo");
6331                 ndr->depth++;
6332                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6333                 ndr->depth++;
6334                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6335                 ndr->depth--;
6336                 ndr_print_samr_DomainInfoClass(ndr, "level", r->in.level);
6337                 ndr_print_ptr(ndr, "info", r->in.info);
6338                 ndr->depth++;
6339                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
6340                 ndr_print_samr_DomainInfo(ndr, "info", r->in.info);
6341                 ndr->depth--;
6342                 ndr->depth--;
6343         }
6344         if (flags & NDR_OUT) {
6345                 ndr_print_struct(ndr, "out", "samr_SetDomainInfo");
6346                 ndr->depth++;
6347                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6348                 ndr->depth--;
6349         }
6350         ndr->depth--;
6351 }
6352
6353 static enum ndr_err_code ndr_push_samr_CreateDomainGroup(struct ndr_push *ndr, int flags, const struct samr_CreateDomainGroup *r)
6354 {
6355         if (flags & NDR_IN) {
6356                 if (r->in.domain_handle == NULL) {
6357                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6358                 }
6359                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6360                 if (r->in.name == NULL) {
6361                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6362                 }
6363                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
6364                 NDR_CHECK(ndr_push_samr_GroupAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
6365         }
6366         if (flags & NDR_OUT) {
6367                 if (r->out.group_handle == NULL) {
6368                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6369                 }
6370                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
6371                 if (r->out.rid == NULL) {
6372                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6373                 }
6374                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
6375                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6376         }
6377         return NDR_ERR_SUCCESS;
6378 }
6379
6380 static enum ndr_err_code ndr_pull_samr_CreateDomainGroup(struct ndr_pull *ndr, int flags, struct samr_CreateDomainGroup *r)
6381 {
6382         TALLOC_CTX *_mem_save_domain_handle_0;
6383         TALLOC_CTX *_mem_save_name_0;
6384         TALLOC_CTX *_mem_save_group_handle_0;
6385         TALLOC_CTX *_mem_save_rid_0;
6386         if (flags & NDR_IN) {
6387                 ZERO_STRUCT(r->out);
6388
6389                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6390                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6391                 }
6392                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6393                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6394                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6395                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6396                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6397                         NDR_PULL_ALLOC(ndr, r->in.name);
6398                 }
6399                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6400                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
6401                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
6402                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
6403                 NDR_CHECK(ndr_pull_samr_GroupAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
6404                 NDR_PULL_ALLOC(ndr, r->out.group_handle);
6405                 ZERO_STRUCTP(r->out.group_handle);
6406                 NDR_PULL_ALLOC(ndr, r->out.rid);
6407                 ZERO_STRUCTP(r->out.rid);
6408         }
6409         if (flags & NDR_OUT) {
6410                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6411                         NDR_PULL_ALLOC(ndr, r->out.group_handle);
6412                 }
6413                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6414                 NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);
6415                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
6416                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
6417                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6418                         NDR_PULL_ALLOC(ndr, r->out.rid);
6419                 }
6420                 _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6421                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
6422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
6423                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
6424                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6425         }
6426         return NDR_ERR_SUCCESS;
6427 }
6428
6429 _PUBLIC_ void ndr_print_samr_CreateDomainGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateDomainGroup *r)
6430 {
6431         ndr_print_struct(ndr, name, "samr_CreateDomainGroup");
6432         ndr->depth++;
6433         if (flags & NDR_SET_VALUES) {
6434                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6435         }
6436         if (flags & NDR_IN) {
6437                 ndr_print_struct(ndr, "in", "samr_CreateDomainGroup");
6438                 ndr->depth++;
6439                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6440                 ndr->depth++;
6441                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6442                 ndr->depth--;
6443                 ndr_print_ptr(ndr, "name", r->in.name);
6444                 ndr->depth++;
6445                 ndr_print_lsa_String(ndr, "name", r->in.name);
6446                 ndr->depth--;
6447                 ndr_print_samr_GroupAccessMask(ndr, "access_mask", r->in.access_mask);
6448                 ndr->depth--;
6449         }
6450         if (flags & NDR_OUT) {
6451                 ndr_print_struct(ndr, "out", "samr_CreateDomainGroup");
6452                 ndr->depth++;
6453                 ndr_print_ptr(ndr, "group_handle", r->out.group_handle);
6454                 ndr->depth++;
6455                 ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);
6456                 ndr->depth--;
6457                 ndr_print_ptr(ndr, "rid", r->out.rid);
6458                 ndr->depth++;
6459                 ndr_print_uint32(ndr, "rid", *r->out.rid);
6460                 ndr->depth--;
6461                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6462                 ndr->depth--;
6463         }
6464         ndr->depth--;
6465 }
6466
6467 static enum ndr_err_code ndr_push_samr_EnumDomainGroups(struct ndr_push *ndr, int flags, const struct samr_EnumDomainGroups *r)
6468 {
6469         if (flags & NDR_IN) {
6470                 if (r->in.domain_handle == NULL) {
6471                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6472                 }
6473                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6474                 if (r->in.resume_handle == NULL) {
6475                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6476                 }
6477                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6478                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
6479         }
6480         if (flags & NDR_OUT) {
6481                 if (r->out.resume_handle == NULL) {
6482                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6483                 }
6484                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6485                 if (r->out.sam == NULL) {
6486                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6487                 }
6488                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
6489                 if (*r->out.sam) {
6490                         NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6491                 }
6492                 if (r->out.num_entries == NULL) {
6493                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6494                 }
6495                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
6496                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6497         }
6498         return NDR_ERR_SUCCESS;
6499 }
6500
6501 static enum ndr_err_code ndr_pull_samr_EnumDomainGroups(struct ndr_pull *ndr, int flags, struct samr_EnumDomainGroups *r)
6502 {
6503         uint32_t _ptr_sam;
6504         TALLOC_CTX *_mem_save_domain_handle_0;
6505         TALLOC_CTX *_mem_save_resume_handle_0;
6506         TALLOC_CTX *_mem_save_sam_0;
6507         TALLOC_CTX *_mem_save_sam_1;
6508         TALLOC_CTX *_mem_save_num_entries_0;
6509         if (flags & NDR_IN) {
6510                 ZERO_STRUCT(r->out);
6511
6512                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6513                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6514                 }
6515                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6516                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6517                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6518                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6519                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6520                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
6521                 }
6522                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6523                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6524                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6525                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6526                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
6527                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6528                 *r->out.resume_handle = *r->in.resume_handle;
6529                 NDR_PULL_ALLOC(ndr, r->out.sam);
6530                 ZERO_STRUCTP(r->out.sam);
6531                 NDR_PULL_ALLOC(ndr, r->out.num_entries);
6532                 ZERO_STRUCTP(r->out.num_entries);
6533         }
6534         if (flags & NDR_OUT) {
6535                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6536                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6537                 }
6538                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6539                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6540                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6541                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6542                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6543                         NDR_PULL_ALLOC(ndr, r->out.sam);
6544                 }
6545                 _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
6546                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
6547                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
6548                 if (_ptr_sam) {
6549                         NDR_PULL_ALLOC(ndr, *r->out.sam);
6550                 } else {
6551                         *r->out.sam = NULL;
6552                 }
6553                 if (*r->out.sam) {
6554                         _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
6555                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
6556                         NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6557                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
6558                 }
6559                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
6560                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6561                         NDR_PULL_ALLOC(ndr, r->out.num_entries);
6562                 }
6563                 _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
6564                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
6565                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
6566                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
6567                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6568         }
6569         return NDR_ERR_SUCCESS;
6570 }
6571
6572 _PUBLIC_ void ndr_print_samr_EnumDomainGroups(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainGroups *r)
6573 {
6574         ndr_print_struct(ndr, name, "samr_EnumDomainGroups");
6575         ndr->depth++;
6576         if (flags & NDR_SET_VALUES) {
6577                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6578         }
6579         if (flags & NDR_IN) {
6580                 ndr_print_struct(ndr, "in", "samr_EnumDomainGroups");
6581                 ndr->depth++;
6582                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6583                 ndr->depth++;
6584                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6585                 ndr->depth--;
6586                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6587                 ndr->depth++;
6588                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6589                 ndr->depth--;
6590                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
6591                 ndr->depth--;
6592         }
6593         if (flags & NDR_OUT) {
6594                 ndr_print_struct(ndr, "out", "samr_EnumDomainGroups");
6595                 ndr->depth++;
6596                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6597                 ndr->depth++;
6598                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6599                 ndr->depth--;
6600                 ndr_print_ptr(ndr, "sam", r->out.sam);
6601                 ndr->depth++;
6602                 ndr_print_ptr(ndr, "sam", *r->out.sam);
6603                 ndr->depth++;
6604                 if (*r->out.sam) {
6605                         ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
6606                 }
6607                 ndr->depth--;
6608                 ndr->depth--;
6609                 ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
6610                 ndr->depth++;
6611                 ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
6612                 ndr->depth--;
6613                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6614                 ndr->depth--;
6615         }
6616         ndr->depth--;
6617 }
6618
6619 static enum ndr_err_code ndr_push_samr_CreateUser(struct ndr_push *ndr, int flags, const struct samr_CreateUser *r)
6620 {
6621         if (flags & NDR_IN) {
6622                 if (r->in.domain_handle == NULL) {
6623                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6624                 }
6625                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6626                 if (r->in.account_name == NULL) {
6627                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6628                 }
6629                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
6630                 NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
6631         }
6632         if (flags & NDR_OUT) {
6633                 if (r->out.user_handle == NULL) {
6634                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6635                 }
6636                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
6637                 if (r->out.rid == NULL) {
6638                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6639                 }
6640                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
6641                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6642         }
6643         return NDR_ERR_SUCCESS;
6644 }
6645
6646 static enum ndr_err_code ndr_pull_samr_CreateUser(struct ndr_pull *ndr, int flags, struct samr_CreateUser *r)
6647 {
6648         TALLOC_CTX *_mem_save_domain_handle_0;
6649         TALLOC_CTX *_mem_save_account_name_0;
6650         TALLOC_CTX *_mem_save_user_handle_0;
6651         TALLOC_CTX *_mem_save_rid_0;
6652         if (flags & NDR_IN) {
6653                 ZERO_STRUCT(r->out);
6654
6655                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6656                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6657                 }
6658                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6659                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6660                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6661                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6662                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6663                         NDR_PULL_ALLOC(ndr, r->in.account_name);
6664                 }
6665                 _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6666                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account_name, LIBNDR_FLAG_REF_ALLOC);
6667                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
6668                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, LIBNDR_FLAG_REF_ALLOC);
6669                 NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
6670                 NDR_PULL_ALLOC(ndr, r->out.user_handle);
6671                 ZERO_STRUCTP(r->out.user_handle);
6672                 NDR_PULL_ALLOC(ndr, r->out.rid);
6673                 ZERO_STRUCTP(r->out.rid);
6674         }
6675         if (flags & NDR_OUT) {
6676                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6677                         NDR_PULL_ALLOC(ndr, r->out.user_handle);
6678                 }
6679                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6680                 NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
6681                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
6682                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
6683                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6684                         NDR_PULL_ALLOC(ndr, r->out.rid);
6685                 }
6686                 _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6687                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
6688                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
6689                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
6690                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6691         }
6692         return NDR_ERR_SUCCESS;
6693 }
6694
6695 _PUBLIC_ void ndr_print_samr_CreateUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateUser *r)
6696 {
6697         ndr_print_struct(ndr, name, "samr_CreateUser");
6698         ndr->depth++;
6699         if (flags & NDR_SET_VALUES) {
6700                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6701         }
6702         if (flags & NDR_IN) {
6703                 ndr_print_struct(ndr, "in", "samr_CreateUser");
6704                 ndr->depth++;
6705                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6706                 ndr->depth++;
6707                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6708                 ndr->depth--;
6709                 ndr_print_ptr(ndr, "account_name", r->in.account_name);
6710                 ndr->depth++;
6711                 ndr_print_lsa_String(ndr, "account_name", r->in.account_name);
6712                 ndr->depth--;
6713                 ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);
6714                 ndr->depth--;
6715         }
6716         if (flags & NDR_OUT) {
6717                 ndr_print_struct(ndr, "out", "samr_CreateUser");
6718                 ndr->depth++;
6719                 ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
6720                 ndr->depth++;
6721                 ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
6722                 ndr->depth--;
6723                 ndr_print_ptr(ndr, "rid", r->out.rid);
6724                 ndr->depth++;
6725                 ndr_print_uint32(ndr, "rid", *r->out.rid);
6726                 ndr->depth--;
6727                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6728                 ndr->depth--;
6729         }
6730         ndr->depth--;
6731 }
6732
6733 static enum ndr_err_code ndr_push_samr_EnumDomainUsers(struct ndr_push *ndr, int flags, const struct samr_EnumDomainUsers *r)
6734 {
6735         if (flags & NDR_IN) {
6736                 if (r->in.domain_handle == NULL) {
6737                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6738                 }
6739                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6740                 if (r->in.resume_handle == NULL) {
6741                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6742                 }
6743                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6744                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->in.acct_flags));
6745                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
6746         }
6747         if (flags & NDR_OUT) {
6748                 if (r->out.resume_handle == NULL) {
6749                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6750                 }
6751                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6752                 if (r->out.sam == NULL) {
6753                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6754                 }
6755                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
6756                 if (*r->out.sam) {
6757                         NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6758                 }
6759                 if (r->out.num_entries == NULL) {
6760                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6761                 }
6762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
6763                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6764         }
6765         return NDR_ERR_SUCCESS;
6766 }
6767
6768 static enum ndr_err_code ndr_pull_samr_EnumDomainUsers(struct ndr_pull *ndr, int flags, struct samr_EnumDomainUsers *r)
6769 {
6770         uint32_t _ptr_sam;
6771         TALLOC_CTX *_mem_save_domain_handle_0;
6772         TALLOC_CTX *_mem_save_resume_handle_0;
6773         TALLOC_CTX *_mem_save_sam_0;
6774         TALLOC_CTX *_mem_save_sam_1;
6775         TALLOC_CTX *_mem_save_num_entries_0;
6776         if (flags & NDR_IN) {
6777                 ZERO_STRUCT(r->out);
6778
6779                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6780                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6781                 }
6782                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6783                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6784                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6785                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6786                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6787                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
6788                 }
6789                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6790                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6791                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6792                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6793                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->in.acct_flags));
6794                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
6795                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6796                 *r->out.resume_handle = *r->in.resume_handle;
6797                 NDR_PULL_ALLOC(ndr, r->out.sam);
6798                 ZERO_STRUCTP(r->out.sam);
6799                 NDR_PULL_ALLOC(ndr, r->out.num_entries);
6800                 ZERO_STRUCTP(r->out.num_entries);
6801         }
6802         if (flags & NDR_OUT) {
6803                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6804                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6805                 }
6806                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6807                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6808                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6809                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6810                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6811                         NDR_PULL_ALLOC(ndr, r->out.sam);
6812                 }
6813                 _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
6814                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
6815                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
6816                 if (_ptr_sam) {
6817                         NDR_PULL_ALLOC(ndr, *r->out.sam);
6818                 } else {
6819                         *r->out.sam = NULL;
6820                 }
6821                 if (*r->out.sam) {
6822                         _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
6823                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
6824                         NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6825                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
6826                 }
6827                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
6828                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6829                         NDR_PULL_ALLOC(ndr, r->out.num_entries);
6830                 }
6831                 _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
6832                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
6833                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
6834                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
6835                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6836         }
6837         return NDR_ERR_SUCCESS;
6838 }
6839
6840 _PUBLIC_ void ndr_print_samr_EnumDomainUsers(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainUsers *r)
6841 {
6842         ndr_print_struct(ndr, name, "samr_EnumDomainUsers");
6843         ndr->depth++;
6844         if (flags & NDR_SET_VALUES) {
6845                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6846         }
6847         if (flags & NDR_IN) {
6848                 ndr_print_struct(ndr, "in", "samr_EnumDomainUsers");
6849                 ndr->depth++;
6850                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6851                 ndr->depth++;
6852                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6853                 ndr->depth--;
6854                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6855                 ndr->depth++;
6856                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6857                 ndr->depth--;
6858                 ndr_print_samr_AcctFlags(ndr, "acct_flags", r->in.acct_flags);
6859                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
6860                 ndr->depth--;
6861         }
6862         if (flags & NDR_OUT) {
6863                 ndr_print_struct(ndr, "out", "samr_EnumDomainUsers");
6864                 ndr->depth++;
6865                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6866                 ndr->depth++;
6867                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6868                 ndr->depth--;
6869                 ndr_print_ptr(ndr, "sam", r->out.sam);
6870                 ndr->depth++;
6871                 ndr_print_ptr(ndr, "sam", *r->out.sam);
6872                 ndr->depth++;
6873                 if (*r->out.sam) {
6874                         ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
6875                 }
6876                 ndr->depth--;
6877                 ndr->depth--;
6878                 ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
6879                 ndr->depth++;
6880                 ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
6881                 ndr->depth--;
6882                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6883                 ndr->depth--;
6884         }
6885         ndr->depth--;
6886 }
6887
6888 static enum ndr_err_code ndr_push_samr_CreateDomAlias(struct ndr_push *ndr, int flags, const struct samr_CreateDomAlias *r)
6889 {
6890         if (flags & NDR_IN) {
6891                 if (r->in.domain_handle == NULL) {
6892                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6893                 }
6894                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6895                 if (r->in.alias_name == NULL) {
6896                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6897                 }
6898                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.alias_name));
6899                 NDR_CHECK(ndr_push_samr_AliasAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
6900         }
6901         if (flags & NDR_OUT) {
6902                 if (r->out.alias_handle == NULL) {
6903                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6904                 }
6905                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
6906                 if (r->out.rid == NULL) {
6907                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6908                 }
6909                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
6910                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6911         }
6912         return NDR_ERR_SUCCESS;
6913 }
6914
6915 static enum ndr_err_code ndr_pull_samr_CreateDomAlias(struct ndr_pull *ndr, int flags, struct samr_CreateDomAlias *r)
6916 {
6917         TALLOC_CTX *_mem_save_domain_handle_0;
6918         TALLOC_CTX *_mem_save_alias_name_0;
6919         TALLOC_CTX *_mem_save_alias_handle_0;
6920         TALLOC_CTX *_mem_save_rid_0;
6921         if (flags & NDR_IN) {
6922                 ZERO_STRUCT(r->out);
6923
6924                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6925                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6926                 }
6927                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6928                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6929                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6930                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6931                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6932                         NDR_PULL_ALLOC(ndr, r->in.alias_name);
6933                 }
6934                 _mem_save_alias_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6935                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_name, LIBNDR_FLAG_REF_ALLOC);
6936                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.alias_name));
6937                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_name_0, LIBNDR_FLAG_REF_ALLOC);
6938                 NDR_CHECK(ndr_pull_samr_AliasAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
6939                 NDR_PULL_ALLOC(ndr, r->out.alias_handle);
6940                 ZERO_STRUCTP(r->out.alias_handle);
6941                 NDR_PULL_ALLOC(ndr, r->out.rid);
6942                 ZERO_STRUCTP(r->out.rid);
6943         }
6944         if (flags & NDR_OUT) {
6945                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6946                         NDR_PULL_ALLOC(ndr, r->out.alias_handle);
6947                 }
6948                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6949                 NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);
6950                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
6951                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
6952                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6953                         NDR_PULL_ALLOC(ndr, r->out.rid);
6954                 }
6955                 _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6956                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
6957                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
6958                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
6959                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6960         }
6961         return NDR_ERR_SUCCESS;
6962 }
6963
6964 _PUBLIC_ void ndr_print_samr_CreateDomAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateDomAlias *r)
6965 {
6966         ndr_print_struct(ndr, name, "samr_CreateDomAlias");
6967         ndr->depth++;
6968         if (flags & NDR_SET_VALUES) {
6969                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6970         }
6971         if (flags & NDR_IN) {
6972                 ndr_print_struct(ndr, "in", "samr_CreateDomAlias");
6973                 ndr->depth++;
6974                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6975                 ndr->depth++;
6976                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6977                 ndr->depth--;
6978                 ndr_print_ptr(ndr, "alias_name", r->in.alias_name);
6979                 ndr->depth++;
6980                 ndr_print_lsa_String(ndr, "alias_name", r->in.alias_name);
6981                 ndr->depth--;
6982                 ndr_print_samr_AliasAccessMask(ndr, "access_mask", r->in.access_mask);
6983                 ndr->depth--;
6984         }
6985         if (flags & NDR_OUT) {
6986                 ndr_print_struct(ndr, "out", "samr_CreateDomAlias");
6987                 ndr->depth++;
6988                 ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);
6989                 ndr->depth++;
6990                 ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);
6991                 ndr->depth--;
6992                 ndr_print_ptr(ndr, "rid", r->out.rid);
6993                 ndr->depth++;
6994                 ndr_print_uint32(ndr, "rid", *r->out.rid);
6995                 ndr->depth--;
6996                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6997                 ndr->depth--;
6998         }
6999         ndr->depth--;
7000 }
7001
7002 static enum ndr_err_code ndr_push_samr_EnumDomainAliases(struct ndr_push *ndr, int flags, const struct samr_EnumDomainAliases *r)
7003 {
7004         if (flags & NDR_IN) {
7005                 if (r->in.domain_handle == NULL) {
7006                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7007                 }
7008                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7009                 if (r->in.resume_handle == NULL) {
7010                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7011                 }
7012                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
7013                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
7014         }
7015         if (flags & NDR_OUT) {
7016                 if (r->out.resume_handle == NULL) {
7017                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7018                 }
7019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
7020                 if (r->out.sam == NULL) {
7021                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7022                 }
7023                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
7024                 if (*r->out.sam) {
7025                         NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
7026                 }
7027                 if (r->out.num_entries == NULL) {
7028                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7029                 }
7030                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
7031                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7032         }
7033         return NDR_ERR_SUCCESS;
7034 }
7035
7036 static enum ndr_err_code ndr_pull_samr_EnumDomainAliases(struct ndr_pull *ndr, int flags, struct samr_EnumDomainAliases *r)
7037 {
7038         uint32_t _ptr_sam;
7039         TALLOC_CTX *_mem_save_domain_handle_0;
7040         TALLOC_CTX *_mem_save_resume_handle_0;
7041         TALLOC_CTX *_mem_save_sam_0;
7042         TALLOC_CTX *_mem_save_sam_1;
7043         TALLOC_CTX *_mem_save_num_entries_0;
7044         if (flags & NDR_IN) {
7045                 ZERO_STRUCT(r->out);
7046
7047                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7048                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7049                 }
7050                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7051                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7052                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7053                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7054                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7055                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
7056                 }
7057                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7058                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
7059                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
7060                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
7061                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
7062                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
7063                 *r->out.resume_handle = *r->in.resume_handle;
7064                 NDR_PULL_ALLOC(ndr, r->out.sam);
7065                 ZERO_STRUCTP(r->out.sam);
7066                 NDR_PULL_ALLOC(ndr, r->out.num_entries);
7067                 ZERO_STRUCTP(r->out.num_entries);
7068         }
7069         if (flags & NDR_OUT) {
7070                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7071                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
7072                 }
7073                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7074                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
7075                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
7076                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
7077                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7078                         NDR_PULL_ALLOC(ndr, r->out.sam);
7079                 }
7080                 _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
7081                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
7082                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
7083                 if (_ptr_sam) {
7084                         NDR_PULL_ALLOC(ndr, *r->out.sam);
7085                 } else {
7086                         *r->out.sam = NULL;
7087                 }
7088                 if (*r->out.sam) {
7089                         _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
7090                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
7091                         NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
7092                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
7093                 }
7094                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
7095                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7096                         NDR_PULL_ALLOC(ndr, r->out.num_entries);
7097                 }
7098                 _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
7099                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
7100                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
7101                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
7102                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7103         }
7104         return NDR_ERR_SUCCESS;
7105 }
7106
7107 _PUBLIC_ void ndr_print_samr_EnumDomainAliases(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainAliases *r)
7108 {
7109         ndr_print_struct(ndr, name, "samr_EnumDomainAliases");
7110         ndr->depth++;
7111         if (flags & NDR_SET_VALUES) {
7112                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7113         }
7114         if (flags & NDR_IN) {
7115                 ndr_print_struct(ndr, "in", "samr_EnumDomainAliases");
7116                 ndr->depth++;
7117                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7118                 ndr->depth++;
7119                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7120                 ndr->depth--;
7121                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
7122                 ndr->depth++;
7123                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
7124                 ndr->depth--;
7125                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
7126                 ndr->depth--;
7127         }
7128         if (flags & NDR_OUT) {
7129                 ndr_print_struct(ndr, "out", "samr_EnumDomainAliases");
7130                 ndr->depth++;
7131                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
7132                 ndr->depth++;
7133                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
7134                 ndr->depth--;
7135                 ndr_print_ptr(ndr, "sam", r->out.sam);
7136                 ndr->depth++;
7137                 ndr_print_ptr(ndr, "sam", *r->out.sam);
7138                 ndr->depth++;
7139                 if (*r->out.sam) {
7140                         ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
7141                 }
7142                 ndr->depth--;
7143                 ndr->depth--;
7144                 ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
7145                 ndr->depth++;
7146                 ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
7147                 ndr->depth--;
7148                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7149                 ndr->depth--;
7150         }
7151         ndr->depth--;
7152 }
7153
7154 static enum ndr_err_code ndr_push_samr_GetAliasMembership(struct ndr_push *ndr, int flags, const struct samr_GetAliasMembership *r)
7155 {
7156         if (flags & NDR_IN) {
7157                 if (r->in.domain_handle == NULL) {
7158                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7159                 }
7160                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7161                 if (r->in.sids == NULL) {
7162                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7163                 }
7164                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
7165         }
7166         if (flags & NDR_OUT) {
7167                 if (r->out.rids == NULL) {
7168                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7169                 }
7170                 NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
7171                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7172         }
7173         return NDR_ERR_SUCCESS;
7174 }
7175
7176 static enum ndr_err_code ndr_pull_samr_GetAliasMembership(struct ndr_pull *ndr, int flags, struct samr_GetAliasMembership *r)
7177 {
7178         TALLOC_CTX *_mem_save_domain_handle_0;
7179         TALLOC_CTX *_mem_save_sids_0;
7180         TALLOC_CTX *_mem_save_rids_0;
7181         if (flags & NDR_IN) {
7182                 ZERO_STRUCT(r->out);
7183
7184                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7185                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7186                 }
7187                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7188                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7189                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7190                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7191                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7192                         NDR_PULL_ALLOC(ndr, r->in.sids);
7193                 }
7194                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7195                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
7196                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
7197                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
7198                 NDR_PULL_ALLOC(ndr, r->out.rids);
7199                 ZERO_STRUCTP(r->out.rids);
7200         }
7201         if (flags & NDR_OUT) {
7202                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7203                         NDR_PULL_ALLOC(ndr, r->out.rids);
7204                 }
7205                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7206                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
7207                 NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
7208                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
7209                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7210         }
7211         return NDR_ERR_SUCCESS;
7212 }
7213
7214 _PUBLIC_ void ndr_print_samr_GetAliasMembership(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetAliasMembership *r)
7215 {
7216         ndr_print_struct(ndr, name, "samr_GetAliasMembership");
7217         ndr->depth++;
7218         if (flags & NDR_SET_VALUES) {
7219                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7220         }
7221         if (flags & NDR_IN) {
7222                 ndr_print_struct(ndr, "in", "samr_GetAliasMembership");
7223                 ndr->depth++;
7224                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7225                 ndr->depth++;
7226                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7227                 ndr->depth--;
7228                 ndr_print_ptr(ndr, "sids", r->in.sids);
7229                 ndr->depth++;
7230                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
7231                 ndr->depth--;
7232                 ndr->depth--;
7233         }
7234         if (flags & NDR_OUT) {
7235                 ndr_print_struct(ndr, "out", "samr_GetAliasMembership");
7236                 ndr->depth++;
7237                 ndr_print_ptr(ndr, "rids", r->out.rids);
7238                 ndr->depth++;
7239                 ndr_print_samr_Ids(ndr, "rids", r->out.rids);
7240                 ndr->depth--;
7241                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7242                 ndr->depth--;
7243         }
7244         ndr->depth--;
7245 }
7246
7247 _PUBLIC_ enum ndr_err_code ndr_push_samr_LookupNames(struct ndr_push *ndr, int flags, const struct samr_LookupNames *r)
7248 {
7249         uint32_t cntr_names_0;
7250         if (flags & NDR_IN) {
7251                 if (r->in.domain_handle == NULL) {
7252                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7253                 }
7254                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
7256                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 1000));
7257                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7258                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_names));
7259                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
7260                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
7261                 }
7262                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
7263                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
7264                 }
7265         }
7266         if (flags & NDR_OUT) {
7267                 if (r->out.rids == NULL) {
7268                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7269                 }
7270                 NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
7271                 if (r->out.types == NULL) {
7272                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7273                 }
7274                 NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
7275                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7276         }
7277         return NDR_ERR_SUCCESS;
7278 }
7279
7280 _PUBLIC_ enum ndr_err_code ndr_pull_samr_LookupNames(struct ndr_pull *ndr, int flags, struct samr_LookupNames *r)
7281 {
7282         uint32_t cntr_names_0;
7283         TALLOC_CTX *_mem_save_domain_handle_0;
7284         TALLOC_CTX *_mem_save_names_0;
7285         TALLOC_CTX *_mem_save_rids_0;
7286         TALLOC_CTX *_mem_save_types_0;
7287         if (flags & NDR_IN) {
7288                 ZERO_STRUCT(r->out);
7289
7290                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7291                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7292                 }
7293                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7294                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7295                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7296                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7297                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
7298                 if (r->in.num_names > 1000) {
7299                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7300                 }
7301                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
7302                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.names));
7303                 if (ndr_get_array_length(ndr, &r->in.names) > ndr_get_array_size(ndr, &r->in.names)) {
7304                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.names), ndr_get_array_length(ndr, &r->in.names));
7305                 }
7306                 NDR_PULL_ALLOC_N(ndr, r->in.names, ndr_get_array_size(ndr, &r->in.names));
7307                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
7308                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
7309                 for (cntr_names_0 = 0; cntr_names_0 < ndr_get_array_length(ndr, &r->in.names); cntr_names_0++) {
7310                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
7311                 }
7312                 for (cntr_names_0 = 0; cntr_names_0 < ndr_get_array_length(ndr, &r->in.names); cntr_names_0++) {
7313                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
7314                 }
7315                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
7316                 NDR_PULL_ALLOC(ndr, r->out.rids);
7317                 ZERO_STRUCTP(r->out.rids);
7318                 NDR_PULL_ALLOC(ndr, r->out.types);
7319                 ZERO_STRUCTP(r->out.types);
7320                 if (r->in.names) {
7321                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, 1000));
7322                 }
7323                 if (r->in.names) {
7324                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.names, r->in.num_names));
7325                 }
7326         }
7327         if (flags & NDR_OUT) {
7328                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7329                         NDR_PULL_ALLOC(ndr, r->out.rids);
7330                 }
7331                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7332                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
7333                 NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
7334                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
7335                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7336                         NDR_PULL_ALLOC(ndr, r->out.types);
7337                 }
7338                 _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
7339                 NDR_PULL_SET_MEM_CTX(ndr, r->out.types, LIBNDR_FLAG_REF_ALLOC);
7340                 NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
7341                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, LIBNDR_FLAG_REF_ALLOC);
7342                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7343         }
7344         return NDR_ERR_SUCCESS;
7345 }
7346
7347 _PUBLIC_ void ndr_print_samr_LookupNames(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupNames *r)
7348 {
7349         uint32_t cntr_names_0;
7350         ndr_print_struct(ndr, name, "samr_LookupNames");
7351         ndr->depth++;
7352         if (flags & NDR_SET_VALUES) {
7353                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7354         }
7355         if (flags & NDR_IN) {
7356                 ndr_print_struct(ndr, "in", "samr_LookupNames");
7357                 ndr->depth++;
7358                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7359                 ndr->depth++;
7360                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7361                 ndr->depth--;
7362                 ndr_print_uint32(ndr, "num_names", r->in.num_names);
7363                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->in.num_names);
7364                 ndr->depth++;
7365                 for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
7366                         char *idx_0=NULL;
7367                         if (asprintf(&idx_0, "[%d]", cntr_names_0) != -1) {
7368                                 ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
7369                                 free(idx_0);
7370                         }
7371                 }
7372                 ndr->depth--;
7373                 ndr->depth--;
7374         }
7375         if (flags & NDR_OUT) {
7376                 ndr_print_struct(ndr, "out", "samr_LookupNames");
7377                 ndr->depth++;
7378                 ndr_print_ptr(ndr, "rids", r->out.rids);
7379                 ndr->depth++;
7380                 ndr_print_samr_Ids(ndr, "rids", r->out.rids);
7381                 ndr->depth--;
7382                 ndr_print_ptr(ndr, "types", r->out.types);
7383                 ndr->depth++;
7384                 ndr_print_samr_Ids(ndr, "types", r->out.types);
7385                 ndr->depth--;
7386                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7387                 ndr->depth--;
7388         }
7389         ndr->depth--;
7390 }
7391
7392 static enum ndr_err_code ndr_push_samr_LookupRids(struct ndr_push *ndr, int flags, const struct samr_LookupRids *r)
7393 {
7394         uint32_t cntr_rids_0;
7395         if (flags & NDR_IN) {
7396                 if (r->in.domain_handle == NULL) {
7397                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7398                 }
7399                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7400                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_rids));
7401                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 1000));
7402                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7403                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_rids));
7404                 for (cntr_rids_0 = 0; cntr_rids_0 < r->in.num_rids; cntr_rids_0++) {
7405                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rids[cntr_rids_0]));
7406                 }
7407         }
7408         if (flags & NDR_OUT) {
7409                 if (r->out.names == NULL) {
7410                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7411                 }
7412                 NDR_CHECK(ndr_push_lsa_Strings(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
7413                 if (r->out.types == NULL) {
7414                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7415                 }
7416                 NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
7417                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7418         }
7419         return NDR_ERR_SUCCESS;
7420 }
7421
7422 static enum ndr_err_code ndr_pull_samr_LookupRids(struct ndr_pull *ndr, int flags, struct samr_LookupRids *r)
7423 {
7424         uint32_t cntr_rids_0;
7425         TALLOC_CTX *_mem_save_domain_handle_0;
7426         TALLOC_CTX *_mem_save_rids_0;
7427         TALLOC_CTX *_mem_save_names_0;
7428         TALLOC_CTX *_mem_save_types_0;
7429         if (flags & NDR_IN) {
7430                 ZERO_STRUCT(r->out);
7431
7432                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7433                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7434                 }
7435                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7436                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7437                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7438                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_rids));
7440                 if (r->in.num_rids > 1000) {
7441                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7442                 }
7443                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.rids));
7444                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.rids));
7445                 if (ndr_get_array_length(ndr, &r->in.rids) > ndr_get_array_size(ndr, &r->in.rids)) {
7446                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.rids), ndr_get_array_length(ndr, &r->in.rids));
7447                 }
7448                 NDR_PULL_ALLOC_N(ndr, r->in.rids, ndr_get_array_size(ndr, &r->in.rids));
7449                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7450                 NDR_PULL_SET_MEM_CTX(ndr, r->in.rids, 0);
7451                 for (cntr_rids_0 = 0; cntr_rids_0 < ndr_get_array_length(ndr, &r->in.rids); cntr_rids_0++) {
7452                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rids[cntr_rids_0]));
7453                 }
7454                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
7455                 NDR_PULL_ALLOC(ndr, r->out.names);
7456                 ZERO_STRUCTP(r->out.names);
7457                 NDR_PULL_ALLOC(ndr, r->out.types);
7458                 ZERO_STRUCTP(r->out.types);
7459                 if (r->in.rids) {
7460                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.rids, 1000));
7461                 }
7462                 if (r->in.rids) {
7463                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.rids, r->in.num_rids));
7464                 }
7465         }
7466         if (flags & NDR_OUT) {
7467                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7468                         NDR_PULL_ALLOC(ndr, r->out.names);
7469                 }
7470                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
7471                 NDR_PULL_SET_MEM_CTX(ndr, r->out.names, LIBNDR_FLAG_REF_ALLOC);
7472                 NDR_CHECK(ndr_pull_lsa_Strings(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
7473                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
7474                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7475                         NDR_PULL_ALLOC(ndr, r->out.types);
7476                 }
7477                 _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
7478                 NDR_PULL_SET_MEM_CTX(ndr, r->out.types, LIBNDR_FLAG_REF_ALLOC);
7479                 NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
7480                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, LIBNDR_FLAG_REF_ALLOC);
7481                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7482         }
7483         return NDR_ERR_SUCCESS;
7484 }
7485
7486 _PUBLIC_ void ndr_print_samr_LookupRids(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupRids *r)
7487 {
7488         uint32_t cntr_rids_0;
7489         ndr_print_struct(ndr, name, "samr_LookupRids");
7490         ndr->depth++;
7491         if (flags & NDR_SET_VALUES) {
7492                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7493         }
7494         if (flags & NDR_IN) {
7495                 ndr_print_struct(ndr, "in", "samr_LookupRids");
7496                 ndr->depth++;
7497                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7498                 ndr->depth++;
7499                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7500                 ndr->depth--;
7501                 ndr_print_uint32(ndr, "num_rids", r->in.num_rids);
7502                 ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->in.num_rids);
7503                 ndr->depth++;
7504                 for (cntr_rids_0=0;cntr_rids_0<r->in.num_rids;cntr_rids_0++) {
7505                         char *idx_0=NULL;
7506                         if (asprintf(&idx_0, "[%d]", cntr_rids_0) != -1) {
7507                                 ndr_print_uint32(ndr, "rids", r->in.rids[cntr_rids_0]);
7508                                 free(idx_0);
7509                         }
7510                 }
7511                 ndr->depth--;
7512                 ndr->depth--;
7513         }
7514         if (flags & NDR_OUT) {
7515                 ndr_print_struct(ndr, "out", "samr_LookupRids");
7516                 ndr->depth++;
7517                 ndr_print_ptr(ndr, "names", r->out.names);
7518                 ndr->depth++;
7519                 ndr_print_lsa_Strings(ndr, "names", r->out.names);
7520                 ndr->depth--;
7521                 ndr_print_ptr(ndr, "types", r->out.types);
7522                 ndr->depth++;
7523                 ndr_print_samr_Ids(ndr, "types", r->out.types);
7524                 ndr->depth--;
7525                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7526                 ndr->depth--;
7527         }
7528         ndr->depth--;
7529 }
7530
7531 static enum ndr_err_code ndr_push_samr_OpenGroup(struct ndr_push *ndr, int flags, const struct samr_OpenGroup *r)
7532 {
7533         if (flags & NDR_IN) {
7534                 if (r->in.domain_handle == NULL) {
7535                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7536                 }
7537                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7538                 NDR_CHECK(ndr_push_samr_GroupAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
7539                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
7540         }
7541         if (flags & NDR_OUT) {
7542                 if (r->out.group_handle == NULL) {
7543                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7544                 }
7545                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
7546                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7547         }
7548         return NDR_ERR_SUCCESS;
7549 }
7550
7551 static enum ndr_err_code ndr_pull_samr_OpenGroup(struct ndr_pull *ndr, int flags, struct samr_OpenGroup *r)
7552 {
7553         TALLOC_CTX *_mem_save_domain_handle_0;
7554         TALLOC_CTX *_mem_save_group_handle_0;
7555         if (flags & NDR_IN) {
7556                 ZERO_STRUCT(r->out);
7557
7558                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7559                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7560                 }
7561                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7562                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7563                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7564                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7565                 NDR_CHECK(ndr_pull_samr_GroupAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
7566                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
7567                 NDR_PULL_ALLOC(ndr, r->out.group_handle);
7568                 ZERO_STRUCTP(r->out.group_handle);
7569         }
7570         if (flags & NDR_OUT) {
7571                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7572                         NDR_PULL_ALLOC(ndr, r->out.group_handle);
7573                 }
7574                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7575                 NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);
7576                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
7577                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7578                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7579         }
7580         return NDR_ERR_SUCCESS;
7581 }
7582
7583 _PUBLIC_ void ndr_print_samr_OpenGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenGroup *r)
7584 {
7585         ndr_print_struct(ndr, name, "samr_OpenGroup");
7586         ndr->depth++;
7587         if (flags & NDR_SET_VALUES) {
7588                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7589         }
7590         if (flags & NDR_IN) {
7591                 ndr_print_struct(ndr, "in", "samr_OpenGroup");
7592                 ndr->depth++;
7593                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7594                 ndr->depth++;
7595                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7596                 ndr->depth--;
7597                 ndr_print_samr_GroupAccessMask(ndr, "access_mask", r->in.access_mask);
7598                 ndr_print_uint32(ndr, "rid", r->in.rid);
7599                 ndr->depth--;
7600         }
7601         if (flags & NDR_OUT) {
7602                 ndr_print_struct(ndr, "out", "samr_OpenGroup");
7603                 ndr->depth++;
7604                 ndr_print_ptr(ndr, "group_handle", r->out.group_handle);
7605                 ndr->depth++;
7606                 ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);
7607                 ndr->depth--;
7608                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7609                 ndr->depth--;
7610         }
7611         ndr->depth--;
7612 }
7613
7614 static enum ndr_err_code ndr_push_samr_QueryGroupInfo(struct ndr_push *ndr, int flags, const struct samr_QueryGroupInfo *r)
7615 {
7616         if (flags & NDR_IN) {
7617                 if (r->in.group_handle == NULL) {
7618                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7619                 }
7620                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7621                 NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, r->in.level));
7622         }
7623         if (flags & NDR_OUT) {
7624                 if (r->out.info == NULL) {
7625                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7626                 }
7627                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
7628                 if (*r->out.info) {
7629                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
7630                         NDR_CHECK(ndr_push_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
7631                 }
7632                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7633         }
7634         return NDR_ERR_SUCCESS;
7635 }
7636
7637 static enum ndr_err_code ndr_pull_samr_QueryGroupInfo(struct ndr_pull *ndr, int flags, struct samr_QueryGroupInfo *r)
7638 {
7639         uint32_t _ptr_info;
7640         TALLOC_CTX *_mem_save_group_handle_0;
7641         TALLOC_CTX *_mem_save_info_0;
7642         TALLOC_CTX *_mem_save_info_1;
7643         if (flags & NDR_IN) {
7644                 ZERO_STRUCT(r->out);
7645
7646                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7647                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
7648                 }
7649                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7650                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
7651                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7652                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7653                 NDR_CHECK(ndr_pull_samr_GroupInfoEnum(ndr, NDR_SCALARS, &r->in.level));
7654                 NDR_PULL_ALLOC(ndr, r->out.info);
7655                 ZERO_STRUCTP(r->out.info);
7656         }
7657         if (flags & NDR_OUT) {
7658                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7659                         NDR_PULL_ALLOC(ndr, r->out.info);
7660                 }
7661                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7662                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
7663                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
7664                 if (_ptr_info) {
7665                         NDR_PULL_ALLOC(ndr, *r->out.info);
7666                 } else {
7667                         *r->out.info = NULL;
7668                 }
7669                 if (*r->out.info) {
7670                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
7671                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
7672                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
7673                         NDR_CHECK(ndr_pull_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
7674                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
7675                 }
7676                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7677                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7678         }
7679         return NDR_ERR_SUCCESS;
7680 }
7681
7682 _PUBLIC_ void ndr_print_samr_QueryGroupInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryGroupInfo *r)
7683 {
7684         ndr_print_struct(ndr, name, "samr_QueryGroupInfo");
7685         ndr->depth++;
7686         if (flags & NDR_SET_VALUES) {
7687                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7688         }
7689         if (flags & NDR_IN) {
7690                 ndr_print_struct(ndr, "in", "samr_QueryGroupInfo");
7691                 ndr->depth++;
7692                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
7693                 ndr->depth++;
7694                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
7695                 ndr->depth--;
7696                 ndr_print_samr_GroupInfoEnum(ndr, "level", r->in.level);
7697                 ndr->depth--;
7698         }
7699         if (flags & NDR_OUT) {
7700                 ndr_print_struct(ndr, "out", "samr_QueryGroupInfo");
7701                 ndr->depth++;
7702                 ndr_print_ptr(ndr, "info", r->out.info);
7703                 ndr->depth++;
7704                 ndr_print_ptr(ndr, "info", *r->out.info);
7705                 ndr->depth++;
7706                 if (*r->out.info) {
7707                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
7708                         ndr_print_samr_GroupInfo(ndr, "info", *r->out.info);
7709                 }
7710                 ndr->depth--;
7711                 ndr->depth--;
7712                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7713                 ndr->depth--;
7714         }
7715         ndr->depth--;
7716 }
7717
7718 static enum ndr_err_code ndr_push_samr_SetGroupInfo(struct ndr_push *ndr, int flags, const struct samr_SetGroupInfo *r)
7719 {
7720         if (flags & NDR_IN) {
7721                 if (r->in.group_handle == NULL) {
7722                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7723                 }
7724                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7725                 NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, r->in.level));
7726                 if (r->in.info == NULL) {
7727                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7728                 }
7729                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
7730                 NDR_CHECK(ndr_push_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
7731         }
7732         if (flags & NDR_OUT) {
7733                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7734         }
7735         return NDR_ERR_SUCCESS;
7736 }
7737
7738 static enum ndr_err_code ndr_pull_samr_SetGroupInfo(struct ndr_pull *ndr, int flags, struct samr_SetGroupInfo *r)
7739 {
7740         TALLOC_CTX *_mem_save_group_handle_0;
7741         TALLOC_CTX *_mem_save_info_0;
7742         if (flags & NDR_IN) {
7743                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7744                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
7745                 }
7746                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7747                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
7748                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7749                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7750                 NDR_CHECK(ndr_pull_samr_GroupInfoEnum(ndr, NDR_SCALARS, &r->in.level));
7751                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7752                         NDR_PULL_ALLOC(ndr, r->in.info);
7753                 }
7754                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7755                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
7756                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
7757                 NDR_CHECK(ndr_pull_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
7758                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7759         }
7760         if (flags & NDR_OUT) {
7761                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7762         }
7763         return NDR_ERR_SUCCESS;
7764 }
7765
7766 _PUBLIC_ void ndr_print_samr_SetGroupInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetGroupInfo *r)
7767 {
7768         ndr_print_struct(ndr, name, "samr_SetGroupInfo");
7769         ndr->depth++;
7770         if (flags & NDR_SET_VALUES) {
7771                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7772         }
7773         if (flags & NDR_IN) {
7774                 ndr_print_struct(ndr, "in", "samr_SetGroupInfo");
7775                 ndr->depth++;
7776                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
7777                 ndr->depth++;
7778                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
7779                 ndr->depth--;
7780                 ndr_print_samr_GroupInfoEnum(ndr, "level", r->in.level);
7781                 ndr_print_ptr(ndr, "info", r->in.info);
7782                 ndr->depth++;
7783                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
7784                 ndr_print_samr_GroupInfo(ndr, "info", r->in.info);
7785                 ndr->depth--;
7786                 ndr->depth--;
7787         }
7788         if (flags & NDR_OUT) {
7789                 ndr_print_struct(ndr, "out", "samr_SetGroupInfo");
7790                 ndr->depth++;
7791                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7792                 ndr->depth--;
7793         }
7794         ndr->depth--;
7795 }
7796
7797 static enum ndr_err_code ndr_push_samr_AddGroupMember(struct ndr_push *ndr, int flags, const struct samr_AddGroupMember *r)
7798 {
7799         if (flags & NDR_IN) {
7800                 if (r->in.group_handle == NULL) {
7801                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7802                 }
7803                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7804                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
7805                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
7806         }
7807         if (flags & NDR_OUT) {
7808                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7809         }
7810         return NDR_ERR_SUCCESS;
7811 }
7812
7813 static enum ndr_err_code ndr_pull_samr_AddGroupMember(struct ndr_pull *ndr, int flags, struct samr_AddGroupMember *r)
7814 {
7815         TALLOC_CTX *_mem_save_group_handle_0;
7816         if (flags & NDR_IN) {
7817                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7818                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
7819                 }
7820                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7821                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
7822                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7823                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7824                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
7825                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
7826         }
7827         if (flags & NDR_OUT) {
7828                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7829         }
7830         return NDR_ERR_SUCCESS;
7831 }
7832
7833 _PUBLIC_ void ndr_print_samr_AddGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddGroupMember *r)
7834 {
7835         ndr_print_struct(ndr, name, "samr_AddGroupMember");
7836         ndr->depth++;
7837         if (flags & NDR_SET_VALUES) {
7838                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7839         }
7840         if (flags & NDR_IN) {
7841                 ndr_print_struct(ndr, "in", "samr_AddGroupMember");
7842                 ndr->depth++;
7843                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
7844                 ndr->depth++;
7845                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
7846                 ndr->depth--;
7847                 ndr_print_uint32(ndr, "rid", r->in.rid);
7848                 ndr_print_uint32(ndr, "flags", r->in.flags);
7849                 ndr->depth--;
7850         }
7851         if (flags & NDR_OUT) {
7852                 ndr_print_struct(ndr, "out", "samr_AddGroupMember");
7853                 ndr->depth++;
7854                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7855                 ndr->depth--;
7856         }
7857         ndr->depth--;
7858 }
7859
7860 static enum ndr_err_code ndr_push_samr_DeleteDomainGroup(struct ndr_push *ndr, int flags, const struct samr_DeleteDomainGroup *r)
7861 {
7862         if (flags & NDR_IN) {
7863                 if (r->in.group_handle == NULL) {
7864                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7865                 }
7866                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7867         }
7868         if (flags & NDR_OUT) {
7869                 if (r->out.group_handle == NULL) {
7870                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7871                 }
7872                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
7873                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7874         }
7875         return NDR_ERR_SUCCESS;
7876 }
7877
7878 static enum ndr_err_code ndr_pull_samr_DeleteDomainGroup(struct ndr_pull *ndr, int flags, struct samr_DeleteDomainGroup *r)
7879 {
7880         TALLOC_CTX *_mem_save_group_handle_0;
7881         if (flags & NDR_IN) {
7882                 ZERO_STRUCT(r->out);
7883
7884                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7885                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
7886                 }
7887                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7888                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
7889                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7890                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7891                 NDR_PULL_ALLOC(ndr, r->out.group_handle);
7892                 *r->out.group_handle = *r->in.group_handle;
7893         }
7894         if (flags & NDR_OUT) {
7895                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7896                         NDR_PULL_ALLOC(ndr, r->out.group_handle);
7897                 }
7898                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7899                 NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);
7900                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
7901                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7902                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7903         }
7904         return NDR_ERR_SUCCESS;
7905 }
7906
7907 _PUBLIC_ void ndr_print_samr_DeleteDomainGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteDomainGroup *r)
7908 {
7909         ndr_print_struct(ndr, name, "samr_DeleteDomainGroup");
7910         ndr->depth++;
7911         if (flags & NDR_SET_VALUES) {
7912                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7913         }
7914         if (flags & NDR_IN) {
7915                 ndr_print_struct(ndr, "in", "samr_DeleteDomainGroup");
7916                 ndr->depth++;
7917                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
7918                 ndr->depth++;
7919                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
7920                 ndr->depth--;
7921                 ndr->depth--;
7922         }
7923         if (flags & NDR_OUT) {
7924                 ndr_print_struct(ndr, "out", "samr_DeleteDomainGroup");
7925                 ndr->depth++;
7926                 ndr_print_ptr(ndr, "group_handle", r->out.group_handle);
7927                 ndr->depth++;
7928                 ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);
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_DeleteGroupMember(struct ndr_push *ndr, int flags, const struct samr_DeleteGroupMember *r)
7937 {
7938         if (flags & NDR_IN) {
7939                 if (r->in.group_handle == NULL) {
7940                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7941                 }
7942                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7943                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
7944         }
7945         if (flags & NDR_OUT) {
7946                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7947         }
7948         return NDR_ERR_SUCCESS;
7949 }
7950
7951 static enum ndr_err_code ndr_pull_samr_DeleteGroupMember(struct ndr_pull *ndr, int flags, struct samr_DeleteGroupMember *r)
7952 {
7953         TALLOC_CTX *_mem_save_group_handle_0;
7954         if (flags & NDR_IN) {
7955                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7956                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
7957                 }
7958                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7959                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
7960                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7961                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7962                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
7963         }
7964         if (flags & NDR_OUT) {
7965                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7966         }
7967         return NDR_ERR_SUCCESS;
7968 }
7969
7970 _PUBLIC_ void ndr_print_samr_DeleteGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteGroupMember *r)
7971 {
7972         ndr_print_struct(ndr, name, "samr_DeleteGroupMember");
7973         ndr->depth++;
7974         if (flags & NDR_SET_VALUES) {
7975                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7976         }
7977         if (flags & NDR_IN) {
7978                 ndr_print_struct(ndr, "in", "samr_DeleteGroupMember");
7979                 ndr->depth++;
7980                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
7981                 ndr->depth++;
7982                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
7983                 ndr->depth--;
7984                 ndr_print_uint32(ndr, "rid", r->in.rid);
7985                 ndr->depth--;
7986         }
7987         if (flags & NDR_OUT) {
7988                 ndr_print_struct(ndr, "out", "samr_DeleteGroupMember");
7989                 ndr->depth++;
7990                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7991                 ndr->depth--;
7992         }
7993         ndr->depth--;
7994 }
7995
7996 static enum ndr_err_code ndr_push_samr_QueryGroupMember(struct ndr_push *ndr, int flags, const struct samr_QueryGroupMember *r)
7997 {
7998         if (flags & NDR_IN) {
7999                 if (r->in.group_handle == NULL) {
8000                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8001                 }
8002                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8003         }
8004         if (flags & NDR_OUT) {
8005                 if (r->out.rids == NULL) {
8006                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8007                 }
8008                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rids));
8009                 if (*r->out.rids) {
8010                         NDR_CHECK(ndr_push_samr_RidTypeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
8011                 }
8012                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8013         }
8014         return NDR_ERR_SUCCESS;
8015 }
8016
8017 static enum ndr_err_code ndr_pull_samr_QueryGroupMember(struct ndr_pull *ndr, int flags, struct samr_QueryGroupMember *r)
8018 {
8019         uint32_t _ptr_rids;
8020         TALLOC_CTX *_mem_save_group_handle_0;
8021         TALLOC_CTX *_mem_save_rids_0;
8022         TALLOC_CTX *_mem_save_rids_1;
8023         if (flags & NDR_IN) {
8024                 ZERO_STRUCT(r->out);
8025
8026                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8027                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
8028                 }
8029                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8030                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
8031                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8032                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
8033                 NDR_PULL_ALLOC(ndr, r->out.rids);
8034                 ZERO_STRUCTP(r->out.rids);
8035         }
8036         if (flags & NDR_OUT) {
8037                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8038                         NDR_PULL_ALLOC(ndr, r->out.rids);
8039                 }
8040                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
8041                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
8042                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
8043                 if (_ptr_rids) {
8044                         NDR_PULL_ALLOC(ndr, *r->out.rids);
8045                 } else {
8046                         *r->out.rids = NULL;
8047                 }
8048                 if (*r->out.rids) {
8049                         _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
8050                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.rids, 0);
8051                         NDR_CHECK(ndr_pull_samr_RidTypeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
8052                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
8053                 }
8054                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
8055                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8056         }
8057         return NDR_ERR_SUCCESS;
8058 }
8059
8060 _PUBLIC_ void ndr_print_samr_QueryGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryGroupMember *r)
8061 {
8062         ndr_print_struct(ndr, name, "samr_QueryGroupMember");
8063         ndr->depth++;
8064         if (flags & NDR_SET_VALUES) {
8065                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8066         }
8067         if (flags & NDR_IN) {
8068                 ndr_print_struct(ndr, "in", "samr_QueryGroupMember");
8069                 ndr->depth++;
8070                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
8071                 ndr->depth++;
8072                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
8073                 ndr->depth--;
8074                 ndr->depth--;
8075         }
8076         if (flags & NDR_OUT) {
8077                 ndr_print_struct(ndr, "out", "samr_QueryGroupMember");
8078                 ndr->depth++;
8079                 ndr_print_ptr(ndr, "rids", r->out.rids);
8080                 ndr->depth++;
8081                 ndr_print_ptr(ndr, "rids", *r->out.rids);
8082                 ndr->depth++;
8083                 if (*r->out.rids) {
8084                         ndr_print_samr_RidTypeArray(ndr, "rids", *r->out.rids);
8085                 }
8086                 ndr->depth--;
8087                 ndr->depth--;
8088                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8089                 ndr->depth--;
8090         }
8091         ndr->depth--;
8092 }
8093
8094 static enum ndr_err_code ndr_push_samr_SetMemberAttributesOfGroup(struct ndr_push *ndr, int flags, const struct samr_SetMemberAttributesOfGroup *r)
8095 {
8096         if (flags & NDR_IN) {
8097                 if (r->in.group_handle == NULL) {
8098                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8099                 }
8100                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8101                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
8102                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
8103         }
8104         if (flags & NDR_OUT) {
8105                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8106         }
8107         return NDR_ERR_SUCCESS;
8108 }
8109
8110 static enum ndr_err_code ndr_pull_samr_SetMemberAttributesOfGroup(struct ndr_pull *ndr, int flags, struct samr_SetMemberAttributesOfGroup *r)
8111 {
8112         TALLOC_CTX *_mem_save_group_handle_0;
8113         if (flags & NDR_IN) {
8114                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8115                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
8116                 }
8117                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8118                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
8119                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8120                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
8121                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
8122                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
8123         }
8124         if (flags & NDR_OUT) {
8125                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8126         }
8127         return NDR_ERR_SUCCESS;
8128 }
8129
8130 _PUBLIC_ void ndr_print_samr_SetMemberAttributesOfGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetMemberAttributesOfGroup *r)
8131 {
8132         ndr_print_struct(ndr, name, "samr_SetMemberAttributesOfGroup");
8133         ndr->depth++;
8134         if (flags & NDR_SET_VALUES) {
8135                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8136         }
8137         if (flags & NDR_IN) {
8138                 ndr_print_struct(ndr, "in", "samr_SetMemberAttributesOfGroup");
8139                 ndr->depth++;
8140                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
8141                 ndr->depth++;
8142                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
8143                 ndr->depth--;
8144                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
8145                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
8146                 ndr->depth--;
8147         }
8148         if (flags & NDR_OUT) {
8149                 ndr_print_struct(ndr, "out", "samr_SetMemberAttributesOfGroup");
8150                 ndr->depth++;
8151                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8152                 ndr->depth--;
8153         }
8154         ndr->depth--;
8155 }
8156
8157 static enum ndr_err_code ndr_push_samr_OpenAlias(struct ndr_push *ndr, int flags, const struct samr_OpenAlias *r)
8158 {
8159         if (flags & NDR_IN) {
8160                 if (r->in.domain_handle == NULL) {
8161                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8162                 }
8163                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
8164                 NDR_CHECK(ndr_push_samr_AliasAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
8165                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
8166         }
8167         if (flags & NDR_OUT) {
8168                 if (r->out.alias_handle == NULL) {
8169                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8170                 }
8171                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
8172                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8173         }
8174         return NDR_ERR_SUCCESS;
8175 }
8176
8177 static enum ndr_err_code ndr_pull_samr_OpenAlias(struct ndr_pull *ndr, int flags, struct samr_OpenAlias *r)
8178 {
8179         TALLOC_CTX *_mem_save_domain_handle_0;
8180         TALLOC_CTX *_mem_save_alias_handle_0;
8181         if (flags & NDR_IN) {
8182                 ZERO_STRUCT(r->out);
8183
8184                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8185                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
8186                 }
8187                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8188                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
8189                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
8190                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
8191                 NDR_CHECK(ndr_pull_samr_AliasAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
8192                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
8193                 NDR_PULL_ALLOC(ndr, r->out.alias_handle);
8194                 ZERO_STRUCTP(r->out.alias_handle);
8195         }
8196         if (flags & NDR_OUT) {
8197                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8198                         NDR_PULL_ALLOC(ndr, r->out.alias_handle);
8199                 }
8200                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8201                 NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8202                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
8203                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8204                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8205         }
8206         return NDR_ERR_SUCCESS;
8207 }
8208
8209 _PUBLIC_ void ndr_print_samr_OpenAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenAlias *r)
8210 {
8211         ndr_print_struct(ndr, name, "samr_OpenAlias");
8212         ndr->depth++;
8213         if (flags & NDR_SET_VALUES) {
8214                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8215         }
8216         if (flags & NDR_IN) {
8217                 ndr_print_struct(ndr, "in", "samr_OpenAlias");
8218                 ndr->depth++;
8219                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
8220                 ndr->depth++;
8221                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
8222                 ndr->depth--;
8223                 ndr_print_samr_AliasAccessMask(ndr, "access_mask", r->in.access_mask);
8224                 ndr_print_uint32(ndr, "rid", r->in.rid);
8225                 ndr->depth--;
8226         }
8227         if (flags & NDR_OUT) {
8228                 ndr_print_struct(ndr, "out", "samr_OpenAlias");
8229                 ndr->depth++;
8230                 ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);
8231                 ndr->depth++;
8232                 ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);
8233                 ndr->depth--;
8234                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8235                 ndr->depth--;
8236         }
8237         ndr->depth--;
8238 }
8239
8240 static enum ndr_err_code ndr_push_samr_QueryAliasInfo(struct ndr_push *ndr, int flags, const struct samr_QueryAliasInfo *r)
8241 {
8242         if (flags & NDR_IN) {
8243                 if (r->in.alias_handle == NULL) {
8244                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8245                 }
8246                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8247                 NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, r->in.level));
8248         }
8249         if (flags & NDR_OUT) {
8250                 if (r->out.info == NULL) {
8251                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8252                 }
8253                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
8254                 if (*r->out.info) {
8255                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
8256                         NDR_CHECK(ndr_push_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8257                 }
8258                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8259         }
8260         return NDR_ERR_SUCCESS;
8261 }
8262
8263 static enum ndr_err_code ndr_pull_samr_QueryAliasInfo(struct ndr_pull *ndr, int flags, struct samr_QueryAliasInfo *r)
8264 {
8265         uint32_t _ptr_info;
8266         TALLOC_CTX *_mem_save_alias_handle_0;
8267         TALLOC_CTX *_mem_save_info_0;
8268         TALLOC_CTX *_mem_save_info_1;
8269         if (flags & NDR_IN) {
8270                 ZERO_STRUCT(r->out);
8271
8272                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8273                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8274                 }
8275                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8276                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8277                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8278                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8279                 NDR_CHECK(ndr_pull_samr_AliasInfoEnum(ndr, NDR_SCALARS, &r->in.level));
8280                 NDR_PULL_ALLOC(ndr, r->out.info);
8281                 ZERO_STRUCTP(r->out.info);
8282         }
8283         if (flags & NDR_OUT) {
8284                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8285                         NDR_PULL_ALLOC(ndr, r->out.info);
8286                 }
8287                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8288                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
8289                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8290                 if (_ptr_info) {
8291                         NDR_PULL_ALLOC(ndr, *r->out.info);
8292                 } else {
8293                         *r->out.info = NULL;
8294                 }
8295                 if (*r->out.info) {
8296                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
8297                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
8298                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
8299                         NDR_CHECK(ndr_pull_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8300                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
8301                 }
8302                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
8303                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8304         }
8305         return NDR_ERR_SUCCESS;
8306 }
8307
8308 _PUBLIC_ void ndr_print_samr_QueryAliasInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryAliasInfo *r)
8309 {
8310         ndr_print_struct(ndr, name, "samr_QueryAliasInfo");
8311         ndr->depth++;
8312         if (flags & NDR_SET_VALUES) {
8313                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8314         }
8315         if (flags & NDR_IN) {
8316                 ndr_print_struct(ndr, "in", "samr_QueryAliasInfo");
8317                 ndr->depth++;
8318                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8319                 ndr->depth++;
8320                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8321                 ndr->depth--;
8322                 ndr_print_samr_AliasInfoEnum(ndr, "level", r->in.level);
8323                 ndr->depth--;
8324         }
8325         if (flags & NDR_OUT) {
8326                 ndr_print_struct(ndr, "out", "samr_QueryAliasInfo");
8327                 ndr->depth++;
8328                 ndr_print_ptr(ndr, "info", r->out.info);
8329                 ndr->depth++;
8330                 ndr_print_ptr(ndr, "info", *r->out.info);
8331                 ndr->depth++;
8332                 if (*r->out.info) {
8333                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
8334                         ndr_print_samr_AliasInfo(ndr, "info", *r->out.info);
8335                 }
8336                 ndr->depth--;
8337                 ndr->depth--;
8338                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8339                 ndr->depth--;
8340         }
8341         ndr->depth--;
8342 }
8343
8344 static enum ndr_err_code ndr_push_samr_SetAliasInfo(struct ndr_push *ndr, int flags, const struct samr_SetAliasInfo *r)
8345 {
8346         if (flags & NDR_IN) {
8347                 if (r->in.alias_handle == NULL) {
8348                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8349                 }
8350                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8351                 NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, r->in.level));
8352                 if (r->in.info == NULL) {
8353                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8354                 }
8355                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
8356                 NDR_CHECK(ndr_push_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8357         }
8358         if (flags & NDR_OUT) {
8359                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8360         }
8361         return NDR_ERR_SUCCESS;
8362 }
8363
8364 static enum ndr_err_code ndr_pull_samr_SetAliasInfo(struct ndr_pull *ndr, int flags, struct samr_SetAliasInfo *r)
8365 {
8366         TALLOC_CTX *_mem_save_alias_handle_0;
8367         TALLOC_CTX *_mem_save_info_0;
8368         if (flags & NDR_IN) {
8369                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8370                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8371                 }
8372                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8373                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8374                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8375                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8376                 NDR_CHECK(ndr_pull_samr_AliasInfoEnum(ndr, NDR_SCALARS, &r->in.level));
8377                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8378                         NDR_PULL_ALLOC(ndr, r->in.info);
8379                 }
8380                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8381                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
8382                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
8383                 NDR_CHECK(ndr_pull_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8384                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
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_SetAliasInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetAliasInfo *r)
8393 {
8394         ndr_print_struct(ndr, name, "samr_SetAliasInfo");
8395         ndr->depth++;
8396         if (flags & NDR_SET_VALUES) {
8397                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8398         }
8399         if (flags & NDR_IN) {
8400                 ndr_print_struct(ndr, "in", "samr_SetAliasInfo");
8401                 ndr->depth++;
8402                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8403                 ndr->depth++;
8404                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8405                 ndr->depth--;
8406                 ndr_print_samr_AliasInfoEnum(ndr, "level", r->in.level);
8407                 ndr_print_ptr(ndr, "info", r->in.info);
8408                 ndr->depth++;
8409                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
8410                 ndr_print_samr_AliasInfo(ndr, "info", r->in.info);
8411                 ndr->depth--;
8412                 ndr->depth--;
8413         }
8414         if (flags & NDR_OUT) {
8415                 ndr_print_struct(ndr, "out", "samr_SetAliasInfo");
8416                 ndr->depth++;
8417                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8418                 ndr->depth--;
8419         }
8420         ndr->depth--;
8421 }
8422
8423 static enum ndr_err_code ndr_push_samr_DeleteDomAlias(struct ndr_push *ndr, int flags, const struct samr_DeleteDomAlias *r)
8424 {
8425         if (flags & NDR_IN) {
8426                 if (r->in.alias_handle == NULL) {
8427                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8428                 }
8429                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8430         }
8431         if (flags & NDR_OUT) {
8432                 if (r->out.alias_handle == NULL) {
8433                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8434                 }
8435                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
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_DeleteDomAlias(struct ndr_pull *ndr, int flags, struct samr_DeleteDomAlias *r)
8442 {
8443         TALLOC_CTX *_mem_save_alias_handle_0;
8444         if (flags & NDR_IN) {
8445                 ZERO_STRUCT(r->out);
8446
8447                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8448                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8449                 }
8450                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8451                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8452                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8453                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8454                 NDR_PULL_ALLOC(ndr, r->out.alias_handle);
8455                 *r->out.alias_handle = *r->in.alias_handle;
8456         }
8457         if (flags & NDR_OUT) {
8458                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8459                         NDR_PULL_ALLOC(ndr, r->out.alias_handle);
8460                 }
8461                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8462                 NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8463                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
8464                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8465                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8466         }
8467         return NDR_ERR_SUCCESS;
8468 }
8469
8470 _PUBLIC_ void ndr_print_samr_DeleteDomAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteDomAlias *r)
8471 {
8472         ndr_print_struct(ndr, name, "samr_DeleteDomAlias");
8473         ndr->depth++;
8474         if (flags & NDR_SET_VALUES) {
8475                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8476         }
8477         if (flags & NDR_IN) {
8478                 ndr_print_struct(ndr, "in", "samr_DeleteDomAlias");
8479                 ndr->depth++;
8480                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8481                 ndr->depth++;
8482                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8483                 ndr->depth--;
8484                 ndr->depth--;
8485         }
8486         if (flags & NDR_OUT) {
8487                 ndr_print_struct(ndr, "out", "samr_DeleteDomAlias");
8488                 ndr->depth++;
8489                 ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);
8490                 ndr->depth++;
8491                 ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);
8492                 ndr->depth--;
8493                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8494                 ndr->depth--;
8495         }
8496         ndr->depth--;
8497 }
8498
8499 static enum ndr_err_code ndr_push_samr_AddAliasMember(struct ndr_push *ndr, int flags, const struct samr_AddAliasMember *r)
8500 {
8501         if (flags & NDR_IN) {
8502                 if (r->in.alias_handle == NULL) {
8503                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8504                 }
8505                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8506                 if (r->in.sid == NULL) {
8507                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8508                 }
8509                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8510         }
8511         if (flags & NDR_OUT) {
8512                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8513         }
8514         return NDR_ERR_SUCCESS;
8515 }
8516
8517 static enum ndr_err_code ndr_pull_samr_AddAliasMember(struct ndr_pull *ndr, int flags, struct samr_AddAliasMember *r)
8518 {
8519         TALLOC_CTX *_mem_save_alias_handle_0;
8520         TALLOC_CTX *_mem_save_sid_0;
8521         if (flags & NDR_IN) {
8522                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8523                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8524                 }
8525                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8526                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8527                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8528                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8529                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8530                         NDR_PULL_ALLOC(ndr, r->in.sid);
8531                 }
8532                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
8533                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
8534                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8535                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
8536         }
8537         if (flags & NDR_OUT) {
8538                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8539         }
8540         return NDR_ERR_SUCCESS;
8541 }
8542
8543 _PUBLIC_ void ndr_print_samr_AddAliasMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddAliasMember *r)
8544 {
8545         ndr_print_struct(ndr, name, "samr_AddAliasMember");
8546         ndr->depth++;
8547         if (flags & NDR_SET_VALUES) {
8548                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8549         }
8550         if (flags & NDR_IN) {
8551                 ndr_print_struct(ndr, "in", "samr_AddAliasMember");
8552                 ndr->depth++;
8553                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8554                 ndr->depth++;
8555                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8556                 ndr->depth--;
8557                 ndr_print_ptr(ndr, "sid", r->in.sid);
8558                 ndr->depth++;
8559                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
8560                 ndr->depth--;
8561                 ndr->depth--;
8562         }
8563         if (flags & NDR_OUT) {
8564                 ndr_print_struct(ndr, "out", "samr_AddAliasMember");
8565                 ndr->depth++;
8566                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8567                 ndr->depth--;
8568         }
8569         ndr->depth--;
8570 }
8571
8572 static enum ndr_err_code ndr_push_samr_DeleteAliasMember(struct ndr_push *ndr, int flags, const struct samr_DeleteAliasMember *r)
8573 {
8574         if (flags & NDR_IN) {
8575                 if (r->in.alias_handle == NULL) {
8576                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8577                 }
8578                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8579                 if (r->in.sid == NULL) {
8580                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8581                 }
8582                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8583         }
8584         if (flags & NDR_OUT) {
8585                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8586         }
8587         return NDR_ERR_SUCCESS;
8588 }
8589
8590 static enum ndr_err_code ndr_pull_samr_DeleteAliasMember(struct ndr_pull *ndr, int flags, struct samr_DeleteAliasMember *r)
8591 {
8592         TALLOC_CTX *_mem_save_alias_handle_0;
8593         TALLOC_CTX *_mem_save_sid_0;
8594         if (flags & NDR_IN) {
8595                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8596                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8597                 }
8598                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8599                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8600                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8601                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8602                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8603                         NDR_PULL_ALLOC(ndr, r->in.sid);
8604                 }
8605                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
8606                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
8607                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8608                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
8609         }
8610         if (flags & NDR_OUT) {
8611                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8612         }
8613         return NDR_ERR_SUCCESS;
8614 }
8615
8616 _PUBLIC_ void ndr_print_samr_DeleteAliasMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteAliasMember *r)
8617 {
8618         ndr_print_struct(ndr, name, "samr_DeleteAliasMember");
8619         ndr->depth++;
8620         if (flags & NDR_SET_VALUES) {
8621                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8622         }
8623         if (flags & NDR_IN) {
8624                 ndr_print_struct(ndr, "in", "samr_DeleteAliasMember");
8625                 ndr->depth++;
8626                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8627                 ndr->depth++;
8628                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8629                 ndr->depth--;
8630                 ndr_print_ptr(ndr, "sid", r->in.sid);
8631                 ndr->depth++;
8632                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
8633                 ndr->depth--;
8634                 ndr->depth--;
8635         }
8636         if (flags & NDR_OUT) {
8637                 ndr_print_struct(ndr, "out", "samr_DeleteAliasMember");
8638                 ndr->depth++;
8639                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8640                 ndr->depth--;
8641         }
8642         ndr->depth--;
8643 }
8644
8645 static enum ndr_err_code ndr_push_samr_GetMembersInAlias(struct ndr_push *ndr, int flags, const struct samr_GetMembersInAlias *r)
8646 {
8647         if (flags & NDR_IN) {
8648                 if (r->in.alias_handle == NULL) {
8649                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8650                 }
8651                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8652         }
8653         if (flags & NDR_OUT) {
8654                 if (r->out.sids == NULL) {
8655                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8656                 }
8657                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
8658                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8659         }
8660         return NDR_ERR_SUCCESS;
8661 }
8662
8663 static enum ndr_err_code ndr_pull_samr_GetMembersInAlias(struct ndr_pull *ndr, int flags, struct samr_GetMembersInAlias *r)
8664 {
8665         TALLOC_CTX *_mem_save_alias_handle_0;
8666         TALLOC_CTX *_mem_save_sids_0;
8667         if (flags & NDR_IN) {
8668                 ZERO_STRUCT(r->out);
8669
8670                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8671                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8672                 }
8673                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8674                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8675                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8676                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8677                 NDR_PULL_ALLOC(ndr, r->out.sids);
8678                 ZERO_STRUCTP(r->out.sids);
8679         }
8680         if (flags & NDR_OUT) {
8681                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8682                         NDR_PULL_ALLOC(ndr, r->out.sids);
8683                 }
8684                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
8685                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
8686                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
8687                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
8688                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8689         }
8690         return NDR_ERR_SUCCESS;
8691 }
8692
8693 _PUBLIC_ void ndr_print_samr_GetMembersInAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetMembersInAlias *r)
8694 {
8695         ndr_print_struct(ndr, name, "samr_GetMembersInAlias");
8696         ndr->depth++;
8697         if (flags & NDR_SET_VALUES) {
8698                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8699         }
8700         if (flags & NDR_IN) {
8701                 ndr_print_struct(ndr, "in", "samr_GetMembersInAlias");
8702                 ndr->depth++;
8703                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8704                 ndr->depth++;
8705                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8706                 ndr->depth--;
8707                 ndr->depth--;
8708         }
8709         if (flags & NDR_OUT) {
8710                 ndr_print_struct(ndr, "out", "samr_GetMembersInAlias");
8711                 ndr->depth++;
8712                 ndr_print_ptr(ndr, "sids", r->out.sids);
8713                 ndr->depth++;
8714                 ndr_print_lsa_SidArray(ndr, "sids", r->out.sids);
8715                 ndr->depth--;
8716                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8717                 ndr->depth--;
8718         }
8719         ndr->depth--;
8720 }
8721
8722 _PUBLIC_ enum ndr_err_code ndr_push_samr_OpenUser(struct ndr_push *ndr, int flags, const struct samr_OpenUser *r)
8723 {
8724         if (flags & NDR_IN) {
8725                 if (r->in.domain_handle == NULL) {
8726                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8727                 }
8728                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
8729                 NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
8730                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
8731         }
8732         if (flags & NDR_OUT) {
8733                 if (r->out.user_handle == NULL) {
8734                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8735                 }
8736                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
8737                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8738         }
8739         return NDR_ERR_SUCCESS;
8740 }
8741
8742 _PUBLIC_ enum ndr_err_code ndr_pull_samr_OpenUser(struct ndr_pull *ndr, int flags, struct samr_OpenUser *r)
8743 {
8744         TALLOC_CTX *_mem_save_domain_handle_0;
8745         TALLOC_CTX *_mem_save_user_handle_0;
8746         if (flags & NDR_IN) {
8747                 ZERO_STRUCT(r->out);
8748
8749                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8750                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
8751                 }
8752                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8753                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
8754                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
8755                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
8756                 NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
8757                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
8758                 NDR_PULL_ALLOC(ndr, r->out.user_handle);
8759                 ZERO_STRUCTP(r->out.user_handle);
8760         }
8761         if (flags & NDR_OUT) {
8762                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8763                         NDR_PULL_ALLOC(ndr, r->out.user_handle);
8764                 }
8765                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8766                 NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
8767                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
8768                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
8769                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8770         }
8771         return NDR_ERR_SUCCESS;
8772 }
8773
8774 _PUBLIC_ void ndr_print_samr_OpenUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenUser *r)
8775 {
8776         ndr_print_struct(ndr, name, "samr_OpenUser");
8777         ndr->depth++;
8778         if (flags & NDR_SET_VALUES) {
8779                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8780         }
8781         if (flags & NDR_IN) {
8782                 ndr_print_struct(ndr, "in", "samr_OpenUser");
8783                 ndr->depth++;
8784                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
8785                 ndr->depth++;
8786                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
8787                 ndr->depth--;
8788                 ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);
8789                 ndr_print_uint32(ndr, "rid", r->in.rid);
8790                 ndr->depth--;
8791         }
8792         if (flags & NDR_OUT) {
8793                 ndr_print_struct(ndr, "out", "samr_OpenUser");
8794                 ndr->depth++;
8795                 ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
8796                 ndr->depth++;
8797                 ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
8798                 ndr->depth--;
8799                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8800                 ndr->depth--;
8801         }
8802         ndr->depth--;
8803 }
8804
8805 static enum ndr_err_code ndr_push_samr_DeleteUser(struct ndr_push *ndr, int flags, const struct samr_DeleteUser *r)
8806 {
8807         if (flags & NDR_IN) {
8808                 if (r->in.user_handle == NULL) {
8809                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8810                 }
8811                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
8812         }
8813         if (flags & NDR_OUT) {
8814                 if (r->out.user_handle == NULL) {
8815                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8816                 }
8817                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
8818                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8819         }
8820         return NDR_ERR_SUCCESS;
8821 }
8822
8823 static enum ndr_err_code ndr_pull_samr_DeleteUser(struct ndr_pull *ndr, int flags, struct samr_DeleteUser *r)
8824 {
8825         TALLOC_CTX *_mem_save_user_handle_0;
8826         if (flags & NDR_IN) {
8827                 ZERO_STRUCT(r->out);
8828
8829                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8830                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
8831                 }
8832                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8833                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
8834                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
8835                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
8836                 NDR_PULL_ALLOC(ndr, r->out.user_handle);
8837                 *r->out.user_handle = *r->in.user_handle;
8838         }
8839         if (flags & NDR_OUT) {
8840                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8841                         NDR_PULL_ALLOC(ndr, r->out.user_handle);
8842                 }
8843                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8844                 NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
8845                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
8846                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
8847                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8848         }
8849         return NDR_ERR_SUCCESS;
8850 }
8851
8852 _PUBLIC_ void ndr_print_samr_DeleteUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteUser *r)
8853 {
8854         ndr_print_struct(ndr, name, "samr_DeleteUser");
8855         ndr->depth++;
8856         if (flags & NDR_SET_VALUES) {
8857                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8858         }
8859         if (flags & NDR_IN) {
8860                 ndr_print_struct(ndr, "in", "samr_DeleteUser");
8861                 ndr->depth++;
8862                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
8863                 ndr->depth++;
8864                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
8865                 ndr->depth--;
8866                 ndr->depth--;
8867         }
8868         if (flags & NDR_OUT) {
8869                 ndr_print_struct(ndr, "out", "samr_DeleteUser");
8870                 ndr->depth++;
8871                 ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
8872                 ndr->depth++;
8873                 ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
8874                 ndr->depth--;
8875                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8876                 ndr->depth--;
8877         }
8878         ndr->depth--;
8879 }
8880
8881 _PUBLIC_ enum ndr_err_code ndr_push_samr_QueryUserInfo(struct ndr_push *ndr, int flags, const struct samr_QueryUserInfo *r)
8882 {
8883         if (flags & NDR_IN) {
8884                 if (r->in.user_handle == NULL) {
8885                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8886                 }
8887                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
8888                 NDR_CHECK(ndr_push_samr_UserInfoLevel(ndr, NDR_SCALARS, r->in.level));
8889         }
8890         if (flags & NDR_OUT) {
8891                 if (r->out.info == NULL) {
8892                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8893                 }
8894                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
8895                 if (*r->out.info) {
8896                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
8897                         NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8898                 }
8899                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8900         }
8901         return NDR_ERR_SUCCESS;
8902 }
8903
8904 _PUBLIC_ enum ndr_err_code ndr_pull_samr_QueryUserInfo(struct ndr_pull *ndr, int flags, struct samr_QueryUserInfo *r)
8905 {
8906         uint32_t _ptr_info;
8907         TALLOC_CTX *_mem_save_user_handle_0;
8908         TALLOC_CTX *_mem_save_info_0;
8909         TALLOC_CTX *_mem_save_info_1;
8910         if (flags & NDR_IN) {
8911                 ZERO_STRUCT(r->out);
8912
8913                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8914                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
8915                 }
8916                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8917                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
8918                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
8919                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
8920                 NDR_CHECK(ndr_pull_samr_UserInfoLevel(ndr, NDR_SCALARS, &r->in.level));
8921                 NDR_PULL_ALLOC(ndr, r->out.info);
8922                 ZERO_STRUCTP(r->out.info);
8923         }
8924         if (flags & NDR_OUT) {
8925                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8926                         NDR_PULL_ALLOC(ndr, r->out.info);
8927                 }
8928                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8929                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
8930                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8931                 if (_ptr_info) {
8932                         NDR_PULL_ALLOC(ndr, *r->out.info);
8933                 } else {
8934                         *r->out.info = NULL;
8935                 }
8936                 if (*r->out.info) {
8937                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
8938                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
8939                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
8940                         NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8941                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
8942                 }
8943                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
8944                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8945         }
8946         return NDR_ERR_SUCCESS;
8947 }
8948
8949 _PUBLIC_ void ndr_print_samr_QueryUserInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryUserInfo *r)
8950 {
8951         ndr_print_struct(ndr, name, "samr_QueryUserInfo");
8952         ndr->depth++;
8953         if (flags & NDR_SET_VALUES) {
8954                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8955         }
8956         if (flags & NDR_IN) {
8957                 ndr_print_struct(ndr, "in", "samr_QueryUserInfo");
8958                 ndr->depth++;
8959                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
8960                 ndr->depth++;
8961                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
8962                 ndr->depth--;
8963                 ndr_print_samr_UserInfoLevel(ndr, "level", r->in.level);
8964                 ndr->depth--;
8965         }
8966         if (flags & NDR_OUT) {
8967                 ndr_print_struct(ndr, "out", "samr_QueryUserInfo");
8968                 ndr->depth++;
8969                 ndr_print_ptr(ndr, "info", r->out.info);
8970                 ndr->depth++;
8971                 ndr_print_ptr(ndr, "info", *r->out.info);
8972                 ndr->depth++;
8973                 if (*r->out.info) {
8974                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
8975                         ndr_print_samr_UserInfo(ndr, "info", *r->out.info);
8976                 }
8977                 ndr->depth--;
8978                 ndr->depth--;
8979                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8980                 ndr->depth--;
8981         }
8982         ndr->depth--;
8983 }
8984
8985 _PUBLIC_ enum ndr_err_code ndr_push_samr_SetUserInfo(struct ndr_push *ndr, int flags, const struct samr_SetUserInfo *r)
8986 {
8987         if (flags & NDR_IN) {
8988                 if (r->in.user_handle == NULL) {
8989                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8990                 }
8991                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
8992                 NDR_CHECK(ndr_push_samr_UserInfoLevel(ndr, NDR_SCALARS, r->in.level));
8993                 if (r->in.info == NULL) {
8994                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8995                 }
8996                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
8997                 NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8998         }
8999         if (flags & NDR_OUT) {
9000                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9001         }
9002         return NDR_ERR_SUCCESS;
9003 }
9004
9005 _PUBLIC_ enum ndr_err_code ndr_pull_samr_SetUserInfo(struct ndr_pull *ndr, int flags, struct samr_SetUserInfo *r)
9006 {
9007         TALLOC_CTX *_mem_save_user_handle_0;
9008         TALLOC_CTX *_mem_save_info_0;
9009         if (flags & NDR_IN) {
9010                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9011                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9012                 }
9013                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9014                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9015                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9016                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9017                 NDR_CHECK(ndr_pull_samr_UserInfoLevel(ndr, NDR_SCALARS, &r->in.level));
9018                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9019                         NDR_PULL_ALLOC(ndr, r->in.info);
9020                 }
9021                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9022                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
9023                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
9024                 NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
9025                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9026         }
9027         if (flags & NDR_OUT) {
9028                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9029         }
9030         return NDR_ERR_SUCCESS;
9031 }
9032
9033 _PUBLIC_ void ndr_print_samr_SetUserInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetUserInfo *r)
9034 {
9035         ndr_print_struct(ndr, name, "samr_SetUserInfo");
9036         ndr->depth++;
9037         if (flags & NDR_SET_VALUES) {
9038                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9039         }
9040         if (flags & NDR_IN) {
9041                 ndr_print_struct(ndr, "in", "samr_SetUserInfo");
9042                 ndr->depth++;
9043                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9044                 ndr->depth++;
9045                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9046                 ndr->depth--;
9047                 ndr_print_samr_UserInfoLevel(ndr, "level", r->in.level);
9048                 ndr_print_ptr(ndr, "info", r->in.info);
9049                 ndr->depth++;
9050                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
9051                 ndr_print_samr_UserInfo(ndr, "info", r->in.info);
9052                 ndr->depth--;
9053                 ndr->depth--;
9054         }
9055         if (flags & NDR_OUT) {
9056                 ndr_print_struct(ndr, "out", "samr_SetUserInfo");
9057                 ndr->depth++;
9058                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9059                 ndr->depth--;
9060         }
9061         ndr->depth--;
9062 }
9063
9064 static enum ndr_err_code ndr_push_samr_ChangePasswordUser(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser *r)
9065 {
9066         if (flags & NDR_IN) {
9067                 if (r->in.user_handle == NULL) {
9068                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9069                 }
9070                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9071                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_present));
9072                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_lm_crypted));
9073                 if (r->in.old_lm_crypted) {
9074                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.old_lm_crypted));
9075                 }
9076                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_lm_crypted));
9077                 if (r->in.new_lm_crypted) {
9078                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.new_lm_crypted));
9079                 }
9080                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.nt_present));
9081                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_nt_crypted));
9082                 if (r->in.old_nt_crypted) {
9083                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.old_nt_crypted));
9084                 }
9085                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_nt_crypted));
9086                 if (r->in.new_nt_crypted) {
9087                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.new_nt_crypted));
9088                 }
9089                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.cross1_present));
9090                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_cross));
9091                 if (r->in.nt_cross) {
9092                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_cross));
9093                 }
9094                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.cross2_present));
9095                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_cross));
9096                 if (r->in.lm_cross) {
9097                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_cross));
9098                 }
9099         }
9100         if (flags & NDR_OUT) {
9101                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9102         }
9103         return NDR_ERR_SUCCESS;
9104 }
9105
9106 static enum ndr_err_code ndr_pull_samr_ChangePasswordUser(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser *r)
9107 {
9108         uint32_t _ptr_old_lm_crypted;
9109         uint32_t _ptr_new_lm_crypted;
9110         uint32_t _ptr_old_nt_crypted;
9111         uint32_t _ptr_new_nt_crypted;
9112         uint32_t _ptr_nt_cross;
9113         uint32_t _ptr_lm_cross;
9114         TALLOC_CTX *_mem_save_user_handle_0;
9115         TALLOC_CTX *_mem_save_old_lm_crypted_0;
9116         TALLOC_CTX *_mem_save_new_lm_crypted_0;
9117         TALLOC_CTX *_mem_save_old_nt_crypted_0;
9118         TALLOC_CTX *_mem_save_new_nt_crypted_0;
9119         TALLOC_CTX *_mem_save_nt_cross_0;
9120         TALLOC_CTX *_mem_save_lm_cross_0;
9121         if (flags & NDR_IN) {
9122                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9123                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9124                 }
9125                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9126                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9127                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9128                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9129                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_present));
9130                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_lm_crypted));
9131                 if (_ptr_old_lm_crypted) {
9132                         NDR_PULL_ALLOC(ndr, r->in.old_lm_crypted);
9133                 } else {
9134                         r->in.old_lm_crypted = NULL;
9135                 }
9136                 if (r->in.old_lm_crypted) {
9137                         _mem_save_old_lm_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
9138                         NDR_PULL_SET_MEM_CTX(ndr, r->in.old_lm_crypted, 0);
9139                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.old_lm_crypted));
9140                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_lm_crypted_0, 0);
9141                 }
9142                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_lm_crypted));
9143                 if (_ptr_new_lm_crypted) {
9144                         NDR_PULL_ALLOC(ndr, r->in.new_lm_crypted);
9145                 } else {
9146                         r->in.new_lm_crypted = NULL;
9147                 }
9148                 if (r->in.new_lm_crypted) {
9149                         _mem_save_new_lm_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
9150                         NDR_PULL_SET_MEM_CTX(ndr, r->in.new_lm_crypted, 0);
9151                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.new_lm_crypted));
9152                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_lm_crypted_0, 0);
9153                 }
9154                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.nt_present));
9155                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_nt_crypted));
9156                 if (_ptr_old_nt_crypted) {
9157                         NDR_PULL_ALLOC(ndr, r->in.old_nt_crypted);
9158                 } else {
9159                         r->in.old_nt_crypted = NULL;
9160                 }
9161                 if (r->in.old_nt_crypted) {
9162                         _mem_save_old_nt_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
9163                         NDR_PULL_SET_MEM_CTX(ndr, r->in.old_nt_crypted, 0);
9164                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.old_nt_crypted));
9165                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_nt_crypted_0, 0);
9166                 }
9167                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_nt_crypted));
9168                 if (_ptr_new_nt_crypted) {
9169                         NDR_PULL_ALLOC(ndr, r->in.new_nt_crypted);
9170                 } else {
9171                         r->in.new_nt_crypted = NULL;
9172                 }
9173                 if (r->in.new_nt_crypted) {
9174                         _mem_save_new_nt_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
9175                         NDR_PULL_SET_MEM_CTX(ndr, r->in.new_nt_crypted, 0);
9176                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.new_nt_crypted));
9177                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_nt_crypted_0, 0);
9178                 }
9179                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.cross1_present));
9180                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_cross));
9181                 if (_ptr_nt_cross) {
9182                         NDR_PULL_ALLOC(ndr, r->in.nt_cross);
9183                 } else {
9184                         r->in.nt_cross = NULL;
9185                 }
9186                 if (r->in.nt_cross) {
9187                         _mem_save_nt_cross_0 = NDR_PULL_GET_MEM_CTX(ndr);
9188                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_cross, 0);
9189                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_cross));
9190                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_cross_0, 0);
9191                 }
9192                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.cross2_present));
9193                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_cross));
9194                 if (_ptr_lm_cross) {
9195                         NDR_PULL_ALLOC(ndr, r->in.lm_cross);
9196                 } else {
9197                         r->in.lm_cross = NULL;
9198                 }
9199                 if (r->in.lm_cross) {
9200                         _mem_save_lm_cross_0 = NDR_PULL_GET_MEM_CTX(ndr);
9201                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_cross, 0);
9202                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_cross));
9203                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_cross_0, 0);
9204                 }
9205         }
9206         if (flags & NDR_OUT) {
9207                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9208         }
9209         return NDR_ERR_SUCCESS;
9210 }
9211
9212 _PUBLIC_ void ndr_print_samr_ChangePasswordUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser *r)
9213 {
9214         ndr_print_struct(ndr, name, "samr_ChangePasswordUser");
9215         ndr->depth++;
9216         if (flags & NDR_SET_VALUES) {
9217                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9218         }
9219         if (flags & NDR_IN) {
9220                 ndr_print_struct(ndr, "in", "samr_ChangePasswordUser");
9221                 ndr->depth++;
9222                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9223                 ndr->depth++;
9224                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9225                 ndr->depth--;
9226                 ndr_print_uint8(ndr, "lm_present", r->in.lm_present);
9227                 ndr_print_ptr(ndr, "old_lm_crypted", r->in.old_lm_crypted);
9228                 ndr->depth++;
9229                 if (r->in.old_lm_crypted) {
9230                         ndr_print_samr_Password(ndr, "old_lm_crypted", r->in.old_lm_crypted);
9231                 }
9232                 ndr->depth--;
9233                 ndr_print_ptr(ndr, "new_lm_crypted", r->in.new_lm_crypted);
9234                 ndr->depth++;
9235                 if (r->in.new_lm_crypted) {
9236                         ndr_print_samr_Password(ndr, "new_lm_crypted", r->in.new_lm_crypted);
9237                 }
9238                 ndr->depth--;
9239                 ndr_print_uint8(ndr, "nt_present", r->in.nt_present);
9240                 ndr_print_ptr(ndr, "old_nt_crypted", r->in.old_nt_crypted);
9241                 ndr->depth++;
9242                 if (r->in.old_nt_crypted) {
9243                         ndr_print_samr_Password(ndr, "old_nt_crypted", r->in.old_nt_crypted);
9244                 }
9245                 ndr->depth--;
9246                 ndr_print_ptr(ndr, "new_nt_crypted", r->in.new_nt_crypted);
9247                 ndr->depth++;
9248                 if (r->in.new_nt_crypted) {
9249                         ndr_print_samr_Password(ndr, "new_nt_crypted", r->in.new_nt_crypted);
9250                 }
9251                 ndr->depth--;
9252                 ndr_print_uint8(ndr, "cross1_present", r->in.cross1_present);
9253                 ndr_print_ptr(ndr, "nt_cross", r->in.nt_cross);
9254                 ndr->depth++;
9255                 if (r->in.nt_cross) {
9256                         ndr_print_samr_Password(ndr, "nt_cross", r->in.nt_cross);
9257                 }
9258                 ndr->depth--;
9259                 ndr_print_uint8(ndr, "cross2_present", r->in.cross2_present);
9260                 ndr_print_ptr(ndr, "lm_cross", r->in.lm_cross);
9261                 ndr->depth++;
9262                 if (r->in.lm_cross) {
9263                         ndr_print_samr_Password(ndr, "lm_cross", r->in.lm_cross);
9264                 }
9265                 ndr->depth--;
9266                 ndr->depth--;
9267         }
9268         if (flags & NDR_OUT) {
9269                 ndr_print_struct(ndr, "out", "samr_ChangePasswordUser");
9270                 ndr->depth++;
9271                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9272                 ndr->depth--;
9273         }
9274         ndr->depth--;
9275 }
9276
9277 static enum ndr_err_code ndr_push_samr_GetGroupsForUser(struct ndr_push *ndr, int flags, const struct samr_GetGroupsForUser *r)
9278 {
9279         if (flags & NDR_IN) {
9280                 if (r->in.user_handle == NULL) {
9281                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9282                 }
9283                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9284         }
9285         if (flags & NDR_OUT) {
9286                 if (r->out.rids == NULL) {
9287                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9288                 }
9289                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rids));
9290                 if (*r->out.rids) {
9291                         NDR_CHECK(ndr_push_samr_RidWithAttributeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
9292                 }
9293                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9294         }
9295         return NDR_ERR_SUCCESS;
9296 }
9297
9298 static enum ndr_err_code ndr_pull_samr_GetGroupsForUser(struct ndr_pull *ndr, int flags, struct samr_GetGroupsForUser *r)
9299 {
9300         uint32_t _ptr_rids;
9301         TALLOC_CTX *_mem_save_user_handle_0;
9302         TALLOC_CTX *_mem_save_rids_0;
9303         TALLOC_CTX *_mem_save_rids_1;
9304         if (flags & NDR_IN) {
9305                 ZERO_STRUCT(r->out);
9306
9307                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9308                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9309                 }
9310                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9311                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9312                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9313                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9314                 NDR_PULL_ALLOC(ndr, r->out.rids);
9315                 ZERO_STRUCTP(r->out.rids);
9316         }
9317         if (flags & NDR_OUT) {
9318                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9319                         NDR_PULL_ALLOC(ndr, r->out.rids);
9320                 }
9321                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
9322                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
9323                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
9324                 if (_ptr_rids) {
9325                         NDR_PULL_ALLOC(ndr, *r->out.rids);
9326                 } else {
9327                         *r->out.rids = NULL;
9328                 }
9329                 if (*r->out.rids) {
9330                         _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
9331                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.rids, 0);
9332                         NDR_CHECK(ndr_pull_samr_RidWithAttributeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
9333                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
9334                 }
9335                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
9336                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9337         }
9338         return NDR_ERR_SUCCESS;
9339 }
9340
9341 _PUBLIC_ void ndr_print_samr_GetGroupsForUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetGroupsForUser *r)
9342 {
9343         ndr_print_struct(ndr, name, "samr_GetGroupsForUser");
9344         ndr->depth++;
9345         if (flags & NDR_SET_VALUES) {
9346                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9347         }
9348         if (flags & NDR_IN) {
9349                 ndr_print_struct(ndr, "in", "samr_GetGroupsForUser");
9350                 ndr->depth++;
9351                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9352                 ndr->depth++;
9353                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9354                 ndr->depth--;
9355                 ndr->depth--;
9356         }
9357         if (flags & NDR_OUT) {
9358                 ndr_print_struct(ndr, "out", "samr_GetGroupsForUser");
9359                 ndr->depth++;
9360                 ndr_print_ptr(ndr, "rids", r->out.rids);
9361                 ndr->depth++;
9362                 ndr_print_ptr(ndr, "rids", *r->out.rids);
9363                 ndr->depth++;
9364                 if (*r->out.rids) {
9365                         ndr_print_samr_RidWithAttributeArray(ndr, "rids", *r->out.rids);
9366                 }
9367                 ndr->depth--;
9368                 ndr->depth--;
9369                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9370                 ndr->depth--;
9371         }
9372         ndr->depth--;
9373 }
9374
9375 static enum ndr_err_code ndr_push_samr_QueryDisplayInfo(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo *r)
9376 {
9377         if (flags & NDR_IN) {
9378                 if (r->in.domain_handle == NULL) {
9379                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9380                 }
9381                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9382                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9383                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));
9384                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));
9385                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
9386         }
9387         if (flags & NDR_OUT) {
9388                 if (r->out.total_size == NULL) {
9389                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9390                 }
9391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));
9392                 if (r->out.returned_size == NULL) {
9393                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9394                 }
9395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));
9396                 if (r->out.info == NULL) {
9397                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9398                 }
9399                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
9400                 NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
9401                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9402         }
9403         return NDR_ERR_SUCCESS;
9404 }
9405
9406 static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo *r)
9407 {
9408         TALLOC_CTX *_mem_save_domain_handle_0;
9409         TALLOC_CTX *_mem_save_total_size_0;
9410         TALLOC_CTX *_mem_save_returned_size_0;
9411         TALLOC_CTX *_mem_save_info_0;
9412         if (flags & NDR_IN) {
9413                 ZERO_STRUCT(r->out);
9414
9415                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9416                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
9417                 }
9418                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9419                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
9420                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9421                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
9422                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
9423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));
9424                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));
9425                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
9426                 NDR_PULL_ALLOC(ndr, r->out.total_size);
9427                 ZERO_STRUCTP(r->out.total_size);
9428                 NDR_PULL_ALLOC(ndr, r->out.returned_size);
9429                 ZERO_STRUCTP(r->out.returned_size);
9430                 NDR_PULL_ALLOC(ndr, r->out.info);
9431                 ZERO_STRUCTP(r->out.info);
9432         }
9433         if (flags & NDR_OUT) {
9434                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9435                         NDR_PULL_ALLOC(ndr, r->out.total_size);
9436                 }
9437                 _mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
9438                 NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);
9439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));
9440                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);
9441                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9442                         NDR_PULL_ALLOC(ndr, r->out.returned_size);
9443                 }
9444                 _mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
9445                 NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);
9446                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));
9447                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);
9448                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9449                         NDR_PULL_ALLOC(ndr, r->out.info);
9450                 }
9451                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9452                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9453                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
9454                 NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
9455                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9456                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9457         }
9458         return NDR_ERR_SUCCESS;
9459 }
9460
9461 _PUBLIC_ void ndr_print_samr_QueryDisplayInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo *r)
9462 {
9463         ndr_print_struct(ndr, name, "samr_QueryDisplayInfo");
9464         ndr->depth++;
9465         if (flags & NDR_SET_VALUES) {
9466                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9467         }
9468         if (flags & NDR_IN) {
9469                 ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo");
9470                 ndr->depth++;
9471                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
9472                 ndr->depth++;
9473                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
9474                 ndr->depth--;
9475                 ndr_print_uint16(ndr, "level", r->in.level);
9476                 ndr_print_uint32(ndr, "start_idx", r->in.start_idx);
9477                 ndr_print_uint32(ndr, "max_entries", r->in.max_entries);
9478                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
9479                 ndr->depth--;
9480         }
9481         if (flags & NDR_OUT) {
9482                 ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo");
9483                 ndr->depth++;
9484                 ndr_print_ptr(ndr, "total_size", r->out.total_size);
9485                 ndr->depth++;
9486                 ndr_print_uint32(ndr, "total_size", *r->out.total_size);
9487                 ndr->depth--;
9488                 ndr_print_ptr(ndr, "returned_size", r->out.returned_size);
9489                 ndr->depth++;
9490                 ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);
9491                 ndr->depth--;
9492                 ndr_print_ptr(ndr, "info", r->out.info);
9493                 ndr->depth++;
9494                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
9495                 ndr_print_samr_DispInfo(ndr, "info", r->out.info);
9496                 ndr->depth--;
9497                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9498                 ndr->depth--;
9499         }
9500         ndr->depth--;
9501 }
9502
9503 static enum ndr_err_code ndr_push_samr_GetDisplayEnumerationIndex(struct ndr_push *ndr, int flags, const struct samr_GetDisplayEnumerationIndex *r)
9504 {
9505         if (flags & NDR_IN) {
9506                 if (r->in.domain_handle == NULL) {
9507                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9508                 }
9509                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9510                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9511                 if (r->in.name == NULL) {
9512                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9513                 }
9514                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
9515         }
9516         if (flags & NDR_OUT) {
9517                 if (r->out.idx == NULL) {
9518                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9519                 }
9520                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.idx));
9521                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9522         }
9523         return NDR_ERR_SUCCESS;
9524 }
9525
9526 static enum ndr_err_code ndr_pull_samr_GetDisplayEnumerationIndex(struct ndr_pull *ndr, int flags, struct samr_GetDisplayEnumerationIndex *r)
9527 {
9528         TALLOC_CTX *_mem_save_domain_handle_0;
9529         TALLOC_CTX *_mem_save_name_0;
9530         TALLOC_CTX *_mem_save_idx_0;
9531         if (flags & NDR_IN) {
9532                 ZERO_STRUCT(r->out);
9533
9534                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9535                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
9536                 }
9537                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9538                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
9539                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9540                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
9541                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
9542                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9543                         NDR_PULL_ALLOC(ndr, r->in.name);
9544                 }
9545                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9546                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
9547                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
9548                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
9549                 NDR_PULL_ALLOC(ndr, r->out.idx);
9550                 ZERO_STRUCTP(r->out.idx);
9551         }
9552         if (flags & NDR_OUT) {
9553                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9554                         NDR_PULL_ALLOC(ndr, r->out.idx);
9555                 }
9556                 _mem_save_idx_0 = NDR_PULL_GET_MEM_CTX(ndr);
9557                 NDR_PULL_SET_MEM_CTX(ndr, r->out.idx, LIBNDR_FLAG_REF_ALLOC);
9558                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.idx));
9559                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_idx_0, LIBNDR_FLAG_REF_ALLOC);
9560                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9561         }
9562         return NDR_ERR_SUCCESS;
9563 }
9564
9565 _PUBLIC_ void ndr_print_samr_GetDisplayEnumerationIndex(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDisplayEnumerationIndex *r)
9566 {
9567         ndr_print_struct(ndr, name, "samr_GetDisplayEnumerationIndex");
9568         ndr->depth++;
9569         if (flags & NDR_SET_VALUES) {
9570                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9571         }
9572         if (flags & NDR_IN) {
9573                 ndr_print_struct(ndr, "in", "samr_GetDisplayEnumerationIndex");
9574                 ndr->depth++;
9575                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
9576                 ndr->depth++;
9577                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
9578                 ndr->depth--;
9579                 ndr_print_uint16(ndr, "level", r->in.level);
9580                 ndr_print_ptr(ndr, "name", r->in.name);
9581                 ndr->depth++;
9582                 ndr_print_lsa_String(ndr, "name", r->in.name);
9583                 ndr->depth--;
9584                 ndr->depth--;
9585         }
9586         if (flags & NDR_OUT) {
9587                 ndr_print_struct(ndr, "out", "samr_GetDisplayEnumerationIndex");
9588                 ndr->depth++;
9589                 ndr_print_ptr(ndr, "idx", r->out.idx);
9590                 ndr->depth++;
9591                 ndr_print_uint32(ndr, "idx", *r->out.idx);
9592                 ndr->depth--;
9593                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9594                 ndr->depth--;
9595         }
9596         ndr->depth--;
9597 }
9598
9599 static enum ndr_err_code ndr_push_samr_TestPrivateFunctionsDomain(struct ndr_push *ndr, int flags, const struct samr_TestPrivateFunctionsDomain *r)
9600 {
9601         if (flags & NDR_IN) {
9602                 if (r->in.domain_handle == NULL) {
9603                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9604                 }
9605                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9606         }
9607         if (flags & NDR_OUT) {
9608                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9609         }
9610         return NDR_ERR_SUCCESS;
9611 }
9612
9613 static enum ndr_err_code ndr_pull_samr_TestPrivateFunctionsDomain(struct ndr_pull *ndr, int flags, struct samr_TestPrivateFunctionsDomain *r)
9614 {
9615         TALLOC_CTX *_mem_save_domain_handle_0;
9616         if (flags & NDR_IN) {
9617                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9618                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
9619                 }
9620                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9621                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
9622                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9623                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
9624         }
9625         if (flags & NDR_OUT) {
9626                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9627         }
9628         return NDR_ERR_SUCCESS;
9629 }
9630
9631 _PUBLIC_ void ndr_print_samr_TestPrivateFunctionsDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_TestPrivateFunctionsDomain *r)
9632 {
9633         ndr_print_struct(ndr, name, "samr_TestPrivateFunctionsDomain");
9634         ndr->depth++;
9635         if (flags & NDR_SET_VALUES) {
9636                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9637         }
9638         if (flags & NDR_IN) {
9639                 ndr_print_struct(ndr, "in", "samr_TestPrivateFunctionsDomain");
9640                 ndr->depth++;
9641                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
9642                 ndr->depth++;
9643                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
9644                 ndr->depth--;
9645                 ndr->depth--;
9646         }
9647         if (flags & NDR_OUT) {
9648                 ndr_print_struct(ndr, "out", "samr_TestPrivateFunctionsDomain");
9649                 ndr->depth++;
9650                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9651                 ndr->depth--;
9652         }
9653         ndr->depth--;
9654 }
9655
9656 static enum ndr_err_code ndr_push_samr_TestPrivateFunctionsUser(struct ndr_push *ndr, int flags, const struct samr_TestPrivateFunctionsUser *r)
9657 {
9658         if (flags & NDR_IN) {
9659                 if (r->in.user_handle == NULL) {
9660                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9661                 }
9662                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9663         }
9664         if (flags & NDR_OUT) {
9665                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9666         }
9667         return NDR_ERR_SUCCESS;
9668 }
9669
9670 static enum ndr_err_code ndr_pull_samr_TestPrivateFunctionsUser(struct ndr_pull *ndr, int flags, struct samr_TestPrivateFunctionsUser *r)
9671 {
9672         TALLOC_CTX *_mem_save_user_handle_0;
9673         if (flags & NDR_IN) {
9674                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9675                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9676                 }
9677                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9678                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9679                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9680                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9681         }
9682         if (flags & NDR_OUT) {
9683                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9684         }
9685         return NDR_ERR_SUCCESS;
9686 }
9687
9688 _PUBLIC_ void ndr_print_samr_TestPrivateFunctionsUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_TestPrivateFunctionsUser *r)
9689 {
9690         ndr_print_struct(ndr, name, "samr_TestPrivateFunctionsUser");
9691         ndr->depth++;
9692         if (flags & NDR_SET_VALUES) {
9693                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9694         }
9695         if (flags & NDR_IN) {
9696                 ndr_print_struct(ndr, "in", "samr_TestPrivateFunctionsUser");
9697                 ndr->depth++;
9698                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9699                 ndr->depth++;
9700                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9701                 ndr->depth--;
9702                 ndr->depth--;
9703         }
9704         if (flags & NDR_OUT) {
9705                 ndr_print_struct(ndr, "out", "samr_TestPrivateFunctionsUser");
9706                 ndr->depth++;
9707                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9708                 ndr->depth--;
9709         }
9710         ndr->depth--;
9711 }
9712
9713 _PUBLIC_ enum ndr_err_code ndr_push_samr_GetUserPwInfo(struct ndr_push *ndr, int flags, const struct samr_GetUserPwInfo *r)
9714 {
9715         if (flags & NDR_IN) {
9716                 if (r->in.user_handle == NULL) {
9717                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9718                 }
9719                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9720         }
9721         if (flags & NDR_OUT) {
9722                 if (r->out.info == NULL) {
9723                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9724                 }
9725                 NDR_CHECK(ndr_push_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
9726                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9727         }
9728         return NDR_ERR_SUCCESS;
9729 }
9730
9731 _PUBLIC_ enum ndr_err_code ndr_pull_samr_GetUserPwInfo(struct ndr_pull *ndr, int flags, struct samr_GetUserPwInfo *r)
9732 {
9733         TALLOC_CTX *_mem_save_user_handle_0;
9734         TALLOC_CTX *_mem_save_info_0;
9735         if (flags & NDR_IN) {
9736                 ZERO_STRUCT(r->out);
9737
9738                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9739                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9740                 }
9741                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9742                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9743                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9744                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9745                 NDR_PULL_ALLOC(ndr, r->out.info);
9746                 ZERO_STRUCTP(r->out.info);
9747         }
9748         if (flags & NDR_OUT) {
9749                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9750                         NDR_PULL_ALLOC(ndr, r->out.info);
9751                 }
9752                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9753                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9754                 NDR_CHECK(ndr_pull_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
9755                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9756                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9757         }
9758         return NDR_ERR_SUCCESS;
9759 }
9760
9761 _PUBLIC_ void ndr_print_samr_GetUserPwInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetUserPwInfo *r)
9762 {
9763         ndr_print_struct(ndr, name, "samr_GetUserPwInfo");
9764         ndr->depth++;
9765         if (flags & NDR_SET_VALUES) {
9766                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9767         }
9768         if (flags & NDR_IN) {
9769                 ndr_print_struct(ndr, "in", "samr_GetUserPwInfo");
9770                 ndr->depth++;
9771                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9772                 ndr->depth++;
9773                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9774                 ndr->depth--;
9775                 ndr->depth--;
9776         }
9777         if (flags & NDR_OUT) {
9778                 ndr_print_struct(ndr, "out", "samr_GetUserPwInfo");
9779                 ndr->depth++;
9780                 ndr_print_ptr(ndr, "info", r->out.info);
9781                 ndr->depth++;
9782                 ndr_print_samr_PwInfo(ndr, "info", r->out.info);
9783                 ndr->depth--;
9784                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9785                 ndr->depth--;
9786         }
9787         ndr->depth--;
9788 }
9789
9790 static enum ndr_err_code ndr_push_samr_RemoveMemberFromForeignDomain(struct ndr_push *ndr, int flags, const struct samr_RemoveMemberFromForeignDomain *r)
9791 {
9792         if (flags & NDR_IN) {
9793                 if (r->in.domain_handle == NULL) {
9794                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9795                 }
9796                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9797                 if (r->in.sid == NULL) {
9798                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9799                 }
9800                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
9801         }
9802         if (flags & NDR_OUT) {
9803                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9804         }
9805         return NDR_ERR_SUCCESS;
9806 }
9807
9808 static enum ndr_err_code ndr_pull_samr_RemoveMemberFromForeignDomain(struct ndr_pull *ndr, int flags, struct samr_RemoveMemberFromForeignDomain *r)
9809 {
9810         TALLOC_CTX *_mem_save_domain_handle_0;
9811         TALLOC_CTX *_mem_save_sid_0;
9812         if (flags & NDR_IN) {
9813                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9814                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
9815                 }
9816                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9817                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
9818                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9819                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
9820                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9821                         NDR_PULL_ALLOC(ndr, r->in.sid);
9822                 }
9823                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
9824                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
9825                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
9826                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
9827         }
9828         if (flags & NDR_OUT) {
9829                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9830         }
9831         return NDR_ERR_SUCCESS;
9832 }
9833
9834 _PUBLIC_ void ndr_print_samr_RemoveMemberFromForeignDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_RemoveMemberFromForeignDomain *r)
9835 {
9836         ndr_print_struct(ndr, name, "samr_RemoveMemberFromForeignDomain");
9837         ndr->depth++;
9838         if (flags & NDR_SET_VALUES) {
9839                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9840         }
9841         if (flags & NDR_IN) {
9842                 ndr_print_struct(ndr, "in", "samr_RemoveMemberFromForeignDomain");
9843                 ndr->depth++;
9844                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
9845                 ndr->depth++;
9846                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
9847                 ndr->depth--;
9848                 ndr_print_ptr(ndr, "sid", r->in.sid);
9849                 ndr->depth++;
9850                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
9851                 ndr->depth--;
9852                 ndr->depth--;
9853         }
9854         if (flags & NDR_OUT) {
9855                 ndr_print_struct(ndr, "out", "samr_RemoveMemberFromForeignDomain");
9856                 ndr->depth++;
9857                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9858                 ndr->depth--;
9859         }
9860         ndr->depth--;
9861 }
9862
9863 static enum ndr_err_code ndr_push_samr_QueryDomainInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryDomainInfo2 *r)
9864 {
9865         if (flags & NDR_IN) {
9866                 if (r->in.domain_handle == NULL) {
9867                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9868                 }
9869                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9870                 NDR_CHECK(ndr_push_samr_DomainInfoClass(ndr, NDR_SCALARS, r->in.level));
9871         }
9872         if (flags & NDR_OUT) {
9873                 if (r->out.info == NULL) {
9874                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9875                 }
9876                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
9877                 if (*r->out.info) {
9878                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
9879                         NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9880                 }
9881                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9882         }
9883         return NDR_ERR_SUCCESS;
9884 }
9885
9886 static enum ndr_err_code ndr_pull_samr_QueryDomainInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryDomainInfo2 *r)
9887 {
9888         uint32_t _ptr_info;
9889         TALLOC_CTX *_mem_save_domain_handle_0;
9890         TALLOC_CTX *_mem_save_info_0;
9891         TALLOC_CTX *_mem_save_info_1;
9892         if (flags & NDR_IN) {
9893                 ZERO_STRUCT(r->out);
9894
9895                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9896                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
9897                 }
9898                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9899                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
9900                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9901                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
9902                 NDR_CHECK(ndr_pull_samr_DomainInfoClass(ndr, NDR_SCALARS, &r->in.level));
9903                 NDR_PULL_ALLOC(ndr, r->out.info);
9904                 ZERO_STRUCTP(r->out.info);
9905         }
9906         if (flags & NDR_OUT) {
9907                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9908                         NDR_PULL_ALLOC(ndr, r->out.info);
9909                 }
9910                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9911                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9912                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9913                 if (_ptr_info) {
9914                         NDR_PULL_ALLOC(ndr, *r->out.info);
9915                 } else {
9916                         *r->out.info = NULL;
9917                 }
9918                 if (*r->out.info) {
9919                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
9920                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
9921                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
9922                         NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9923                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
9924                 }
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_QueryDomainInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDomainInfo2 *r)
9932 {
9933         ndr_print_struct(ndr, name, "samr_QueryDomainInfo2");
9934         ndr->depth++;
9935         if (flags & NDR_SET_VALUES) {
9936                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9937         }
9938         if (flags & NDR_IN) {
9939                 ndr_print_struct(ndr, "in", "samr_QueryDomainInfo2");
9940                 ndr->depth++;
9941                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
9942                 ndr->depth++;
9943                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
9944                 ndr->depth--;
9945                 ndr_print_samr_DomainInfoClass(ndr, "level", r->in.level);
9946                 ndr->depth--;
9947         }
9948         if (flags & NDR_OUT) {
9949                 ndr_print_struct(ndr, "out", "samr_QueryDomainInfo2");
9950                 ndr->depth++;
9951                 ndr_print_ptr(ndr, "info", r->out.info);
9952                 ndr->depth++;
9953                 ndr_print_ptr(ndr, "info", *r->out.info);
9954                 ndr->depth++;
9955                 if (*r->out.info) {
9956                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
9957                         ndr_print_samr_DomainInfo(ndr, "info", *r->out.info);
9958                 }
9959                 ndr->depth--;
9960                 ndr->depth--;
9961                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9962                 ndr->depth--;
9963         }
9964         ndr->depth--;
9965 }
9966
9967 static enum ndr_err_code ndr_push_samr_QueryUserInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryUserInfo2 *r)
9968 {
9969         if (flags & NDR_IN) {
9970                 if (r->in.user_handle == NULL) {
9971                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9972                 }
9973                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9974                 NDR_CHECK(ndr_push_samr_UserInfoLevel(ndr, NDR_SCALARS, r->in.level));
9975         }
9976         if (flags & NDR_OUT) {
9977                 if (r->out.info == NULL) {
9978                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9979                 }
9980                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
9981                 if (*r->out.info) {
9982                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
9983                         NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9984                 }
9985                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9986         }
9987         return NDR_ERR_SUCCESS;
9988 }
9989
9990 static enum ndr_err_code ndr_pull_samr_QueryUserInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryUserInfo2 *r)
9991 {
9992         uint32_t _ptr_info;
9993         TALLOC_CTX *_mem_save_user_handle_0;
9994         TALLOC_CTX *_mem_save_info_0;
9995         TALLOC_CTX *_mem_save_info_1;
9996         if (flags & NDR_IN) {
9997                 ZERO_STRUCT(r->out);
9998
9999                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10000                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
10001                 }
10002                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10003                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
10004                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
10005                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
10006                 NDR_CHECK(ndr_pull_samr_UserInfoLevel(ndr, NDR_SCALARS, &r->in.level));
10007                 NDR_PULL_ALLOC(ndr, r->out.info);
10008                 ZERO_STRUCTP(r->out.info);
10009         }
10010         if (flags & NDR_OUT) {
10011                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10012                         NDR_PULL_ALLOC(ndr, r->out.info);
10013                 }
10014                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10015                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
10016                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
10017                 if (_ptr_info) {
10018                         NDR_PULL_ALLOC(ndr, *r->out.info);
10019                 } else {
10020                         *r->out.info = NULL;
10021                 }
10022                 if (*r->out.info) {
10023                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
10024                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
10025                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
10026                         NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
10027                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
10028                 }
10029                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
10030                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10031         }
10032         return NDR_ERR_SUCCESS;
10033 }
10034
10035 _PUBLIC_ void ndr_print_samr_QueryUserInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryUserInfo2 *r)
10036 {
10037         ndr_print_struct(ndr, name, "samr_QueryUserInfo2");
10038         ndr->depth++;
10039         if (flags & NDR_SET_VALUES) {
10040                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10041         }
10042         if (flags & NDR_IN) {
10043                 ndr_print_struct(ndr, "in", "samr_QueryUserInfo2");
10044                 ndr->depth++;
10045                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
10046                 ndr->depth++;
10047                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
10048                 ndr->depth--;
10049                 ndr_print_samr_UserInfoLevel(ndr, "level", r->in.level);
10050                 ndr->depth--;
10051         }
10052         if (flags & NDR_OUT) {
10053                 ndr_print_struct(ndr, "out", "samr_QueryUserInfo2");
10054                 ndr->depth++;
10055                 ndr_print_ptr(ndr, "info", r->out.info);
10056                 ndr->depth++;
10057                 ndr_print_ptr(ndr, "info", *r->out.info);
10058                 ndr->depth++;
10059                 if (*r->out.info) {
10060                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
10061                         ndr_print_samr_UserInfo(ndr, "info", *r->out.info);
10062                 }
10063                 ndr->depth--;
10064                 ndr->depth--;
10065                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10066                 ndr->depth--;
10067         }
10068         ndr->depth--;
10069 }
10070
10071 static enum ndr_err_code ndr_push_samr_QueryDisplayInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo2 *r)
10072 {
10073         if (flags & NDR_IN) {
10074                 if (r->in.domain_handle == NULL) {
10075                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10076                 }
10077                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10078                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
10079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));
10080                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));
10081                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
10082         }
10083         if (flags & NDR_OUT) {
10084                 if (r->out.total_size == NULL) {
10085                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10086                 }
10087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));
10088                 if (r->out.returned_size == NULL) {
10089                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10090                 }
10091                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));
10092                 if (r->out.info == NULL) {
10093                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10094                 }
10095                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
10096                 NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
10097                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10098         }
10099         return NDR_ERR_SUCCESS;
10100 }
10101
10102 static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo2 *r)
10103 {
10104         TALLOC_CTX *_mem_save_domain_handle_0;
10105         TALLOC_CTX *_mem_save_total_size_0;
10106         TALLOC_CTX *_mem_save_returned_size_0;
10107         TALLOC_CTX *_mem_save_info_0;
10108         if (flags & NDR_IN) {
10109                 ZERO_STRUCT(r->out);
10110
10111                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10112                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10113                 }
10114                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10115                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10116                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10117                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10118                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10119                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));
10120                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));
10121                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
10122                 NDR_PULL_ALLOC(ndr, r->out.total_size);
10123                 ZERO_STRUCTP(r->out.total_size);
10124                 NDR_PULL_ALLOC(ndr, r->out.returned_size);
10125                 ZERO_STRUCTP(r->out.returned_size);
10126                 NDR_PULL_ALLOC(ndr, r->out.info);
10127                 ZERO_STRUCTP(r->out.info);
10128         }
10129         if (flags & NDR_OUT) {
10130                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10131                         NDR_PULL_ALLOC(ndr, r->out.total_size);
10132                 }
10133                 _mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
10134                 NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);
10135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));
10136                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);
10137                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10138                         NDR_PULL_ALLOC(ndr, r->out.returned_size);
10139                 }
10140                 _mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
10141                 NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);
10142                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));
10143                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);
10144                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10145                         NDR_PULL_ALLOC(ndr, r->out.info);
10146                 }
10147                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10148                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
10149                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
10150                 NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
10151                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
10152                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10153         }
10154         return NDR_ERR_SUCCESS;
10155 }
10156
10157 _PUBLIC_ void ndr_print_samr_QueryDisplayInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo2 *r)
10158 {
10159         ndr_print_struct(ndr, name, "samr_QueryDisplayInfo2");
10160         ndr->depth++;
10161         if (flags & NDR_SET_VALUES) {
10162                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10163         }
10164         if (flags & NDR_IN) {
10165                 ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo2");
10166                 ndr->depth++;
10167                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10168                 ndr->depth++;
10169                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10170                 ndr->depth--;
10171                 ndr_print_uint16(ndr, "level", r->in.level);
10172                 ndr_print_uint32(ndr, "start_idx", r->in.start_idx);
10173                 ndr_print_uint32(ndr, "max_entries", r->in.max_entries);
10174                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
10175                 ndr->depth--;
10176         }
10177         if (flags & NDR_OUT) {
10178                 ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo2");
10179                 ndr->depth++;
10180                 ndr_print_ptr(ndr, "total_size", r->out.total_size);
10181                 ndr->depth++;
10182                 ndr_print_uint32(ndr, "total_size", *r->out.total_size);
10183                 ndr->depth--;
10184                 ndr_print_ptr(ndr, "returned_size", r->out.returned_size);
10185                 ndr->depth++;
10186                 ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);
10187                 ndr->depth--;
10188                 ndr_print_ptr(ndr, "info", r->out.info);
10189                 ndr->depth++;
10190                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
10191                 ndr_print_samr_DispInfo(ndr, "info", r->out.info);
10192                 ndr->depth--;
10193                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10194                 ndr->depth--;
10195         }
10196         ndr->depth--;
10197 }
10198
10199 static enum ndr_err_code ndr_push_samr_GetDisplayEnumerationIndex2(struct ndr_push *ndr, int flags, const struct samr_GetDisplayEnumerationIndex2 *r)
10200 {
10201         if (flags & NDR_IN) {
10202                 if (r->in.domain_handle == NULL) {
10203                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10204                 }
10205                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10206                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
10207                 if (r->in.name == NULL) {
10208                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10209                 }
10210                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
10211         }
10212         if (flags & NDR_OUT) {
10213                 if (r->out.idx == NULL) {
10214                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10215                 }
10216                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.idx));
10217                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10218         }
10219         return NDR_ERR_SUCCESS;
10220 }
10221
10222 static enum ndr_err_code ndr_pull_samr_GetDisplayEnumerationIndex2(struct ndr_pull *ndr, int flags, struct samr_GetDisplayEnumerationIndex2 *r)
10223 {
10224         TALLOC_CTX *_mem_save_domain_handle_0;
10225         TALLOC_CTX *_mem_save_name_0;
10226         TALLOC_CTX *_mem_save_idx_0;
10227         if (flags & NDR_IN) {
10228                 ZERO_STRUCT(r->out);
10229
10230                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10231                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10232                 }
10233                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10234                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10235                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10236                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10237                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10238                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10239                         NDR_PULL_ALLOC(ndr, r->in.name);
10240                 }
10241                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10242                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
10243                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
10244                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
10245                 NDR_PULL_ALLOC(ndr, r->out.idx);
10246                 ZERO_STRUCTP(r->out.idx);
10247         }
10248         if (flags & NDR_OUT) {
10249                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10250                         NDR_PULL_ALLOC(ndr, r->out.idx);
10251                 }
10252                 _mem_save_idx_0 = NDR_PULL_GET_MEM_CTX(ndr);
10253                 NDR_PULL_SET_MEM_CTX(ndr, r->out.idx, LIBNDR_FLAG_REF_ALLOC);
10254                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.idx));
10255                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_idx_0, LIBNDR_FLAG_REF_ALLOC);
10256                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10257         }
10258         return NDR_ERR_SUCCESS;
10259 }
10260
10261 _PUBLIC_ void ndr_print_samr_GetDisplayEnumerationIndex2(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDisplayEnumerationIndex2 *r)
10262 {
10263         ndr_print_struct(ndr, name, "samr_GetDisplayEnumerationIndex2");
10264         ndr->depth++;
10265         if (flags & NDR_SET_VALUES) {
10266                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10267         }
10268         if (flags & NDR_IN) {
10269                 ndr_print_struct(ndr, "in", "samr_GetDisplayEnumerationIndex2");
10270                 ndr->depth++;
10271                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10272                 ndr->depth++;
10273                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10274                 ndr->depth--;
10275                 ndr_print_uint16(ndr, "level", r->in.level);
10276                 ndr_print_ptr(ndr, "name", r->in.name);
10277                 ndr->depth++;
10278                 ndr_print_lsa_String(ndr, "name", r->in.name);
10279                 ndr->depth--;
10280                 ndr->depth--;
10281         }
10282         if (flags & NDR_OUT) {
10283                 ndr_print_struct(ndr, "out", "samr_GetDisplayEnumerationIndex2");
10284                 ndr->depth++;
10285                 ndr_print_ptr(ndr, "idx", r->out.idx);
10286                 ndr->depth++;
10287                 ndr_print_uint32(ndr, "idx", *r->out.idx);
10288                 ndr->depth--;
10289                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10290                 ndr->depth--;
10291         }
10292         ndr->depth--;
10293 }
10294
10295 static enum ndr_err_code ndr_push_samr_CreateUser2(struct ndr_push *ndr, int flags, const struct samr_CreateUser2 *r)
10296 {
10297         if (flags & NDR_IN) {
10298                 if (r->in.domain_handle == NULL) {
10299                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10300                 }
10301                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10302                 if (r->in.account_name == NULL) {
10303                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10304                 }
10305                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
10306                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->in.acct_flags));
10307                 NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
10308         }
10309         if (flags & NDR_OUT) {
10310                 if (r->out.user_handle == NULL) {
10311                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10312                 }
10313                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
10314                 if (r->out.access_granted == NULL) {
10315                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10316                 }
10317                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.access_granted));
10318                 if (r->out.rid == NULL) {
10319                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10320                 }
10321                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
10322                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10323         }
10324         return NDR_ERR_SUCCESS;
10325 }
10326
10327 static enum ndr_err_code ndr_pull_samr_CreateUser2(struct ndr_pull *ndr, int flags, struct samr_CreateUser2 *r)
10328 {
10329         TALLOC_CTX *_mem_save_domain_handle_0;
10330         TALLOC_CTX *_mem_save_account_name_0;
10331         TALLOC_CTX *_mem_save_user_handle_0;
10332         TALLOC_CTX *_mem_save_access_granted_0;
10333         TALLOC_CTX *_mem_save_rid_0;
10334         if (flags & NDR_IN) {
10335                 ZERO_STRUCT(r->out);
10336
10337                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10338                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10339                 }
10340                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10341                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10342                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10343                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10344                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10345                         NDR_PULL_ALLOC(ndr, r->in.account_name);
10346                 }
10347                 _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10348                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account_name, LIBNDR_FLAG_REF_ALLOC);
10349                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
10350                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, LIBNDR_FLAG_REF_ALLOC);
10351                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->in.acct_flags));
10352                 NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
10353                 NDR_PULL_ALLOC(ndr, r->out.user_handle);
10354                 ZERO_STRUCTP(r->out.user_handle);
10355                 NDR_PULL_ALLOC(ndr, r->out.access_granted);
10356                 ZERO_STRUCTP(r->out.access_granted);
10357                 NDR_PULL_ALLOC(ndr, r->out.rid);
10358                 ZERO_STRUCTP(r->out.rid);
10359         }
10360         if (flags & NDR_OUT) {
10361                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10362                         NDR_PULL_ALLOC(ndr, r->out.user_handle);
10363                 }
10364                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10365                 NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
10366                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
10367                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
10368                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10369                         NDR_PULL_ALLOC(ndr, r->out.access_granted);
10370                 }
10371                 _mem_save_access_granted_0 = NDR_PULL_GET_MEM_CTX(ndr);
10372                 NDR_PULL_SET_MEM_CTX(ndr, r->out.access_granted, LIBNDR_FLAG_REF_ALLOC);
10373                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.access_granted));
10374                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_access_granted_0, LIBNDR_FLAG_REF_ALLOC);
10375                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10376                         NDR_PULL_ALLOC(ndr, r->out.rid);
10377                 }
10378                 _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
10379                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
10380                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
10381                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
10382                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10383         }
10384         return NDR_ERR_SUCCESS;
10385 }
10386
10387 _PUBLIC_ void ndr_print_samr_CreateUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateUser2 *r)
10388 {
10389         ndr_print_struct(ndr, name, "samr_CreateUser2");
10390         ndr->depth++;
10391         if (flags & NDR_SET_VALUES) {
10392                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10393         }
10394         if (flags & NDR_IN) {
10395                 ndr_print_struct(ndr, "in", "samr_CreateUser2");
10396                 ndr->depth++;
10397                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10398                 ndr->depth++;
10399                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10400                 ndr->depth--;
10401                 ndr_print_ptr(ndr, "account_name", r->in.account_name);
10402                 ndr->depth++;
10403                 ndr_print_lsa_String(ndr, "account_name", r->in.account_name);
10404                 ndr->depth--;
10405                 ndr_print_samr_AcctFlags(ndr, "acct_flags", r->in.acct_flags);
10406                 ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);
10407                 ndr->depth--;
10408         }
10409         if (flags & NDR_OUT) {
10410                 ndr_print_struct(ndr, "out", "samr_CreateUser2");
10411                 ndr->depth++;
10412                 ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
10413                 ndr->depth++;
10414                 ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
10415                 ndr->depth--;
10416                 ndr_print_ptr(ndr, "access_granted", r->out.access_granted);
10417                 ndr->depth++;
10418                 ndr_print_uint32(ndr, "access_granted", *r->out.access_granted);
10419                 ndr->depth--;
10420                 ndr_print_ptr(ndr, "rid", r->out.rid);
10421                 ndr->depth++;
10422                 ndr_print_uint32(ndr, "rid", *r->out.rid);
10423                 ndr->depth--;
10424                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10425                 ndr->depth--;
10426         }
10427         ndr->depth--;
10428 }
10429
10430 static enum ndr_err_code ndr_push_samr_QueryDisplayInfo3(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo3 *r)
10431 {
10432         if (flags & NDR_IN) {
10433                 if (r->in.domain_handle == NULL) {
10434                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10435                 }
10436                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10437                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
10438                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));
10439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));
10440                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
10441         }
10442         if (flags & NDR_OUT) {
10443                 if (r->out.total_size == NULL) {
10444                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10445                 }
10446                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));
10447                 if (r->out.returned_size == NULL) {
10448                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10449                 }
10450                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));
10451                 if (r->out.info == NULL) {
10452                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10453                 }
10454                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
10455                 NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
10456                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10457         }
10458         return NDR_ERR_SUCCESS;
10459 }
10460
10461 static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo3(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo3 *r)
10462 {
10463         TALLOC_CTX *_mem_save_domain_handle_0;
10464         TALLOC_CTX *_mem_save_total_size_0;
10465         TALLOC_CTX *_mem_save_returned_size_0;
10466         TALLOC_CTX *_mem_save_info_0;
10467         if (flags & NDR_IN) {
10468                 ZERO_STRUCT(r->out);
10469
10470                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10471                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10472                 }
10473                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10474                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10475                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10476                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10477                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10478                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));
10479                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));
10480                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
10481                 NDR_PULL_ALLOC(ndr, r->out.total_size);
10482                 ZERO_STRUCTP(r->out.total_size);
10483                 NDR_PULL_ALLOC(ndr, r->out.returned_size);
10484                 ZERO_STRUCTP(r->out.returned_size);
10485                 NDR_PULL_ALLOC(ndr, r->out.info);
10486                 ZERO_STRUCTP(r->out.info);
10487         }
10488         if (flags & NDR_OUT) {
10489                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10490                         NDR_PULL_ALLOC(ndr, r->out.total_size);
10491                 }
10492                 _mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
10493                 NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);
10494                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));
10495                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);
10496                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10497                         NDR_PULL_ALLOC(ndr, r->out.returned_size);
10498                 }
10499                 _mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
10500                 NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);
10501                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));
10502                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);
10503                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10504                         NDR_PULL_ALLOC(ndr, r->out.info);
10505                 }
10506                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10507                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
10508                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
10509                 NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
10510                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
10511                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10512         }
10513         return NDR_ERR_SUCCESS;
10514 }
10515
10516 _PUBLIC_ void ndr_print_samr_QueryDisplayInfo3(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo3 *r)
10517 {
10518         ndr_print_struct(ndr, name, "samr_QueryDisplayInfo3");
10519         ndr->depth++;
10520         if (flags & NDR_SET_VALUES) {
10521                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10522         }
10523         if (flags & NDR_IN) {
10524                 ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo3");
10525                 ndr->depth++;
10526                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10527                 ndr->depth++;
10528                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10529                 ndr->depth--;
10530                 ndr_print_uint16(ndr, "level", r->in.level);
10531                 ndr_print_uint32(ndr, "start_idx", r->in.start_idx);
10532                 ndr_print_uint32(ndr, "max_entries", r->in.max_entries);
10533                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
10534                 ndr->depth--;
10535         }
10536         if (flags & NDR_OUT) {
10537                 ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo3");
10538                 ndr->depth++;
10539                 ndr_print_ptr(ndr, "total_size", r->out.total_size);
10540                 ndr->depth++;
10541                 ndr_print_uint32(ndr, "total_size", *r->out.total_size);
10542                 ndr->depth--;
10543                 ndr_print_ptr(ndr, "returned_size", r->out.returned_size);
10544                 ndr->depth++;
10545                 ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);
10546                 ndr->depth--;
10547                 ndr_print_ptr(ndr, "info", r->out.info);
10548                 ndr->depth++;
10549                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
10550                 ndr_print_samr_DispInfo(ndr, "info", r->out.info);
10551                 ndr->depth--;
10552                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10553                 ndr->depth--;
10554         }
10555         ndr->depth--;
10556 }
10557
10558 static enum ndr_err_code ndr_push_samr_AddMultipleMembersToAlias(struct ndr_push *ndr, int flags, const struct samr_AddMultipleMembersToAlias *r)
10559 {
10560         if (flags & NDR_IN) {
10561                 if (r->in.alias_handle == NULL) {
10562                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10563                 }
10564                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
10565                 if (r->in.sids == NULL) {
10566                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10567                 }
10568                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10569         }
10570         if (flags & NDR_OUT) {
10571                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10572         }
10573         return NDR_ERR_SUCCESS;
10574 }
10575
10576 static enum ndr_err_code ndr_pull_samr_AddMultipleMembersToAlias(struct ndr_pull *ndr, int flags, struct samr_AddMultipleMembersToAlias *r)
10577 {
10578         TALLOC_CTX *_mem_save_alias_handle_0;
10579         TALLOC_CTX *_mem_save_sids_0;
10580         if (flags & NDR_IN) {
10581                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10582                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
10583                 }
10584                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10585                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
10586                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
10587                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
10588                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10589                         NDR_PULL_ALLOC(ndr, r->in.sids);
10590                 }
10591                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
10592                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
10593                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10594                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
10595         }
10596         if (flags & NDR_OUT) {
10597                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10598         }
10599         return NDR_ERR_SUCCESS;
10600 }
10601
10602 _PUBLIC_ void ndr_print_samr_AddMultipleMembersToAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddMultipleMembersToAlias *r)
10603 {
10604         ndr_print_struct(ndr, name, "samr_AddMultipleMembersToAlias");
10605         ndr->depth++;
10606         if (flags & NDR_SET_VALUES) {
10607                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10608         }
10609         if (flags & NDR_IN) {
10610                 ndr_print_struct(ndr, "in", "samr_AddMultipleMembersToAlias");
10611                 ndr->depth++;
10612                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
10613                 ndr->depth++;
10614                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
10615                 ndr->depth--;
10616                 ndr_print_ptr(ndr, "sids", r->in.sids);
10617                 ndr->depth++;
10618                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
10619                 ndr->depth--;
10620                 ndr->depth--;
10621         }
10622         if (flags & NDR_OUT) {
10623                 ndr_print_struct(ndr, "out", "samr_AddMultipleMembersToAlias");
10624                 ndr->depth++;
10625                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10626                 ndr->depth--;
10627         }
10628         ndr->depth--;
10629 }
10630
10631 static enum ndr_err_code ndr_push_samr_RemoveMultipleMembersFromAlias(struct ndr_push *ndr, int flags, const struct samr_RemoveMultipleMembersFromAlias *r)
10632 {
10633         if (flags & NDR_IN) {
10634                 if (r->in.alias_handle == NULL) {
10635                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10636                 }
10637                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
10638                 if (r->in.sids == NULL) {
10639                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10640                 }
10641                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10642         }
10643         if (flags & NDR_OUT) {
10644                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10645         }
10646         return NDR_ERR_SUCCESS;
10647 }
10648
10649 static enum ndr_err_code ndr_pull_samr_RemoveMultipleMembersFromAlias(struct ndr_pull *ndr, int flags, struct samr_RemoveMultipleMembersFromAlias *r)
10650 {
10651         TALLOC_CTX *_mem_save_alias_handle_0;
10652         TALLOC_CTX *_mem_save_sids_0;
10653         if (flags & NDR_IN) {
10654                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10655                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
10656                 }
10657                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10658                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
10659                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
10660                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
10661                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10662                         NDR_PULL_ALLOC(ndr, r->in.sids);
10663                 }
10664                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
10665                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
10666                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10667                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
10668         }
10669         if (flags & NDR_OUT) {
10670                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10671         }
10672         return NDR_ERR_SUCCESS;
10673 }
10674
10675 _PUBLIC_ void ndr_print_samr_RemoveMultipleMembersFromAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_RemoveMultipleMembersFromAlias *r)
10676 {
10677         ndr_print_struct(ndr, name, "samr_RemoveMultipleMembersFromAlias");
10678         ndr->depth++;
10679         if (flags & NDR_SET_VALUES) {
10680                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10681         }
10682         if (flags & NDR_IN) {
10683                 ndr_print_struct(ndr, "in", "samr_RemoveMultipleMembersFromAlias");
10684                 ndr->depth++;
10685                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
10686                 ndr->depth++;
10687                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
10688                 ndr->depth--;
10689                 ndr_print_ptr(ndr, "sids", r->in.sids);
10690                 ndr->depth++;
10691                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
10692                 ndr->depth--;
10693                 ndr->depth--;
10694         }
10695         if (flags & NDR_OUT) {
10696                 ndr_print_struct(ndr, "out", "samr_RemoveMultipleMembersFromAlias");
10697                 ndr->depth++;
10698                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10699                 ndr->depth--;
10700         }
10701         ndr->depth--;
10702 }
10703
10704 static enum ndr_err_code ndr_push_samr_OemChangePasswordUser2(struct ndr_push *ndr, int flags, const struct samr_OemChangePasswordUser2 *r)
10705 {
10706         if (flags & NDR_IN) {
10707                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
10708                 if (r->in.server) {
10709                         NDR_CHECK(ndr_push_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
10710                 }
10711                 if (r->in.account == NULL) {
10712                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10713                 }
10714                 NDR_CHECK(ndr_push_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
10715                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
10716                 if (r->in.password) {
10717                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password));
10718                 }
10719                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hash));
10720                 if (r->in.hash) {
10721                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.hash));
10722                 }
10723         }
10724         if (flags & NDR_OUT) {
10725                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10726         }
10727         return NDR_ERR_SUCCESS;
10728 }
10729
10730 static enum ndr_err_code ndr_pull_samr_OemChangePasswordUser2(struct ndr_pull *ndr, int flags, struct samr_OemChangePasswordUser2 *r)
10731 {
10732         uint32_t _ptr_server;
10733         uint32_t _ptr_password;
10734         uint32_t _ptr_hash;
10735         TALLOC_CTX *_mem_save_server_0;
10736         TALLOC_CTX *_mem_save_account_0;
10737         TALLOC_CTX *_mem_save_password_0;
10738         TALLOC_CTX *_mem_save_hash_0;
10739         if (flags & NDR_IN) {
10740                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
10741                 if (_ptr_server) {
10742                         NDR_PULL_ALLOC(ndr, r->in.server);
10743                 } else {
10744                         r->in.server = NULL;
10745                 }
10746                 if (r->in.server) {
10747                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
10748                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
10749                         NDR_CHECK(ndr_pull_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
10750                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
10751                 }
10752                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10753                         NDR_PULL_ALLOC(ndr, r->in.account);
10754                 }
10755                 _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
10756                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);
10757                 NDR_CHECK(ndr_pull_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
10758                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);
10759                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
10760                 if (_ptr_password) {
10761                         NDR_PULL_ALLOC(ndr, r->in.password);
10762                 } else {
10763                         r->in.password = NULL;
10764                 }
10765                 if (r->in.password) {
10766                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
10767                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
10768                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password));
10769                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
10770                 }
10771                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hash));
10772                 if (_ptr_hash) {
10773                         NDR_PULL_ALLOC(ndr, r->in.hash);
10774                 } else {
10775                         r->in.hash = NULL;
10776                 }
10777                 if (r->in.hash) {
10778                         _mem_save_hash_0 = NDR_PULL_GET_MEM_CTX(ndr);
10779                         NDR_PULL_SET_MEM_CTX(ndr, r->in.hash, 0);
10780                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.hash));
10781                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hash_0, 0);
10782                 }
10783         }
10784         if (flags & NDR_OUT) {
10785                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10786         }
10787         return NDR_ERR_SUCCESS;
10788 }
10789
10790 _PUBLIC_ void ndr_print_samr_OemChangePasswordUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_OemChangePasswordUser2 *r)
10791 {
10792         ndr_print_struct(ndr, name, "samr_OemChangePasswordUser2");
10793         ndr->depth++;
10794         if (flags & NDR_SET_VALUES) {
10795                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10796         }
10797         if (flags & NDR_IN) {
10798                 ndr_print_struct(ndr, "in", "samr_OemChangePasswordUser2");
10799                 ndr->depth++;
10800                 ndr_print_ptr(ndr, "server", r->in.server);
10801                 ndr->depth++;
10802                 if (r->in.server) {
10803                         ndr_print_lsa_AsciiString(ndr, "server", r->in.server);
10804                 }
10805                 ndr->depth--;
10806                 ndr_print_ptr(ndr, "account", r->in.account);
10807                 ndr->depth++;
10808                 ndr_print_lsa_AsciiString(ndr, "account", r->in.account);
10809                 ndr->depth--;
10810                 ndr_print_ptr(ndr, "password", r->in.password);
10811                 ndr->depth++;
10812                 if (r->in.password) {
10813                         ndr_print_samr_CryptPassword(ndr, "password", r->in.password);
10814                 }
10815                 ndr->depth--;
10816                 ndr_print_ptr(ndr, "hash", r->in.hash);
10817                 ndr->depth++;
10818                 if (r->in.hash) {
10819                         ndr_print_samr_Password(ndr, "hash", r->in.hash);
10820                 }
10821                 ndr->depth--;
10822                 ndr->depth--;
10823         }
10824         if (flags & NDR_OUT) {
10825                 ndr_print_struct(ndr, "out", "samr_OemChangePasswordUser2");
10826                 ndr->depth++;
10827                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10828                 ndr->depth--;
10829         }
10830         ndr->depth--;
10831 }
10832
10833 static enum ndr_err_code ndr_push_samr_ChangePasswordUser2(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser2 *r)
10834 {
10835         if (flags & NDR_IN) {
10836                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
10837                 if (r->in.server) {
10838                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
10839                 }
10840                 if (r->in.account == NULL) {
10841                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10842                 }
10843                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
10844                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_password));
10845                 if (r->in.nt_password) {
10846                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
10847                 }
10848                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_verifier));
10849                 if (r->in.nt_verifier) {
10850                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
10851                 }
10852                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_change));
10853                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_password));
10854                 if (r->in.lm_password) {
10855                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
10856                 }
10857                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_verifier));
10858                 if (r->in.lm_verifier) {
10859                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
10860                 }
10861         }
10862         if (flags & NDR_OUT) {
10863                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10864         }
10865         return NDR_ERR_SUCCESS;
10866 }
10867
10868 static enum ndr_err_code ndr_pull_samr_ChangePasswordUser2(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser2 *r)
10869 {
10870         uint32_t _ptr_server;
10871         uint32_t _ptr_nt_password;
10872         uint32_t _ptr_nt_verifier;
10873         uint32_t _ptr_lm_password;
10874         uint32_t _ptr_lm_verifier;
10875         TALLOC_CTX *_mem_save_server_0;
10876         TALLOC_CTX *_mem_save_account_0;
10877         TALLOC_CTX *_mem_save_nt_password_0;
10878         TALLOC_CTX *_mem_save_nt_verifier_0;
10879         TALLOC_CTX *_mem_save_lm_password_0;
10880         TALLOC_CTX *_mem_save_lm_verifier_0;
10881         if (flags & NDR_IN) {
10882                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
10883                 if (_ptr_server) {
10884                         NDR_PULL_ALLOC(ndr, r->in.server);
10885                 } else {
10886                         r->in.server = NULL;
10887                 }
10888                 if (r->in.server) {
10889                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
10890                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
10891                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
10892                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
10893                 }
10894                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10895                         NDR_PULL_ALLOC(ndr, r->in.account);
10896                 }
10897                 _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
10898                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);
10899                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
10900                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);
10901                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_password));
10902                 if (_ptr_nt_password) {
10903                         NDR_PULL_ALLOC(ndr, r->in.nt_password);
10904                 } else {
10905                         r->in.nt_password = NULL;
10906                 }
10907                 if (r->in.nt_password) {
10908                         _mem_save_nt_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
10909                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_password, 0);
10910                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
10911                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_password_0, 0);
10912                 }
10913                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_verifier));
10914                 if (_ptr_nt_verifier) {
10915                         NDR_PULL_ALLOC(ndr, r->in.nt_verifier);
10916                 } else {
10917                         r->in.nt_verifier = NULL;
10918                 }
10919                 if (r->in.nt_verifier) {
10920                         _mem_save_nt_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
10921                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_verifier, 0);
10922                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
10923                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_verifier_0, 0);
10924                 }
10925                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_change));
10926                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_password));
10927                 if (_ptr_lm_password) {
10928                         NDR_PULL_ALLOC(ndr, r->in.lm_password);
10929                 } else {
10930                         r->in.lm_password = NULL;
10931                 }
10932                 if (r->in.lm_password) {
10933                         _mem_save_lm_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
10934                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_password, 0);
10935                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
10936                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_password_0, 0);
10937                 }
10938                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_verifier));
10939                 if (_ptr_lm_verifier) {
10940                         NDR_PULL_ALLOC(ndr, r->in.lm_verifier);
10941                 } else {
10942                         r->in.lm_verifier = NULL;
10943                 }
10944                 if (r->in.lm_verifier) {
10945                         _mem_save_lm_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
10946                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_verifier, 0);
10947                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
10948                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_verifier_0, 0);
10949                 }
10950         }
10951         if (flags & NDR_OUT) {
10952                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10953         }
10954         return NDR_ERR_SUCCESS;
10955 }
10956
10957 _PUBLIC_ void ndr_print_samr_ChangePasswordUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser2 *r)
10958 {
10959         ndr_print_struct(ndr, name, "samr_ChangePasswordUser2");
10960         ndr->depth++;
10961         if (flags & NDR_SET_VALUES) {
10962                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10963         }
10964         if (flags & NDR_IN) {
10965                 ndr_print_struct(ndr, "in", "samr_ChangePasswordUser2");
10966                 ndr->depth++;
10967                 ndr_print_ptr(ndr, "server", r->in.server);
10968                 ndr->depth++;
10969                 if (r->in.server) {
10970                         ndr_print_lsa_String(ndr, "server", r->in.server);
10971                 }
10972                 ndr->depth--;
10973                 ndr_print_ptr(ndr, "account", r->in.account);
10974                 ndr->depth++;
10975                 ndr_print_lsa_String(ndr, "account", r->in.account);
10976                 ndr->depth--;
10977                 ndr_print_ptr(ndr, "nt_password", r->in.nt_password);
10978                 ndr->depth++;
10979                 if (r->in.nt_password) {
10980                         ndr_print_samr_CryptPassword(ndr, "nt_password", r->in.nt_password);
10981                 }
10982                 ndr->depth--;
10983                 ndr_print_ptr(ndr, "nt_verifier", r->in.nt_verifier);
10984                 ndr->depth++;
10985                 if (r->in.nt_verifier) {
10986                         ndr_print_samr_Password(ndr, "nt_verifier", r->in.nt_verifier);
10987                 }
10988                 ndr->depth--;
10989                 ndr_print_uint8(ndr, "lm_change", r->in.lm_change);
10990                 ndr_print_ptr(ndr, "lm_password", r->in.lm_password);
10991                 ndr->depth++;
10992                 if (r->in.lm_password) {
10993                         ndr_print_samr_CryptPassword(ndr, "lm_password", r->in.lm_password);
10994                 }
10995                 ndr->depth--;
10996                 ndr_print_ptr(ndr, "lm_verifier", r->in.lm_verifier);
10997                 ndr->depth++;
10998                 if (r->in.lm_verifier) {
10999                         ndr_print_samr_Password(ndr, "lm_verifier", r->in.lm_verifier);
11000                 }
11001                 ndr->depth--;
11002                 ndr->depth--;
11003         }
11004         if (flags & NDR_OUT) {
11005                 ndr_print_struct(ndr, "out", "samr_ChangePasswordUser2");
11006                 ndr->depth++;
11007                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11008                 ndr->depth--;
11009         }
11010         ndr->depth--;
11011 }
11012
11013 static enum ndr_err_code ndr_push_samr_GetDomPwInfo(struct ndr_push *ndr, int flags, const struct samr_GetDomPwInfo *r)
11014 {
11015         if (flags & NDR_IN) {
11016                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.domain_name));
11017                 if (r->in.domain_name) {
11018                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
11019                 }
11020         }
11021         if (flags & NDR_OUT) {
11022                 if (r->out.info == NULL) {
11023                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11024                 }
11025                 NDR_CHECK(ndr_push_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
11026                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11027         }
11028         return NDR_ERR_SUCCESS;
11029 }
11030
11031 static enum ndr_err_code ndr_pull_samr_GetDomPwInfo(struct ndr_pull *ndr, int flags, struct samr_GetDomPwInfo *r)
11032 {
11033         uint32_t _ptr_domain_name;
11034         TALLOC_CTX *_mem_save_domain_name_0;
11035         TALLOC_CTX *_mem_save_info_0;
11036         if (flags & NDR_IN) {
11037                 ZERO_STRUCT(r->out);
11038
11039                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
11040                 if (_ptr_domain_name) {
11041                         NDR_PULL_ALLOC(ndr, r->in.domain_name);
11042                 } else {
11043                         r->in.domain_name = NULL;
11044                 }
11045                 if (r->in.domain_name) {
11046                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11047                         NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_name, 0);
11048                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
11049                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
11050                 }
11051                 NDR_PULL_ALLOC(ndr, r->out.info);
11052                 ZERO_STRUCTP(r->out.info);
11053         }
11054         if (flags & NDR_OUT) {
11055                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11056                         NDR_PULL_ALLOC(ndr, r->out.info);
11057                 }
11058                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
11059                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
11060                 NDR_CHECK(ndr_pull_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
11061                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
11062                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11063         }
11064         return NDR_ERR_SUCCESS;
11065 }
11066
11067 _PUBLIC_ void ndr_print_samr_GetDomPwInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDomPwInfo *r)
11068 {
11069         ndr_print_struct(ndr, name, "samr_GetDomPwInfo");
11070         ndr->depth++;
11071         if (flags & NDR_SET_VALUES) {
11072                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11073         }
11074         if (flags & NDR_IN) {
11075                 ndr_print_struct(ndr, "in", "samr_GetDomPwInfo");
11076                 ndr->depth++;
11077                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
11078                 ndr->depth++;
11079                 if (r->in.domain_name) {
11080                         ndr_print_lsa_String(ndr, "domain_name", r->in.domain_name);
11081                 }
11082                 ndr->depth--;
11083                 ndr->depth--;
11084         }
11085         if (flags & NDR_OUT) {
11086                 ndr_print_struct(ndr, "out", "samr_GetDomPwInfo");
11087                 ndr->depth++;
11088                 ndr_print_ptr(ndr, "info", r->out.info);
11089                 ndr->depth++;
11090                 ndr_print_samr_PwInfo(ndr, "info", r->out.info);
11091                 ndr->depth--;
11092                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11093                 ndr->depth--;
11094         }
11095         ndr->depth--;
11096 }
11097
11098 static enum ndr_err_code ndr_push_samr_Connect2(struct ndr_push *ndr, int flags, const struct samr_Connect2 *r)
11099 {
11100         if (flags & NDR_IN) {
11101                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
11102                 if (r->in.system_name) {
11103                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11104                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11105                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11106                         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));
11107                 }
11108                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
11109         }
11110         if (flags & NDR_OUT) {
11111                 if (r->out.connect_handle == NULL) {
11112                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11113                 }
11114                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11115                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11116         }
11117         return NDR_ERR_SUCCESS;
11118 }
11119
11120 static enum ndr_err_code ndr_pull_samr_Connect2(struct ndr_pull *ndr, int flags, struct samr_Connect2 *r)
11121 {
11122         uint32_t _ptr_system_name;
11123         TALLOC_CTX *_mem_save_system_name_0;
11124         TALLOC_CTX *_mem_save_connect_handle_0;
11125         if (flags & NDR_IN) {
11126                 ZERO_STRUCT(r->out);
11127
11128                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
11129                 if (_ptr_system_name) {
11130                         NDR_PULL_ALLOC(ndr, r->in.system_name);
11131                 } else {
11132                         r->in.system_name = NULL;
11133                 }
11134                 if (r->in.system_name) {
11135                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11136                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
11137                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
11138                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
11139                         if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
11140                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.system_name), ndr_get_array_length(ndr, &r->in.system_name));
11141                         }
11142                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
11143                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t), CH_UTF16));
11144                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
11145                 }
11146                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
11147                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11148                 ZERO_STRUCTP(r->out.connect_handle);
11149         }
11150         if (flags & NDR_OUT) {
11151                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11152                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11153                 }
11154                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11155                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
11156                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11157                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
11158                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11159         }
11160         return NDR_ERR_SUCCESS;
11161 }
11162
11163 _PUBLIC_ void ndr_print_samr_Connect2(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect2 *r)
11164 {
11165         ndr_print_struct(ndr, name, "samr_Connect2");
11166         ndr->depth++;
11167         if (flags & NDR_SET_VALUES) {
11168                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11169         }
11170         if (flags & NDR_IN) {
11171                 ndr_print_struct(ndr, "in", "samr_Connect2");
11172                 ndr->depth++;
11173                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
11174                 ndr->depth++;
11175                 if (r->in.system_name) {
11176                         ndr_print_string(ndr, "system_name", r->in.system_name);
11177                 }
11178                 ndr->depth--;
11179                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
11180                 ndr->depth--;
11181         }
11182         if (flags & NDR_OUT) {
11183                 ndr_print_struct(ndr, "out", "samr_Connect2");
11184                 ndr->depth++;
11185                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
11186                 ndr->depth++;
11187                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
11188                 ndr->depth--;
11189                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11190                 ndr->depth--;
11191         }
11192         ndr->depth--;
11193 }
11194
11195 _PUBLIC_ enum ndr_err_code ndr_push_samr_SetUserInfo2(struct ndr_push *ndr, int flags, const struct samr_SetUserInfo2 *r)
11196 {
11197         if (flags & NDR_IN) {
11198                 if (r->in.user_handle == NULL) {
11199                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11200                 }
11201                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
11202                 NDR_CHECK(ndr_push_samr_UserInfoLevel(ndr, NDR_SCALARS, r->in.level));
11203                 if (r->in.info == NULL) {
11204                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11205                 }
11206                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
11207                 NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
11208         }
11209         if (flags & NDR_OUT) {
11210                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11211         }
11212         return NDR_ERR_SUCCESS;
11213 }
11214
11215 _PUBLIC_ enum ndr_err_code ndr_pull_samr_SetUserInfo2(struct ndr_pull *ndr, int flags, struct samr_SetUserInfo2 *r)
11216 {
11217         TALLOC_CTX *_mem_save_user_handle_0;
11218         TALLOC_CTX *_mem_save_info_0;
11219         if (flags & NDR_IN) {
11220                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11221                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
11222                 }
11223                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11224                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
11225                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
11226                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
11227                 NDR_CHECK(ndr_pull_samr_UserInfoLevel(ndr, NDR_SCALARS, &r->in.level));
11228                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11229                         NDR_PULL_ALLOC(ndr, r->in.info);
11230                 }
11231                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
11232                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
11233                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
11234                 NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
11235                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
11236         }
11237         if (flags & NDR_OUT) {
11238                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11239         }
11240         return NDR_ERR_SUCCESS;
11241 }
11242
11243 _PUBLIC_ void ndr_print_samr_SetUserInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetUserInfo2 *r)
11244 {
11245         ndr_print_struct(ndr, name, "samr_SetUserInfo2");
11246         ndr->depth++;
11247         if (flags & NDR_SET_VALUES) {
11248                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11249         }
11250         if (flags & NDR_IN) {
11251                 ndr_print_struct(ndr, "in", "samr_SetUserInfo2");
11252                 ndr->depth++;
11253                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
11254                 ndr->depth++;
11255                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
11256                 ndr->depth--;
11257                 ndr_print_samr_UserInfoLevel(ndr, "level", r->in.level);
11258                 ndr_print_ptr(ndr, "info", r->in.info);
11259                 ndr->depth++;
11260                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
11261                 ndr_print_samr_UserInfo(ndr, "info", r->in.info);
11262                 ndr->depth--;
11263                 ndr->depth--;
11264         }
11265         if (flags & NDR_OUT) {
11266                 ndr_print_struct(ndr, "out", "samr_SetUserInfo2");
11267                 ndr->depth++;
11268                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11269                 ndr->depth--;
11270         }
11271         ndr->depth--;
11272 }
11273
11274 static enum ndr_err_code ndr_push_samr_SetBootKeyInformation(struct ndr_push *ndr, int flags, const struct samr_SetBootKeyInformation *r)
11275 {
11276         if (flags & NDR_IN) {
11277                 if (r->in.connect_handle == NULL) {
11278                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11279                 }
11280                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
11281                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
11282                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
11283                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown3));
11284         }
11285         if (flags & NDR_OUT) {
11286                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11287         }
11288         return NDR_ERR_SUCCESS;
11289 }
11290
11291 static enum ndr_err_code ndr_pull_samr_SetBootKeyInformation(struct ndr_pull *ndr, int flags, struct samr_SetBootKeyInformation *r)
11292 {
11293         TALLOC_CTX *_mem_save_connect_handle_0;
11294         if (flags & NDR_IN) {
11295                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11296                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
11297                 }
11298                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11299                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
11300                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
11301                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
11302                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
11303                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
11304                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown3));
11305         }
11306         if (flags & NDR_OUT) {
11307                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11308         }
11309         return NDR_ERR_SUCCESS;
11310 }
11311
11312 _PUBLIC_ void ndr_print_samr_SetBootKeyInformation(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetBootKeyInformation *r)
11313 {
11314         ndr_print_struct(ndr, name, "samr_SetBootKeyInformation");
11315         ndr->depth++;
11316         if (flags & NDR_SET_VALUES) {
11317                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11318         }
11319         if (flags & NDR_IN) {
11320                 ndr_print_struct(ndr, "in", "samr_SetBootKeyInformation");
11321                 ndr->depth++;
11322                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
11323                 ndr->depth++;
11324                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
11325                 ndr->depth--;
11326                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
11327                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
11328                 ndr_print_uint32(ndr, "unknown3", r->in.unknown3);
11329                 ndr->depth--;
11330         }
11331         if (flags & NDR_OUT) {
11332                 ndr_print_struct(ndr, "out", "samr_SetBootKeyInformation");
11333                 ndr->depth++;
11334                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11335                 ndr->depth--;
11336         }
11337         ndr->depth--;
11338 }
11339
11340 static enum ndr_err_code ndr_push_samr_GetBootKeyInformation(struct ndr_push *ndr, int flags, const struct samr_GetBootKeyInformation *r)
11341 {
11342         if (flags & NDR_IN) {
11343                 if (r->in.domain_handle == NULL) {
11344                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11345                 }
11346                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
11347         }
11348         if (flags & NDR_OUT) {
11349                 if (r->out.unknown == NULL) {
11350                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11351                 }
11352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.unknown));
11353                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11354         }
11355         return NDR_ERR_SUCCESS;
11356 }
11357
11358 static enum ndr_err_code ndr_pull_samr_GetBootKeyInformation(struct ndr_pull *ndr, int flags, struct samr_GetBootKeyInformation *r)
11359 {
11360         TALLOC_CTX *_mem_save_domain_handle_0;
11361         TALLOC_CTX *_mem_save_unknown_0;
11362         if (flags & NDR_IN) {
11363                 ZERO_STRUCT(r->out);
11364
11365                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11366                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
11367                 }
11368                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11369                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
11370                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
11371                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
11372                 NDR_PULL_ALLOC(ndr, r->out.unknown);
11373                 ZERO_STRUCTP(r->out.unknown);
11374         }
11375         if (flags & NDR_OUT) {
11376                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11377                         NDR_PULL_ALLOC(ndr, r->out.unknown);
11378                 }
11379                 _mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);
11380                 NDR_PULL_SET_MEM_CTX(ndr, r->out.unknown, LIBNDR_FLAG_REF_ALLOC);
11381                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.unknown));
11382                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, LIBNDR_FLAG_REF_ALLOC);
11383                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11384         }
11385         return NDR_ERR_SUCCESS;
11386 }
11387
11388 _PUBLIC_ void ndr_print_samr_GetBootKeyInformation(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetBootKeyInformation *r)
11389 {
11390         ndr_print_struct(ndr, name, "samr_GetBootKeyInformation");
11391         ndr->depth++;
11392         if (flags & NDR_SET_VALUES) {
11393                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11394         }
11395         if (flags & NDR_IN) {
11396                 ndr_print_struct(ndr, "in", "samr_GetBootKeyInformation");
11397                 ndr->depth++;
11398                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
11399                 ndr->depth++;
11400                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
11401                 ndr->depth--;
11402                 ndr->depth--;
11403         }
11404         if (flags & NDR_OUT) {
11405                 ndr_print_struct(ndr, "out", "samr_GetBootKeyInformation");
11406                 ndr->depth++;
11407                 ndr_print_ptr(ndr, "unknown", r->out.unknown);
11408                 ndr->depth++;
11409                 ndr_print_uint32(ndr, "unknown", *r->out.unknown);
11410                 ndr->depth--;
11411                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11412                 ndr->depth--;
11413         }
11414         ndr->depth--;
11415 }
11416
11417 static enum ndr_err_code ndr_push_samr_Connect3(struct ndr_push *ndr, int flags, const struct samr_Connect3 *r)
11418 {
11419         if (flags & NDR_IN) {
11420                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
11421                 if (r->in.system_name) {
11422                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11423                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11424                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11425                         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));
11426                 }
11427                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
11428                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
11429         }
11430         if (flags & NDR_OUT) {
11431                 if (r->out.connect_handle == NULL) {
11432                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11433                 }
11434                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11435                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11436         }
11437         return NDR_ERR_SUCCESS;
11438 }
11439
11440 static enum ndr_err_code ndr_pull_samr_Connect3(struct ndr_pull *ndr, int flags, struct samr_Connect3 *r)
11441 {
11442         uint32_t _ptr_system_name;
11443         TALLOC_CTX *_mem_save_system_name_0;
11444         TALLOC_CTX *_mem_save_connect_handle_0;
11445         if (flags & NDR_IN) {
11446                 ZERO_STRUCT(r->out);
11447
11448                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
11449                 if (_ptr_system_name) {
11450                         NDR_PULL_ALLOC(ndr, r->in.system_name);
11451                 } else {
11452                         r->in.system_name = NULL;
11453                 }
11454                 if (r->in.system_name) {
11455                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11456                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
11457                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
11458                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
11459                         if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
11460                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.system_name), ndr_get_array_length(ndr, &r->in.system_name));
11461                         }
11462                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
11463                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t), CH_UTF16));
11464                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
11465                 }
11466                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
11467                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
11468                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11469                 ZERO_STRUCTP(r->out.connect_handle);
11470         }
11471         if (flags & NDR_OUT) {
11472                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11473                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11474                 }
11475                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11476                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
11477                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11478                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
11479                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11480         }
11481         return NDR_ERR_SUCCESS;
11482 }
11483
11484 _PUBLIC_ void ndr_print_samr_Connect3(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect3 *r)
11485 {
11486         ndr_print_struct(ndr, name, "samr_Connect3");
11487         ndr->depth++;
11488         if (flags & NDR_SET_VALUES) {
11489                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11490         }
11491         if (flags & NDR_IN) {
11492                 ndr_print_struct(ndr, "in", "samr_Connect3");
11493                 ndr->depth++;
11494                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
11495                 ndr->depth++;
11496                 if (r->in.system_name) {
11497                         ndr_print_string(ndr, "system_name", r->in.system_name);
11498                 }
11499                 ndr->depth--;
11500                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
11501                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
11502                 ndr->depth--;
11503         }
11504         if (flags & NDR_OUT) {
11505                 ndr_print_struct(ndr, "out", "samr_Connect3");
11506                 ndr->depth++;
11507                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
11508                 ndr->depth++;
11509                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
11510                 ndr->depth--;
11511                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11512                 ndr->depth--;
11513         }
11514         ndr->depth--;
11515 }
11516
11517 static enum ndr_err_code ndr_push_samr_Connect4(struct ndr_push *ndr, int flags, const struct samr_Connect4 *r)
11518 {
11519         if (flags & NDR_IN) {
11520                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
11521                 if (r->in.system_name) {
11522                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11523                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11524                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11525                         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));
11526                 }
11527                 NDR_CHECK(ndr_push_samr_ConnectVersion(ndr, NDR_SCALARS, r->in.client_version));
11528                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
11529         }
11530         if (flags & NDR_OUT) {
11531                 if (r->out.connect_handle == NULL) {
11532                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11533                 }
11534                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11535                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11536         }
11537         return NDR_ERR_SUCCESS;
11538 }
11539
11540 static enum ndr_err_code ndr_pull_samr_Connect4(struct ndr_pull *ndr, int flags, struct samr_Connect4 *r)
11541 {
11542         uint32_t _ptr_system_name;
11543         TALLOC_CTX *_mem_save_system_name_0;
11544         TALLOC_CTX *_mem_save_connect_handle_0;
11545         if (flags & NDR_IN) {
11546                 ZERO_STRUCT(r->out);
11547
11548                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
11549                 if (_ptr_system_name) {
11550                         NDR_PULL_ALLOC(ndr, r->in.system_name);
11551                 } else {
11552                         r->in.system_name = NULL;
11553                 }
11554                 if (r->in.system_name) {
11555                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11556                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
11557                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
11558                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
11559                         if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
11560                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.system_name), ndr_get_array_length(ndr, &r->in.system_name));
11561                         }
11562                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
11563                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t), CH_UTF16));
11564                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
11565                 }
11566                 NDR_CHECK(ndr_pull_samr_ConnectVersion(ndr, NDR_SCALARS, &r->in.client_version));
11567                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
11568                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11569                 ZERO_STRUCTP(r->out.connect_handle);
11570         }
11571         if (flags & NDR_OUT) {
11572                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11573                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11574                 }
11575                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11576                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
11577                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11578                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
11579                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11580         }
11581         return NDR_ERR_SUCCESS;
11582 }
11583
11584 _PUBLIC_ void ndr_print_samr_Connect4(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect4 *r)
11585 {
11586         ndr_print_struct(ndr, name, "samr_Connect4");
11587         ndr->depth++;
11588         if (flags & NDR_SET_VALUES) {
11589                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11590         }
11591         if (flags & NDR_IN) {
11592                 ndr_print_struct(ndr, "in", "samr_Connect4");
11593                 ndr->depth++;
11594                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
11595                 ndr->depth++;
11596                 if (r->in.system_name) {
11597                         ndr_print_string(ndr, "system_name", r->in.system_name);
11598                 }
11599                 ndr->depth--;
11600                 ndr_print_samr_ConnectVersion(ndr, "client_version", r->in.client_version);
11601                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
11602                 ndr->depth--;
11603         }
11604         if (flags & NDR_OUT) {
11605                 ndr_print_struct(ndr, "out", "samr_Connect4");
11606                 ndr->depth++;
11607                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
11608                 ndr->depth++;
11609                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
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_ChangePasswordUser3(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser3 *r)
11618 {
11619         if (flags & NDR_IN) {
11620                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
11621                 if (r->in.server) {
11622                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
11623                 }
11624                 if (r->in.account == NULL) {
11625                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11626                 }
11627                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
11628                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_password));
11629                 if (r->in.nt_password) {
11630                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
11631                 }
11632                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_verifier));
11633                 if (r->in.nt_verifier) {
11634                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
11635                 }
11636                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_change));
11637                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_password));
11638                 if (r->in.lm_password) {
11639                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
11640                 }
11641                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_verifier));
11642                 if (r->in.lm_verifier) {
11643                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
11644                 }
11645                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password3));
11646                 if (r->in.password3) {
11647                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password3));
11648                 }
11649         }
11650         if (flags & NDR_OUT) {
11651                 if (r->out.dominfo == NULL) {
11652                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11653                 }
11654                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.dominfo));
11655                 if (*r->out.dominfo) {
11656                         NDR_CHECK(ndr_push_samr_DomInfo1(ndr, NDR_SCALARS, *r->out.dominfo));
11657                 }
11658                 if (r->out.reject == NULL) {
11659                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11660                 }
11661                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.reject));
11662                 if (*r->out.reject) {
11663                         NDR_CHECK(ndr_push_samr_ChangeReject(ndr, NDR_SCALARS, *r->out.reject));
11664                 }
11665                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11666         }
11667         return NDR_ERR_SUCCESS;
11668 }
11669
11670 static enum ndr_err_code ndr_pull_samr_ChangePasswordUser3(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser3 *r)
11671 {
11672         uint32_t _ptr_server;
11673         uint32_t _ptr_nt_password;
11674         uint32_t _ptr_nt_verifier;
11675         uint32_t _ptr_lm_password;
11676         uint32_t _ptr_lm_verifier;
11677         uint32_t _ptr_password3;
11678         uint32_t _ptr_dominfo;
11679         uint32_t _ptr_reject;
11680         TALLOC_CTX *_mem_save_server_0;
11681         TALLOC_CTX *_mem_save_account_0;
11682         TALLOC_CTX *_mem_save_nt_password_0;
11683         TALLOC_CTX *_mem_save_nt_verifier_0;
11684         TALLOC_CTX *_mem_save_lm_password_0;
11685         TALLOC_CTX *_mem_save_lm_verifier_0;
11686         TALLOC_CTX *_mem_save_password3_0;
11687         TALLOC_CTX *_mem_save_dominfo_0;
11688         TALLOC_CTX *_mem_save_dominfo_1;
11689         TALLOC_CTX *_mem_save_reject_0;
11690         TALLOC_CTX *_mem_save_reject_1;
11691         if (flags & NDR_IN) {
11692                 ZERO_STRUCT(r->out);
11693
11694                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
11695                 if (_ptr_server) {
11696                         NDR_PULL_ALLOC(ndr, r->in.server);
11697                 } else {
11698                         r->in.server = NULL;
11699                 }
11700                 if (r->in.server) {
11701                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
11702                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
11703                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
11704                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
11705                 }
11706                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11707                         NDR_PULL_ALLOC(ndr, r->in.account);
11708                 }
11709                 _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
11710                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);
11711                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
11712                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);
11713                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_password));
11714                 if (_ptr_nt_password) {
11715                         NDR_PULL_ALLOC(ndr, r->in.nt_password);
11716                 } else {
11717                         r->in.nt_password = NULL;
11718                 }
11719                 if (r->in.nt_password) {
11720                         _mem_save_nt_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
11721                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_password, 0);
11722                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
11723                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_password_0, 0);
11724                 }
11725                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_verifier));
11726                 if (_ptr_nt_verifier) {
11727                         NDR_PULL_ALLOC(ndr, r->in.nt_verifier);
11728                 } else {
11729                         r->in.nt_verifier = NULL;
11730                 }
11731                 if (r->in.nt_verifier) {
11732                         _mem_save_nt_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
11733                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_verifier, 0);
11734                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
11735                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_verifier_0, 0);
11736                 }
11737                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_change));
11738                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_password));
11739                 if (_ptr_lm_password) {
11740                         NDR_PULL_ALLOC(ndr, r->in.lm_password);
11741                 } else {
11742                         r->in.lm_password = NULL;
11743                 }
11744                 if (r->in.lm_password) {
11745                         _mem_save_lm_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
11746                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_password, 0);
11747                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
11748                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_password_0, 0);
11749                 }
11750                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_verifier));
11751                 if (_ptr_lm_verifier) {
11752                         NDR_PULL_ALLOC(ndr, r->in.lm_verifier);
11753                 } else {
11754                         r->in.lm_verifier = NULL;
11755                 }
11756                 if (r->in.lm_verifier) {
11757                         _mem_save_lm_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
11758                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_verifier, 0);
11759                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
11760                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_verifier_0, 0);
11761                 }
11762                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password3));
11763                 if (_ptr_password3) {
11764                         NDR_PULL_ALLOC(ndr, r->in.password3);
11765                 } else {
11766                         r->in.password3 = NULL;
11767                 }
11768                 if (r->in.password3) {
11769                         _mem_save_password3_0 = NDR_PULL_GET_MEM_CTX(ndr);
11770                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password3, 0);
11771                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password3));
11772                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password3_0, 0);
11773                 }
11774                 NDR_PULL_ALLOC(ndr, r->out.dominfo);
11775                 ZERO_STRUCTP(r->out.dominfo);
11776                 NDR_PULL_ALLOC(ndr, r->out.reject);
11777                 ZERO_STRUCTP(r->out.reject);
11778         }
11779         if (flags & NDR_OUT) {
11780                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11781                         NDR_PULL_ALLOC(ndr, r->out.dominfo);
11782                 }
11783                 _mem_save_dominfo_0 = NDR_PULL_GET_MEM_CTX(ndr);
11784                 NDR_PULL_SET_MEM_CTX(ndr, r->out.dominfo, LIBNDR_FLAG_REF_ALLOC);
11785                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dominfo));
11786                 if (_ptr_dominfo) {
11787                         NDR_PULL_ALLOC(ndr, *r->out.dominfo);
11788                 } else {
11789                         *r->out.dominfo = NULL;
11790                 }
11791                 if (*r->out.dominfo) {
11792                         _mem_save_dominfo_1 = NDR_PULL_GET_MEM_CTX(ndr);
11793                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.dominfo, 0);
11794                         NDR_CHECK(ndr_pull_samr_DomInfo1(ndr, NDR_SCALARS, *r->out.dominfo));
11795                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dominfo_1, 0);
11796                 }
11797                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dominfo_0, LIBNDR_FLAG_REF_ALLOC);
11798                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11799                         NDR_PULL_ALLOC(ndr, r->out.reject);
11800                 }
11801                 _mem_save_reject_0 = NDR_PULL_GET_MEM_CTX(ndr);
11802                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reject, LIBNDR_FLAG_REF_ALLOC);
11803                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_reject));
11804                 if (_ptr_reject) {
11805                         NDR_PULL_ALLOC(ndr, *r->out.reject);
11806                 } else {
11807                         *r->out.reject = NULL;
11808                 }
11809                 if (*r->out.reject) {
11810                         _mem_save_reject_1 = NDR_PULL_GET_MEM_CTX(ndr);
11811                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.reject, 0);
11812                         NDR_CHECK(ndr_pull_samr_ChangeReject(ndr, NDR_SCALARS, *r->out.reject));
11813                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reject_1, 0);
11814                 }
11815                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reject_0, LIBNDR_FLAG_REF_ALLOC);
11816                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11817         }
11818         return NDR_ERR_SUCCESS;
11819 }
11820
11821 _PUBLIC_ void ndr_print_samr_ChangePasswordUser3(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser3 *r)
11822 {
11823         ndr_print_struct(ndr, name, "samr_ChangePasswordUser3");
11824         ndr->depth++;
11825         if (flags & NDR_SET_VALUES) {
11826                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11827         }
11828         if (flags & NDR_IN) {
11829                 ndr_print_struct(ndr, "in", "samr_ChangePasswordUser3");
11830                 ndr->depth++;
11831                 ndr_print_ptr(ndr, "server", r->in.server);
11832                 ndr->depth++;
11833                 if (r->in.server) {
11834                         ndr_print_lsa_String(ndr, "server", r->in.server);
11835                 }
11836                 ndr->depth--;
11837                 ndr_print_ptr(ndr, "account", r->in.account);
11838                 ndr->depth++;
11839                 ndr_print_lsa_String(ndr, "account", r->in.account);
11840                 ndr->depth--;
11841                 ndr_print_ptr(ndr, "nt_password", r->in.nt_password);
11842                 ndr->depth++;
11843                 if (r->in.nt_password) {
11844                         ndr_print_samr_CryptPassword(ndr, "nt_password", r->in.nt_password);
11845                 }
11846                 ndr->depth--;
11847                 ndr_print_ptr(ndr, "nt_verifier", r->in.nt_verifier);
11848                 ndr->depth++;
11849                 if (r->in.nt_verifier) {
11850                         ndr_print_samr_Password(ndr, "nt_verifier", r->in.nt_verifier);
11851                 }
11852                 ndr->depth--;
11853                 ndr_print_uint8(ndr, "lm_change", r->in.lm_change);
11854                 ndr_print_ptr(ndr, "lm_password", r->in.lm_password);
11855                 ndr->depth++;
11856                 if (r->in.lm_password) {
11857                         ndr_print_samr_CryptPassword(ndr, "lm_password", r->in.lm_password);
11858                 }
11859                 ndr->depth--;
11860                 ndr_print_ptr(ndr, "lm_verifier", r->in.lm_verifier);
11861                 ndr->depth++;
11862                 if (r->in.lm_verifier) {
11863                         ndr_print_samr_Password(ndr, "lm_verifier", r->in.lm_verifier);
11864                 }
11865                 ndr->depth--;
11866                 ndr_print_ptr(ndr, "password3", r->in.password3);
11867                 ndr->depth++;
11868                 if (r->in.password3) {
11869                         ndr_print_samr_CryptPassword(ndr, "password3", r->in.password3);
11870                 }
11871                 ndr->depth--;
11872                 ndr->depth--;
11873         }
11874         if (flags & NDR_OUT) {
11875                 ndr_print_struct(ndr, "out", "samr_ChangePasswordUser3");
11876                 ndr->depth++;
11877                 ndr_print_ptr(ndr, "dominfo", r->out.dominfo);
11878                 ndr->depth++;
11879                 ndr_print_ptr(ndr, "dominfo", *r->out.dominfo);
11880                 ndr->depth++;
11881                 if (*r->out.dominfo) {
11882                         ndr_print_samr_DomInfo1(ndr, "dominfo", *r->out.dominfo);
11883                 }
11884                 ndr->depth--;
11885                 ndr->depth--;
11886                 ndr_print_ptr(ndr, "reject", r->out.reject);
11887                 ndr->depth++;
11888                 ndr_print_ptr(ndr, "reject", *r->out.reject);
11889                 ndr->depth++;
11890                 if (*r->out.reject) {
11891                         ndr_print_samr_ChangeReject(ndr, "reject", *r->out.reject);
11892                 }
11893                 ndr->depth--;
11894                 ndr->depth--;
11895                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11896                 ndr->depth--;
11897         }
11898         ndr->depth--;
11899 }
11900
11901 _PUBLIC_ enum ndr_err_code ndr_push_samr_Connect5(struct ndr_push *ndr, int flags, const struct samr_Connect5 *r)
11902 {
11903         if (flags & NDR_IN) {
11904                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
11905                 if (r->in.system_name) {
11906                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11907                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11908                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11909                         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));
11910                 }
11911                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
11912                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level_in));
11913                 if (r->in.info_in == NULL) {
11914                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11915                 }
11916                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info_in, r->in.level_in));
11917                 NDR_CHECK(ndr_push_samr_ConnectInfo(ndr, NDR_SCALARS, r->in.info_in));
11918         }
11919         if (flags & NDR_OUT) {
11920                 if (r->out.level_out == NULL) {
11921                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11922                 }
11923                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
11924                 if (r->out.info_out == NULL) {
11925                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11926                 }
11927                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info_out, *r->out.level_out));
11928                 NDR_CHECK(ndr_push_samr_ConnectInfo(ndr, NDR_SCALARS, r->out.info_out));
11929                 if (r->out.connect_handle == NULL) {
11930                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11931                 }
11932                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11933                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11934         }
11935         return NDR_ERR_SUCCESS;
11936 }
11937
11938 _PUBLIC_ enum ndr_err_code ndr_pull_samr_Connect5(struct ndr_pull *ndr, int flags, struct samr_Connect5 *r)
11939 {
11940         uint32_t _ptr_system_name;
11941         TALLOC_CTX *_mem_save_system_name_0;
11942         TALLOC_CTX *_mem_save_info_in_0;
11943         TALLOC_CTX *_mem_save_level_out_0;
11944         TALLOC_CTX *_mem_save_info_out_0;
11945         TALLOC_CTX *_mem_save_connect_handle_0;
11946         if (flags & NDR_IN) {
11947                 ZERO_STRUCT(r->out);
11948
11949                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
11950                 if (_ptr_system_name) {
11951                         NDR_PULL_ALLOC(ndr, r->in.system_name);
11952                 } else {
11953                         r->in.system_name = NULL;
11954                 }
11955                 if (r->in.system_name) {
11956                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11957                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
11958                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
11959                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
11960                         if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
11961                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.system_name), ndr_get_array_length(ndr, &r->in.system_name));
11962                         }
11963                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
11964                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t), CH_UTF16));
11965                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
11966                 }
11967                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
11968                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level_in));
11969                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11970                         NDR_PULL_ALLOC(ndr, r->in.info_in);
11971                 }
11972                 _mem_save_info_in_0 = NDR_PULL_GET_MEM_CTX(ndr);
11973                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_in, LIBNDR_FLAG_REF_ALLOC);
11974                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info_in, r->in.level_in));
11975                 NDR_CHECK(ndr_pull_samr_ConnectInfo(ndr, NDR_SCALARS, r->in.info_in));
11976                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_in_0, LIBNDR_FLAG_REF_ALLOC);
11977                 NDR_PULL_ALLOC(ndr, r->out.level_out);
11978                 ZERO_STRUCTP(r->out.level_out);
11979                 NDR_PULL_ALLOC(ndr, r->out.info_out);
11980                 ZERO_STRUCTP(r->out.info_out);
11981                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11982                 ZERO_STRUCTP(r->out.connect_handle);
11983         }
11984         if (flags & NDR_OUT) {
11985                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11986                         NDR_PULL_ALLOC(ndr, r->out.level_out);
11987                 }
11988                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
11989                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
11990                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
11991                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
11992                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11993                         NDR_PULL_ALLOC(ndr, r->out.info_out);
11994                 }
11995                 _mem_save_info_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
11996                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_out, LIBNDR_FLAG_REF_ALLOC);
11997                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info_out, *r->out.level_out));
11998                 NDR_CHECK(ndr_pull_samr_ConnectInfo(ndr, NDR_SCALARS, r->out.info_out));
11999                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_out_0, LIBNDR_FLAG_REF_ALLOC);
12000                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12001                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
12002                 }
12003                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12004                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
12005                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
12006                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
12007                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12008         }
12009         return NDR_ERR_SUCCESS;
12010 }
12011
12012 _PUBLIC_ void ndr_print_samr_Connect5(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect5 *r)
12013 {
12014         ndr_print_struct(ndr, name, "samr_Connect5");
12015         ndr->depth++;
12016         if (flags & NDR_SET_VALUES) {
12017                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12018         }
12019         if (flags & NDR_IN) {
12020                 ndr_print_struct(ndr, "in", "samr_Connect5");
12021                 ndr->depth++;
12022                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
12023                 ndr->depth++;
12024                 if (r->in.system_name) {
12025                         ndr_print_string(ndr, "system_name", r->in.system_name);
12026                 }
12027                 ndr->depth--;
12028                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
12029                 ndr_print_uint32(ndr, "level_in", r->in.level_in);
12030                 ndr_print_ptr(ndr, "info_in", r->in.info_in);
12031                 ndr->depth++;
12032                 ndr_print_set_switch_value(ndr, r->in.info_in, r->in.level_in);
12033                 ndr_print_samr_ConnectInfo(ndr, "info_in", r->in.info_in);
12034                 ndr->depth--;
12035                 ndr->depth--;
12036         }
12037         if (flags & NDR_OUT) {
12038                 ndr_print_struct(ndr, "out", "samr_Connect5");
12039                 ndr->depth++;
12040                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
12041                 ndr->depth++;
12042                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
12043                 ndr->depth--;
12044                 ndr_print_ptr(ndr, "info_out", r->out.info_out);
12045                 ndr->depth++;
12046                 ndr_print_set_switch_value(ndr, r->out.info_out, *r->out.level_out);
12047                 ndr_print_samr_ConnectInfo(ndr, "info_out", r->out.info_out);
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_RidToSid(struct ndr_push *ndr, int flags, const struct samr_RidToSid *r)
12060 {
12061         if (flags & NDR_IN) {
12062                 if (r->in.domain_handle == NULL) {
12063                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12064                 }
12065                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
12066                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
12067         }
12068         if (flags & NDR_OUT) {
12069                 if (r->out.sid == NULL) {
12070                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12071                 }
12072                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sid));
12073                 if (*r->out.sid) {
12074                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
12075                 }
12076                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12077         }
12078         return NDR_ERR_SUCCESS;
12079 }
12080
12081 static enum ndr_err_code ndr_pull_samr_RidToSid(struct ndr_pull *ndr, int flags, struct samr_RidToSid *r)
12082 {
12083         uint32_t _ptr_sid;
12084         TALLOC_CTX *_mem_save_domain_handle_0;
12085         TALLOC_CTX *_mem_save_sid_0;
12086         TALLOC_CTX *_mem_save_sid_1;
12087         if (flags & NDR_IN) {
12088                 ZERO_STRUCT(r->out);
12089
12090                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12091                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
12092                 }
12093                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12094                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
12095                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
12096                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
12097                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
12098                 NDR_PULL_ALLOC(ndr, r->out.sid);
12099                 ZERO_STRUCTP(r->out.sid);
12100         }
12101         if (flags & NDR_OUT) {
12102                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12103                         NDR_PULL_ALLOC(ndr, r->out.sid);
12104                 }
12105                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
12106                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);
12107                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
12108                 if (_ptr_sid) {
12109                         NDR_PULL_ALLOC(ndr, *r->out.sid);
12110                 } else {
12111                         *r->out.sid = NULL;
12112                 }
12113                 if (*r->out.sid) {
12114                         _mem_save_sid_1 = NDR_PULL_GET_MEM_CTX(ndr);
12115                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sid, 0);
12116                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
12117                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_1, 0);
12118                 }
12119                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
12120                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12121         }
12122         return NDR_ERR_SUCCESS;
12123 }
12124
12125 _PUBLIC_ void ndr_print_samr_RidToSid(struct ndr_print *ndr, const char *name, int flags, const struct samr_RidToSid *r)
12126 {
12127         ndr_print_struct(ndr, name, "samr_RidToSid");
12128         ndr->depth++;
12129         if (flags & NDR_SET_VALUES) {
12130                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12131         }
12132         if (flags & NDR_IN) {
12133                 ndr_print_struct(ndr, "in", "samr_RidToSid");
12134                 ndr->depth++;
12135                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
12136                 ndr->depth++;
12137                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
12138                 ndr->depth--;
12139                 ndr_print_uint32(ndr, "rid", r->in.rid);
12140                 ndr->depth--;
12141         }
12142         if (flags & NDR_OUT) {
12143                 ndr_print_struct(ndr, "out", "samr_RidToSid");
12144                 ndr->depth++;
12145                 ndr_print_ptr(ndr, "sid", r->out.sid);
12146                 ndr->depth++;
12147                 ndr_print_ptr(ndr, "sid", *r->out.sid);
12148                 ndr->depth++;
12149                 if (*r->out.sid) {
12150                         ndr_print_dom_sid2(ndr, "sid", *r->out.sid);
12151                 }
12152                 ndr->depth--;
12153                 ndr->depth--;
12154                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12155                 ndr->depth--;
12156         }
12157         ndr->depth--;
12158 }
12159
12160 static enum ndr_err_code ndr_push_samr_SetDsrmPassword(struct ndr_push *ndr, int flags, const struct samr_SetDsrmPassword *r)
12161 {
12162         if (flags & NDR_IN) {
12163                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.name));
12164                 if (r->in.name) {
12165                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
12166                 }
12167                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
12168                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hash));
12169                 if (r->in.hash) {
12170                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.hash));
12171                 }
12172         }
12173         if (flags & NDR_OUT) {
12174                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12175         }
12176         return NDR_ERR_SUCCESS;
12177 }
12178
12179 static enum ndr_err_code ndr_pull_samr_SetDsrmPassword(struct ndr_pull *ndr, int flags, struct samr_SetDsrmPassword *r)
12180 {
12181         uint32_t _ptr_name;
12182         uint32_t _ptr_hash;
12183         TALLOC_CTX *_mem_save_name_0;
12184         TALLOC_CTX *_mem_save_hash_0;
12185         if (flags & NDR_IN) {
12186                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
12187                 if (_ptr_name) {
12188                         NDR_PULL_ALLOC(ndr, r->in.name);
12189                 } else {
12190                         r->in.name = NULL;
12191                 }
12192                 if (r->in.name) {
12193                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12194                         NDR_PULL_SET_MEM_CTX(ndr, r->in.name, 0);
12195                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
12196                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
12197                 }
12198                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
12199                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hash));
12200                 if (_ptr_hash) {
12201                         NDR_PULL_ALLOC(ndr, r->in.hash);
12202                 } else {
12203                         r->in.hash = NULL;
12204                 }
12205                 if (r->in.hash) {
12206                         _mem_save_hash_0 = NDR_PULL_GET_MEM_CTX(ndr);
12207                         NDR_PULL_SET_MEM_CTX(ndr, r->in.hash, 0);
12208                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.hash));
12209                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hash_0, 0);
12210                 }
12211         }
12212         if (flags & NDR_OUT) {
12213                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12214         }
12215         return NDR_ERR_SUCCESS;
12216 }
12217
12218 _PUBLIC_ void ndr_print_samr_SetDsrmPassword(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetDsrmPassword *r)
12219 {
12220         ndr_print_struct(ndr, name, "samr_SetDsrmPassword");
12221         ndr->depth++;
12222         if (flags & NDR_SET_VALUES) {
12223                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12224         }
12225         if (flags & NDR_IN) {
12226                 ndr_print_struct(ndr, "in", "samr_SetDsrmPassword");
12227                 ndr->depth++;
12228                 ndr_print_ptr(ndr, "name", r->in.name);
12229                 ndr->depth++;
12230                 if (r->in.name) {
12231                         ndr_print_lsa_String(ndr, "name", r->in.name);
12232                 }
12233                 ndr->depth--;
12234                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
12235                 ndr_print_ptr(ndr, "hash", r->in.hash);
12236                 ndr->depth++;
12237                 if (r->in.hash) {
12238                         ndr_print_samr_Password(ndr, "hash", r->in.hash);
12239                 }
12240                 ndr->depth--;
12241                 ndr->depth--;
12242         }
12243         if (flags & NDR_OUT) {
12244                 ndr_print_struct(ndr, "out", "samr_SetDsrmPassword");
12245                 ndr->depth++;
12246                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12247                 ndr->depth--;
12248         }
12249         ndr->depth--;
12250 }
12251
12252 static enum ndr_err_code ndr_push_samr_ValidatePassword(struct ndr_push *ndr, int flags, const struct samr_ValidatePassword *r)
12253 {
12254         if (flags & NDR_IN) {
12255                 NDR_CHECK(ndr_push_samr_ValidatePasswordLevel(ndr, NDR_SCALARS, r->in.level));
12256                 if (r->in.req == NULL) {
12257                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12258                 }
12259                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
12260                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
12261         }
12262         if (flags & NDR_OUT) {
12263                 if (r->out.rep == NULL) {
12264                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12265                 }
12266                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rep));
12267                 if (*r->out.rep) {
12268                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.rep, r->in.level));
12269                         NDR_CHECK(ndr_push_samr_ValidatePasswordRep(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rep));
12270                 }
12271                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12272         }
12273         return NDR_ERR_SUCCESS;
12274 }
12275
12276 static enum ndr_err_code ndr_pull_samr_ValidatePassword(struct ndr_pull *ndr, int flags, struct samr_ValidatePassword *r)
12277 {
12278         uint32_t _ptr_rep;
12279         TALLOC_CTX *_mem_save_req_0;
12280         TALLOC_CTX *_mem_save_rep_0;
12281         TALLOC_CTX *_mem_save_rep_1;
12282         if (flags & NDR_IN) {
12283                 ZERO_STRUCT(r->out);
12284
12285                 NDR_CHECK(ndr_pull_samr_ValidatePasswordLevel(ndr, NDR_SCALARS, &r->in.level));
12286                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12287                         NDR_PULL_ALLOC(ndr, r->in.req);
12288                 }
12289                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
12290                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
12291                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
12292                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
12293                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
12294                 NDR_PULL_ALLOC(ndr, r->out.rep);
12295                 ZERO_STRUCTP(r->out.rep);
12296         }
12297         if (flags & NDR_OUT) {
12298                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12299                         NDR_PULL_ALLOC(ndr, r->out.rep);
12300                 }
12301                 _mem_save_rep_0 = NDR_PULL_GET_MEM_CTX(ndr);
12302                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rep, LIBNDR_FLAG_REF_ALLOC);
12303                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rep));
12304                 if (_ptr_rep) {
12305                         NDR_PULL_ALLOC(ndr, *r->out.rep);
12306                 } else {
12307                         *r->out.rep = NULL;
12308                 }
12309                 if (*r->out.rep) {
12310                         _mem_save_rep_1 = NDR_PULL_GET_MEM_CTX(ndr);
12311                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.rep, 0);
12312                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.rep, r->in.level));
12313                         NDR_CHECK(ndr_pull_samr_ValidatePasswordRep(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rep));
12314                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rep_1, 0);
12315                 }
12316                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rep_0, LIBNDR_FLAG_REF_ALLOC);
12317                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12318         }
12319         return NDR_ERR_SUCCESS;
12320 }
12321
12322 _PUBLIC_ void ndr_print_samr_ValidatePassword(struct ndr_print *ndr, const char *name, int flags, const struct samr_ValidatePassword *r)
12323 {
12324         ndr_print_struct(ndr, name, "samr_ValidatePassword");
12325         ndr->depth++;
12326         if (flags & NDR_SET_VALUES) {
12327                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12328         }
12329         if (flags & NDR_IN) {
12330                 ndr_print_struct(ndr, "in", "samr_ValidatePassword");
12331                 ndr->depth++;
12332                 ndr_print_samr_ValidatePasswordLevel(ndr, "level", r->in.level);
12333                 ndr_print_ptr(ndr, "req", r->in.req);
12334                 ndr->depth++;
12335                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
12336                 ndr_print_samr_ValidatePasswordReq(ndr, "req", r->in.req);
12337                 ndr->depth--;
12338                 ndr->depth--;
12339         }
12340         if (flags & NDR_OUT) {
12341                 ndr_print_struct(ndr, "out", "samr_ValidatePassword");
12342                 ndr->depth++;
12343                 ndr_print_ptr(ndr, "rep", r->out.rep);
12344                 ndr->depth++;
12345                 ndr_print_ptr(ndr, "rep", *r->out.rep);
12346                 ndr->depth++;
12347                 if (*r->out.rep) {
12348                         ndr_print_set_switch_value(ndr, *r->out.rep, r->in.level);
12349                         ndr_print_samr_ValidatePasswordRep(ndr, "rep", *r->out.rep);
12350                 }
12351                 ndr->depth--;
12352                 ndr->depth--;
12353                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12354                 ndr->depth--;
12355         }
12356         ndr->depth--;
12357 }
12358
12359 static const struct ndr_interface_call samr_calls[] = {
12360         {
12361                 "samr_Connect",
12362                 sizeof(struct samr_Connect),
12363                 (ndr_push_flags_fn_t) ndr_push_samr_Connect,
12364                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect,
12365                 (ndr_print_function_t) ndr_print_samr_Connect,
12366                 false,
12367         },
12368         {
12369                 "samr_Close",
12370                 sizeof(struct samr_Close),
12371                 (ndr_push_flags_fn_t) ndr_push_samr_Close,
12372                 (ndr_pull_flags_fn_t) ndr_pull_samr_Close,
12373                 (ndr_print_function_t) ndr_print_samr_Close,
12374                 false,
12375         },
12376         {
12377                 "samr_SetSecurity",
12378                 sizeof(struct samr_SetSecurity),
12379                 (ndr_push_flags_fn_t) ndr_push_samr_SetSecurity,
12380                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetSecurity,
12381                 (ndr_print_function_t) ndr_print_samr_SetSecurity,
12382                 false,
12383         },
12384         {
12385                 "samr_QuerySecurity",
12386                 sizeof(struct samr_QuerySecurity),
12387                 (ndr_push_flags_fn_t) ndr_push_samr_QuerySecurity,
12388                 (ndr_pull_flags_fn_t) ndr_pull_samr_QuerySecurity,
12389                 (ndr_print_function_t) ndr_print_samr_QuerySecurity,
12390                 false,
12391         },
12392         {
12393                 "samr_Shutdown",
12394                 sizeof(struct samr_Shutdown),
12395                 (ndr_push_flags_fn_t) ndr_push_samr_Shutdown,
12396                 (ndr_pull_flags_fn_t) ndr_pull_samr_Shutdown,
12397                 (ndr_print_function_t) ndr_print_samr_Shutdown,
12398                 false,
12399         },
12400         {
12401                 "samr_LookupDomain",
12402                 sizeof(struct samr_LookupDomain),
12403                 (ndr_push_flags_fn_t) ndr_push_samr_LookupDomain,
12404                 (ndr_pull_flags_fn_t) ndr_pull_samr_LookupDomain,
12405                 (ndr_print_function_t) ndr_print_samr_LookupDomain,
12406                 false,
12407         },
12408         {
12409                 "samr_EnumDomains",
12410                 sizeof(struct samr_EnumDomains),
12411                 (ndr_push_flags_fn_t) ndr_push_samr_EnumDomains,
12412                 (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomains,
12413                 (ndr_print_function_t) ndr_print_samr_EnumDomains,
12414                 false,
12415         },
12416         {
12417                 "samr_OpenDomain",
12418                 sizeof(struct samr_OpenDomain),
12419                 (ndr_push_flags_fn_t) ndr_push_samr_OpenDomain,
12420                 (ndr_pull_flags_fn_t) ndr_pull_samr_OpenDomain,
12421                 (ndr_print_function_t) ndr_print_samr_OpenDomain,
12422                 false,
12423         },
12424         {
12425                 "samr_QueryDomainInfo",
12426                 sizeof(struct samr_QueryDomainInfo),
12427                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDomainInfo,
12428                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDomainInfo,
12429                 (ndr_print_function_t) ndr_print_samr_QueryDomainInfo,
12430                 false,
12431         },
12432         {
12433                 "samr_SetDomainInfo",
12434                 sizeof(struct samr_SetDomainInfo),
12435                 (ndr_push_flags_fn_t) ndr_push_samr_SetDomainInfo,
12436                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetDomainInfo,
12437                 (ndr_print_function_t) ndr_print_samr_SetDomainInfo,
12438                 false,
12439         },
12440         {
12441                 "samr_CreateDomainGroup",
12442                 sizeof(struct samr_CreateDomainGroup),
12443                 (ndr_push_flags_fn_t) ndr_push_samr_CreateDomainGroup,
12444                 (ndr_pull_flags_fn_t) ndr_pull_samr_CreateDomainGroup,
12445                 (ndr_print_function_t) ndr_print_samr_CreateDomainGroup,
12446                 false,
12447         },
12448         {
12449                 "samr_EnumDomainGroups",
12450                 sizeof(struct samr_EnumDomainGroups),
12451                 (ndr_push_flags_fn_t) ndr_push_samr_EnumDomainGroups,
12452                 (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainGroups,
12453                 (ndr_print_function_t) ndr_print_samr_EnumDomainGroups,
12454                 false,
12455         },
12456         {
12457                 "samr_CreateUser",
12458                 sizeof(struct samr_CreateUser),
12459                 (ndr_push_flags_fn_t) ndr_push_samr_CreateUser,
12460                 (ndr_pull_flags_fn_t) ndr_pull_samr_CreateUser,
12461                 (ndr_print_function_t) ndr_print_samr_CreateUser,
12462                 false,
12463         },
12464         {
12465                 "samr_EnumDomainUsers",
12466                 sizeof(struct samr_EnumDomainUsers),
12467                 (ndr_push_flags_fn_t) ndr_push_samr_EnumDomainUsers,
12468                 (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainUsers,
12469                 (ndr_print_function_t) ndr_print_samr_EnumDomainUsers,
12470                 false,
12471         },
12472         {
12473                 "samr_CreateDomAlias",
12474                 sizeof(struct samr_CreateDomAlias),
12475                 (ndr_push_flags_fn_t) ndr_push_samr_CreateDomAlias,
12476                 (ndr_pull_flags_fn_t) ndr_pull_samr_CreateDomAlias,
12477                 (ndr_print_function_t) ndr_print_samr_CreateDomAlias,
12478                 false,
12479         },
12480         {
12481                 "samr_EnumDomainAliases",
12482                 sizeof(struct samr_EnumDomainAliases),
12483                 (ndr_push_flags_fn_t) ndr_push_samr_EnumDomainAliases,
12484                 (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainAliases,
12485                 (ndr_print_function_t) ndr_print_samr_EnumDomainAliases,
12486                 false,
12487         },
12488         {
12489                 "samr_GetAliasMembership",
12490                 sizeof(struct samr_GetAliasMembership),
12491                 (ndr_push_flags_fn_t) ndr_push_samr_GetAliasMembership,
12492                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetAliasMembership,
12493                 (ndr_print_function_t) ndr_print_samr_GetAliasMembership,
12494                 false,
12495         },
12496         {
12497                 "samr_LookupNames",
12498                 sizeof(struct samr_LookupNames),
12499                 (ndr_push_flags_fn_t) ndr_push_samr_LookupNames,
12500                 (ndr_pull_flags_fn_t) ndr_pull_samr_LookupNames,
12501                 (ndr_print_function_t) ndr_print_samr_LookupNames,
12502                 false,
12503         },
12504         {
12505                 "samr_LookupRids",
12506                 sizeof(struct samr_LookupRids),
12507                 (ndr_push_flags_fn_t) ndr_push_samr_LookupRids,
12508                 (ndr_pull_flags_fn_t) ndr_pull_samr_LookupRids,
12509                 (ndr_print_function_t) ndr_print_samr_LookupRids,
12510                 false,
12511         },
12512         {
12513                 "samr_OpenGroup",
12514                 sizeof(struct samr_OpenGroup),
12515                 (ndr_push_flags_fn_t) ndr_push_samr_OpenGroup,
12516                 (ndr_pull_flags_fn_t) ndr_pull_samr_OpenGroup,
12517                 (ndr_print_function_t) ndr_print_samr_OpenGroup,
12518                 false,
12519         },
12520         {
12521                 "samr_QueryGroupInfo",
12522                 sizeof(struct samr_QueryGroupInfo),
12523                 (ndr_push_flags_fn_t) ndr_push_samr_QueryGroupInfo,
12524                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryGroupInfo,
12525                 (ndr_print_function_t) ndr_print_samr_QueryGroupInfo,
12526                 false,
12527         },
12528         {
12529                 "samr_SetGroupInfo",
12530                 sizeof(struct samr_SetGroupInfo),
12531                 (ndr_push_flags_fn_t) ndr_push_samr_SetGroupInfo,
12532                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetGroupInfo,
12533                 (ndr_print_function_t) ndr_print_samr_SetGroupInfo,
12534                 false,
12535         },
12536         {
12537                 "samr_AddGroupMember",
12538                 sizeof(struct samr_AddGroupMember),
12539                 (ndr_push_flags_fn_t) ndr_push_samr_AddGroupMember,
12540                 (ndr_pull_flags_fn_t) ndr_pull_samr_AddGroupMember,
12541                 (ndr_print_function_t) ndr_print_samr_AddGroupMember,
12542                 false,
12543         },
12544         {
12545                 "samr_DeleteDomainGroup",
12546                 sizeof(struct samr_DeleteDomainGroup),
12547                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteDomainGroup,
12548                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteDomainGroup,
12549                 (ndr_print_function_t) ndr_print_samr_DeleteDomainGroup,
12550                 false,
12551         },
12552         {
12553                 "samr_DeleteGroupMember",
12554                 sizeof(struct samr_DeleteGroupMember),
12555                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteGroupMember,
12556                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteGroupMember,
12557                 (ndr_print_function_t) ndr_print_samr_DeleteGroupMember,
12558                 false,
12559         },
12560         {
12561                 "samr_QueryGroupMember",
12562                 sizeof(struct samr_QueryGroupMember),
12563                 (ndr_push_flags_fn_t) ndr_push_samr_QueryGroupMember,
12564                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryGroupMember,
12565                 (ndr_print_function_t) ndr_print_samr_QueryGroupMember,
12566                 false,
12567         },
12568         {
12569                 "samr_SetMemberAttributesOfGroup",
12570                 sizeof(struct samr_SetMemberAttributesOfGroup),
12571                 (ndr_push_flags_fn_t) ndr_push_samr_SetMemberAttributesOfGroup,
12572                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetMemberAttributesOfGroup,
12573                 (ndr_print_function_t) ndr_print_samr_SetMemberAttributesOfGroup,
12574                 false,
12575         },
12576         {
12577                 "samr_OpenAlias",
12578                 sizeof(struct samr_OpenAlias),
12579                 (ndr_push_flags_fn_t) ndr_push_samr_OpenAlias,
12580                 (ndr_pull_flags_fn_t) ndr_pull_samr_OpenAlias,
12581                 (ndr_print_function_t) ndr_print_samr_OpenAlias,
12582                 false,
12583         },
12584         {
12585                 "samr_QueryAliasInfo",
12586                 sizeof(struct samr_QueryAliasInfo),
12587                 (ndr_push_flags_fn_t) ndr_push_samr_QueryAliasInfo,
12588                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryAliasInfo,
12589                 (ndr_print_function_t) ndr_print_samr_QueryAliasInfo,
12590                 false,
12591         },
12592         {
12593                 "samr_SetAliasInfo",
12594                 sizeof(struct samr_SetAliasInfo),
12595                 (ndr_push_flags_fn_t) ndr_push_samr_SetAliasInfo,
12596                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetAliasInfo,
12597                 (ndr_print_function_t) ndr_print_samr_SetAliasInfo,
12598                 false,
12599         },
12600         {
12601                 "samr_DeleteDomAlias",
12602                 sizeof(struct samr_DeleteDomAlias),
12603                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteDomAlias,
12604                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteDomAlias,
12605                 (ndr_print_function_t) ndr_print_samr_DeleteDomAlias,
12606                 false,
12607         },
12608         {
12609                 "samr_AddAliasMember",
12610                 sizeof(struct samr_AddAliasMember),
12611                 (ndr_push_flags_fn_t) ndr_push_samr_AddAliasMember,
12612                 (ndr_pull_flags_fn_t) ndr_pull_samr_AddAliasMember,
12613                 (ndr_print_function_t) ndr_print_samr_AddAliasMember,
12614                 false,
12615         },
12616         {
12617                 "samr_DeleteAliasMember",
12618                 sizeof(struct samr_DeleteAliasMember),
12619                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteAliasMember,
12620                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteAliasMember,
12621                 (ndr_print_function_t) ndr_print_samr_DeleteAliasMember,
12622                 false,
12623         },
12624         {
12625                 "samr_GetMembersInAlias",
12626                 sizeof(struct samr_GetMembersInAlias),
12627                 (ndr_push_flags_fn_t) ndr_push_samr_GetMembersInAlias,
12628                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetMembersInAlias,
12629                 (ndr_print_function_t) ndr_print_samr_GetMembersInAlias,
12630                 false,
12631         },
12632         {
12633                 "samr_OpenUser",
12634                 sizeof(struct samr_OpenUser),
12635                 (ndr_push_flags_fn_t) ndr_push_samr_OpenUser,
12636                 (ndr_pull_flags_fn_t) ndr_pull_samr_OpenUser,
12637                 (ndr_print_function_t) ndr_print_samr_OpenUser,
12638                 false,
12639         },
12640         {
12641                 "samr_DeleteUser",
12642                 sizeof(struct samr_DeleteUser),
12643                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteUser,
12644                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteUser,
12645                 (ndr_print_function_t) ndr_print_samr_DeleteUser,
12646                 false,
12647         },
12648         {
12649                 "samr_QueryUserInfo",
12650                 sizeof(struct samr_QueryUserInfo),
12651                 (ndr_push_flags_fn_t) ndr_push_samr_QueryUserInfo,
12652                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryUserInfo,
12653                 (ndr_print_function_t) ndr_print_samr_QueryUserInfo,
12654                 false,
12655         },
12656         {
12657                 "samr_SetUserInfo",
12658                 sizeof(struct samr_SetUserInfo),
12659                 (ndr_push_flags_fn_t) ndr_push_samr_SetUserInfo,
12660                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetUserInfo,
12661                 (ndr_print_function_t) ndr_print_samr_SetUserInfo,
12662                 false,
12663         },
12664         {
12665                 "samr_ChangePasswordUser",
12666                 sizeof(struct samr_ChangePasswordUser),
12667                 (ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser,
12668                 (ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser,
12669                 (ndr_print_function_t) ndr_print_samr_ChangePasswordUser,
12670                 false,
12671         },
12672         {
12673                 "samr_GetGroupsForUser",
12674                 sizeof(struct samr_GetGroupsForUser),
12675                 (ndr_push_flags_fn_t) ndr_push_samr_GetGroupsForUser,
12676                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetGroupsForUser,
12677                 (ndr_print_function_t) ndr_print_samr_GetGroupsForUser,
12678                 false,
12679         },
12680         {
12681                 "samr_QueryDisplayInfo",
12682                 sizeof(struct samr_QueryDisplayInfo),
12683                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo,
12684                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo,
12685                 (ndr_print_function_t) ndr_print_samr_QueryDisplayInfo,
12686                 false,
12687         },
12688         {
12689                 "samr_GetDisplayEnumerationIndex",
12690                 sizeof(struct samr_GetDisplayEnumerationIndex),
12691                 (ndr_push_flags_fn_t) ndr_push_samr_GetDisplayEnumerationIndex,
12692                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetDisplayEnumerationIndex,
12693                 (ndr_print_function_t) ndr_print_samr_GetDisplayEnumerationIndex,
12694                 false,
12695         },
12696         {
12697                 "samr_TestPrivateFunctionsDomain",
12698                 sizeof(struct samr_TestPrivateFunctionsDomain),
12699                 (ndr_push_flags_fn_t) ndr_push_samr_TestPrivateFunctionsDomain,
12700                 (ndr_pull_flags_fn_t) ndr_pull_samr_TestPrivateFunctionsDomain,
12701                 (ndr_print_function_t) ndr_print_samr_TestPrivateFunctionsDomain,
12702                 false,
12703         },
12704         {
12705                 "samr_TestPrivateFunctionsUser",
12706                 sizeof(struct samr_TestPrivateFunctionsUser),
12707                 (ndr_push_flags_fn_t) ndr_push_samr_TestPrivateFunctionsUser,
12708                 (ndr_pull_flags_fn_t) ndr_pull_samr_TestPrivateFunctionsUser,
12709                 (ndr_print_function_t) ndr_print_samr_TestPrivateFunctionsUser,
12710                 false,
12711         },
12712         {
12713                 "samr_GetUserPwInfo",
12714                 sizeof(struct samr_GetUserPwInfo),
12715                 (ndr_push_flags_fn_t) ndr_push_samr_GetUserPwInfo,
12716                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetUserPwInfo,
12717                 (ndr_print_function_t) ndr_print_samr_GetUserPwInfo,
12718                 false,
12719         },
12720         {
12721                 "samr_RemoveMemberFromForeignDomain",
12722                 sizeof(struct samr_RemoveMemberFromForeignDomain),
12723                 (ndr_push_flags_fn_t) ndr_push_samr_RemoveMemberFromForeignDomain,
12724                 (ndr_pull_flags_fn_t) ndr_pull_samr_RemoveMemberFromForeignDomain,
12725                 (ndr_print_function_t) ndr_print_samr_RemoveMemberFromForeignDomain,
12726                 false,
12727         },
12728         {
12729                 "samr_QueryDomainInfo2",
12730                 sizeof(struct samr_QueryDomainInfo2),
12731                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDomainInfo2,
12732                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDomainInfo2,
12733                 (ndr_print_function_t) ndr_print_samr_QueryDomainInfo2,
12734                 false,
12735         },
12736         {
12737                 "samr_QueryUserInfo2",
12738                 sizeof(struct samr_QueryUserInfo2),
12739                 (ndr_push_flags_fn_t) ndr_push_samr_QueryUserInfo2,
12740                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryUserInfo2,
12741                 (ndr_print_function_t) ndr_print_samr_QueryUserInfo2,
12742                 false,
12743         },
12744         {
12745                 "samr_QueryDisplayInfo2",
12746                 sizeof(struct samr_QueryDisplayInfo2),
12747                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo2,
12748                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo2,
12749                 (ndr_print_function_t) ndr_print_samr_QueryDisplayInfo2,
12750                 false,
12751         },
12752         {
12753                 "samr_GetDisplayEnumerationIndex2",
12754                 sizeof(struct samr_GetDisplayEnumerationIndex2),
12755                 (ndr_push_flags_fn_t) ndr_push_samr_GetDisplayEnumerationIndex2,
12756                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetDisplayEnumerationIndex2,
12757                 (ndr_print_function_t) ndr_print_samr_GetDisplayEnumerationIndex2,
12758                 false,
12759         },
12760         {
12761                 "samr_CreateUser2",
12762                 sizeof(struct samr_CreateUser2),
12763                 (ndr_push_flags_fn_t) ndr_push_samr_CreateUser2,
12764                 (ndr_pull_flags_fn_t) ndr_pull_samr_CreateUser2,
12765                 (ndr_print_function_t) ndr_print_samr_CreateUser2,
12766                 false,
12767         },
12768         {
12769                 "samr_QueryDisplayInfo3",
12770                 sizeof(struct samr_QueryDisplayInfo3),
12771                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo3,
12772                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo3,
12773                 (ndr_print_function_t) ndr_print_samr_QueryDisplayInfo3,
12774                 false,
12775         },
12776         {
12777                 "samr_AddMultipleMembersToAlias",
12778                 sizeof(struct samr_AddMultipleMembersToAlias),
12779                 (ndr_push_flags_fn_t) ndr_push_samr_AddMultipleMembersToAlias,
12780                 (ndr_pull_flags_fn_t) ndr_pull_samr_AddMultipleMembersToAlias,
12781                 (ndr_print_function_t) ndr_print_samr_AddMultipleMembersToAlias,
12782                 false,
12783         },
12784         {
12785                 "samr_RemoveMultipleMembersFromAlias",
12786                 sizeof(struct samr_RemoveMultipleMembersFromAlias),
12787                 (ndr_push_flags_fn_t) ndr_push_samr_RemoveMultipleMembersFromAlias,
12788                 (ndr_pull_flags_fn_t) ndr_pull_samr_RemoveMultipleMembersFromAlias,
12789                 (ndr_print_function_t) ndr_print_samr_RemoveMultipleMembersFromAlias,
12790                 false,
12791         },
12792         {
12793                 "samr_OemChangePasswordUser2",
12794                 sizeof(struct samr_OemChangePasswordUser2),
12795                 (ndr_push_flags_fn_t) ndr_push_samr_OemChangePasswordUser2,
12796                 (ndr_pull_flags_fn_t) ndr_pull_samr_OemChangePasswordUser2,
12797                 (ndr_print_function_t) ndr_print_samr_OemChangePasswordUser2,
12798                 false,
12799         },
12800         {
12801                 "samr_ChangePasswordUser2",
12802                 sizeof(struct samr_ChangePasswordUser2),
12803                 (ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser2,
12804                 (ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser2,
12805                 (ndr_print_function_t) ndr_print_samr_ChangePasswordUser2,
12806                 false,
12807         },
12808         {
12809                 "samr_GetDomPwInfo",
12810                 sizeof(struct samr_GetDomPwInfo),
12811                 (ndr_push_flags_fn_t) ndr_push_samr_GetDomPwInfo,
12812                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetDomPwInfo,
12813                 (ndr_print_function_t) ndr_print_samr_GetDomPwInfo,
12814                 false,
12815         },
12816         {
12817                 "samr_Connect2",
12818                 sizeof(struct samr_Connect2),
12819                 (ndr_push_flags_fn_t) ndr_push_samr_Connect2,
12820                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect2,
12821                 (ndr_print_function_t) ndr_print_samr_Connect2,
12822                 false,
12823         },
12824         {
12825                 "samr_SetUserInfo2",
12826                 sizeof(struct samr_SetUserInfo2),
12827                 (ndr_push_flags_fn_t) ndr_push_samr_SetUserInfo2,
12828                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetUserInfo2,
12829                 (ndr_print_function_t) ndr_print_samr_SetUserInfo2,
12830                 false,
12831         },
12832         {
12833                 "samr_SetBootKeyInformation",
12834                 sizeof(struct samr_SetBootKeyInformation),
12835                 (ndr_push_flags_fn_t) ndr_push_samr_SetBootKeyInformation,
12836                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetBootKeyInformation,
12837                 (ndr_print_function_t) ndr_print_samr_SetBootKeyInformation,
12838                 false,
12839         },
12840         {
12841                 "samr_GetBootKeyInformation",
12842                 sizeof(struct samr_GetBootKeyInformation),
12843                 (ndr_push_flags_fn_t) ndr_push_samr_GetBootKeyInformation,
12844                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetBootKeyInformation,
12845                 (ndr_print_function_t) ndr_print_samr_GetBootKeyInformation,
12846                 false,
12847         },
12848         {
12849                 "samr_Connect3",
12850                 sizeof(struct samr_Connect3),
12851                 (ndr_push_flags_fn_t) ndr_push_samr_Connect3,
12852                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect3,
12853                 (ndr_print_function_t) ndr_print_samr_Connect3,
12854                 false,
12855         },
12856         {
12857                 "samr_Connect4",
12858                 sizeof(struct samr_Connect4),
12859                 (ndr_push_flags_fn_t) ndr_push_samr_Connect4,
12860                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect4,
12861                 (ndr_print_function_t) ndr_print_samr_Connect4,
12862                 false,
12863         },
12864         {
12865                 "samr_ChangePasswordUser3",
12866                 sizeof(struct samr_ChangePasswordUser3),
12867                 (ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser3,
12868                 (ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser3,
12869                 (ndr_print_function_t) ndr_print_samr_ChangePasswordUser3,
12870                 false,
12871         },
12872         {
12873                 "samr_Connect5",
12874                 sizeof(struct samr_Connect5),
12875                 (ndr_push_flags_fn_t) ndr_push_samr_Connect5,
12876                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect5,
12877                 (ndr_print_function_t) ndr_print_samr_Connect5,
12878                 false,
12879         },
12880         {
12881                 "samr_RidToSid",
12882                 sizeof(struct samr_RidToSid),
12883                 (ndr_push_flags_fn_t) ndr_push_samr_RidToSid,
12884                 (ndr_pull_flags_fn_t) ndr_pull_samr_RidToSid,
12885                 (ndr_print_function_t) ndr_print_samr_RidToSid,
12886                 false,
12887         },
12888         {
12889                 "samr_SetDsrmPassword",
12890                 sizeof(struct samr_SetDsrmPassword),
12891                 (ndr_push_flags_fn_t) ndr_push_samr_SetDsrmPassword,
12892                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetDsrmPassword,
12893                 (ndr_print_function_t) ndr_print_samr_SetDsrmPassword,
12894                 false,
12895         },
12896         {
12897                 "samr_ValidatePassword",
12898                 sizeof(struct samr_ValidatePassword),
12899                 (ndr_push_flags_fn_t) ndr_push_samr_ValidatePassword,
12900                 (ndr_pull_flags_fn_t) ndr_pull_samr_ValidatePassword,
12901                 (ndr_print_function_t) ndr_print_samr_ValidatePassword,
12902                 false,
12903         },
12904         { NULL, 0, NULL, NULL, NULL, false }
12905 };
12906
12907 static const char * const samr_endpoint_strings[] = {
12908         "ncacn_np:[\\pipe\\samr]",
12909         "ncacn_ip_tcp:",
12910         "ncalrpc:",
12911 };
12912
12913 static const struct ndr_interface_string_array samr_endpoints = {
12914         .count  = 3,
12915         .names  = samr_endpoint_strings
12916 };
12917
12918 static const char * const samr_authservice_strings[] = {
12919         "host",
12920 };
12921
12922 static const struct ndr_interface_string_array samr_authservices = {
12923         .count  = 1,
12924         .names  = samr_authservice_strings
12925 };
12926
12927
12928 const struct ndr_interface_table ndr_table_samr = {
12929         .name           = "samr",
12930         .syntax_id      = {
12931                 {0x12345778,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xac}},
12932                 NDR_SAMR_VERSION
12933         },
12934         .helpstring     = NDR_SAMR_HELPSTRING,
12935         .num_calls      = 68,
12936         .calls          = samr_calls,
12937         .endpoints      = &samr_endpoints,
12938         .authservices   = &samr_authservices
12939 };
12940