source3/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_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_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_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_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_OPEN_DOMAIN", SAMR_ACCESS_OPEN_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, 4));
 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, 4));
 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, 4));
 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_uint32(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, 4));
 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_Role(struct ndr_push *ndr, int ndr_flags, enum samr_Role r)
 367 {
 368         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 369         return NDR_ERR_SUCCESS;
 370 }
 371
 372 static enum ndr_err_code ndr_pull_samr_Role(struct ndr_pull *ndr, int ndr_flags, enum samr_Role *r)
 373 {
 374         uint32_t v;
 375         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 376         *r = v;
 377         return NDR_ERR_SUCCESS;
 378 }
 379
 380 _PUBLIC_ void ndr_print_samr_Role(struct ndr_print *ndr, const char *name, enum samr_Role r)
 381 {
 382         const char *val = NULL;
 383
 384         switch (r) {
 385                 case SAMR_ROLE_STANDALONE: val = "SAMR_ROLE_STANDALONE"; break;
 386                 case SAMR_ROLE_DOMAIN_MEMBER: val = "SAMR_ROLE_DOMAIN_MEMBER"; break;
 387                 case SAMR_ROLE_DOMAIN_BDC: val = "SAMR_ROLE_DOMAIN_BDC"; break;
 388                 case SAMR_ROLE_DOMAIN_PDC: val = "SAMR_ROLE_DOMAIN_PDC"; break;
 389         }
 390         ndr_print_enum(ndr, name, "ENUM", val, r);
 391 }
 392
 393 _PUBLIC_ enum ndr_err_code ndr_push_samr_PasswordProperties(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 394 {
 395         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 396         return NDR_ERR_SUCCESS;
 397 }
 398
 399 _PUBLIC_ enum ndr_err_code ndr_pull_samr_PasswordProperties(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 400 {
 401         uint32_t v;
 402         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 403         *r = v;
 404         return NDR_ERR_SUCCESS;
 405 }
 406
 407 _PUBLIC_ void ndr_print_samr_PasswordProperties(struct ndr_print *ndr, const char *name, uint32_t r)
 408 {
 409         ndr_print_uint32(ndr, name, r);
 410         ndr->depth++;
 411         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_COMPLEX", DOMAIN_PASSWORD_COMPLEX, r);
 412         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_NO_ANON_CHANGE", DOMAIN_PASSWORD_NO_ANON_CHANGE, r);
 413         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_NO_CLEAR_CHANGE", DOMAIN_PASSWORD_NO_CLEAR_CHANGE, r);
 414         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_LOCKOUT_ADMINS", DOMAIN_PASSWORD_LOCKOUT_ADMINS, r);
 415         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_STORE_CLEARTEXT", DOMAIN_PASSWORD_STORE_CLEARTEXT, r);
 416         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_REFUSE_PASSWORD_CHANGE", DOMAIN_REFUSE_PASSWORD_CHANGE, r);
 417         ndr->depth--;
 418 }
 419
 420 static enum ndr_err_code ndr_push_samr_DomInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo1 *r)
 421 {
 422         if (ndr_flags & NDR_SCALARS) {
 423                 NDR_CHECK(ndr_push_align(ndr, 4));
 424                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->min_password_length));
 425                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->password_history_length));
 426                 NDR_CHECK(ndr_push_samr_PasswordProperties(ndr, NDR_SCALARS, r->password_properties));
 427                 NDR_CHECK(ndr_push_dlong(ndr, NDR_SCALARS, r->max_password_age));
 428                 NDR_CHECK(ndr_push_dlong(ndr, NDR_SCALARS, r->min_password_age));
 429         }
 430         if (ndr_flags & NDR_BUFFERS) {
 431         }
 432         return NDR_ERR_SUCCESS;
 433 }
 434
 435 static enum ndr_err_code ndr_pull_samr_DomInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo1 *r)
 436 {
 437         if (ndr_flags & NDR_SCALARS) {
 438                 NDR_CHECK(ndr_pull_align(ndr, 4));
 439                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->min_password_length));
 440                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->password_history_length));
 441                 NDR_CHECK(ndr_pull_samr_PasswordProperties(ndr, NDR_SCALARS, &r->password_properties));
 442                 NDR_CHECK(ndr_pull_dlong(ndr, NDR_SCALARS, &r->max_password_age));
 443                 NDR_CHECK(ndr_pull_dlong(ndr, NDR_SCALARS, &r->min_password_age));
 444         }
 445         if (ndr_flags & NDR_BUFFERS) {
 446         }
 447         return NDR_ERR_SUCCESS;
 448 }
 449
 450 _PUBLIC_ void ndr_print_samr_DomInfo1(struct ndr_print *ndr, const char *name, const struct samr_DomInfo1 *r)
 451 {
 452         ndr_print_struct(ndr, name, "samr_DomInfo1");
 453         ndr->depth++;
 454         ndr_print_uint16(ndr, "min_password_length", r->min_password_length);
 455         ndr_print_uint16(ndr, "password_history_length", r->password_history_length);
 456         ndr_print_samr_PasswordProperties(ndr, "password_properties", r->password_properties);
 457         ndr_print_dlong(ndr, "max_password_age", r->max_password_age);
 458         ndr_print_dlong(ndr, "min_password_age", r->min_password_age);
 459         ndr->depth--;
 460 }
 461
 462 static enum ndr_err_code ndr_push_samr_DomGeneralInformation(struct ndr_push *ndr, int ndr_flags, const struct samr_DomGeneralInformation *r)
 463 {
 464         if (ndr_flags & NDR_SCALARS) {
 465                 NDR_CHECK(ndr_push_align(ndr, 4));
 466                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_logoff_time));
 467                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 468                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 469                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->primary));
 470                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->sequence_num));
 471                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
 472                 NDR_CHECK(ndr_push_samr_Role(ndr, NDR_SCALARS, r->role));
 473                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
 474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_users));
 475                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_groups));
 476                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_aliases));
 477         }
 478         if (ndr_flags & NDR_BUFFERS) {
 479                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 480                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 481                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 482         }
 483         return NDR_ERR_SUCCESS;
 484 }
 485
 486 static enum ndr_err_code ndr_pull_samr_DomGeneralInformation(struct ndr_pull *ndr, int ndr_flags, struct samr_DomGeneralInformation *r)
 487 {
 488         if (ndr_flags & NDR_SCALARS) {
 489                 NDR_CHECK(ndr_pull_align(ndr, 4));
 490                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_logoff_time));
 491                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 492                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 493                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->primary));
 494                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->sequence_num));
 495                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
 496                 NDR_CHECK(ndr_pull_samr_Role(ndr, NDR_SCALARS, &r->role));
 497                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
 498                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_users));
 499                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_groups));
 500                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_aliases));
 501         }
 502         if (ndr_flags & NDR_BUFFERS) {
 503                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 504                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 505                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 506         }
 507         return NDR_ERR_SUCCESS;
 508 }
 509
 510 _PUBLIC_ void ndr_print_samr_DomGeneralInformation(struct ndr_print *ndr, const char *name, const struct samr_DomGeneralInformation *r)
 511 {
 512         ndr_print_struct(ndr, name, "samr_DomGeneralInformation");
 513         ndr->depth++;
 514         ndr_print_NTTIME(ndr, "force_logoff_time", r->force_logoff_time);
 515         ndr_print_lsa_String(ndr, "oem_information", &r->oem_information);
 516         ndr_print_lsa_String(ndr, "domain_name", &r->domain_name);
 517         ndr_print_lsa_String(ndr, "primary", &r->primary);
 518         ndr_print_udlong(ndr, "sequence_num", r->sequence_num);
 519         ndr_print_uint32(ndr, "unknown2", r->unknown2);
 520         ndr_print_samr_Role(ndr, "role", r->role);
 521         ndr_print_uint32(ndr, "unknown3", r->unknown3);
 522         ndr_print_uint32(ndr, "num_users", r->num_users);
 523         ndr_print_uint32(ndr, "num_groups", r->num_groups);
 524         ndr_print_uint32(ndr, "num_aliases", r->num_aliases);
 525         ndr->depth--;
 526 }
 527
 528 static enum ndr_err_code ndr_push_samr_DomInfo3(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo3 *r)
 529 {
 530         if (ndr_flags & NDR_SCALARS) {
 531                 NDR_CHECK(ndr_push_align(ndr, 4));
 532                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_logoff_time));
 533         }
 534         if (ndr_flags & NDR_BUFFERS) {
 535         }
 536         return NDR_ERR_SUCCESS;
 537 }
 538
 539 static enum ndr_err_code ndr_pull_samr_DomInfo3(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo3 *r)
 540 {
 541         if (ndr_flags & NDR_SCALARS) {
 542                 NDR_CHECK(ndr_pull_align(ndr, 4));
 543                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_logoff_time));
 544         }
 545         if (ndr_flags & NDR_BUFFERS) {
 546         }
 547         return NDR_ERR_SUCCESS;
 548 }
 549
 550 _PUBLIC_ void ndr_print_samr_DomInfo3(struct ndr_print *ndr, const char *name, const struct samr_DomInfo3 *r)
 551 {
 552         ndr_print_struct(ndr, name, "samr_DomInfo3");
 553         ndr->depth++;
 554         ndr_print_NTTIME(ndr, "force_logoff_time", r->force_logoff_time);
 555         ndr->depth--;
 556 }
 557
 558 static enum ndr_err_code ndr_push_samr_DomOEMInformation(struct ndr_push *ndr, int ndr_flags, const struct samr_DomOEMInformation *r)
 559 {
 560         if (ndr_flags & NDR_SCALARS) {
 561                 NDR_CHECK(ndr_push_align(ndr, 4));
 562                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 563         }
 564         if (ndr_flags & NDR_BUFFERS) {
 565                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 566         }
 567         return NDR_ERR_SUCCESS;
 568 }
 569
 570 static enum ndr_err_code ndr_pull_samr_DomOEMInformation(struct ndr_pull *ndr, int ndr_flags, struct samr_DomOEMInformation *r)
 571 {
 572         if (ndr_flags & NDR_SCALARS) {
 573                 NDR_CHECK(ndr_pull_align(ndr, 4));
 574                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 575         }
 576         if (ndr_flags & NDR_BUFFERS) {
 577                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 578         }
 579         return NDR_ERR_SUCCESS;
 580 }
 581
 582 _PUBLIC_ void ndr_print_samr_DomOEMInformation(struct ndr_print *ndr, const char *name, const struct samr_DomOEMInformation *r)
 583 {
 584         ndr_print_struct(ndr, name, "samr_DomOEMInformation");
 585         ndr->depth++;
 586         ndr_print_lsa_String(ndr, "oem_information", &r->oem_information);
 587         ndr->depth--;
 588 }
 589
 590 static enum ndr_err_code ndr_push_samr_DomInfo5(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo5 *r)
 591 {
 592         if (ndr_flags & NDR_SCALARS) {
 593                 NDR_CHECK(ndr_push_align(ndr, 4));
 594                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 595         }
 596         if (ndr_flags & NDR_BUFFERS) {
 597                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 598         }
 599         return NDR_ERR_SUCCESS;
 600 }
 601
 602 static enum ndr_err_code ndr_pull_samr_DomInfo5(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo5 *r)
 603 {
 604         if (ndr_flags & NDR_SCALARS) {
 605                 NDR_CHECK(ndr_pull_align(ndr, 4));
 606                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 607         }
 608         if (ndr_flags & NDR_BUFFERS) {
 609                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 610         }
 611         return NDR_ERR_SUCCESS;
 612 }
 613
 614 _PUBLIC_ void ndr_print_samr_DomInfo5(struct ndr_print *ndr, const char *name, const struct samr_DomInfo5 *r)
 615 {
 616         ndr_print_struct(ndr, name, "samr_DomInfo5");
 617         ndr->depth++;
 618         ndr_print_lsa_String(ndr, "domain_name", &r->domain_name);
 619         ndr->depth--;
 620 }
 621
 622 static enum ndr_err_code ndr_push_samr_DomInfo6(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo6 *r)
 623 {
 624         if (ndr_flags & NDR_SCALARS) {
 625                 NDR_CHECK(ndr_push_align(ndr, 4));
 626                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->primary));
 627         }
 628         if (ndr_flags & NDR_BUFFERS) {
 629                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 630         }
 631         return NDR_ERR_SUCCESS;
 632 }
 633
 634 static enum ndr_err_code ndr_pull_samr_DomInfo6(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo6 *r)
 635 {
 636         if (ndr_flags & NDR_SCALARS) {
 637                 NDR_CHECK(ndr_pull_align(ndr, 4));
 638                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->primary));
 639         }
 640         if (ndr_flags & NDR_BUFFERS) {
 641                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 642         }
 643         return NDR_ERR_SUCCESS;
 644 }
 645
 646 _PUBLIC_ void ndr_print_samr_DomInfo6(struct ndr_print *ndr, const char *name, const struct samr_DomInfo6 *r)
 647 {
 648         ndr_print_struct(ndr, name, "samr_DomInfo6");
 649         ndr->depth++;
 650         ndr_print_lsa_String(ndr, "primary", &r->primary);
 651         ndr->depth--;
 652 }
 653
 654 static enum ndr_err_code ndr_push_samr_DomInfo7(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo7 *r)
 655 {
 656         if (ndr_flags & NDR_SCALARS) {
 657                 NDR_CHECK(ndr_push_align(ndr, 4));
 658                 NDR_CHECK(ndr_push_samr_Role(ndr, NDR_SCALARS, r->role));
 659         }
 660         if (ndr_flags & NDR_BUFFERS) {
 661         }
 662         return NDR_ERR_SUCCESS;
 663 }
 664
 665 static enum ndr_err_code ndr_pull_samr_DomInfo7(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo7 *r)
 666 {
 667         if (ndr_flags & NDR_SCALARS) {
 668                 NDR_CHECK(ndr_pull_align(ndr, 4));
 669                 NDR_CHECK(ndr_pull_samr_Role(ndr, NDR_SCALARS, &r->role));
 670         }
 671         if (ndr_flags & NDR_BUFFERS) {
 672         }
 673         return NDR_ERR_SUCCESS;
 674 }
 675
 676 _PUBLIC_ void ndr_print_samr_DomInfo7(struct ndr_print *ndr, const char *name, const struct samr_DomInfo7 *r)
 677 {
 678         ndr_print_struct(ndr, name, "samr_DomInfo7");
 679         ndr->depth++;
 680         ndr_print_samr_Role(ndr, "role", r->role);
 681         ndr->depth--;
 682 }
 683
 684 static enum ndr_err_code ndr_push_samr_DomInfo8(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo8 *r)
 685 {
 686         if (ndr_flags & NDR_SCALARS) {
 687                 NDR_CHECK(ndr_push_align(ndr, 8));
 688                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->sequence_num));
 689                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->domain_create_time));
 690         }
 691         if (ndr_flags & NDR_BUFFERS) {
 692         }
 693         return NDR_ERR_SUCCESS;
 694 }
 695
 696 static enum ndr_err_code ndr_pull_samr_DomInfo8(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo8 *r)
 697 {
 698         if (ndr_flags & NDR_SCALARS) {
 699                 NDR_CHECK(ndr_pull_align(ndr, 8));
 700                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->sequence_num));
 701                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->domain_create_time));
 702         }
 703         if (ndr_flags & NDR_BUFFERS) {
 704         }
 705         return NDR_ERR_SUCCESS;
 706 }
 707
 708 _PUBLIC_ void ndr_print_samr_DomInfo8(struct ndr_print *ndr, const char *name, const struct samr_DomInfo8 *r)
 709 {
 710         ndr_print_struct(ndr, name, "samr_DomInfo8");
 711         ndr->depth++;
 712         ndr_print_hyper(ndr, "sequence_num", r->sequence_num);
 713         ndr_print_NTTIME(ndr, "domain_create_time", r->domain_create_time);
 714         ndr->depth--;
 715 }
 716
 717 static enum ndr_err_code ndr_push_samr_DomInfo9(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo9 *r)
 718 {
 719         if (ndr_flags & NDR_SCALARS) {
 720                 NDR_CHECK(ndr_push_align(ndr, 4));
 721                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
 722         }
 723         if (ndr_flags & NDR_BUFFERS) {
 724         }
 725         return NDR_ERR_SUCCESS;
 726 }
 727
 728 static enum ndr_err_code ndr_pull_samr_DomInfo9(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo9 *r)
 729 {
 730         if (ndr_flags & NDR_SCALARS) {
 731                 NDR_CHECK(ndr_pull_align(ndr, 4));
 732                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
 733         }
 734         if (ndr_flags & NDR_BUFFERS) {
 735         }
 736         return NDR_ERR_SUCCESS;
 737 }
 738
 739 _PUBLIC_ void ndr_print_samr_DomInfo9(struct ndr_print *ndr, const char *name, const struct samr_DomInfo9 *r)
 740 {
 741         ndr_print_struct(ndr, name, "samr_DomInfo9");
 742         ndr->depth++;
 743         ndr_print_uint32(ndr, "unknown", r->unknown);
 744         ndr->depth--;
 745 }
 746
 747 static enum ndr_err_code ndr_push_samr_DomGeneralInformation2(struct ndr_push *ndr, int ndr_flags, const struct samr_DomGeneralInformation2 *r)
 748 {
 749         if (ndr_flags & NDR_SCALARS) {
 750                 NDR_CHECK(ndr_push_align(ndr, 8));
 751                 NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 752                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_duration));
 753                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_window));
 754                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lockout_threshold));
 755         }
 756         if (ndr_flags & NDR_BUFFERS) {
 757                 NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
 758         }
 759         return NDR_ERR_SUCCESS;
 760 }
 761
 762 static enum ndr_err_code ndr_pull_samr_DomGeneralInformation2(struct ndr_pull *ndr, int ndr_flags, struct samr_DomGeneralInformation2 *r)
 763 {
 764         if (ndr_flags & NDR_SCALARS) {
 765                 NDR_CHECK(ndr_pull_align(ndr, 8));
 766                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 767                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_duration));
 768                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_window));
 769                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lockout_threshold));
 770         }
 771         if (ndr_flags & NDR_BUFFERS) {
 772                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
 773         }
 774         return NDR_ERR_SUCCESS;
 775 }
 776
 777 _PUBLIC_ void ndr_print_samr_DomGeneralInformation2(struct ndr_print *ndr, const char *name, const struct samr_DomGeneralInformation2 *r)
 778 {
 779         ndr_print_struct(ndr, name, "samr_DomGeneralInformation2");
 780         ndr->depth++;
 781         ndr_print_samr_DomGeneralInformation(ndr, "general", &r->general);
 782         ndr_print_hyper(ndr, "lockout_duration", r->lockout_duration);
 783         ndr_print_hyper(ndr, "lockout_window", r->lockout_window);
 784         ndr_print_uint16(ndr, "lockout_threshold", r->lockout_threshold);
 785         ndr->depth--;
 786 }
 787
 788 static enum ndr_err_code ndr_push_samr_DomInfo12(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo12 *r)
 789 {
 790         if (ndr_flags & NDR_SCALARS) {
 791                 NDR_CHECK(ndr_push_align(ndr, 8));
 792                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_duration));
 793                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_window));
 794                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lockout_threshold));
 795         }
 796         if (ndr_flags & NDR_BUFFERS) {
 797         }
 798         return NDR_ERR_SUCCESS;
 799 }
 800
 801 static enum ndr_err_code ndr_pull_samr_DomInfo12(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo12 *r)
 802 {
 803         if (ndr_flags & NDR_SCALARS) {
 804                 NDR_CHECK(ndr_pull_align(ndr, 8));
 805                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_duration));
 806                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_window));
 807                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lockout_threshold));
 808         }
 809         if (ndr_flags & NDR_BUFFERS) {
 810         }
 811         return NDR_ERR_SUCCESS;
 812 }
 813
 814 _PUBLIC_ void ndr_print_samr_DomInfo12(struct ndr_print *ndr, const char *name, const struct samr_DomInfo12 *r)
 815 {
 816         ndr_print_struct(ndr, name, "samr_DomInfo12");
 817         ndr->depth++;
 818         ndr_print_hyper(ndr, "lockout_duration", r->lockout_duration);
 819         ndr_print_hyper(ndr, "lockout_window", r->lockout_window);
 820         ndr_print_uint16(ndr, "lockout_threshold", r->lockout_threshold);
 821         ndr->depth--;
 822 }
 823
 824 static enum ndr_err_code ndr_push_samr_DomInfo13(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo13 *r)
 825 {
 826         if (ndr_flags & NDR_SCALARS) {
 827                 NDR_CHECK(ndr_push_align(ndr, 8));
 828                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->sequence_num));
 829                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->domain_create_time));
 830                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
 831                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
 832         }
 833         if (ndr_flags & NDR_BUFFERS) {
 834         }
 835         return NDR_ERR_SUCCESS;
 836 }
 837
 838 static enum ndr_err_code ndr_pull_samr_DomInfo13(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo13 *r)
 839 {
 840         if (ndr_flags & NDR_SCALARS) {
 841                 NDR_CHECK(ndr_pull_align(ndr, 8));
 842                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->sequence_num));
 843                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->domain_create_time));
 844                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
 845                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
 846         }
 847         if (ndr_flags & NDR_BUFFERS) {
 848         }
 849         return NDR_ERR_SUCCESS;
 850 }
 851
 852 _PUBLIC_ void ndr_print_samr_DomInfo13(struct ndr_print *ndr, const char *name, const struct samr_DomInfo13 *r)
 853 {
 854         ndr_print_struct(ndr, name, "samr_DomInfo13");
 855         ndr->depth++;
 856         ndr_print_hyper(ndr, "sequence_num", r->sequence_num);
 857         ndr_print_NTTIME(ndr, "domain_create_time", r->domain_create_time);
 858         ndr_print_uint32(ndr, "unknown1", r->unknown1);
 859         ndr_print_uint32(ndr, "unknown2", r->unknown2);
 860         ndr->depth--;
 861 }
 862
 863 static enum ndr_err_code ndr_push_samr_DomainInfo(struct ndr_push *ndr, int ndr_flags, const union samr_DomainInfo *r)
 864 {
 865         if (ndr_flags & NDR_SCALARS) {
 866                 int level = ndr_push_get_switch_value(ndr, r);
 867                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
 868                 switch (level) {
 869                         case 1: {
 870                                 NDR_CHECK(ndr_push_samr_DomInfo1(ndr, NDR_SCALARS, &r->info1));
 871                         break; }
 872
 873                         case 2: {
 874                                 NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 875                         break; }
 876
 877                         case 3: {
 878                                 NDR_CHECK(ndr_push_samr_DomInfo3(ndr, NDR_SCALARS, &r->info3));
 879                         break; }
 880
 881                         case 4: {
 882                                 NDR_CHECK(ndr_push_samr_DomOEMInformation(ndr, NDR_SCALARS, &r->oem));
 883                         break; }
 884
 885                         case 5: {
 886                                 NDR_CHECK(ndr_push_samr_DomInfo5(ndr, NDR_SCALARS, &r->info5));
 887                         break; }
 888
 889                         case 6: {
 890                                 NDR_CHECK(ndr_push_samr_DomInfo6(ndr, NDR_SCALARS, &r->info6));
 891                         break; }
 892
 893                         case 7: {
 894                                 NDR_CHECK(ndr_push_samr_DomInfo7(ndr, NDR_SCALARS, &r->info7));
 895                         break; }
 896
 897                         case 8: {
 898                                 NDR_CHECK(ndr_push_samr_DomInfo8(ndr, NDR_SCALARS, &r->info8));
 899                         break; }
 900
 901                         case 9: {
 902                                 NDR_CHECK(ndr_push_samr_DomInfo9(ndr, NDR_SCALARS, &r->info9));
 903                         break; }
 904
 905                         case 11: {
 906                                 NDR_CHECK(ndr_push_samr_DomGeneralInformation2(ndr, NDR_SCALARS, &r->general2));
 907                         break; }
 908
 909                         case 12: {
 910                                 NDR_CHECK(ndr_push_samr_DomInfo12(ndr, NDR_SCALARS, &r->info12));
 911                         break; }
 912
 913                         case 13: {
 914                                 NDR_CHECK(ndr_push_samr_DomInfo13(ndr, NDR_SCALARS, &r->info13));
 915                         break; }
 916
 917                         default:
 918                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 919                 }
 920         }
 921         if (ndr_flags & NDR_BUFFERS) {
 922                 int level = ndr_push_get_switch_value(ndr, r);
 923                 switch (level) {
 924                         case 1:
 925                         break;
 926
 927                         case 2:
 928                                 NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
 929                         break;
 930
 931                         case 3:
 932                         break;
 933
 934                         case 4:
 935                                 NDR_CHECK(ndr_push_samr_DomOEMInformation(ndr, NDR_BUFFERS, &r->oem));
 936                         break;
 937
 938                         case 5:
 939                                 NDR_CHECK(ndr_push_samr_DomInfo5(ndr, NDR_BUFFERS, &r->info5));
 940                         break;
 941
 942                         case 6:
 943                                 NDR_CHECK(ndr_push_samr_DomInfo6(ndr, NDR_BUFFERS, &r->info6));
 944                         break;
 945
 946                         case 7:
 947                         break;
 948
 949                         case 8:
 950                         break;
 951
 952                         case 9:
 953                         break;
 954
 955                         case 11:
 956                                 NDR_CHECK(ndr_push_samr_DomGeneralInformation2(ndr, NDR_BUFFERS, &r->general2));
 957                         break;
 958
 959                         case 12:
 960                         break;
 961
 962                         case 13:
 963                         break;
 964
 965                         default:
 966                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 967                 }
 968         }
 969         return NDR_ERR_SUCCESS;
 970 }
 971
 972 static enum ndr_err_code ndr_pull_samr_DomainInfo(struct ndr_pull *ndr, int ndr_flags, union samr_DomainInfo *r)
 973 {
 974         int level;
 975         uint16_t _level;
 976         level = ndr_pull_get_switch_value(ndr, r);
 977         if (ndr_flags & NDR_SCALARS) {
 978                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
 979                 if (_level != level) {
 980                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
 981                 }
 982                 switch (level) {
 983                         case 1: {
 984                                 NDR_CHECK(ndr_pull_samr_DomInfo1(ndr, NDR_SCALARS, &r->info1));
 985                         break; }
 986
 987                         case 2: {
 988                                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 989                         break; }
 990
 991                         case 3: {
 992                                 NDR_CHECK(ndr_pull_samr_DomInfo3(ndr, NDR_SCALARS, &r->info3));
 993                         break; }
 994
 995                         case 4: {
 996                                 NDR_CHECK(ndr_pull_samr_DomOEMInformation(ndr, NDR_SCALARS, &r->oem));
 997                         break; }
 998
 999                         case 5: {
1000                                 NDR_CHECK(ndr_pull_samr_DomInfo5(ndr, NDR_SCALARS, &r->info5));
1001                         break; }
1002
1003                         case 6: {
1004                                 NDR_CHECK(ndr_pull_samr_DomInfo6(ndr, NDR_SCALARS, &r->info6));
1005                         break; }
1006
1007                         case 7: {
1008                                 NDR_CHECK(ndr_pull_samr_DomInfo7(ndr, NDR_SCALARS, &r->info7));
1009                         break; }
1010
1011                         case 8: {
1012                                 NDR_CHECK(ndr_pull_samr_DomInfo8(ndr, NDR_SCALARS, &r->info8));
1013                         break; }
1014
1015                         case 9: {
1016                                 NDR_CHECK(ndr_pull_samr_DomInfo9(ndr, NDR_SCALARS, &r->info9));
1017                         break; }
1018
1019                         case 11: {
1020                                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation2(ndr, NDR_SCALARS, &r->general2));
1021                         break; }
1022
1023                         case 12: {
1024                                 NDR_CHECK(ndr_pull_samr_DomInfo12(ndr, NDR_SCALARS, &r->info12));
1025                         break; }
1026
1027                         case 13: {
1028                                 NDR_CHECK(ndr_pull_samr_DomInfo13(ndr, NDR_SCALARS, &r->info13));
1029                         break; }
1030
1031                         default:
1032                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1033                 }
1034         }
1035         if (ndr_flags & NDR_BUFFERS) {
1036                 switch (level) {
1037                         case 1:
1038                         break;
1039
1040                         case 2:
1041                                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
1042                         break;
1043
1044                         case 3:
1045                         break;
1046
1047                         case 4:
1048                                 NDR_CHECK(ndr_pull_samr_DomOEMInformation(ndr, NDR_BUFFERS, &r->oem));
1049                         break;
1050
1051                         case 5:
1052                                 NDR_CHECK(ndr_pull_samr_DomInfo5(ndr, NDR_BUFFERS, &r->info5));
1053                         break;
1054
1055                         case 6:
1056                                 NDR_CHECK(ndr_pull_samr_DomInfo6(ndr, NDR_BUFFERS, &r->info6));
1057                         break;
1058
1059                         case 7:
1060                         break;
1061
1062                         case 8:
1063                         break;
1064
1065                         case 9:
1066                         break;
1067
1068                         case 11:
1069                                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation2(ndr, NDR_BUFFERS, &r->general2));
1070                         break;
1071
1072                         case 12:
1073                         break;
1074
1075                         case 13:
1076                         break;
1077
1078                         default:
1079                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1080                 }
1081         }
1082         return NDR_ERR_SUCCESS;
1083 }
1084
1085 _PUBLIC_ void ndr_print_samr_DomainInfo(struct ndr_print *ndr, const char *name, const union samr_DomainInfo *r)
1086 {
1087         int level;
1088         level = ndr_print_get_switch_value(ndr, r);
1089         ndr_print_union(ndr, name, level, "samr_DomainInfo");
1090         switch (level) {
1091                 case 1:
1092                         ndr_print_samr_DomInfo1(ndr, "info1", &r->info1);
1093                 break;
1094
1095                 case 2:
1096                         ndr_print_samr_DomGeneralInformation(ndr, "general", &r->general);
1097                 break;
1098
1099                 case 3:
1100                         ndr_print_samr_DomInfo3(ndr, "info3", &r->info3);
1101                 break;
1102
1103                 case 4:
1104                         ndr_print_samr_DomOEMInformation(ndr, "oem", &r->oem);
1105                 break;
1106
1107                 case 5:
1108                         ndr_print_samr_DomInfo5(ndr, "info5", &r->info5);
1109                 break;
1110
1111                 case 6:
1112                         ndr_print_samr_DomInfo6(ndr, "info6", &r->info6);
1113                 break;
1114
1115                 case 7:
1116                         ndr_print_samr_DomInfo7(ndr, "info7", &r->info7);
1117                 break;
1118
1119                 case 8:
1120                         ndr_print_samr_DomInfo8(ndr, "info8", &r->info8);
1121                 break;
1122
1123                 case 9:
1124                         ndr_print_samr_DomInfo9(ndr, "info9", &r->info9);
1125                 break;
1126
1127                 case 11:
1128                         ndr_print_samr_DomGeneralInformation2(ndr, "general2", &r->general2);
1129                 break;
1130
1131                 case 12:
1132                         ndr_print_samr_DomInfo12(ndr, "info12", &r->info12);
1133                 break;
1134
1135                 case 13:
1136                         ndr_print_samr_DomInfo13(ndr, "info13", &r->info13);
1137                 break;
1138
1139                 default:
1140                         ndr_print_bad_level(ndr, name, level);
1141         }
1142 }
1143
1144 static enum ndr_err_code ndr_push_samr_Ids(struct ndr_push *ndr, int ndr_flags, const struct samr_Ids *r)
1145 {
1146         uint32_t cntr_ids_1;
1147         if (ndr_flags & NDR_SCALARS) {
1148                 NDR_CHECK(ndr_push_align(ndr, 4));
1149                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1150                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ids));
1151         }
1152         if (ndr_flags & NDR_BUFFERS) {
1153                 if (r->ids) {
1154                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1155                         for (cntr_ids_1 = 0; cntr_ids_1 < r->count; cntr_ids_1++) {
1156                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ids[cntr_ids_1]));
1157                         }
1158                 }
1159         }
1160         return NDR_ERR_SUCCESS;
1161 }
1162
1163 static enum ndr_err_code ndr_pull_samr_Ids(struct ndr_pull *ndr, int ndr_flags, struct samr_Ids *r)
1164 {
1165         uint32_t _ptr_ids;
1166         uint32_t cntr_ids_1;
1167         TALLOC_CTX *_mem_save_ids_0;
1168         TALLOC_CTX *_mem_save_ids_1;
1169         if (ndr_flags & NDR_SCALARS) {
1170                 NDR_CHECK(ndr_pull_align(ndr, 4));
1171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1172                 if (r->count < 0 || r->count > 1024) {
1173                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1174                 }
1175                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ids));
1176                 if (_ptr_ids) {
1177                         NDR_PULL_ALLOC(ndr, r->ids);
1178                 } else {
1179                         r->ids = NULL;
1180                 }
1181         }
1182         if (ndr_flags & NDR_BUFFERS) {
1183                 if (r->ids) {
1184                         _mem_save_ids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1185                         NDR_PULL_SET_MEM_CTX(ndr, r->ids, 0);
1186                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ids));
1187                         NDR_PULL_ALLOC_N(ndr, r->ids, ndr_get_array_size(ndr, &r->ids));
1188                         _mem_save_ids_1 = NDR_PULL_GET_MEM_CTX(ndr);
1189                         NDR_PULL_SET_MEM_CTX(ndr, r->ids, 0);
1190                         for (cntr_ids_1 = 0; cntr_ids_1 < r->count; cntr_ids_1++) {
1191                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ids[cntr_ids_1]));
1192                         }
1193                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ids_1, 0);
1194                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ids_0, 0);
1195                 }
1196                 if (r->ids) {
1197                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->ids, r->count));
1198                 }
1199         }
1200         return NDR_ERR_SUCCESS;
1201 }
1202
1203 _PUBLIC_ void ndr_print_samr_Ids(struct ndr_print *ndr, const char *name, const struct samr_Ids *r)
1204 {
1205         uint32_t cntr_ids_1;
1206         ndr_print_struct(ndr, name, "samr_Ids");
1207         ndr->depth++;
1208         ndr_print_uint32(ndr, "count", r->count);
1209         ndr_print_ptr(ndr, "ids", r->ids);
1210         ndr->depth++;
1211         if (r->ids) {
1212                 ndr->print(ndr, "%s: ARRAY(%d)", "ids", (int)r->count);
1213                 ndr->depth++;
1214                 for (cntr_ids_1=0;cntr_ids_1<r->count;cntr_ids_1++) {
1215                         char *idx_1=NULL;
1216                         if (asprintf(&idx_1, "[%d]", cntr_ids_1) != -1) {
1217                                 ndr_print_uint32(ndr, "ids", r->ids[cntr_ids_1]);
1218                                 free(idx_1);
1219                         }
1220                 }
1221                 ndr->depth--;
1222         }
1223         ndr->depth--;
1224         ndr->depth--;
1225 }
1226
1227 _PUBLIC_ enum ndr_err_code ndr_push_samr_GroupAttrs(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1228 {
1229         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1230         return NDR_ERR_SUCCESS;
1231 }
1232
1233 _PUBLIC_ enum ndr_err_code ndr_pull_samr_GroupAttrs(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1234 {
1235         uint32_t v;
1236         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1237         *r = v;
1238         return NDR_ERR_SUCCESS;
1239 }
1240
1241 _PUBLIC_ void ndr_print_samr_GroupAttrs(struct ndr_print *ndr, const char *name, uint32_t r)
1242 {
1243         ndr_print_uint32(ndr, name, r);
1244         ndr->depth++;
1245         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_MANDATORY", SE_GROUP_MANDATORY, r);
1246         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_ENABLED_BY_DEFAULT", SE_GROUP_ENABLED_BY_DEFAULT, r);
1247         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_ENABLED", SE_GROUP_ENABLED, r);
1248         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_OWNER", SE_GROUP_OWNER, r);
1249         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_USE_FOR_DENY_ONLY", SE_GROUP_USE_FOR_DENY_ONLY, r);
1250         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_RESOURCE", SE_GROUP_RESOURCE, r);
1251         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_LOGON_ID", SE_GROUP_LOGON_ID, r);
1252         ndr->depth--;
1253 }
1254
1255 static enum ndr_err_code ndr_push_samr_GroupInfoAll(struct ndr_push *ndr, int ndr_flags, const struct samr_GroupInfoAll *r)
1256 {
1257         if (ndr_flags & NDR_SCALARS) {
1258                 NDR_CHECK(ndr_push_align(ndr, 4));
1259                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1260                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
1261                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_members));
1262                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1263         }
1264         if (ndr_flags & NDR_BUFFERS) {
1265                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1266                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1267         }
1268         return NDR_ERR_SUCCESS;
1269 }
1270
1271 static enum ndr_err_code ndr_pull_samr_GroupInfoAll(struct ndr_pull *ndr, int ndr_flags, struct samr_GroupInfoAll *r)
1272 {
1273         if (ndr_flags & NDR_SCALARS) {
1274                 NDR_CHECK(ndr_pull_align(ndr, 4));
1275                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1276                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
1277                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_members));
1278                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1279         }
1280         if (ndr_flags & NDR_BUFFERS) {
1281                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1282                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1283         }
1284         return NDR_ERR_SUCCESS;
1285 }
1286
1287 _PUBLIC_ void ndr_print_samr_GroupInfoAll(struct ndr_print *ndr, const char *name, const struct samr_GroupInfoAll *r)
1288 {
1289         ndr_print_struct(ndr, name, "samr_GroupInfoAll");
1290         ndr->depth++;
1291         ndr_print_lsa_String(ndr, "name", &r->name);
1292         ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);
1293         ndr_print_uint32(ndr, "num_members", r->num_members);
1294         ndr_print_lsa_String(ndr, "description", &r->description);
1295         ndr->depth--;
1296 }
1297
1298 static enum ndr_err_code ndr_push_samr_GroupInfoAttributes(struct ndr_push *ndr, int ndr_flags, const struct samr_GroupInfoAttributes *r)
1299 {
1300         if (ndr_flags & NDR_SCALARS) {
1301                 NDR_CHECK(ndr_push_align(ndr, 4));
1302                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
1303         }
1304         if (ndr_flags & NDR_BUFFERS) {
1305         }
1306         return NDR_ERR_SUCCESS;
1307 }
1308
1309 static enum ndr_err_code ndr_pull_samr_GroupInfoAttributes(struct ndr_pull *ndr, int ndr_flags, struct samr_GroupInfoAttributes *r)
1310 {
1311         if (ndr_flags & NDR_SCALARS) {
1312                 NDR_CHECK(ndr_pull_align(ndr, 4));
1313                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
1314         }
1315         if (ndr_flags & NDR_BUFFERS) {
1316         }
1317         return NDR_ERR_SUCCESS;
1318 }
1319
1320 _PUBLIC_ void ndr_print_samr_GroupInfoAttributes(struct ndr_print *ndr, const char *name, const struct samr_GroupInfoAttributes *r)
1321 {
1322         ndr_print_struct(ndr, name, "samr_GroupInfoAttributes");
1323         ndr->depth++;
1324         ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);
1325         ndr->depth--;
1326 }
1327
1328 static enum ndr_err_code ndr_push_samr_GroupInfoEnum(struct ndr_push *ndr, int ndr_flags, enum samr_GroupInfoEnum r)
1329 {
1330         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
1331         return NDR_ERR_SUCCESS;
1332 }
1333
1334 static enum ndr_err_code ndr_pull_samr_GroupInfoEnum(struct ndr_pull *ndr, int ndr_flags, enum samr_GroupInfoEnum *r)
1335 {
1336         uint16_t v;
1337         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
1338         *r = v;
1339         return NDR_ERR_SUCCESS;
1340 }
1341
1342 _PUBLIC_ void ndr_print_samr_GroupInfoEnum(struct ndr_print *ndr, const char *name, enum samr_GroupInfoEnum r)
1343 {
1344         const char *val = NULL;
1345
1346         switch (r) {
1347                 case GROUPINFOALL: val = "GROUPINFOALL"; break;
1348                 case GROUPINFONAME: val = "GROUPINFONAME"; break;
1349                 case GROUPINFOATTRIBUTES: val = "GROUPINFOATTRIBUTES"; break;
1350                 case GROUPINFODESCRIPTION: val = "GROUPINFODESCRIPTION"; break;
1351                 case GROUPINFOALL2: val = "GROUPINFOALL2"; break;
1352         }
1353         ndr_print_enum(ndr, name, "ENUM", val, r);
1354 }
1355
1356 static enum ndr_err_code ndr_push_samr_GroupInfo(struct ndr_push *ndr, int ndr_flags, const union samr_GroupInfo *r)
1357 {
1358         if (ndr_flags & NDR_SCALARS) {
1359                 int level = ndr_push_get_switch_value(ndr, r);
1360                 NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, level));
1361                 switch (level) {
1362                         case GROUPINFOALL: {
1363                                 NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all));
1364                         break; }
1365
1366                         case GROUPINFONAME: {
1367                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1368                         break; }
1369
1370                         case GROUPINFOATTRIBUTES: {
1371                                 NDR_CHECK(ndr_push_samr_GroupInfoAttributes(ndr, NDR_SCALARS, &r->attributes));
1372                         break; }
1373
1374                         case GROUPINFODESCRIPTION: {
1375                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1376                         break; }
1377
1378                         case GROUPINFOALL2: {
1379                                 NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all2));
1380                         break; }
1381
1382                         default:
1383                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1384                 }
1385         }
1386         if (ndr_flags & NDR_BUFFERS) {
1387                 int level = ndr_push_get_switch_value(ndr, r);
1388                 switch (level) {
1389                         case GROUPINFOALL:
1390                                 NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all));
1391                         break;
1392
1393                         case GROUPINFONAME:
1394                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1395                         break;
1396
1397                         case GROUPINFOATTRIBUTES:
1398                         break;
1399
1400                         case GROUPINFODESCRIPTION:
1401                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1402                         break;
1403
1404                         case GROUPINFOALL2:
1405                                 NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all2));
1406                         break;
1407
1408                         default:
1409                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1410                 }
1411         }
1412         return NDR_ERR_SUCCESS;
1413 }
1414
1415 static enum ndr_err_code ndr_pull_samr_GroupInfo(struct ndr_pull *ndr, int ndr_flags, union samr_GroupInfo *r)
1416 {
1417         int level;
1418         uint16_t _level;
1419         level = ndr_pull_get_switch_value(ndr, r);
1420         if (ndr_flags & NDR_SCALARS) {
1421                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
1422                 if (_level != level) {
1423                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1424                 }
1425                 switch (level) {
1426                         case GROUPINFOALL: {
1427                                 NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all));
1428                         break; }
1429
1430                         case GROUPINFONAME: {
1431                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1432                         break; }
1433
1434                         case GROUPINFOATTRIBUTES: {
1435                                 NDR_CHECK(ndr_pull_samr_GroupInfoAttributes(ndr, NDR_SCALARS, &r->attributes));
1436                         break; }
1437
1438                         case GROUPINFODESCRIPTION: {
1439                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1440                         break; }
1441
1442                         case GROUPINFOALL2: {
1443                                 NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all2));
1444                         break; }
1445
1446                         default:
1447                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1448                 }
1449         }
1450         if (ndr_flags & NDR_BUFFERS) {
1451                 switch (level) {
1452                         case GROUPINFOALL:
1453                                 NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all));
1454                         break;
1455
1456                         case GROUPINFONAME:
1457                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1458                         break;
1459
1460                         case GROUPINFOATTRIBUTES:
1461                         break;
1462
1463                         case GROUPINFODESCRIPTION:
1464                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1465                         break;
1466
1467                         case GROUPINFOALL2:
1468                                 NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all2));
1469                         break;
1470
1471                         default:
1472                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1473                 }
1474         }
1475         return NDR_ERR_SUCCESS;
1476 }
1477
1478 _PUBLIC_ void ndr_print_samr_GroupInfo(struct ndr_print *ndr, const char *name, const union samr_GroupInfo *r)
1479 {
1480         int level;
1481         level = ndr_print_get_switch_value(ndr, r);
1482         ndr_print_union(ndr, name, level, "samr_GroupInfo");
1483         switch (level) {
1484                 case GROUPINFOALL:
1485                         ndr_print_samr_GroupInfoAll(ndr, "all", &r->all);
1486                 break;
1487
1488                 case GROUPINFONAME:
1489                         ndr_print_lsa_String(ndr, "name", &r->name);
1490                 break;
1491
1492                 case GROUPINFOATTRIBUTES:
1493                         ndr_print_samr_GroupInfoAttributes(ndr, "attributes", &r->attributes);
1494                 break;
1495
1496                 case GROUPINFODESCRIPTION:
1497                         ndr_print_lsa_String(ndr, "description", &r->description);
1498                 break;
1499
1500                 case GROUPINFOALL2:
1501                         ndr_print_samr_GroupInfoAll(ndr, "all2", &r->all2);
1502                 break;
1503
1504                 default:
1505                         ndr_print_bad_level(ndr, name, level);
1506         }
1507 }
1508
1509 static enum ndr_err_code ndr_push_samr_RidTypeArray(struct ndr_push *ndr, int ndr_flags, const struct samr_RidTypeArray *r)
1510 {
1511         uint32_t cntr_rids_1;
1512         uint32_t cntr_types_1;
1513         if (ndr_flags & NDR_SCALARS) {
1514                 NDR_CHECK(ndr_push_align(ndr, 4));
1515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1516                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->rids));
1517                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
1518         }
1519         if (ndr_flags & NDR_BUFFERS) {
1520                 if (r->rids) {
1521                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1522                         for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {
1523                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rids[cntr_rids_1]));
1524                         }
1525                 }
1526                 if (r->types) {
1527                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1528                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
1529                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->types[cntr_types_1]));
1530                         }
1531                 }
1532         }
1533         return NDR_ERR_SUCCESS;
1534 }
1535
1536 static enum ndr_err_code ndr_pull_samr_RidTypeArray(struct ndr_pull *ndr, int ndr_flags, struct samr_RidTypeArray *r)
1537 {
1538         uint32_t _ptr_rids;
1539         uint32_t cntr_rids_1;
1540         TALLOC_CTX *_mem_save_rids_0;
1541         TALLOC_CTX *_mem_save_rids_1;
1542         uint32_t _ptr_types;
1543         uint32_t cntr_types_1;
1544         TALLOC_CTX *_mem_save_types_0;
1545         TALLOC_CTX *_mem_save_types_1;
1546         if (ndr_flags & NDR_SCALARS) {
1547                 NDR_CHECK(ndr_pull_align(ndr, 4));
1548                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1549                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
1550                 if (_ptr_rids) {
1551                         NDR_PULL_ALLOC(ndr, r->rids);
1552                 } else {
1553                         r->rids = NULL;
1554                 }
1555                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
1556                 if (_ptr_types) {
1557                         NDR_PULL_ALLOC(ndr, r->types);
1558                 } else {
1559                         r->types = NULL;
1560                 }
1561         }
1562         if (ndr_flags & NDR_BUFFERS) {
1563                 if (r->rids) {
1564                         _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1565                         NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
1566                         NDR_CHECK(ndr_pull_array_size(ndr, &r->rids));
1567                         NDR_PULL_ALLOC_N(ndr, r->rids, ndr_get_array_size(ndr, &r->rids));
1568                         _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
1569                         NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
1570                         for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {
1571                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));
1572                         }
1573                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
1574                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
1575                 }
1576                 if (r->types) {
1577                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
1578                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
1579                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
1580                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
1581                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
1582                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
1583                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
1584                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
1585                         }
1586                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
1587                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
1588                 }
1589                 if (r->rids) {
1590                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->rids, r->count));
1591                 }
1592                 if (r->types) {
1593                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
1594                 }
1595         }
1596         return NDR_ERR_SUCCESS;
1597 }
1598
1599 _PUBLIC_ void ndr_print_samr_RidTypeArray(struct ndr_print *ndr, const char *name, const struct samr_RidTypeArray *r)
1600 {
1601         uint32_t cntr_rids_1;
1602         uint32_t cntr_types_1;
1603         ndr_print_struct(ndr, name, "samr_RidTypeArray");
1604         ndr->depth++;
1605         ndr_print_uint32(ndr, "count", r->count);
1606         ndr_print_ptr(ndr, "rids", r->rids);
1607         ndr->depth++;
1608         if (r->rids) {
1609                 ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->count);
1610                 ndr->depth++;
1611                 for (cntr_rids_1=0;cntr_rids_1<r->count;cntr_rids_1++) {
1612                         char *idx_1=NULL;
1613                         if (asprintf(&idx_1, "[%d]", cntr_rids_1) != -1) {
1614                                 ndr_print_uint32(ndr, "rids", r->rids[cntr_rids_1]);
1615                                 free(idx_1);
1616                         }
1617                 }
1618                 ndr->depth--;
1619         }
1620         ndr->depth--;
1621         ndr_print_ptr(ndr, "types", r->types);
1622         ndr->depth++;
1623         if (r->types) {
1624                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
1625                 ndr->depth++;
1626                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
1627                         char *idx_1=NULL;
1628                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
1629                                 ndr_print_uint32(ndr, "types", r->types[cntr_types_1]);
1630                                 free(idx_1);
1631                         }
1632                 }
1633                 ndr->depth--;
1634         }
1635         ndr->depth--;
1636         ndr->depth--;
1637 }
1638
1639 static enum ndr_err_code ndr_push_samr_AliasInfoAll(struct ndr_push *ndr, int ndr_flags, const struct samr_AliasInfoAll *r)
1640 {
1641         if (ndr_flags & NDR_SCALARS) {
1642                 NDR_CHECK(ndr_push_align(ndr, 4));
1643                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1644                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_members));
1645                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1646         }
1647         if (ndr_flags & NDR_BUFFERS) {
1648                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1649                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1650         }
1651         return NDR_ERR_SUCCESS;
1652 }
1653
1654 static enum ndr_err_code ndr_pull_samr_AliasInfoAll(struct ndr_pull *ndr, int ndr_flags, struct samr_AliasInfoAll *r)
1655 {
1656         if (ndr_flags & NDR_SCALARS) {
1657                 NDR_CHECK(ndr_pull_align(ndr, 4));
1658                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1659                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_members));
1660                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1661         }
1662         if (ndr_flags & NDR_BUFFERS) {
1663                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1664                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1665         }
1666         return NDR_ERR_SUCCESS;
1667 }
1668
1669 _PUBLIC_ void ndr_print_samr_AliasInfoAll(struct ndr_print *ndr, const char *name, const struct samr_AliasInfoAll *r)
1670 {
1671         ndr_print_struct(ndr, name, "samr_AliasInfoAll");
1672         ndr->depth++;
1673         ndr_print_lsa_String(ndr, "name", &r->name);
1674         ndr_print_uint32(ndr, "num_members", r->num_members);
1675         ndr_print_lsa_String(ndr, "description", &r->description);
1676         ndr->depth--;
1677 }
1678
1679 static enum ndr_err_code ndr_push_samr_AliasInfoEnum(struct ndr_push *ndr, int ndr_flags, enum samr_AliasInfoEnum r)
1680 {
1681         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
1682         return NDR_ERR_SUCCESS;
1683 }
1684
1685 static enum ndr_err_code ndr_pull_samr_AliasInfoEnum(struct ndr_pull *ndr, int ndr_flags, enum samr_AliasInfoEnum *r)
1686 {
1687         uint16_t v;
1688         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
1689         *r = v;
1690         return NDR_ERR_SUCCESS;
1691 }
1692
1693 _PUBLIC_ void ndr_print_samr_AliasInfoEnum(struct ndr_print *ndr, const char *name, enum samr_AliasInfoEnum r)
1694 {
1695         const char *val = NULL;
1696
1697         switch (r) {
1698                 case ALIASINFOALL: val = "ALIASINFOALL"; break;
1699                 case ALIASINFONAME: val = "ALIASINFONAME"; break;
1700                 case ALIASINFODESCRIPTION: val = "ALIASINFODESCRIPTION"; break;
1701         }
1702         ndr_print_enum(ndr, name, "ENUM", val, r);
1703 }
1704
1705 static enum ndr_err_code ndr_push_samr_AliasInfo(struct ndr_push *ndr, int ndr_flags, const union samr_AliasInfo *r)
1706 {
1707         if (ndr_flags & NDR_SCALARS) {
1708                 int level = ndr_push_get_switch_value(ndr, r);
1709                 NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, level));
1710                 switch (level) {
1711                         case ALIASINFOALL: {
1712                                 NDR_CHECK(ndr_push_samr_AliasInfoAll(ndr, NDR_SCALARS, &r->all));
1713                         break; }
1714
1715                         case ALIASINFONAME: {
1716                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1717                         break; }
1718
1719                         case ALIASINFODESCRIPTION: {
1720                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1721                         break; }
1722
1723                         default:
1724                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1725                 }
1726         }
1727         if (ndr_flags & NDR_BUFFERS) {
1728                 int level = ndr_push_get_switch_value(ndr, r);
1729                 switch (level) {
1730                         case ALIASINFOALL:
1731                                 NDR_CHECK(ndr_push_samr_AliasInfoAll(ndr, NDR_BUFFERS, &r->all));
1732                         break;
1733
1734                         case ALIASINFONAME:
1735                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1736                         break;
1737
1738                         case ALIASINFODESCRIPTION:
1739                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1740                         break;
1741
1742                         default:
1743                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1744                 }
1745         }
1746         return NDR_ERR_SUCCESS;
1747 }
1748
1749 static enum ndr_err_code ndr_pull_samr_AliasInfo(struct ndr_pull *ndr, int ndr_flags, union samr_AliasInfo *r)
1750 {
1751         int level;
1752         uint16_t _level;
1753         level = ndr_pull_get_switch_value(ndr, r);
1754         if (ndr_flags & NDR_SCALARS) {
1755                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
1756                 if (_level != level) {
1757                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1758                 }
1759                 switch (level) {
1760                         case ALIASINFOALL: {
1761                                 NDR_CHECK(ndr_pull_samr_AliasInfoAll(ndr, NDR_SCALARS, &r->all));
1762                         break; }
1763
1764                         case ALIASINFONAME: {
1765                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1766                         break; }
1767
1768                         case ALIASINFODESCRIPTION: {
1769                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1770                         break; }
1771
1772                         default:
1773                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1774                 }
1775         }
1776         if (ndr_flags & NDR_BUFFERS) {
1777                 switch (level) {
1778                         case ALIASINFOALL:
1779                                 NDR_CHECK(ndr_pull_samr_AliasInfoAll(ndr, NDR_BUFFERS, &r->all));
1780                         break;
1781
1782                         case ALIASINFONAME:
1783                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1784                         break;
1785
1786                         case ALIASINFODESCRIPTION:
1787                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1788                         break;
1789
1790                         default:
1791                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1792                 }
1793         }
1794         return NDR_ERR_SUCCESS;
1795 }
1796
1797 _PUBLIC_ void ndr_print_samr_AliasInfo(struct ndr_print *ndr, const char *name, const union samr_AliasInfo *r)
1798 {
1799         int level;
1800         level = ndr_print_get_switch_value(ndr, r);
1801         ndr_print_union(ndr, name, level, "samr_AliasInfo");
1802         switch (level) {
1803                 case ALIASINFOALL:
1804                         ndr_print_samr_AliasInfoAll(ndr, "all", &r->all);
1805                 break;
1806
1807                 case ALIASINFONAME:
1808                         ndr_print_lsa_String(ndr, "name", &r->name);
1809                 break;
1810
1811                 case ALIASINFODESCRIPTION:
1812                         ndr_print_lsa_String(ndr, "description", &r->description);
1813                 break;
1814
1815                 default:
1816                         ndr_print_bad_level(ndr, name, level);
1817         }
1818 }
1819
1820 static enum ndr_err_code ndr_push_samr_UserInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo1 *r)
1821 {
1822         if (ndr_flags & NDR_SCALARS) {
1823                 NDR_CHECK(ndr_push_align(ndr, 4));
1824                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
1825                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
1826                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
1827                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1828                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));
1829         }
1830         if (ndr_flags & NDR_BUFFERS) {
1831                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
1832                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
1833                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1834                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));
1835         }
1836         return NDR_ERR_SUCCESS;
1837 }
1838
1839 static enum ndr_err_code ndr_pull_samr_UserInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo1 *r)
1840 {
1841         if (ndr_flags & NDR_SCALARS) {
1842                 NDR_CHECK(ndr_pull_align(ndr, 4));
1843                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
1844                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
1845                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
1846                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1847                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));
1848         }
1849         if (ndr_flags & NDR_BUFFERS) {
1850                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
1851                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
1852                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1853                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));
1854         }
1855         return NDR_ERR_SUCCESS;
1856 }
1857
1858 _PUBLIC_ void ndr_print_samr_UserInfo1(struct ndr_print *ndr, const char *name, const struct samr_UserInfo1 *r)
1859 {
1860         ndr_print_struct(ndr, name, "samr_UserInfo1");
1861         ndr->depth++;
1862         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
1863         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
1864         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
1865         ndr_print_lsa_String(ndr, "description", &r->description);
1866         ndr_print_lsa_String(ndr, "comment", &r->comment);
1867         ndr->depth--;
1868 }
1869
1870 static enum ndr_err_code ndr_push_samr_UserInfo2(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo2 *r)
1871 {
1872         if (ndr_flags & NDR_SCALARS) {
1873                 NDR_CHECK(ndr_push_align(ndr, 4));
1874                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));
1875                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->unknown));
1876                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->country_code));
1877                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->code_page));
1878         }
1879         if (ndr_flags & NDR_BUFFERS) {
1880                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));
1881                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->unknown));
1882         }
1883         return NDR_ERR_SUCCESS;
1884 }
1885
1886 static enum ndr_err_code ndr_pull_samr_UserInfo2(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo2 *r)
1887 {
1888         if (ndr_flags & NDR_SCALARS) {
1889                 NDR_CHECK(ndr_pull_align(ndr, 4));
1890                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));
1891                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->unknown));
1892                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->country_code));
1893                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->code_page));
1894         }
1895         if (ndr_flags & NDR_BUFFERS) {
1896                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));
1897                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->unknown));
1898         }
1899         return NDR_ERR_SUCCESS;
1900 }
1901
1902 _PUBLIC_ void ndr_print_samr_UserInfo2(struct ndr_print *ndr, const char *name, const struct samr_UserInfo2 *r)
1903 {
1904         ndr_print_struct(ndr, name, "samr_UserInfo2");
1905         ndr->depth++;
1906         ndr_print_lsa_String(ndr, "comment", &r->comment);
1907         ndr_print_lsa_String(ndr, "unknown", &r->unknown);
1908         ndr_print_uint16(ndr, "country_code", r->country_code);
1909         ndr_print_uint16(ndr, "code_page", r->code_page);
1910         ndr->depth--;
1911 }
1912
1913 _PUBLIC_ enum ndr_err_code ndr_push_samr_LogonHours(struct ndr_push *ndr, int ndr_flags, const struct samr_LogonHours *r)
1914 {
1915         {
1916                 uint32_t _flags_save_STRUCT = ndr->flags;
1917                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1918                 if (ndr_flags & NDR_SCALARS) {
1919                         NDR_CHECK(ndr_push_align(ndr, 4));
1920                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->units_per_week));
1921                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->bits));
1922                 }
1923                 if (ndr_flags & NDR_BUFFERS) {
1924                         if (r->bits) {
1925                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1260));
1926                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1927                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->units_per_week / 8));
1928                                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->bits, r->units_per_week / 8));
1929                         }
1930                 }
1931                 ndr->flags = _flags_save_STRUCT;
1932         }
1933         return NDR_ERR_SUCCESS;
1934 }
1935
1936 _PUBLIC_ enum ndr_err_code ndr_pull_samr_LogonHours(struct ndr_pull *ndr, int ndr_flags, struct samr_LogonHours *r)
1937 {
1938         uint32_t _ptr_bits;
1939         TALLOC_CTX *_mem_save_bits_0;
1940         {
1941                 uint32_t _flags_save_STRUCT = ndr->flags;
1942                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1943                 if (ndr_flags & NDR_SCALARS) {
1944                         NDR_CHECK(ndr_pull_align(ndr, 4));
1945                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->units_per_week));
1946                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bits));
1947                         if (_ptr_bits) {
1948                                 NDR_PULL_ALLOC(ndr, r->bits);
1949                         } else {
1950                                 r->bits = NULL;
1951                         }
1952                 }
1953                 if (ndr_flags & NDR_BUFFERS) {
1954                         if (r->bits) {
1955                                 _mem_save_bits_0 = NDR_PULL_GET_MEM_CTX(ndr);
1956                                 NDR_PULL_SET_MEM_CTX(ndr, r->bits, 0);
1957                                 NDR_CHECK(ndr_pull_array_size(ndr, &r->bits));
1958                                 NDR_CHECK(ndr_pull_array_length(ndr, &r->bits));
1959                                 if (ndr_get_array_length(ndr, &r->bits) > ndr_get_array_size(ndr, &r->bits)) {
1960                                         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));
1961                                 }
1962                                 NDR_PULL_ALLOC_N(ndr, r->bits, ndr_get_array_size(ndr, &r->bits));
1963                                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->bits, ndr_get_array_length(ndr, &r->bits)));
1964                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bits_0, 0);
1965                         }
1966                         if (r->bits) {
1967                                 NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->bits, 1260));
1968                         }
1969                         if (r->bits) {
1970                                 NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->bits, r->units_per_week / 8));
1971                         }
1972                 }
1973                 ndr->flags = _flags_save_STRUCT;
1974         }
1975         return NDR_ERR_SUCCESS;
1976 }
1977
1978 _PUBLIC_ void ndr_print_samr_LogonHours(struct ndr_print *ndr, const char *name, const struct samr_LogonHours *r)
1979 {
1980         ndr_print_struct(ndr, name, "samr_LogonHours");
1981         {
1982                 uint32_t _flags_save_STRUCT = ndr->flags;
1983                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1984                 ndr->depth++;
1985                 ndr_print_uint16(ndr, "units_per_week", r->units_per_week);
1986                 ndr_print_ptr(ndr, "bits", r->bits);
1987                 ndr->depth++;
1988                 if (r->bits) {
1989                         ndr_print_array_uint8(ndr, "bits", r->bits, r->units_per_week / 8);
1990                 }
1991                 ndr->depth--;
1992                 ndr->depth--;
1993                 ndr->flags = _flags_save_STRUCT;
1994         }
1995 }
1996
1997 static enum ndr_err_code ndr_push_samr_UserInfo3(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo3 *r)
1998 {
1999         if (ndr_flags & NDR_SCALARS) {
2000                 NDR_CHECK(ndr_push_align(ndr, 4));
2001                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2002                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2003                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
2004                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
2005                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2006                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2007                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2008                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2009                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2010                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));
2011                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));
2012                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));
2013                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->allow_password_change));
2014                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_password_change));
2015                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2016                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));
2017                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
2018                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
2019         }
2020         if (ndr_flags & NDR_BUFFERS) {
2021                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2022                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2023                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2024                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2025                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2026                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2027                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2028                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2029         }
2030         return NDR_ERR_SUCCESS;
2031 }
2032
2033 static enum ndr_err_code ndr_pull_samr_UserInfo3(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo3 *r)
2034 {
2035         if (ndr_flags & NDR_SCALARS) {
2036                 NDR_CHECK(ndr_pull_align(ndr, 4));
2037                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2038                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2039                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
2040                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
2041                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2042                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2043                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2044                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2045                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2046                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));
2047                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));
2048                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));
2049                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->allow_password_change));
2050                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_password_change));
2051                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2052                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));
2053                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
2054                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
2055         }
2056         if (ndr_flags & NDR_BUFFERS) {
2057                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2058                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2059                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2060                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2061                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2062                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2063                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2064                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2065         }
2066         return NDR_ERR_SUCCESS;
2067 }
2068
2069 _PUBLIC_ void ndr_print_samr_UserInfo3(struct ndr_print *ndr, const char *name, const struct samr_UserInfo3 *r)
2070 {
2071         ndr_print_struct(ndr, name, "samr_UserInfo3");
2072         ndr->depth++;
2073         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2074         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2075         ndr_print_uint32(ndr, "rid", r->rid);
2076         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
2077         ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
2078         ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
2079         ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
2080         ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
2081         ndr_print_lsa_String(ndr, "workstations", &r->workstations);
2082         ndr_print_NTTIME(ndr, "last_logon", r->last_logon);
2083         ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);
2084         ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);
2085         ndr_print_NTTIME(ndr, "allow_password_change", r->allow_password_change);
2086         ndr_print_NTTIME(ndr, "force_password_change", r->force_password_change);
2087         ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
2088         ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);
2089         ndr_print_uint16(ndr, "logon_count", r->logon_count);
2090         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
2091         ndr->depth--;
2092 }
2093
2094 static enum ndr_err_code ndr_push_samr_UserInfo4(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo4 *r)
2095 {
2096         if (ndr_flags & NDR_SCALARS) {
2097                 NDR_CHECK(ndr_push_align(ndr, 4));
2098                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2099         }
2100         if (ndr_flags & NDR_BUFFERS) {
2101                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2102         }
2103         return NDR_ERR_SUCCESS;
2104 }
2105
2106 static enum ndr_err_code ndr_pull_samr_UserInfo4(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo4 *r)
2107 {
2108         if (ndr_flags & NDR_SCALARS) {
2109                 NDR_CHECK(ndr_pull_align(ndr, 4));
2110                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2111         }
2112         if (ndr_flags & NDR_BUFFERS) {
2113                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2114         }
2115         return NDR_ERR_SUCCESS;
2116 }
2117
2118 _PUBLIC_ void ndr_print_samr_UserInfo4(struct ndr_print *ndr, const char *name, const struct samr_UserInfo4 *r)
2119 {
2120         ndr_print_struct(ndr, name, "samr_UserInfo4");
2121         ndr->depth++;
2122         ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
2123         ndr->depth--;
2124 }
2125
2126 static enum ndr_err_code ndr_push_samr_UserInfo5(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo5 *r)
2127 {
2128         if (ndr_flags & NDR_SCALARS) {
2129                 NDR_CHECK(ndr_push_align(ndr, 4));
2130                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2131                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2132                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
2133                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
2134                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2135                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2136                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2137                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2138                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
2139                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2140                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));
2141                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));
2142                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2143                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));
2144                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
2145                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));
2146                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
2147                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
2148         }
2149         if (ndr_flags & NDR_BUFFERS) {
2150                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2151                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2152                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2153                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2154                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2155                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2156                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
2157                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2158                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2159         }
2160         return NDR_ERR_SUCCESS;
2161 }
2162
2163 static enum ndr_err_code ndr_pull_samr_UserInfo5(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo5 *r)
2164 {
2165         if (ndr_flags & NDR_SCALARS) {
2166                 NDR_CHECK(ndr_pull_align(ndr, 4));
2167                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2168                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2169                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
2170                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
2171                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2172                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2173                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2174                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2175                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
2176                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2177                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));
2178                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));
2179                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2180                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));
2181                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
2182                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));
2183                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
2184                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
2185         }
2186         if (ndr_flags & NDR_BUFFERS) {
2187                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2188                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2189                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2190                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2191                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2192                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2193                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
2194                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2195                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2196         }
2197         return NDR_ERR_SUCCESS;
2198 }
2199
2200 _PUBLIC_ void ndr_print_samr_UserInfo5(struct ndr_print *ndr, const char *name, const struct samr_UserInfo5 *r)
2201 {
2202         ndr_print_struct(ndr, name, "samr_UserInfo5");
2203         ndr->depth++;
2204         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2205         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2206         ndr_print_uint32(ndr, "rid", r->rid);
2207         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
2208         ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
2209         ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
2210         ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
2211         ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
2212         ndr_print_lsa_String(ndr, "description", &r->description);
2213         ndr_print_lsa_String(ndr, "workstations", &r->workstations);
2214         ndr_print_NTTIME(ndr, "last_logon", r->last_logon);
2215         ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);
2216         ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
2217         ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);
2218         ndr_print_uint16(ndr, "logon_count", r->logon_count);
2219         ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);
2220         ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);
2221         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
2222         ndr->depth--;
2223 }
2224
2225 static enum ndr_err_code ndr_push_samr_UserInfo6(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo6 *r)
2226 {
2227         if (ndr_flags & NDR_SCALARS) {
2228                 NDR_CHECK(ndr_push_align(ndr, 4));
2229                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2230                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2231         }
2232         if (ndr_flags & NDR_BUFFERS) {
2233                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2234                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2235         }
2236         return NDR_ERR_SUCCESS;
2237 }
2238
2239 static enum ndr_err_code ndr_pull_samr_UserInfo6(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo6 *r)
2240 {
2241         if (ndr_flags & NDR_SCALARS) {
2242                 NDR_CHECK(ndr_pull_align(ndr, 4));
2243                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2244                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2245         }
2246         if (ndr_flags & NDR_BUFFERS) {
2247                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2248                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2249         }
2250         return NDR_ERR_SUCCESS;
2251 }
2252
2253 _PUBLIC_ void ndr_print_samr_UserInfo6(struct ndr_print *ndr, const char *name, const struct samr_UserInfo6 *r)
2254 {
2255         ndr_print_struct(ndr, name, "samr_UserInfo6");
2256         ndr->depth++;
2257         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2258         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2259         ndr->depth--;
2260 }
2261
2262 static enum ndr_err_code ndr_push_samr_UserInfo7(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo7 *r)
2263 {
2264         if (ndr_flags & NDR_SCALARS) {
2265                 NDR_CHECK(ndr_push_align(ndr, 4));
2266                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2267         }
2268         if (ndr_flags & NDR_BUFFERS) {
2269                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2270         }
2271         return NDR_ERR_SUCCESS;
2272 }
2273
2274 static enum ndr_err_code ndr_pull_samr_UserInfo7(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo7 *r)
2275 {
2276         if (ndr_flags & NDR_SCALARS) {
2277                 NDR_CHECK(ndr_pull_align(ndr, 4));
2278                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2279         }
2280         if (ndr_flags & NDR_BUFFERS) {
2281                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2282         }
2283         return NDR_ERR_SUCCESS;
2284 }
2285
2286 _PUBLIC_ void ndr_print_samr_UserInfo7(struct ndr_print *ndr, const char *name, const struct samr_UserInfo7 *r)
2287 {
2288         ndr_print_struct(ndr, name, "samr_UserInfo7");
2289         ndr->depth++;
2290         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2291         ndr->depth--;
2292 }
2293
2294 static enum ndr_err_code ndr_push_samr_UserInfo8(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo8 *r)
2295 {
2296         if (ndr_flags & NDR_SCALARS) {
2297                 NDR_CHECK(ndr_push_align(ndr, 4));
2298                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2299         }
2300         if (ndr_flags & NDR_BUFFERS) {
2301                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2302         }
2303         return NDR_ERR_SUCCESS;
2304 }
2305
2306 static enum ndr_err_code ndr_pull_samr_UserInfo8(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo8 *r)
2307 {
2308         if (ndr_flags & NDR_SCALARS) {
2309                 NDR_CHECK(ndr_pull_align(ndr, 4));
2310                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2311         }
2312         if (ndr_flags & NDR_BUFFERS) {
2313                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2314         }
2315         return NDR_ERR_SUCCESS;
2316 }
2317
2318 _PUBLIC_ void ndr_print_samr_UserInfo8(struct ndr_print *ndr, const char *name, const struct samr_UserInfo8 *r)
2319 {
2320         ndr_print_struct(ndr, name, "samr_UserInfo8");
2321         ndr->depth++;
2322         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2323         ndr->depth--;
2324 }
2325
2326 static enum ndr_err_code ndr_push_samr_UserInfo9(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo9 *r)
2327 {
2328         if (ndr_flags & NDR_SCALARS) {
2329                 NDR_CHECK(ndr_push_align(ndr, 4));
2330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
2331         }
2332         if (ndr_flags & NDR_BUFFERS) {
2333         }
2334         return NDR_ERR_SUCCESS;
2335 }
2336
2337 static enum ndr_err_code ndr_pull_samr_UserInfo9(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo9 *r)
2338 {
2339         if (ndr_flags & NDR_SCALARS) {
2340                 NDR_CHECK(ndr_pull_align(ndr, 4));
2341                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
2342         }
2343         if (ndr_flags & NDR_BUFFERS) {
2344         }
2345         return NDR_ERR_SUCCESS;
2346 }
2347
2348 _PUBLIC_ void ndr_print_samr_UserInfo9(struct ndr_print *ndr, const char *name, const struct samr_UserInfo9 *r)
2349 {
2350         ndr_print_struct(ndr, name, "samr_UserInfo9");
2351         ndr->depth++;
2352         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
2353         ndr->depth--;
2354 }
2355
2356 static enum ndr_err_code ndr_push_samr_UserInfo10(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo10 *r)
2357 {
2358         if (ndr_flags & NDR_SCALARS) {
2359                 NDR_CHECK(ndr_push_align(ndr, 4));
2360                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2361                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2362         }
2363         if (ndr_flags & NDR_BUFFERS) {
2364                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2365                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2366         }
2367         return NDR_ERR_SUCCESS;
2368 }
2369
2370 static enum ndr_err_code ndr_pull_samr_UserInfo10(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo10 *r)
2371 {
2372         if (ndr_flags & NDR_SCALARS) {
2373                 NDR_CHECK(ndr_pull_align(ndr, 4));
2374                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2375                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2376         }
2377         if (ndr_flags & NDR_BUFFERS) {
2378                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2379                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2380         }
2381         return NDR_ERR_SUCCESS;
2382 }
2383
2384 _PUBLIC_ void ndr_print_samr_UserInfo10(struct ndr_print *ndr, const char *name, const struct samr_UserInfo10 *r)
2385 {
2386         ndr_print_struct(ndr, name, "samr_UserInfo10");
2387         ndr->depth++;
2388         ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
2389         ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
2390         ndr->depth--;
2391 }
2392
2393 static enum ndr_err_code ndr_push_samr_UserInfo11(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo11 *r)
2394 {
2395         if (ndr_flags & NDR_SCALARS) {
2396                 NDR_CHECK(ndr_push_align(ndr, 4));
2397                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2398         }
2399         if (ndr_flags & NDR_BUFFERS) {
2400                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2401         }
2402         return NDR_ERR_SUCCESS;
2403 }
2404
2405 static enum ndr_err_code ndr_pull_samr_UserInfo11(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo11 *r)
2406 {
2407         if (ndr_flags & NDR_SCALARS) {
2408                 NDR_CHECK(ndr_pull_align(ndr, 4));
2409                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2410         }
2411         if (ndr_flags & NDR_BUFFERS) {
2412                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2413         }
2414         return NDR_ERR_SUCCESS;
2415 }
2416
2417 _PUBLIC_ void ndr_print_samr_UserInfo11(struct ndr_print *ndr, const char *name, const struct samr_UserInfo11 *r)
2418 {
2419         ndr_print_struct(ndr, name, "samr_UserInfo11");
2420         ndr->depth++;
2421         ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
2422         ndr->depth--;
2423 }
2424
2425 static enum ndr_err_code ndr_push_samr_UserInfo12(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo12 *r)
2426 {
2427         if (ndr_flags & NDR_SCALARS) {
2428                 NDR_CHECK(ndr_push_align(ndr, 4));
2429                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2430         }
2431         if (ndr_flags & NDR_BUFFERS) {
2432                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2433         }
2434         return NDR_ERR_SUCCESS;
2435 }
2436
2437 static enum ndr_err_code ndr_pull_samr_UserInfo12(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo12 *r)
2438 {
2439         if (ndr_flags & NDR_SCALARS) {
2440                 NDR_CHECK(ndr_pull_align(ndr, 4));
2441                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2442         }
2443         if (ndr_flags & NDR_BUFFERS) {
2444                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2445         }
2446         return NDR_ERR_SUCCESS;
2447 }
2448
2449 _PUBLIC_ void ndr_print_samr_UserInfo12(struct ndr_print *ndr, const char *name, const struct samr_UserInfo12 *r)
2450 {
2451         ndr_print_struct(ndr, name, "samr_UserInfo12");
2452         ndr->depth++;
2453         ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
2454         ndr->depth--;
2455 }
2456
2457 static enum ndr_err_code ndr_push_samr_UserInfo13(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo13 *r)
2458 {
2459         if (ndr_flags & NDR_SCALARS) {
2460                 NDR_CHECK(ndr_push_align(ndr, 4));
2461                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
2462         }
2463         if (ndr_flags & NDR_BUFFERS) {
2464                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
2465         }
2466         return NDR_ERR_SUCCESS;
2467 }
2468
2469 static enum ndr_err_code ndr_pull_samr_UserInfo13(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo13 *r)
2470 {
2471         if (ndr_flags & NDR_SCALARS) {
2472                 NDR_CHECK(ndr_pull_align(ndr, 4));
2473                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
2474         }
2475         if (ndr_flags & NDR_BUFFERS) {
2476                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
2477         }
2478         return NDR_ERR_SUCCESS;
2479 }
2480
2481 _PUBLIC_ void ndr_print_samr_UserInfo13(struct ndr_print *ndr, const char *name, const struct samr_UserInfo13 *r)
2482 {
2483         ndr_print_struct(ndr, name, "samr_UserInfo13");
2484         ndr->depth++;
2485         ndr_print_lsa_String(ndr, "description", &r->description);
2486         ndr->depth--;
2487 }
2488
2489 static enum ndr_err_code ndr_push_samr_UserInfo14(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo14 *r)
2490 {
2491         if (ndr_flags & NDR_SCALARS) {
2492                 NDR_CHECK(ndr_push_align(ndr, 4));
2493                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2494         }
2495         if (ndr_flags & NDR_BUFFERS) {
2496                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2497         }
2498         return NDR_ERR_SUCCESS;
2499 }
2500
2501 static enum ndr_err_code ndr_pull_samr_UserInfo14(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo14 *r)
2502 {
2503         if (ndr_flags & NDR_SCALARS) {
2504                 NDR_CHECK(ndr_pull_align(ndr, 4));
2505                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2506         }
2507         if (ndr_flags & NDR_BUFFERS) {
2508                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2509         }
2510         return NDR_ERR_SUCCESS;
2511 }
2512
2513 _PUBLIC_ void ndr_print_samr_UserInfo14(struct ndr_print *ndr, const char *name, const struct samr_UserInfo14 *r)
2514 {
2515         ndr_print_struct(ndr, name, "samr_UserInfo14");
2516         ndr->depth++;
2517         ndr_print_lsa_String(ndr, "workstations", &r->workstations);
2518         ndr->depth--;
2519 }
2520
2521 static enum ndr_err_code ndr_push_samr_UserInfo16(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo16 *r)
2522 {
2523         if (ndr_flags & NDR_SCALARS) {
2524                 NDR_CHECK(ndr_push_align(ndr, 4));
2525                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
2526         }
2527         if (ndr_flags & NDR_BUFFERS) {
2528         }
2529         return NDR_ERR_SUCCESS;
2530 }
2531
2532 static enum ndr_err_code ndr_pull_samr_UserInfo16(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo16 *r)
2533 {
2534         if (ndr_flags & NDR_SCALARS) {
2535                 NDR_CHECK(ndr_pull_align(ndr, 4));
2536                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
2537         }
2538         if (ndr_flags & NDR_BUFFERS) {
2539         }
2540         return NDR_ERR_SUCCESS;
2541 }
2542
2543 _PUBLIC_ void ndr_print_samr_UserInfo16(struct ndr_print *ndr, const char *name, const struct samr_UserInfo16 *r)
2544 {
2545         ndr_print_struct(ndr, name, "samr_UserInfo16");
2546         ndr->depth++;
2547         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
2548         ndr->depth--;
2549 }
2550
2551 static enum ndr_err_code ndr_push_samr_UserInfo17(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo17 *r)
2552 {
2553         if (ndr_flags & NDR_SCALARS) {
2554                 NDR_CHECK(ndr_push_align(ndr, 4));
2555                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
2556         }
2557         if (ndr_flags & NDR_BUFFERS) {
2558         }
2559         return NDR_ERR_SUCCESS;
2560 }
2561
2562 static enum ndr_err_code ndr_pull_samr_UserInfo17(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo17 *r)
2563 {
2564         if (ndr_flags & NDR_SCALARS) {
2565                 NDR_CHECK(ndr_pull_align(ndr, 4));
2566                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
2567         }
2568         if (ndr_flags & NDR_BUFFERS) {
2569         }
2570         return NDR_ERR_SUCCESS;
2571 }
2572
2573 _PUBLIC_ void ndr_print_samr_UserInfo17(struct ndr_print *ndr, const char *name, const struct samr_UserInfo17 *r)
2574 {
2575         ndr_print_struct(ndr, name, "samr_UserInfo17");
2576         ndr->depth++;
2577         ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);
2578         ndr->depth--;
2579 }
2580
2581 _PUBLIC_ enum ndr_err_code ndr_push_samr_Password(struct ndr_push *ndr, int ndr_flags, const struct samr_Password *r)
2582 {
2583         {
2584                 uint32_t _flags_save_STRUCT = ndr->flags;
2585                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2586                 if (ndr_flags & NDR_SCALARS) {
2587                         NDR_CHECK(ndr_push_align(ndr, 1));
2588                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
2589                 }
2590                 if (ndr_flags & NDR_BUFFERS) {
2591                 }
2592                 ndr->flags = _flags_save_STRUCT;
2593         }
2594         return NDR_ERR_SUCCESS;
2595 }
2596
2597 _PUBLIC_ enum ndr_err_code ndr_pull_samr_Password(struct ndr_pull *ndr, int ndr_flags, struct samr_Password *r)
2598 {
2599         {
2600                 uint32_t _flags_save_STRUCT = ndr->flags;
2601                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2602                 if (ndr_flags & NDR_SCALARS) {
2603                         NDR_CHECK(ndr_pull_align(ndr, 1));
2604                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
2605                 }
2606                 if (ndr_flags & NDR_BUFFERS) {
2607                 }
2608                 ndr->flags = _flags_save_STRUCT;
2609         }
2610         return NDR_ERR_SUCCESS;
2611 }
2612
2613 _PUBLIC_ void ndr_print_samr_Password(struct ndr_print *ndr, const char *name, const struct samr_Password *r)
2614 {
2615         ndr_print_struct(ndr, name, "samr_Password");
2616         {
2617                 uint32_t _flags_save_STRUCT = ndr->flags;
2618                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2619                 ndr->depth++;
2620                 ndr_print_array_uint8(ndr, "hash", r->hash, 16);
2621                 ndr->depth--;
2622                 ndr->flags = _flags_save_STRUCT;
2623         }
2624 }
2625
2626 static enum ndr_err_code ndr_push_samr_UserInfo18(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo18 *r)
2627 {
2628         if (ndr_flags & NDR_SCALARS) {
2629                 NDR_CHECK(ndr_push_align(ndr, 1));
2630                 NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->lm_pwd));
2631                 NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->nt_pwd));
2632                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->lm_pwd_active));
2633                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->nt_pwd_active));
2634         }
2635         if (ndr_flags & NDR_BUFFERS) {
2636         }
2637         return NDR_ERR_SUCCESS;
2638 }
2639
2640 static enum ndr_err_code ndr_pull_samr_UserInfo18(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo18 *r)
2641 {
2642         if (ndr_flags & NDR_SCALARS) {
2643                 NDR_CHECK(ndr_pull_align(ndr, 1));
2644                 NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->lm_pwd));
2645                 NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->nt_pwd));
2646                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->lm_pwd_active));
2647                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->nt_pwd_active));
2648         }
2649         if (ndr_flags & NDR_BUFFERS) {
2650         }
2651         return NDR_ERR_SUCCESS;
2652 }
2653
2654 _PUBLIC_ void ndr_print_samr_UserInfo18(struct ndr_print *ndr, const char *name, const struct samr_UserInfo18 *r)
2655 {
2656         ndr_print_struct(ndr, name, "samr_UserInfo18");
2657         ndr->depth++;
2658         ndr_print_samr_Password(ndr, "lm_pwd", &r->lm_pwd);
2659         ndr_print_samr_Password(ndr, "nt_pwd", &r->nt_pwd);
2660         ndr_print_uint8(ndr, "lm_pwd_active", r->lm_pwd_active);
2661         ndr_print_uint8(ndr, "nt_pwd_active", r->nt_pwd_active);
2662         ndr->depth--;
2663 }
2664
2665 static enum ndr_err_code ndr_push_samr_UserInfo20(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo20 *r)
2666 {
2667         if (ndr_flags & NDR_SCALARS) {
2668                 NDR_CHECK(ndr_push_align(ndr, 4));
2669                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
2670         }
2671         if (ndr_flags & NDR_BUFFERS) {
2672                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
2673         }
2674         return NDR_ERR_SUCCESS;
2675 }
2676
2677 static enum ndr_err_code ndr_pull_samr_UserInfo20(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo20 *r)
2678 {
2679         if (ndr_flags & NDR_SCALARS) {
2680                 NDR_CHECK(ndr_pull_align(ndr, 4));
2681                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
2682         }
2683         if (ndr_flags & NDR_BUFFERS) {
2684                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
2685         }
2686         return NDR_ERR_SUCCESS;
2687 }
2688
2689 _PUBLIC_ void ndr_print_samr_UserInfo20(struct ndr_print *ndr, const char *name, const struct samr_UserInfo20 *r)
2690 {
2691         ndr_print_struct(ndr, name, "samr_UserInfo20");
2692         ndr->depth++;
2693         ndr_print_lsa_BinaryString(ndr, "parameters", &r->parameters);
2694         ndr->depth--;
2695 }
2696
2697 static enum ndr_err_code ndr_push_samr_FieldsPresent(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2698 {
2699         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2700         return NDR_ERR_SUCCESS;
2701 }
2702
2703 static enum ndr_err_code ndr_pull_samr_FieldsPresent(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2704 {
2705         uint32_t v;
2706         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2707         *r = v;
2708         return NDR_ERR_SUCCESS;
2709 }
2710
2711 _PUBLIC_ void ndr_print_samr_FieldsPresent(struct ndr_print *ndr, const char *name, uint32_t r)
2712 {
2713         ndr_print_uint32(ndr, name, r);
2714         ndr->depth++;
2715         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCOUNT_NAME", SAMR_FIELD_ACCOUNT_NAME, r);
2716         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_FULL_NAME", SAMR_FIELD_FULL_NAME, r);
2717         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_RID", SAMR_FIELD_RID, r);
2718         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PRIMARY_GID", SAMR_FIELD_PRIMARY_GID, r);
2719         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_DESCRIPTION", SAMR_FIELD_DESCRIPTION, r);
2720         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_COMMENT", SAMR_FIELD_COMMENT, r);
2721         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_HOME_DIRECTORY", SAMR_FIELD_HOME_DIRECTORY, r);
2722         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_HOME_DRIVE", SAMR_FIELD_HOME_DRIVE, r);
2723         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LOGON_SCRIPT", SAMR_FIELD_LOGON_SCRIPT, r);
2724         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PROFILE_PATH", SAMR_FIELD_PROFILE_PATH, r);
2725         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_WORKSTATIONS", SAMR_FIELD_WORKSTATIONS, r);
2726         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_LOGON", SAMR_FIELD_LAST_LOGON, r);
2727         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_LOGOFF", SAMR_FIELD_LAST_LOGOFF, r);
2728         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LOGON_HOURS", SAMR_FIELD_LOGON_HOURS, r);
2729         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_BAD_PWD_COUNT", SAMR_FIELD_BAD_PWD_COUNT, r);
2730         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_NUM_LOGONS", SAMR_FIELD_NUM_LOGONS, r);
2731         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ALLOW_PWD_CHANGE", SAMR_FIELD_ALLOW_PWD_CHANGE, r);
2732         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_FORCE_PWD_CHANGE", SAMR_FIELD_FORCE_PWD_CHANGE, r);
2733         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_PWD_CHANGE", SAMR_FIELD_LAST_PWD_CHANGE, r);
2734         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCT_EXPIRY", SAMR_FIELD_ACCT_EXPIRY, r);
2735         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCT_FLAGS", SAMR_FIELD_ACCT_FLAGS, r);
2736         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PARAMETERS", SAMR_FIELD_PARAMETERS, r);
2737         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_COUNTRY_CODE", SAMR_FIELD_COUNTRY_CODE, r);
2738         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_CODE_PAGE", SAMR_FIELD_CODE_PAGE, r);
2739         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PASSWORD", SAMR_FIELD_PASSWORD, r);
2740         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PASSWORD2", SAMR_FIELD_PASSWORD2, r);
2741         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PRIVATE_DATA", SAMR_FIELD_PRIVATE_DATA, r);
2742         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_EXPIRED_FLAG", SAMR_FIELD_EXPIRED_FLAG, r);
2743         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_SEC_DESC", SAMR_FIELD_SEC_DESC, r);
2744         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_OWF_PWD", SAMR_FIELD_OWF_PWD, r);
2745         ndr->depth--;
2746 }
2747
2748 static enum ndr_err_code ndr_push_samr_UserInfo21(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo21 *r)
2749 {
2750         if (ndr_flags & NDR_SCALARS) {
2751                 NDR_CHECK(ndr_push_align(ndr, 4));
2752                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));
2753                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));
2754                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));
2755                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
2756                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->allow_password_change));
2757                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_password_change));
2758                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2759                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2760                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2761                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2762                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2763                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2764                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
2765                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2766                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));
2767                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
2768                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->unknown1));
2769                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->unknown2));
2770                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->unknown3));
2771                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_count));
2772                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->buffer));
2773                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
2774                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
2775                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
2776                 NDR_CHECK(ndr_push_samr_FieldsPresent(ndr, NDR_SCALARS, r->fields_present));
2777                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2778                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));
2779                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
2780                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->country_code));
2781                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->code_page));
2782                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->nt_password_set));
2783                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->lm_password_set));
2784                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
2785                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->unknown4));
2786         }
2787         if (ndr_flags & NDR_BUFFERS) {
2788                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2789                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2790                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2791                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2792                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2793                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2794                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
2795                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2796                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));
2797                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
2798                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->unknown1));
2799                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->unknown2));
2800                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->unknown3));
2801                 if (r->buffer) {
2802                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_count));
2803                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->buffer, r->buf_count));
2804                 }
2805                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2806         }
2807         return NDR_ERR_SUCCESS;
2808 }
2809
2810 static enum ndr_err_code ndr_pull_samr_UserInfo21(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo21 *r)
2811 {
2812         uint32_t _ptr_buffer;
2813         TALLOC_CTX *_mem_save_buffer_0;
2814         if (ndr_flags & NDR_SCALARS) {
2815                 NDR_CHECK(ndr_pull_align(ndr, 4));
2816                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));
2817                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));
2818                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));
2819                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
2820                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->allow_password_change));
2821                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_password_change));
2822                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2823                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2824                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2825                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2826                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2827                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2828                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
2829                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2830                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));
2831                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
2832                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->unknown1));
2833                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->unknown2));
2834                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->unknown3));
2835                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_count));
2836                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
2837                 if (_ptr_buffer) {
2838                         NDR_PULL_ALLOC(ndr, r->buffer);
2839                 } else {
2840                         r->buffer = NULL;
2841                 }
2842                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
2843                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
2844                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
2845                 NDR_CHECK(ndr_pull_samr_FieldsPresent(ndr, NDR_SCALARS, &r->fields_present));
2846                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2847                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));
2848                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
2849                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->country_code));
2850                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->code_page));
2851                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->nt_password_set));
2852                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->lm_password_set));
2853                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
2854                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->unknown4));
2855         }
2856         if (ndr_flags & NDR_BUFFERS) {
2857                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2858                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2859                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2860                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2861                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2862                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2863                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
2864                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2865                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));
2866                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
2867                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->unknown1));
2868                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->unknown2));
2869                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->unknown3));
2870                 if (r->buffer) {
2871                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
2872                         NDR_PULL_SET_MEM_CTX(ndr, r->buffer, 0);
2873                         NDR_CHECK(ndr_pull_array_size(ndr, &r->buffer));
2874                         NDR_PULL_ALLOC_N(ndr, r->buffer, ndr_get_array_size(ndr, &r->buffer));
2875                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->buffer, ndr_get_array_size(ndr, &r->buffer)));
2876                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
2877                 }
2878                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2879                 if (r->buffer) {
2880                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->buffer, r->buf_count));
2881                 }
2882         }
2883         return NDR_ERR_SUCCESS;
2884 }
2885
2886 _PUBLIC_ void ndr_print_samr_UserInfo21(struct ndr_print *ndr, const char *name, const struct samr_UserInfo21 *r)
2887 {
2888         ndr_print_struct(ndr, name, "samr_UserInfo21");
2889         ndr->depth++;
2890         ndr_print_NTTIME(ndr, "last_logon", r->last_logon);
2891         ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);
2892         ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);
2893         ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);
2894         ndr_print_NTTIME(ndr, "allow_password_change", r->allow_password_change);
2895         ndr_print_NTTIME(ndr, "force_password_change", r->force_password_change);
2896         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2897         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2898         ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
2899         ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
2900         ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
2901         ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
2902         ndr_print_lsa_String(ndr, "description", &r->description);
2903         ndr_print_lsa_String(ndr, "workstations", &r->workstations);
2904         ndr_print_lsa_String(ndr, "comment", &r->comment);
2905         ndr_print_lsa_BinaryString(ndr, "parameters", &r->parameters);
2906         ndr_print_lsa_String(ndr, "unknown1", &r->unknown1);
2907         ndr_print_lsa_String(ndr, "unknown2", &r->unknown2);
2908         ndr_print_lsa_String(ndr, "unknown3", &r->unknown3);
2909         ndr_print_uint32(ndr, "buf_count", r->buf_count);
2910         ndr_print_ptr(ndr, "buffer", r->buffer);
2911         ndr->depth++;
2912         if (r->buffer) {
2913                 ndr_print_array_uint8(ndr, "buffer", r->buffer, r->buf_count);
2914         }
2915         ndr->depth--;
2916         ndr_print_uint32(ndr, "rid", r->rid);
2917         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
2918         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
2919         ndr_print_samr_FieldsPresent(ndr, "fields_present", r->fields_present);
2920         ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
2921         ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);
2922         ndr_print_uint16(ndr, "logon_count", r->logon_count);
2923         ndr_print_uint16(ndr, "country_code", r->country_code);
2924         ndr_print_uint16(ndr, "code_page", r->code_page);
2925         ndr_print_uint8(ndr, "nt_password_set", r->nt_password_set);
2926         ndr_print_uint8(ndr, "lm_password_set", r->lm_password_set);
2927         ndr_print_uint8(ndr, "password_expired", r->password_expired);
2928         ndr_print_uint8(ndr, "unknown4", r->unknown4);
2929         ndr->depth--;
2930 }
2931
2932 _PUBLIC_ enum ndr_err_code ndr_push_samr_CryptPassword(struct ndr_push *ndr, int ndr_flags, const struct samr_CryptPassword *r)
2933 {
2934         {
2935                 uint32_t _flags_save_STRUCT = ndr->flags;
2936                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2937                 if (ndr_flags & NDR_SCALARS) {
2938                         NDR_CHECK(ndr_push_align(ndr, 1));
2939                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 516));
2940                 }
2941                 if (ndr_flags & NDR_BUFFERS) {
2942                 }
2943                 ndr->flags = _flags_save_STRUCT;
2944         }
2945         return NDR_ERR_SUCCESS;
2946 }
2947
2948 _PUBLIC_ enum ndr_err_code ndr_pull_samr_CryptPassword(struct ndr_pull *ndr, int ndr_flags, struct samr_CryptPassword *r)
2949 {
2950         {
2951                 uint32_t _flags_save_STRUCT = ndr->flags;
2952                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2953                 if (ndr_flags & NDR_SCALARS) {
2954                         NDR_CHECK(ndr_pull_align(ndr, 1));
2955                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, 516));
2956                 }
2957                 if (ndr_flags & NDR_BUFFERS) {
2958                 }
2959                 ndr->flags = _flags_save_STRUCT;
2960         }
2961         return NDR_ERR_SUCCESS;
2962 }
2963
2964 _PUBLIC_ void ndr_print_samr_CryptPassword(struct ndr_print *ndr, const char *name, const struct samr_CryptPassword *r)
2965 {
2966         ndr_print_struct(ndr, name, "samr_CryptPassword");
2967         {
2968                 uint32_t _flags_save_STRUCT = ndr->flags;
2969                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2970                 ndr->depth++;
2971                 ndr_print_array_uint8(ndr, "data", r->data, 516);
2972                 ndr->depth--;
2973                 ndr->flags = _flags_save_STRUCT;
2974         }
2975 }
2976
2977 static enum ndr_err_code ndr_push_samr_UserInfo23(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo23 *r)
2978 {
2979         if (ndr_flags & NDR_SCALARS) {
2980                 NDR_CHECK(ndr_push_align(ndr, 4));
2981                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
2982                 NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
2983         }
2984         if (ndr_flags & NDR_BUFFERS) {
2985                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
2986         }
2987         return NDR_ERR_SUCCESS;
2988 }
2989
2990 static enum ndr_err_code ndr_pull_samr_UserInfo23(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo23 *r)
2991 {
2992         if (ndr_flags & NDR_SCALARS) {
2993                 NDR_CHECK(ndr_pull_align(ndr, 4));
2994                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
2995                 NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
2996         }
2997         if (ndr_flags & NDR_BUFFERS) {
2998                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
2999         }
3000         return NDR_ERR_SUCCESS;
3001 }
3002
3003 _PUBLIC_ void ndr_print_samr_UserInfo23(struct ndr_print *ndr, const char *name, const struct samr_UserInfo23 *r)
3004 {
3005         ndr_print_struct(ndr, name, "samr_UserInfo23");
3006         ndr->depth++;
3007         ndr_print_samr_UserInfo21(ndr, "info", &r->info);
3008         ndr_print_samr_CryptPassword(ndr, "password", &r->password);
3009         ndr->depth--;
3010 }
3011
3012 static enum ndr_err_code ndr_push_samr_UserInfo24(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo24 *r)
3013 {
3014         if (ndr_flags & NDR_SCALARS) {
3015                 NDR_CHECK(ndr_push_align(ndr, 1));
3016                 NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
3017                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->pw_len));
3018         }
3019         if (ndr_flags & NDR_BUFFERS) {
3020         }
3021         return NDR_ERR_SUCCESS;
3022 }
3023
3024 static enum ndr_err_code ndr_pull_samr_UserInfo24(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo24 *r)
3025 {
3026         if (ndr_flags & NDR_SCALARS) {
3027                 NDR_CHECK(ndr_pull_align(ndr, 1));
3028                 NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
3029                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->pw_len));
3030         }
3031         if (ndr_flags & NDR_BUFFERS) {
3032         }
3033         return NDR_ERR_SUCCESS;
3034 }
3035
3036 _PUBLIC_ void ndr_print_samr_UserInfo24(struct ndr_print *ndr, const char *name, const struct samr_UserInfo24 *r)
3037 {
3038         ndr_print_struct(ndr, name, "samr_UserInfo24");
3039         ndr->depth++;
3040         ndr_print_samr_CryptPassword(ndr, "password", &r->password);
3041         ndr_print_uint8(ndr, "pw_len", r->pw_len);
3042         ndr->depth--;
3043 }
3044
3045 static enum ndr_err_code ndr_push_samr_CryptPasswordEx(struct ndr_push *ndr, int ndr_flags, const struct samr_CryptPasswordEx *r)
3046 {
3047         {
3048                 uint32_t _flags_save_STRUCT = ndr->flags;
3049                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3050                 if (ndr_flags & NDR_SCALARS) {
3051                         NDR_CHECK(ndr_push_align(ndr, 1));
3052                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 532));
3053                 }
3054                 if (ndr_flags & NDR_BUFFERS) {
3055                 }
3056                 ndr->flags = _flags_save_STRUCT;
3057         }
3058         return NDR_ERR_SUCCESS;
3059 }
3060
3061 static enum ndr_err_code ndr_pull_samr_CryptPasswordEx(struct ndr_pull *ndr, int ndr_flags, struct samr_CryptPasswordEx *r)
3062 {
3063         {
3064                 uint32_t _flags_save_STRUCT = ndr->flags;
3065                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3066                 if (ndr_flags & NDR_SCALARS) {
3067                         NDR_CHECK(ndr_pull_align(ndr, 1));
3068                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, 532));
3069                 }
3070                 if (ndr_flags & NDR_BUFFERS) {
3071                 }
3072                 ndr->flags = _flags_save_STRUCT;
3073         }
3074         return NDR_ERR_SUCCESS;
3075 }
3076
3077 _PUBLIC_ void ndr_print_samr_CryptPasswordEx(struct ndr_print *ndr, const char *name, const struct samr_CryptPasswordEx *r)
3078 {
3079         ndr_print_struct(ndr, name, "samr_CryptPasswordEx");
3080         {
3081                 uint32_t _flags_save_STRUCT = ndr->flags;
3082                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3083                 ndr->depth++;
3084                 ndr_print_array_uint8(ndr, "data", r->data, 532);
3085                 ndr->depth--;
3086                 ndr->flags = _flags_save_STRUCT;
3087         }
3088 }
3089
3090 static enum ndr_err_code ndr_push_samr_UserInfo25(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo25 *r)
3091 {
3092         if (ndr_flags & NDR_SCALARS) {
3093                 NDR_CHECK(ndr_push_align(ndr, 4));
3094                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
3095                 NDR_CHECK(ndr_push_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
3096         }
3097         if (ndr_flags & NDR_BUFFERS) {
3098                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
3099         }
3100         return NDR_ERR_SUCCESS;
3101 }
3102
3103 static enum ndr_err_code ndr_pull_samr_UserInfo25(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo25 *r)
3104 {
3105         if (ndr_flags & NDR_SCALARS) {
3106                 NDR_CHECK(ndr_pull_align(ndr, 4));
3107                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
3108                 NDR_CHECK(ndr_pull_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
3109         }
3110         if (ndr_flags & NDR_BUFFERS) {
3111                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
3112         }
3113         return NDR_ERR_SUCCESS;
3114 }
3115
3116 _PUBLIC_ void ndr_print_samr_UserInfo25(struct ndr_print *ndr, const char *name, const struct samr_UserInfo25 *r)
3117 {
3118         ndr_print_struct(ndr, name, "samr_UserInfo25");
3119         ndr->depth++;
3120         ndr_print_samr_UserInfo21(ndr, "info", &r->info);
3121         ndr_print_samr_CryptPasswordEx(ndr, "password", &r->password);
3122         ndr->depth--;
3123 }
3124
3125 static enum ndr_err_code ndr_push_samr_UserInfo26(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo26 *r)
3126 {
3127         if (ndr_flags & NDR_SCALARS) {
3128                 NDR_CHECK(ndr_push_align(ndr, 1));
3129                 NDR_CHECK(ndr_push_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
3130                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->pw_len));
3131         }
3132         if (ndr_flags & NDR_BUFFERS) {
3133         }
3134         return NDR_ERR_SUCCESS;
3135 }
3136
3137 static enum ndr_err_code ndr_pull_samr_UserInfo26(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo26 *r)
3138 {
3139         if (ndr_flags & NDR_SCALARS) {
3140                 NDR_CHECK(ndr_pull_align(ndr, 1));
3141                 NDR_CHECK(ndr_pull_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
3142                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->pw_len));
3143         }
3144         if (ndr_flags & NDR_BUFFERS) {
3145         }
3146         return NDR_ERR_SUCCESS;
3147 }
3148
3149 _PUBLIC_ void ndr_print_samr_UserInfo26(struct ndr_print *ndr, const char *name, const struct samr_UserInfo26 *r)
3150 {
3151         ndr_print_struct(ndr, name, "samr_UserInfo26");
3152         ndr->depth++;
3153         ndr_print_samr_CryptPasswordEx(ndr, "password", &r->password);
3154         ndr_print_uint8(ndr, "pw_len", r->pw_len);
3155         ndr->depth--;
3156 }
3157
3158 static enum ndr_err_code ndr_push_samr_UserInfo(struct ndr_push *ndr, int ndr_flags, const union samr_UserInfo *r)
3159 {
3160         if (ndr_flags & NDR_SCALARS) {
3161                 int level = ndr_push_get_switch_value(ndr, r);
3162                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
3163                 switch (level) {
3164                         case 1: {
3165                                 NDR_CHECK(ndr_push_samr_UserInfo1(ndr, NDR_SCALARS, &r->info1));
3166                         break; }
3167
3168                         case 2: {
3169                                 NDR_CHECK(ndr_push_samr_UserInfo2(ndr, NDR_SCALARS, &r->info2));
3170                         break; }
3171
3172                         case 3: {
3173                                 NDR_CHECK(ndr_push_samr_UserInfo3(ndr, NDR_SCALARS, &r->info3));
3174                         break; }
3175
3176                         case 4: {
3177                                 NDR_CHECK(ndr_push_samr_UserInfo4(ndr, NDR_SCALARS, &r->info4));
3178                         break; }
3179
3180                         case 5: {
3181                                 NDR_CHECK(ndr_push_samr_UserInfo5(ndr, NDR_SCALARS, &r->info5));
3182                         break; }
3183
3184                         case 6: {
3185                                 NDR_CHECK(ndr_push_samr_UserInfo6(ndr, NDR_SCALARS, &r->info6));
3186                         break; }
3187
3188                         case 7: {
3189                                 NDR_CHECK(ndr_push_samr_UserInfo7(ndr, NDR_SCALARS, &r->info7));
3190                         break; }
3191
3192                         case 8: {
3193                                 NDR_CHECK(ndr_push_samr_UserInfo8(ndr, NDR_SCALARS, &r->info8));
3194                         break; }
3195
3196                         case 9: {
3197                                 NDR_CHECK(ndr_push_samr_UserInfo9(ndr, NDR_SCALARS, &r->info9));
3198                         break; }
3199
3200                         case 10: {
3201                                 NDR_CHECK(ndr_push_samr_UserInfo10(ndr, NDR_SCALARS, &r->info10));
3202                         break; }
3203
3204                         case 11: {
3205                                 NDR_CHECK(ndr_push_samr_UserInfo11(ndr, NDR_SCALARS, &r->info11));
3206                         break; }
3207
3208                         case 12: {
3209                                 NDR_CHECK(ndr_push_samr_UserInfo12(ndr, NDR_SCALARS, &r->info12));
3210                         break; }
3211
3212                         case 13: {
3213                                 NDR_CHECK(ndr_push_samr_UserInfo13(ndr, NDR_SCALARS, &r->info13));
3214                         break; }
3215
3216                         case 14: {
3217                                 NDR_CHECK(ndr_push_samr_UserInfo14(ndr, NDR_SCALARS, &r->info14));
3218                         break; }
3219
3220                         case 16: {
3221                                 NDR_CHECK(ndr_push_samr_UserInfo16(ndr, NDR_SCALARS, &r->info16));
3222                         break; }
3223
3224                         case 17: {
3225                                 NDR_CHECK(ndr_push_samr_UserInfo17(ndr, NDR_SCALARS, &r->info17));
3226                         break; }
3227
3228                         case 18: {
3229                                 NDR_CHECK(ndr_push_samr_UserInfo18(ndr, NDR_SCALARS, &r->info18));
3230                         break; }
3231
3232                         case 20: {
3233                                 NDR_CHECK(ndr_push_samr_UserInfo20(ndr, NDR_SCALARS, &r->info20));
3234                         break; }
3235
3236                         case 21: {
3237                                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info21));
3238                         break; }
3239
3240                         case 23: {
3241                                 NDR_CHECK(ndr_push_samr_UserInfo23(ndr, NDR_SCALARS, &r->info23));
3242                         break; }
3243
3244                         case 24: {
3245                                 NDR_CHECK(ndr_push_samr_UserInfo24(ndr, NDR_SCALARS, &r->info24));
3246                         break; }
3247
3248                         case 25: {
3249                                 NDR_CHECK(ndr_push_samr_UserInfo25(ndr, NDR_SCALARS, &r->info25));
3250                         break; }
3251
3252                         case 26: {
3253                                 NDR_CHECK(ndr_push_samr_UserInfo26(ndr, NDR_SCALARS, &r->info26));
3254                         break; }
3255
3256                         default:
3257                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3258                 }
3259         }
3260         if (ndr_flags & NDR_BUFFERS) {
3261                 int level = ndr_push_get_switch_value(ndr, r);
3262                 switch (level) {
3263                         case 1:
3264                                 NDR_CHECK(ndr_push_samr_UserInfo1(ndr, NDR_BUFFERS, &r->info1));
3265                         break;
3266
3267                         case 2:
3268                                 NDR_CHECK(ndr_push_samr_UserInfo2(ndr, NDR_BUFFERS, &r->info2));
3269                         break;
3270
3271                         case 3:
3272                                 NDR_CHECK(ndr_push_samr_UserInfo3(ndr, NDR_BUFFERS, &r->info3));
3273                         break;
3274
3275                         case 4:
3276                                 NDR_CHECK(ndr_push_samr_UserInfo4(ndr, NDR_BUFFERS, &r->info4));
3277                         break;
3278
3279                         case 5:
3280                                 NDR_CHECK(ndr_push_samr_UserInfo5(ndr, NDR_BUFFERS, &r->info5));
3281                         break;
3282
3283                         case 6:
3284                                 NDR_CHECK(ndr_push_samr_UserInfo6(ndr, NDR_BUFFERS, &r->info6));
3285                         break;
3286
3287                         case 7:
3288                                 NDR_CHECK(ndr_push_samr_UserInfo7(ndr, NDR_BUFFERS, &r->info7));
3289                         break;
3290
3291                         case 8:
3292                                 NDR_CHECK(ndr_push_samr_UserInfo8(ndr, NDR_BUFFERS, &r->info8));
3293                         break;
3294
3295                         case 9:
3296                         break;
3297
3298                         case 10:
3299                                 NDR_CHECK(ndr_push_samr_UserInfo10(ndr, NDR_BUFFERS, &r->info10));
3300                         break;
3301
3302                         case 11:
3303                                 NDR_CHECK(ndr_push_samr_UserInfo11(ndr, NDR_BUFFERS, &r->info11));
3304                         break;
3305
3306                         case 12:
3307                                 NDR_CHECK(ndr_push_samr_UserInfo12(ndr, NDR_BUFFERS, &r->info12));
3308                         break;
3309
3310                         case 13:
3311                                 NDR_CHECK(ndr_push_samr_UserInfo13(ndr, NDR_BUFFERS, &r->info13));
3312                         break;
3313
3314                         case 14:
3315                                 NDR_CHECK(ndr_push_samr_UserInfo14(ndr, NDR_BUFFERS, &r->info14));
3316                         break;
3317
3318                         case 16:
3319                         break;
3320
3321                         case 17:
3322                         break;
3323
3324                         case 18:
3325                         break;
3326
3327                         case 20:
3328                                 NDR_CHECK(ndr_push_samr_UserInfo20(ndr, NDR_BUFFERS, &r->info20));
3329                         break;
3330
3331                         case 21:
3332                                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info21));
3333                         break;
3334
3335                         case 23:
3336                                 NDR_CHECK(ndr_push_samr_UserInfo23(ndr, NDR_BUFFERS, &r->info23));
3337                         break;
3338
3339                         case 24:
3340                         break;
3341
3342                         case 25:
3343                                 NDR_CHECK(ndr_push_samr_UserInfo25(ndr, NDR_BUFFERS, &r->info25));
3344                         break;
3345
3346                         case 26:
3347                         break;
3348
3349                         default:
3350                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3351                 }
3352         }
3353         return NDR_ERR_SUCCESS;
3354 }
3355
3356 static enum ndr_err_code ndr_pull_samr_UserInfo(struct ndr_pull *ndr, int ndr_flags, union samr_UserInfo *r)
3357 {
3358         int level;
3359         uint16_t _level;
3360         level = ndr_pull_get_switch_value(ndr, r);
3361         if (ndr_flags & NDR_SCALARS) {
3362                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
3363                 if (_level != level) {
3364                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3365                 }
3366                 switch (level) {
3367                         case 1: {
3368                                 NDR_CHECK(ndr_pull_samr_UserInfo1(ndr, NDR_SCALARS, &r->info1));
3369                         break; }
3370
3371                         case 2: {
3372                                 NDR_CHECK(ndr_pull_samr_UserInfo2(ndr, NDR_SCALARS, &r->info2));
3373                         break; }
3374
3375                         case 3: {
3376                                 NDR_CHECK(ndr_pull_samr_UserInfo3(ndr, NDR_SCALARS, &r->info3));
3377                         break; }
3378
3379                         case 4: {
3380                                 NDR_CHECK(ndr_pull_samr_UserInfo4(ndr, NDR_SCALARS, &r->info4));
3381                         break; }
3382
3383                         case 5: {
3384                                 NDR_CHECK(ndr_pull_samr_UserInfo5(ndr, NDR_SCALARS, &r->info5));
3385                         break; }
3386
3387                         case 6: {
3388                                 NDR_CHECK(ndr_pull_samr_UserInfo6(ndr, NDR_SCALARS, &r->info6));
3389                         break; }
3390
3391                         case 7: {
3392                                 NDR_CHECK(ndr_pull_samr_UserInfo7(ndr, NDR_SCALARS, &r->info7));
3393                         break; }
3394
3395                         case 8: {
3396                                 NDR_CHECK(ndr_pull_samr_UserInfo8(ndr, NDR_SCALARS, &r->info8));
3397                         break; }
3398
3399                         case 9: {
3400                                 NDR_CHECK(ndr_pull_samr_UserInfo9(ndr, NDR_SCALARS, &r->info9));
3401                         break; }
3402
3403                         case 10: {
3404                                 NDR_CHECK(ndr_pull_samr_UserInfo10(ndr, NDR_SCALARS, &r->info10));
3405                         break; }
3406
3407                         case 11: {
3408                                 NDR_CHECK(ndr_pull_samr_UserInfo11(ndr, NDR_SCALARS, &r->info11));
3409                         break; }
3410
3411                         case 12: {
3412                                 NDR_CHECK(ndr_pull_samr_UserInfo12(ndr, NDR_SCALARS, &r->info12));
3413                         break; }
3414
3415                         case 13: {
3416                                 NDR_CHECK(ndr_pull_samr_UserInfo13(ndr, NDR_SCALARS, &r->info13));
3417                         break; }
3418
3419                         case 14: {
3420                                 NDR_CHECK(ndr_pull_samr_UserInfo14(ndr, NDR_SCALARS, &r->info14));
3421                         break; }
3422
3423                         case 16: {
3424                                 NDR_CHECK(ndr_pull_samr_UserInfo16(ndr, NDR_SCALARS, &r->info16));
3425                         break; }
3426
3427                         case 17: {
3428                                 NDR_CHECK(ndr_pull_samr_UserInfo17(ndr, NDR_SCALARS, &r->info17));
3429                         break; }
3430
3431                         case 18: {
3432                                 NDR_CHECK(ndr_pull_samr_UserInfo18(ndr, NDR_SCALARS, &r->info18));
3433                         break; }
3434
3435                         case 20: {
3436                                 NDR_CHECK(ndr_pull_samr_UserInfo20(ndr, NDR_SCALARS, &r->info20));
3437                         break; }
3438
3439                         case 21: {
3440                                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info21));
3441                         break; }
3442
3443                         case 23: {
3444                                 NDR_CHECK(ndr_pull_samr_UserInfo23(ndr, NDR_SCALARS, &r->info23));
3445                         break; }
3446
3447                         case 24: {
3448                                 NDR_CHECK(ndr_pull_samr_UserInfo24(ndr, NDR_SCALARS, &r->info24));
3449                         break; }
3450
3451                         case 25: {
3452                                 NDR_CHECK(ndr_pull_samr_UserInfo25(ndr, NDR_SCALARS, &r->info25));
3453                         break; }
3454
3455                         case 26: {
3456                                 NDR_CHECK(ndr_pull_samr_UserInfo26(ndr, NDR_SCALARS, &r->info26));
3457                         break; }
3458
3459                         default:
3460                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3461                 }
3462         }
3463         if (ndr_flags & NDR_BUFFERS) {
3464                 switch (level) {
3465                         case 1:
3466                                 NDR_CHECK(ndr_pull_samr_UserInfo1(ndr, NDR_BUFFERS, &r->info1));
3467                         break;
3468
3469                         case 2:
3470                                 NDR_CHECK(ndr_pull_samr_UserInfo2(ndr, NDR_BUFFERS, &r->info2));
3471                         break;
3472
3473                         case 3:
3474                                 NDR_CHECK(ndr_pull_samr_UserInfo3(ndr, NDR_BUFFERS, &r->info3));
3475                         break;
3476
3477                         case 4:
3478                                 NDR_CHECK(ndr_pull_samr_UserInfo4(ndr, NDR_BUFFERS, &r->info4));
3479                         break;
3480
3481                         case 5:
3482                                 NDR_CHECK(ndr_pull_samr_UserInfo5(ndr, NDR_BUFFERS, &r->info5));
3483                         break;
3484
3485                         case 6:
3486                                 NDR_CHECK(ndr_pull_samr_UserInfo6(ndr, NDR_BUFFERS, &r->info6));
3487                         break;
3488
3489                         case 7:
3490                                 NDR_CHECK(ndr_pull_samr_UserInfo7(ndr, NDR_BUFFERS, &r->info7));
3491                         break;
3492
3493                         case 8:
3494                                 NDR_CHECK(ndr_pull_samr_UserInfo8(ndr, NDR_BUFFERS, &r->info8));
3495                         break;
3496
3497                         case 9:
3498                         break;
3499
3500                         case 10:
3501                                 NDR_CHECK(ndr_pull_samr_UserInfo10(ndr, NDR_BUFFERS, &r->info10));
3502                         break;
3503
3504                         case 11:
3505                                 NDR_CHECK(ndr_pull_samr_UserInfo11(ndr, NDR_BUFFERS, &r->info11));
3506                         break;
3507
3508                         case 12:
3509                                 NDR_CHECK(ndr_pull_samr_UserInfo12(ndr, NDR_BUFFERS, &r->info12));
3510                         break;
3511
3512                         case 13:
3513                                 NDR_CHECK(ndr_pull_samr_UserInfo13(ndr, NDR_BUFFERS, &r->info13));
3514                         break;
3515
3516                         case 14:
3517                                 NDR_CHECK(ndr_pull_samr_UserInfo14(ndr, NDR_BUFFERS, &r->info14));
3518                         break;
3519
3520                         case 16:
3521                         break;
3522
3523                         case 17:
3524                         break;
3525
3526                         case 18:
3527                         break;
3528
3529                         case 20:
3530                                 NDR_CHECK(ndr_pull_samr_UserInfo20(ndr, NDR_BUFFERS, &r->info20));
3531                         break;
3532
3533                         case 21:
3534                                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info21));
3535                         break;
3536
3537                         case 23:
3538                                 NDR_CHECK(ndr_pull_samr_UserInfo23(ndr, NDR_BUFFERS, &r->info23));
3539                         break;
3540
3541                         case 24:
3542                         break;
3543
3544                         case 25:
3545                                 NDR_CHECK(ndr_pull_samr_UserInfo25(ndr, NDR_BUFFERS, &r->info25));
3546                         break;
3547
3548                         case 26:
3549                         break;
3550
3551                         default:
3552                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3553                 }
3554         }
3555         return NDR_ERR_SUCCESS;
3556 }
3557
3558 _PUBLIC_ void ndr_print_samr_UserInfo(struct ndr_print *ndr, const char *name, const union samr_UserInfo *r)
3559 {
3560         int level;
3561         level = ndr_print_get_switch_value(ndr, r);
3562         ndr_print_union(ndr, name, level, "samr_UserInfo");
3563         switch (level) {
3564                 case 1:
3565                         ndr_print_samr_UserInfo1(ndr, "info1", &r->info1);
3566                 break;
3567
3568                 case 2:
3569                         ndr_print_samr_UserInfo2(ndr, "info2", &r->info2);
3570                 break;
3571
3572                 case 3:
3573                         ndr_print_samr_UserInfo3(ndr, "info3", &r->info3);
3574                 break;
3575
3576                 case 4:
3577                         ndr_print_samr_UserInfo4(ndr, "info4", &r->info4);
3578                 break;
3579
3580                 case 5:
3581                         ndr_print_samr_UserInfo5(ndr, "info5", &r->info5);
3582                 break;
3583
3584                 case 6:
3585                         ndr_print_samr_UserInfo6(ndr, "info6", &r->info6);
3586                 break;
3587
3588                 case 7:
3589                         ndr_print_samr_UserInfo7(ndr, "info7", &r->info7);
3590                 break;
3591
3592                 case 8:
3593                         ndr_print_samr_UserInfo8(ndr, "info8", &r->info8);
3594                 break;
3595
3596                 case 9:
3597                         ndr_print_samr_UserInfo9(ndr, "info9", &r->info9);
3598                 break;
3599
3600                 case 10:
3601                         ndr_print_samr_UserInfo10(ndr, "info10", &r->info10);
3602                 break;
3603
3604                 case 11:
3605                         ndr_print_samr_UserInfo11(ndr, "info11", &r->info11);
3606                 break;
3607
3608                 case 12:
3609                         ndr_print_samr_UserInfo12(ndr, "info12", &r->info12);
3610                 break;
3611
3612                 case 13:
3613                         ndr_print_samr_UserInfo13(ndr, "info13", &r->info13);
3614                 break;
3615
3616                 case 14:
3617                         ndr_print_samr_UserInfo14(ndr, "info14", &r->info14);
3618                 break;
3619
3620                 case 16:
3621                         ndr_print_samr_UserInfo16(ndr, "info16", &r->info16);
3622                 break;
3623
3624                 case 17:
3625                         ndr_print_samr_UserInfo17(ndr, "info17", &r->info17);
3626                 break;
3627
3628                 case 18:
3629                         ndr_print_samr_UserInfo18(ndr, "info18", &r->info18);
3630                 break;
3631
3632                 case 20:
3633                         ndr_print_samr_UserInfo20(ndr, "info20", &r->info20);
3634                 break;
3635
3636                 case 21:
3637                         ndr_print_samr_UserInfo21(ndr, "info21", &r->info21);
3638                 break;
3639
3640                 case 23:
3641                         ndr_print_samr_UserInfo23(ndr, "info23", &r->info23);
3642                 break;
3643
3644                 case 24:
3645                         ndr_print_samr_UserInfo24(ndr, "info24", &r->info24);
3646                 break;
3647
3648                 case 25:
3649                         ndr_print_samr_UserInfo25(ndr, "info25", &r->info25);
3650                 break;
3651
3652                 case 26:
3653                         ndr_print_samr_UserInfo26(ndr, "info26", &r->info26);
3654                 break;
3655
3656                 default:
3657                         ndr_print_bad_level(ndr, name, level);
3658         }
3659 }
3660
3661 _PUBLIC_ enum ndr_err_code ndr_push_samr_RidWithAttribute(struct ndr_push *ndr, int ndr_flags, const struct samr_RidWithAttribute *r)
3662 {
3663         if (ndr_flags & NDR_SCALARS) {
3664                 NDR_CHECK(ndr_push_align(ndr, 4));
3665                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
3666                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
3667         }
3668         if (ndr_flags & NDR_BUFFERS) {
3669         }
3670         return NDR_ERR_SUCCESS;
3671 }
3672
3673 _PUBLIC_ enum ndr_err_code ndr_pull_samr_RidWithAttribute(struct ndr_pull *ndr, int ndr_flags, struct samr_RidWithAttribute *r)
3674 {
3675         if (ndr_flags & NDR_SCALARS) {
3676                 NDR_CHECK(ndr_pull_align(ndr, 4));
3677                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
3678                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
3679         }
3680         if (ndr_flags & NDR_BUFFERS) {
3681         }
3682         return NDR_ERR_SUCCESS;
3683 }
3684
3685 _PUBLIC_ void ndr_print_samr_RidWithAttribute(struct ndr_print *ndr, const char *name, const struct samr_RidWithAttribute *r)
3686 {
3687         ndr_print_struct(ndr, name, "samr_RidWithAttribute");
3688         ndr->depth++;
3689         ndr_print_uint32(ndr, "rid", r->rid);
3690         ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);
3691         ndr->depth--;
3692 }
3693
3694 _PUBLIC_ enum ndr_err_code ndr_push_samr_RidWithAttributeArray(struct ndr_push *ndr, int ndr_flags, const struct samr_RidWithAttributeArray *r)
3695 {
3696         uint32_t cntr_rids_1;
3697         if (ndr_flags & NDR_SCALARS) {
3698                 NDR_CHECK(ndr_push_align(ndr, 4));
3699                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3700                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->rids));
3701         }
3702         if (ndr_flags & NDR_BUFFERS) {
3703                 if (r->rids) {
3704                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3705                         for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {
3706                                 NDR_CHECK(ndr_push_samr_RidWithAttribute(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));
3707                         }
3708                 }
3709         }
3710         return NDR_ERR_SUCCESS;
3711 }
3712
3713 _PUBLIC_ enum ndr_err_code ndr_pull_samr_RidWithAttributeArray(struct ndr_pull *ndr, int ndr_flags, struct samr_RidWithAttributeArray *r)
3714 {
3715         uint32_t _ptr_rids;
3716         uint32_t cntr_rids_1;
3717         TALLOC_CTX *_mem_save_rids_0;
3718         TALLOC_CTX *_mem_save_rids_1;
3719         if (ndr_flags & NDR_SCALARS) {
3720                 NDR_CHECK(ndr_pull_align(ndr, 4));
3721                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3722                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
3723                 if (_ptr_rids) {
3724                         NDR_PULL_ALLOC(ndr, r->rids);
3725                 } else {
3726                         r->rids = NULL;
3727                 }
3728         }
3729         if (ndr_flags & NDR_BUFFERS) {
3730                 if (r->rids) {
3731                         _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
3732                         NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
3733                         NDR_CHECK(ndr_pull_array_size(ndr, &r->rids));
3734                         NDR_PULL_ALLOC_N(ndr, r->rids, ndr_get_array_size(ndr, &r->rids));
3735                         _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
3736                         NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
3737                         for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {
3738                                 NDR_CHECK(ndr_pull_samr_RidWithAttribute(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));
3739                         }
3740                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
3741                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
3742                 }
3743                 if (r->rids) {
3744                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->rids, r->count));
3745                 }
3746         }
3747         return NDR_ERR_SUCCESS;
3748 }
3749
3750 _PUBLIC_ void ndr_print_samr_RidWithAttributeArray(struct ndr_print *ndr, const char *name, const struct samr_RidWithAttributeArray *r)
3751 {
3752         uint32_t cntr_rids_1;
3753         ndr_print_struct(ndr, name, "samr_RidWithAttributeArray");
3754         ndr->depth++;
3755         ndr_print_uint32(ndr, "count", r->count);
3756         ndr_print_ptr(ndr, "rids", r->rids);
3757         ndr->depth++;
3758         if (r->rids) {
3759                 ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->count);
3760                 ndr->depth++;
3761                 for (cntr_rids_1=0;cntr_rids_1<r->count;cntr_rids_1++) {
3762                         char *idx_1=NULL;
3763                         if (asprintf(&idx_1, "[%d]", cntr_rids_1) != -1) {
3764                                 ndr_print_samr_RidWithAttribute(ndr, "rids", &r->rids[cntr_rids_1]);
3765                                 free(idx_1);
3766                         }
3767                 }
3768                 ndr->depth--;
3769         }
3770         ndr->depth--;
3771         ndr->depth--;
3772 }
3773
3774 static enum ndr_err_code ndr_push_samr_DispEntryGeneral(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryGeneral *r)
3775 {
3776         if (ndr_flags & NDR_SCALARS) {
3777                 NDR_CHECK(ndr_push_align(ndr, 4));
3778                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
3779                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
3780                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
3781                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
3782                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
3783                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
3784         }
3785         if (ndr_flags & NDR_BUFFERS) {
3786                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
3787                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
3788                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
3789         }
3790         return NDR_ERR_SUCCESS;
3791 }
3792
3793 static enum ndr_err_code ndr_pull_samr_DispEntryGeneral(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryGeneral *r)
3794 {
3795         if (ndr_flags & NDR_SCALARS) {
3796                 NDR_CHECK(ndr_pull_align(ndr, 4));
3797                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
3798                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
3799                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
3800                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
3801                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
3802                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
3803         }
3804         if (ndr_flags & NDR_BUFFERS) {
3805                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
3806                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
3807                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
3808         }
3809         return NDR_ERR_SUCCESS;
3810 }
3811
3812 _PUBLIC_ void ndr_print_samr_DispEntryGeneral(struct ndr_print *ndr, const char *name, const struct samr_DispEntryGeneral *r)
3813 {
3814         ndr_print_struct(ndr, name, "samr_DispEntryGeneral");
3815         ndr->depth++;
3816         ndr_print_uint32(ndr, "idx", r->idx);
3817         ndr_print_uint32(ndr, "rid", r->rid);
3818         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
3819         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
3820         ndr_print_lsa_String(ndr, "description", &r->description);
3821         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
3822         ndr->depth--;
3823 }
3824
3825 static enum ndr_err_code ndr_push_samr_DispInfoGeneral(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoGeneral *r)
3826 {
3827         uint32_t cntr_entries_1;
3828         if (ndr_flags & NDR_SCALARS) {
3829                 NDR_CHECK(ndr_push_align(ndr, 4));
3830                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3831                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
3832         }
3833         if (ndr_flags & NDR_BUFFERS) {
3834                 if (r->entries) {
3835                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3836                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
3837                                 NDR_CHECK(ndr_push_samr_DispEntryGeneral(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
3838                         }
3839                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
3840                                 NDR_CHECK(ndr_push_samr_DispEntryGeneral(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
3841                         }
3842                 }
3843         }
3844         return NDR_ERR_SUCCESS;
3845 }
3846
3847 static enum ndr_err_code ndr_pull_samr_DispInfoGeneral(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoGeneral *r)
3848 {
3849         uint32_t _ptr_entries;
3850         uint32_t cntr_entries_1;
3851         TALLOC_CTX *_mem_save_entries_0;
3852         TALLOC_CTX *_mem_save_entries_1;
3853         if (ndr_flags & NDR_SCALARS) {
3854                 NDR_CHECK(ndr_pull_align(ndr, 4));
3855                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3856                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
3857                 if (_ptr_entries) {
3858                         NDR_PULL_ALLOC(ndr, r->entries);
3859                 } else {
3860                         r->entries = NULL;
3861                 }
3862         }
3863         if (ndr_flags & NDR_BUFFERS) {
3864                 if (r->entries) {
3865                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
3866                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
3867                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
3868                         NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
3869                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
3870                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
3871                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
3872                                 NDR_CHECK(ndr_pull_samr_DispEntryGeneral(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
3873                         }
3874                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
3875                                 NDR_CHECK(ndr_pull_samr_DispEntryGeneral(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
3876                         }
3877                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
3878                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
3879                 }
3880                 if (r->entries) {
3881                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
3882                 }
3883         }
3884         return NDR_ERR_SUCCESS;
3885 }
3886
3887 _PUBLIC_ void ndr_print_samr_DispInfoGeneral(struct ndr_print *ndr, const char *name, const struct samr_DispInfoGeneral *r)
3888 {
3889         uint32_t cntr_entries_1;
3890         ndr_print_struct(ndr, name, "samr_DispInfoGeneral");
3891         ndr->depth++;
3892         ndr_print_uint32(ndr, "count", r->count);
3893         ndr_print_ptr(ndr, "entries", r->entries);
3894         ndr->depth++;
3895         if (r->entries) {
3896                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
3897                 ndr->depth++;
3898                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
3899                         char *idx_1=NULL;
3900                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
3901                                 ndr_print_samr_DispEntryGeneral(ndr, "entries", &r->entries[cntr_entries_1]);
3902                                 free(idx_1);
3903                         }
3904                 }
3905                 ndr->depth--;
3906         }
3907         ndr->depth--;
3908         ndr->depth--;
3909 }
3910
3911 static enum ndr_err_code ndr_push_samr_DispEntryFull(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryFull *r)
3912 {
3913         if (ndr_flags & NDR_SCALARS) {
3914                 NDR_CHECK(ndr_push_align(ndr, 4));
3915                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
3916                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
3917                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
3918                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
3919                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
3920         }
3921         if (ndr_flags & NDR_BUFFERS) {
3922                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
3923                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
3924         }
3925         return NDR_ERR_SUCCESS;
3926 }
3927
3928 static enum ndr_err_code ndr_pull_samr_DispEntryFull(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryFull *r)
3929 {
3930         if (ndr_flags & NDR_SCALARS) {
3931                 NDR_CHECK(ndr_pull_align(ndr, 4));
3932                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
3933                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
3934                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
3935                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
3936                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
3937         }
3938         if (ndr_flags & NDR_BUFFERS) {
3939                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
3940                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
3941         }
3942         return NDR_ERR_SUCCESS;
3943 }
3944
3945 _PUBLIC_ void ndr_print_samr_DispEntryFull(struct ndr_print *ndr, const char *name, const struct samr_DispEntryFull *r)
3946 {
3947         ndr_print_struct(ndr, name, "samr_DispEntryFull");
3948         ndr->depth++;
3949         ndr_print_uint32(ndr, "idx", r->idx);
3950         ndr_print_uint32(ndr, "rid", r->rid);
3951         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
3952         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
3953         ndr_print_lsa_String(ndr, "description", &r->description);
3954         ndr->depth--;
3955 }
3956
3957 static enum ndr_err_code ndr_push_samr_DispInfoFull(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoFull *r)
3958 {
3959         uint32_t cntr_entries_1;
3960         if (ndr_flags & NDR_SCALARS) {
3961                 NDR_CHECK(ndr_push_align(ndr, 4));
3962                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3963                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
3964         }
3965         if (ndr_flags & NDR_BUFFERS) {
3966                 if (r->entries) {
3967                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3968                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
3969                                 NDR_CHECK(ndr_push_samr_DispEntryFull(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
3970                         }
3971                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
3972                                 NDR_CHECK(ndr_push_samr_DispEntryFull(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
3973                         }
3974                 }
3975         }
3976         return NDR_ERR_SUCCESS;
3977 }
3978
3979 static enum ndr_err_code ndr_pull_samr_DispInfoFull(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoFull *r)
3980 {
3981         uint32_t _ptr_entries;
3982         uint32_t cntr_entries_1;
3983         TALLOC_CTX *_mem_save_entries_0;
3984         TALLOC_CTX *_mem_save_entries_1;
3985         if (ndr_flags & NDR_SCALARS) {
3986                 NDR_CHECK(ndr_pull_align(ndr, 4));
3987                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3988                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
3989                 if (_ptr_entries) {
3990                         NDR_PULL_ALLOC(ndr, r->entries);
3991                 } else {
3992                         r->entries = NULL;
3993                 }
3994         }
3995         if (ndr_flags & NDR_BUFFERS) {
3996                 if (r->entries) {
3997                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
3998                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
3999                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
4000                         NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
4001                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
4002                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4003                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4004                                 NDR_CHECK(ndr_pull_samr_DispEntryFull(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4005                         }
4006                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4007                                 NDR_CHECK(ndr_pull_samr_DispEntryFull(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4008                         }
4009                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
4010                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
4011                 }
4012                 if (r->entries) {
4013                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
4014                 }
4015         }
4016         return NDR_ERR_SUCCESS;
4017 }
4018
4019 _PUBLIC_ void ndr_print_samr_DispInfoFull(struct ndr_print *ndr, const char *name, const struct samr_DispInfoFull *r)
4020 {
4021         uint32_t cntr_entries_1;
4022         ndr_print_struct(ndr, name, "samr_DispInfoFull");
4023         ndr->depth++;
4024         ndr_print_uint32(ndr, "count", r->count);
4025         ndr_print_ptr(ndr, "entries", r->entries);
4026         ndr->depth++;
4027         if (r->entries) {
4028                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
4029                 ndr->depth++;
4030                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
4031                         char *idx_1=NULL;
4032                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
4033                                 ndr_print_samr_DispEntryFull(ndr, "entries", &r->entries[cntr_entries_1]);
4034                                 free(idx_1);
4035                         }
4036                 }
4037                 ndr->depth--;
4038         }
4039         ndr->depth--;
4040         ndr->depth--;
4041 }
4042
4043 static enum ndr_err_code ndr_push_samr_DispEntryFullGroup(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryFullGroup *r)
4044 {
4045         if (ndr_flags & NDR_SCALARS) {
4046                 NDR_CHECK(ndr_push_align(ndr, 4));
4047                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
4048                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
4049                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->acct_flags));
4050                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
4051                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
4052         }
4053         if (ndr_flags & NDR_BUFFERS) {
4054                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
4055                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
4056         }
4057         return NDR_ERR_SUCCESS;
4058 }
4059
4060 static enum ndr_err_code ndr_pull_samr_DispEntryFullGroup(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryFullGroup *r)
4061 {
4062         if (ndr_flags & NDR_SCALARS) {
4063                 NDR_CHECK(ndr_pull_align(ndr, 4));
4064                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
4065                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
4066                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->acct_flags));
4067                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
4068                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
4069         }
4070         if (ndr_flags & NDR_BUFFERS) {
4071                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
4072                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
4073         }
4074         return NDR_ERR_SUCCESS;
4075 }
4076
4077 _PUBLIC_ void ndr_print_samr_DispEntryFullGroup(struct ndr_print *ndr, const char *name, const struct samr_DispEntryFullGroup *r)
4078 {
4079         ndr_print_struct(ndr, name, "samr_DispEntryFullGroup");
4080         ndr->depth++;
4081         ndr_print_uint32(ndr, "idx", r->idx);
4082         ndr_print_uint32(ndr, "rid", r->rid);
4083         ndr_print_samr_GroupAttrs(ndr, "acct_flags", r->acct_flags);
4084         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
4085         ndr_print_lsa_String(ndr, "description", &r->description);
4086         ndr->depth--;
4087 }
4088
4089 static enum ndr_err_code ndr_push_samr_DispInfoFullGroups(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoFullGroups *r)
4090 {
4091         uint32_t cntr_entries_1;
4092         if (ndr_flags & NDR_SCALARS) {
4093                 NDR_CHECK(ndr_push_align(ndr, 4));
4094                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4095                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
4096         }
4097         if (ndr_flags & NDR_BUFFERS) {
4098                 if (r->entries) {
4099                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4100                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4101                                 NDR_CHECK(ndr_push_samr_DispEntryFullGroup(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4102                         }
4103                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4104                                 NDR_CHECK(ndr_push_samr_DispEntryFullGroup(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4105                         }
4106                 }
4107         }
4108         return NDR_ERR_SUCCESS;
4109 }
4110
4111 static enum ndr_err_code ndr_pull_samr_DispInfoFullGroups(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoFullGroups *r)
4112 {
4113         uint32_t _ptr_entries;
4114         uint32_t cntr_entries_1;
4115         TALLOC_CTX *_mem_save_entries_0;
4116         TALLOC_CTX *_mem_save_entries_1;
4117         if (ndr_flags & NDR_SCALARS) {
4118                 NDR_CHECK(ndr_pull_align(ndr, 4));
4119                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4120                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
4121                 if (_ptr_entries) {
4122                         NDR_PULL_ALLOC(ndr, r->entries);
4123                 } else {
4124                         r->entries = NULL;
4125                 }
4126         }
4127         if (ndr_flags & NDR_BUFFERS) {
4128                 if (r->entries) {
4129                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
4130                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4131                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
4132                         NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
4133                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
4134                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4135                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4136                                 NDR_CHECK(ndr_pull_samr_DispEntryFullGroup(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4137                         }
4138                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4139                                 NDR_CHECK(ndr_pull_samr_DispEntryFullGroup(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4140                         }
4141                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
4142                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
4143                 }
4144                 if (r->entries) {
4145                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
4146                 }
4147         }
4148         return NDR_ERR_SUCCESS;
4149 }
4150
4151 _PUBLIC_ void ndr_print_samr_DispInfoFullGroups(struct ndr_print *ndr, const char *name, const struct samr_DispInfoFullGroups *r)
4152 {
4153         uint32_t cntr_entries_1;
4154         ndr_print_struct(ndr, name, "samr_DispInfoFullGroups");
4155         ndr->depth++;
4156         ndr_print_uint32(ndr, "count", r->count);
4157         ndr_print_ptr(ndr, "entries", r->entries);
4158         ndr->depth++;
4159         if (r->entries) {
4160                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
4161                 ndr->depth++;
4162                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
4163                         char *idx_1=NULL;
4164                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
4165                                 ndr_print_samr_DispEntryFullGroup(ndr, "entries", &r->entries[cntr_entries_1]);
4166                                 free(idx_1);
4167                         }
4168                 }
4169                 ndr->depth--;
4170         }
4171         ndr->depth--;
4172         ndr->depth--;
4173 }
4174
4175 static enum ndr_err_code ndr_push_samr_DispEntryAscii(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryAscii *r)
4176 {
4177         if (ndr_flags & NDR_SCALARS) {
4178                 NDR_CHECK(ndr_push_align(ndr, 4));
4179                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
4180                 NDR_CHECK(ndr_push_lsa_AsciiStringLarge(ndr, NDR_SCALARS, &r->account_name));
4181         }
4182         if (ndr_flags & NDR_BUFFERS) {
4183                 NDR_CHECK(ndr_push_lsa_AsciiStringLarge(ndr, NDR_BUFFERS, &r->account_name));
4184         }
4185         return NDR_ERR_SUCCESS;
4186 }
4187
4188 static enum ndr_err_code ndr_pull_samr_DispEntryAscii(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryAscii *r)
4189 {
4190         if (ndr_flags & NDR_SCALARS) {
4191                 NDR_CHECK(ndr_pull_align(ndr, 4));
4192                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
4193                 NDR_CHECK(ndr_pull_lsa_AsciiStringLarge(ndr, NDR_SCALARS, &r->account_name));
4194         }
4195         if (ndr_flags & NDR_BUFFERS) {
4196                 NDR_CHECK(ndr_pull_lsa_AsciiStringLarge(ndr, NDR_BUFFERS, &r->account_name));
4197         }
4198         return NDR_ERR_SUCCESS;
4199 }
4200
4201 _PUBLIC_ void ndr_print_samr_DispEntryAscii(struct ndr_print *ndr, const char *name, const struct samr_DispEntryAscii *r)
4202 {
4203         ndr_print_struct(ndr, name, "samr_DispEntryAscii");
4204         ndr->depth++;
4205         ndr_print_uint32(ndr, "idx", r->idx);
4206         ndr_print_lsa_AsciiStringLarge(ndr, "account_name", &r->account_name);
4207         ndr->depth--;
4208 }
4209
4210 static enum ndr_err_code ndr_push_samr_DispInfoAscii(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoAscii *r)
4211 {
4212         uint32_t cntr_entries_1;
4213         if (ndr_flags & NDR_SCALARS) {
4214                 NDR_CHECK(ndr_push_align(ndr, 4));
4215                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4216                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
4217         }
4218         if (ndr_flags & NDR_BUFFERS) {
4219                 if (r->entries) {
4220                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4221                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4222                                 NDR_CHECK(ndr_push_samr_DispEntryAscii(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4223                         }
4224                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4225                                 NDR_CHECK(ndr_push_samr_DispEntryAscii(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4226                         }
4227                 }
4228         }
4229         return NDR_ERR_SUCCESS;
4230 }
4231
4232 static enum ndr_err_code ndr_pull_samr_DispInfoAscii(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoAscii *r)
4233 {
4234         uint32_t _ptr_entries;
4235         uint32_t cntr_entries_1;
4236         TALLOC_CTX *_mem_save_entries_0;
4237         TALLOC_CTX *_mem_save_entries_1;
4238         if (ndr_flags & NDR_SCALARS) {
4239                 NDR_CHECK(ndr_pull_align(ndr, 4));
4240                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4241                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
4242                 if (_ptr_entries) {
4243                         NDR_PULL_ALLOC(ndr, r->entries);
4244                 } else {
4245                         r->entries = NULL;
4246                 }
4247         }
4248         if (ndr_flags & NDR_BUFFERS) {
4249                 if (r->entries) {
4250                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
4251                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4252                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
4253                         NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
4254                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
4255                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4256                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4257                                 NDR_CHECK(ndr_pull_samr_DispEntryAscii(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4258                         }
4259                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4260                                 NDR_CHECK(ndr_pull_samr_DispEntryAscii(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4261                         }
4262                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
4263                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
4264                 }
4265                 if (r->entries) {
4266                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
4267                 }
4268         }
4269         return NDR_ERR_SUCCESS;
4270 }
4271
4272 _PUBLIC_ void ndr_print_samr_DispInfoAscii(struct ndr_print *ndr, const char *name, const struct samr_DispInfoAscii *r)
4273 {
4274         uint32_t cntr_entries_1;
4275         ndr_print_struct(ndr, name, "samr_DispInfoAscii");
4276         ndr->depth++;
4277         ndr_print_uint32(ndr, "count", r->count);
4278         ndr_print_ptr(ndr, "entries", r->entries);
4279         ndr->depth++;
4280         if (r->entries) {
4281                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
4282                 ndr->depth++;
4283                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
4284                         char *idx_1=NULL;
4285                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
4286                                 ndr_print_samr_DispEntryAscii(ndr, "entries", &r->entries[cntr_entries_1]);
4287                                 free(idx_1);
4288                         }
4289                 }
4290                 ndr->depth--;
4291         }
4292         ndr->depth--;
4293         ndr->depth--;
4294 }
4295
4296 static enum ndr_err_code ndr_push_samr_DispInfo(struct ndr_push *ndr, int ndr_flags, const union samr_DispInfo *r)
4297 {
4298         if (ndr_flags & NDR_SCALARS) {
4299                 int level = ndr_push_get_switch_value(ndr, r);
4300                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
4301                 switch (level) {
4302                         case 1: {
4303                                 NDR_CHECK(ndr_push_samr_DispInfoGeneral(ndr, NDR_SCALARS, &r->info1));
4304                         break; }
4305
4306                         case 2: {
4307                                 NDR_CHECK(ndr_push_samr_DispInfoFull(ndr, NDR_SCALARS, &r->info2));
4308                         break; }
4309
4310                         case 3: {
4311                                 NDR_CHECK(ndr_push_samr_DispInfoFullGroups(ndr, NDR_SCALARS, &r->info3));
4312                         break; }
4313
4314                         case 4: {
4315                                 NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info4));
4316                         break; }
4317
4318                         case 5: {
4319                                 NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info5));
4320                         break; }
4321
4322                         default:
4323                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4324                 }
4325         }
4326         if (ndr_flags & NDR_BUFFERS) {
4327                 int level = ndr_push_get_switch_value(ndr, r);
4328                 switch (level) {
4329                         case 1:
4330                                 NDR_CHECK(ndr_push_samr_DispInfoGeneral(ndr, NDR_BUFFERS, &r->info1));
4331                         break;
4332
4333                         case 2:
4334                                 NDR_CHECK(ndr_push_samr_DispInfoFull(ndr, NDR_BUFFERS, &r->info2));
4335                         break;
4336
4337                         case 3:
4338                                 NDR_CHECK(ndr_push_samr_DispInfoFullGroups(ndr, NDR_BUFFERS, &r->info3));
4339                         break;
4340
4341                         case 4:
4342                                 NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info4));
4343                         break;
4344
4345                         case 5:
4346                                 NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info5));
4347                         break;
4348
4349                         default:
4350                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4351                 }
4352         }
4353         return NDR_ERR_SUCCESS;
4354 }
4355
4356 static enum ndr_err_code ndr_pull_samr_DispInfo(struct ndr_pull *ndr, int ndr_flags, union samr_DispInfo *r)
4357 {
4358         int level;
4359         uint16_t _level;
4360         level = ndr_pull_get_switch_value(ndr, r);
4361         if (ndr_flags & NDR_SCALARS) {
4362                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
4363                 if (_level != level) {
4364                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4365                 }
4366                 switch (level) {
4367                         case 1: {
4368                                 NDR_CHECK(ndr_pull_samr_DispInfoGeneral(ndr, NDR_SCALARS, &r->info1));
4369                         break; }
4370
4371                         case 2: {
4372                                 NDR_CHECK(ndr_pull_samr_DispInfoFull(ndr, NDR_SCALARS, &r->info2));
4373                         break; }
4374
4375                         case 3: {
4376                                 NDR_CHECK(ndr_pull_samr_DispInfoFullGroups(ndr, NDR_SCALARS, &r->info3));
4377                         break; }
4378
4379                         case 4: {
4380                                 NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info4));
4381                         break; }
4382
4383                         case 5: {
4384                                 NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info5));
4385                         break; }
4386
4387                         default:
4388                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4389                 }
4390         }
4391         if (ndr_flags & NDR_BUFFERS) {
4392                 switch (level) {
4393                         case 1:
4394                                 NDR_CHECK(ndr_pull_samr_DispInfoGeneral(ndr, NDR_BUFFERS, &r->info1));
4395                         break;
4396
4397                         case 2:
4398                                 NDR_CHECK(ndr_pull_samr_DispInfoFull(ndr, NDR_BUFFERS, &r->info2));
4399                         break;
4400
4401                         case 3:
4402                                 NDR_CHECK(ndr_pull_samr_DispInfoFullGroups(ndr, NDR_BUFFERS, &r->info3));
4403                         break;
4404
4405                         case 4:
4406                                 NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info4));
4407                         break;
4408
4409                         case 5:
4410                                 NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info5));
4411                         break;
4412
4413                         default:
4414                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4415                 }
4416         }
4417         return NDR_ERR_SUCCESS;
4418 }
4419
4420 _PUBLIC_ void ndr_print_samr_DispInfo(struct ndr_print *ndr, const char *name, const union samr_DispInfo *r)
4421 {
4422         int level;
4423         level = ndr_print_get_switch_value(ndr, r);
4424         ndr_print_union(ndr, name, level, "samr_DispInfo");
4425         switch (level) {
4426                 case 1:
4427                         ndr_print_samr_DispInfoGeneral(ndr, "info1", &r->info1);
4428                 break;
4429
4430                 case 2:
4431                         ndr_print_samr_DispInfoFull(ndr, "info2", &r->info2);
4432                 break;
4433
4434                 case 3:
4435                         ndr_print_samr_DispInfoFullGroups(ndr, "info3", &r->info3);
4436                 break;
4437
4438                 case 4:
4439                         ndr_print_samr_DispInfoAscii(ndr, "info4", &r->info4);
4440                 break;
4441
4442                 case 5:
4443                         ndr_print_samr_DispInfoAscii(ndr, "info5", &r->info5);
4444                 break;
4445
4446                 default:
4447                         ndr_print_bad_level(ndr, name, level);
4448         }
4449 }
4450
4451 static enum ndr_err_code ndr_push_samr_PwInfo(struct ndr_push *ndr, int ndr_flags, const struct samr_PwInfo *r)
4452 {
4453         if (ndr_flags & NDR_SCALARS) {
4454                 NDR_CHECK(ndr_push_align(ndr, 4));
4455                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->min_password_length));
4456                 NDR_CHECK(ndr_push_samr_PasswordProperties(ndr, NDR_SCALARS, r->password_properties));
4457         }
4458         if (ndr_flags & NDR_BUFFERS) {
4459         }
4460         return NDR_ERR_SUCCESS;
4461 }
4462
4463 static enum ndr_err_code ndr_pull_samr_PwInfo(struct ndr_pull *ndr, int ndr_flags, struct samr_PwInfo *r)
4464 {
4465         if (ndr_flags & NDR_SCALARS) {
4466                 NDR_CHECK(ndr_pull_align(ndr, 4));
4467                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->min_password_length));
4468                 NDR_CHECK(ndr_pull_samr_PasswordProperties(ndr, NDR_SCALARS, &r->password_properties));
4469         }
4470         if (ndr_flags & NDR_BUFFERS) {
4471         }
4472         return NDR_ERR_SUCCESS;
4473 }
4474
4475 _PUBLIC_ void ndr_print_samr_PwInfo(struct ndr_print *ndr, const char *name, const struct samr_PwInfo *r)
4476 {
4477         ndr_print_struct(ndr, name, "samr_PwInfo");
4478         ndr->depth++;
4479         ndr_print_uint16(ndr, "min_password_length", r->min_password_length);
4480         ndr_print_samr_PasswordProperties(ndr, "password_properties", r->password_properties);
4481         ndr->depth--;
4482 }
4483
4484 static enum ndr_err_code ndr_push_samr_ConnectVersion(struct ndr_push *ndr, int ndr_flags, enum samr_ConnectVersion r)
4485 {
4486         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
4487         return NDR_ERR_SUCCESS;
4488 }
4489
4490 static enum ndr_err_code ndr_pull_samr_ConnectVersion(struct ndr_pull *ndr, int ndr_flags, enum samr_ConnectVersion *r)
4491 {
4492         uint16_t v;
4493         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
4494         *r = v;
4495         return NDR_ERR_SUCCESS;
4496 }
4497
4498 _PUBLIC_ void ndr_print_samr_ConnectVersion(struct ndr_print *ndr, const char *name, enum samr_ConnectVersion r)
4499 {
4500         const char *val = NULL;
4501
4502         switch (r) {
4503                 case SAMR_CONNECT_PRE_W2K: val = "SAMR_CONNECT_PRE_W2K"; break;
4504                 case SAMR_CONNECT_W2K: val = "SAMR_CONNECT_W2K"; break;
4505                 case SAMR_CONNECT_AFTER_W2K: val = "SAMR_CONNECT_AFTER_W2K"; break;
4506         }
4507         ndr_print_enum(ndr, name, "ENUM", val, r);
4508 }
4509
4510 static enum ndr_err_code ndr_push_samr_ChangeReject(struct ndr_push *ndr, int ndr_flags, const struct samr_ChangeReject *r)
4511 {
4512         if (ndr_flags & NDR_SCALARS) {
4513                 NDR_CHECK(ndr_push_align(ndr, 4));
4514                 NDR_CHECK(ndr_push_samr_RejectReason(ndr, NDR_SCALARS, r->reason));
4515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
4516                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
4517         }
4518         if (ndr_flags & NDR_BUFFERS) {
4519         }
4520         return NDR_ERR_SUCCESS;
4521 }
4522
4523 static enum ndr_err_code ndr_pull_samr_ChangeReject(struct ndr_pull *ndr, int ndr_flags, struct samr_ChangeReject *r)
4524 {
4525         if (ndr_flags & NDR_SCALARS) {
4526                 NDR_CHECK(ndr_pull_align(ndr, 4));
4527                 NDR_CHECK(ndr_pull_samr_RejectReason(ndr, NDR_SCALARS, &r->reason));
4528                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
4529                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
4530         }
4531         if (ndr_flags & NDR_BUFFERS) {
4532         }
4533         return NDR_ERR_SUCCESS;
4534 }
4535
4536 _PUBLIC_ void ndr_print_samr_ChangeReject(struct ndr_print *ndr, const char *name, const struct samr_ChangeReject *r)
4537 {
4538         ndr_print_struct(ndr, name, "samr_ChangeReject");
4539         ndr->depth++;
4540         ndr_print_samr_RejectReason(ndr, "reason", r->reason);
4541         ndr_print_uint32(ndr, "unknown1", r->unknown1);
4542         ndr_print_uint32(ndr, "unknown2", r->unknown2);
4543         ndr->depth--;
4544 }
4545
4546 static enum ndr_err_code ndr_push_samr_ConnectInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_ConnectInfo1 *r)
4547 {
4548         if (ndr_flags & NDR_SCALARS) {
4549                 NDR_CHECK(ndr_push_align(ndr, 4));
4550                 NDR_CHECK(ndr_push_samr_ConnectVersion(ndr, NDR_SCALARS, r->client_version));
4551                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
4552         }
4553         if (ndr_flags & NDR_BUFFERS) {
4554         }
4555         return NDR_ERR_SUCCESS;
4556 }
4557
4558 static enum ndr_err_code ndr_pull_samr_ConnectInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_ConnectInfo1 *r)
4559 {
4560         if (ndr_flags & NDR_SCALARS) {
4561                 NDR_CHECK(ndr_pull_align(ndr, 4));
4562                 NDR_CHECK(ndr_pull_samr_ConnectVersion(ndr, NDR_SCALARS, &r->client_version));
4563                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
4564         }
4565         if (ndr_flags & NDR_BUFFERS) {
4566         }
4567         return NDR_ERR_SUCCESS;
4568 }
4569
4570 _PUBLIC_ void ndr_print_samr_ConnectInfo1(struct ndr_print *ndr, const char *name, const struct samr_ConnectInfo1 *r)
4571 {
4572         ndr_print_struct(ndr, name, "samr_ConnectInfo1");
4573         ndr->depth++;
4574         ndr_print_samr_ConnectVersion(ndr, "client_version", r->client_version);
4575         ndr_print_uint32(ndr, "unknown2", r->unknown2);
4576         ndr->depth--;
4577 }
4578
4579 static enum ndr_err_code ndr_push_samr_ConnectInfo(struct ndr_push *ndr, int ndr_flags, const union samr_ConnectInfo *r)
4580 {
4581         if (ndr_flags & NDR_SCALARS) {
4582                 int level = ndr_push_get_switch_value(ndr, r);
4583                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4584                 switch (level) {
4585                         case 1: {
4586                                 NDR_CHECK(ndr_push_samr_ConnectInfo1(ndr, NDR_SCALARS, &r->info1));
4587                         break; }
4588
4589                         default:
4590                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4591                 }
4592         }
4593         if (ndr_flags & NDR_BUFFERS) {
4594                 int level = ndr_push_get_switch_value(ndr, r);
4595                 switch (level) {
4596                         case 1:
4597                         break;
4598
4599                         default:
4600                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4601                 }
4602         }
4603         return NDR_ERR_SUCCESS;
4604 }
4605
4606 static enum ndr_err_code ndr_pull_samr_ConnectInfo(struct ndr_pull *ndr, int ndr_flags, union samr_ConnectInfo *r)
4607 {
4608         int level;
4609         uint32_t _level;
4610         level = ndr_pull_get_switch_value(ndr, r);
4611         if (ndr_flags & NDR_SCALARS) {
4612                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4613                 if (_level != level) {
4614                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4615                 }
4616                 switch (level) {
4617                         case 1: {
4618                                 NDR_CHECK(ndr_pull_samr_ConnectInfo1(ndr, NDR_SCALARS, &r->info1));
4619                         break; }
4620
4621                         default:
4622                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4623                 }
4624         }
4625         if (ndr_flags & NDR_BUFFERS) {
4626                 switch (level) {
4627                         case 1:
4628                         break;
4629
4630                         default:
4631                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4632                 }
4633         }
4634         return NDR_ERR_SUCCESS;
4635 }
4636
4637 _PUBLIC_ void ndr_print_samr_ConnectInfo(struct ndr_print *ndr, const char *name, const union samr_ConnectInfo *r)
4638 {
4639         int level;
4640         level = ndr_print_get_switch_value(ndr, r);
4641         ndr_print_union(ndr, name, level, "samr_ConnectInfo");
4642         switch (level) {
4643                 case 1:
4644                         ndr_print_samr_ConnectInfo1(ndr, "info1", &r->info1);
4645                 break;
4646
4647                 default:
4648                         ndr_print_bad_level(ndr, name, level);
4649         }
4650 }
4651
4652 static enum ndr_err_code ndr_push_samr_ValidateFieldsPresent(struct ndr_push *ndr, int ndr_flags, uint32_t r)
4653 {
4654         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4655         return NDR_ERR_SUCCESS;
4656 }
4657
4658 static enum ndr_err_code ndr_pull_samr_ValidateFieldsPresent(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
4659 {
4660         uint32_t v;
4661         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4662         *r = v;
4663         return NDR_ERR_SUCCESS;
4664 }
4665
4666 _PUBLIC_ void ndr_print_samr_ValidateFieldsPresent(struct ndr_print *ndr, const char *name, uint32_t r)
4667 {
4668         ndr_print_uint32(ndr, name, r);
4669         ndr->depth++;
4670         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_LAST_SET", SAMR_VALIDATE_FIELD_PASSWORD_LAST_SET, r);
4671         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_BAD_PASSWORD_TIME", SAMR_VALIDATE_FIELD_BAD_PASSWORD_TIME, r);
4672         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_LOCKOUT_TIME", SAMR_VALIDATE_FIELD_LOCKOUT_TIME, r);
4673         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_BAD_PASSWORD_COUNT", SAMR_VALIDATE_FIELD_BAD_PASSWORD_COUNT, r);
4674         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_HISTORY_LENGTH", SAMR_VALIDATE_FIELD_PASSWORD_HISTORY_LENGTH, r);
4675         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_HISTORY", SAMR_VALIDATE_FIELD_PASSWORD_HISTORY, r);
4676         ndr->depth--;
4677 }
4678
4679 static enum ndr_err_code ndr_push_samr_ValidatePasswordLevel(struct ndr_push *ndr, int ndr_flags, enum samr_ValidatePasswordLevel r)
4680 {
4681         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
4682         return NDR_ERR_SUCCESS;
4683 }
4684
4685 static enum ndr_err_code ndr_pull_samr_ValidatePasswordLevel(struct ndr_pull *ndr, int ndr_flags, enum samr_ValidatePasswordLevel *r)
4686 {
4687         uint16_t v;
4688         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
4689         *r = v;
4690         return NDR_ERR_SUCCESS;
4691 }
4692
4693 _PUBLIC_ void ndr_print_samr_ValidatePasswordLevel(struct ndr_print *ndr, const char *name, enum samr_ValidatePasswordLevel r)
4694 {
4695         const char *val = NULL;
4696
4697         switch (r) {
4698                 case NetValidateAuthentication: val = "NetValidateAuthentication"; break;
4699                 case NetValidatePasswordChange: val = "NetValidatePasswordChange"; break;
4700                 case NetValidatePasswordReset: val = "NetValidatePasswordReset"; break;
4701         }
4702         ndr_print_enum(ndr, name, "ENUM", val, r);
4703 }
4704
4705 static enum ndr_err_code ndr_push_samr_ValidationStatus(struct ndr_push *ndr, int ndr_flags, enum samr_ValidationStatus r)
4706 {
4707         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
4708         return NDR_ERR_SUCCESS;
4709 }
4710
4711 static enum ndr_err_code ndr_pull_samr_ValidationStatus(struct ndr_pull *ndr, int ndr_flags, enum samr_ValidationStatus *r)
4712 {
4713         uint16_t v;
4714         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
4715         *r = v;
4716         return NDR_ERR_SUCCESS;
4717 }
4718
4719 _PUBLIC_ void ndr_print_samr_ValidationStatus(struct ndr_print *ndr, const char *name, enum samr_ValidationStatus r)
4720 {
4721         const char *val = NULL;
4722
4723         switch (r) {
4724                 case SAMR_VALIDATION_STATUS_SUCCESS: val = "SAMR_VALIDATION_STATUS_SUCCESS"; break;
4725                 case SAMR_VALIDATION_STATUS_PASSWORD_MUST_CHANGE: val = "SAMR_VALIDATION_STATUS_PASSWORD_MUST_CHANGE"; break;
4726                 case SAMR_VALIDATION_STATUS_ACCOUNT_LOCKED_OUT: val = "SAMR_VALIDATION_STATUS_ACCOUNT_LOCKED_OUT"; break;
4727                 case SAMR_VALIDATION_STATUS_BAD_PASSWORD: val = "SAMR_VALIDATION_STATUS_BAD_PASSWORD"; break;
4728                 case SAMR_VALIDATION_STATUS_PWD_HISTORY_CONFLICT: val = "SAMR_VALIDATION_STATUS_PWD_HISTORY_CONFLICT"; break;
4729                 case SAMR_VALIDATION_STATUS_PWD_TOO_SHORT: val = "SAMR_VALIDATION_STATUS_PWD_TOO_SHORT"; break;
4730                 case SAMR_VALIDATION_STATUS_PWD_TOO_LONG: val = "SAMR_VALIDATION_STATUS_PWD_TOO_LONG"; break;
4731                 case SAMR_VALIDATION_STATUS_NOT_COMPLEX_ENOUGH: val = "SAMR_VALIDATION_STATUS_NOT_COMPLEX_ENOUGH"; break;
4732                 case SAMR_VALIDATION_STATUS_PASSWORD_TOO_RECENT: val = "SAMR_VALIDATION_STATUS_PASSWORD_TOO_RECENT"; break;
4733         }
4734         ndr_print_enum(ndr, name, "ENUM", val, r);
4735 }
4736
4737 static enum ndr_err_code ndr_push_samr_ValidationBlob(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidationBlob *r)
4738 {
4739         if (ndr_flags & NDR_SCALARS) {
4740                 NDR_CHECK(ndr_push_align(ndr, 4));
4741                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
4742                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
4743         }
4744         if (ndr_flags & NDR_BUFFERS) {
4745                 if (r->data) {
4746                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
4747                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
4748                 }
4749         }
4750         return NDR_ERR_SUCCESS;
4751 }
4752
4753 static enum ndr_err_code ndr_pull_samr_ValidationBlob(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidationBlob *r)
4754 {
4755         uint32_t _ptr_data;
4756         TALLOC_CTX *_mem_save_data_0;
4757         if (ndr_flags & NDR_SCALARS) {
4758                 NDR_CHECK(ndr_pull_align(ndr, 4));
4759                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
4760                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
4761                 if (_ptr_data) {
4762                         NDR_PULL_ALLOC(ndr, r->data);
4763                 } else {
4764                         r->data = NULL;
4765                 }
4766         }
4767         if (ndr_flags & NDR_BUFFERS) {
4768                 if (r->data) {
4769                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
4770                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
4771                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
4772                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
4773                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
4774                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
4775                 }
4776                 if (r->data) {
4777                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
4778                 }
4779         }
4780         return NDR_ERR_SUCCESS;
4781 }
4782
4783 _PUBLIC_ void ndr_print_samr_ValidationBlob(struct ndr_print *ndr, const char *name, const struct samr_ValidationBlob *r)
4784 {
4785         ndr_print_struct(ndr, name, "samr_ValidationBlob");
4786         ndr->depth++;
4787         ndr_print_uint32(ndr, "length", r->length);
4788         ndr_print_ptr(ndr, "data", r->data);
4789         ndr->depth++;
4790         if (r->data) {
4791                 ndr_print_array_uint8(ndr, "data", r->data, r->length);
4792         }
4793         ndr->depth--;
4794         ndr->depth--;
4795 }
4796
4797 static enum ndr_err_code ndr_push_samr_ValidatePasswordInfo(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordInfo *r)
4798 {
4799         uint32_t cntr_pwd_history_1;
4800         if (ndr_flags & NDR_SCALARS) {
4801                 NDR_CHECK(ndr_push_align(ndr, 8));
4802                 NDR_CHECK(ndr_push_samr_ValidateFieldsPresent(ndr, NDR_SCALARS, r->fields_present));
4803                 NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->last_password_change));
4804                 NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->bad_password_time));
4805                 NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->lockout_time));
4806                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bad_pwd_count));
4807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pwd_history_len));
4808                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pwd_history));
4809         }
4810         if (ndr_flags & NDR_BUFFERS) {
4811                 if (r->pwd_history) {
4812                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pwd_history_len));
4813                         for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {
4814                                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->pwd_history[cntr_pwd_history_1]));
4815                         }
4816                         for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {
4817                                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->pwd_history[cntr_pwd_history_1]));
4818                         }
4819                 }
4820         }
4821         return NDR_ERR_SUCCESS;
4822 }
4823
4824 static enum ndr_err_code ndr_pull_samr_ValidatePasswordInfo(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordInfo *r)
4825 {
4826         uint32_t _ptr_pwd_history;
4827         uint32_t cntr_pwd_history_1;
4828         TALLOC_CTX *_mem_save_pwd_history_0;
4829         TALLOC_CTX *_mem_save_pwd_history_1;
4830         if (ndr_flags & NDR_SCALARS) {
4831                 NDR_CHECK(ndr_pull_align(ndr, 8));
4832                 NDR_CHECK(ndr_pull_samr_ValidateFieldsPresent(ndr, NDR_SCALARS, &r->fields_present));
4833                 NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->last_password_change));
4834                 NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->bad_password_time));
4835                 NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->lockout_time));
4836                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bad_pwd_count));
4837                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pwd_history_len));
4838                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pwd_history));
4839                 if (_ptr_pwd_history) {
4840                         NDR_PULL_ALLOC(ndr, r->pwd_history);
4841                 } else {
4842                         r->pwd_history = NULL;
4843                 }
4844         }
4845         if (ndr_flags & NDR_BUFFERS) {
4846                 if (r->pwd_history) {
4847                         _mem_save_pwd_history_0 = NDR_PULL_GET_MEM_CTX(ndr);
4848                         NDR_PULL_SET_MEM_CTX(ndr, r->pwd_history, 0);
4849                         NDR_CHECK(ndr_pull_array_size(ndr, &r->pwd_history));
4850                         NDR_PULL_ALLOC_N(ndr, r->pwd_history, ndr_get_array_size(ndr, &r->pwd_history));
4851                         _mem_save_pwd_history_1 = NDR_PULL_GET_MEM_CTX(ndr);
4852                         NDR_PULL_SET_MEM_CTX(ndr, r->pwd_history, 0);
4853                         for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {
4854                                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->pwd_history[cntr_pwd_history_1]));
4855                         }
4856                         for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {
4857                                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->pwd_history[cntr_pwd_history_1]));
4858                         }
4859                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pwd_history_1, 0);
4860                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pwd_history_0, 0);
4861                 }
4862                 if (r->pwd_history) {
4863                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->pwd_history, r->pwd_history_len));
4864                 }
4865         }
4866         return NDR_ERR_SUCCESS;
4867 }
4868
4869 _PUBLIC_ void ndr_print_samr_ValidatePasswordInfo(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordInfo *r)
4870 {
4871         uint32_t cntr_pwd_history_1;
4872         ndr_print_struct(ndr, name, "samr_ValidatePasswordInfo");
4873         ndr->depth++;
4874         ndr_print_samr_ValidateFieldsPresent(ndr, "fields_present", r->fields_present);
4875         ndr_print_NTTIME_hyper(ndr, "last_password_change", r->last_password_change);
4876         ndr_print_NTTIME_hyper(ndr, "bad_password_time", r->bad_password_time);
4877         ndr_print_NTTIME_hyper(ndr, "lockout_time", r->lockout_time);
4878         ndr_print_uint32(ndr, "bad_pwd_count", r->bad_pwd_count);
4879         ndr_print_uint32(ndr, "pwd_history_len", r->pwd_history_len);
4880         ndr_print_ptr(ndr, "pwd_history", r->pwd_history);
4881         ndr->depth++;
4882         if (r->pwd_history) {
4883                 ndr->print(ndr, "%s: ARRAY(%d)", "pwd_history", (int)r->pwd_history_len);
4884                 ndr->depth++;
4885                 for (cntr_pwd_history_1=0;cntr_pwd_history_1<r->pwd_history_len;cntr_pwd_history_1++) {
4886                         char *idx_1=NULL;
4887                         if (asprintf(&idx_1, "[%d]", cntr_pwd_history_1) != -1) {
4888                                 ndr_print_samr_ValidationBlob(ndr, "pwd_history", &r->pwd_history[cntr_pwd_history_1]);
4889                                 free(idx_1);
4890                         }
4891                 }
4892                 ndr->depth--;
4893         }
4894         ndr->depth--;
4895         ndr->depth--;
4896 }
4897
4898 static enum ndr_err_code ndr_push_samr_ValidatePasswordRepCtr(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordRepCtr *r)
4899 {
4900         if (ndr_flags & NDR_SCALARS) {
4901                 NDR_CHECK(ndr_push_align(ndr, 8));
4902                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
4903                 NDR_CHECK(ndr_push_samr_ValidationStatus(ndr, NDR_SCALARS, r->status));
4904         }
4905         if (ndr_flags & NDR_BUFFERS) {
4906                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
4907         }
4908         return NDR_ERR_SUCCESS;
4909 }
4910
4911 static enum ndr_err_code ndr_pull_samr_ValidatePasswordRepCtr(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordRepCtr *r)
4912 {
4913         if (ndr_flags & NDR_SCALARS) {
4914                 NDR_CHECK(ndr_pull_align(ndr, 8));
4915                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
4916                 NDR_CHECK(ndr_pull_samr_ValidationStatus(ndr, NDR_SCALARS, &r->status));
4917         }
4918         if (ndr_flags & NDR_BUFFERS) {
4919                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
4920         }
4921         return NDR_ERR_SUCCESS;
4922 }
4923
4924 _PUBLIC_ void ndr_print_samr_ValidatePasswordRepCtr(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordRepCtr *r)
4925 {
4926         ndr_print_struct(ndr, name, "samr_ValidatePasswordRepCtr");
4927         ndr->depth++;
4928         ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
4929         ndr_print_samr_ValidationStatus(ndr, "status", r->status);
4930         ndr->depth--;
4931 }
4932
4933 static enum ndr_err_code ndr_push_samr_ValidatePasswordRep(struct ndr_push *ndr, int ndr_flags, const union samr_ValidatePasswordRep *r)
4934 {
4935         if (ndr_flags & NDR_SCALARS) {
4936                 int level = ndr_push_get_switch_value(ndr, r);
4937                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
4938                 switch (level) {
4939                         case 1: {
4940                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr1));
4941                         break; }
4942
4943                         case 2: {
4944                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr2));
4945                         break; }
4946
4947                         case 3: {
4948                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr3));
4949                         break; }
4950
4951                         default:
4952                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4953                 }
4954         }
4955         if (ndr_flags & NDR_BUFFERS) {
4956                 int level = ndr_push_get_switch_value(ndr, r);
4957                 switch (level) {
4958                         case 1:
4959                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr1));
4960                         break;
4961
4962                         case 2:
4963                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr2));
4964                         break;
4965
4966                         case 3:
4967                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr3));
4968                         break;
4969
4970                         default:
4971                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4972                 }
4973         }
4974         return NDR_ERR_SUCCESS;
4975 }
4976
4977 static enum ndr_err_code ndr_pull_samr_ValidatePasswordRep(struct ndr_pull *ndr, int ndr_flags, union samr_ValidatePasswordRep *r)
4978 {
4979         int level;
4980         uint16_t _level;
4981         level = ndr_pull_get_switch_value(ndr, r);
4982         if (ndr_flags & NDR_SCALARS) {
4983                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
4984                 if (_level != level) {
4985                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4986                 }
4987                 switch (level) {
4988                         case 1: {
4989                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr1));
4990                         break; }
4991
4992                         case 2: {
4993                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr2));
4994                         break; }
4995
4996                         case 3: {
4997                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr3));
4998                         break; }
4999
5000                         default:
5001                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5002                 }
5003         }
5004         if (ndr_flags & NDR_BUFFERS) {
5005                 switch (level) {
5006                         case 1:
5007                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr1));
5008                         break;
5009
5010                         case 2:
5011                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr2));
5012                         break;
5013
5014                         case 3:
5015                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr3));
5016                         break;
5017
5018                         default:
5019                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5020                 }
5021         }
5022         return NDR_ERR_SUCCESS;
5023 }
5024
5025 _PUBLIC_ void ndr_print_samr_ValidatePasswordRep(struct ndr_print *ndr, const char *name, const union samr_ValidatePasswordRep *r)
5026 {
5027         int level;
5028         level = ndr_print_get_switch_value(ndr, r);
5029         ndr_print_union(ndr, name, level, "samr_ValidatePasswordRep");
5030         switch (level) {
5031                 case 1:
5032                         ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr1", &r->ctr1);
5033                 break;
5034
5035                 case 2:
5036                         ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr2", &r->ctr2);
5037                 break;
5038
5039                 case 3:
5040                         ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr3", &r->ctr3);
5041                 break;
5042
5043                 default:
5044                         ndr_print_bad_level(ndr, name, level);
5045         }
5046 }
5047
5048 static enum ndr_err_code ndr_push_samr_ValidatePasswordReq3(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq3 *r)
5049 {
5050         if (ndr_flags & NDR_SCALARS) {
5051                 NDR_CHECK(ndr_push_align(ndr, 8));
5052                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5053                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
5054                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
5055                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
5056                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->pwd_must_change_at_next_logon));
5057                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->clear_lockout));
5058         }
5059         if (ndr_flags & NDR_BUFFERS) {
5060                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5061                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
5062                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
5063                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
5064         }
5065         return NDR_ERR_SUCCESS;
5066 }
5067
5068 static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq3(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq3 *r)
5069 {
5070         if (ndr_flags & NDR_SCALARS) {
5071                 NDR_CHECK(ndr_pull_align(ndr, 8));
5072                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5073                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
5074                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
5075                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
5076                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->pwd_must_change_at_next_logon));
5077                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->clear_lockout));
5078         }
5079         if (ndr_flags & NDR_BUFFERS) {
5080                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5081                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
5082                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
5083                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
5084         }
5085         return NDR_ERR_SUCCESS;
5086 }
5087
5088 _PUBLIC_ void ndr_print_samr_ValidatePasswordReq3(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq3 *r)
5089 {
5090         ndr_print_struct(ndr, name, "samr_ValidatePasswordReq3");
5091         ndr->depth++;
5092         ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
5093         ndr_print_lsa_StringLarge(ndr, "password", &r->password);
5094         ndr_print_lsa_StringLarge(ndr, "account", &r->account);
5095         ndr_print_samr_ValidationBlob(ndr, "hash", &r->hash);
5096         ndr_print_uint8(ndr, "pwd_must_change_at_next_logon", r->pwd_must_change_at_next_logon);
5097         ndr_print_uint8(ndr, "clear_lockout", r->clear_lockout);
5098         ndr->depth--;
5099 }
5100
5101 static enum ndr_err_code ndr_push_samr_ValidatePasswordReq2(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq2 *r)
5102 {
5103         if (ndr_flags & NDR_SCALARS) {
5104                 NDR_CHECK(ndr_push_align(ndr, 8));
5105                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5106                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
5107                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
5108                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
5109                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_matched));
5110         }
5111         if (ndr_flags & NDR_BUFFERS) {
5112                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5113                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
5114                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
5115                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
5116         }
5117         return NDR_ERR_SUCCESS;
5118 }
5119
5120 static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq2(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq2 *r)
5121 {
5122         if (ndr_flags & NDR_SCALARS) {
5123                 NDR_CHECK(ndr_pull_align(ndr, 8));
5124                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5125                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
5126                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
5127                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
5128                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_matched));
5129         }
5130         if (ndr_flags & NDR_BUFFERS) {
5131                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5132                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
5133                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
5134                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
5135         }
5136         return NDR_ERR_SUCCESS;
5137 }
5138
5139 _PUBLIC_ void ndr_print_samr_ValidatePasswordReq2(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq2 *r)
5140 {
5141         ndr_print_struct(ndr, name, "samr_ValidatePasswordReq2");
5142         ndr->depth++;
5143         ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
5144         ndr_print_lsa_StringLarge(ndr, "password", &r->password);
5145         ndr_print_lsa_StringLarge(ndr, "account", &r->account);
5146         ndr_print_samr_ValidationBlob(ndr, "hash", &r->hash);
5147         ndr_print_uint8(ndr, "password_matched", r->password_matched);
5148         ndr->depth--;
5149 }
5150
5151 static enum ndr_err_code ndr_push_samr_ValidatePasswordReq1(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq1 *r)
5152 {
5153         if (ndr_flags & NDR_SCALARS) {
5154                 NDR_CHECK(ndr_push_align(ndr, 8));
5155                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5156                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_matched));
5157         }
5158         if (ndr_flags & NDR_BUFFERS) {
5159                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5160         }
5161         return NDR_ERR_SUCCESS;
5162 }
5163
5164 static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq1(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq1 *r)
5165 {
5166         if (ndr_flags & NDR_SCALARS) {
5167                 NDR_CHECK(ndr_pull_align(ndr, 8));
5168                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5169                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_matched));
5170         }
5171         if (ndr_flags & NDR_BUFFERS) {
5172                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5173         }
5174         return NDR_ERR_SUCCESS;
5175 }
5176
5177 _PUBLIC_ void ndr_print_samr_ValidatePasswordReq1(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq1 *r)
5178 {
5179         ndr_print_struct(ndr, name, "samr_ValidatePasswordReq1");
5180         ndr->depth++;
5181         ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
5182         ndr_print_uint8(ndr, "password_matched", r->password_matched);
5183         ndr->depth--;
5184 }
5185
5186 static enum ndr_err_code ndr_push_samr_ValidatePasswordReq(struct ndr_push *ndr, int ndr_flags, const union samr_ValidatePasswordReq *r)
5187 {
5188         if (ndr_flags & NDR_SCALARS) {
5189                 int level = ndr_push_get_switch_value(ndr, r);
5190                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
5191                 switch (level) {
5192                         case 1: {
5193                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq1(ndr, NDR_SCALARS, &r->req1));
5194                         break; }
5195
5196                         case 2: {
5197                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq2(ndr, NDR_SCALARS, &r->req2));
5198                         break; }
5199
5200                         case 3: {
5201                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq3(ndr, NDR_SCALARS, &r->req3));
5202                         break; }
5203
5204                         default:
5205                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5206                 }
5207         }
5208         if (ndr_flags & NDR_BUFFERS) {
5209                 int level = ndr_push_get_switch_value(ndr, r);
5210                 switch (level) {
5211                         case 1:
5212                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq1(ndr, NDR_BUFFERS, &r->req1));
5213                         break;
5214
5215                         case 2:
5216                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq2(ndr, NDR_BUFFERS, &r->req2));
5217                         break;
5218
5219                         case 3:
5220                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq3(ndr, NDR_BUFFERS, &r->req3));
5221                         break;
5222
5223                         default:
5224                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5225                 }
5226         }
5227         return NDR_ERR_SUCCESS;
5228 }
5229
5230 static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq(struct ndr_pull *ndr, int ndr_flags, union samr_ValidatePasswordReq *r)
5231 {
5232         int level;
5233         uint16_t _level;
5234         level = ndr_pull_get_switch_value(ndr, r);
5235         if (ndr_flags & NDR_SCALARS) {
5236                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
5237                 if (_level != level) {
5238                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5239                 }
5240                 switch (level) {
5241                         case 1: {
5242                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq1(ndr, NDR_SCALARS, &r->req1));
5243                         break; }
5244
5245                         case 2: {
5246                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq2(ndr, NDR_SCALARS, &r->req2));
5247                         break; }
5248
5249                         case 3: {
5250                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq3(ndr, NDR_SCALARS, &r->req3));
5251                         break; }
5252
5253                         default:
5254                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5255                 }
5256         }
5257         if (ndr_flags & NDR_BUFFERS) {
5258                 switch (level) {
5259                         case 1:
5260                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq1(ndr, NDR_BUFFERS, &r->req1));
5261                         break;
5262
5263                         case 2:
5264                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq2(ndr, NDR_BUFFERS, &r->req2));
5265                         break;
5266
5267                         case 3:
5268                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq3(ndr, NDR_BUFFERS, &r->req3));
5269                         break;
5270
5271                         default:
5272                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5273                 }
5274         }
5275         return NDR_ERR_SUCCESS;
5276 }
5277
5278 _PUBLIC_ void ndr_print_samr_ValidatePasswordReq(struct ndr_print *ndr, const char *name, const union samr_ValidatePasswordReq *r)
5279 {
5280         int level;
5281         level = ndr_print_get_switch_value(ndr, r);
5282         ndr_print_union(ndr, name, level, "samr_ValidatePasswordReq");
5283         switch (level) {
5284                 case 1:
5285                         ndr_print_samr_ValidatePasswordReq1(ndr, "req1", &r->req1);
5286                 break;
5287
5288                 case 2:
5289                         ndr_print_samr_ValidatePasswordReq2(ndr, "req2", &r->req2);
5290                 break;
5291
5292                 case 3:
5293                         ndr_print_samr_ValidatePasswordReq3(ndr, "req3", &r->req3);
5294                 break;
5295
5296                 default:
5297                         ndr_print_bad_level(ndr, name, level);
5298         }
5299 }
5300
5301 static enum ndr_err_code ndr_push_samr_Connect(struct ndr_push *ndr, int flags, const struct samr_Connect *r)
5302 {
5303         if (flags & NDR_IN) {
5304                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
5305                 if (r->in.system_name) {
5306                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
5307                 }
5308                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
5309         }
5310         if (flags & NDR_OUT) {
5311                 if (r->out.connect_handle == NULL) {
5312                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5313                 }
5314                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
5315                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5316         }
5317         return NDR_ERR_SUCCESS;
5318 }
5319
5320 static enum ndr_err_code ndr_pull_samr_Connect(struct ndr_pull *ndr, int flags, struct samr_Connect *r)
5321 {
5322         uint32_t _ptr_system_name;
5323         TALLOC_CTX *_mem_save_system_name_0;
5324         TALLOC_CTX *_mem_save_connect_handle_0;
5325         if (flags & NDR_IN) {
5326                 ZERO_STRUCT(r->out);
5327
5328                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
5329                 if (_ptr_system_name) {
5330                         NDR_PULL_ALLOC(ndr, r->in.system_name);
5331                 } else {
5332                         r->in.system_name = NULL;
5333                 }
5334                 if (r->in.system_name) {
5335                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5336                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
5337                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
5338                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
5339                 }
5340                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
5341                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
5342                 ZERO_STRUCTP(r->out.connect_handle);
5343         }
5344         if (flags & NDR_OUT) {
5345                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5346                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
5347                 }
5348                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5349                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
5350                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
5351                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
5352                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5353         }
5354         return NDR_ERR_SUCCESS;
5355 }
5356
5357 _PUBLIC_ void ndr_print_samr_Connect(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect *r)
5358 {
5359         ndr_print_struct(ndr, name, "samr_Connect");
5360         ndr->depth++;
5361         if (flags & NDR_SET_VALUES) {
5362                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5363         }
5364         if (flags & NDR_IN) {
5365                 ndr_print_struct(ndr, "in", "samr_Connect");
5366                 ndr->depth++;
5367                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
5368                 ndr->depth++;
5369                 if (r->in.system_name) {
5370                         ndr_print_uint16(ndr, "system_name", *r->in.system_name);
5371                 }
5372                 ndr->depth--;
5373                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
5374                 ndr->depth--;
5375         }
5376         if (flags & NDR_OUT) {
5377                 ndr_print_struct(ndr, "out", "samr_Connect");
5378                 ndr->depth++;
5379                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
5380                 ndr->depth++;
5381                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
5382                 ndr->depth--;
5383                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5384                 ndr->depth--;
5385         }
5386         ndr->depth--;
5387 }
5388
5389 _PUBLIC_ enum ndr_err_code ndr_push_samr_Close(struct ndr_push *ndr, int flags, const struct samr_Close *r)
5390 {
5391         if (flags & NDR_IN) {
5392                 if (r->in.handle == NULL) {
5393                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5394                 }
5395                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5396         }
5397         if (flags & NDR_OUT) {
5398                 if (r->out.handle == NULL) {
5399                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5400                 }
5401                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
5402                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5403         }
5404         return NDR_ERR_SUCCESS;
5405 }
5406
5407 _PUBLIC_ enum ndr_err_code ndr_pull_samr_Close(struct ndr_pull *ndr, int flags, struct samr_Close *r)
5408 {
5409         TALLOC_CTX *_mem_save_handle_0;
5410         if (flags & NDR_IN) {
5411                 ZERO_STRUCT(r->out);
5412
5413                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5414                         NDR_PULL_ALLOC(ndr, r->in.handle);
5415                 }
5416                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5417                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5418                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5419                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5420                 NDR_PULL_ALLOC(ndr, r->out.handle);
5421                 *r->out.handle = *r->in.handle;
5422         }
5423         if (flags & NDR_OUT) {
5424                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5425                         NDR_PULL_ALLOC(ndr, r->out.handle);
5426                 }
5427                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5428                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
5429                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
5430                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5431                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5432         }
5433         return NDR_ERR_SUCCESS;
5434 }
5435
5436 _PUBLIC_ void ndr_print_samr_Close(struct ndr_print *ndr, const char *name, int flags, const struct samr_Close *r)
5437 {
5438         ndr_print_struct(ndr, name, "samr_Close");
5439         ndr->depth++;
5440         if (flags & NDR_SET_VALUES) {
5441                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5442         }
5443         if (flags & NDR_IN) {
5444                 ndr_print_struct(ndr, "in", "samr_Close");
5445                 ndr->depth++;
5446                 ndr_print_ptr(ndr, "handle", r->in.handle);
5447                 ndr->depth++;
5448                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5449                 ndr->depth--;
5450                 ndr->depth--;
5451         }
5452         if (flags & NDR_OUT) {
5453                 ndr_print_struct(ndr, "out", "samr_Close");
5454                 ndr->depth++;
5455                 ndr_print_ptr(ndr, "handle", r->out.handle);
5456                 ndr->depth++;
5457                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
5458                 ndr->depth--;
5459                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5460                 ndr->depth--;
5461         }
5462         ndr->depth--;
5463 }
5464
5465 static enum ndr_err_code ndr_push_samr_SetSecurity(struct ndr_push *ndr, int flags, const struct samr_SetSecurity *r)
5466 {
5467         if (flags & NDR_IN) {
5468                 if (r->in.handle == NULL) {
5469                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5470                 }
5471                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5472                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
5473                 if (r->in.sdbuf == NULL) {
5474                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5475                 }
5476                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sdbuf));
5477         }
5478         if (flags & NDR_OUT) {
5479                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5480         }
5481         return NDR_ERR_SUCCESS;
5482 }
5483
5484 static enum ndr_err_code ndr_pull_samr_SetSecurity(struct ndr_pull *ndr, int flags, struct samr_SetSecurity *r)
5485 {
5486         TALLOC_CTX *_mem_save_handle_0;
5487         TALLOC_CTX *_mem_save_sdbuf_0;
5488         if (flags & NDR_IN) {
5489                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5490                         NDR_PULL_ALLOC(ndr, r->in.handle);
5491                 }
5492                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5493                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5494                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5495                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5496                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
5497                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5498                         NDR_PULL_ALLOC(ndr, r->in.sdbuf);
5499                 }
5500                 _mem_save_sdbuf_0 = NDR_PULL_GET_MEM_CTX(ndr);
5501                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sdbuf, LIBNDR_FLAG_REF_ALLOC);
5502                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sdbuf));
5503                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_0, LIBNDR_FLAG_REF_ALLOC);
5504         }
5505         if (flags & NDR_OUT) {
5506                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5507         }
5508         return NDR_ERR_SUCCESS;
5509 }
5510
5511 _PUBLIC_ void ndr_print_samr_SetSecurity(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetSecurity *r)
5512 {
5513         ndr_print_struct(ndr, name, "samr_SetSecurity");
5514         ndr->depth++;
5515         if (flags & NDR_SET_VALUES) {
5516                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5517         }
5518         if (flags & NDR_IN) {
5519                 ndr_print_struct(ndr, "in", "samr_SetSecurity");
5520                 ndr->depth++;
5521                 ndr_print_ptr(ndr, "handle", r->in.handle);
5522                 ndr->depth++;
5523                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5524                 ndr->depth--;
5525                 ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
5526                 ndr_print_ptr(ndr, "sdbuf", r->in.sdbuf);
5527                 ndr->depth++;
5528                 ndr_print_sec_desc_buf(ndr, "sdbuf", r->in.sdbuf);
5529                 ndr->depth--;
5530                 ndr->depth--;
5531         }
5532         if (flags & NDR_OUT) {
5533                 ndr_print_struct(ndr, "out", "samr_SetSecurity");
5534                 ndr->depth++;
5535                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5536                 ndr->depth--;
5537         }
5538         ndr->depth--;
5539 }
5540
5541 static enum ndr_err_code ndr_push_samr_QuerySecurity(struct ndr_push *ndr, int flags, const struct samr_QuerySecurity *r)
5542 {
5543         if (flags & NDR_IN) {
5544                 if (r->in.handle == NULL) {
5545                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5546                 }
5547                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5548                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
5549         }
5550         if (flags & NDR_OUT) {
5551                 if (r->out.sdbuf == NULL) {
5552                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5553                 }
5554                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sdbuf));
5555                 if (*r->out.sdbuf) {
5556                         NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sdbuf));
5557                 }
5558                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5559         }
5560         return NDR_ERR_SUCCESS;
5561 }
5562
5563 static enum ndr_err_code ndr_pull_samr_QuerySecurity(struct ndr_pull *ndr, int flags, struct samr_QuerySecurity *r)
5564 {
5565         uint32_t _ptr_sdbuf;
5566         TALLOC_CTX *_mem_save_handle_0;
5567         TALLOC_CTX *_mem_save_sdbuf_0;
5568         TALLOC_CTX *_mem_save_sdbuf_1;
5569         if (flags & NDR_IN) {
5570                 ZERO_STRUCT(r->out);
5571
5572                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5573                         NDR_PULL_ALLOC(ndr, r->in.handle);
5574                 }
5575                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5576                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5577                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5578                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5579                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
5580                 NDR_PULL_ALLOC(ndr, r->out.sdbuf);
5581                 ZERO_STRUCTP(r->out.sdbuf);
5582         }
5583         if (flags & NDR_OUT) {
5584                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5585                         NDR_PULL_ALLOC(ndr, r->out.sdbuf);
5586                 }
5587                 _mem_save_sdbuf_0 = NDR_PULL_GET_MEM_CTX(ndr);
5588                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sdbuf, LIBNDR_FLAG_REF_ALLOC);
5589                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sdbuf));
5590                 if (_ptr_sdbuf) {
5591                         NDR_PULL_ALLOC(ndr, *r->out.sdbuf);
5592                 } else {
5593                         *r->out.sdbuf = NULL;
5594                 }
5595                 if (*r->out.sdbuf) {
5596                         _mem_save_sdbuf_1 = NDR_PULL_GET_MEM_CTX(ndr);
5597                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sdbuf, 0);
5598                         NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sdbuf));
5599                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_1, 0);
5600                 }
5601                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_0, LIBNDR_FLAG_REF_ALLOC);
5602                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5603         }
5604         return NDR_ERR_SUCCESS;
5605 }
5606
5607 _PUBLIC_ void ndr_print_samr_QuerySecurity(struct ndr_print *ndr, const char *name, int flags, const struct samr_QuerySecurity *r)
5608 {
5609         ndr_print_struct(ndr, name, "samr_QuerySecurity");
5610         ndr->depth++;
5611         if (flags & NDR_SET_VALUES) {
5612                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5613         }
5614         if (flags & NDR_IN) {
5615                 ndr_print_struct(ndr, "in", "samr_QuerySecurity");
5616                 ndr->depth++;
5617                 ndr_print_ptr(ndr, "handle", r->in.handle);
5618                 ndr->depth++;
5619                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5620                 ndr->depth--;
5621                 ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
5622                 ndr->depth--;
5623         }
5624         if (flags & NDR_OUT) {
5625                 ndr_print_struct(ndr, "out", "samr_QuerySecurity");
5626                 ndr->depth++;
5627                 ndr_print_ptr(ndr, "sdbuf", r->out.sdbuf);
5628                 ndr->depth++;
5629                 ndr_print_ptr(ndr, "sdbuf", *r->out.sdbuf);
5630                 ndr->depth++;
5631                 if (*r->out.sdbuf) {
5632                         ndr_print_sec_desc_buf(ndr, "sdbuf", *r->out.sdbuf);
5633                 }
5634                 ndr->depth--;
5635                 ndr->depth--;
5636                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5637                 ndr->depth--;
5638         }
5639         ndr->depth--;
5640 }
5641
5642 static enum ndr_err_code ndr_push_samr_Shutdown(struct ndr_push *ndr, int flags, const struct samr_Shutdown *r)
5643 {
5644         if (flags & NDR_IN) {
5645                 if (r->in.connect_handle == NULL) {
5646                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5647                 }
5648                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5649         }
5650         if (flags & NDR_OUT) {
5651                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5652         }
5653         return NDR_ERR_SUCCESS;
5654 }
5655
5656 static enum ndr_err_code ndr_pull_samr_Shutdown(struct ndr_pull *ndr, int flags, struct samr_Shutdown *r)
5657 {
5658         TALLOC_CTX *_mem_save_connect_handle_0;
5659         if (flags & NDR_IN) {
5660                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5661                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
5662                 }
5663                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5664                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
5665                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5666                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
5667         }
5668         if (flags & NDR_OUT) {
5669                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5670         }
5671         return NDR_ERR_SUCCESS;
5672 }
5673
5674 _PUBLIC_ void ndr_print_samr_Shutdown(struct ndr_print *ndr, const char *name, int flags, const struct samr_Shutdown *r)
5675 {
5676         ndr_print_struct(ndr, name, "samr_Shutdown");
5677         ndr->depth++;
5678         if (flags & NDR_SET_VALUES) {
5679                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5680         }
5681         if (flags & NDR_IN) {
5682                 ndr_print_struct(ndr, "in", "samr_Shutdown");
5683                 ndr->depth++;
5684                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
5685                 ndr->depth++;
5686                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
5687                 ndr->depth--;
5688                 ndr->depth--;
5689         }
5690         if (flags & NDR_OUT) {
5691                 ndr_print_struct(ndr, "out", "samr_Shutdown");
5692                 ndr->depth++;
5693                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5694                 ndr->depth--;
5695         }
5696         ndr->depth--;
5697 }
5698
5699 static enum ndr_err_code ndr_push_samr_LookupDomain(struct ndr_push *ndr, int flags, const struct samr_LookupDomain *r)
5700 {
5701         if (flags & NDR_IN) {
5702                 if (r->in.connect_handle == NULL) {
5703                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5704                 }
5705                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5706                 if (r->in.domain_name == NULL) {
5707                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5708                 }
5709                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
5710         }
5711         if (flags & NDR_OUT) {
5712                 if (r->out.sid == NULL) {
5713                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5714                 }
5715                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sid));
5716                 if (*r->out.sid) {
5717                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
5718                 }
5719                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5720         }
5721         return NDR_ERR_SUCCESS;
5722 }
5723
5724 static enum ndr_err_code ndr_pull_samr_LookupDomain(struct ndr_pull *ndr, int flags, struct samr_LookupDomain *r)
5725 {
5726         uint32_t _ptr_sid;
5727         TALLOC_CTX *_mem_save_connect_handle_0;
5728         TALLOC_CTX *_mem_save_domain_name_0;
5729         TALLOC_CTX *_mem_save_sid_0;
5730         TALLOC_CTX *_mem_save_sid_1;
5731         if (flags & NDR_IN) {
5732                 ZERO_STRUCT(r->out);
5733
5734                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5735                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
5736                 }
5737                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5738                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
5739                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5740                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
5741                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5742                         NDR_PULL_ALLOC(ndr, r->in.domain_name);
5743                 }
5744                 _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5745                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_name, LIBNDR_FLAG_REF_ALLOC);
5746                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
5747                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, LIBNDR_FLAG_REF_ALLOC);
5748                 NDR_PULL_ALLOC(ndr, r->out.sid);
5749                 ZERO_STRUCTP(r->out.sid);
5750         }
5751         if (flags & NDR_OUT) {
5752                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5753                         NDR_PULL_ALLOC(ndr, r->out.sid);
5754                 }
5755                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
5756                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);
5757                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
5758                 if (_ptr_sid) {
5759                         NDR_PULL_ALLOC(ndr, *r->out.sid);
5760                 } else {
5761                         *r->out.sid = NULL;
5762                 }
5763                 if (*r->out.sid) {
5764                         _mem_save_sid_1 = NDR_PULL_GET_MEM_CTX(ndr);
5765                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sid, 0);
5766                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
5767                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_1, 0);
5768                 }
5769                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
5770                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5771         }
5772         return NDR_ERR_SUCCESS;
5773 }
5774
5775 _PUBLIC_ void ndr_print_samr_LookupDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupDomain *r)
5776 {
5777         ndr_print_struct(ndr, name, "samr_LookupDomain");
5778         ndr->depth++;
5779         if (flags & NDR_SET_VALUES) {
5780                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5781         }
5782         if (flags & NDR_IN) {
5783                 ndr_print_struct(ndr, "in", "samr_LookupDomain");
5784                 ndr->depth++;
5785                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
5786                 ndr->depth++;
5787                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
5788                 ndr->depth--;
5789                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
5790                 ndr->depth++;
5791                 ndr_print_lsa_String(ndr, "domain_name", r->in.domain_name);
5792                 ndr->depth--;
5793                 ndr->depth--;
5794         }
5795         if (flags & NDR_OUT) {
5796                 ndr_print_struct(ndr, "out", "samr_LookupDomain");
5797                 ndr->depth++;
5798                 ndr_print_ptr(ndr, "sid", r->out.sid);
5799                 ndr->depth++;
5800                 ndr_print_ptr(ndr, "sid", *r->out.sid);
5801                 ndr->depth++;
5802                 if (*r->out.sid) {
5803                         ndr_print_dom_sid2(ndr, "sid", *r->out.sid);
5804                 }
5805                 ndr->depth--;
5806                 ndr->depth--;
5807                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5808                 ndr->depth--;
5809         }
5810         ndr->depth--;
5811 }
5812
5813 static enum ndr_err_code ndr_push_samr_EnumDomains(struct ndr_push *ndr, int flags, const struct samr_EnumDomains *r)
5814 {
5815         if (flags & NDR_IN) {
5816                 if (r->in.connect_handle == NULL) {
5817                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5818                 }
5819                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5820                 if (r->in.resume_handle == NULL) {
5821                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5822                 }
5823                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
5824                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
5825         }
5826         if (flags & NDR_OUT) {
5827                 if (r->out.resume_handle == NULL) {
5828                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5829                 }
5830                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
5831                 if (r->out.sam == NULL) {
5832                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5833                 }
5834                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
5835                 if (*r->out.sam) {
5836                         NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
5837                 }
5838                 if (r->out.num_entries == NULL) {
5839                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5840                 }
5841                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
5842                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5843         }
5844         return NDR_ERR_SUCCESS;
5845 }
5846
5847 static enum ndr_err_code ndr_pull_samr_EnumDomains(struct ndr_pull *ndr, int flags, struct samr_EnumDomains *r)
5848 {
5849         uint32_t _ptr_sam;
5850         TALLOC_CTX *_mem_save_connect_handle_0;
5851         TALLOC_CTX *_mem_save_resume_handle_0;
5852         TALLOC_CTX *_mem_save_sam_0;
5853         TALLOC_CTX *_mem_save_sam_1;
5854         TALLOC_CTX *_mem_save_num_entries_0;
5855         if (flags & NDR_IN) {
5856                 ZERO_STRUCT(r->out);
5857
5858                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5859                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
5860                 }
5861                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5862                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
5863                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5864                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
5865                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5866                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
5867                 }
5868                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5869                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
5870                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
5871                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
5872                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
5873                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
5874                 *r->out.resume_handle = *r->in.resume_handle;
5875                 NDR_PULL_ALLOC(ndr, r->out.sam);
5876                 ZERO_STRUCTP(r->out.sam);
5877                 NDR_PULL_ALLOC(ndr, r->out.num_entries);
5878                 ZERO_STRUCTP(r->out.num_entries);
5879         }
5880         if (flags & NDR_OUT) {
5881                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5882                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
5883                 }
5884                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5885                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
5886                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
5887                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
5888                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5889                         NDR_PULL_ALLOC(ndr, r->out.sam);
5890                 }
5891                 _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
5892                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
5893                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
5894                 if (_ptr_sam) {
5895                         NDR_PULL_ALLOC(ndr, *r->out.sam);
5896                 } else {
5897                         *r->out.sam = NULL;
5898                 }
5899                 if (*r->out.sam) {
5900                         _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
5901                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
5902                         NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
5903                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
5904                 }
5905                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
5906                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5907                         NDR_PULL_ALLOC(ndr, r->out.num_entries);
5908                 }
5909                 _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
5910                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
5911                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
5912                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
5913                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5914         }
5915         return NDR_ERR_SUCCESS;
5916 }
5917
5918 _PUBLIC_ void ndr_print_samr_EnumDomains(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomains *r)
5919 {
5920         ndr_print_struct(ndr, name, "samr_EnumDomains");
5921         ndr->depth++;
5922         if (flags & NDR_SET_VALUES) {
5923                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5924         }
5925         if (flags & NDR_IN) {
5926                 ndr_print_struct(ndr, "in", "samr_EnumDomains");
5927                 ndr->depth++;
5928                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
5929                 ndr->depth++;
5930                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
5931                 ndr->depth--;
5932                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
5933                 ndr->depth++;
5934                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
5935                 ndr->depth--;
5936                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
5937                 ndr->depth--;
5938         }
5939         if (flags & NDR_OUT) {
5940                 ndr_print_struct(ndr, "out", "samr_EnumDomains");
5941                 ndr->depth++;
5942                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
5943                 ndr->depth++;
5944                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
5945                 ndr->depth--;
5946                 ndr_print_ptr(ndr, "sam", r->out.sam);
5947                 ndr->depth++;
5948                 ndr_print_ptr(ndr, "sam", *r->out.sam);
5949                 ndr->depth++;
5950                 if (*r->out.sam) {
5951                         ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
5952                 }
5953                 ndr->depth--;
5954                 ndr->depth--;
5955                 ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
5956                 ndr->depth++;
5957                 ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
5958                 ndr->depth--;
5959                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5960                 ndr->depth--;
5961         }
5962         ndr->depth--;
5963 }
5964
5965 _PUBLIC_ enum ndr_err_code ndr_push_samr_OpenDomain(struct ndr_push *ndr, int flags, const struct samr_OpenDomain *r)
5966 {
5967         if (flags & NDR_IN) {
5968                 if (r->in.connect_handle == NULL) {
5969                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5970                 }
5971                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5972                 NDR_CHECK(ndr_push_samr_DomainAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
5973                 if (r->in.sid == NULL) {
5974                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5975                 }
5976                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
5977         }
5978         if (flags & NDR_OUT) {
5979                 if (r->out.domain_handle == NULL) {
5980                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5981                 }
5982                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.domain_handle));
5983                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5984         }
5985         return NDR_ERR_SUCCESS;
5986 }
5987
5988 _PUBLIC_ enum ndr_err_code ndr_pull_samr_OpenDomain(struct ndr_pull *ndr, int flags, struct samr_OpenDomain *r)
5989 {
5990         TALLOC_CTX *_mem_save_connect_handle_0;
5991         TALLOC_CTX *_mem_save_sid_0;
5992         TALLOC_CTX *_mem_save_domain_handle_0;
5993         if (flags & NDR_IN) {
5994                 ZERO_STRUCT(r->out);
5995
5996                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5997                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
5998                 }
5999                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6000                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
6001                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
6002                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
6003                 NDR_CHECK(ndr_pull_samr_DomainAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
6004                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6005                         NDR_PULL_ALLOC(ndr, r->in.sid);
6006                 }
6007                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6008                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
6009                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
6010                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
6011                 NDR_PULL_ALLOC(ndr, r->out.domain_handle);
6012                 ZERO_STRUCTP(r->out.domain_handle);
6013         }
6014         if (flags & NDR_OUT) {
6015                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6016                         NDR_PULL_ALLOC(ndr, r->out.domain_handle);
6017                 }
6018                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6019                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6020                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.domain_handle));
6021                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_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_OpenDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenDomain *r)
6028 {
6029         ndr_print_struct(ndr, name, "samr_OpenDomain");
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_OpenDomain");
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_samr_DomainAccessMask(ndr, "access_mask", r->in.access_mask);
6042                 ndr_print_ptr(ndr, "sid", r->in.sid);
6043                 ndr->depth++;
6044                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
6045                 ndr->depth--;
6046                 ndr->depth--;
6047         }
6048         if (flags & NDR_OUT) {
6049                 ndr_print_struct(ndr, "out", "samr_OpenDomain");
6050                 ndr->depth++;
6051                 ndr_print_ptr(ndr, "domain_handle", r->out.domain_handle);
6052                 ndr->depth++;
6053                 ndr_print_policy_handle(ndr, "domain_handle", r->out.domain_handle);
6054                 ndr->depth--;
6055                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6056                 ndr->depth--;
6057         }
6058         ndr->depth--;
6059 }
6060
6061 static enum ndr_err_code ndr_push_samr_QueryDomainInfo(struct ndr_push *ndr, int flags, const struct samr_QueryDomainInfo *r)
6062 {
6063         if (flags & NDR_IN) {
6064                 if (r->in.domain_handle == NULL) {
6065                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6066                 }
6067                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6068                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
6069         }
6070         if (flags & NDR_OUT) {
6071                 if (r->out.info == NULL) {
6072                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6073                 }
6074                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
6075                 if (*r->out.info) {
6076                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
6077                         NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
6078                 }
6079                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6080         }
6081         return NDR_ERR_SUCCESS;
6082 }
6083
6084 static enum ndr_err_code ndr_pull_samr_QueryDomainInfo(struct ndr_pull *ndr, int flags, struct samr_QueryDomainInfo *r)
6085 {
6086         uint32_t _ptr_info;
6087         TALLOC_CTX *_mem_save_domain_handle_0;
6088         TALLOC_CTX *_mem_save_info_0;
6089         TALLOC_CTX *_mem_save_info_1;
6090         if (flags & NDR_IN) {
6091                 ZERO_STRUCT(r->out);
6092
6093                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6094                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6095                 }
6096                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6097                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6098                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6099                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6100                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
6101                 NDR_PULL_ALLOC(ndr, r->out.info);
6102                 ZERO_STRUCTP(r->out.info);
6103         }
6104         if (flags & NDR_OUT) {
6105                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6106                         NDR_PULL_ALLOC(ndr, r->out.info);
6107                 }
6108                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6109                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
6110                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
6111                 if (_ptr_info) {
6112                         NDR_PULL_ALLOC(ndr, *r->out.info);
6113                 } else {
6114                         *r->out.info = NULL;
6115                 }
6116                 if (*r->out.info) {
6117                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
6118                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
6119                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
6120                         NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
6121                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
6122                 }
6123                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6124                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6125         }
6126         return NDR_ERR_SUCCESS;
6127 }
6128
6129 _PUBLIC_ void ndr_print_samr_QueryDomainInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDomainInfo *r)
6130 {
6131         ndr_print_struct(ndr, name, "samr_QueryDomainInfo");
6132         ndr->depth++;
6133         if (flags & NDR_SET_VALUES) {
6134                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6135         }
6136         if (flags & NDR_IN) {
6137                 ndr_print_struct(ndr, "in", "samr_QueryDomainInfo");
6138                 ndr->depth++;
6139                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6140                 ndr->depth++;
6141                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6142                 ndr->depth--;
6143                 ndr_print_uint16(ndr, "level", r->in.level);
6144                 ndr->depth--;
6145         }
6146         if (flags & NDR_OUT) {
6147                 ndr_print_struct(ndr, "out", "samr_QueryDomainInfo");
6148                 ndr->depth++;
6149                 ndr_print_ptr(ndr, "info", r->out.info);
6150                 ndr->depth++;
6151                 ndr_print_ptr(ndr, "info", *r->out.info);
6152                 ndr->depth++;
6153                 if (*r->out.info) {
6154                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
6155                         ndr_print_samr_DomainInfo(ndr, "info", *r->out.info);
6156                 }
6157                 ndr->depth--;
6158                 ndr->depth--;
6159                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6160                 ndr->depth--;
6161         }
6162         ndr->depth--;
6163 }
6164
6165 static enum ndr_err_code ndr_push_samr_SetDomainInfo(struct ndr_push *ndr, int flags, const struct samr_SetDomainInfo *r)
6166 {
6167         if (flags & NDR_IN) {
6168                 if (r->in.domain_handle == NULL) {
6169                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6170                 }
6171                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6172                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
6173                 if (r->in.info == NULL) {
6174                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6175                 }
6176                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
6177                 NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6178         }
6179         if (flags & NDR_OUT) {
6180                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6181         }
6182         return NDR_ERR_SUCCESS;
6183 }
6184
6185 static enum ndr_err_code ndr_pull_samr_SetDomainInfo(struct ndr_pull *ndr, int flags, struct samr_SetDomainInfo *r)
6186 {
6187         TALLOC_CTX *_mem_save_domain_handle_0;
6188         TALLOC_CTX *_mem_save_info_0;
6189         if (flags & NDR_IN) {
6190                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6191                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6192                 }
6193                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6194                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6195                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6196                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6197                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
6198                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6199                         NDR_PULL_ALLOC(ndr, r->in.info);
6200                 }
6201                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6202                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
6203                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
6204                 NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6205                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6206         }
6207         if (flags & NDR_OUT) {
6208                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6209         }
6210         return NDR_ERR_SUCCESS;
6211 }
6212
6213 _PUBLIC_ void ndr_print_samr_SetDomainInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetDomainInfo *r)
6214 {
6215         ndr_print_struct(ndr, name, "samr_SetDomainInfo");
6216         ndr->depth++;
6217         if (flags & NDR_SET_VALUES) {
6218                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6219         }
6220         if (flags & NDR_IN) {
6221                 ndr_print_struct(ndr, "in", "samr_SetDomainInfo");
6222                 ndr->depth++;
6223                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6224                 ndr->depth++;
6225                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6226                 ndr->depth--;
6227                 ndr_print_uint16(ndr, "level", r->in.level);
6228                 ndr_print_ptr(ndr, "info", r->in.info);
6229                 ndr->depth++;
6230                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
6231                 ndr_print_samr_DomainInfo(ndr, "info", r->in.info);
6232                 ndr->depth--;
6233                 ndr->depth--;
6234         }
6235         if (flags & NDR_OUT) {
6236                 ndr_print_struct(ndr, "out", "samr_SetDomainInfo");
6237                 ndr->depth++;
6238                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6239                 ndr->depth--;
6240         }
6241         ndr->depth--;
6242 }
6243
6244 static enum ndr_err_code ndr_push_samr_CreateDomainGroup(struct ndr_push *ndr, int flags, const struct samr_CreateDomainGroup *r)
6245 {
6246         if (flags & NDR_IN) {
6247                 if (r->in.domain_handle == NULL) {
6248                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6249                 }
6250                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6251                 if (r->in.name == NULL) {
6252                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6253                 }
6254                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
6255                 NDR_CHECK(ndr_push_samr_GroupAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
6256         }
6257         if (flags & NDR_OUT) {
6258                 if (r->out.group_handle == NULL) {
6259                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6260                 }
6261                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
6262                 if (r->out.rid == NULL) {
6263                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6264                 }
6265                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
6266                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6267         }
6268         return NDR_ERR_SUCCESS;
6269 }
6270
6271 static enum ndr_err_code ndr_pull_samr_CreateDomainGroup(struct ndr_pull *ndr, int flags, struct samr_CreateDomainGroup *r)
6272 {
6273         TALLOC_CTX *_mem_save_domain_handle_0;
6274         TALLOC_CTX *_mem_save_name_0;
6275         TALLOC_CTX *_mem_save_group_handle_0;
6276         TALLOC_CTX *_mem_save_rid_0;
6277         if (flags & NDR_IN) {
6278                 ZERO_STRUCT(r->out);
6279
6280                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6281                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6282                 }
6283                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6284                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6285                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6286                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6287                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6288                         NDR_PULL_ALLOC(ndr, r->in.name);
6289                 }
6290                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6291                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
6292                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
6293                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
6294                 NDR_CHECK(ndr_pull_samr_GroupAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
6295                 NDR_PULL_ALLOC(ndr, r->out.group_handle);
6296                 ZERO_STRUCTP(r->out.group_handle);
6297                 NDR_PULL_ALLOC(ndr, r->out.rid);
6298                 ZERO_STRUCTP(r->out.rid);
6299         }
6300         if (flags & NDR_OUT) {
6301                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6302                         NDR_PULL_ALLOC(ndr, r->out.group_handle);
6303                 }
6304                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6305                 NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);
6306                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
6307                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
6308                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6309                         NDR_PULL_ALLOC(ndr, r->out.rid);
6310                 }
6311                 _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6312                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
6313                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
6314                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
6315                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6316         }
6317         return NDR_ERR_SUCCESS;
6318 }
6319
6320 _PUBLIC_ void ndr_print_samr_CreateDomainGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateDomainGroup *r)
6321 {
6322         ndr_print_struct(ndr, name, "samr_CreateDomainGroup");
6323         ndr->depth++;
6324         if (flags & NDR_SET_VALUES) {
6325                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6326         }
6327         if (flags & NDR_IN) {
6328                 ndr_print_struct(ndr, "in", "samr_CreateDomainGroup");
6329                 ndr->depth++;
6330                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6331                 ndr->depth++;
6332                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6333                 ndr->depth--;
6334                 ndr_print_ptr(ndr, "name", r->in.name);
6335                 ndr->depth++;
6336                 ndr_print_lsa_String(ndr, "name", r->in.name);
6337                 ndr->depth--;
6338                 ndr_print_samr_GroupAccessMask(ndr, "access_mask", r->in.access_mask);
6339                 ndr->depth--;
6340         }
6341         if (flags & NDR_OUT) {
6342                 ndr_print_struct(ndr, "out", "samr_CreateDomainGroup");
6343                 ndr->depth++;
6344                 ndr_print_ptr(ndr, "group_handle", r->out.group_handle);
6345                 ndr->depth++;
6346                 ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);
6347                 ndr->depth--;
6348                 ndr_print_ptr(ndr, "rid", r->out.rid);
6349                 ndr->depth++;
6350                 ndr_print_uint32(ndr, "rid", *r->out.rid);
6351                 ndr->depth--;
6352                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6353                 ndr->depth--;
6354         }
6355         ndr->depth--;
6356 }
6357
6358 static enum ndr_err_code ndr_push_samr_EnumDomainGroups(struct ndr_push *ndr, int flags, const struct samr_EnumDomainGroups *r)
6359 {
6360         if (flags & NDR_IN) {
6361                 if (r->in.domain_handle == NULL) {
6362                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6363                 }
6364                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6365                 if (r->in.resume_handle == NULL) {
6366                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6367                 }
6368                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6369                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
6370         }
6371         if (flags & NDR_OUT) {
6372                 if (r->out.resume_handle == NULL) {
6373                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6374                 }
6375                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6376                 if (r->out.sam == NULL) {
6377                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6378                 }
6379                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
6380                 if (*r->out.sam) {
6381                         NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6382                 }
6383                 if (r->out.num_entries == NULL) {
6384                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6385                 }
6386                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
6387                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6388         }
6389         return NDR_ERR_SUCCESS;
6390 }
6391
6392 static enum ndr_err_code ndr_pull_samr_EnumDomainGroups(struct ndr_pull *ndr, int flags, struct samr_EnumDomainGroups *r)
6393 {
6394         uint32_t _ptr_sam;
6395         TALLOC_CTX *_mem_save_domain_handle_0;
6396         TALLOC_CTX *_mem_save_resume_handle_0;
6397         TALLOC_CTX *_mem_save_sam_0;
6398         TALLOC_CTX *_mem_save_sam_1;
6399         TALLOC_CTX *_mem_save_num_entries_0;
6400         if (flags & NDR_IN) {
6401                 ZERO_STRUCT(r->out);
6402
6403                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6404                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6405                 }
6406                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6407                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6408                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6409                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6410                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6411                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
6412                 }
6413                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6414                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6416                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
6418                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6419                 *r->out.resume_handle = *r->in.resume_handle;
6420                 NDR_PULL_ALLOC(ndr, r->out.sam);
6421                 ZERO_STRUCTP(r->out.sam);
6422                 NDR_PULL_ALLOC(ndr, r->out.num_entries);
6423                 ZERO_STRUCTP(r->out.num_entries);
6424         }
6425         if (flags & NDR_OUT) {
6426                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6427                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6428                 }
6429                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6430                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6432                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6433                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6434                         NDR_PULL_ALLOC(ndr, r->out.sam);
6435                 }
6436                 _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
6437                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
6438                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
6439                 if (_ptr_sam) {
6440                         NDR_PULL_ALLOC(ndr, *r->out.sam);
6441                 } else {
6442                         *r->out.sam = NULL;
6443                 }
6444                 if (*r->out.sam) {
6445                         _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
6446                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
6447                         NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6448                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
6449                 }
6450                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
6451                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6452                         NDR_PULL_ALLOC(ndr, r->out.num_entries);
6453                 }
6454                 _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
6455                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
6456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
6457                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
6458                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6459         }
6460         return NDR_ERR_SUCCESS;
6461 }
6462
6463 _PUBLIC_ void ndr_print_samr_EnumDomainGroups(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainGroups *r)
6464 {
6465         ndr_print_struct(ndr, name, "samr_EnumDomainGroups");
6466         ndr->depth++;
6467         if (flags & NDR_SET_VALUES) {
6468                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6469         }
6470         if (flags & NDR_IN) {
6471                 ndr_print_struct(ndr, "in", "samr_EnumDomainGroups");
6472                 ndr->depth++;
6473                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6474                 ndr->depth++;
6475                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6476                 ndr->depth--;
6477                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6478                 ndr->depth++;
6479                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6480                 ndr->depth--;
6481                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
6482                 ndr->depth--;
6483         }
6484         if (flags & NDR_OUT) {
6485                 ndr_print_struct(ndr, "out", "samr_EnumDomainGroups");
6486                 ndr->depth++;
6487                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6488                 ndr->depth++;
6489                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6490                 ndr->depth--;
6491                 ndr_print_ptr(ndr, "sam", r->out.sam);
6492                 ndr->depth++;
6493                 ndr_print_ptr(ndr, "sam", *r->out.sam);
6494                 ndr->depth++;
6495                 if (*r->out.sam) {
6496                         ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
6497                 }
6498                 ndr->depth--;
6499                 ndr->depth--;
6500                 ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
6501                 ndr->depth++;
6502                 ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
6503                 ndr->depth--;
6504                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6505                 ndr->depth--;
6506         }
6507         ndr->depth--;
6508 }
6509
6510 static enum ndr_err_code ndr_push_samr_CreateUser(struct ndr_push *ndr, int flags, const struct samr_CreateUser *r)
6511 {
6512         if (flags & NDR_IN) {
6513                 if (r->in.domain_handle == NULL) {
6514                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6515                 }
6516                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6517                 if (r->in.account_name == NULL) {
6518                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6519                 }
6520                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
6521                 NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
6522         }
6523         if (flags & NDR_OUT) {
6524                 if (r->out.user_handle == NULL) {
6525                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6526                 }
6527                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
6528                 if (r->out.rid == NULL) {
6529                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6530                 }
6531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
6532                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6533         }
6534         return NDR_ERR_SUCCESS;
6535 }
6536
6537 static enum ndr_err_code ndr_pull_samr_CreateUser(struct ndr_pull *ndr, int flags, struct samr_CreateUser *r)
6538 {
6539         TALLOC_CTX *_mem_save_domain_handle_0;
6540         TALLOC_CTX *_mem_save_account_name_0;
6541         TALLOC_CTX *_mem_save_user_handle_0;
6542         TALLOC_CTX *_mem_save_rid_0;
6543         if (flags & NDR_IN) {
6544                 ZERO_STRUCT(r->out);
6545
6546                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6547                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6548                 }
6549                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6550                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6551                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6552                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6553                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6554                         NDR_PULL_ALLOC(ndr, r->in.account_name);
6555                 }
6556                 _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6557                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account_name, LIBNDR_FLAG_REF_ALLOC);
6558                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
6559                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, LIBNDR_FLAG_REF_ALLOC);
6560                 NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
6561                 NDR_PULL_ALLOC(ndr, r->out.user_handle);
6562                 ZERO_STRUCTP(r->out.user_handle);
6563                 NDR_PULL_ALLOC(ndr, r->out.rid);
6564                 ZERO_STRUCTP(r->out.rid);
6565         }
6566         if (flags & NDR_OUT) {
6567                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6568                         NDR_PULL_ALLOC(ndr, r->out.user_handle);
6569                 }
6570                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6571                 NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
6572                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
6573                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
6574                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6575                         NDR_PULL_ALLOC(ndr, r->out.rid);
6576                 }
6577                 _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6578                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
6579                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
6580                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
6581                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6582         }
6583         return NDR_ERR_SUCCESS;
6584 }
6585
6586 _PUBLIC_ void ndr_print_samr_CreateUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateUser *r)
6587 {
6588         ndr_print_struct(ndr, name, "samr_CreateUser");
6589         ndr->depth++;
6590         if (flags & NDR_SET_VALUES) {
6591                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6592         }
6593         if (flags & NDR_IN) {
6594                 ndr_print_struct(ndr, "in", "samr_CreateUser");
6595                 ndr->depth++;
6596                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6597                 ndr->depth++;
6598                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6599                 ndr->depth--;
6600                 ndr_print_ptr(ndr, "account_name", r->in.account_name);
6601                 ndr->depth++;
6602                 ndr_print_lsa_String(ndr, "account_name", r->in.account_name);
6603                 ndr->depth--;
6604                 ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);
6605                 ndr->depth--;
6606         }
6607         if (flags & NDR_OUT) {
6608                 ndr_print_struct(ndr, "out", "samr_CreateUser");
6609                 ndr->depth++;
6610                 ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
6611                 ndr->depth++;
6612                 ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
6613                 ndr->depth--;
6614                 ndr_print_ptr(ndr, "rid", r->out.rid);
6615                 ndr->depth++;
6616                 ndr_print_uint32(ndr, "rid", *r->out.rid);
6617                 ndr->depth--;
6618                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6619                 ndr->depth--;
6620         }
6621         ndr->depth--;
6622 }
6623
6624 static enum ndr_err_code ndr_push_samr_EnumDomainUsers(struct ndr_push *ndr, int flags, const struct samr_EnumDomainUsers *r)
6625 {
6626         if (flags & NDR_IN) {
6627                 if (r->in.domain_handle == NULL) {
6628                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6629                 }
6630                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6631                 if (r->in.resume_handle == NULL) {
6632                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6633                 }
6634                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6635                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->in.acct_flags));
6636                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
6637         }
6638         if (flags & NDR_OUT) {
6639                 if (r->out.resume_handle == NULL) {
6640                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6641                 }
6642                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6643                 if (r->out.sam == NULL) {
6644                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6645                 }
6646                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
6647                 if (*r->out.sam) {
6648                         NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6649                 }
6650                 if (r->out.num_entries == NULL) {
6651                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6652                 }
6653                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
6654                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6655         }
6656         return NDR_ERR_SUCCESS;
6657 }
6658
6659 static enum ndr_err_code ndr_pull_samr_EnumDomainUsers(struct ndr_pull *ndr, int flags, struct samr_EnumDomainUsers *r)
6660 {
6661         uint32_t _ptr_sam;
6662         TALLOC_CTX *_mem_save_domain_handle_0;
6663         TALLOC_CTX *_mem_save_resume_handle_0;
6664         TALLOC_CTX *_mem_save_sam_0;
6665         TALLOC_CTX *_mem_save_sam_1;
6666         TALLOC_CTX *_mem_save_num_entries_0;
6667         if (flags & NDR_IN) {
6668                 ZERO_STRUCT(r->out);
6669
6670                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6671                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6672                 }
6673                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6674                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6675                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6676                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6677                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6678                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
6679                 }
6680                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6681                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6682                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6683                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6684                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->in.acct_flags));
6685                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
6686                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6687                 *r->out.resume_handle = *r->in.resume_handle;
6688                 NDR_PULL_ALLOC(ndr, r->out.sam);
6689                 ZERO_STRUCTP(r->out.sam);
6690                 NDR_PULL_ALLOC(ndr, r->out.num_entries);
6691                 ZERO_STRUCTP(r->out.num_entries);
6692         }
6693         if (flags & NDR_OUT) {
6694                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6695                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6696                 }
6697                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6698                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6699                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6700                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6701                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6702                         NDR_PULL_ALLOC(ndr, r->out.sam);
6703                 }
6704                 _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
6705                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
6706                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
6707                 if (_ptr_sam) {
6708                         NDR_PULL_ALLOC(ndr, *r->out.sam);
6709                 } else {
6710                         *r->out.sam = NULL;
6711                 }
6712                 if (*r->out.sam) {
6713                         _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
6714                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
6715                         NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6716                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
6717                 }
6718                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
6719                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6720                         NDR_PULL_ALLOC(ndr, r->out.num_entries);
6721                 }
6722                 _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
6723                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
6724                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
6725                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
6726                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6727         }
6728         return NDR_ERR_SUCCESS;
6729 }
6730
6731 _PUBLIC_ void ndr_print_samr_EnumDomainUsers(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainUsers *r)
6732 {
6733         ndr_print_struct(ndr, name, "samr_EnumDomainUsers");
6734         ndr->depth++;
6735         if (flags & NDR_SET_VALUES) {
6736                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6737         }
6738         if (flags & NDR_IN) {
6739                 ndr_print_struct(ndr, "in", "samr_EnumDomainUsers");
6740                 ndr->depth++;
6741                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6742                 ndr->depth++;
6743                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6744                 ndr->depth--;
6745                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6746                 ndr->depth++;
6747                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6748                 ndr->depth--;
6749                 ndr_print_samr_AcctFlags(ndr, "acct_flags", r->in.acct_flags);
6750                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
6751                 ndr->depth--;
6752         }
6753         if (flags & NDR_OUT) {
6754                 ndr_print_struct(ndr, "out", "samr_EnumDomainUsers");
6755                 ndr->depth++;
6756                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6757                 ndr->depth++;
6758                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6759                 ndr->depth--;
6760                 ndr_print_ptr(ndr, "sam", r->out.sam);
6761                 ndr->depth++;
6762                 ndr_print_ptr(ndr, "sam", *r->out.sam);
6763                 ndr->depth++;
6764                 if (*r->out.sam) {
6765                         ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
6766                 }
6767                 ndr->depth--;
6768                 ndr->depth--;
6769                 ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
6770                 ndr->depth++;
6771                 ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
6772                 ndr->depth--;
6773                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6774                 ndr->depth--;
6775         }
6776         ndr->depth--;
6777 }
6778
6779 static enum ndr_err_code ndr_push_samr_CreateDomAlias(struct ndr_push *ndr, int flags, const struct samr_CreateDomAlias *r)
6780 {
6781         if (flags & NDR_IN) {
6782                 if (r->in.domain_handle == NULL) {
6783                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6784                 }
6785                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6786                 if (r->in.alias_name == NULL) {
6787                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6788                 }
6789                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.alias_name));
6790                 NDR_CHECK(ndr_push_samr_AliasAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
6791         }
6792         if (flags & NDR_OUT) {
6793                 if (r->out.alias_handle == NULL) {
6794                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6795                 }
6796                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
6797                 if (r->out.rid == NULL) {
6798                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6799                 }
6800                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
6801                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6802         }
6803         return NDR_ERR_SUCCESS;
6804 }
6805
6806 static enum ndr_err_code ndr_pull_samr_CreateDomAlias(struct ndr_pull *ndr, int flags, struct samr_CreateDomAlias *r)
6807 {
6808         TALLOC_CTX *_mem_save_domain_handle_0;
6809         TALLOC_CTX *_mem_save_alias_name_0;
6810         TALLOC_CTX *_mem_save_alias_handle_0;
6811         TALLOC_CTX *_mem_save_rid_0;
6812         if (flags & NDR_IN) {
6813                 ZERO_STRUCT(r->out);
6814
6815                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6816                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6817                 }
6818                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6819                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6820                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6821                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6822                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6823                         NDR_PULL_ALLOC(ndr, r->in.alias_name);
6824                 }
6825                 _mem_save_alias_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6826                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_name, LIBNDR_FLAG_REF_ALLOC);
6827                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.alias_name));
6828                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_name_0, LIBNDR_FLAG_REF_ALLOC);
6829                 NDR_CHECK(ndr_pull_samr_AliasAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
6830                 NDR_PULL_ALLOC(ndr, r->out.alias_handle);
6831                 ZERO_STRUCTP(r->out.alias_handle);
6832                 NDR_PULL_ALLOC(ndr, r->out.rid);
6833                 ZERO_STRUCTP(r->out.rid);
6834         }
6835         if (flags & NDR_OUT) {
6836                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6837                         NDR_PULL_ALLOC(ndr, r->out.alias_handle);
6838                 }
6839                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6840                 NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);
6841                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
6842                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
6843                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6844                         NDR_PULL_ALLOC(ndr, r->out.rid);
6845                 }
6846                 _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6847                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
6848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
6849                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
6850                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6851         }
6852         return NDR_ERR_SUCCESS;
6853 }
6854
6855 _PUBLIC_ void ndr_print_samr_CreateDomAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateDomAlias *r)
6856 {
6857         ndr_print_struct(ndr, name, "samr_CreateDomAlias");
6858         ndr->depth++;
6859         if (flags & NDR_SET_VALUES) {
6860                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6861         }
6862         if (flags & NDR_IN) {
6863                 ndr_print_struct(ndr, "in", "samr_CreateDomAlias");
6864                 ndr->depth++;
6865                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6866                 ndr->depth++;
6867                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6868                 ndr->depth--;
6869                 ndr_print_ptr(ndr, "alias_name", r->in.alias_name);
6870                 ndr->depth++;
6871                 ndr_print_lsa_String(ndr, "alias_name", r->in.alias_name);
6872                 ndr->depth--;
6873                 ndr_print_samr_AliasAccessMask(ndr, "access_mask", r->in.access_mask);
6874                 ndr->depth--;
6875         }
6876         if (flags & NDR_OUT) {
6877                 ndr_print_struct(ndr, "out", "samr_CreateDomAlias");
6878                 ndr->depth++;
6879                 ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);
6880                 ndr->depth++;
6881                 ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);
6882                 ndr->depth--;
6883                 ndr_print_ptr(ndr, "rid", r->out.rid);
6884                 ndr->depth++;
6885                 ndr_print_uint32(ndr, "rid", *r->out.rid);
6886                 ndr->depth--;
6887                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6888                 ndr->depth--;
6889         }
6890         ndr->depth--;
6891 }
6892
6893 static enum ndr_err_code ndr_push_samr_EnumDomainAliases(struct ndr_push *ndr, int flags, const struct samr_EnumDomainAliases *r)
6894 {
6895         if (flags & NDR_IN) {
6896                 if (r->in.domain_handle == NULL) {
6897                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6898                 }
6899                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6900                 if (r->in.resume_handle == NULL) {
6901                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6902                 }
6903                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6904                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
6905         }
6906         if (flags & NDR_OUT) {
6907                 if (r->out.resume_handle == NULL) {
6908                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6909                 }
6910                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6911                 if (r->out.sam == NULL) {
6912                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6913                 }
6914                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
6915                 if (*r->out.sam) {
6916                         NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6917                 }
6918                 if (r->out.num_entries == NULL) {
6919                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6920                 }
6921                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
6922                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6923         }
6924         return NDR_ERR_SUCCESS;
6925 }
6926
6927 static enum ndr_err_code ndr_pull_samr_EnumDomainAliases(struct ndr_pull *ndr, int flags, struct samr_EnumDomainAliases *r)
6928 {
6929         uint32_t _ptr_sam;
6930         TALLOC_CTX *_mem_save_domain_handle_0;
6931         TALLOC_CTX *_mem_save_resume_handle_0;
6932         TALLOC_CTX *_mem_save_sam_0;
6933         TALLOC_CTX *_mem_save_sam_1;
6934         TALLOC_CTX *_mem_save_num_entries_0;
6935         if (flags & NDR_IN) {
6936                 ZERO_STRUCT(r->out);
6937
6938                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6939                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6940                 }
6941                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6942                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6943                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6944                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6945                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6946                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
6947                 }
6948                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6949                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6950                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6951                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6952                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
6953                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6954                 *r->out.resume_handle = *r->in.resume_handle;
6955                 NDR_PULL_ALLOC(ndr, r->out.sam);
6956                 ZERO_STRUCTP(r->out.sam);
6957                 NDR_PULL_ALLOC(ndr, r->out.num_entries);
6958                 ZERO_STRUCTP(r->out.num_entries);
6959         }
6960         if (flags & NDR_OUT) {
6961                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6962                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6963                 }
6964                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6965                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6966                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6967                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6968                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6969                         NDR_PULL_ALLOC(ndr, r->out.sam);
6970                 }
6971                 _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
6972                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
6973                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
6974                 if (_ptr_sam) {
6975                         NDR_PULL_ALLOC(ndr, *r->out.sam);
6976                 } else {
6977                         *r->out.sam = NULL;
6978                 }
6979                 if (*r->out.sam) {
6980                         _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
6981                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
6982                         NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6983                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
6984                 }
6985                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
6986                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6987                         NDR_PULL_ALLOC(ndr, r->out.num_entries);
6988                 }
6989                 _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
6990                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
6991                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
6992                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
6993                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6994         }
6995         return NDR_ERR_SUCCESS;
6996 }
6997
6998 _PUBLIC_ void ndr_print_samr_EnumDomainAliases(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainAliases *r)
6999 {
7000         ndr_print_struct(ndr, name, "samr_EnumDomainAliases");
7001         ndr->depth++;
7002         if (flags & NDR_SET_VALUES) {
7003                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7004         }
7005         if (flags & NDR_IN) {
7006                 ndr_print_struct(ndr, "in", "samr_EnumDomainAliases");
7007                 ndr->depth++;
7008                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7009                 ndr->depth++;
7010                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7011                 ndr->depth--;
7012                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
7013                 ndr->depth++;
7014                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
7015                 ndr->depth--;
7016                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
7017                 ndr->depth--;
7018         }
7019         if (flags & NDR_OUT) {
7020                 ndr_print_struct(ndr, "out", "samr_EnumDomainAliases");
7021                 ndr->depth++;
7022                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
7023                 ndr->depth++;
7024                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
7025                 ndr->depth--;
7026                 ndr_print_ptr(ndr, "sam", r->out.sam);
7027                 ndr->depth++;
7028                 ndr_print_ptr(ndr, "sam", *r->out.sam);
7029                 ndr->depth++;
7030                 if (*r->out.sam) {
7031                         ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
7032                 }
7033                 ndr->depth--;
7034                 ndr->depth--;
7035                 ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
7036                 ndr->depth++;
7037                 ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
7038                 ndr->depth--;
7039                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7040                 ndr->depth--;
7041         }
7042         ndr->depth--;
7043 }
7044
7045 static enum ndr_err_code ndr_push_samr_GetAliasMembership(struct ndr_push *ndr, int flags, const struct samr_GetAliasMembership *r)
7046 {
7047         if (flags & NDR_IN) {
7048                 if (r->in.domain_handle == NULL) {
7049                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7050                 }
7051                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7052                 if (r->in.sids == NULL) {
7053                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7054                 }
7055                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
7056         }
7057         if (flags & NDR_OUT) {
7058                 if (r->out.rids == NULL) {
7059                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7060                 }
7061                 NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
7062                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7063         }
7064         return NDR_ERR_SUCCESS;
7065 }
7066
7067 static enum ndr_err_code ndr_pull_samr_GetAliasMembership(struct ndr_pull *ndr, int flags, struct samr_GetAliasMembership *r)
7068 {
7069         TALLOC_CTX *_mem_save_domain_handle_0;
7070         TALLOC_CTX *_mem_save_sids_0;
7071         TALLOC_CTX *_mem_save_rids_0;
7072         if (flags & NDR_IN) {
7073                 ZERO_STRUCT(r->out);
7074
7075                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7076                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7077                 }
7078                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7079                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7080                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7081                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7082                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7083                         NDR_PULL_ALLOC(ndr, r->in.sids);
7084                 }
7085                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7086                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
7087                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
7088                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
7089                 NDR_PULL_ALLOC(ndr, r->out.rids);
7090                 ZERO_STRUCTP(r->out.rids);
7091         }
7092         if (flags & NDR_OUT) {
7093                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7094                         NDR_PULL_ALLOC(ndr, r->out.rids);
7095                 }
7096                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7097                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
7098                 NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
7099                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
7100                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7101         }
7102         return NDR_ERR_SUCCESS;
7103 }
7104
7105 _PUBLIC_ void ndr_print_samr_GetAliasMembership(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetAliasMembership *r)
7106 {
7107         ndr_print_struct(ndr, name, "samr_GetAliasMembership");
7108         ndr->depth++;
7109         if (flags & NDR_SET_VALUES) {
7110                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7111         }
7112         if (flags & NDR_IN) {
7113                 ndr_print_struct(ndr, "in", "samr_GetAliasMembership");
7114                 ndr->depth++;
7115                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7116                 ndr->depth++;
7117                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7118                 ndr->depth--;
7119                 ndr_print_ptr(ndr, "sids", r->in.sids);
7120                 ndr->depth++;
7121                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
7122                 ndr->depth--;
7123                 ndr->depth--;
7124         }
7125         if (flags & NDR_OUT) {
7126                 ndr_print_struct(ndr, "out", "samr_GetAliasMembership");
7127                 ndr->depth++;
7128                 ndr_print_ptr(ndr, "rids", r->out.rids);
7129                 ndr->depth++;
7130                 ndr_print_samr_Ids(ndr, "rids", r->out.rids);
7131                 ndr->depth--;
7132                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7133                 ndr->depth--;
7134         }
7135         ndr->depth--;
7136 }
7137
7138 _PUBLIC_ enum ndr_err_code ndr_push_samr_LookupNames(struct ndr_push *ndr, int flags, const struct samr_LookupNames *r)
7139 {
7140         uint32_t cntr_names_0;
7141         if (flags & NDR_IN) {
7142                 if (r->in.domain_handle == NULL) {
7143                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7144                 }
7145                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7146                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
7147                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1000));
7148                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7149                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
7150                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
7151                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
7152                 }
7153                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
7154                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
7155                 }
7156         }
7157         if (flags & NDR_OUT) {
7158                 if (r->out.rids == NULL) {
7159                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7160                 }
7161                 NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
7162                 if (r->out.types == NULL) {
7163                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7164                 }
7165                 NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
7166                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7167         }
7168         return NDR_ERR_SUCCESS;
7169 }
7170
7171 _PUBLIC_ enum ndr_err_code ndr_pull_samr_LookupNames(struct ndr_pull *ndr, int flags, struct samr_LookupNames *r)
7172 {
7173         uint32_t cntr_names_0;
7174         TALLOC_CTX *_mem_save_domain_handle_0;
7175         TALLOC_CTX *_mem_save_names_0;
7176         TALLOC_CTX *_mem_save_rids_0;
7177         TALLOC_CTX *_mem_save_types_0;
7178         if (flags & NDR_IN) {
7179                 ZERO_STRUCT(r->out);
7180
7181                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7182                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7183                 }
7184                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7185                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7186                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7187                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7188                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
7189                 if (r->in.num_names < 0 || r->in.num_names > 1000) {
7190                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7191                 }
7192                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
7193                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.names));
7194                 if (ndr_get_array_length(ndr, &r->in.names) > ndr_get_array_size(ndr, &r->in.names)) {
7195                         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));
7196                 }
7197                 NDR_PULL_ALLOC_N(ndr, r->in.names, ndr_get_array_size(ndr, &r->in.names));
7198                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
7199                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
7200                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
7201                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
7202                 }
7203                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
7204                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
7205                 }
7206                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
7207                 NDR_PULL_ALLOC(ndr, r->out.rids);
7208                 ZERO_STRUCTP(r->out.rids);
7209                 NDR_PULL_ALLOC(ndr, r->out.types);
7210                 ZERO_STRUCTP(r->out.types);
7211                 if (r->in.names) {
7212                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, 1000));
7213                 }
7214                 if (r->in.names) {
7215                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.names, r->in.num_names));
7216                 }
7217         }
7218         if (flags & NDR_OUT) {
7219                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7220                         NDR_PULL_ALLOC(ndr, r->out.rids);
7221                 }
7222                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7223                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
7224                 NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
7225                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
7226                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7227                         NDR_PULL_ALLOC(ndr, r->out.types);
7228                 }
7229                 _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
7230                 NDR_PULL_SET_MEM_CTX(ndr, r->out.types, LIBNDR_FLAG_REF_ALLOC);
7231                 NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
7232                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, LIBNDR_FLAG_REF_ALLOC);
7233                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7234         }
7235         return NDR_ERR_SUCCESS;
7236 }
7237
7238 _PUBLIC_ void ndr_print_samr_LookupNames(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupNames *r)
7239 {
7240         uint32_t cntr_names_0;
7241         ndr_print_struct(ndr, name, "samr_LookupNames");
7242         ndr->depth++;
7243         if (flags & NDR_SET_VALUES) {
7244                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7245         }
7246         if (flags & NDR_IN) {
7247                 ndr_print_struct(ndr, "in", "samr_LookupNames");
7248                 ndr->depth++;
7249                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7250                 ndr->depth++;
7251                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7252                 ndr->depth--;
7253                 ndr_print_uint32(ndr, "num_names", r->in.num_names);
7254                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->in.num_names);
7255                 ndr->depth++;
7256                 for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
7257                         char *idx_0=NULL;
7258                         if (asprintf(&idx_0, "[%d]", cntr_names_0) != -1) {
7259                                 ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
7260                                 free(idx_0);
7261                         }
7262                 }
7263                 ndr->depth--;
7264                 ndr->depth--;
7265         }
7266         if (flags & NDR_OUT) {
7267                 ndr_print_struct(ndr, "out", "samr_LookupNames");
7268                 ndr->depth++;
7269                 ndr_print_ptr(ndr, "rids", r->out.rids);
7270                 ndr->depth++;
7271                 ndr_print_samr_Ids(ndr, "rids", r->out.rids);
7272                 ndr->depth--;
7273                 ndr_print_ptr(ndr, "types", r->out.types);
7274                 ndr->depth++;
7275                 ndr_print_samr_Ids(ndr, "types", r->out.types);
7276                 ndr->depth--;
7277                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7278                 ndr->depth--;
7279         }
7280         ndr->depth--;
7281 }
7282
7283 static enum ndr_err_code ndr_push_samr_LookupRids(struct ndr_push *ndr, int flags, const struct samr_LookupRids *r)
7284 {
7285         uint32_t cntr_rids_0;
7286         if (flags & NDR_IN) {
7287                 if (r->in.domain_handle == NULL) {
7288                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7289                 }
7290                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7291                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_rids));
7292                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1000));
7293                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7294                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_rids));
7295                 for (cntr_rids_0 = 0; cntr_rids_0 < r->in.num_rids; cntr_rids_0++) {
7296                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rids[cntr_rids_0]));
7297                 }
7298         }
7299         if (flags & NDR_OUT) {
7300                 if (r->out.names == NULL) {
7301                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7302                 }
7303                 NDR_CHECK(ndr_push_lsa_Strings(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
7304                 if (r->out.types == NULL) {
7305                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7306                 }
7307                 NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
7308                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7309         }
7310         return NDR_ERR_SUCCESS;
7311 }
7312
7313 static enum ndr_err_code ndr_pull_samr_LookupRids(struct ndr_pull *ndr, int flags, struct samr_LookupRids *r)
7314 {
7315         uint32_t cntr_rids_0;
7316         TALLOC_CTX *_mem_save_domain_handle_0;
7317         TALLOC_CTX *_mem_save_rids_0;
7318         TALLOC_CTX *_mem_save_names_0;
7319         TALLOC_CTX *_mem_save_types_0;
7320         if (flags & NDR_IN) {
7321                 ZERO_STRUCT(r->out);
7322
7323                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7324                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7325                 }
7326                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7327                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7328                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7329                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_rids));
7331                 if (r->in.num_rids < 0 || r->in.num_rids > 1000) {
7332                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7333                 }
7334                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.rids));
7335                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.rids));
7336                 if (ndr_get_array_length(ndr, &r->in.rids) > ndr_get_array_size(ndr, &r->in.rids)) {
7337                         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));
7338                 }
7339                 NDR_PULL_ALLOC_N(ndr, r->in.rids, ndr_get_array_size(ndr, &r->in.rids));
7340                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7341                 NDR_PULL_SET_MEM_CTX(ndr, r->in.rids, 0);
7342                 for (cntr_rids_0 = 0; cntr_rids_0 < r->in.num_rids; cntr_rids_0++) {
7343                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rids[cntr_rids_0]));
7344                 }
7345                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
7346                 NDR_PULL_ALLOC(ndr, r->out.names);
7347                 ZERO_STRUCTP(r->out.names);
7348                 NDR_PULL_ALLOC(ndr, r->out.types);
7349                 ZERO_STRUCTP(r->out.types);
7350                 if (r->in.rids) {
7351                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.rids, 1000));
7352                 }
7353                 if (r->in.rids) {
7354                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.rids, r->in.num_rids));
7355                 }
7356         }
7357         if (flags & NDR_OUT) {
7358                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7359                         NDR_PULL_ALLOC(ndr, r->out.names);
7360                 }
7361                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
7362                 NDR_PULL_SET_MEM_CTX(ndr, r->out.names, LIBNDR_FLAG_REF_ALLOC);
7363                 NDR_CHECK(ndr_pull_lsa_Strings(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
7364                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
7365                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7366                         NDR_PULL_ALLOC(ndr, r->out.types);
7367                 }
7368                 _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
7369                 NDR_PULL_SET_MEM_CTX(ndr, r->out.types, LIBNDR_FLAG_REF_ALLOC);
7370                 NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
7371                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, LIBNDR_FLAG_REF_ALLOC);
7372                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7373         }
7374         return NDR_ERR_SUCCESS;
7375 }
7376
7377 _PUBLIC_ void ndr_print_samr_LookupRids(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupRids *r)
7378 {
7379         uint32_t cntr_rids_0;
7380         ndr_print_struct(ndr, name, "samr_LookupRids");
7381         ndr->depth++;
7382         if (flags & NDR_SET_VALUES) {
7383                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7384         }
7385         if (flags & NDR_IN) {
7386                 ndr_print_struct(ndr, "in", "samr_LookupRids");
7387                 ndr->depth++;
7388                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7389                 ndr->depth++;
7390                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7391                 ndr->depth--;
7392                 ndr_print_uint32(ndr, "num_rids", r->in.num_rids);
7393                 ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->in.num_rids);
7394                 ndr->depth++;
7395                 for (cntr_rids_0=0;cntr_rids_0<r->in.num_rids;cntr_rids_0++) {
7396                         char *idx_0=NULL;
7397                         if (asprintf(&idx_0, "[%d]", cntr_rids_0) != -1) {
7398                                 ndr_print_uint32(ndr, "rids", r->in.rids[cntr_rids_0]);
7399                                 free(idx_0);
7400                         }
7401                 }
7402                 ndr->depth--;
7403                 ndr->depth--;
7404         }
7405         if (flags & NDR_OUT) {
7406                 ndr_print_struct(ndr, "out", "samr_LookupRids");
7407                 ndr->depth++;
7408                 ndr_print_ptr(ndr, "names", r->out.names);
7409                 ndr->depth++;
7410                 ndr_print_lsa_Strings(ndr, "names", r->out.names);
7411                 ndr->depth--;
7412                 ndr_print_ptr(ndr, "types", r->out.types);
7413                 ndr->depth++;
7414                 ndr_print_samr_Ids(ndr, "types", r->out.types);
7415                 ndr->depth--;
7416                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7417                 ndr->depth--;
7418         }
7419         ndr->depth--;
7420 }
7421
7422 static enum ndr_err_code ndr_push_samr_OpenGroup(struct ndr_push *ndr, int flags, const struct samr_OpenGroup *r)
7423 {
7424         if (flags & NDR_IN) {
7425                 if (r->in.domain_handle == NULL) {
7426                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7427                 }
7428                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7429                 NDR_CHECK(ndr_push_samr_GroupAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
7430                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
7431         }
7432         if (flags & NDR_OUT) {
7433                 if (r->out.group_handle == NULL) {
7434                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7435                 }
7436                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
7437                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7438         }
7439         return NDR_ERR_SUCCESS;
7440 }
7441
7442 static enum ndr_err_code ndr_pull_samr_OpenGroup(struct ndr_pull *ndr, int flags, struct samr_OpenGroup *r)
7443 {
7444         TALLOC_CTX *_mem_save_domain_handle_0;
7445         TALLOC_CTX *_mem_save_group_handle_0;
7446         if (flags & NDR_IN) {
7447                 ZERO_STRUCT(r->out);
7448
7449                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7450                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7451                 }
7452                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7453                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7454                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7455                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7456                 NDR_CHECK(ndr_pull_samr_GroupAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
7457                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
7458                 NDR_PULL_ALLOC(ndr, r->out.group_handle);
7459                 ZERO_STRUCTP(r->out.group_handle);
7460         }
7461         if (flags & NDR_OUT) {
7462                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7463                         NDR_PULL_ALLOC(ndr, r->out.group_handle);
7464                 }
7465                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7466                 NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);
7467                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
7468                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7469                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7470         }
7471         return NDR_ERR_SUCCESS;
7472 }
7473
7474 _PUBLIC_ void ndr_print_samr_OpenGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenGroup *r)
7475 {
7476         ndr_print_struct(ndr, name, "samr_OpenGroup");
7477         ndr->depth++;
7478         if (flags & NDR_SET_VALUES) {
7479                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7480         }
7481         if (flags & NDR_IN) {
7482                 ndr_print_struct(ndr, "in", "samr_OpenGroup");
7483                 ndr->depth++;
7484                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7485                 ndr->depth++;
7486                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7487                 ndr->depth--;
7488                 ndr_print_samr_GroupAccessMask(ndr, "access_mask", r->in.access_mask);
7489                 ndr_print_uint32(ndr, "rid", r->in.rid);
7490                 ndr->depth--;
7491         }
7492         if (flags & NDR_OUT) {
7493                 ndr_print_struct(ndr, "out", "samr_OpenGroup");
7494                 ndr->depth++;
7495                 ndr_print_ptr(ndr, "group_handle", r->out.group_handle);
7496                 ndr->depth++;
7497                 ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);
7498                 ndr->depth--;
7499                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7500                 ndr->depth--;
7501         }
7502         ndr->depth--;
7503 }
7504
7505 static enum ndr_err_code ndr_push_samr_QueryGroupInfo(struct ndr_push *ndr, int flags, const struct samr_QueryGroupInfo *r)
7506 {
7507         if (flags & NDR_IN) {
7508                 if (r->in.group_handle == NULL) {
7509                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7510                 }
7511                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7512                 NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, r->in.level));
7513         }
7514         if (flags & NDR_OUT) {
7515                 if (r->out.info == NULL) {
7516                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7517                 }
7518                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
7519                 if (*r->out.info) {
7520                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
7521                         NDR_CHECK(ndr_push_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
7522                 }
7523                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7524         }
7525         return NDR_ERR_SUCCESS;
7526 }
7527
7528 static enum ndr_err_code ndr_pull_samr_QueryGroupInfo(struct ndr_pull *ndr, int flags, struct samr_QueryGroupInfo *r)
7529 {
7530         uint32_t _ptr_info;
7531         TALLOC_CTX *_mem_save_group_handle_0;
7532         TALLOC_CTX *_mem_save_info_0;
7533         TALLOC_CTX *_mem_save_info_1;
7534         if (flags & NDR_IN) {
7535                 ZERO_STRUCT(r->out);
7536
7537                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7538                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
7539                 }
7540                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7541                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
7542                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7543                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7544                 NDR_CHECK(ndr_pull_samr_GroupInfoEnum(ndr, NDR_SCALARS, &r->in.level));
7545                 NDR_PULL_ALLOC(ndr, r->out.info);
7546                 ZERO_STRUCTP(r->out.info);
7547         }
7548         if (flags & NDR_OUT) {
7549                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7550                         NDR_PULL_ALLOC(ndr, r->out.info);
7551                 }
7552                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7553                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
7554                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
7555                 if (_ptr_info) {
7556                         NDR_PULL_ALLOC(ndr, *r->out.info);
7557                 } else {
7558                         *r->out.info = NULL;
7559                 }
7560                 if (*r->out.info) {
7561                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
7562                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
7563                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
7564                         NDR_CHECK(ndr_pull_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
7565                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
7566                 }
7567                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7568                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7569         }
7570         return NDR_ERR_SUCCESS;
7571 }
7572
7573 _PUBLIC_ void ndr_print_samr_QueryGroupInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryGroupInfo *r)
7574 {
7575         ndr_print_struct(ndr, name, "samr_QueryGroupInfo");
7576         ndr->depth++;
7577         if (flags & NDR_SET_VALUES) {
7578                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7579         }
7580         if (flags & NDR_IN) {
7581                 ndr_print_struct(ndr, "in", "samr_QueryGroupInfo");
7582                 ndr->depth++;
7583                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
7584                 ndr->depth++;
7585                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
7586                 ndr->depth--;
7587                 ndr_print_samr_GroupInfoEnum(ndr, "level", r->in.level);
7588                 ndr->depth--;
7589         }
7590         if (flags & NDR_OUT) {
7591                 ndr_print_struct(ndr, "out", "samr_QueryGroupInfo");
7592                 ndr->depth++;
7593                 ndr_print_ptr(ndr, "info", r->out.info);
7594                 ndr->depth++;
7595                 ndr_print_ptr(ndr, "info", *r->out.info);
7596                 ndr->depth++;
7597                 if (*r->out.info) {
7598                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
7599                         ndr_print_samr_GroupInfo(ndr, "info", *r->out.info);
7600                 }
7601                 ndr->depth--;
7602                 ndr->depth--;
7603                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7604                 ndr->depth--;
7605         }
7606         ndr->depth--;
7607 }
7608
7609 static enum ndr_err_code ndr_push_samr_SetGroupInfo(struct ndr_push *ndr, int flags, const struct samr_SetGroupInfo *r)
7610 {
7611         if (flags & NDR_IN) {
7612                 if (r->in.group_handle == NULL) {
7613                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7614                 }
7615                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7616                 NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, r->in.level));
7617                 if (r->in.info == NULL) {
7618                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7619                 }
7620                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
7621                 NDR_CHECK(ndr_push_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
7622         }
7623         if (flags & NDR_OUT) {
7624                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7625         }
7626         return NDR_ERR_SUCCESS;
7627 }
7628
7629 static enum ndr_err_code ndr_pull_samr_SetGroupInfo(struct ndr_pull *ndr, int flags, struct samr_SetGroupInfo *r)
7630 {
7631         TALLOC_CTX *_mem_save_group_handle_0;
7632         TALLOC_CTX *_mem_save_info_0;
7633         if (flags & NDR_IN) {
7634                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7635                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
7636                 }
7637                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7638                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
7639                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7640                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7641                 NDR_CHECK(ndr_pull_samr_GroupInfoEnum(ndr, NDR_SCALARS, &r->in.level));
7642                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7643                         NDR_PULL_ALLOC(ndr, r->in.info);
7644                 }
7645                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7646                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
7647                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
7648                 NDR_CHECK(ndr_pull_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
7649                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7650         }
7651         if (flags & NDR_OUT) {
7652                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7653         }
7654         return NDR_ERR_SUCCESS;
7655 }
7656
7657 _PUBLIC_ void ndr_print_samr_SetGroupInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetGroupInfo *r)
7658 {
7659         ndr_print_struct(ndr, name, "samr_SetGroupInfo");
7660         ndr->depth++;
7661         if (flags & NDR_SET_VALUES) {
7662                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7663         }
7664         if (flags & NDR_IN) {
7665                 ndr_print_struct(ndr, "in", "samr_SetGroupInfo");
7666                 ndr->depth++;
7667                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
7668                 ndr->depth++;
7669                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
7670                 ndr->depth--;
7671                 ndr_print_samr_GroupInfoEnum(ndr, "level", r->in.level);
7672                 ndr_print_ptr(ndr, "info", r->in.info);
7673                 ndr->depth++;
7674                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
7675                 ndr_print_samr_GroupInfo(ndr, "info", r->in.info);
7676                 ndr->depth--;
7677                 ndr->depth--;
7678         }
7679         if (flags & NDR_OUT) {
7680                 ndr_print_struct(ndr, "out", "samr_SetGroupInfo");
7681                 ndr->depth++;
7682                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7683                 ndr->depth--;
7684         }
7685         ndr->depth--;
7686 }
7687
7688 static enum ndr_err_code ndr_push_samr_AddGroupMember(struct ndr_push *ndr, int flags, const struct samr_AddGroupMember *r)
7689 {
7690         if (flags & NDR_IN) {
7691                 if (r->in.group_handle == NULL) {
7692                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7693                 }
7694                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7695                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
7696                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
7697         }
7698         if (flags & NDR_OUT) {
7699                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7700         }
7701         return NDR_ERR_SUCCESS;
7702 }
7703
7704 static enum ndr_err_code ndr_pull_samr_AddGroupMember(struct ndr_pull *ndr, int flags, struct samr_AddGroupMember *r)
7705 {
7706         TALLOC_CTX *_mem_save_group_handle_0;
7707         if (flags & NDR_IN) {
7708                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7709                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
7710                 }
7711                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7712                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
7713                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7714                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7715                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
7716                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
7717         }
7718         if (flags & NDR_OUT) {
7719                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7720         }
7721         return NDR_ERR_SUCCESS;
7722 }
7723
7724 _PUBLIC_ void ndr_print_samr_AddGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddGroupMember *r)
7725 {
7726         ndr_print_struct(ndr, name, "samr_AddGroupMember");
7727         ndr->depth++;
7728         if (flags & NDR_SET_VALUES) {
7729                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7730         }
7731         if (flags & NDR_IN) {
7732                 ndr_print_struct(ndr, "in", "samr_AddGroupMember");
7733                 ndr->depth++;
7734                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
7735                 ndr->depth++;
7736                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
7737                 ndr->depth--;
7738                 ndr_print_uint32(ndr, "rid", r->in.rid);
7739                 ndr_print_uint32(ndr, "flags", r->in.flags);
7740                 ndr->depth--;
7741         }
7742         if (flags & NDR_OUT) {
7743                 ndr_print_struct(ndr, "out", "samr_AddGroupMember");
7744                 ndr->depth++;
7745                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7746                 ndr->depth--;
7747         }
7748         ndr->depth--;
7749 }
7750
7751 static enum ndr_err_code ndr_push_samr_DeleteDomainGroup(struct ndr_push *ndr, int flags, const struct samr_DeleteDomainGroup *r)
7752 {
7753         if (flags & NDR_IN) {
7754                 if (r->in.group_handle == NULL) {
7755                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7756                 }
7757                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7758         }
7759         if (flags & NDR_OUT) {
7760                 if (r->out.group_handle == NULL) {
7761                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7762                 }
7763                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
7764                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7765         }
7766         return NDR_ERR_SUCCESS;
7767 }
7768
7769 static enum ndr_err_code ndr_pull_samr_DeleteDomainGroup(struct ndr_pull *ndr, int flags, struct samr_DeleteDomainGroup *r)
7770 {
7771         TALLOC_CTX *_mem_save_group_handle_0;
7772         if (flags & NDR_IN) {
7773                 ZERO_STRUCT(r->out);
7774
7775                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7776                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
7777                 }
7778                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7779                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
7780                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7781                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7782                 NDR_PULL_ALLOC(ndr, r->out.group_handle);
7783                 *r->out.group_handle = *r->in.group_handle;
7784         }
7785         if (flags & NDR_OUT) {
7786                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7787                         NDR_PULL_ALLOC(ndr, r->out.group_handle);
7788                 }
7789                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7790                 NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);
7791                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
7792                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7793                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7794         }
7795         return NDR_ERR_SUCCESS;
7796 }
7797
7798 _PUBLIC_ void ndr_print_samr_DeleteDomainGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteDomainGroup *r)
7799 {
7800         ndr_print_struct(ndr, name, "samr_DeleteDomainGroup");
7801         ndr->depth++;
7802         if (flags & NDR_SET_VALUES) {
7803                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7804         }
7805         if (flags & NDR_IN) {
7806                 ndr_print_struct(ndr, "in", "samr_DeleteDomainGroup");
7807                 ndr->depth++;
7808                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
7809                 ndr->depth++;
7810                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
7811                 ndr->depth--;
7812                 ndr->depth--;
7813         }
7814         if (flags & NDR_OUT) {
7815                 ndr_print_struct(ndr, "out", "samr_DeleteDomainGroup");
7816                 ndr->depth++;
7817                 ndr_print_ptr(ndr, "group_handle", r->out.group_handle);
7818                 ndr->depth++;
7819                 ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);
7820                 ndr->depth--;
7821                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7822                 ndr->depth--;
7823         }
7824         ndr->depth--;
7825 }
7826
7827 static enum ndr_err_code ndr_push_samr_DeleteGroupMember(struct ndr_push *ndr, int flags, const struct samr_DeleteGroupMember *r)
7828 {
7829         if (flags & NDR_IN) {
7830                 if (r->in.group_handle == NULL) {
7831                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7832                 }
7833                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7834                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
7835         }
7836         if (flags & NDR_OUT) {
7837                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7838         }
7839         return NDR_ERR_SUCCESS;
7840 }
7841
7842 static enum ndr_err_code ndr_pull_samr_DeleteGroupMember(struct ndr_pull *ndr, int flags, struct samr_DeleteGroupMember *r)
7843 {
7844         TALLOC_CTX *_mem_save_group_handle_0;
7845         if (flags & NDR_IN) {
7846                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7847                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
7848                 }
7849                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7850                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
7851                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7852                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7853                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
7854         }
7855         if (flags & NDR_OUT) {
7856                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7857         }
7858         return NDR_ERR_SUCCESS;
7859 }
7860
7861 _PUBLIC_ void ndr_print_samr_DeleteGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteGroupMember *r)
7862 {
7863         ndr_print_struct(ndr, name, "samr_DeleteGroupMember");
7864         ndr->depth++;
7865         if (flags & NDR_SET_VALUES) {
7866                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7867         }
7868         if (flags & NDR_IN) {
7869                 ndr_print_struct(ndr, "in", "samr_DeleteGroupMember");
7870                 ndr->depth++;
7871                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
7872                 ndr->depth++;
7873                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
7874                 ndr->depth--;
7875                 ndr_print_uint32(ndr, "rid", r->in.rid);
7876                 ndr->depth--;
7877         }
7878         if (flags & NDR_OUT) {
7879                 ndr_print_struct(ndr, "out", "samr_DeleteGroupMember");
7880                 ndr->depth++;
7881                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7882                 ndr->depth--;
7883         }
7884         ndr->depth--;
7885 }
7886
7887 static enum ndr_err_code ndr_push_samr_QueryGroupMember(struct ndr_push *ndr, int flags, const struct samr_QueryGroupMember *r)
7888 {
7889         if (flags & NDR_IN) {
7890                 if (r->in.group_handle == NULL) {
7891                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7892                 }
7893                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7894         }
7895         if (flags & NDR_OUT) {
7896                 if (r->out.rids == NULL) {
7897                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7898                 }
7899                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rids));
7900                 if (*r->out.rids) {
7901                         NDR_CHECK(ndr_push_samr_RidTypeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
7902                 }
7903                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7904         }
7905         return NDR_ERR_SUCCESS;
7906 }
7907
7908 static enum ndr_err_code ndr_pull_samr_QueryGroupMember(struct ndr_pull *ndr, int flags, struct samr_QueryGroupMember *r)
7909 {
7910         uint32_t _ptr_rids;
7911         TALLOC_CTX *_mem_save_group_handle_0;
7912         TALLOC_CTX *_mem_save_rids_0;
7913         TALLOC_CTX *_mem_save_rids_1;
7914         if (flags & NDR_IN) {
7915                 ZERO_STRUCT(r->out);
7916
7917                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7918                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
7919                 }
7920                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7921                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
7922                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7923                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7924                 NDR_PULL_ALLOC(ndr, r->out.rids);
7925                 ZERO_STRUCTP(r->out.rids);
7926         }
7927         if (flags & NDR_OUT) {
7928                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7929                         NDR_PULL_ALLOC(ndr, r->out.rids);
7930                 }
7931                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7932                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
7933                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
7934                 if (_ptr_rids) {
7935                         NDR_PULL_ALLOC(ndr, *r->out.rids);
7936                 } else {
7937                         *r->out.rids = NULL;
7938                 }
7939                 if (*r->out.rids) {
7940                         _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
7941                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.rids, 0);
7942                         NDR_CHECK(ndr_pull_samr_RidTypeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
7943                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
7944                 }
7945                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
7946                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7947         }
7948         return NDR_ERR_SUCCESS;
7949 }
7950
7951 _PUBLIC_ void ndr_print_samr_QueryGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryGroupMember *r)
7952 {
7953         ndr_print_struct(ndr, name, "samr_QueryGroupMember");
7954         ndr->depth++;
7955         if (flags & NDR_SET_VALUES) {
7956                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7957         }
7958         if (flags & NDR_IN) {
7959                 ndr_print_struct(ndr, "in", "samr_QueryGroupMember");
7960                 ndr->depth++;
7961                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
7962                 ndr->depth++;
7963                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
7964                 ndr->depth--;
7965                 ndr->depth--;
7966         }
7967         if (flags & NDR_OUT) {
7968                 ndr_print_struct(ndr, "out", "samr_QueryGroupMember");
7969                 ndr->depth++;
7970                 ndr_print_ptr(ndr, "rids", r->out.rids);
7971                 ndr->depth++;
7972                 ndr_print_ptr(ndr, "rids", *r->out.rids);
7973                 ndr->depth++;
7974                 if (*r->out.rids) {
7975                         ndr_print_samr_RidTypeArray(ndr, "rids", *r->out.rids);
7976                 }
7977                 ndr->depth--;
7978                 ndr->depth--;
7979                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7980                 ndr->depth--;
7981         }
7982         ndr->depth--;
7983 }
7984
7985 static enum ndr_err_code ndr_push_samr_SetMemberAttributesOfGroup(struct ndr_push *ndr, int flags, const struct samr_SetMemberAttributesOfGroup *r)
7986 {
7987         if (flags & NDR_IN) {
7988                 if (r->in.group_handle == NULL) {
7989                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7990                 }
7991                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7992                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
7993                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
7994         }
7995         if (flags & NDR_OUT) {
7996                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7997         }
7998         return NDR_ERR_SUCCESS;
7999 }
8000
8001 static enum ndr_err_code ndr_pull_samr_SetMemberAttributesOfGroup(struct ndr_pull *ndr, int flags, struct samr_SetMemberAttributesOfGroup *r)
8002 {
8003         TALLOC_CTX *_mem_save_group_handle_0;
8004         if (flags & NDR_IN) {
8005                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8006                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
8007                 }
8008                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8009                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
8010                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8011                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
8012                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
8013                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
8014         }
8015         if (flags & NDR_OUT) {
8016                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8017         }
8018         return NDR_ERR_SUCCESS;
8019 }
8020
8021 _PUBLIC_ void ndr_print_samr_SetMemberAttributesOfGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetMemberAttributesOfGroup *r)
8022 {
8023         ndr_print_struct(ndr, name, "samr_SetMemberAttributesOfGroup");
8024         ndr->depth++;
8025         if (flags & NDR_SET_VALUES) {
8026                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8027         }
8028         if (flags & NDR_IN) {
8029                 ndr_print_struct(ndr, "in", "samr_SetMemberAttributesOfGroup");
8030                 ndr->depth++;
8031                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
8032                 ndr->depth++;
8033                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
8034                 ndr->depth--;
8035                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
8036                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
8037                 ndr->depth--;
8038         }
8039         if (flags & NDR_OUT) {
8040                 ndr_print_struct(ndr, "out", "samr_SetMemberAttributesOfGroup");
8041                 ndr->depth++;
8042                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8043                 ndr->depth--;
8044         }
8045         ndr->depth--;
8046 }
8047
8048 static enum ndr_err_code ndr_push_samr_OpenAlias(struct ndr_push *ndr, int flags, const struct samr_OpenAlias *r)
8049 {
8050         if (flags & NDR_IN) {
8051                 if (r->in.domain_handle == NULL) {
8052                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8053                 }
8054                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
8055                 NDR_CHECK(ndr_push_samr_AliasAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
8056                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
8057         }
8058         if (flags & NDR_OUT) {
8059                 if (r->out.alias_handle == NULL) {
8060                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8061                 }
8062                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
8063                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8064         }
8065         return NDR_ERR_SUCCESS;
8066 }
8067
8068 static enum ndr_err_code ndr_pull_samr_OpenAlias(struct ndr_pull *ndr, int flags, struct samr_OpenAlias *r)
8069 {
8070         TALLOC_CTX *_mem_save_domain_handle_0;
8071         TALLOC_CTX *_mem_save_alias_handle_0;
8072         if (flags & NDR_IN) {
8073                 ZERO_STRUCT(r->out);
8074
8075                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8076                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
8077                 }
8078                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8079                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
8080                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
8081                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
8082                 NDR_CHECK(ndr_pull_samr_AliasAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
8083                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
8084                 NDR_PULL_ALLOC(ndr, r->out.alias_handle);
8085                 ZERO_STRUCTP(r->out.alias_handle);
8086         }
8087         if (flags & NDR_OUT) {
8088                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8089                         NDR_PULL_ALLOC(ndr, r->out.alias_handle);
8090                 }
8091                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8092                 NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8093                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
8094                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8095                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8096         }
8097         return NDR_ERR_SUCCESS;
8098 }
8099
8100 _PUBLIC_ void ndr_print_samr_OpenAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenAlias *r)
8101 {
8102         ndr_print_struct(ndr, name, "samr_OpenAlias");
8103         ndr->depth++;
8104         if (flags & NDR_SET_VALUES) {
8105                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8106         }
8107         if (flags & NDR_IN) {
8108                 ndr_print_struct(ndr, "in", "samr_OpenAlias");
8109                 ndr->depth++;
8110                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
8111                 ndr->depth++;
8112                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
8113                 ndr->depth--;
8114                 ndr_print_samr_AliasAccessMask(ndr, "access_mask", r->in.access_mask);
8115                 ndr_print_uint32(ndr, "rid", r->in.rid);
8116                 ndr->depth--;
8117         }
8118         if (flags & NDR_OUT) {
8119                 ndr_print_struct(ndr, "out", "samr_OpenAlias");
8120                 ndr->depth++;
8121                 ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);
8122                 ndr->depth++;
8123                 ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);
8124                 ndr->depth--;
8125                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8126                 ndr->depth--;
8127         }
8128         ndr->depth--;
8129 }
8130
8131 static enum ndr_err_code ndr_push_samr_QueryAliasInfo(struct ndr_push *ndr, int flags, const struct samr_QueryAliasInfo *r)
8132 {
8133         if (flags & NDR_IN) {
8134                 if (r->in.alias_handle == NULL) {
8135                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8136                 }
8137                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8138                 NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, r->in.level));
8139         }
8140         if (flags & NDR_OUT) {
8141                 if (r->out.info == NULL) {
8142                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8143                 }
8144                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
8145                 if (*r->out.info) {
8146                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
8147                         NDR_CHECK(ndr_push_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8148                 }
8149                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8150         }
8151         return NDR_ERR_SUCCESS;
8152 }
8153
8154 static enum ndr_err_code ndr_pull_samr_QueryAliasInfo(struct ndr_pull *ndr, int flags, struct samr_QueryAliasInfo *r)
8155 {
8156         uint32_t _ptr_info;
8157         TALLOC_CTX *_mem_save_alias_handle_0;
8158         TALLOC_CTX *_mem_save_info_0;
8159         TALLOC_CTX *_mem_save_info_1;
8160         if (flags & NDR_IN) {
8161                 ZERO_STRUCT(r->out);
8162
8163                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8164                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8165                 }
8166                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8167                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8168                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8169                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8170                 NDR_CHECK(ndr_pull_samr_AliasInfoEnum(ndr, NDR_SCALARS, &r->in.level));
8171                 NDR_PULL_ALLOC(ndr, r->out.info);
8172                 ZERO_STRUCTP(r->out.info);
8173         }
8174         if (flags & NDR_OUT) {
8175                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8176                         NDR_PULL_ALLOC(ndr, r->out.info);
8177                 }
8178                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8179                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
8180                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8181                 if (_ptr_info) {
8182                         NDR_PULL_ALLOC(ndr, *r->out.info);
8183                 } else {
8184                         *r->out.info = NULL;
8185                 }
8186                 if (*r->out.info) {
8187                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
8188                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
8189                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
8190                         NDR_CHECK(ndr_pull_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8191                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
8192                 }
8193                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
8194                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8195         }
8196         return NDR_ERR_SUCCESS;
8197 }
8198
8199 _PUBLIC_ void ndr_print_samr_QueryAliasInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryAliasInfo *r)
8200 {
8201         ndr_print_struct(ndr, name, "samr_QueryAliasInfo");
8202         ndr->depth++;
8203         if (flags & NDR_SET_VALUES) {
8204                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8205         }
8206         if (flags & NDR_IN) {
8207                 ndr_print_struct(ndr, "in", "samr_QueryAliasInfo");
8208                 ndr->depth++;
8209                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8210                 ndr->depth++;
8211                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8212                 ndr->depth--;
8213                 ndr_print_samr_AliasInfoEnum(ndr, "level", r->in.level);
8214                 ndr->depth--;
8215         }
8216         if (flags & NDR_OUT) {
8217                 ndr_print_struct(ndr, "out", "samr_QueryAliasInfo");
8218                 ndr->depth++;
8219                 ndr_print_ptr(ndr, "info", r->out.info);
8220                 ndr->depth++;
8221                 ndr_print_ptr(ndr, "info", *r->out.info);
8222                 ndr->depth++;
8223                 if (*r->out.info) {
8224                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
8225                         ndr_print_samr_AliasInfo(ndr, "info", *r->out.info);
8226                 }
8227                 ndr->depth--;
8228                 ndr->depth--;
8229                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8230                 ndr->depth--;
8231         }
8232         ndr->depth--;
8233 }
8234
8235 static enum ndr_err_code ndr_push_samr_SetAliasInfo(struct ndr_push *ndr, int flags, const struct samr_SetAliasInfo *r)
8236 {
8237         if (flags & NDR_IN) {
8238                 if (r->in.alias_handle == NULL) {
8239                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8240                 }
8241                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8242                 NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, r->in.level));
8243                 if (r->in.info == NULL) {
8244                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8245                 }
8246                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
8247                 NDR_CHECK(ndr_push_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8248         }
8249         if (flags & NDR_OUT) {
8250                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8251         }
8252         return NDR_ERR_SUCCESS;
8253 }
8254
8255 static enum ndr_err_code ndr_pull_samr_SetAliasInfo(struct ndr_pull *ndr, int flags, struct samr_SetAliasInfo *r)
8256 {
8257         TALLOC_CTX *_mem_save_alias_handle_0;
8258         TALLOC_CTX *_mem_save_info_0;
8259         if (flags & NDR_IN) {
8260                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8261                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8262                 }
8263                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8264                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8265                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8266                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8267                 NDR_CHECK(ndr_pull_samr_AliasInfoEnum(ndr, NDR_SCALARS, &r->in.level));
8268                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8269                         NDR_PULL_ALLOC(ndr, r->in.info);
8270                 }
8271                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8272                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
8273                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
8274                 NDR_CHECK(ndr_pull_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8275                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
8276         }
8277         if (flags & NDR_OUT) {
8278                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8279         }
8280         return NDR_ERR_SUCCESS;
8281 }
8282
8283 _PUBLIC_ void ndr_print_samr_SetAliasInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetAliasInfo *r)
8284 {
8285         ndr_print_struct(ndr, name, "samr_SetAliasInfo");
8286         ndr->depth++;
8287         if (flags & NDR_SET_VALUES) {
8288                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8289         }
8290         if (flags & NDR_IN) {
8291                 ndr_print_struct(ndr, "in", "samr_SetAliasInfo");
8292                 ndr->depth++;
8293                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8294                 ndr->depth++;
8295                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8296                 ndr->depth--;
8297                 ndr_print_samr_AliasInfoEnum(ndr, "level", r->in.level);
8298                 ndr_print_ptr(ndr, "info", r->in.info);
8299                 ndr->depth++;
8300                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
8301                 ndr_print_samr_AliasInfo(ndr, "info", r->in.info);
8302                 ndr->depth--;
8303                 ndr->depth--;
8304         }
8305         if (flags & NDR_OUT) {
8306                 ndr_print_struct(ndr, "out", "samr_SetAliasInfo");
8307                 ndr->depth++;
8308                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8309                 ndr->depth--;
8310         }
8311         ndr->depth--;
8312 }
8313
8314 static enum ndr_err_code ndr_push_samr_DeleteDomAlias(struct ndr_push *ndr, int flags, const struct samr_DeleteDomAlias *r)
8315 {
8316         if (flags & NDR_IN) {
8317                 if (r->in.alias_handle == NULL) {
8318                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8319                 }
8320                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8321         }
8322         if (flags & NDR_OUT) {
8323                 if (r->out.alias_handle == NULL) {
8324                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8325                 }
8326                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
8327                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8328         }
8329         return NDR_ERR_SUCCESS;
8330 }
8331
8332 static enum ndr_err_code ndr_pull_samr_DeleteDomAlias(struct ndr_pull *ndr, int flags, struct samr_DeleteDomAlias *r)
8333 {
8334         TALLOC_CTX *_mem_save_alias_handle_0;
8335         if (flags & NDR_IN) {
8336                 ZERO_STRUCT(r->out);
8337
8338                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8339                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8340                 }
8341                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8342                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8343                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8344                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8345                 NDR_PULL_ALLOC(ndr, r->out.alias_handle);
8346                 *r->out.alias_handle = *r->in.alias_handle;
8347         }
8348         if (flags & NDR_OUT) {
8349                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8350                         NDR_PULL_ALLOC(ndr, r->out.alias_handle);
8351                 }
8352                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8353                 NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8354                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
8355                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8356                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8357         }
8358         return NDR_ERR_SUCCESS;
8359 }
8360
8361 _PUBLIC_ void ndr_print_samr_DeleteDomAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteDomAlias *r)
8362 {
8363         ndr_print_struct(ndr, name, "samr_DeleteDomAlias");
8364         ndr->depth++;
8365         if (flags & NDR_SET_VALUES) {
8366                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8367         }
8368         if (flags & NDR_IN) {
8369                 ndr_print_struct(ndr, "in", "samr_DeleteDomAlias");
8370                 ndr->depth++;
8371                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8372                 ndr->depth++;
8373                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8374                 ndr->depth--;
8375                 ndr->depth--;
8376         }
8377         if (flags & NDR_OUT) {
8378                 ndr_print_struct(ndr, "out", "samr_DeleteDomAlias");
8379                 ndr->depth++;
8380                 ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);
8381                 ndr->depth++;
8382                 ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);
8383                 ndr->depth--;
8384                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8385                 ndr->depth--;
8386         }
8387         ndr->depth--;
8388 }
8389
8390 static enum ndr_err_code ndr_push_samr_AddAliasMember(struct ndr_push *ndr, int flags, const struct samr_AddAliasMember *r)
8391 {
8392         if (flags & NDR_IN) {
8393                 if (r->in.alias_handle == NULL) {
8394                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8395                 }
8396                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8397                 if (r->in.sid == NULL) {
8398                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8399                 }
8400                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8401         }
8402         if (flags & NDR_OUT) {
8403                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8404         }
8405         return NDR_ERR_SUCCESS;
8406 }
8407
8408 static enum ndr_err_code ndr_pull_samr_AddAliasMember(struct ndr_pull *ndr, int flags, struct samr_AddAliasMember *r)
8409 {
8410         TALLOC_CTX *_mem_save_alias_handle_0;
8411         TALLOC_CTX *_mem_save_sid_0;
8412         if (flags & NDR_IN) {
8413                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8414                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8415                 }
8416                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8417                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8418                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8419                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8420                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8421                         NDR_PULL_ALLOC(ndr, r->in.sid);
8422                 }
8423                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
8424                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
8425                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8426                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
8427         }
8428         if (flags & NDR_OUT) {
8429                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8430         }
8431         return NDR_ERR_SUCCESS;
8432 }
8433
8434 _PUBLIC_ void ndr_print_samr_AddAliasMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddAliasMember *r)
8435 {
8436         ndr_print_struct(ndr, name, "samr_AddAliasMember");
8437         ndr->depth++;
8438         if (flags & NDR_SET_VALUES) {
8439                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8440         }
8441         if (flags & NDR_IN) {
8442                 ndr_print_struct(ndr, "in", "samr_AddAliasMember");
8443                 ndr->depth++;
8444                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8445                 ndr->depth++;
8446                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8447                 ndr->depth--;
8448                 ndr_print_ptr(ndr, "sid", r->in.sid);
8449                 ndr->depth++;
8450                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
8451                 ndr->depth--;
8452                 ndr->depth--;
8453         }
8454         if (flags & NDR_OUT) {
8455                 ndr_print_struct(ndr, "out", "samr_AddAliasMember");
8456                 ndr->depth++;
8457                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8458                 ndr->depth--;
8459         }
8460         ndr->depth--;
8461 }
8462
8463 static enum ndr_err_code ndr_push_samr_DeleteAliasMember(struct ndr_push *ndr, int flags, const struct samr_DeleteAliasMember *r)
8464 {
8465         if (flags & NDR_IN) {
8466                 if (r->in.alias_handle == NULL) {
8467                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8468                 }
8469                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8470                 if (r->in.sid == NULL) {
8471                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8472                 }
8473                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8474         }
8475         if (flags & NDR_OUT) {
8476                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8477         }
8478         return NDR_ERR_SUCCESS;
8479 }
8480
8481 static enum ndr_err_code ndr_pull_samr_DeleteAliasMember(struct ndr_pull *ndr, int flags, struct samr_DeleteAliasMember *r)
8482 {
8483         TALLOC_CTX *_mem_save_alias_handle_0;
8484         TALLOC_CTX *_mem_save_sid_0;
8485         if (flags & NDR_IN) {
8486                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8487                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8488                 }
8489                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8490                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8491                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8492                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8493                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8494                         NDR_PULL_ALLOC(ndr, r->in.sid);
8495                 }
8496                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
8497                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
8498                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8499                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
8500         }
8501         if (flags & NDR_OUT) {
8502                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8503         }
8504         return NDR_ERR_SUCCESS;
8505 }
8506
8507 _PUBLIC_ void ndr_print_samr_DeleteAliasMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteAliasMember *r)
8508 {
8509         ndr_print_struct(ndr, name, "samr_DeleteAliasMember");
8510         ndr->depth++;
8511         if (flags & NDR_SET_VALUES) {
8512                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8513         }
8514         if (flags & NDR_IN) {
8515                 ndr_print_struct(ndr, "in", "samr_DeleteAliasMember");
8516                 ndr->depth++;
8517                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8518                 ndr->depth++;
8519                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8520                 ndr->depth--;
8521                 ndr_print_ptr(ndr, "sid", r->in.sid);
8522                 ndr->depth++;
8523                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
8524                 ndr->depth--;
8525                 ndr->depth--;
8526         }
8527         if (flags & NDR_OUT) {
8528                 ndr_print_struct(ndr, "out", "samr_DeleteAliasMember");
8529                 ndr->depth++;
8530                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8531                 ndr->depth--;
8532         }
8533         ndr->depth--;
8534 }
8535
8536 static enum ndr_err_code ndr_push_samr_GetMembersInAlias(struct ndr_push *ndr, int flags, const struct samr_GetMembersInAlias *r)
8537 {
8538         if (flags & NDR_IN) {
8539                 if (r->in.alias_handle == NULL) {
8540                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8541                 }
8542                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8543         }
8544         if (flags & NDR_OUT) {
8545                 if (r->out.sids == NULL) {
8546                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8547                 }
8548                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
8549                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8550         }
8551         return NDR_ERR_SUCCESS;
8552 }
8553
8554 static enum ndr_err_code ndr_pull_samr_GetMembersInAlias(struct ndr_pull *ndr, int flags, struct samr_GetMembersInAlias *r)
8555 {
8556         TALLOC_CTX *_mem_save_alias_handle_0;
8557         TALLOC_CTX *_mem_save_sids_0;
8558         if (flags & NDR_IN) {
8559                 ZERO_STRUCT(r->out);
8560
8561                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8562                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8563                 }
8564                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8565                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8566                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8567                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8568                 NDR_PULL_ALLOC(ndr, r->out.sids);
8569                 ZERO_STRUCTP(r->out.sids);
8570         }
8571         if (flags & NDR_OUT) {
8572                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8573                         NDR_PULL_ALLOC(ndr, r->out.sids);
8574                 }
8575                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
8576                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
8577                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
8578                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
8579                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8580         }
8581         return NDR_ERR_SUCCESS;
8582 }
8583
8584 _PUBLIC_ void ndr_print_samr_GetMembersInAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetMembersInAlias *r)
8585 {
8586         ndr_print_struct(ndr, name, "samr_GetMembersInAlias");
8587         ndr->depth++;
8588         if (flags & NDR_SET_VALUES) {
8589                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8590         }
8591         if (flags & NDR_IN) {
8592                 ndr_print_struct(ndr, "in", "samr_GetMembersInAlias");
8593                 ndr->depth++;
8594                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8595                 ndr->depth++;
8596                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8597                 ndr->depth--;
8598                 ndr->depth--;
8599         }
8600         if (flags & NDR_OUT) {
8601                 ndr_print_struct(ndr, "out", "samr_GetMembersInAlias");
8602                 ndr->depth++;
8603                 ndr_print_ptr(ndr, "sids", r->out.sids);
8604                 ndr->depth++;
8605                 ndr_print_lsa_SidArray(ndr, "sids", r->out.sids);
8606                 ndr->depth--;
8607                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8608                 ndr->depth--;
8609         }
8610         ndr->depth--;
8611 }
8612
8613 _PUBLIC_ enum ndr_err_code ndr_push_samr_OpenUser(struct ndr_push *ndr, int flags, const struct samr_OpenUser *r)
8614 {
8615         if (flags & NDR_IN) {
8616                 if (r->in.domain_handle == NULL) {
8617                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8618                 }
8619                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
8620                 NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
8621                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
8622         }
8623         if (flags & NDR_OUT) {
8624                 if (r->out.user_handle == NULL) {
8625                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8626                 }
8627                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
8628                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8629         }
8630         return NDR_ERR_SUCCESS;
8631 }
8632
8633 _PUBLIC_ enum ndr_err_code ndr_pull_samr_OpenUser(struct ndr_pull *ndr, int flags, struct samr_OpenUser *r)
8634 {
8635         TALLOC_CTX *_mem_save_domain_handle_0;
8636         TALLOC_CTX *_mem_save_user_handle_0;
8637         if (flags & NDR_IN) {
8638                 ZERO_STRUCT(r->out);
8639
8640                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8641                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
8642                 }
8643                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8644                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
8645                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
8646                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
8647                 NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
8648                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
8649                 NDR_PULL_ALLOC(ndr, r->out.user_handle);
8650                 ZERO_STRUCTP(r->out.user_handle);
8651         }
8652         if (flags & NDR_OUT) {
8653                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8654                         NDR_PULL_ALLOC(ndr, r->out.user_handle);
8655                 }
8656                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8657                 NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
8658                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
8659                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
8660                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8661         }
8662         return NDR_ERR_SUCCESS;
8663 }
8664
8665 _PUBLIC_ void ndr_print_samr_OpenUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenUser *r)
8666 {
8667         ndr_print_struct(ndr, name, "samr_OpenUser");
8668         ndr->depth++;
8669         if (flags & NDR_SET_VALUES) {
8670                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8671         }
8672         if (flags & NDR_IN) {
8673                 ndr_print_struct(ndr, "in", "samr_OpenUser");
8674                 ndr->depth++;
8675                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
8676                 ndr->depth++;
8677                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
8678                 ndr->depth--;
8679                 ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);
8680                 ndr_print_uint32(ndr, "rid", r->in.rid);
8681                 ndr->depth--;
8682         }
8683         if (flags & NDR_OUT) {
8684                 ndr_print_struct(ndr, "out", "samr_OpenUser");
8685                 ndr->depth++;
8686                 ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
8687                 ndr->depth++;
8688                 ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
8689                 ndr->depth--;
8690                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8691                 ndr->depth--;
8692         }
8693         ndr->depth--;
8694 }
8695
8696 static enum ndr_err_code ndr_push_samr_DeleteUser(struct ndr_push *ndr, int flags, const struct samr_DeleteUser *r)
8697 {
8698         if (flags & NDR_IN) {
8699                 if (r->in.user_handle == NULL) {
8700                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8701                 }
8702                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
8703         }
8704         if (flags & NDR_OUT) {
8705                 if (r->out.user_handle == NULL) {
8706                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8707                 }
8708                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
8709                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8710         }
8711         return NDR_ERR_SUCCESS;
8712 }
8713
8714 static enum ndr_err_code ndr_pull_samr_DeleteUser(struct ndr_pull *ndr, int flags, struct samr_DeleteUser *r)
8715 {
8716         TALLOC_CTX *_mem_save_user_handle_0;
8717         if (flags & NDR_IN) {
8718                 ZERO_STRUCT(r->out);
8719
8720                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8721                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
8722                 }
8723                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8724                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
8725                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
8726                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
8727                 NDR_PULL_ALLOC(ndr, r->out.user_handle);
8728                 *r->out.user_handle = *r->in.user_handle;
8729         }
8730         if (flags & NDR_OUT) {
8731                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8732                         NDR_PULL_ALLOC(ndr, r->out.user_handle);
8733                 }
8734                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8735                 NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
8736                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
8737                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
8738                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8739         }
8740         return NDR_ERR_SUCCESS;
8741 }
8742
8743 _PUBLIC_ void ndr_print_samr_DeleteUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteUser *r)
8744 {
8745         ndr_print_struct(ndr, name, "samr_DeleteUser");
8746         ndr->depth++;
8747         if (flags & NDR_SET_VALUES) {
8748                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8749         }
8750         if (flags & NDR_IN) {
8751                 ndr_print_struct(ndr, "in", "samr_DeleteUser");
8752                 ndr->depth++;
8753                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
8754                 ndr->depth++;
8755                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
8756                 ndr->depth--;
8757                 ndr->depth--;
8758         }
8759         if (flags & NDR_OUT) {
8760                 ndr_print_struct(ndr, "out", "samr_DeleteUser");
8761                 ndr->depth++;
8762                 ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
8763                 ndr->depth++;
8764                 ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
8765                 ndr->depth--;
8766                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8767                 ndr->depth--;
8768         }
8769         ndr->depth--;
8770 }
8771
8772 _PUBLIC_ enum ndr_err_code ndr_push_samr_QueryUserInfo(struct ndr_push *ndr, int flags, const struct samr_QueryUserInfo *r)
8773 {
8774         if (flags & NDR_IN) {
8775                 if (r->in.user_handle == NULL) {
8776                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8777                 }
8778                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
8779                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
8780         }
8781         if (flags & NDR_OUT) {
8782                 if (r->out.info == NULL) {
8783                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8784                 }
8785                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
8786                 if (*r->out.info) {
8787                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
8788                         NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8789                 }
8790                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8791         }
8792         return NDR_ERR_SUCCESS;
8793 }
8794
8795 _PUBLIC_ enum ndr_err_code ndr_pull_samr_QueryUserInfo(struct ndr_pull *ndr, int flags, struct samr_QueryUserInfo *r)
8796 {
8797         uint32_t _ptr_info;
8798         TALLOC_CTX *_mem_save_user_handle_0;
8799         TALLOC_CTX *_mem_save_info_0;
8800         TALLOC_CTX *_mem_save_info_1;
8801         if (flags & NDR_IN) {
8802                 ZERO_STRUCT(r->out);
8803
8804                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8805                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
8806                 }
8807                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8808                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
8809                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
8810                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
8811                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
8812                 NDR_PULL_ALLOC(ndr, r->out.info);
8813                 ZERO_STRUCTP(r->out.info);
8814         }
8815         if (flags & NDR_OUT) {
8816                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8817                         NDR_PULL_ALLOC(ndr, r->out.info);
8818                 }
8819                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8820                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
8821                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8822                 if (_ptr_info) {
8823                         NDR_PULL_ALLOC(ndr, *r->out.info);
8824                 } else {
8825                         *r->out.info = NULL;
8826                 }
8827                 if (*r->out.info) {
8828                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
8829                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
8830                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
8831                         NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8832                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
8833                 }
8834                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
8835                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8836         }
8837         return NDR_ERR_SUCCESS;
8838 }
8839
8840 _PUBLIC_ void ndr_print_samr_QueryUserInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryUserInfo *r)
8841 {
8842         ndr_print_struct(ndr, name, "samr_QueryUserInfo");
8843         ndr->depth++;
8844         if (flags & NDR_SET_VALUES) {
8845                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8846         }
8847         if (flags & NDR_IN) {
8848                 ndr_print_struct(ndr, "in", "samr_QueryUserInfo");
8849                 ndr->depth++;
8850                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
8851                 ndr->depth++;
8852                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
8853                 ndr->depth--;
8854                 ndr_print_uint16(ndr, "level", r->in.level);
8855                 ndr->depth--;
8856         }
8857         if (flags & NDR_OUT) {
8858                 ndr_print_struct(ndr, "out", "samr_QueryUserInfo");
8859                 ndr->depth++;
8860                 ndr_print_ptr(ndr, "info", r->out.info);
8861                 ndr->depth++;
8862                 ndr_print_ptr(ndr, "info", *r->out.info);
8863                 ndr->depth++;
8864                 if (*r->out.info) {
8865                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
8866                         ndr_print_samr_UserInfo(ndr, "info", *r->out.info);
8867                 }
8868                 ndr->depth--;
8869                 ndr->depth--;
8870                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8871                 ndr->depth--;
8872         }
8873         ndr->depth--;
8874 }
8875
8876 _PUBLIC_ enum ndr_err_code ndr_push_samr_SetUserInfo(struct ndr_push *ndr, int flags, const struct samr_SetUserInfo *r)
8877 {
8878         if (flags & NDR_IN) {
8879                 if (r->in.user_handle == NULL) {
8880                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8881                 }
8882                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
8883                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
8884                 if (r->in.info == NULL) {
8885                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8886                 }
8887                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
8888                 NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8889         }
8890         if (flags & NDR_OUT) {
8891                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8892         }
8893         return NDR_ERR_SUCCESS;
8894 }
8895
8896 _PUBLIC_ enum ndr_err_code ndr_pull_samr_SetUserInfo(struct ndr_pull *ndr, int flags, struct samr_SetUserInfo *r)
8897 {
8898         TALLOC_CTX *_mem_save_user_handle_0;
8899         TALLOC_CTX *_mem_save_info_0;
8900         if (flags & NDR_IN) {
8901                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8902                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
8903                 }
8904                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8905                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
8906                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
8907                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
8908                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
8909                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8910                         NDR_PULL_ALLOC(ndr, r->in.info);
8911                 }
8912                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8913                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
8914                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
8915                 NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8916                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
8917         }
8918         if (flags & NDR_OUT) {
8919                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8920         }
8921         return NDR_ERR_SUCCESS;
8922 }
8923
8924 _PUBLIC_ void ndr_print_samr_SetUserInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetUserInfo *r)
8925 {
8926         ndr_print_struct(ndr, name, "samr_SetUserInfo");
8927         ndr->depth++;
8928         if (flags & NDR_SET_VALUES) {
8929                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8930         }
8931         if (flags & NDR_IN) {
8932                 ndr_print_struct(ndr, "in", "samr_SetUserInfo");
8933                 ndr->depth++;
8934                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
8935                 ndr->depth++;
8936                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
8937                 ndr->depth--;
8938                 ndr_print_uint16(ndr, "level", r->in.level);
8939                 ndr_print_ptr(ndr, "info", r->in.info);
8940                 ndr->depth++;
8941                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
8942                 ndr_print_samr_UserInfo(ndr, "info", r->in.info);
8943                 ndr->depth--;
8944                 ndr->depth--;
8945         }
8946         if (flags & NDR_OUT) {
8947                 ndr_print_struct(ndr, "out", "samr_SetUserInfo");
8948                 ndr->depth++;
8949                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8950                 ndr->depth--;
8951         }
8952         ndr->depth--;
8953 }
8954
8955 static enum ndr_err_code ndr_push_samr_ChangePasswordUser(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser *r)
8956 {
8957         if (flags & NDR_IN) {
8958                 if (r->in.user_handle == NULL) {
8959                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8960                 }
8961                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
8962                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_present));
8963                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_lm_crypted));
8964                 if (r->in.old_lm_crypted) {
8965                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.old_lm_crypted));
8966                 }
8967                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_lm_crypted));
8968                 if (r->in.new_lm_crypted) {
8969                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.new_lm_crypted));
8970                 }
8971                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.nt_present));
8972                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_nt_crypted));
8973                 if (r->in.old_nt_crypted) {
8974                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.old_nt_crypted));
8975                 }
8976                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_nt_crypted));
8977                 if (r->in.new_nt_crypted) {
8978                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.new_nt_crypted));
8979                 }
8980                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.cross1_present));
8981                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_cross));
8982                 if (r->in.nt_cross) {
8983                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_cross));
8984                 }
8985                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.cross2_present));
8986                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_cross));
8987                 if (r->in.lm_cross) {
8988                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_cross));
8989                 }
8990         }
8991         if (flags & NDR_OUT) {
8992                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8993         }
8994         return NDR_ERR_SUCCESS;
8995 }
8996
8997 static enum ndr_err_code ndr_pull_samr_ChangePasswordUser(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser *r)
8998 {
8999         uint32_t _ptr_old_lm_crypted;
9000         uint32_t _ptr_new_lm_crypted;
9001         uint32_t _ptr_old_nt_crypted;
9002         uint32_t _ptr_new_nt_crypted;
9003         uint32_t _ptr_nt_cross;
9004         uint32_t _ptr_lm_cross;
9005         TALLOC_CTX *_mem_save_user_handle_0;
9006         TALLOC_CTX *_mem_save_old_lm_crypted_0;
9007         TALLOC_CTX *_mem_save_new_lm_crypted_0;
9008         TALLOC_CTX *_mem_save_old_nt_crypted_0;
9009         TALLOC_CTX *_mem_save_new_nt_crypted_0;
9010         TALLOC_CTX *_mem_save_nt_cross_0;
9011         TALLOC_CTX *_mem_save_lm_cross_0;
9012         if (flags & NDR_IN) {
9013                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9014                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9015                 }
9016                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9017                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9018                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9019                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9020                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_present));
9021                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_lm_crypted));
9022                 if (_ptr_old_lm_crypted) {
9023                         NDR_PULL_ALLOC(ndr, r->in.old_lm_crypted);
9024                 } else {
9025                         r->in.old_lm_crypted = NULL;
9026                 }
9027                 if (r->in.old_lm_crypted) {
9028                         _mem_save_old_lm_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
9029                         NDR_PULL_SET_MEM_CTX(ndr, r->in.old_lm_crypted, 0);
9030                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.old_lm_crypted));
9031                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_lm_crypted_0, 0);
9032                 }
9033                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_lm_crypted));
9034                 if (_ptr_new_lm_crypted) {
9035                         NDR_PULL_ALLOC(ndr, r->in.new_lm_crypted);
9036                 } else {
9037                         r->in.new_lm_crypted = NULL;
9038                 }
9039                 if (r->in.new_lm_crypted) {
9040                         _mem_save_new_lm_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
9041                         NDR_PULL_SET_MEM_CTX(ndr, r->in.new_lm_crypted, 0);
9042                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.new_lm_crypted));
9043                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_lm_crypted_0, 0);
9044                 }
9045                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.nt_present));
9046                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_nt_crypted));
9047                 if (_ptr_old_nt_crypted) {
9048                         NDR_PULL_ALLOC(ndr, r->in.old_nt_crypted);
9049                 } else {
9050                         r->in.old_nt_crypted = NULL;
9051                 }
9052                 if (r->in.old_nt_crypted) {
9053                         _mem_save_old_nt_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
9054                         NDR_PULL_SET_MEM_CTX(ndr, r->in.old_nt_crypted, 0);
9055                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.old_nt_crypted));
9056                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_nt_crypted_0, 0);
9057                 }
9058                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_nt_crypted));
9059                 if (_ptr_new_nt_crypted) {
9060                         NDR_PULL_ALLOC(ndr, r->in.new_nt_crypted);
9061                 } else {
9062                         r->in.new_nt_crypted = NULL;
9063                 }
9064                 if (r->in.new_nt_crypted) {
9065                         _mem_save_new_nt_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
9066                         NDR_PULL_SET_MEM_CTX(ndr, r->in.new_nt_crypted, 0);
9067                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.new_nt_crypted));
9068                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_nt_crypted_0, 0);
9069                 }
9070                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.cross1_present));
9071                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_cross));
9072                 if (_ptr_nt_cross) {
9073                         NDR_PULL_ALLOC(ndr, r->in.nt_cross);
9074                 } else {
9075                         r->in.nt_cross = NULL;
9076                 }
9077                 if (r->in.nt_cross) {
9078                         _mem_save_nt_cross_0 = NDR_PULL_GET_MEM_CTX(ndr);
9079                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_cross, 0);
9080                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_cross));
9081                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_cross_0, 0);
9082                 }
9083                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.cross2_present));
9084                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_cross));
9085                 if (_ptr_lm_cross) {
9086                         NDR_PULL_ALLOC(ndr, r->in.lm_cross);
9087                 } else {
9088                         r->in.lm_cross = NULL;
9089                 }
9090                 if (r->in.lm_cross) {
9091                         _mem_save_lm_cross_0 = NDR_PULL_GET_MEM_CTX(ndr);
9092                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_cross, 0);
9093                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_cross));
9094                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_cross_0, 0);
9095                 }
9096         }
9097         if (flags & NDR_OUT) {
9098                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9099         }
9100         return NDR_ERR_SUCCESS;
9101 }
9102
9103 _PUBLIC_ void ndr_print_samr_ChangePasswordUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser *r)
9104 {
9105         ndr_print_struct(ndr, name, "samr_ChangePasswordUser");
9106         ndr->depth++;
9107         if (flags & NDR_SET_VALUES) {
9108                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9109         }
9110         if (flags & NDR_IN) {
9111                 ndr_print_struct(ndr, "in", "samr_ChangePasswordUser");
9112                 ndr->depth++;
9113                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9114                 ndr->depth++;
9115                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9116                 ndr->depth--;
9117                 ndr_print_uint8(ndr, "lm_present", r->in.lm_present);
9118                 ndr_print_ptr(ndr, "old_lm_crypted", r->in.old_lm_crypted);
9119                 ndr->depth++;
9120                 if (r->in.old_lm_crypted) {
9121                         ndr_print_samr_Password(ndr, "old_lm_crypted", r->in.old_lm_crypted);
9122                 }
9123                 ndr->depth--;
9124                 ndr_print_ptr(ndr, "new_lm_crypted", r->in.new_lm_crypted);
9125                 ndr->depth++;
9126                 if (r->in.new_lm_crypted) {
9127                         ndr_print_samr_Password(ndr, "new_lm_crypted", r->in.new_lm_crypted);
9128                 }
9129                 ndr->depth--;
9130                 ndr_print_uint8(ndr, "nt_present", r->in.nt_present);
9131                 ndr_print_ptr(ndr, "old_nt_crypted", r->in.old_nt_crypted);
9132                 ndr->depth++;
9133                 if (r->in.old_nt_crypted) {
9134                         ndr_print_samr_Password(ndr, "old_nt_crypted", r->in.old_nt_crypted);
9135                 }
9136                 ndr->depth--;
9137                 ndr_print_ptr(ndr, "new_nt_crypted", r->in.new_nt_crypted);
9138                 ndr->depth++;
9139                 if (r->in.new_nt_crypted) {
9140                         ndr_print_samr_Password(ndr, "new_nt_crypted", r->in.new_nt_crypted);
9141                 }
9142                 ndr->depth--;
9143                 ndr_print_uint8(ndr, "cross1_present", r->in.cross1_present);
9144                 ndr_print_ptr(ndr, "nt_cross", r->in.nt_cross);
9145                 ndr->depth++;
9146                 if (r->in.nt_cross) {
9147                         ndr_print_samr_Password(ndr, "nt_cross", r->in.nt_cross);
9148                 }
9149                 ndr->depth--;
9150                 ndr_print_uint8(ndr, "cross2_present", r->in.cross2_present);
9151                 ndr_print_ptr(ndr, "lm_cross", r->in.lm_cross);
9152                 ndr->depth++;
9153                 if (r->in.lm_cross) {
9154                         ndr_print_samr_Password(ndr, "lm_cross", r->in.lm_cross);
9155                 }
9156                 ndr->depth--;
9157                 ndr->depth--;
9158         }
9159         if (flags & NDR_OUT) {
9160                 ndr_print_struct(ndr, "out", "samr_ChangePasswordUser");
9161                 ndr->depth++;
9162                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9163                 ndr->depth--;
9164         }
9165         ndr->depth--;
9166 }
9167
9168 static enum ndr_err_code ndr_push_samr_GetGroupsForUser(struct ndr_push *ndr, int flags, const struct samr_GetGroupsForUser *r)
9169 {
9170         if (flags & NDR_IN) {
9171                 if (r->in.user_handle == NULL) {
9172                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9173                 }
9174                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9175         }
9176         if (flags & NDR_OUT) {
9177                 if (r->out.rids == NULL) {
9178                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9179                 }
9180                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rids));
9181                 if (*r->out.rids) {
9182                         NDR_CHECK(ndr_push_samr_RidWithAttributeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
9183                 }
9184                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9185         }
9186         return NDR_ERR_SUCCESS;
9187 }
9188
9189 static enum ndr_err_code ndr_pull_samr_GetGroupsForUser(struct ndr_pull *ndr, int flags, struct samr_GetGroupsForUser *r)
9190 {
9191         uint32_t _ptr_rids;
9192         TALLOC_CTX *_mem_save_user_handle_0;
9193         TALLOC_CTX *_mem_save_rids_0;
9194         TALLOC_CTX *_mem_save_rids_1;
9195         if (flags & NDR_IN) {
9196                 ZERO_STRUCT(r->out);
9197
9198                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9199                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9200                 }
9201                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9202                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9203                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9204                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9205                 NDR_PULL_ALLOC(ndr, r->out.rids);
9206                 ZERO_STRUCTP(r->out.rids);
9207         }
9208         if (flags & NDR_OUT) {
9209                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9210                         NDR_PULL_ALLOC(ndr, r->out.rids);
9211                 }
9212                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
9213                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
9214                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
9215                 if (_ptr_rids) {
9216                         NDR_PULL_ALLOC(ndr, *r->out.rids);
9217                 } else {
9218                         *r->out.rids = NULL;
9219                 }
9220                 if (*r->out.rids) {
9221                         _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
9222                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.rids, 0);
9223                         NDR_CHECK(ndr_pull_samr_RidWithAttributeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
9224                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
9225                 }
9226                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
9227                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9228         }
9229         return NDR_ERR_SUCCESS;
9230 }
9231
9232 _PUBLIC_ void ndr_print_samr_GetGroupsForUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetGroupsForUser *r)
9233 {
9234         ndr_print_struct(ndr, name, "samr_GetGroupsForUser");
9235         ndr->depth++;
9236         if (flags & NDR_SET_VALUES) {
9237                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9238         }
9239         if (flags & NDR_IN) {
9240                 ndr_print_struct(ndr, "in", "samr_GetGroupsForUser");
9241                 ndr->depth++;
9242                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9243                 ndr->depth++;
9244                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9245                 ndr->depth--;
9246                 ndr->depth--;
9247         }
9248         if (flags & NDR_OUT) {
9249                 ndr_print_struct(ndr, "out", "samr_GetGroupsForUser");
9250                 ndr->depth++;
9251                 ndr_print_ptr(ndr, "rids", r->out.rids);
9252                 ndr->depth++;
9253                 ndr_print_ptr(ndr, "rids", *r->out.rids);
9254                 ndr->depth++;
9255                 if (*r->out.rids) {
9256                         ndr_print_samr_RidWithAttributeArray(ndr, "rids", *r->out.rids);
9257                 }
9258                 ndr->depth--;
9259                 ndr->depth--;
9260                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9261                 ndr->depth--;
9262         }
9263         ndr->depth--;
9264 }
9265
9266 static enum ndr_err_code ndr_push_samr_QueryDisplayInfo(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo *r)
9267 {
9268         if (flags & NDR_IN) {
9269                 if (r->in.domain_handle == NULL) {
9270                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9271                 }
9272                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9273                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9274                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));
9275                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));
9276                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
9277         }
9278         if (flags & NDR_OUT) {
9279                 if (r->out.total_size == NULL) {
9280                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9281                 }
9282                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));
9283                 if (r->out.returned_size == NULL) {
9284                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9285                 }
9286                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));
9287                 if (r->out.info == NULL) {
9288                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9289                 }
9290                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
9291                 NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
9292                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9293         }
9294         return NDR_ERR_SUCCESS;
9295 }
9296
9297 static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo *r)
9298 {
9299         TALLOC_CTX *_mem_save_domain_handle_0;
9300         TALLOC_CTX *_mem_save_total_size_0;
9301         TALLOC_CTX *_mem_save_returned_size_0;
9302         TALLOC_CTX *_mem_save_info_0;
9303         if (flags & NDR_IN) {
9304                 ZERO_STRUCT(r->out);
9305
9306                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9307                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
9308                 }
9309                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9310                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
9311                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9312                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
9313                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
9314                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));
9315                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));
9316                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
9317                 NDR_PULL_ALLOC(ndr, r->out.total_size);
9318                 ZERO_STRUCTP(r->out.total_size);
9319                 NDR_PULL_ALLOC(ndr, r->out.returned_size);
9320                 ZERO_STRUCTP(r->out.returned_size);
9321                 NDR_PULL_ALLOC(ndr, r->out.info);
9322                 ZERO_STRUCTP(r->out.info);
9323         }
9324         if (flags & NDR_OUT) {
9325                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9326                         NDR_PULL_ALLOC(ndr, r->out.total_size);
9327                 }
9328                 _mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
9329                 NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);
9330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));
9331                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);
9332                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9333                         NDR_PULL_ALLOC(ndr, r->out.returned_size);
9334                 }
9335                 _mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
9336                 NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);
9337                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));
9338                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);
9339                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9340                         NDR_PULL_ALLOC(ndr, r->out.info);
9341                 }
9342                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9343                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9344                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
9345                 NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
9346                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9347                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9348         }
9349         return NDR_ERR_SUCCESS;
9350 }
9351
9352 _PUBLIC_ void ndr_print_samr_QueryDisplayInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo *r)
9353 {
9354         ndr_print_struct(ndr, name, "samr_QueryDisplayInfo");
9355         ndr->depth++;
9356         if (flags & NDR_SET_VALUES) {
9357                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9358         }
9359         if (flags & NDR_IN) {
9360                 ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo");
9361                 ndr->depth++;
9362                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
9363                 ndr->depth++;
9364                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
9365                 ndr->depth--;
9366                 ndr_print_uint16(ndr, "level", r->in.level);
9367                 ndr_print_uint32(ndr, "start_idx", r->in.start_idx);
9368                 ndr_print_uint32(ndr, "max_entries", r->in.max_entries);
9369                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
9370                 ndr->depth--;
9371         }
9372         if (flags & NDR_OUT) {
9373                 ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo");
9374                 ndr->depth++;
9375                 ndr_print_ptr(ndr, "total_size", r->out.total_size);
9376                 ndr->depth++;
9377                 ndr_print_uint32(ndr, "total_size", *r->out.total_size);
9378                 ndr->depth--;
9379                 ndr_print_ptr(ndr, "returned_size", r->out.returned_size);
9380                 ndr->depth++;
9381                 ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);
9382                 ndr->depth--;
9383                 ndr_print_ptr(ndr, "info", r->out.info);
9384                 ndr->depth++;
9385                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
9386                 ndr_print_samr_DispInfo(ndr, "info", r->out.info);
9387                 ndr->depth--;
9388                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9389                 ndr->depth--;
9390         }
9391         ndr->depth--;
9392 }
9393
9394 static enum ndr_err_code ndr_push_samr_GetDisplayEnumerationIndex(struct ndr_push *ndr, int flags, const struct samr_GetDisplayEnumerationIndex *r)
9395 {
9396         if (flags & NDR_IN) {
9397                 if (r->in.domain_handle == NULL) {
9398                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9399                 }
9400                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9401                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9402                 if (r->in.name == NULL) {
9403                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9404                 }
9405                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
9406         }
9407         if (flags & NDR_OUT) {
9408                 if (r->out.idx == NULL) {
9409                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9410                 }
9411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.idx));
9412                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9413         }
9414         return NDR_ERR_SUCCESS;
9415 }
9416
9417 static enum ndr_err_code ndr_pull_samr_GetDisplayEnumerationIndex(struct ndr_pull *ndr, int flags, struct samr_GetDisplayEnumerationIndex *r)
9418 {
9419         TALLOC_CTX *_mem_save_domain_handle_0;
9420         TALLOC_CTX *_mem_save_name_0;
9421         TALLOC_CTX *_mem_save_idx_0;
9422         if (flags & NDR_IN) {
9423                 ZERO_STRUCT(r->out);
9424
9425                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9426                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
9427                 }
9428                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9429                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
9430                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9431                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
9432                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
9433                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9434                         NDR_PULL_ALLOC(ndr, r->in.name);
9435                 }
9436                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9437                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
9438                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
9439                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
9440                 NDR_PULL_ALLOC(ndr, r->out.idx);
9441                 ZERO_STRUCTP(r->out.idx);
9442         }
9443         if (flags & NDR_OUT) {
9444                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9445                         NDR_PULL_ALLOC(ndr, r->out.idx);
9446                 }
9447                 _mem_save_idx_0 = NDR_PULL_GET_MEM_CTX(ndr);
9448                 NDR_PULL_SET_MEM_CTX(ndr, r->out.idx, LIBNDR_FLAG_REF_ALLOC);
9449                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.idx));
9450                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_idx_0, LIBNDR_FLAG_REF_ALLOC);
9451                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9452         }
9453         return NDR_ERR_SUCCESS;
9454 }
9455
9456 _PUBLIC_ void ndr_print_samr_GetDisplayEnumerationIndex(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDisplayEnumerationIndex *r)
9457 {
9458         ndr_print_struct(ndr, name, "samr_GetDisplayEnumerationIndex");
9459         ndr->depth++;
9460         if (flags & NDR_SET_VALUES) {
9461                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9462         }
9463         if (flags & NDR_IN) {
9464                 ndr_print_struct(ndr, "in", "samr_GetDisplayEnumerationIndex");
9465                 ndr->depth++;
9466                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
9467                 ndr->depth++;
9468                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
9469                 ndr->depth--;
9470                 ndr_print_uint16(ndr, "level", r->in.level);
9471                 ndr_print_ptr(ndr, "name", r->in.name);
9472                 ndr->depth++;
9473                 ndr_print_lsa_String(ndr, "name", r->in.name);
9474                 ndr->depth--;
9475                 ndr->depth--;
9476         }
9477         if (flags & NDR_OUT) {
9478                 ndr_print_struct(ndr, "out", "samr_GetDisplayEnumerationIndex");
9479                 ndr->depth++;
9480                 ndr_print_ptr(ndr, "idx", r->out.idx);
9481                 ndr->depth++;
9482                 ndr_print_uint32(ndr, "idx", *r->out.idx);
9483                 ndr->depth--;
9484                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9485                 ndr->depth--;
9486         }
9487         ndr->depth--;
9488 }
9489
9490 static enum ndr_err_code ndr_push_samr_TestPrivateFunctionsDomain(struct ndr_push *ndr, int flags, const struct samr_TestPrivateFunctionsDomain *r)
9491 {
9492         if (flags & NDR_IN) {
9493                 if (r->in.domain_handle == NULL) {
9494                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9495                 }
9496                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9497         }
9498         if (flags & NDR_OUT) {
9499                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9500         }
9501         return NDR_ERR_SUCCESS;
9502 }
9503
9504 static enum ndr_err_code ndr_pull_samr_TestPrivateFunctionsDomain(struct ndr_pull *ndr, int flags, struct samr_TestPrivateFunctionsDomain *r)
9505 {
9506         TALLOC_CTX *_mem_save_domain_handle_0;
9507         if (flags & NDR_IN) {
9508                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9509                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
9510                 }
9511                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9512                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
9513                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9514                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
9515         }
9516         if (flags & NDR_OUT) {
9517                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9518         }
9519         return NDR_ERR_SUCCESS;
9520 }
9521
9522 _PUBLIC_ void ndr_print_samr_TestPrivateFunctionsDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_TestPrivateFunctionsDomain *r)
9523 {
9524         ndr_print_struct(ndr, name, "samr_TestPrivateFunctionsDomain");
9525         ndr->depth++;
9526         if (flags & NDR_SET_VALUES) {
9527                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9528         }
9529         if (flags & NDR_IN) {
9530                 ndr_print_struct(ndr, "in", "samr_TestPrivateFunctionsDomain");
9531                 ndr->depth++;
9532                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
9533                 ndr->depth++;
9534                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
9535                 ndr->depth--;
9536                 ndr->depth--;
9537         }
9538         if (flags & NDR_OUT) {
9539                 ndr_print_struct(ndr, "out", "samr_TestPrivateFunctionsDomain");
9540                 ndr->depth++;
9541                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9542                 ndr->depth--;
9543         }
9544         ndr->depth--;
9545 }
9546
9547 static enum ndr_err_code ndr_push_samr_TestPrivateFunctionsUser(struct ndr_push *ndr, int flags, const struct samr_TestPrivateFunctionsUser *r)
9548 {
9549         if (flags & NDR_IN) {
9550                 if (r->in.user_handle == NULL) {
9551                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9552                 }
9553                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9554         }
9555         if (flags & NDR_OUT) {
9556                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9557         }
9558         return NDR_ERR_SUCCESS;
9559 }
9560
9561 static enum ndr_err_code ndr_pull_samr_TestPrivateFunctionsUser(struct ndr_pull *ndr, int flags, struct samr_TestPrivateFunctionsUser *r)
9562 {
9563         TALLOC_CTX *_mem_save_user_handle_0;
9564         if (flags & NDR_IN) {
9565                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9566                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9567                 }
9568                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9569                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9570                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9571                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9572         }
9573         if (flags & NDR_OUT) {
9574                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9575         }
9576         return NDR_ERR_SUCCESS;
9577 }
9578
9579 _PUBLIC_ void ndr_print_samr_TestPrivateFunctionsUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_TestPrivateFunctionsUser *r)
9580 {
9581         ndr_print_struct(ndr, name, "samr_TestPrivateFunctionsUser");
9582         ndr->depth++;
9583         if (flags & NDR_SET_VALUES) {
9584                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9585         }
9586         if (flags & NDR_IN) {
9587                 ndr_print_struct(ndr, "in", "samr_TestPrivateFunctionsUser");
9588                 ndr->depth++;
9589                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9590                 ndr->depth++;
9591                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9592                 ndr->depth--;
9593                 ndr->depth--;
9594         }
9595         if (flags & NDR_OUT) {
9596                 ndr_print_struct(ndr, "out", "samr_TestPrivateFunctionsUser");
9597                 ndr->depth++;
9598                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9599                 ndr->depth--;
9600         }
9601         ndr->depth--;
9602 }
9603
9604 _PUBLIC_ enum ndr_err_code ndr_push_samr_GetUserPwInfo(struct ndr_push *ndr, int flags, const struct samr_GetUserPwInfo *r)
9605 {
9606         if (flags & NDR_IN) {
9607                 if (r->in.user_handle == NULL) {
9608                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9609                 }
9610                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9611         }
9612         if (flags & NDR_OUT) {
9613                 if (r->out.info == NULL) {
9614                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9615                 }
9616                 NDR_CHECK(ndr_push_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
9617                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9618         }
9619         return NDR_ERR_SUCCESS;
9620 }
9621
9622 _PUBLIC_ enum ndr_err_code ndr_pull_samr_GetUserPwInfo(struct ndr_pull *ndr, int flags, struct samr_GetUserPwInfo *r)
9623 {
9624         TALLOC_CTX *_mem_save_user_handle_0;
9625         TALLOC_CTX *_mem_save_info_0;
9626         if (flags & NDR_IN) {
9627                 ZERO_STRUCT(r->out);
9628
9629                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9630                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9631                 }
9632                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9633                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9634                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9635                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9636                 NDR_PULL_ALLOC(ndr, r->out.info);
9637                 ZERO_STRUCTP(r->out.info);
9638         }
9639         if (flags & NDR_OUT) {
9640                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9641                         NDR_PULL_ALLOC(ndr, r->out.info);
9642                 }
9643                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9644                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9645                 NDR_CHECK(ndr_pull_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
9646                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9647                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9648         }
9649         return NDR_ERR_SUCCESS;
9650 }
9651
9652 _PUBLIC_ void ndr_print_samr_GetUserPwInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetUserPwInfo *r)
9653 {
9654         ndr_print_struct(ndr, name, "samr_GetUserPwInfo");
9655         ndr->depth++;
9656         if (flags & NDR_SET_VALUES) {
9657                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9658         }
9659         if (flags & NDR_IN) {
9660                 ndr_print_struct(ndr, "in", "samr_GetUserPwInfo");
9661                 ndr->depth++;
9662                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9663                 ndr->depth++;
9664                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9665                 ndr->depth--;
9666                 ndr->depth--;
9667         }
9668         if (flags & NDR_OUT) {
9669                 ndr_print_struct(ndr, "out", "samr_GetUserPwInfo");
9670                 ndr->depth++;
9671                 ndr_print_ptr(ndr, "info", r->out.info);
9672                 ndr->depth++;
9673                 ndr_print_samr_PwInfo(ndr, "info", r->out.info);
9674                 ndr->depth--;
9675                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9676                 ndr->depth--;
9677         }
9678         ndr->depth--;
9679 }
9680
9681 static enum ndr_err_code ndr_push_samr_RemoveMemberFromForeignDomain(struct ndr_push *ndr, int flags, const struct samr_RemoveMemberFromForeignDomain *r)
9682 {
9683         if (flags & NDR_IN) {
9684                 if (r->in.domain_handle == NULL) {
9685                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9686                 }
9687                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9688                 if (r->in.sid == NULL) {
9689                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9690                 }
9691                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
9692         }
9693         if (flags & NDR_OUT) {
9694                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9695         }
9696         return NDR_ERR_SUCCESS;
9697 }
9698
9699 static enum ndr_err_code ndr_pull_samr_RemoveMemberFromForeignDomain(struct ndr_pull *ndr, int flags, struct samr_RemoveMemberFromForeignDomain *r)
9700 {
9701         TALLOC_CTX *_mem_save_domain_handle_0;
9702         TALLOC_CTX *_mem_save_sid_0;
9703         if (flags & NDR_IN) {
9704                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9705                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
9706                 }
9707                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9708                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
9709                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9710                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
9711                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9712                         NDR_PULL_ALLOC(ndr, r->in.sid);
9713                 }
9714                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
9715                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
9716                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
9717                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
9718         }
9719         if (flags & NDR_OUT) {
9720                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9721         }
9722         return NDR_ERR_SUCCESS;
9723 }
9724
9725 _PUBLIC_ void ndr_print_samr_RemoveMemberFromForeignDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_RemoveMemberFromForeignDomain *r)
9726 {
9727         ndr_print_struct(ndr, name, "samr_RemoveMemberFromForeignDomain");
9728         ndr->depth++;
9729         if (flags & NDR_SET_VALUES) {
9730                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9731         }
9732         if (flags & NDR_IN) {
9733                 ndr_print_struct(ndr, "in", "samr_RemoveMemberFromForeignDomain");
9734                 ndr->depth++;
9735                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
9736                 ndr->depth++;
9737                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
9738                 ndr->depth--;
9739                 ndr_print_ptr(ndr, "sid", r->in.sid);
9740                 ndr->depth++;
9741                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
9742                 ndr->depth--;
9743                 ndr->depth--;
9744         }
9745         if (flags & NDR_OUT) {
9746                 ndr_print_struct(ndr, "out", "samr_RemoveMemberFromForeignDomain");
9747                 ndr->depth++;
9748                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9749                 ndr->depth--;
9750         }
9751         ndr->depth--;
9752 }
9753
9754 static enum ndr_err_code ndr_push_samr_QueryDomainInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryDomainInfo2 *r)
9755 {
9756         if (flags & NDR_IN) {
9757                 if (r->in.domain_handle == NULL) {
9758                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9759                 }
9760                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9761                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9762         }
9763         if (flags & NDR_OUT) {
9764                 if (r->out.info == NULL) {
9765                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9766                 }
9767                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
9768                 if (*r->out.info) {
9769                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
9770                         NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9771                 }
9772                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9773         }
9774         return NDR_ERR_SUCCESS;
9775 }
9776
9777 static enum ndr_err_code ndr_pull_samr_QueryDomainInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryDomainInfo2 *r)
9778 {
9779         uint32_t _ptr_info;
9780         TALLOC_CTX *_mem_save_domain_handle_0;
9781         TALLOC_CTX *_mem_save_info_0;
9782         TALLOC_CTX *_mem_save_info_1;
9783         if (flags & NDR_IN) {
9784                 ZERO_STRUCT(r->out);
9785
9786                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9787                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
9788                 }
9789                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9790                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
9791                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9792                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
9793                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
9794                 NDR_PULL_ALLOC(ndr, r->out.info);
9795                 ZERO_STRUCTP(r->out.info);
9796         }
9797         if (flags & NDR_OUT) {
9798                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9799                         NDR_PULL_ALLOC(ndr, r->out.info);
9800                 }
9801                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9802                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9803                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9804                 if (_ptr_info) {
9805                         NDR_PULL_ALLOC(ndr, *r->out.info);
9806                 } else {
9807                         *r->out.info = NULL;
9808                 }
9809                 if (*r->out.info) {
9810                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
9811                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
9812                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
9813                         NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9814                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
9815                 }
9816                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9817                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9818         }
9819         return NDR_ERR_SUCCESS;
9820 }
9821
9822 _PUBLIC_ void ndr_print_samr_QueryDomainInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDomainInfo2 *r)
9823 {
9824         ndr_print_struct(ndr, name, "samr_QueryDomainInfo2");
9825         ndr->depth++;
9826         if (flags & NDR_SET_VALUES) {
9827                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9828         }
9829         if (flags & NDR_IN) {
9830                 ndr_print_struct(ndr, "in", "samr_QueryDomainInfo2");
9831                 ndr->depth++;
9832                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
9833                 ndr->depth++;
9834                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
9835                 ndr->depth--;
9836                 ndr_print_uint16(ndr, "level", r->in.level);
9837                 ndr->depth--;
9838         }
9839         if (flags & NDR_OUT) {
9840                 ndr_print_struct(ndr, "out", "samr_QueryDomainInfo2");
9841                 ndr->depth++;
9842                 ndr_print_ptr(ndr, "info", r->out.info);
9843                 ndr->depth++;
9844                 ndr_print_ptr(ndr, "info", *r->out.info);
9845                 ndr->depth++;
9846                 if (*r->out.info) {
9847                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
9848                         ndr_print_samr_DomainInfo(ndr, "info", *r->out.info);
9849                 }
9850                 ndr->depth--;
9851                 ndr->depth--;
9852                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9853                 ndr->depth--;
9854         }
9855         ndr->depth--;
9856 }
9857
9858 static enum ndr_err_code ndr_push_samr_QueryUserInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryUserInfo2 *r)
9859 {
9860         if (flags & NDR_IN) {
9861                 if (r->in.user_handle == NULL) {
9862                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9863                 }
9864                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9865                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9866         }
9867         if (flags & NDR_OUT) {
9868                 if (r->out.info == NULL) {
9869                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9870                 }
9871                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
9872                 if (*r->out.info) {
9873                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
9874                         NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9875                 }
9876                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9877         }
9878         return NDR_ERR_SUCCESS;
9879 }
9880
9881 static enum ndr_err_code ndr_pull_samr_QueryUserInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryUserInfo2 *r)
9882 {
9883         uint32_t _ptr_info;
9884         TALLOC_CTX *_mem_save_user_handle_0;
9885         TALLOC_CTX *_mem_save_info_0;
9886         TALLOC_CTX *_mem_save_info_1;
9887         if (flags & NDR_IN) {
9888                 ZERO_STRUCT(r->out);
9889
9890                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9891                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9892                 }
9893                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9894                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9895                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9896                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9897                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
9898                 NDR_PULL_ALLOC(ndr, r->out.info);
9899                 ZERO_STRUCTP(r->out.info);
9900         }
9901         if (flags & NDR_OUT) {
9902                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9903                         NDR_PULL_ALLOC(ndr, r->out.info);
9904                 }
9905                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9906                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9907                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9908                 if (_ptr_info) {
9909                         NDR_PULL_ALLOC(ndr, *r->out.info);
9910                 } else {
9911                         *r->out.info = NULL;
9912                 }
9913                 if (*r->out.info) {
9914                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
9915                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
9916                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
9917                         NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9918                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
9919                 }
9920                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9921                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9922         }
9923         return NDR_ERR_SUCCESS;
9924 }
9925
9926 _PUBLIC_ void ndr_print_samr_QueryUserInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryUserInfo2 *r)
9927 {
9928         ndr_print_struct(ndr, name, "samr_QueryUserInfo2");
9929         ndr->depth++;
9930         if (flags & NDR_SET_VALUES) {
9931                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9932         }
9933         if (flags & NDR_IN) {
9934                 ndr_print_struct(ndr, "in", "samr_QueryUserInfo2");
9935                 ndr->depth++;
9936                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9937                 ndr->depth++;
9938                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9939                 ndr->depth--;
9940                 ndr_print_uint16(ndr, "level", r->in.level);
9941                 ndr->depth--;
9942         }
9943         if (flags & NDR_OUT) {
9944                 ndr_print_struct(ndr, "out", "samr_QueryUserInfo2");
9945                 ndr->depth++;
9946                 ndr_print_ptr(ndr, "info", r->out.info);
9947                 ndr->depth++;
9948                 ndr_print_ptr(ndr, "info", *r->out.info);
9949                 ndr->depth++;
9950                 if (*r->out.info) {
9951                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
9952                         ndr_print_samr_UserInfo(ndr, "info", *r->out.info);
9953                 }
9954                 ndr->depth--;
9955                 ndr->depth--;
9956                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9957                 ndr->depth--;
9958         }
9959         ndr->depth--;
9960 }
9961
9962 static enum ndr_err_code ndr_push_samr_QueryDisplayInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo2 *r)
9963 {
9964         if (flags & NDR_IN) {
9965                 if (r->in.domain_handle == NULL) {
9966                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9967                 }
9968                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9969                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9970                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));
9971                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));
9972                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
9973         }
9974         if (flags & NDR_OUT) {
9975                 if (r->out.total_size == NULL) {
9976                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9977                 }
9978                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));
9979                 if (r->out.returned_size == NULL) {
9980                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9981                 }
9982                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));
9983                 if (r->out.info == NULL) {
9984                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9985                 }
9986                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
9987                 NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
9988                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9989         }
9990         return NDR_ERR_SUCCESS;
9991 }
9992
9993 static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo2 *r)
9994 {
9995         TALLOC_CTX *_mem_save_domain_handle_0;
9996         TALLOC_CTX *_mem_save_total_size_0;
9997         TALLOC_CTX *_mem_save_returned_size_0;
9998         TALLOC_CTX *_mem_save_info_0;
9999         if (flags & NDR_IN) {
10000                 ZERO_STRUCT(r->out);
10001
10002                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10003                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10004                 }
10005                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10006                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10007                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10008                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10009                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10010                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));
10011                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));
10012                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
10013                 NDR_PULL_ALLOC(ndr, r->out.total_size);
10014                 ZERO_STRUCTP(r->out.total_size);
10015                 NDR_PULL_ALLOC(ndr, r->out.returned_size);
10016                 ZERO_STRUCTP(r->out.returned_size);
10017                 NDR_PULL_ALLOC(ndr, r->out.info);
10018                 ZERO_STRUCTP(r->out.info);
10019         }
10020         if (flags & NDR_OUT) {
10021                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10022                         NDR_PULL_ALLOC(ndr, r->out.total_size);
10023                 }
10024                 _mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
10025                 NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);
10026                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));
10027                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);
10028                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10029                         NDR_PULL_ALLOC(ndr, r->out.returned_size);
10030                 }
10031                 _mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
10032                 NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);
10033                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));
10034                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);
10035                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10036                         NDR_PULL_ALLOC(ndr, r->out.info);
10037                 }
10038                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10039                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
10040                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
10041                 NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
10042                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
10043                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10044         }
10045         return NDR_ERR_SUCCESS;
10046 }
10047
10048 _PUBLIC_ void ndr_print_samr_QueryDisplayInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo2 *r)
10049 {
10050         ndr_print_struct(ndr, name, "samr_QueryDisplayInfo2");
10051         ndr->depth++;
10052         if (flags & NDR_SET_VALUES) {
10053                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10054         }
10055         if (flags & NDR_IN) {
10056                 ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo2");
10057                 ndr->depth++;
10058                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10059                 ndr->depth++;
10060                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10061                 ndr->depth--;
10062                 ndr_print_uint16(ndr, "level", r->in.level);
10063                 ndr_print_uint32(ndr, "start_idx", r->in.start_idx);
10064                 ndr_print_uint32(ndr, "max_entries", r->in.max_entries);
10065                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
10066                 ndr->depth--;
10067         }
10068         if (flags & NDR_OUT) {
10069                 ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo2");
10070                 ndr->depth++;
10071                 ndr_print_ptr(ndr, "total_size", r->out.total_size);
10072                 ndr->depth++;
10073                 ndr_print_uint32(ndr, "total_size", *r->out.total_size);
10074                 ndr->depth--;
10075                 ndr_print_ptr(ndr, "returned_size", r->out.returned_size);
10076                 ndr->depth++;
10077                 ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);
10078                 ndr->depth--;
10079                 ndr_print_ptr(ndr, "info", r->out.info);
10080                 ndr->depth++;
10081                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
10082                 ndr_print_samr_DispInfo(ndr, "info", r->out.info);
10083                 ndr->depth--;
10084                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10085                 ndr->depth--;
10086         }
10087         ndr->depth--;
10088 }
10089
10090 static enum ndr_err_code ndr_push_samr_GetDisplayEnumerationIndex2(struct ndr_push *ndr, int flags, const struct samr_GetDisplayEnumerationIndex2 *r)
10091 {
10092         if (flags & NDR_IN) {
10093                 if (r->in.domain_handle == NULL) {
10094                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10095                 }
10096                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10097                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
10098                 if (r->in.name == NULL) {
10099                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10100                 }
10101                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
10102         }
10103         if (flags & NDR_OUT) {
10104                 if (r->out.idx == NULL) {
10105                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10106                 }
10107                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.idx));
10108                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10109         }
10110         return NDR_ERR_SUCCESS;
10111 }
10112
10113 static enum ndr_err_code ndr_pull_samr_GetDisplayEnumerationIndex2(struct ndr_pull *ndr, int flags, struct samr_GetDisplayEnumerationIndex2 *r)
10114 {
10115         TALLOC_CTX *_mem_save_domain_handle_0;
10116         TALLOC_CTX *_mem_save_name_0;
10117         TALLOC_CTX *_mem_save_idx_0;
10118         if (flags & NDR_IN) {
10119                 ZERO_STRUCT(r->out);
10120
10121                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10122                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10123                 }
10124                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10125                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10126                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10127                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10128                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10129                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10130                         NDR_PULL_ALLOC(ndr, r->in.name);
10131                 }
10132                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10133                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
10134                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
10135                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
10136                 NDR_PULL_ALLOC(ndr, r->out.idx);
10137                 ZERO_STRUCTP(r->out.idx);
10138         }
10139         if (flags & NDR_OUT) {
10140                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10141                         NDR_PULL_ALLOC(ndr, r->out.idx);
10142                 }
10143                 _mem_save_idx_0 = NDR_PULL_GET_MEM_CTX(ndr);
10144                 NDR_PULL_SET_MEM_CTX(ndr, r->out.idx, LIBNDR_FLAG_REF_ALLOC);
10145                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.idx));
10146                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_idx_0, LIBNDR_FLAG_REF_ALLOC);
10147                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10148         }
10149         return NDR_ERR_SUCCESS;
10150 }
10151
10152 _PUBLIC_ void ndr_print_samr_GetDisplayEnumerationIndex2(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDisplayEnumerationIndex2 *r)
10153 {
10154         ndr_print_struct(ndr, name, "samr_GetDisplayEnumerationIndex2");
10155         ndr->depth++;
10156         if (flags & NDR_SET_VALUES) {
10157                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10158         }
10159         if (flags & NDR_IN) {
10160                 ndr_print_struct(ndr, "in", "samr_GetDisplayEnumerationIndex2");
10161                 ndr->depth++;
10162                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10163                 ndr->depth++;
10164                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10165                 ndr->depth--;
10166                 ndr_print_uint16(ndr, "level", r->in.level);
10167                 ndr_print_ptr(ndr, "name", r->in.name);
10168                 ndr->depth++;
10169                 ndr_print_lsa_String(ndr, "name", r->in.name);
10170                 ndr->depth--;
10171                 ndr->depth--;
10172         }
10173         if (flags & NDR_OUT) {
10174                 ndr_print_struct(ndr, "out", "samr_GetDisplayEnumerationIndex2");
10175                 ndr->depth++;
10176                 ndr_print_ptr(ndr, "idx", r->out.idx);
10177                 ndr->depth++;
10178                 ndr_print_uint32(ndr, "idx", *r->out.idx);
10179                 ndr->depth--;
10180                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10181                 ndr->depth--;
10182         }
10183         ndr->depth--;
10184 }
10185
10186 static enum ndr_err_code ndr_push_samr_CreateUser2(struct ndr_push *ndr, int flags, const struct samr_CreateUser2 *r)
10187 {
10188         if (flags & NDR_IN) {
10189                 if (r->in.domain_handle == NULL) {
10190                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10191                 }
10192                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10193                 if (r->in.account_name == NULL) {
10194                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10195                 }
10196                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
10197                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->in.acct_flags));
10198                 NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
10199         }
10200         if (flags & NDR_OUT) {
10201                 if (r->out.user_handle == NULL) {
10202                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10203                 }
10204                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
10205                 if (r->out.access_granted == NULL) {
10206                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10207                 }
10208                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.access_granted));
10209                 if (r->out.rid == NULL) {
10210                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10211                 }
10212                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
10213                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10214         }
10215         return NDR_ERR_SUCCESS;
10216 }
10217
10218 static enum ndr_err_code ndr_pull_samr_CreateUser2(struct ndr_pull *ndr, int flags, struct samr_CreateUser2 *r)
10219 {
10220         TALLOC_CTX *_mem_save_domain_handle_0;
10221         TALLOC_CTX *_mem_save_account_name_0;
10222         TALLOC_CTX *_mem_save_user_handle_0;
10223         TALLOC_CTX *_mem_save_access_granted_0;
10224         TALLOC_CTX *_mem_save_rid_0;
10225         if (flags & NDR_IN) {
10226                 ZERO_STRUCT(r->out);
10227
10228                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10229                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10230                 }
10231                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10232                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10233                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10234                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10235                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10236                         NDR_PULL_ALLOC(ndr, r->in.account_name);
10237                 }
10238                 _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10239                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account_name, LIBNDR_FLAG_REF_ALLOC);
10240                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
10241                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, LIBNDR_FLAG_REF_ALLOC);
10242                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->in.acct_flags));
10243                 NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
10244                 NDR_PULL_ALLOC(ndr, r->out.user_handle);
10245                 ZERO_STRUCTP(r->out.user_handle);
10246                 NDR_PULL_ALLOC(ndr, r->out.access_granted);
10247                 ZERO_STRUCTP(r->out.access_granted);
10248                 NDR_PULL_ALLOC(ndr, r->out.rid);
10249                 ZERO_STRUCTP(r->out.rid);
10250         }
10251         if (flags & NDR_OUT) {
10252                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10253                         NDR_PULL_ALLOC(ndr, r->out.user_handle);
10254                 }
10255                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10256                 NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
10257                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
10258                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
10259                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10260                         NDR_PULL_ALLOC(ndr, r->out.access_granted);
10261                 }
10262                 _mem_save_access_granted_0 = NDR_PULL_GET_MEM_CTX(ndr);
10263                 NDR_PULL_SET_MEM_CTX(ndr, r->out.access_granted, LIBNDR_FLAG_REF_ALLOC);
10264                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.access_granted));
10265                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_access_granted_0, LIBNDR_FLAG_REF_ALLOC);
10266                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10267                         NDR_PULL_ALLOC(ndr, r->out.rid);
10268                 }
10269                 _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
10270                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
10271                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
10272                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
10273                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10274         }
10275         return NDR_ERR_SUCCESS;
10276 }
10277
10278 _PUBLIC_ void ndr_print_samr_CreateUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateUser2 *r)
10279 {
10280         ndr_print_struct(ndr, name, "samr_CreateUser2");
10281         ndr->depth++;
10282         if (flags & NDR_SET_VALUES) {
10283                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10284         }
10285         if (flags & NDR_IN) {
10286                 ndr_print_struct(ndr, "in", "samr_CreateUser2");
10287                 ndr->depth++;
10288                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10289                 ndr->depth++;
10290                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10291                 ndr->depth--;
10292                 ndr_print_ptr(ndr, "account_name", r->in.account_name);
10293                 ndr->depth++;
10294                 ndr_print_lsa_String(ndr, "account_name", r->in.account_name);
10295                 ndr->depth--;
10296                 ndr_print_samr_AcctFlags(ndr, "acct_flags", r->in.acct_flags);
10297                 ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);
10298                 ndr->depth--;
10299         }
10300         if (flags & NDR_OUT) {
10301                 ndr_print_struct(ndr, "out", "samr_CreateUser2");
10302                 ndr->depth++;
10303                 ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
10304                 ndr->depth++;
10305                 ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
10306                 ndr->depth--;
10307                 ndr_print_ptr(ndr, "access_granted", r->out.access_granted);
10308                 ndr->depth++;
10309                 ndr_print_uint32(ndr, "access_granted", *r->out.access_granted);
10310                 ndr->depth--;
10311                 ndr_print_ptr(ndr, "rid", r->out.rid);
10312                 ndr->depth++;
10313                 ndr_print_uint32(ndr, "rid", *r->out.rid);
10314                 ndr->depth--;
10315                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10316                 ndr->depth--;
10317         }
10318         ndr->depth--;
10319 }
10320
10321 static enum ndr_err_code ndr_push_samr_QueryDisplayInfo3(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo3 *r)
10322 {
10323         if (flags & NDR_IN) {
10324                 if (r->in.domain_handle == NULL) {
10325                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10326                 }
10327                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10328                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
10329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));
10330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));
10331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
10332         }
10333         if (flags & NDR_OUT) {
10334                 if (r->out.total_size == NULL) {
10335                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10336                 }
10337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));
10338                 if (r->out.returned_size == NULL) {
10339                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10340                 }
10341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));
10342                 if (r->out.info == NULL) {
10343                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10344                 }
10345                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
10346                 NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
10347                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10348         }
10349         return NDR_ERR_SUCCESS;
10350 }
10351
10352 static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo3(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo3 *r)
10353 {
10354         TALLOC_CTX *_mem_save_domain_handle_0;
10355         TALLOC_CTX *_mem_save_total_size_0;
10356         TALLOC_CTX *_mem_save_returned_size_0;
10357         TALLOC_CTX *_mem_save_info_0;
10358         if (flags & NDR_IN) {
10359                 ZERO_STRUCT(r->out);
10360
10361                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10362                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10363                 }
10364                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10365                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10366                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10367                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10368                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10369                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));
10370                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));
10371                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
10372                 NDR_PULL_ALLOC(ndr, r->out.total_size);
10373                 ZERO_STRUCTP(r->out.total_size);
10374                 NDR_PULL_ALLOC(ndr, r->out.returned_size);
10375                 ZERO_STRUCTP(r->out.returned_size);
10376                 NDR_PULL_ALLOC(ndr, r->out.info);
10377                 ZERO_STRUCTP(r->out.info);
10378         }
10379         if (flags & NDR_OUT) {
10380                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10381                         NDR_PULL_ALLOC(ndr, r->out.total_size);
10382                 }
10383                 _mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
10384                 NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);
10385                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));
10386                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);
10387                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10388                         NDR_PULL_ALLOC(ndr, r->out.returned_size);
10389                 }
10390                 _mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
10391                 NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);
10392                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));
10393                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);
10394                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10395                         NDR_PULL_ALLOC(ndr, r->out.info);
10396                 }
10397                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10398                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
10399                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
10400                 NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
10401                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
10402                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10403         }
10404         return NDR_ERR_SUCCESS;
10405 }
10406
10407 _PUBLIC_ void ndr_print_samr_QueryDisplayInfo3(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo3 *r)
10408 {
10409         ndr_print_struct(ndr, name, "samr_QueryDisplayInfo3");
10410         ndr->depth++;
10411         if (flags & NDR_SET_VALUES) {
10412                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10413         }
10414         if (flags & NDR_IN) {
10415                 ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo3");
10416                 ndr->depth++;
10417                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10418                 ndr->depth++;
10419                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10420                 ndr->depth--;
10421                 ndr_print_uint16(ndr, "level", r->in.level);
10422                 ndr_print_uint32(ndr, "start_idx", r->in.start_idx);
10423                 ndr_print_uint32(ndr, "max_entries", r->in.max_entries);
10424                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
10425                 ndr->depth--;
10426         }
10427         if (flags & NDR_OUT) {
10428                 ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo3");
10429                 ndr->depth++;
10430                 ndr_print_ptr(ndr, "total_size", r->out.total_size);
10431                 ndr->depth++;
10432                 ndr_print_uint32(ndr, "total_size", *r->out.total_size);
10433                 ndr->depth--;
10434                 ndr_print_ptr(ndr, "returned_size", r->out.returned_size);
10435                 ndr->depth++;
10436                 ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);
10437                 ndr->depth--;
10438                 ndr_print_ptr(ndr, "info", r->out.info);
10439                 ndr->depth++;
10440                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
10441                 ndr_print_samr_DispInfo(ndr, "info", r->out.info);
10442                 ndr->depth--;
10443                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10444                 ndr->depth--;
10445         }
10446         ndr->depth--;
10447 }
10448
10449 static enum ndr_err_code ndr_push_samr_AddMultipleMembersToAlias(struct ndr_push *ndr, int flags, const struct samr_AddMultipleMembersToAlias *r)
10450 {
10451         if (flags & NDR_IN) {
10452                 if (r->in.alias_handle == NULL) {
10453                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10454                 }
10455                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
10456                 if (r->in.sids == NULL) {
10457                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10458                 }
10459                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10460         }
10461         if (flags & NDR_OUT) {
10462                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10463         }
10464         return NDR_ERR_SUCCESS;
10465 }
10466
10467 static enum ndr_err_code ndr_pull_samr_AddMultipleMembersToAlias(struct ndr_pull *ndr, int flags, struct samr_AddMultipleMembersToAlias *r)
10468 {
10469         TALLOC_CTX *_mem_save_alias_handle_0;
10470         TALLOC_CTX *_mem_save_sids_0;
10471         if (flags & NDR_IN) {
10472                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10473                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
10474                 }
10475                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10476                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
10477                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
10478                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
10479                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10480                         NDR_PULL_ALLOC(ndr, r->in.sids);
10481                 }
10482                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
10483                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
10484                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10485                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
10486         }
10487         if (flags & NDR_OUT) {
10488                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10489         }
10490         return NDR_ERR_SUCCESS;
10491 }
10492
10493 _PUBLIC_ void ndr_print_samr_AddMultipleMembersToAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddMultipleMembersToAlias *r)
10494 {
10495         ndr_print_struct(ndr, name, "samr_AddMultipleMembersToAlias");
10496         ndr->depth++;
10497         if (flags & NDR_SET_VALUES) {
10498                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10499         }
10500         if (flags & NDR_IN) {
10501                 ndr_print_struct(ndr, "in", "samr_AddMultipleMembersToAlias");
10502                 ndr->depth++;
10503                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
10504                 ndr->depth++;
10505                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
10506                 ndr->depth--;
10507                 ndr_print_ptr(ndr, "sids", r->in.sids);
10508                 ndr->depth++;
10509                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
10510                 ndr->depth--;
10511                 ndr->depth--;
10512         }
10513         if (flags & NDR_OUT) {
10514                 ndr_print_struct(ndr, "out", "samr_AddMultipleMembersToAlias");
10515                 ndr->depth++;
10516                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10517                 ndr->depth--;
10518         }
10519         ndr->depth--;
10520 }
10521
10522 static enum ndr_err_code ndr_push_samr_RemoveMultipleMembersFromAlias(struct ndr_push *ndr, int flags, const struct samr_RemoveMultipleMembersFromAlias *r)
10523 {
10524         if (flags & NDR_IN) {
10525                 if (r->in.alias_handle == NULL) {
10526                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10527                 }
10528                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
10529                 if (r->in.sids == NULL) {
10530                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10531                 }
10532                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10533         }
10534         if (flags & NDR_OUT) {
10535                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10536         }
10537         return NDR_ERR_SUCCESS;
10538 }
10539
10540 static enum ndr_err_code ndr_pull_samr_RemoveMultipleMembersFromAlias(struct ndr_pull *ndr, int flags, struct samr_RemoveMultipleMembersFromAlias *r)
10541 {
10542         TALLOC_CTX *_mem_save_alias_handle_0;
10543         TALLOC_CTX *_mem_save_sids_0;
10544         if (flags & NDR_IN) {
10545                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10546                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
10547                 }
10548                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10549                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
10550                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
10551                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
10552                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10553                         NDR_PULL_ALLOC(ndr, r->in.sids);
10554                 }
10555                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
10556                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
10557                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10558                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
10559         }
10560         if (flags & NDR_OUT) {
10561                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10562         }
10563         return NDR_ERR_SUCCESS;
10564 }
10565
10566 _PUBLIC_ void ndr_print_samr_RemoveMultipleMembersFromAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_RemoveMultipleMembersFromAlias *r)
10567 {
10568         ndr_print_struct(ndr, name, "samr_RemoveMultipleMembersFromAlias");
10569         ndr->depth++;
10570         if (flags & NDR_SET_VALUES) {
10571                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10572         }
10573         if (flags & NDR_IN) {
10574                 ndr_print_struct(ndr, "in", "samr_RemoveMultipleMembersFromAlias");
10575                 ndr->depth++;
10576                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
10577                 ndr->depth++;
10578                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
10579                 ndr->depth--;
10580                 ndr_print_ptr(ndr, "sids", r->in.sids);
10581                 ndr->depth++;
10582                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
10583                 ndr->depth--;
10584                 ndr->depth--;
10585         }
10586         if (flags & NDR_OUT) {
10587                 ndr_print_struct(ndr, "out", "samr_RemoveMultipleMembersFromAlias");
10588                 ndr->depth++;
10589                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10590                 ndr->depth--;
10591         }
10592         ndr->depth--;
10593 }
10594
10595 static enum ndr_err_code ndr_push_samr_OemChangePasswordUser2(struct ndr_push *ndr, int flags, const struct samr_OemChangePasswordUser2 *r)
10596 {
10597         if (flags & NDR_IN) {
10598                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
10599                 if (r->in.server) {
10600                         NDR_CHECK(ndr_push_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
10601                 }
10602                 if (r->in.account == NULL) {
10603                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10604                 }
10605                 NDR_CHECK(ndr_push_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
10606                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
10607                 if (r->in.password) {
10608                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password));
10609                 }
10610                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hash));
10611                 if (r->in.hash) {
10612                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.hash));
10613                 }
10614         }
10615         if (flags & NDR_OUT) {
10616                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10617         }
10618         return NDR_ERR_SUCCESS;
10619 }
10620
10621 static enum ndr_err_code ndr_pull_samr_OemChangePasswordUser2(struct ndr_pull *ndr, int flags, struct samr_OemChangePasswordUser2 *r)
10622 {
10623         uint32_t _ptr_server;
10624         uint32_t _ptr_password;
10625         uint32_t _ptr_hash;
10626         TALLOC_CTX *_mem_save_server_0;
10627         TALLOC_CTX *_mem_save_account_0;
10628         TALLOC_CTX *_mem_save_password_0;
10629         TALLOC_CTX *_mem_save_hash_0;
10630         if (flags & NDR_IN) {
10631                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
10632                 if (_ptr_server) {
10633                         NDR_PULL_ALLOC(ndr, r->in.server);
10634                 } else {
10635                         r->in.server = NULL;
10636                 }
10637                 if (r->in.server) {
10638                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
10639                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
10640                         NDR_CHECK(ndr_pull_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
10641                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
10642                 }
10643                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10644                         NDR_PULL_ALLOC(ndr, r->in.account);
10645                 }
10646                 _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
10647                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);
10648                 NDR_CHECK(ndr_pull_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
10649                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);
10650                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
10651                 if (_ptr_password) {
10652                         NDR_PULL_ALLOC(ndr, r->in.password);
10653                 } else {
10654                         r->in.password = NULL;
10655                 }
10656                 if (r->in.password) {
10657                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
10658                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
10659                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password));
10660                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
10661                 }
10662                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hash));
10663                 if (_ptr_hash) {
10664                         NDR_PULL_ALLOC(ndr, r->in.hash);
10665                 } else {
10666                         r->in.hash = NULL;
10667                 }
10668                 if (r->in.hash) {
10669                         _mem_save_hash_0 = NDR_PULL_GET_MEM_CTX(ndr);
10670                         NDR_PULL_SET_MEM_CTX(ndr, r->in.hash, 0);
10671                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.hash));
10672                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hash_0, 0);
10673                 }
10674         }
10675         if (flags & NDR_OUT) {
10676                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10677         }
10678         return NDR_ERR_SUCCESS;
10679 }
10680
10681 _PUBLIC_ void ndr_print_samr_OemChangePasswordUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_OemChangePasswordUser2 *r)
10682 {
10683         ndr_print_struct(ndr, name, "samr_OemChangePasswordUser2");
10684         ndr->depth++;
10685         if (flags & NDR_SET_VALUES) {
10686                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10687         }
10688         if (flags & NDR_IN) {
10689                 ndr_print_struct(ndr, "in", "samr_OemChangePasswordUser2");
10690                 ndr->depth++;
10691                 ndr_print_ptr(ndr, "server", r->in.server);
10692                 ndr->depth++;
10693                 if (r->in.server) {
10694                         ndr_print_lsa_AsciiString(ndr, "server", r->in.server);
10695                 }
10696                 ndr->depth--;
10697                 ndr_print_ptr(ndr, "account", r->in.account);
10698                 ndr->depth++;
10699                 ndr_print_lsa_AsciiString(ndr, "account", r->in.account);
10700                 ndr->depth--;
10701                 ndr_print_ptr(ndr, "password", r->in.password);
10702                 ndr->depth++;
10703                 if (r->in.password) {
10704                         ndr_print_samr_CryptPassword(ndr, "password", r->in.password);
10705                 }
10706                 ndr->depth--;
10707                 ndr_print_ptr(ndr, "hash", r->in.hash);
10708                 ndr->depth++;
10709                 if (r->in.hash) {
10710                         ndr_print_samr_Password(ndr, "hash", r->in.hash);
10711                 }
10712                 ndr->depth--;
10713                 ndr->depth--;
10714         }
10715         if (flags & NDR_OUT) {
10716                 ndr_print_struct(ndr, "out", "samr_OemChangePasswordUser2");
10717                 ndr->depth++;
10718                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10719                 ndr->depth--;
10720         }
10721         ndr->depth--;
10722 }
10723
10724 static enum ndr_err_code ndr_push_samr_ChangePasswordUser2(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser2 *r)
10725 {
10726         if (flags & NDR_IN) {
10727                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
10728                 if (r->in.server) {
10729                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
10730                 }
10731                 if (r->in.account == NULL) {
10732                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10733                 }
10734                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
10735                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_password));
10736                 if (r->in.nt_password) {
10737                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
10738                 }
10739                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_verifier));
10740                 if (r->in.nt_verifier) {
10741                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
10742                 }
10743                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_change));
10744                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_password));
10745                 if (r->in.lm_password) {
10746                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
10747                 }
10748                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_verifier));
10749                 if (r->in.lm_verifier) {
10750                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
10751                 }
10752         }
10753         if (flags & NDR_OUT) {
10754                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10755         }
10756         return NDR_ERR_SUCCESS;
10757 }
10758
10759 static enum ndr_err_code ndr_pull_samr_ChangePasswordUser2(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser2 *r)
10760 {
10761         uint32_t _ptr_server;
10762         uint32_t _ptr_nt_password;
10763         uint32_t _ptr_nt_verifier;
10764         uint32_t _ptr_lm_password;
10765         uint32_t _ptr_lm_verifier;
10766         TALLOC_CTX *_mem_save_server_0;
10767         TALLOC_CTX *_mem_save_account_0;
10768         TALLOC_CTX *_mem_save_nt_password_0;
10769         TALLOC_CTX *_mem_save_nt_verifier_0;
10770         TALLOC_CTX *_mem_save_lm_password_0;
10771         TALLOC_CTX *_mem_save_lm_verifier_0;
10772         if (flags & NDR_IN) {
10773                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
10774                 if (_ptr_server) {
10775                         NDR_PULL_ALLOC(ndr, r->in.server);
10776                 } else {
10777                         r->in.server = NULL;
10778                 }
10779                 if (r->in.server) {
10780                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
10781                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
10782                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
10783                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
10784                 }
10785                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10786                         NDR_PULL_ALLOC(ndr, r->in.account);
10787                 }
10788                 _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
10789                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);
10790                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
10791                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);
10792                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_password));
10793                 if (_ptr_nt_password) {
10794                         NDR_PULL_ALLOC(ndr, r->in.nt_password);
10795                 } else {
10796                         r->in.nt_password = NULL;
10797                 }
10798                 if (r->in.nt_password) {
10799                         _mem_save_nt_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
10800                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_password, 0);
10801                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
10802                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_password_0, 0);
10803                 }
10804                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_verifier));
10805                 if (_ptr_nt_verifier) {
10806                         NDR_PULL_ALLOC(ndr, r->in.nt_verifier);
10807                 } else {
10808                         r->in.nt_verifier = NULL;
10809                 }
10810                 if (r->in.nt_verifier) {
10811                         _mem_save_nt_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
10812                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_verifier, 0);
10813                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
10814                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_verifier_0, 0);
10815                 }
10816                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_change));
10817                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_password));
10818                 if (_ptr_lm_password) {
10819                         NDR_PULL_ALLOC(ndr, r->in.lm_password);
10820                 } else {
10821                         r->in.lm_password = NULL;
10822                 }
10823                 if (r->in.lm_password) {
10824                         _mem_save_lm_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
10825                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_password, 0);
10826                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
10827                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_password_0, 0);
10828                 }
10829                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_verifier));
10830                 if (_ptr_lm_verifier) {
10831                         NDR_PULL_ALLOC(ndr, r->in.lm_verifier);
10832                 } else {
10833                         r->in.lm_verifier = NULL;
10834                 }
10835                 if (r->in.lm_verifier) {
10836                         _mem_save_lm_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
10837                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_verifier, 0);
10838                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
10839                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_verifier_0, 0);
10840                 }
10841         }
10842         if (flags & NDR_OUT) {
10843                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10844         }
10845         return NDR_ERR_SUCCESS;
10846 }
10847
10848 _PUBLIC_ void ndr_print_samr_ChangePasswordUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser2 *r)
10849 {
10850         ndr_print_struct(ndr, name, "samr_ChangePasswordUser2");
10851         ndr->depth++;
10852         if (flags & NDR_SET_VALUES) {
10853                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10854         }
10855         if (flags & NDR_IN) {
10856                 ndr_print_struct(ndr, "in", "samr_ChangePasswordUser2");
10857                 ndr->depth++;
10858                 ndr_print_ptr(ndr, "server", r->in.server);
10859                 ndr->depth++;
10860                 if (r->in.server) {
10861                         ndr_print_lsa_String(ndr, "server", r->in.server);
10862                 }
10863                 ndr->depth--;
10864                 ndr_print_ptr(ndr, "account", r->in.account);
10865                 ndr->depth++;
10866                 ndr_print_lsa_String(ndr, "account", r->in.account);
10867                 ndr->depth--;
10868                 ndr_print_ptr(ndr, "nt_password", r->in.nt_password);
10869                 ndr->depth++;
10870                 if (r->in.nt_password) {
10871                         ndr_print_samr_CryptPassword(ndr, "nt_password", r->in.nt_password);
10872                 }
10873                 ndr->depth--;
10874                 ndr_print_ptr(ndr, "nt_verifier", r->in.nt_verifier);
10875                 ndr->depth++;
10876                 if (r->in.nt_verifier) {
10877                         ndr_print_samr_Password(ndr, "nt_verifier", r->in.nt_verifier);
10878                 }
10879                 ndr->depth--;
10880                 ndr_print_uint8(ndr, "lm_change", r->in.lm_change);
10881                 ndr_print_ptr(ndr, "lm_password", r->in.lm_password);
10882                 ndr->depth++;
10883                 if (r->in.lm_password) {
10884                         ndr_print_samr_CryptPassword(ndr, "lm_password", r->in.lm_password);
10885                 }
10886                 ndr->depth--;
10887                 ndr_print_ptr(ndr, "lm_verifier", r->in.lm_verifier);
10888                 ndr->depth++;
10889                 if (r->in.lm_verifier) {
10890                         ndr_print_samr_Password(ndr, "lm_verifier", r->in.lm_verifier);
10891                 }
10892                 ndr->depth--;
10893                 ndr->depth--;
10894         }
10895         if (flags & NDR_OUT) {
10896                 ndr_print_struct(ndr, "out", "samr_ChangePasswordUser2");
10897                 ndr->depth++;
10898                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10899                 ndr->depth--;
10900         }
10901         ndr->depth--;
10902 }
10903
10904 static enum ndr_err_code ndr_push_samr_GetDomPwInfo(struct ndr_push *ndr, int flags, const struct samr_GetDomPwInfo *r)
10905 {
10906         if (flags & NDR_IN) {
10907                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.domain_name));
10908                 if (r->in.domain_name) {
10909                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
10910                 }
10911         }
10912         if (flags & NDR_OUT) {
10913                 if (r->out.info == NULL) {
10914                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10915                 }
10916                 NDR_CHECK(ndr_push_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
10917                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10918         }
10919         return NDR_ERR_SUCCESS;
10920 }
10921
10922 static enum ndr_err_code ndr_pull_samr_GetDomPwInfo(struct ndr_pull *ndr, int flags, struct samr_GetDomPwInfo *r)
10923 {
10924         uint32_t _ptr_domain_name;
10925         TALLOC_CTX *_mem_save_domain_name_0;
10926         TALLOC_CTX *_mem_save_info_0;
10927         if (flags & NDR_IN) {
10928                 ZERO_STRUCT(r->out);
10929
10930                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
10931                 if (_ptr_domain_name) {
10932                         NDR_PULL_ALLOC(ndr, r->in.domain_name);
10933                 } else {
10934                         r->in.domain_name = NULL;
10935                 }
10936                 if (r->in.domain_name) {
10937                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10938                         NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_name, 0);
10939                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
10940                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
10941                 }
10942                 NDR_PULL_ALLOC(ndr, r->out.info);
10943                 ZERO_STRUCTP(r->out.info);
10944         }
10945         if (flags & NDR_OUT) {
10946                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10947                         NDR_PULL_ALLOC(ndr, r->out.info);
10948                 }
10949                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10950                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
10951                 NDR_CHECK(ndr_pull_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
10952                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
10953                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10954         }
10955         return NDR_ERR_SUCCESS;
10956 }
10957
10958 _PUBLIC_ void ndr_print_samr_GetDomPwInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDomPwInfo *r)
10959 {
10960         ndr_print_struct(ndr, name, "samr_GetDomPwInfo");
10961         ndr->depth++;
10962         if (flags & NDR_SET_VALUES) {
10963                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10964         }
10965         if (flags & NDR_IN) {
10966                 ndr_print_struct(ndr, "in", "samr_GetDomPwInfo");
10967                 ndr->depth++;
10968                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
10969                 ndr->depth++;
10970                 if (r->in.domain_name) {
10971                         ndr_print_lsa_String(ndr, "domain_name", r->in.domain_name);
10972                 }
10973                 ndr->depth--;
10974                 ndr->depth--;
10975         }
10976         if (flags & NDR_OUT) {
10977                 ndr_print_struct(ndr, "out", "samr_GetDomPwInfo");
10978                 ndr->depth++;
10979                 ndr_print_ptr(ndr, "info", r->out.info);
10980                 ndr->depth++;
10981                 ndr_print_samr_PwInfo(ndr, "info", r->out.info);
10982                 ndr->depth--;
10983                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10984                 ndr->depth--;
10985         }
10986         ndr->depth--;
10987 }
10988
10989 static enum ndr_err_code ndr_push_samr_Connect2(struct ndr_push *ndr, int flags, const struct samr_Connect2 *r)
10990 {
10991         if (flags & NDR_IN) {
10992                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
10993                 if (r->in.system_name) {
10994                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
10995                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10996                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
10997                         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));
10998                 }
10999                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
11000         }
11001         if (flags & NDR_OUT) {
11002                 if (r->out.connect_handle == NULL) {
11003                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11004                 }
11005                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11006                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11007         }
11008         return NDR_ERR_SUCCESS;
11009 }
11010
11011 static enum ndr_err_code ndr_pull_samr_Connect2(struct ndr_pull *ndr, int flags, struct samr_Connect2 *r)
11012 {
11013         uint32_t _ptr_system_name;
11014         TALLOC_CTX *_mem_save_system_name_0;
11015         TALLOC_CTX *_mem_save_connect_handle_0;
11016         if (flags & NDR_IN) {
11017                 ZERO_STRUCT(r->out);
11018
11019                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
11020                 if (_ptr_system_name) {
11021                         NDR_PULL_ALLOC(ndr, r->in.system_name);
11022                 } else {
11023                         r->in.system_name = NULL;
11024                 }
11025                 if (r->in.system_name) {
11026                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11027                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
11028                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
11029                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
11030                         if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
11031                                 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));
11032                         }
11033                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
11034                         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));
11035                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
11036                 }
11037                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
11038                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11039                 ZERO_STRUCTP(r->out.connect_handle);
11040         }
11041         if (flags & NDR_OUT) {
11042                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11043                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11044                 }
11045                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11046                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
11047                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11048                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
11049                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11050         }
11051         return NDR_ERR_SUCCESS;
11052 }
11053
11054 _PUBLIC_ void ndr_print_samr_Connect2(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect2 *r)
11055 {
11056         ndr_print_struct(ndr, name, "samr_Connect2");
11057         ndr->depth++;
11058         if (flags & NDR_SET_VALUES) {
11059                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11060         }
11061         if (flags & NDR_IN) {
11062                 ndr_print_struct(ndr, "in", "samr_Connect2");
11063                 ndr->depth++;
11064                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
11065                 ndr->depth++;
11066                 if (r->in.system_name) {
11067                         ndr_print_string(ndr, "system_name", r->in.system_name);
11068                 }
11069                 ndr->depth--;
11070                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
11071                 ndr->depth--;
11072         }
11073         if (flags & NDR_OUT) {
11074                 ndr_print_struct(ndr, "out", "samr_Connect2");
11075                 ndr->depth++;
11076                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
11077                 ndr->depth++;
11078                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
11079                 ndr->depth--;
11080                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11081                 ndr->depth--;
11082         }
11083         ndr->depth--;
11084 }
11085
11086 _PUBLIC_ enum ndr_err_code ndr_push_samr_SetUserInfo2(struct ndr_push *ndr, int flags, const struct samr_SetUserInfo2 *r)
11087 {
11088         if (flags & NDR_IN) {
11089                 if (r->in.user_handle == NULL) {
11090                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11091                 }
11092                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
11093                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
11094                 if (r->in.info == NULL) {
11095                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11096                 }
11097                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
11098                 NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
11099         }
11100         if (flags & NDR_OUT) {
11101                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11102         }
11103         return NDR_ERR_SUCCESS;
11104 }
11105
11106 _PUBLIC_ enum ndr_err_code ndr_pull_samr_SetUserInfo2(struct ndr_pull *ndr, int flags, struct samr_SetUserInfo2 *r)
11107 {
11108         TALLOC_CTX *_mem_save_user_handle_0;
11109         TALLOC_CTX *_mem_save_info_0;
11110         if (flags & NDR_IN) {
11111                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11112                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
11113                 }
11114                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11115                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
11116                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
11117                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
11118                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
11119                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11120                         NDR_PULL_ALLOC(ndr, r->in.info);
11121                 }
11122                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
11123                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
11124                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
11125                 NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
11126                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
11127         }
11128         if (flags & NDR_OUT) {
11129                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11130         }
11131         return NDR_ERR_SUCCESS;
11132 }
11133
11134 _PUBLIC_ void ndr_print_samr_SetUserInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetUserInfo2 *r)
11135 {
11136         ndr_print_struct(ndr, name, "samr_SetUserInfo2");
11137         ndr->depth++;
11138         if (flags & NDR_SET_VALUES) {
11139                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11140         }
11141         if (flags & NDR_IN) {
11142                 ndr_print_struct(ndr, "in", "samr_SetUserInfo2");
11143                 ndr->depth++;
11144                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
11145                 ndr->depth++;
11146                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
11147                 ndr->depth--;
11148                 ndr_print_uint16(ndr, "level", r->in.level);
11149                 ndr_print_ptr(ndr, "info", r->in.info);
11150                 ndr->depth++;
11151                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
11152                 ndr_print_samr_UserInfo(ndr, "info", r->in.info);
11153                 ndr->depth--;
11154                 ndr->depth--;
11155         }
11156         if (flags & NDR_OUT) {
11157                 ndr_print_struct(ndr, "out", "samr_SetUserInfo2");
11158                 ndr->depth++;
11159                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11160                 ndr->depth--;
11161         }
11162         ndr->depth--;
11163 }
11164
11165 static enum ndr_err_code ndr_push_samr_SetBootKeyInformation(struct ndr_push *ndr, int flags, const struct samr_SetBootKeyInformation *r)
11166 {
11167         if (flags & NDR_IN) {
11168                 if (r->in.connect_handle == NULL) {
11169                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11170                 }
11171                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
11172                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
11173                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
11174                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown3));
11175         }
11176         if (flags & NDR_OUT) {
11177                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11178         }
11179         return NDR_ERR_SUCCESS;
11180 }
11181
11182 static enum ndr_err_code ndr_pull_samr_SetBootKeyInformation(struct ndr_pull *ndr, int flags, struct samr_SetBootKeyInformation *r)
11183 {
11184         TALLOC_CTX *_mem_save_connect_handle_0;
11185         if (flags & NDR_IN) {
11186                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11187                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
11188                 }
11189                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11190                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
11191                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
11192                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
11193                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
11194                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
11195                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown3));
11196         }
11197         if (flags & NDR_OUT) {
11198                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11199         }
11200         return NDR_ERR_SUCCESS;
11201 }
11202
11203 _PUBLIC_ void ndr_print_samr_SetBootKeyInformation(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetBootKeyInformation *r)
11204 {
11205         ndr_print_struct(ndr, name, "samr_SetBootKeyInformation");
11206         ndr->depth++;
11207         if (flags & NDR_SET_VALUES) {
11208                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11209         }
11210         if (flags & NDR_IN) {
11211                 ndr_print_struct(ndr, "in", "samr_SetBootKeyInformation");
11212                 ndr->depth++;
11213                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
11214                 ndr->depth++;
11215                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
11216                 ndr->depth--;
11217                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
11218                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
11219                 ndr_print_uint32(ndr, "unknown3", r->in.unknown3);
11220                 ndr->depth--;
11221         }
11222         if (flags & NDR_OUT) {
11223                 ndr_print_struct(ndr, "out", "samr_SetBootKeyInformation");
11224                 ndr->depth++;
11225                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11226                 ndr->depth--;
11227         }
11228         ndr->depth--;
11229 }
11230
11231 static enum ndr_err_code ndr_push_samr_GetBootKeyInformation(struct ndr_push *ndr, int flags, const struct samr_GetBootKeyInformation *r)
11232 {
11233         if (flags & NDR_IN) {
11234                 if (r->in.domain_handle == NULL) {
11235                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11236                 }
11237                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
11238         }
11239         if (flags & NDR_OUT) {
11240                 if (r->out.unknown == NULL) {
11241                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11242                 }
11243                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.unknown));
11244                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11245         }
11246         return NDR_ERR_SUCCESS;
11247 }
11248
11249 static enum ndr_err_code ndr_pull_samr_GetBootKeyInformation(struct ndr_pull *ndr, int flags, struct samr_GetBootKeyInformation *r)
11250 {
11251         TALLOC_CTX *_mem_save_domain_handle_0;
11252         TALLOC_CTX *_mem_save_unknown_0;
11253         if (flags & NDR_IN) {
11254                 ZERO_STRUCT(r->out);
11255
11256                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11257                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
11258                 }
11259                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11260                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
11261                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
11262                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
11263                 NDR_PULL_ALLOC(ndr, r->out.unknown);
11264                 ZERO_STRUCTP(r->out.unknown);
11265         }
11266         if (flags & NDR_OUT) {
11267                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11268                         NDR_PULL_ALLOC(ndr, r->out.unknown);
11269                 }
11270                 _mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);
11271                 NDR_PULL_SET_MEM_CTX(ndr, r->out.unknown, LIBNDR_FLAG_REF_ALLOC);
11272                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.unknown));
11273                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, LIBNDR_FLAG_REF_ALLOC);
11274                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11275         }
11276         return NDR_ERR_SUCCESS;
11277 }
11278
11279 _PUBLIC_ void ndr_print_samr_GetBootKeyInformation(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetBootKeyInformation *r)
11280 {
11281         ndr_print_struct(ndr, name, "samr_GetBootKeyInformation");
11282         ndr->depth++;
11283         if (flags & NDR_SET_VALUES) {
11284                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11285         }
11286         if (flags & NDR_IN) {
11287                 ndr_print_struct(ndr, "in", "samr_GetBootKeyInformation");
11288                 ndr->depth++;
11289                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
11290                 ndr->depth++;
11291                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
11292                 ndr->depth--;
11293                 ndr->depth--;
11294         }
11295         if (flags & NDR_OUT) {
11296                 ndr_print_struct(ndr, "out", "samr_GetBootKeyInformation");
11297                 ndr->depth++;
11298                 ndr_print_ptr(ndr, "unknown", r->out.unknown);
11299                 ndr->depth++;
11300                 ndr_print_uint32(ndr, "unknown", *r->out.unknown);
11301                 ndr->depth--;
11302                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11303                 ndr->depth--;
11304         }
11305         ndr->depth--;
11306 }
11307
11308 static enum ndr_err_code ndr_push_samr_Connect3(struct ndr_push *ndr, int flags, const struct samr_Connect3 *r)
11309 {
11310         if (flags & NDR_IN) {
11311                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
11312                 if (r->in.system_name) {
11313                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11314                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11315                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11316                         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));
11317                 }
11318                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
11319                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
11320         }
11321         if (flags & NDR_OUT) {
11322                 if (r->out.connect_handle == NULL) {
11323                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11324                 }
11325                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11326                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11327         }
11328         return NDR_ERR_SUCCESS;
11329 }
11330
11331 static enum ndr_err_code ndr_pull_samr_Connect3(struct ndr_pull *ndr, int flags, struct samr_Connect3 *r)
11332 {
11333         uint32_t _ptr_system_name;
11334         TALLOC_CTX *_mem_save_system_name_0;
11335         TALLOC_CTX *_mem_save_connect_handle_0;
11336         if (flags & NDR_IN) {
11337                 ZERO_STRUCT(r->out);
11338
11339                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
11340                 if (_ptr_system_name) {
11341                         NDR_PULL_ALLOC(ndr, r->in.system_name);
11342                 } else {
11343                         r->in.system_name = NULL;
11344                 }
11345                 if (r->in.system_name) {
11346                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11347                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
11348                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
11349                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
11350                         if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
11351                                 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));
11352                         }
11353                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
11354                         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));
11355                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
11356                 }
11357                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
11358                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
11359                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11360                 ZERO_STRUCTP(r->out.connect_handle);
11361         }
11362         if (flags & NDR_OUT) {
11363                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11364                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11365                 }
11366                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11367                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
11368                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11369                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
11370                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11371         }
11372         return NDR_ERR_SUCCESS;
11373 }
11374
11375 _PUBLIC_ void ndr_print_samr_Connect3(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect3 *r)
11376 {
11377         ndr_print_struct(ndr, name, "samr_Connect3");
11378         ndr->depth++;
11379         if (flags & NDR_SET_VALUES) {
11380                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11381         }
11382         if (flags & NDR_IN) {
11383                 ndr_print_struct(ndr, "in", "samr_Connect3");
11384                 ndr->depth++;
11385                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
11386                 ndr->depth++;
11387                 if (r->in.system_name) {
11388                         ndr_print_string(ndr, "system_name", r->in.system_name);
11389                 }
11390                 ndr->depth--;
11391                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
11392                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
11393                 ndr->depth--;
11394         }
11395         if (flags & NDR_OUT) {
11396                 ndr_print_struct(ndr, "out", "samr_Connect3");
11397                 ndr->depth++;
11398                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
11399                 ndr->depth++;
11400                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
11401                 ndr->depth--;
11402                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11403                 ndr->depth--;
11404         }
11405         ndr->depth--;
11406 }
11407
11408 static enum ndr_err_code ndr_push_samr_Connect4(struct ndr_push *ndr, int flags, const struct samr_Connect4 *r)
11409 {
11410         if (flags & NDR_IN) {
11411                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
11412                 if (r->in.system_name) {
11413                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11414                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11415                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11416                         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));
11417                 }
11418                 NDR_CHECK(ndr_push_samr_ConnectVersion(ndr, NDR_SCALARS, r->in.client_version));
11419                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
11420         }
11421         if (flags & NDR_OUT) {
11422                 if (r->out.connect_handle == NULL) {
11423                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11424                 }
11425                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11426                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11427         }
11428         return NDR_ERR_SUCCESS;
11429 }
11430
11431 static enum ndr_err_code ndr_pull_samr_Connect4(struct ndr_pull *ndr, int flags, struct samr_Connect4 *r)
11432 {
11433         uint32_t _ptr_system_name;
11434         TALLOC_CTX *_mem_save_system_name_0;
11435         TALLOC_CTX *_mem_save_connect_handle_0;
11436         if (flags & NDR_IN) {
11437                 ZERO_STRUCT(r->out);
11438
11439                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
11440                 if (_ptr_system_name) {
11441                         NDR_PULL_ALLOC(ndr, r->in.system_name);
11442                 } else {
11443                         r->in.system_name = NULL;
11444                 }
11445                 if (r->in.system_name) {
11446                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11447                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
11448                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
11449                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
11450                         if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
11451                                 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));
11452                         }
11453                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
11454                         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));
11455                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
11456                 }
11457                 NDR_CHECK(ndr_pull_samr_ConnectVersion(ndr, NDR_SCALARS, &r->in.client_version));
11458                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
11459                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11460                 ZERO_STRUCTP(r->out.connect_handle);
11461         }
11462         if (flags & NDR_OUT) {
11463                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11464                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11465                 }
11466                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11467                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
11468                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11469                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
11470                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11471         }
11472         return NDR_ERR_SUCCESS;
11473 }
11474
11475 _PUBLIC_ void ndr_print_samr_Connect4(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect4 *r)
11476 {
11477         ndr_print_struct(ndr, name, "samr_Connect4");
11478         ndr->depth++;
11479         if (flags & NDR_SET_VALUES) {
11480                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11481         }
11482         if (flags & NDR_IN) {
11483                 ndr_print_struct(ndr, "in", "samr_Connect4");
11484                 ndr->depth++;
11485                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
11486                 ndr->depth++;
11487                 if (r->in.system_name) {
11488                         ndr_print_string(ndr, "system_name", r->in.system_name);
11489                 }
11490                 ndr->depth--;
11491                 ndr_print_samr_ConnectVersion(ndr, "client_version", r->in.client_version);
11492                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
11493                 ndr->depth--;
11494         }
11495         if (flags & NDR_OUT) {
11496                 ndr_print_struct(ndr, "out", "samr_Connect4");
11497                 ndr->depth++;
11498                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
11499                 ndr->depth++;
11500                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
11501                 ndr->depth--;
11502                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11503                 ndr->depth--;
11504         }
11505         ndr->depth--;
11506 }
11507
11508 static enum ndr_err_code ndr_push_samr_ChangePasswordUser3(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser3 *r)
11509 {
11510         if (flags & NDR_IN) {
11511                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
11512                 if (r->in.server) {
11513                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
11514                 }
11515                 if (r->in.account == NULL) {
11516                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11517                 }
11518                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
11519                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_password));
11520                 if (r->in.nt_password) {
11521                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
11522                 }
11523                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_verifier));
11524                 if (r->in.nt_verifier) {
11525                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
11526                 }
11527                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_change));
11528                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_password));
11529                 if (r->in.lm_password) {
11530                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
11531                 }
11532                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_verifier));
11533                 if (r->in.lm_verifier) {
11534                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
11535                 }
11536                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password3));
11537                 if (r->in.password3) {
11538                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password3));
11539                 }
11540         }
11541         if (flags & NDR_OUT) {
11542                 if (r->out.dominfo == NULL) {
11543                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11544                 }
11545                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.dominfo));
11546                 if (*r->out.dominfo) {
11547                         NDR_CHECK(ndr_push_samr_DomInfo1(ndr, NDR_SCALARS, *r->out.dominfo));
11548                 }
11549                 if (r->out.reject == NULL) {
11550                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11551                 }
11552                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.reject));
11553                 if (*r->out.reject) {
11554                         NDR_CHECK(ndr_push_samr_ChangeReject(ndr, NDR_SCALARS, *r->out.reject));
11555                 }
11556                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11557         }
11558         return NDR_ERR_SUCCESS;
11559 }
11560
11561 static enum ndr_err_code ndr_pull_samr_ChangePasswordUser3(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser3 *r)
11562 {
11563         uint32_t _ptr_server;
11564         uint32_t _ptr_nt_password;
11565         uint32_t _ptr_nt_verifier;
11566         uint32_t _ptr_lm_password;
11567         uint32_t _ptr_lm_verifier;
11568         uint32_t _ptr_password3;
11569         uint32_t _ptr_dominfo;
11570         uint32_t _ptr_reject;
11571         TALLOC_CTX *_mem_save_server_0;
11572         TALLOC_CTX *_mem_save_account_0;
11573         TALLOC_CTX *_mem_save_nt_password_0;
11574         TALLOC_CTX *_mem_save_nt_verifier_0;
11575         TALLOC_CTX *_mem_save_lm_password_0;
11576         TALLOC_CTX *_mem_save_lm_verifier_0;
11577         TALLOC_CTX *_mem_save_password3_0;
11578         TALLOC_CTX *_mem_save_dominfo_0;
11579         TALLOC_CTX *_mem_save_dominfo_1;
11580         TALLOC_CTX *_mem_save_reject_0;
11581         TALLOC_CTX *_mem_save_reject_1;
11582         if (flags & NDR_IN) {
11583                 ZERO_STRUCT(r->out);
11584
11585                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
11586                 if (_ptr_server) {
11587                         NDR_PULL_ALLOC(ndr, r->in.server);
11588                 } else {
11589                         r->in.server = NULL;
11590                 }
11591                 if (r->in.server) {
11592                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
11593                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
11594                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
11595                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
11596                 }
11597                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11598                         NDR_PULL_ALLOC(ndr, r->in.account);
11599                 }
11600                 _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
11601                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);
11602                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
11603                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);
11604                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_password));
11605                 if (_ptr_nt_password) {
11606                         NDR_PULL_ALLOC(ndr, r->in.nt_password);
11607                 } else {
11608                         r->in.nt_password = NULL;
11609                 }
11610                 if (r->in.nt_password) {
11611                         _mem_save_nt_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
11612                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_password, 0);
11613                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
11614                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_password_0, 0);
11615                 }
11616                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_verifier));
11617                 if (_ptr_nt_verifier) {
11618                         NDR_PULL_ALLOC(ndr, r->in.nt_verifier);
11619                 } else {
11620                         r->in.nt_verifier = NULL;
11621                 }
11622                 if (r->in.nt_verifier) {
11623                         _mem_save_nt_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
11624                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_verifier, 0);
11625                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
11626                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_verifier_0, 0);
11627                 }
11628                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_change));
11629                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_password));
11630                 if (_ptr_lm_password) {
11631                         NDR_PULL_ALLOC(ndr, r->in.lm_password);
11632                 } else {
11633                         r->in.lm_password = NULL;
11634                 }
11635                 if (r->in.lm_password) {
11636                         _mem_save_lm_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
11637                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_password, 0);
11638                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
11639                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_password_0, 0);
11640                 }
11641                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_verifier));
11642                 if (_ptr_lm_verifier) {
11643                         NDR_PULL_ALLOC(ndr, r->in.lm_verifier);
11644                 } else {
11645                         r->in.lm_verifier = NULL;
11646                 }
11647                 if (r->in.lm_verifier) {
11648                         _mem_save_lm_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
11649                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_verifier, 0);
11650                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
11651                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_verifier_0, 0);
11652                 }
11653                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password3));
11654                 if (_ptr_password3) {
11655                         NDR_PULL_ALLOC(ndr, r->in.password3);
11656                 } else {
11657                         r->in.password3 = NULL;
11658                 }
11659                 if (r->in.password3) {
11660                         _mem_save_password3_0 = NDR_PULL_GET_MEM_CTX(ndr);
11661                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password3, 0);
11662                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password3));
11663                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password3_0, 0);
11664                 }
11665                 NDR_PULL_ALLOC(ndr, r->out.dominfo);
11666                 ZERO_STRUCTP(r->out.dominfo);
11667                 NDR_PULL_ALLOC(ndr, r->out.reject);
11668                 ZERO_STRUCTP(r->out.reject);
11669         }
11670         if (flags & NDR_OUT) {
11671                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11672                         NDR_PULL_ALLOC(ndr, r->out.dominfo);
11673                 }
11674                 _mem_save_dominfo_0 = NDR_PULL_GET_MEM_CTX(ndr);
11675                 NDR_PULL_SET_MEM_CTX(ndr, r->out.dominfo, LIBNDR_FLAG_REF_ALLOC);
11676                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dominfo));
11677                 if (_ptr_dominfo) {
11678                         NDR_PULL_ALLOC(ndr, *r->out.dominfo);
11679                 } else {
11680                         *r->out.dominfo = NULL;
11681                 }
11682                 if (*r->out.dominfo) {
11683                         _mem_save_dominfo_1 = NDR_PULL_GET_MEM_CTX(ndr);
11684                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.dominfo, 0);
11685                         NDR_CHECK(ndr_pull_samr_DomInfo1(ndr, NDR_SCALARS, *r->out.dominfo));
11686                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dominfo_1, 0);
11687                 }
11688                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dominfo_0, LIBNDR_FLAG_REF_ALLOC);
11689                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11690                         NDR_PULL_ALLOC(ndr, r->out.reject);
11691                 }
11692                 _mem_save_reject_0 = NDR_PULL_GET_MEM_CTX(ndr);
11693                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reject, LIBNDR_FLAG_REF_ALLOC);
11694                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_reject));
11695                 if (_ptr_reject) {
11696                         NDR_PULL_ALLOC(ndr, *r->out.reject);
11697                 } else {
11698                         *r->out.reject = NULL;
11699                 }
11700                 if (*r->out.reject) {
11701                         _mem_save_reject_1 = NDR_PULL_GET_MEM_CTX(ndr);
11702                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.reject, 0);
11703                         NDR_CHECK(ndr_pull_samr_ChangeReject(ndr, NDR_SCALARS, *r->out.reject));
11704                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reject_1, 0);
11705                 }
11706                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reject_0, LIBNDR_FLAG_REF_ALLOC);
11707                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11708         }
11709         return NDR_ERR_SUCCESS;
11710 }
11711
11712 _PUBLIC_ void ndr_print_samr_ChangePasswordUser3(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser3 *r)
11713 {
11714         ndr_print_struct(ndr, name, "samr_ChangePasswordUser3");
11715         ndr->depth++;
11716         if (flags & NDR_SET_VALUES) {
11717                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11718         }
11719         if (flags & NDR_IN) {
11720                 ndr_print_struct(ndr, "in", "samr_ChangePasswordUser3");
11721                 ndr->depth++;
11722                 ndr_print_ptr(ndr, "server", r->in.server);
11723                 ndr->depth++;
11724                 if (r->in.server) {
11725                         ndr_print_lsa_String(ndr, "server", r->in.server);
11726                 }
11727                 ndr->depth--;
11728                 ndr_print_ptr(ndr, "account", r->in.account);
11729                 ndr->depth++;
11730                 ndr_print_lsa_String(ndr, "account", r->in.account);
11731                 ndr->depth--;
11732                 ndr_print_ptr(ndr, "nt_password", r->in.nt_password);
11733                 ndr->depth++;
11734                 if (r->in.nt_password) {
11735                         ndr_print_samr_CryptPassword(ndr, "nt_password", r->in.nt_password);
11736                 }
11737                 ndr->depth--;
11738                 ndr_print_ptr(ndr, "nt_verifier", r->in.nt_verifier);
11739                 ndr->depth++;
11740                 if (r->in.nt_verifier) {
11741                         ndr_print_samr_Password(ndr, "nt_verifier", r->in.nt_verifier);
11742                 }
11743                 ndr->depth--;
11744                 ndr_print_uint8(ndr, "lm_change", r->in.lm_change);
11745                 ndr_print_ptr(ndr, "lm_password", r->in.lm_password);
11746                 ndr->depth++;
11747                 if (r->in.lm_password) {
11748                         ndr_print_samr_CryptPassword(ndr, "lm_password", r->in.lm_password);
11749                 }
11750                 ndr->depth--;
11751                 ndr_print_ptr(ndr, "lm_verifier", r->in.lm_verifier);
11752                 ndr->depth++;
11753                 if (r->in.lm_verifier) {
11754                         ndr_print_samr_Password(ndr, "lm_verifier", r->in.lm_verifier);
11755                 }
11756                 ndr->depth--;
11757                 ndr_print_ptr(ndr, "password3", r->in.password3);
11758                 ndr->depth++;
11759                 if (r->in.password3) {
11760                         ndr_print_samr_CryptPassword(ndr, "password3", r->in.password3);
11761                 }
11762                 ndr->depth--;
11763                 ndr->depth--;
11764         }
11765         if (flags & NDR_OUT) {
11766                 ndr_print_struct(ndr, "out", "samr_ChangePasswordUser3");
11767                 ndr->depth++;
11768                 ndr_print_ptr(ndr, "dominfo", r->out.dominfo);
11769                 ndr->depth++;
11770                 ndr_print_ptr(ndr, "dominfo", *r->out.dominfo);
11771                 ndr->depth++;
11772                 if (*r->out.dominfo) {
11773                         ndr_print_samr_DomInfo1(ndr, "dominfo", *r->out.dominfo);
11774                 }
11775                 ndr->depth--;
11776                 ndr->depth--;
11777                 ndr_print_ptr(ndr, "reject", r->out.reject);
11778                 ndr->depth++;
11779                 ndr_print_ptr(ndr, "reject", *r->out.reject);
11780                 ndr->depth++;
11781                 if (*r->out.reject) {
11782                         ndr_print_samr_ChangeReject(ndr, "reject", *r->out.reject);
11783                 }
11784                 ndr->depth--;
11785                 ndr->depth--;
11786                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11787                 ndr->depth--;
11788         }
11789         ndr->depth--;
11790 }
11791
11792 _PUBLIC_ enum ndr_err_code ndr_push_samr_Connect5(struct ndr_push *ndr, int flags, const struct samr_Connect5 *r)
11793 {
11794         if (flags & NDR_IN) {
11795                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
11796                 if (r->in.system_name) {
11797                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11798                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11799                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11800                         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));
11801                 }
11802                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
11803                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level_in));
11804                 if (r->in.info_in == NULL) {
11805                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11806                 }
11807                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info_in, r->in.level_in));
11808                 NDR_CHECK(ndr_push_samr_ConnectInfo(ndr, NDR_SCALARS, r->in.info_in));
11809         }
11810         if (flags & NDR_OUT) {
11811                 if (r->out.level_out == NULL) {
11812                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11813                 }
11814                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
11815                 if (r->out.info_out == NULL) {
11816                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11817                 }
11818                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info_out, *r->out.level_out));
11819                 NDR_CHECK(ndr_push_samr_ConnectInfo(ndr, NDR_SCALARS, r->out.info_out));
11820                 if (r->out.connect_handle == NULL) {
11821                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11822                 }
11823                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11824                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11825         }
11826         return NDR_ERR_SUCCESS;
11827 }
11828
11829 _PUBLIC_ enum ndr_err_code ndr_pull_samr_Connect5(struct ndr_pull *ndr, int flags, struct samr_Connect5 *r)
11830 {
11831         uint32_t _ptr_system_name;
11832         TALLOC_CTX *_mem_save_system_name_0;
11833         TALLOC_CTX *_mem_save_info_in_0;
11834         TALLOC_CTX *_mem_save_level_out_0;
11835         TALLOC_CTX *_mem_save_info_out_0;
11836         TALLOC_CTX *_mem_save_connect_handle_0;
11837         if (flags & NDR_IN) {
11838                 ZERO_STRUCT(r->out);
11839
11840                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
11841                 if (_ptr_system_name) {
11842                         NDR_PULL_ALLOC(ndr, r->in.system_name);
11843                 } else {
11844                         r->in.system_name = NULL;
11845                 }
11846                 if (r->in.system_name) {
11847                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11848                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
11849                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
11850                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
11851                         if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
11852                                 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));
11853                         }
11854                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
11855                         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));
11856                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
11857                 }
11858                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
11859                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level_in));
11860                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11861                         NDR_PULL_ALLOC(ndr, r->in.info_in);
11862                 }
11863                 _mem_save_info_in_0 = NDR_PULL_GET_MEM_CTX(ndr);
11864                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_in, LIBNDR_FLAG_REF_ALLOC);
11865                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info_in, r->in.level_in));
11866                 NDR_CHECK(ndr_pull_samr_ConnectInfo(ndr, NDR_SCALARS, r->in.info_in));
11867                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_in_0, LIBNDR_FLAG_REF_ALLOC);
11868                 NDR_PULL_ALLOC(ndr, r->out.level_out);
11869                 ZERO_STRUCTP(r->out.level_out);
11870                 NDR_PULL_ALLOC(ndr, r->out.info_out);
11871                 ZERO_STRUCTP(r->out.info_out);
11872                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11873                 ZERO_STRUCTP(r->out.connect_handle);
11874         }
11875         if (flags & NDR_OUT) {
11876                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11877                         NDR_PULL_ALLOC(ndr, r->out.level_out);
11878                 }
11879                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
11880                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
11881                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
11882                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
11883                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11884                         NDR_PULL_ALLOC(ndr, r->out.info_out);
11885                 }
11886                 _mem_save_info_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
11887                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_out, LIBNDR_FLAG_REF_ALLOC);
11888                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info_out, *r->out.level_out));
11889                 NDR_CHECK(ndr_pull_samr_ConnectInfo(ndr, NDR_SCALARS, r->out.info_out));
11890                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_out_0, LIBNDR_FLAG_REF_ALLOC);
11891                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11892                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11893                 }
11894                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11895                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
11896                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11897                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
11898                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11899         }
11900         return NDR_ERR_SUCCESS;
11901 }
11902
11903 _PUBLIC_ void ndr_print_samr_Connect5(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect5 *r)
11904 {
11905         ndr_print_struct(ndr, name, "samr_Connect5");
11906         ndr->depth++;
11907         if (flags & NDR_SET_VALUES) {
11908                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11909         }
11910         if (flags & NDR_IN) {
11911                 ndr_print_struct(ndr, "in", "samr_Connect5");
11912                 ndr->depth++;
11913                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
11914                 ndr->depth++;
11915                 if (r->in.system_name) {
11916                         ndr_print_string(ndr, "system_name", r->in.system_name);
11917                 }
11918                 ndr->depth--;
11919                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
11920                 ndr_print_uint32(ndr, "level_in", r->in.level_in);
11921                 ndr_print_ptr(ndr, "info_in", r->in.info_in);
11922                 ndr->depth++;
11923                 ndr_print_set_switch_value(ndr, r->in.info_in, r->in.level_in);
11924                 ndr_print_samr_ConnectInfo(ndr, "info_in", r->in.info_in);
11925                 ndr->depth--;
11926                 ndr->depth--;
11927         }
11928         if (flags & NDR_OUT) {
11929                 ndr_print_struct(ndr, "out", "samr_Connect5");
11930                 ndr->depth++;
11931                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
11932                 ndr->depth++;
11933                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
11934                 ndr->depth--;
11935                 ndr_print_ptr(ndr, "info_out", r->out.info_out);
11936                 ndr->depth++;
11937                 ndr_print_set_switch_value(ndr, r->out.info_out, *r->out.level_out);
11938                 ndr_print_samr_ConnectInfo(ndr, "info_out", r->out.info_out);
11939                 ndr->depth--;
11940                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
11941                 ndr->depth++;
11942                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
11943                 ndr->depth--;
11944                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11945                 ndr->depth--;
11946         }
11947         ndr->depth--;
11948 }
11949
11950 static enum ndr_err_code ndr_push_samr_RidToSid(struct ndr_push *ndr, int flags, const struct samr_RidToSid *r)
11951 {
11952         if (flags & NDR_IN) {
11953                 if (r->in.domain_handle == NULL) {
11954                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11955                 }
11956                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
11957                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
11958         }
11959         if (flags & NDR_OUT) {
11960                 if (r->out.sid == NULL) {
11961                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11962                 }
11963                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sid));
11964                 if (*r->out.sid) {
11965                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
11966                 }
11967                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11968         }
11969         return NDR_ERR_SUCCESS;
11970 }
11971
11972 static enum ndr_err_code ndr_pull_samr_RidToSid(struct ndr_pull *ndr, int flags, struct samr_RidToSid *r)
11973 {
11974         uint32_t _ptr_sid;
11975         TALLOC_CTX *_mem_save_domain_handle_0;
11976         TALLOC_CTX *_mem_save_sid_0;
11977         TALLOC_CTX *_mem_save_sid_1;
11978         if (flags & NDR_IN) {
11979                 ZERO_STRUCT(r->out);
11980
11981                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11982                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
11983                 }
11984                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11985                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
11986                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
11987                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
11988                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
11989                 NDR_PULL_ALLOC(ndr, r->out.sid);
11990                 ZERO_STRUCTP(r->out.sid);
11991         }
11992         if (flags & NDR_OUT) {
11993                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11994                         NDR_PULL_ALLOC(ndr, r->out.sid);
11995                 }
11996                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
11997                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);
11998                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
11999                 if (_ptr_sid) {
12000                         NDR_PULL_ALLOC(ndr, *r->out.sid);
12001                 } else {
12002                         *r->out.sid = NULL;
12003                 }
12004                 if (*r->out.sid) {
12005                         _mem_save_sid_1 = NDR_PULL_GET_MEM_CTX(ndr);
12006                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sid, 0);
12007                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
12008                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_1, 0);
12009                 }
12010                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
12011                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12012         }
12013         return NDR_ERR_SUCCESS;
12014 }
12015
12016 _PUBLIC_ void ndr_print_samr_RidToSid(struct ndr_print *ndr, const char *name, int flags, const struct samr_RidToSid *r)
12017 {
12018         ndr_print_struct(ndr, name, "samr_RidToSid");
12019         ndr->depth++;
12020         if (flags & NDR_SET_VALUES) {
12021                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12022         }
12023         if (flags & NDR_IN) {
12024                 ndr_print_struct(ndr, "in", "samr_RidToSid");
12025                 ndr->depth++;
12026                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
12027                 ndr->depth++;
12028                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
12029                 ndr->depth--;
12030                 ndr_print_uint32(ndr, "rid", r->in.rid);
12031                 ndr->depth--;
12032         }
12033         if (flags & NDR_OUT) {
12034                 ndr_print_struct(ndr, "out", "samr_RidToSid");
12035                 ndr->depth++;
12036                 ndr_print_ptr(ndr, "sid", r->out.sid);
12037                 ndr->depth++;
12038                 ndr_print_ptr(ndr, "sid", *r->out.sid);
12039                 ndr->depth++;
12040                 if (*r->out.sid) {
12041                         ndr_print_dom_sid2(ndr, "sid", *r->out.sid);
12042                 }
12043                 ndr->depth--;
12044                 ndr->depth--;
12045                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12046                 ndr->depth--;
12047         }
12048         ndr->depth--;
12049 }
12050
12051 static enum ndr_err_code ndr_push_samr_SetDsrmPassword(struct ndr_push *ndr, int flags, const struct samr_SetDsrmPassword *r)
12052 {
12053         if (flags & NDR_IN) {
12054                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.name));
12055                 if (r->in.name) {
12056                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
12057                 }
12058                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
12059                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hash));
12060                 if (r->in.hash) {
12061                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.hash));
12062                 }
12063         }
12064         if (flags & NDR_OUT) {
12065                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12066         }
12067         return NDR_ERR_SUCCESS;
12068 }
12069
12070 static enum ndr_err_code ndr_pull_samr_SetDsrmPassword(struct ndr_pull *ndr, int flags, struct samr_SetDsrmPassword *r)
12071 {
12072         uint32_t _ptr_name;
12073         uint32_t _ptr_hash;
12074         TALLOC_CTX *_mem_save_name_0;
12075         TALLOC_CTX *_mem_save_hash_0;
12076         if (flags & NDR_IN) {
12077                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
12078                 if (_ptr_name) {
12079                         NDR_PULL_ALLOC(ndr, r->in.name);
12080                 } else {
12081                         r->in.name = NULL;
12082                 }
12083                 if (r->in.name) {
12084                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12085                         NDR_PULL_SET_MEM_CTX(ndr, r->in.name, 0);
12086                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
12087                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
12088                 }
12089                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
12090                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hash));
12091                 if (_ptr_hash) {
12092                         NDR_PULL_ALLOC(ndr, r->in.hash);
12093                 } else {
12094                         r->in.hash = NULL;
12095                 }
12096                 if (r->in.hash) {
12097                         _mem_save_hash_0 = NDR_PULL_GET_MEM_CTX(ndr);
12098                         NDR_PULL_SET_MEM_CTX(ndr, r->in.hash, 0);
12099                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.hash));
12100                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hash_0, 0);
12101                 }
12102         }
12103         if (flags & NDR_OUT) {
12104                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12105         }
12106         return NDR_ERR_SUCCESS;
12107 }
12108
12109 _PUBLIC_ void ndr_print_samr_SetDsrmPassword(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetDsrmPassword *r)
12110 {
12111         ndr_print_struct(ndr, name, "samr_SetDsrmPassword");
12112         ndr->depth++;
12113         if (flags & NDR_SET_VALUES) {
12114                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12115         }
12116         if (flags & NDR_IN) {
12117                 ndr_print_struct(ndr, "in", "samr_SetDsrmPassword");
12118                 ndr->depth++;
12119                 ndr_print_ptr(ndr, "name", r->in.name);
12120                 ndr->depth++;
12121                 if (r->in.name) {
12122                         ndr_print_lsa_String(ndr, "name", r->in.name);
12123                 }
12124                 ndr->depth--;
12125                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
12126                 ndr_print_ptr(ndr, "hash", r->in.hash);
12127                 ndr->depth++;
12128                 if (r->in.hash) {
12129                         ndr_print_samr_Password(ndr, "hash", r->in.hash);
12130                 }
12131                 ndr->depth--;
12132                 ndr->depth--;
12133         }
12134         if (flags & NDR_OUT) {
12135                 ndr_print_struct(ndr, "out", "samr_SetDsrmPassword");
12136                 ndr->depth++;
12137                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12138                 ndr->depth--;
12139         }
12140         ndr->depth--;
12141 }
12142
12143 static enum ndr_err_code ndr_push_samr_ValidatePassword(struct ndr_push *ndr, int flags, const struct samr_ValidatePassword *r)
12144 {
12145         if (flags & NDR_IN) {
12146                 NDR_CHECK(ndr_push_samr_ValidatePasswordLevel(ndr, NDR_SCALARS, r->in.level));
12147                 if (r->in.req == NULL) {
12148                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12149                 }
12150                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
12151                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
12152         }
12153         if (flags & NDR_OUT) {
12154                 if (r->out.rep == NULL) {
12155                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12156                 }
12157                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rep));
12158                 if (*r->out.rep) {
12159                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.rep, r->in.level));
12160                         NDR_CHECK(ndr_push_samr_ValidatePasswordRep(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rep));
12161                 }
12162                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12163         }
12164         return NDR_ERR_SUCCESS;
12165 }
12166
12167 static enum ndr_err_code ndr_pull_samr_ValidatePassword(struct ndr_pull *ndr, int flags, struct samr_ValidatePassword *r)
12168 {
12169         uint32_t _ptr_rep;
12170         TALLOC_CTX *_mem_save_req_0;
12171         TALLOC_CTX *_mem_save_rep_0;
12172         TALLOC_CTX *_mem_save_rep_1;
12173         if (flags & NDR_IN) {
12174                 ZERO_STRUCT(r->out);
12175
12176                 NDR_CHECK(ndr_pull_samr_ValidatePasswordLevel(ndr, NDR_SCALARS, &r->in.level));
12177                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12178                         NDR_PULL_ALLOC(ndr, r->in.req);
12179                 }
12180                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
12181                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
12182                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
12183                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
12184                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
12185                 NDR_PULL_ALLOC(ndr, r->out.rep);
12186                 ZERO_STRUCTP(r->out.rep);
12187         }
12188         if (flags & NDR_OUT) {
12189                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12190                         NDR_PULL_ALLOC(ndr, r->out.rep);
12191                 }
12192                 _mem_save_rep_0 = NDR_PULL_GET_MEM_CTX(ndr);
12193                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rep, LIBNDR_FLAG_REF_ALLOC);
12194                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rep));
12195                 if (_ptr_rep) {
12196                         NDR_PULL_ALLOC(ndr, *r->out.rep);
12197                 } else {
12198                         *r->out.rep = NULL;
12199                 }
12200                 if (*r->out.rep) {
12201                         _mem_save_rep_1 = NDR_PULL_GET_MEM_CTX(ndr);
12202                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.rep, 0);
12203                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.rep, r->in.level));
12204                         NDR_CHECK(ndr_pull_samr_ValidatePasswordRep(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rep));
12205                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rep_1, 0);
12206                 }
12207                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rep_0, LIBNDR_FLAG_REF_ALLOC);
12208                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12209         }
12210         return NDR_ERR_SUCCESS;
12211 }
12212
12213 _PUBLIC_ void ndr_print_samr_ValidatePassword(struct ndr_print *ndr, const char *name, int flags, const struct samr_ValidatePassword *r)
12214 {
12215         ndr_print_struct(ndr, name, "samr_ValidatePassword");
12216         ndr->depth++;
12217         if (flags & NDR_SET_VALUES) {
12218                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12219         }
12220         if (flags & NDR_IN) {
12221                 ndr_print_struct(ndr, "in", "samr_ValidatePassword");
12222                 ndr->depth++;
12223                 ndr_print_samr_ValidatePasswordLevel(ndr, "level", r->in.level);
12224                 ndr_print_ptr(ndr, "req", r->in.req);
12225                 ndr->depth++;
12226                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
12227                 ndr_print_samr_ValidatePasswordReq(ndr, "req", r->in.req);
12228                 ndr->depth--;
12229                 ndr->depth--;
12230         }
12231         if (flags & NDR_OUT) {
12232                 ndr_print_struct(ndr, "out", "samr_ValidatePassword");
12233                 ndr->depth++;
12234                 ndr_print_ptr(ndr, "rep", r->out.rep);
12235                 ndr->depth++;
12236                 ndr_print_ptr(ndr, "rep", *r->out.rep);
12237                 ndr->depth++;
12238                 if (*r->out.rep) {
12239                         ndr_print_set_switch_value(ndr, *r->out.rep, r->in.level);
12240                         ndr_print_samr_ValidatePasswordRep(ndr, "rep", *r->out.rep);
12241                 }
12242                 ndr->depth--;
12243                 ndr->depth--;
12244                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12245                 ndr->depth--;
12246         }
12247         ndr->depth--;
12248 }
12249
12250 static const struct ndr_interface_call samr_calls[] = {
12251         {
12252                 "samr_Connect",
12253                 sizeof(struct samr_Connect),
12254                 (ndr_push_flags_fn_t) ndr_push_samr_Connect,
12255                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect,
12256                 (ndr_print_function_t) ndr_print_samr_Connect,
12257                 false,
12258         },
12259         {
12260                 "samr_Close",
12261                 sizeof(struct samr_Close),
12262                 (ndr_push_flags_fn_t) ndr_push_samr_Close,
12263                 (ndr_pull_flags_fn_t) ndr_pull_samr_Close,
12264                 (ndr_print_function_t) ndr_print_samr_Close,
12265                 false,
12266         },
12267         {
12268                 "samr_SetSecurity",
12269                 sizeof(struct samr_SetSecurity),
12270                 (ndr_push_flags_fn_t) ndr_push_samr_SetSecurity,
12271                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetSecurity,
12272                 (ndr_print_function_t) ndr_print_samr_SetSecurity,
12273                 false,
12274         },
12275         {
12276                 "samr_QuerySecurity",
12277                 sizeof(struct samr_QuerySecurity),
12278                 (ndr_push_flags_fn_t) ndr_push_samr_QuerySecurity,
12279                 (ndr_pull_flags_fn_t) ndr_pull_samr_QuerySecurity,
12280                 (ndr_print_function_t) ndr_print_samr_QuerySecurity,
12281                 false,
12282         },
12283         {
12284                 "samr_Shutdown",
12285                 sizeof(struct samr_Shutdown),
12286                 (ndr_push_flags_fn_t) ndr_push_samr_Shutdown,
12287                 (ndr_pull_flags_fn_t) ndr_pull_samr_Shutdown,
12288                 (ndr_print_function_t) ndr_print_samr_Shutdown,
12289                 false,
12290         },
12291         {
12292                 "samr_LookupDomain",
12293                 sizeof(struct samr_LookupDomain),
12294                 (ndr_push_flags_fn_t) ndr_push_samr_LookupDomain,
12295                 (ndr_pull_flags_fn_t) ndr_pull_samr_LookupDomain,
12296                 (ndr_print_function_t) ndr_print_samr_LookupDomain,
12297                 false,
12298         },
12299         {
12300                 "samr_EnumDomains",
12301                 sizeof(struct samr_EnumDomains),
12302                 (ndr_push_flags_fn_t) ndr_push_samr_EnumDomains,
12303                 (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomains,
12304                 (ndr_print_function_t) ndr_print_samr_EnumDomains,
12305                 false,
12306         },
12307         {
12308                 "samr_OpenDomain",
12309                 sizeof(struct samr_OpenDomain),
12310                 (ndr_push_flags_fn_t) ndr_push_samr_OpenDomain,
12311                 (ndr_pull_flags_fn_t) ndr_pull_samr_OpenDomain,
12312                 (ndr_print_function_t) ndr_print_samr_OpenDomain,
12313                 false,
12314         },
12315         {
12316                 "samr_QueryDomainInfo",
12317                 sizeof(struct samr_QueryDomainInfo),
12318                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDomainInfo,
12319                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDomainInfo,
12320                 (ndr_print_function_t) ndr_print_samr_QueryDomainInfo,
12321                 false,
12322         },
12323         {
12324                 "samr_SetDomainInfo",
12325                 sizeof(struct samr_SetDomainInfo),
12326                 (ndr_push_flags_fn_t) ndr_push_samr_SetDomainInfo,
12327                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetDomainInfo,
12328                 (ndr_print_function_t) ndr_print_samr_SetDomainInfo,
12329                 false,
12330         },
12331         {
12332                 "samr_CreateDomainGroup",
12333                 sizeof(struct samr_CreateDomainGroup),
12334                 (ndr_push_flags_fn_t) ndr_push_samr_CreateDomainGroup,
12335                 (ndr_pull_flags_fn_t) ndr_pull_samr_CreateDomainGroup,
12336                 (ndr_print_function_t) ndr_print_samr_CreateDomainGroup,
12337                 false,
12338         },
12339         {
12340                 "samr_EnumDomainGroups",
12341                 sizeof(struct samr_EnumDomainGroups),
12342                 (ndr_push_flags_fn_t) ndr_push_samr_EnumDomainGroups,
12343                 (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainGroups,
12344                 (ndr_print_function_t) ndr_print_samr_EnumDomainGroups,
12345                 false,
12346         },
12347         {
12348                 "samr_CreateUser",
12349                 sizeof(struct samr_CreateUser),
12350                 (ndr_push_flags_fn_t) ndr_push_samr_CreateUser,
12351                 (ndr_pull_flags_fn_t) ndr_pull_samr_CreateUser,
12352                 (ndr_print_function_t) ndr_print_samr_CreateUser,
12353                 false,
12354         },
12355         {
12356                 "samr_EnumDomainUsers",
12357                 sizeof(struct samr_EnumDomainUsers),
12358                 (ndr_push_flags_fn_t) ndr_push_samr_EnumDomainUsers,
12359                 (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainUsers,
12360                 (ndr_print_function_t) ndr_print_samr_EnumDomainUsers,
12361                 false,
12362         },
12363         {
12364                 "samr_CreateDomAlias",
12365                 sizeof(struct samr_CreateDomAlias),
12366                 (ndr_push_flags_fn_t) ndr_push_samr_CreateDomAlias,
12367                 (ndr_pull_flags_fn_t) ndr_pull_samr_CreateDomAlias,
12368                 (ndr_print_function_t) ndr_print_samr_CreateDomAlias,
12369                 false,
12370         },
12371         {
12372                 "samr_EnumDomainAliases",
12373                 sizeof(struct samr_EnumDomainAliases),
12374                 (ndr_push_flags_fn_t) ndr_push_samr_EnumDomainAliases,
12375                 (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainAliases,
12376                 (ndr_print_function_t) ndr_print_samr_EnumDomainAliases,
12377                 false,
12378         },
12379         {
12380                 "samr_GetAliasMembership",
12381                 sizeof(struct samr_GetAliasMembership),
12382                 (ndr_push_flags_fn_t) ndr_push_samr_GetAliasMembership,
12383                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetAliasMembership,
12384                 (ndr_print_function_t) ndr_print_samr_GetAliasMembership,
12385                 false,
12386         },
12387         {
12388                 "samr_LookupNames",
12389                 sizeof(struct samr_LookupNames),
12390                 (ndr_push_flags_fn_t) ndr_push_samr_LookupNames,
12391                 (ndr_pull_flags_fn_t) ndr_pull_samr_LookupNames,
12392                 (ndr_print_function_t) ndr_print_samr_LookupNames,
12393                 false,
12394         },
12395         {
12396                 "samr_LookupRids",
12397                 sizeof(struct samr_LookupRids),
12398                 (ndr_push_flags_fn_t) ndr_push_samr_LookupRids,
12399                 (ndr_pull_flags_fn_t) ndr_pull_samr_LookupRids,
12400                 (ndr_print_function_t) ndr_print_samr_LookupRids,
12401                 false,
12402         },
12403         {
12404                 "samr_OpenGroup",
12405                 sizeof(struct samr_OpenGroup),
12406                 (ndr_push_flags_fn_t) ndr_push_samr_OpenGroup,
12407                 (ndr_pull_flags_fn_t) ndr_pull_samr_OpenGroup,
12408                 (ndr_print_function_t) ndr_print_samr_OpenGroup,
12409                 false,
12410         },
12411         {
12412                 "samr_QueryGroupInfo",
12413                 sizeof(struct samr_QueryGroupInfo),
12414                 (ndr_push_flags_fn_t) ndr_push_samr_QueryGroupInfo,
12415                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryGroupInfo,
12416                 (ndr_print_function_t) ndr_print_samr_QueryGroupInfo,
12417                 false,
12418         },
12419         {
12420                 "samr_SetGroupInfo",
12421                 sizeof(struct samr_SetGroupInfo),
12422                 (ndr_push_flags_fn_t) ndr_push_samr_SetGroupInfo,
12423                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetGroupInfo,
12424                 (ndr_print_function_t) ndr_print_samr_SetGroupInfo,
12425                 false,
12426         },
12427         {
12428                 "samr_AddGroupMember",
12429                 sizeof(struct samr_AddGroupMember),
12430                 (ndr_push_flags_fn_t) ndr_push_samr_AddGroupMember,
12431                 (ndr_pull_flags_fn_t) ndr_pull_samr_AddGroupMember,
12432                 (ndr_print_function_t) ndr_print_samr_AddGroupMember,
12433                 false,
12434         },
12435         {
12436                 "samr_DeleteDomainGroup",
12437                 sizeof(struct samr_DeleteDomainGroup),
12438                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteDomainGroup,
12439                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteDomainGroup,
12440                 (ndr_print_function_t) ndr_print_samr_DeleteDomainGroup,
12441                 false,
12442         },
12443         {
12444                 "samr_DeleteGroupMember",
12445                 sizeof(struct samr_DeleteGroupMember),
12446                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteGroupMember,
12447                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteGroupMember,
12448                 (ndr_print_function_t) ndr_print_samr_DeleteGroupMember,
12449                 false,
12450         },
12451         {
12452                 "samr_QueryGroupMember",
12453                 sizeof(struct samr_QueryGroupMember),
12454                 (ndr_push_flags_fn_t) ndr_push_samr_QueryGroupMember,
12455                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryGroupMember,
12456                 (ndr_print_function_t) ndr_print_samr_QueryGroupMember,
12457                 false,
12458         },
12459         {
12460                 "samr_SetMemberAttributesOfGroup",
12461                 sizeof(struct samr_SetMemberAttributesOfGroup),
12462                 (ndr_push_flags_fn_t) ndr_push_samr_SetMemberAttributesOfGroup,
12463                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetMemberAttributesOfGroup,
12464                 (ndr_print_function_t) ndr_print_samr_SetMemberAttributesOfGroup,
12465                 false,
12466         },
12467         {
12468                 "samr_OpenAlias",
12469                 sizeof(struct samr_OpenAlias),
12470                 (ndr_push_flags_fn_t) ndr_push_samr_OpenAlias,
12471                 (ndr_pull_flags_fn_t) ndr_pull_samr_OpenAlias,
12472                 (ndr_print_function_t) ndr_print_samr_OpenAlias,
12473                 false,
12474         },
12475         {
12476                 "samr_QueryAliasInfo",
12477                 sizeof(struct samr_QueryAliasInfo),
12478                 (ndr_push_flags_fn_t) ndr_push_samr_QueryAliasInfo,
12479                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryAliasInfo,
12480                 (ndr_print_function_t) ndr_print_samr_QueryAliasInfo,
12481                 false,
12482         },
12483         {
12484                 "samr_SetAliasInfo",
12485                 sizeof(struct samr_SetAliasInfo),
12486                 (ndr_push_flags_fn_t) ndr_push_samr_SetAliasInfo,
12487                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetAliasInfo,
12488                 (ndr_print_function_t) ndr_print_samr_SetAliasInfo,
12489                 false,
12490         },
12491         {
12492                 "samr_DeleteDomAlias",
12493                 sizeof(struct samr_DeleteDomAlias),
12494                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteDomAlias,
12495                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteDomAlias,
12496                 (ndr_print_function_t) ndr_print_samr_DeleteDomAlias,
12497                 false,
12498         },
12499         {
12500                 "samr_AddAliasMember",
12501                 sizeof(struct samr_AddAliasMember),
12502                 (ndr_push_flags_fn_t) ndr_push_samr_AddAliasMember,
12503                 (ndr_pull_flags_fn_t) ndr_pull_samr_AddAliasMember,
12504                 (ndr_print_function_t) ndr_print_samr_AddAliasMember,
12505                 false,
12506         },
12507         {
12508                 "samr_DeleteAliasMember",
12509                 sizeof(struct samr_DeleteAliasMember),
12510                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteAliasMember,
12511                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteAliasMember,
12512                 (ndr_print_function_t) ndr_print_samr_DeleteAliasMember,
12513                 false,
12514         },
12515         {
12516                 "samr_GetMembersInAlias",
12517                 sizeof(struct samr_GetMembersInAlias),
12518                 (ndr_push_flags_fn_t) ndr_push_samr_GetMembersInAlias,
12519                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetMembersInAlias,
12520                 (ndr_print_function_t) ndr_print_samr_GetMembersInAlias,
12521                 false,
12522         },
12523         {
12524                 "samr_OpenUser",
12525                 sizeof(struct samr_OpenUser),
12526                 (ndr_push_flags_fn_t) ndr_push_samr_OpenUser,
12527                 (ndr_pull_flags_fn_t) ndr_pull_samr_OpenUser,
12528                 (ndr_print_function_t) ndr_print_samr_OpenUser,
12529                 false,
12530         },
12531         {
12532                 "samr_DeleteUser",
12533                 sizeof(struct samr_DeleteUser),
12534                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteUser,
12535                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteUser,
12536                 (ndr_print_function_t) ndr_print_samr_DeleteUser,
12537                 false,
12538         },
12539         {
12540                 "samr_QueryUserInfo",
12541                 sizeof(struct samr_QueryUserInfo),
12542                 (ndr_push_flags_fn_t) ndr_push_samr_QueryUserInfo,
12543                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryUserInfo,
12544                 (ndr_print_function_t) ndr_print_samr_QueryUserInfo,
12545                 false,
12546         },
12547         {
12548                 "samr_SetUserInfo",
12549                 sizeof(struct samr_SetUserInfo),
12550                 (ndr_push_flags_fn_t) ndr_push_samr_SetUserInfo,
12551                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetUserInfo,
12552                 (ndr_print_function_t) ndr_print_samr_SetUserInfo,
12553                 false,
12554         },
12555         {
12556                 "samr_ChangePasswordUser",
12557                 sizeof(struct samr_ChangePasswordUser),
12558                 (ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser,
12559                 (ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser,
12560                 (ndr_print_function_t) ndr_print_samr_ChangePasswordUser,
12561                 false,
12562         },
12563         {
12564                 "samr_GetGroupsForUser",
12565                 sizeof(struct samr_GetGroupsForUser),
12566                 (ndr_push_flags_fn_t) ndr_push_samr_GetGroupsForUser,
12567                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetGroupsForUser,
12568                 (ndr_print_function_t) ndr_print_samr_GetGroupsForUser,
12569                 false,
12570         },
12571         {
12572                 "samr_QueryDisplayInfo",
12573                 sizeof(struct samr_QueryDisplayInfo),
12574                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo,
12575                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo,
12576                 (ndr_print_function_t) ndr_print_samr_QueryDisplayInfo,
12577                 false,
12578         },
12579         {
12580                 "samr_GetDisplayEnumerationIndex",
12581                 sizeof(struct samr_GetDisplayEnumerationIndex),
12582                 (ndr_push_flags_fn_t) ndr_push_samr_GetDisplayEnumerationIndex,
12583                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetDisplayEnumerationIndex,
12584                 (ndr_print_function_t) ndr_print_samr_GetDisplayEnumerationIndex,
12585                 false,
12586         },
12587         {
12588                 "samr_TestPrivateFunctionsDomain",
12589                 sizeof(struct samr_TestPrivateFunctionsDomain),
12590                 (ndr_push_flags_fn_t) ndr_push_samr_TestPrivateFunctionsDomain,
12591                 (ndr_pull_flags_fn_t) ndr_pull_samr_TestPrivateFunctionsDomain,
12592                 (ndr_print_function_t) ndr_print_samr_TestPrivateFunctionsDomain,
12593                 false,
12594         },
12595         {
12596                 "samr_TestPrivateFunctionsUser",
12597                 sizeof(struct samr_TestPrivateFunctionsUser),
12598                 (ndr_push_flags_fn_t) ndr_push_samr_TestPrivateFunctionsUser,
12599                 (ndr_pull_flags_fn_t) ndr_pull_samr_TestPrivateFunctionsUser,
12600                 (ndr_print_function_t) ndr_print_samr_TestPrivateFunctionsUser,
12601                 false,
12602         },
12603         {
12604                 "samr_GetUserPwInfo",
12605                 sizeof(struct samr_GetUserPwInfo),
12606                 (ndr_push_flags_fn_t) ndr_push_samr_GetUserPwInfo,
12607                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetUserPwInfo,
12608                 (ndr_print_function_t) ndr_print_samr_GetUserPwInfo,
12609                 false,
12610         },
12611         {
12612                 "samr_RemoveMemberFromForeignDomain",
12613                 sizeof(struct samr_RemoveMemberFromForeignDomain),
12614                 (ndr_push_flags_fn_t) ndr_push_samr_RemoveMemberFromForeignDomain,
12615                 (ndr_pull_flags_fn_t) ndr_pull_samr_RemoveMemberFromForeignDomain,
12616                 (ndr_print_function_t) ndr_print_samr_RemoveMemberFromForeignDomain,
12617                 false,
12618         },
12619         {
12620                 "samr_QueryDomainInfo2",
12621                 sizeof(struct samr_QueryDomainInfo2),
12622                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDomainInfo2,
12623                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDomainInfo2,
12624                 (ndr_print_function_t) ndr_print_samr_QueryDomainInfo2,
12625                 false,
12626         },
12627         {
12628                 "samr_QueryUserInfo2",
12629                 sizeof(struct samr_QueryUserInfo2),
12630                 (ndr_push_flags_fn_t) ndr_push_samr_QueryUserInfo2,
12631                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryUserInfo2,
12632                 (ndr_print_function_t) ndr_print_samr_QueryUserInfo2,
12633                 false,
12634         },
12635         {
12636                 "samr_QueryDisplayInfo2",
12637                 sizeof(struct samr_QueryDisplayInfo2),
12638                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo2,
12639                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo2,
12640                 (ndr_print_function_t) ndr_print_samr_QueryDisplayInfo2,
12641                 false,
12642         },
12643         {
12644                 "samr_GetDisplayEnumerationIndex2",
12645                 sizeof(struct samr_GetDisplayEnumerationIndex2),
12646                 (ndr_push_flags_fn_t) ndr_push_samr_GetDisplayEnumerationIndex2,
12647                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetDisplayEnumerationIndex2,
12648                 (ndr_print_function_t) ndr_print_samr_GetDisplayEnumerationIndex2,
12649                 false,
12650         },
12651         {
12652                 "samr_CreateUser2",
12653                 sizeof(struct samr_CreateUser2),
12654                 (ndr_push_flags_fn_t) ndr_push_samr_CreateUser2,
12655                 (ndr_pull_flags_fn_t) ndr_pull_samr_CreateUser2,
12656                 (ndr_print_function_t) ndr_print_samr_CreateUser2,
12657                 false,
12658         },
12659         {
12660                 "samr_QueryDisplayInfo3",
12661                 sizeof(struct samr_QueryDisplayInfo3),
12662                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo3,
12663                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo3,
12664                 (ndr_print_function_t) ndr_print_samr_QueryDisplayInfo3,
12665                 false,
12666         },
12667         {
12668                 "samr_AddMultipleMembersToAlias",
12669                 sizeof(struct samr_AddMultipleMembersToAlias),
12670                 (ndr_push_flags_fn_t) ndr_push_samr_AddMultipleMembersToAlias,
12671                 (ndr_pull_flags_fn_t) ndr_pull_samr_AddMultipleMembersToAlias,
12672                 (ndr_print_function_t) ndr_print_samr_AddMultipleMembersToAlias,
12673                 false,
12674         },
12675         {
12676                 "samr_RemoveMultipleMembersFromAlias",
12677                 sizeof(struct samr_RemoveMultipleMembersFromAlias),
12678                 (ndr_push_flags_fn_t) ndr_push_samr_RemoveMultipleMembersFromAlias,
12679                 (ndr_pull_flags_fn_t) ndr_pull_samr_RemoveMultipleMembersFromAlias,
12680                 (ndr_print_function_t) ndr_print_samr_RemoveMultipleMembersFromAlias,
12681                 false,
12682         },
12683         {
12684                 "samr_OemChangePasswordUser2",
12685                 sizeof(struct samr_OemChangePasswordUser2),
12686                 (ndr_push_flags_fn_t) ndr_push_samr_OemChangePasswordUser2,
12687                 (ndr_pull_flags_fn_t) ndr_pull_samr_OemChangePasswordUser2,
12688                 (ndr_print_function_t) ndr_print_samr_OemChangePasswordUser2,
12689                 false,
12690         },
12691         {
12692                 "samr_ChangePasswordUser2",
12693                 sizeof(struct samr_ChangePasswordUser2),
12694                 (ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser2,
12695                 (ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser2,
12696                 (ndr_print_function_t) ndr_print_samr_ChangePasswordUser2,
12697                 false,
12698         },
12699         {
12700                 "samr_GetDomPwInfo",
12701                 sizeof(struct samr_GetDomPwInfo),
12702                 (ndr_push_flags_fn_t) ndr_push_samr_GetDomPwInfo,
12703                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetDomPwInfo,
12704                 (ndr_print_function_t) ndr_print_samr_GetDomPwInfo,
12705                 false,
12706         },
12707         {
12708                 "samr_Connect2",
12709                 sizeof(struct samr_Connect2),
12710                 (ndr_push_flags_fn_t) ndr_push_samr_Connect2,
12711                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect2,
12712                 (ndr_print_function_t) ndr_print_samr_Connect2,
12713                 false,
12714         },
12715         {
12716                 "samr_SetUserInfo2",
12717                 sizeof(struct samr_SetUserInfo2),
12718                 (ndr_push_flags_fn_t) ndr_push_samr_SetUserInfo2,
12719                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetUserInfo2,
12720                 (ndr_print_function_t) ndr_print_samr_SetUserInfo2,
12721                 false,
12722         },
12723         {
12724                 "samr_SetBootKeyInformation",
12725                 sizeof(struct samr_SetBootKeyInformation),
12726                 (ndr_push_flags_fn_t) ndr_push_samr_SetBootKeyInformation,
12727                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetBootKeyInformation,
12728                 (ndr_print_function_t) ndr_print_samr_SetBootKeyInformation,
12729                 false,
12730         },
12731         {
12732                 "samr_GetBootKeyInformation",
12733                 sizeof(struct samr_GetBootKeyInformation),
12734                 (ndr_push_flags_fn_t) ndr_push_samr_GetBootKeyInformation,
12735                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetBootKeyInformation,
12736                 (ndr_print_function_t) ndr_print_samr_GetBootKeyInformation,
12737                 false,
12738         },
12739         {
12740                 "samr_Connect3",
12741                 sizeof(struct samr_Connect3),
12742                 (ndr_push_flags_fn_t) ndr_push_samr_Connect3,
12743                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect3,
12744                 (ndr_print_function_t) ndr_print_samr_Connect3,
12745                 false,
12746         },
12747         {
12748                 "samr_Connect4",
12749                 sizeof(struct samr_Connect4),
12750                 (ndr_push_flags_fn_t) ndr_push_samr_Connect4,
12751                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect4,
12752                 (ndr_print_function_t) ndr_print_samr_Connect4,
12753                 false,
12754         },
12755         {
12756                 "samr_ChangePasswordUser3",
12757                 sizeof(struct samr_ChangePasswordUser3),
12758                 (ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser3,
12759                 (ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser3,
12760                 (ndr_print_function_t) ndr_print_samr_ChangePasswordUser3,
12761                 false,
12762         },
12763         {
12764                 "samr_Connect5",
12765                 sizeof(struct samr_Connect5),
12766                 (ndr_push_flags_fn_t) ndr_push_samr_Connect5,
12767                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect5,
12768                 (ndr_print_function_t) ndr_print_samr_Connect5,
12769                 false,
12770         },
12771         {
12772                 "samr_RidToSid",
12773                 sizeof(struct samr_RidToSid),
12774                 (ndr_push_flags_fn_t) ndr_push_samr_RidToSid,
12775                 (ndr_pull_flags_fn_t) ndr_pull_samr_RidToSid,
12776                 (ndr_print_function_t) ndr_print_samr_RidToSid,
12777                 false,
12778         },
12779         {
12780                 "samr_SetDsrmPassword",
12781                 sizeof(struct samr_SetDsrmPassword),
12782                 (ndr_push_flags_fn_t) ndr_push_samr_SetDsrmPassword,
12783                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetDsrmPassword,
12784                 (ndr_print_function_t) ndr_print_samr_SetDsrmPassword,
12785                 false,
12786         },
12787         {
12788                 "samr_ValidatePassword",
12789                 sizeof(struct samr_ValidatePassword),
12790                 (ndr_push_flags_fn_t) ndr_push_samr_ValidatePassword,
12791                 (ndr_pull_flags_fn_t) ndr_pull_samr_ValidatePassword,
12792                 (ndr_print_function_t) ndr_print_samr_ValidatePassword,
12793                 false,
12794         },
12795         { NULL, 0, NULL, NULL, NULL, false }
12796 };
12797
12798 static const char * const samr_endpoint_strings[] = {
12799         "ncacn_np:[\\pipe\\samr]",
12800         "ncacn_ip_tcp:",
12801         "ncalrpc:",
12802 };
12803
12804 static const struct ndr_interface_string_array samr_endpoints = {
12805         .count  = 3,
12806         .names  = samr_endpoint_strings
12807 };
12808
12809 static const char * const samr_authservice_strings[] = {
12810         "host",
12811 };
12812
12813 static const struct ndr_interface_string_array samr_authservices = {
12814         .count  = 1,
12815         .names  = samr_authservice_strings
12816 };
12817
12818
12819 const struct ndr_interface_table ndr_table_samr = {
12820         .name           = "samr",
12821         .syntax_id      = {
12822                 {0x12345778,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xac}},
12823                 NDR_SAMR_VERSION
12824         },
12825         .helpstring     = NDR_SAMR_HELPSTRING,
12826         .num_calls      = 68,
12827         .calls          = samr_calls,
12828         .endpoints      = &samr_endpoints,
12829         .authservices   = &samr_authservices
12830 };
12831