librpc/gen_ndr/ndr_samr.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_samr.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 #include "librpc/gen_ndr/ndr_lsa.h"
   8 #include "librpc/gen_ndr/ndr_security.h"
   9 _PUBLIC_ enum ndr_err_code ndr_push_netr_SamDatabaseID(struct ndr_push *ndr, int ndr_flags, enum netr_SamDatabaseID r)
  10 {
  11         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
  12         return NDR_ERR_SUCCESS;
  13 }
  14
  15 _PUBLIC_ enum ndr_err_code ndr_pull_netr_SamDatabaseID(struct ndr_pull *ndr, int ndr_flags, enum netr_SamDatabaseID *r)
  16 {
  17         uint32_t v;
  18         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
  19         *r = v;
  20         return NDR_ERR_SUCCESS;
  21 }
  22
  23 _PUBLIC_ void ndr_print_netr_SamDatabaseID(struct ndr_print *ndr, const char *name, enum netr_SamDatabaseID r)
  24 {
  25         const char *val = NULL;
  26
  27         switch (r) {
  28                 case SAM_DATABASE_DOMAIN: val = "SAM_DATABASE_DOMAIN"; break;
  29                 case SAM_DATABASE_BUILTIN: val = "SAM_DATABASE_BUILTIN"; break;
  30                 case SAM_DATABASE_PRIVS: val = "SAM_DATABASE_PRIVS"; break;
  31         }
  32         ndr_print_enum(ndr, name, "ENUM", val, r);
  33 }
  34
  35 _PUBLIC_ enum ndr_err_code ndr_push_samr_RejectReason(struct ndr_push *ndr, int ndr_flags, enum samr_RejectReason r)
  36 {
  37         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
  38         return NDR_ERR_SUCCESS;
  39 }
  40
  41 _PUBLIC_ enum ndr_err_code ndr_pull_samr_RejectReason(struct ndr_pull *ndr, int ndr_flags, enum samr_RejectReason *r)
  42 {
  43         uint32_t v;
  44         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
  45         *r = v;
  46         return NDR_ERR_SUCCESS;
  47 }
  48
  49 _PUBLIC_ void ndr_print_samr_RejectReason(struct ndr_print *ndr, const char *name, enum samr_RejectReason r)
  50 {
  51         const char *val = NULL;
  52
  53         switch (r) {
  54                 case SAMR_REJECT_OTHER: val = "SAMR_REJECT_OTHER"; break;
  55                 case SAMR_REJECT_TOO_SHORT: val = "SAMR_REJECT_TOO_SHORT"; break;
  56                 case SAMR_REJECT_IN_HISTORY: val = "SAMR_REJECT_IN_HISTORY"; break;
  57                 case SAMR_REJECT_COMPLEXITY: val = "SAMR_REJECT_COMPLEXITY"; break;
  58         }
  59         ndr_print_enum(ndr, name, "ENUM", val, r);
  60 }
  61
  62 _PUBLIC_ enum ndr_err_code ndr_push_samr_AcctFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  63 {
  64         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  65         return NDR_ERR_SUCCESS;
  66 }
  67
  68 _PUBLIC_ enum ndr_err_code ndr_pull_samr_AcctFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  69 {
  70         uint32_t v;
  71         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  72         *r = v;
  73         return NDR_ERR_SUCCESS;
  74 }
  75
  76 _PUBLIC_ void ndr_print_samr_AcctFlags(struct ndr_print *ndr, const char *name, uint32_t r)
  77 {
  78         ndr_print_uint32(ndr, name, r);
  79         ndr->depth++;
  80         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_DISABLED", ACB_DISABLED, r);
  81         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_HOMDIRREQ", ACB_HOMDIRREQ, r);
  82         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_PWNOTREQ", ACB_PWNOTREQ, r);
  83         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_TEMPDUP", ACB_TEMPDUP, r);
  84         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_NORMAL", ACB_NORMAL, r);
  85         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_MNS", ACB_MNS, r);
  86         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_DOMTRUST", ACB_DOMTRUST, r);
  87         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_WSTRUST", ACB_WSTRUST, r);
  88         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_SVRTRUST", ACB_SVRTRUST, r);
  89         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_PWNOEXP", ACB_PWNOEXP, r);
  90         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_AUTOLOCK", ACB_AUTOLOCK, r);
  91         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_ENC_TXT_PWD_ALLOWED", ACB_ENC_TXT_PWD_ALLOWED, r);
  92         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_SMARTCARD_REQUIRED", ACB_SMARTCARD_REQUIRED, r);
  93         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_TRUSTED_FOR_DELEGATION", ACB_TRUSTED_FOR_DELEGATION, r);
  94         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_NOT_DELEGATED", ACB_NOT_DELEGATED, r);
  95         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_USE_DES_KEY_ONLY", ACB_USE_DES_KEY_ONLY, r);
  96         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_DONT_REQUIRE_PREAUTH", ACB_DONT_REQUIRE_PREAUTH, r);
  97         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_PW_EXPIRED", ACB_PW_EXPIRED, r);
  98         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_NO_AUTH_DATA_REQD", ACB_NO_AUTH_DATA_REQD, r);
  99         ndr->depth--;
 100 }
 101
 102 static enum ndr_err_code ndr_push_samr_ConnectAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 103 {
 104         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 105         return NDR_ERR_SUCCESS;
 106 }
 107
 108 static enum ndr_err_code ndr_pull_samr_ConnectAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 109 {
 110         uint32_t v;
 111         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 112         *r = v;
 113         return NDR_ERR_SUCCESS;
 114 }
 115
 116 _PUBLIC_ void ndr_print_samr_ConnectAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 117 {
 118         ndr_print_uint32(ndr, name, r);
 119         ndr->depth++;
 120         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_CONNECT_TO_SERVER", SAMR_ACCESS_CONNECT_TO_SERVER, r);
 121         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_SHUTDOWN_SERVER", SAMR_ACCESS_SHUTDOWN_SERVER, r);
 122         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_INITIALIZE_SERVER", SAMR_ACCESS_INITIALIZE_SERVER, r);
 123         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_CREATE_DOMAIN", SAMR_ACCESS_CREATE_DOMAIN, r);
 124         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_ENUM_DOMAINS", SAMR_ACCESS_ENUM_DOMAINS, r);
 125         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_LOOKUP_DOMAIN", SAMR_ACCESS_LOOKUP_DOMAIN, r);
 126         ndr->depth--;
 127 }
 128
 129 static enum ndr_err_code ndr_push_samr_UserAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 130 {
 131         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 132         return NDR_ERR_SUCCESS;
 133 }
 134
 135 static enum ndr_err_code ndr_pull_samr_UserAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 136 {
 137         uint32_t v;
 138         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 139         *r = v;
 140         return NDR_ERR_SUCCESS;
 141 }
 142
 143 _PUBLIC_ void ndr_print_samr_UserAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 144 {
 145         ndr_print_uint32(ndr, name, r);
 146         ndr->depth++;
 147         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_NAME_ETC", SAMR_USER_ACCESS_GET_NAME_ETC, r);
 148         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_LOCALE", SAMR_USER_ACCESS_GET_LOCALE, r);
 149         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_SET_LOC_COM", SAMR_USER_ACCESS_SET_LOC_COM, r);
 150         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_LOGONINFO", SAMR_USER_ACCESS_GET_LOGONINFO, r);
 151         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_ATTRIBUTES", SAMR_USER_ACCESS_GET_ATTRIBUTES, r);
 152         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_SET_ATTRIBUTES", SAMR_USER_ACCESS_SET_ATTRIBUTES, r);
 153         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_CHANGE_PASSWORD", SAMR_USER_ACCESS_CHANGE_PASSWORD, r);
 154         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_SET_PASSWORD", SAMR_USER_ACCESS_SET_PASSWORD, r);
 155         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_GROUPS", SAMR_USER_ACCESS_GET_GROUPS, r);
 156         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_GROUP_MEMBERSHIP", SAMR_USER_ACCESS_GET_GROUP_MEMBERSHIP, r);
 157         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_CHANGE_GROUP_MEMBERSHIP", SAMR_USER_ACCESS_CHANGE_GROUP_MEMBERSHIP, r);
 158         ndr->depth--;
 159 }
 160
 161 static enum ndr_err_code ndr_push_samr_DomainAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 162 {
 163         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 164         return NDR_ERR_SUCCESS;
 165 }
 166
 167 static enum ndr_err_code ndr_pull_samr_DomainAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 168 {
 169         uint32_t v;
 170         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 171         *r = v;
 172         return NDR_ERR_SUCCESS;
 173 }
 174
 175 _PUBLIC_ void ndr_print_samr_DomainAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 176 {
 177         ndr_print_uint32(ndr, name, r);
 178         ndr->depth++;
 179         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1", SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1, r);
 180         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_SET_INFO_1", SAMR_DOMAIN_ACCESS_SET_INFO_1, r);
 181         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2", SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2, r);
 182         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_SET_INFO_2", SAMR_DOMAIN_ACCESS_SET_INFO_2, r);
 183         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_CREATE_USER", SAMR_DOMAIN_ACCESS_CREATE_USER, r);
 184         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_CREATE_GROUP", SAMR_DOMAIN_ACCESS_CREATE_GROUP, r);
 185         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_CREATE_ALIAS", SAMR_DOMAIN_ACCESS_CREATE_ALIAS, r);
 186         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS", SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS, r);
 187         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS", SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS, r);
 188         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT", SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT, r);
 189         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_SET_INFO_3", SAMR_DOMAIN_ACCESS_SET_INFO_3, r);
 190         ndr->depth--;
 191 }
 192
 193 static enum ndr_err_code ndr_push_samr_GroupAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 194 {
 195         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 196         return NDR_ERR_SUCCESS;
 197 }
 198
 199 static enum ndr_err_code ndr_pull_samr_GroupAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 200 {
 201         uint32_t v;
 202         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 203         *r = v;
 204         return NDR_ERR_SUCCESS;
 205 }
 206
 207 _PUBLIC_ void ndr_print_samr_GroupAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 208 {
 209         ndr_print_uint32(ndr, name, r);
 210         ndr->depth++;
 211         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_LOOKUP_INFO", SAMR_GROUP_ACCESS_LOOKUP_INFO, r);
 212         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_SET_INFO", SAMR_GROUP_ACCESS_SET_INFO, r);
 213         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_ADD_MEMBER", SAMR_GROUP_ACCESS_ADD_MEMBER, r);
 214         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_REMOVE_MEMBER", SAMR_GROUP_ACCESS_REMOVE_MEMBER, r);
 215         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_GET_MEMBERS", SAMR_GROUP_ACCESS_GET_MEMBERS, r);
 216         ndr->depth--;
 217 }
 218
 219 static enum ndr_err_code ndr_push_samr_AliasAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 220 {
 221         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 222         return NDR_ERR_SUCCESS;
 223 }
 224
 225 static enum ndr_err_code ndr_pull_samr_AliasAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 226 {
 227         uint32_t v;
 228         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 229         *r = v;
 230         return NDR_ERR_SUCCESS;
 231 }
 232
 233 _PUBLIC_ void ndr_print_samr_AliasAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 234 {
 235         ndr_print_uint32(ndr, name, r);
 236         ndr->depth++;
 237         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_ADD_MEMBER", SAMR_ALIAS_ACCESS_ADD_MEMBER, r);
 238         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_REMOVE_MEMBER", SAMR_ALIAS_ACCESS_REMOVE_MEMBER, r);
 239         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_GET_MEMBERS", SAMR_ALIAS_ACCESS_GET_MEMBERS, r);
 240         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_LOOKUP_INFO", SAMR_ALIAS_ACCESS_LOOKUP_INFO, r);
 241         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_SET_INFO", SAMR_ALIAS_ACCESS_SET_INFO, r);
 242         ndr->depth--;
 243 }
 244
 245 static enum ndr_err_code ndr_push_samr_SamEntry(struct ndr_push *ndr, int ndr_flags, const struct samr_SamEntry *r)
 246 {
 247         if (ndr_flags & NDR_SCALARS) {
 248                 NDR_CHECK(ndr_push_align(ndr, 5));
 249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
 250                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
 251                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 252         }
 253         if (ndr_flags & NDR_BUFFERS) {
 254                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
 255         }
 256         return NDR_ERR_SUCCESS;
 257 }
 258
 259 static enum ndr_err_code ndr_pull_samr_SamEntry(struct ndr_pull *ndr, int ndr_flags, struct samr_SamEntry *r)
 260 {
 261         if (ndr_flags & NDR_SCALARS) {
 262                 NDR_CHECK(ndr_pull_align(ndr, 5));
 263                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
 264                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
 265                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 266         }
 267         if (ndr_flags & NDR_BUFFERS) {
 268                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
 269         }
 270         return NDR_ERR_SUCCESS;
 271 }
 272
 273 _PUBLIC_ void ndr_print_samr_SamEntry(struct ndr_print *ndr, const char *name, const struct samr_SamEntry *r)
 274 {
 275         ndr_print_struct(ndr, name, "samr_SamEntry");
 276         ndr->depth++;
 277         ndr_print_uint32(ndr, "idx", r->idx);
 278         ndr_print_lsa_String(ndr, "name", &r->name);
 279         ndr->depth--;
 280 }
 281
 282 static enum ndr_err_code ndr_push_samr_SamArray(struct ndr_push *ndr, int ndr_flags, const struct samr_SamArray *r)
 283 {
 284         uint32_t cntr_entries_1;
 285         if (ndr_flags & NDR_SCALARS) {
 286                 NDR_CHECK(ndr_push_align(ndr, 5));
 287                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 288                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
 289                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 290         }
 291         if (ndr_flags & NDR_BUFFERS) {
 292                 if (r->entries) {
 293                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
 294                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 295                                 NDR_CHECK(ndr_push_samr_SamEntry(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 296                         }
 297                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 298                                 NDR_CHECK(ndr_push_samr_SamEntry(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 299                         }
 300                 }
 301         }
 302         return NDR_ERR_SUCCESS;
 303 }
 304
 305 static enum ndr_err_code ndr_pull_samr_SamArray(struct ndr_pull *ndr, int ndr_flags, struct samr_SamArray *r)
 306 {
 307         uint32_t _ptr_entries;
 308         uint32_t size_entries_1 = 0;
 309         uint32_t cntr_entries_1;
 310         TALLOC_CTX *_mem_save_entries_0;
 311         TALLOC_CTX *_mem_save_entries_1;
 312         if (ndr_flags & NDR_SCALARS) {
 313                 NDR_CHECK(ndr_pull_align(ndr, 5));
 314                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 315                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
 316                 if (_ptr_entries) {
 317                         NDR_PULL_ALLOC(ndr, r->entries);
 318                 } else {
 319                         r->entries = NULL;
 320                 }
 321                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 322         }
 323         if (ndr_flags & NDR_BUFFERS) {
 324                 if (r->entries) {
 325                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
 326                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 327                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
 328                         size_entries_1 = ndr_get_array_size(ndr, &r->entries);
 329                         NDR_PULL_ALLOC_N(ndr, r->entries, size_entries_1);
 330                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
 331                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 332                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
 333                                 NDR_CHECK(ndr_pull_samr_SamEntry(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 334                         }
 335                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
 336                                 NDR_CHECK(ndr_pull_samr_SamEntry(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 337                         }
 338                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
 339                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
 340                 }
 341                 if (r->entries) {
 342                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
 343                 }
 344         }
 345         return NDR_ERR_SUCCESS;
 346 }
 347
 348 _PUBLIC_ void ndr_print_samr_SamArray(struct ndr_print *ndr, const char *name, const struct samr_SamArray *r)
 349 {
 350         uint32_t cntr_entries_1;
 351         ndr_print_struct(ndr, name, "samr_SamArray");
 352         ndr->depth++;
 353         ndr_print_uint32(ndr, "count", r->count);
 354         ndr_print_ptr(ndr, "entries", r->entries);
 355         ndr->depth++;
 356         if (r->entries) {
 357                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
 358                 ndr->depth++;
 359                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
 360                         char *idx_1=NULL;
 361                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
 362                                 ndr_print_samr_SamEntry(ndr, "entries", &r->entries[cntr_entries_1]);
 363                                 free(idx_1);
 364                         }
 365                 }
 366                 ndr->depth--;
 367         }
 368         ndr->depth--;
 369         ndr->depth--;
 370 }
 371
 372 static enum ndr_err_code ndr_push_samr_DomainInfoClass(struct ndr_push *ndr, int ndr_flags, enum samr_DomainInfoClass r)
 373 {
 374         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 375         return NDR_ERR_SUCCESS;
 376 }
 377
 378 static enum ndr_err_code ndr_pull_samr_DomainInfoClass(struct ndr_pull *ndr, int ndr_flags, enum samr_DomainInfoClass *r)
 379 {
 380         uint16_t v;
 381         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 382         *r = v;
 383         return NDR_ERR_SUCCESS;
 384 }
 385
 386 _PUBLIC_ void ndr_print_samr_DomainInfoClass(struct ndr_print *ndr, const char *name, enum samr_DomainInfoClass r)
 387 {
 388         const char *val = NULL;
 389
 390         switch (r) {
 391                 case DomainPasswordInformation: val = "DomainPasswordInformation"; break;
 392                 case DomainGeneralInformation: val = "DomainGeneralInformation"; break;
 393                 case DomainLogoffInformation: val = "DomainLogoffInformation"; break;
 394                 case DomainOemInformation: val = "DomainOemInformation"; break;
 395                 case DomainNameInformation: val = "DomainNameInformation"; break;
 396                 case DomainReplicationInformation: val = "DomainReplicationInformation"; break;
 397                 case DomainServerRoleInformation: val = "DomainServerRoleInformation"; break;
 398                 case DomainModifiedInformation: val = "DomainModifiedInformation"; break;
 399                 case DomainStateInformation: val = "DomainStateInformation"; break;
 400                 case DomainUasInformation: val = "DomainUasInformation"; break;
 401                 case DomainGeneralInformation2: val = "DomainGeneralInformation2"; break;
 402                 case DomainLockoutInformation: val = "DomainLockoutInformation"; break;
 403                 case DomainModifiedInformation2: val = "DomainModifiedInformation2"; break;
 404         }
 405         ndr_print_enum(ndr, name, "ENUM", val, r);
 406 }
 407
 408 static enum ndr_err_code ndr_push_samr_Role(struct ndr_push *ndr, int ndr_flags, enum samr_Role r)
 409 {
 410         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 411         return NDR_ERR_SUCCESS;
 412 }
 413
 414 static enum ndr_err_code ndr_pull_samr_Role(struct ndr_pull *ndr, int ndr_flags, enum samr_Role *r)
 415 {
 416         uint32_t v;
 417         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 418         *r = v;
 419         return NDR_ERR_SUCCESS;
 420 }
 421
 422 _PUBLIC_ void ndr_print_samr_Role(struct ndr_print *ndr, const char *name, enum samr_Role r)
 423 {
 424         const char *val = NULL;
 425
 426         switch (r) {
 427                 case SAMR_ROLE_STANDALONE: val = "SAMR_ROLE_STANDALONE"; break;
 428                 case SAMR_ROLE_DOMAIN_MEMBER: val = "SAMR_ROLE_DOMAIN_MEMBER"; break;
 429                 case SAMR_ROLE_DOMAIN_BDC: val = "SAMR_ROLE_DOMAIN_BDC"; break;
 430                 case SAMR_ROLE_DOMAIN_PDC: val = "SAMR_ROLE_DOMAIN_PDC"; break;
 431         }
 432         ndr_print_enum(ndr, name, "ENUM", val, r);
 433 }
 434
 435 _PUBLIC_ enum ndr_err_code ndr_push_samr_PasswordProperties(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 436 {
 437         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 438         return NDR_ERR_SUCCESS;
 439 }
 440
 441 _PUBLIC_ enum ndr_err_code ndr_pull_samr_PasswordProperties(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 442 {
 443         uint32_t v;
 444         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 445         *r = v;
 446         return NDR_ERR_SUCCESS;
 447 }
 448
 449 _PUBLIC_ void ndr_print_samr_PasswordProperties(struct ndr_print *ndr, const char *name, uint32_t r)
 450 {
 451         ndr_print_uint32(ndr, name, r);
 452         ndr->depth++;
 453         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_COMPLEX", DOMAIN_PASSWORD_COMPLEX, r);
 454         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_NO_ANON_CHANGE", DOMAIN_PASSWORD_NO_ANON_CHANGE, r);
 455         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_NO_CLEAR_CHANGE", DOMAIN_PASSWORD_NO_CLEAR_CHANGE, r);
 456         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_LOCKOUT_ADMINS", DOMAIN_PASSWORD_LOCKOUT_ADMINS, r);
 457         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_STORE_CLEARTEXT", DOMAIN_PASSWORD_STORE_CLEARTEXT, r);
 458         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_REFUSE_PASSWORD_CHANGE", DOMAIN_REFUSE_PASSWORD_CHANGE, r);
 459         ndr->depth--;
 460 }
 461
 462 static enum ndr_err_code ndr_push_samr_DomainServerState(struct ndr_push *ndr, int ndr_flags, enum samr_DomainServerState r)
 463 {
 464         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 465         return NDR_ERR_SUCCESS;
 466 }
 467
 468 static enum ndr_err_code ndr_pull_samr_DomainServerState(struct ndr_pull *ndr, int ndr_flags, enum samr_DomainServerState *r)
 469 {
 470         uint32_t v;
 471         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 472         *r = v;
 473         return NDR_ERR_SUCCESS;
 474 }
 475
 476 _PUBLIC_ void ndr_print_samr_DomainServerState(struct ndr_print *ndr, const char *name, enum samr_DomainServerState r)
 477 {
 478         const char *val = NULL;
 479
 480         switch (r) {
 481                 case DOMAIN_SERVER_ENABLED: val = "DOMAIN_SERVER_ENABLED"; break;
 482                 case DOMAIN_SERVER_DISABLED: val = "DOMAIN_SERVER_DISABLED"; break;
 483         }
 484         ndr_print_enum(ndr, name, "ENUM", val, r);
 485 }
 486
 487 static enum ndr_err_code ndr_push_samr_DomInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo1 *r)
 488 {
 489         if (ndr_flags & NDR_SCALARS) {
 490                 NDR_CHECK(ndr_push_align(ndr, 4));
 491                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->min_password_length));
 492                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->password_history_length));
 493                 NDR_CHECK(ndr_push_samr_PasswordProperties(ndr, NDR_SCALARS, r->password_properties));
 494                 NDR_CHECK(ndr_push_dlong(ndr, NDR_SCALARS, r->max_password_age));
 495                 NDR_CHECK(ndr_push_dlong(ndr, NDR_SCALARS, r->min_password_age));
 496                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 497         }
 498         if (ndr_flags & NDR_BUFFERS) {
 499         }
 500         return NDR_ERR_SUCCESS;
 501 }
 502
 503 static enum ndr_err_code ndr_pull_samr_DomInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo1 *r)
 504 {
 505         if (ndr_flags & NDR_SCALARS) {
 506                 NDR_CHECK(ndr_pull_align(ndr, 4));
 507                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->min_password_length));
 508                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->password_history_length));
 509                 NDR_CHECK(ndr_pull_samr_PasswordProperties(ndr, NDR_SCALARS, &r->password_properties));
 510                 NDR_CHECK(ndr_pull_dlong(ndr, NDR_SCALARS, &r->max_password_age));
 511                 NDR_CHECK(ndr_pull_dlong(ndr, NDR_SCALARS, &r->min_password_age));
 512                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 513         }
 514         if (ndr_flags & NDR_BUFFERS) {
 515         }
 516         return NDR_ERR_SUCCESS;
 517 }
 518
 519 _PUBLIC_ void ndr_print_samr_DomInfo1(struct ndr_print *ndr, const char *name, const struct samr_DomInfo1 *r)
 520 {
 521         ndr_print_struct(ndr, name, "samr_DomInfo1");
 522         ndr->depth++;
 523         ndr_print_uint16(ndr, "min_password_length", r->min_password_length);
 524         ndr_print_uint16(ndr, "password_history_length", r->password_history_length);
 525         ndr_print_samr_PasswordProperties(ndr, "password_properties", r->password_properties);
 526         ndr_print_dlong(ndr, "max_password_age", r->max_password_age);
 527         ndr_print_dlong(ndr, "min_password_age", r->min_password_age);
 528         ndr->depth--;
 529 }
 530
 531 static enum ndr_err_code ndr_push_samr_DomGeneralInformation(struct ndr_push *ndr, int ndr_flags, const struct samr_DomGeneralInformation *r)
 532 {
 533         if (ndr_flags & NDR_SCALARS) {
 534                 NDR_CHECK(ndr_push_align(ndr, 5));
 535                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_logoff_time));
 536                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 537                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 538                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->primary));
 539                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->sequence_num));
 540                 NDR_CHECK(ndr_push_samr_DomainServerState(ndr, NDR_SCALARS, r->domain_server_state));
 541                 NDR_CHECK(ndr_push_samr_Role(ndr, NDR_SCALARS, r->role));
 542                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
 543                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_users));
 544                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_groups));
 545                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_aliases));
 546                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 547         }
 548         if (ndr_flags & NDR_BUFFERS) {
 549                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 550                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 551                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 552         }
 553         return NDR_ERR_SUCCESS;
 554 }
 555
 556 static enum ndr_err_code ndr_pull_samr_DomGeneralInformation(struct ndr_pull *ndr, int ndr_flags, struct samr_DomGeneralInformation *r)
 557 {
 558         if (ndr_flags & NDR_SCALARS) {
 559                 NDR_CHECK(ndr_pull_align(ndr, 5));
 560                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_logoff_time));
 561                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 562                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 563                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->primary));
 564                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->sequence_num));
 565                 NDR_CHECK(ndr_pull_samr_DomainServerState(ndr, NDR_SCALARS, &r->domain_server_state));
 566                 NDR_CHECK(ndr_pull_samr_Role(ndr, NDR_SCALARS, &r->role));
 567                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
 568                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_users));
 569                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_groups));
 570                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_aliases));
 571                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 572         }
 573         if (ndr_flags & NDR_BUFFERS) {
 574                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 575                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 576                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 577         }
 578         return NDR_ERR_SUCCESS;
 579 }
 580
 581 _PUBLIC_ void ndr_print_samr_DomGeneralInformation(struct ndr_print *ndr, const char *name, const struct samr_DomGeneralInformation *r)
 582 {
 583         ndr_print_struct(ndr, name, "samr_DomGeneralInformation");
 584         ndr->depth++;
 585         ndr_print_NTTIME(ndr, "force_logoff_time", r->force_logoff_time);
 586         ndr_print_lsa_String(ndr, "oem_information", &r->oem_information);
 587         ndr_print_lsa_String(ndr, "domain_name", &r->domain_name);
 588         ndr_print_lsa_String(ndr, "primary", &r->primary);
 589         ndr_print_udlong(ndr, "sequence_num", r->sequence_num);
 590         ndr_print_samr_DomainServerState(ndr, "domain_server_state", r->domain_server_state);
 591         ndr_print_samr_Role(ndr, "role", r->role);
 592         ndr_print_uint32(ndr, "unknown3", r->unknown3);
 593         ndr_print_uint32(ndr, "num_users", r->num_users);
 594         ndr_print_uint32(ndr, "num_groups", r->num_groups);
 595         ndr_print_uint32(ndr, "num_aliases", r->num_aliases);
 596         ndr->depth--;
 597 }
 598
 599 static enum ndr_err_code ndr_push_samr_DomInfo3(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo3 *r)
 600 {
 601         if (ndr_flags & NDR_SCALARS) {
 602                 NDR_CHECK(ndr_push_align(ndr, 4));
 603                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_logoff_time));
 604                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 605         }
 606         if (ndr_flags & NDR_BUFFERS) {
 607         }
 608         return NDR_ERR_SUCCESS;
 609 }
 610
 611 static enum ndr_err_code ndr_pull_samr_DomInfo3(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo3 *r)
 612 {
 613         if (ndr_flags & NDR_SCALARS) {
 614                 NDR_CHECK(ndr_pull_align(ndr, 4));
 615                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_logoff_time));
 616                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 617         }
 618         if (ndr_flags & NDR_BUFFERS) {
 619         }
 620         return NDR_ERR_SUCCESS;
 621 }
 622
 623 _PUBLIC_ void ndr_print_samr_DomInfo3(struct ndr_print *ndr, const char *name, const struct samr_DomInfo3 *r)
 624 {
 625         ndr_print_struct(ndr, name, "samr_DomInfo3");
 626         ndr->depth++;
 627         ndr_print_NTTIME(ndr, "force_logoff_time", r->force_logoff_time);
 628         ndr->depth--;
 629 }
 630
 631 static enum ndr_err_code ndr_push_samr_DomOEMInformation(struct ndr_push *ndr, int ndr_flags, const struct samr_DomOEMInformation *r)
 632 {
 633         if (ndr_flags & NDR_SCALARS) {
 634                 NDR_CHECK(ndr_push_align(ndr, 5));
 635                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 636                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 637         }
 638         if (ndr_flags & NDR_BUFFERS) {
 639                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 640         }
 641         return NDR_ERR_SUCCESS;
 642 }
 643
 644 static enum ndr_err_code ndr_pull_samr_DomOEMInformation(struct ndr_pull *ndr, int ndr_flags, struct samr_DomOEMInformation *r)
 645 {
 646         if (ndr_flags & NDR_SCALARS) {
 647                 NDR_CHECK(ndr_pull_align(ndr, 5));
 648                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 649                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 650         }
 651         if (ndr_flags & NDR_BUFFERS) {
 652                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 653         }
 654         return NDR_ERR_SUCCESS;
 655 }
 656
 657 _PUBLIC_ void ndr_print_samr_DomOEMInformation(struct ndr_print *ndr, const char *name, const struct samr_DomOEMInformation *r)
 658 {
 659         ndr_print_struct(ndr, name, "samr_DomOEMInformation");
 660         ndr->depth++;
 661         ndr_print_lsa_String(ndr, "oem_information", &r->oem_information);
 662         ndr->depth--;
 663 }
 664
 665 static enum ndr_err_code ndr_push_samr_DomInfo5(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo5 *r)
 666 {
 667         if (ndr_flags & NDR_SCALARS) {
 668                 NDR_CHECK(ndr_push_align(ndr, 5));
 669                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 670                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 671         }
 672         if (ndr_flags & NDR_BUFFERS) {
 673                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 674         }
 675         return NDR_ERR_SUCCESS;
 676 }
 677
 678 static enum ndr_err_code ndr_pull_samr_DomInfo5(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo5 *r)
 679 {
 680         if (ndr_flags & NDR_SCALARS) {
 681                 NDR_CHECK(ndr_pull_align(ndr, 5));
 682                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 683                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 684         }
 685         if (ndr_flags & NDR_BUFFERS) {
 686                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 687         }
 688         return NDR_ERR_SUCCESS;
 689 }
 690
 691 _PUBLIC_ void ndr_print_samr_DomInfo5(struct ndr_print *ndr, const char *name, const struct samr_DomInfo5 *r)
 692 {
 693         ndr_print_struct(ndr, name, "samr_DomInfo5");
 694         ndr->depth++;
 695         ndr_print_lsa_String(ndr, "domain_name", &r->domain_name);
 696         ndr->depth--;
 697 }
 698
 699 static enum ndr_err_code ndr_push_samr_DomInfo6(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo6 *r)
 700 {
 701         if (ndr_flags & NDR_SCALARS) {
 702                 NDR_CHECK(ndr_push_align(ndr, 5));
 703                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->primary));
 704                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 705         }
 706         if (ndr_flags & NDR_BUFFERS) {
 707                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 708         }
 709         return NDR_ERR_SUCCESS;
 710 }
 711
 712 static enum ndr_err_code ndr_pull_samr_DomInfo6(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo6 *r)
 713 {
 714         if (ndr_flags & NDR_SCALARS) {
 715                 NDR_CHECK(ndr_pull_align(ndr, 5));
 716                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->primary));
 717                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 718         }
 719         if (ndr_flags & NDR_BUFFERS) {
 720                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 721         }
 722         return NDR_ERR_SUCCESS;
 723 }
 724
 725 _PUBLIC_ void ndr_print_samr_DomInfo6(struct ndr_print *ndr, const char *name, const struct samr_DomInfo6 *r)
 726 {
 727         ndr_print_struct(ndr, name, "samr_DomInfo6");
 728         ndr->depth++;
 729         ndr_print_lsa_String(ndr, "primary", &r->primary);
 730         ndr->depth--;
 731 }
 732
 733 static enum ndr_err_code ndr_push_samr_DomInfo7(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo7 *r)
 734 {
 735         if (ndr_flags & NDR_SCALARS) {
 736                 NDR_CHECK(ndr_push_align(ndr, 4));
 737                 NDR_CHECK(ndr_push_samr_Role(ndr, NDR_SCALARS, r->role));
 738                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 739         }
 740         if (ndr_flags & NDR_BUFFERS) {
 741         }
 742         return NDR_ERR_SUCCESS;
 743 }
 744
 745 static enum ndr_err_code ndr_pull_samr_DomInfo7(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo7 *r)
 746 {
 747         if (ndr_flags & NDR_SCALARS) {
 748                 NDR_CHECK(ndr_pull_align(ndr, 4));
 749                 NDR_CHECK(ndr_pull_samr_Role(ndr, NDR_SCALARS, &r->role));
 750                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 751         }
 752         if (ndr_flags & NDR_BUFFERS) {
 753         }
 754         return NDR_ERR_SUCCESS;
 755 }
 756
 757 _PUBLIC_ void ndr_print_samr_DomInfo7(struct ndr_print *ndr, const char *name, const struct samr_DomInfo7 *r)
 758 {
 759         ndr_print_struct(ndr, name, "samr_DomInfo7");
 760         ndr->depth++;
 761         ndr_print_samr_Role(ndr, "role", r->role);
 762         ndr->depth--;
 763 }
 764
 765 static enum ndr_err_code ndr_push_samr_DomInfo8(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo8 *r)
 766 {
 767         if (ndr_flags & NDR_SCALARS) {
 768                 NDR_CHECK(ndr_push_align(ndr, 8));
 769                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->sequence_num));
 770                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->domain_create_time));
 771                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 772         }
 773         if (ndr_flags & NDR_BUFFERS) {
 774         }
 775         return NDR_ERR_SUCCESS;
 776 }
 777
 778 static enum ndr_err_code ndr_pull_samr_DomInfo8(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo8 *r)
 779 {
 780         if (ndr_flags & NDR_SCALARS) {
 781                 NDR_CHECK(ndr_pull_align(ndr, 8));
 782                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->sequence_num));
 783                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->domain_create_time));
 784                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 785         }
 786         if (ndr_flags & NDR_BUFFERS) {
 787         }
 788         return NDR_ERR_SUCCESS;
 789 }
 790
 791 _PUBLIC_ void ndr_print_samr_DomInfo8(struct ndr_print *ndr, const char *name, const struct samr_DomInfo8 *r)
 792 {
 793         ndr_print_struct(ndr, name, "samr_DomInfo8");
 794         ndr->depth++;
 795         ndr_print_hyper(ndr, "sequence_num", r->sequence_num);
 796         ndr_print_NTTIME(ndr, "domain_create_time", r->domain_create_time);
 797         ndr->depth--;
 798 }
 799
 800 static enum ndr_err_code ndr_push_samr_DomInfo9(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo9 *r)
 801 {
 802         if (ndr_flags & NDR_SCALARS) {
 803                 NDR_CHECK(ndr_push_align(ndr, 4));
 804                 NDR_CHECK(ndr_push_samr_DomainServerState(ndr, NDR_SCALARS, r->domain_server_state));
 805                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 806         }
 807         if (ndr_flags & NDR_BUFFERS) {
 808         }
 809         return NDR_ERR_SUCCESS;
 810 }
 811
 812 static enum ndr_err_code ndr_pull_samr_DomInfo9(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo9 *r)
 813 {
 814         if (ndr_flags & NDR_SCALARS) {
 815                 NDR_CHECK(ndr_pull_align(ndr, 4));
 816                 NDR_CHECK(ndr_pull_samr_DomainServerState(ndr, NDR_SCALARS, &r->domain_server_state));
 817                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 818         }
 819         if (ndr_flags & NDR_BUFFERS) {
 820         }
 821         return NDR_ERR_SUCCESS;
 822 }
 823
 824 _PUBLIC_ void ndr_print_samr_DomInfo9(struct ndr_print *ndr, const char *name, const struct samr_DomInfo9 *r)
 825 {
 826         ndr_print_struct(ndr, name, "samr_DomInfo9");
 827         ndr->depth++;
 828         ndr_print_samr_DomainServerState(ndr, "domain_server_state", r->domain_server_state);
 829         ndr->depth--;
 830 }
 831
 832 static enum ndr_err_code ndr_push_samr_DomGeneralInformation2(struct ndr_push *ndr, int ndr_flags, const struct samr_DomGeneralInformation2 *r)
 833 {
 834         if (ndr_flags & NDR_SCALARS) {
 835                 NDR_CHECK(ndr_push_align(ndr, 8));
 836                 NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 837                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_duration));
 838                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_window));
 839                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lockout_threshold));
 840                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 841         }
 842         if (ndr_flags & NDR_BUFFERS) {
 843                 NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
 844         }
 845         return NDR_ERR_SUCCESS;
 846 }
 847
 848 static enum ndr_err_code ndr_pull_samr_DomGeneralInformation2(struct ndr_pull *ndr, int ndr_flags, struct samr_DomGeneralInformation2 *r)
 849 {
 850         if (ndr_flags & NDR_SCALARS) {
 851                 NDR_CHECK(ndr_pull_align(ndr, 8));
 852                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 853                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_duration));
 854                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_window));
 855                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lockout_threshold));
 856                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 857         }
 858         if (ndr_flags & NDR_BUFFERS) {
 859                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
 860         }
 861         return NDR_ERR_SUCCESS;
 862 }
 863
 864 _PUBLIC_ void ndr_print_samr_DomGeneralInformation2(struct ndr_print *ndr, const char *name, const struct samr_DomGeneralInformation2 *r)
 865 {
 866         ndr_print_struct(ndr, name, "samr_DomGeneralInformation2");
 867         ndr->depth++;
 868         ndr_print_samr_DomGeneralInformation(ndr, "general", &r->general);
 869         ndr_print_hyper(ndr, "lockout_duration", r->lockout_duration);
 870         ndr_print_hyper(ndr, "lockout_window", r->lockout_window);
 871         ndr_print_uint16(ndr, "lockout_threshold", r->lockout_threshold);
 872         ndr->depth--;
 873 }
 874
 875 static enum ndr_err_code ndr_push_samr_DomInfo12(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo12 *r)
 876 {
 877         if (ndr_flags & NDR_SCALARS) {
 878                 NDR_CHECK(ndr_push_align(ndr, 8));
 879                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_duration));
 880                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_window));
 881                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lockout_threshold));
 882                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 883         }
 884         if (ndr_flags & NDR_BUFFERS) {
 885         }
 886         return NDR_ERR_SUCCESS;
 887 }
 888
 889 static enum ndr_err_code ndr_pull_samr_DomInfo12(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo12 *r)
 890 {
 891         if (ndr_flags & NDR_SCALARS) {
 892                 NDR_CHECK(ndr_pull_align(ndr, 8));
 893                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_duration));
 894                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_window));
 895                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lockout_threshold));
 896                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 897         }
 898         if (ndr_flags & NDR_BUFFERS) {
 899         }
 900         return NDR_ERR_SUCCESS;
 901 }
 902
 903 _PUBLIC_ void ndr_print_samr_DomInfo12(struct ndr_print *ndr, const char *name, const struct samr_DomInfo12 *r)
 904 {
 905         ndr_print_struct(ndr, name, "samr_DomInfo12");
 906         ndr->depth++;
 907         ndr_print_hyper(ndr, "lockout_duration", r->lockout_duration);
 908         ndr_print_hyper(ndr, "lockout_window", r->lockout_window);
 909         ndr_print_uint16(ndr, "lockout_threshold", r->lockout_threshold);
 910         ndr->depth--;
 911 }
 912
 913 static enum ndr_err_code ndr_push_samr_DomInfo13(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo13 *r)
 914 {
 915         if (ndr_flags & NDR_SCALARS) {
 916                 NDR_CHECK(ndr_push_align(ndr, 8));
 917                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->sequence_num));
 918                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->domain_create_time));
 919                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->modified_count_at_last_promotion));
 920                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 921         }
 922         if (ndr_flags & NDR_BUFFERS) {
 923         }
 924         return NDR_ERR_SUCCESS;
 925 }
 926
 927 static enum ndr_err_code ndr_pull_samr_DomInfo13(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo13 *r)
 928 {
 929         if (ndr_flags & NDR_SCALARS) {
 930                 NDR_CHECK(ndr_pull_align(ndr, 8));
 931                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->sequence_num));
 932                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->domain_create_time));
 933                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->modified_count_at_last_promotion));
 934                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 935         }
 936         if (ndr_flags & NDR_BUFFERS) {
 937         }
 938         return NDR_ERR_SUCCESS;
 939 }
 940
 941 _PUBLIC_ void ndr_print_samr_DomInfo13(struct ndr_print *ndr, const char *name, const struct samr_DomInfo13 *r)
 942 {
 943         ndr_print_struct(ndr, name, "samr_DomInfo13");
 944         ndr->depth++;
 945         ndr_print_hyper(ndr, "sequence_num", r->sequence_num);
 946         ndr_print_NTTIME(ndr, "domain_create_time", r->domain_create_time);
 947         ndr_print_hyper(ndr, "modified_count_at_last_promotion", r->modified_count_at_last_promotion);
 948         ndr->depth--;
 949 }
 950
 951 static enum ndr_err_code ndr_push_samr_DomainInfo(struct ndr_push *ndr, int ndr_flags, const union samr_DomainInfo *r)
 952 {
 953         if (ndr_flags & NDR_SCALARS) {
 954                 int level = ndr_push_get_switch_value(ndr, r);
 955                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
 956                 NDR_CHECK(ndr_push_union_align(ndr, 8));
 957                 switch (level) {
 958                         case 1: {
 959                                 NDR_CHECK(ndr_push_samr_DomInfo1(ndr, NDR_SCALARS, &r->info1));
 960                         break; }
 961
 962                         case 2: {
 963                                 NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 964                         break; }
 965
 966                         case 3: {
 967                                 NDR_CHECK(ndr_push_samr_DomInfo3(ndr, NDR_SCALARS, &r->info3));
 968                         break; }
 969
 970                         case 4: {
 971                                 NDR_CHECK(ndr_push_samr_DomOEMInformation(ndr, NDR_SCALARS, &r->oem));
 972                         break; }
 973
 974                         case 5: {
 975                                 NDR_CHECK(ndr_push_samr_DomInfo5(ndr, NDR_SCALARS, &r->info5));
 976                         break; }
 977
 978                         case 6: {
 979                                 NDR_CHECK(ndr_push_samr_DomInfo6(ndr, NDR_SCALARS, &r->info6));
 980                         break; }
 981
 982                         case 7: {
 983                                 NDR_CHECK(ndr_push_samr_DomInfo7(ndr, NDR_SCALARS, &r->info7));
 984                         break; }
 985
 986                         case 8: {
 987                                 NDR_CHECK(ndr_push_samr_DomInfo8(ndr, NDR_SCALARS, &r->info8));
 988                         break; }
 989
 990                         case 9: {
 991                                 NDR_CHECK(ndr_push_samr_DomInfo9(ndr, NDR_SCALARS, &r->info9));
 992                         break; }
 993
 994                         case 11: {
 995                                 NDR_CHECK(ndr_push_samr_DomGeneralInformation2(ndr, NDR_SCALARS, &r->general2));
 996                         break; }
 997
 998                         case 12: {
 999                                 NDR_CHECK(ndr_push_samr_DomInfo12(ndr, NDR_SCALARS, &r->info12));
1000                         break; }
1001
1002                         case 13: {
1003                                 NDR_CHECK(ndr_push_samr_DomInfo13(ndr, NDR_SCALARS, &r->info13));
1004                         break; }
1005
1006                         default:
1007                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1008                 }
1009         }
1010         if (ndr_flags & NDR_BUFFERS) {
1011                 int level = ndr_push_get_switch_value(ndr, r);
1012                 switch (level) {
1013                         case 1:
1014                         break;
1015
1016                         case 2:
1017                                 NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
1018                         break;
1019
1020                         case 3:
1021                         break;
1022
1023                         case 4:
1024                                 NDR_CHECK(ndr_push_samr_DomOEMInformation(ndr, NDR_BUFFERS, &r->oem));
1025                         break;
1026
1027                         case 5:
1028                                 NDR_CHECK(ndr_push_samr_DomInfo5(ndr, NDR_BUFFERS, &r->info5));
1029                         break;
1030
1031                         case 6:
1032                                 NDR_CHECK(ndr_push_samr_DomInfo6(ndr, NDR_BUFFERS, &r->info6));
1033                         break;
1034
1035                         case 7:
1036                         break;
1037
1038                         case 8:
1039                         break;
1040
1041                         case 9:
1042                         break;
1043
1044                         case 11:
1045                                 NDR_CHECK(ndr_push_samr_DomGeneralInformation2(ndr, NDR_BUFFERS, &r->general2));
1046                         break;
1047
1048                         case 12:
1049                         break;
1050
1051                         case 13:
1052                         break;
1053
1054                         default:
1055                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1056                 }
1057         }
1058         return NDR_ERR_SUCCESS;
1059 }
1060
1061 static enum ndr_err_code ndr_pull_samr_DomainInfo(struct ndr_pull *ndr, int ndr_flags, union samr_DomainInfo *r)
1062 {
1063         int level;
1064         uint16_t _level;
1065         level = ndr_pull_get_switch_value(ndr, r);
1066         if (ndr_flags & NDR_SCALARS) {
1067                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
1068                 if (_level != level) {
1069                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1070                 }
1071                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
1072                 switch (level) {
1073                         case 1: {
1074                                 NDR_CHECK(ndr_pull_samr_DomInfo1(ndr, NDR_SCALARS, &r->info1));
1075                         break; }
1076
1077                         case 2: {
1078                                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
1079                         break; }
1080
1081                         case 3: {
1082                                 NDR_CHECK(ndr_pull_samr_DomInfo3(ndr, NDR_SCALARS, &r->info3));
1083                         break; }
1084
1085                         case 4: {
1086                                 NDR_CHECK(ndr_pull_samr_DomOEMInformation(ndr, NDR_SCALARS, &r->oem));
1087                         break; }
1088
1089                         case 5: {
1090                                 NDR_CHECK(ndr_pull_samr_DomInfo5(ndr, NDR_SCALARS, &r->info5));
1091                         break; }
1092
1093                         case 6: {
1094                                 NDR_CHECK(ndr_pull_samr_DomInfo6(ndr, NDR_SCALARS, &r->info6));
1095                         break; }
1096
1097                         case 7: {
1098                                 NDR_CHECK(ndr_pull_samr_DomInfo7(ndr, NDR_SCALARS, &r->info7));
1099                         break; }
1100
1101                         case 8: {
1102                                 NDR_CHECK(ndr_pull_samr_DomInfo8(ndr, NDR_SCALARS, &r->info8));
1103                         break; }
1104
1105                         case 9: {
1106                                 NDR_CHECK(ndr_pull_samr_DomInfo9(ndr, NDR_SCALARS, &r->info9));
1107                         break; }
1108
1109                         case 11: {
1110                                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation2(ndr, NDR_SCALARS, &r->general2));
1111                         break; }
1112
1113                         case 12: {
1114                                 NDR_CHECK(ndr_pull_samr_DomInfo12(ndr, NDR_SCALARS, &r->info12));
1115                         break; }
1116
1117                         case 13: {
1118                                 NDR_CHECK(ndr_pull_samr_DomInfo13(ndr, NDR_SCALARS, &r->info13));
1119                         break; }
1120
1121                         default:
1122                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1123                 }
1124         }
1125         if (ndr_flags & NDR_BUFFERS) {
1126                 switch (level) {
1127                         case 1:
1128                         break;
1129
1130                         case 2:
1131                                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
1132                         break;
1133
1134                         case 3:
1135                         break;
1136
1137                         case 4:
1138                                 NDR_CHECK(ndr_pull_samr_DomOEMInformation(ndr, NDR_BUFFERS, &r->oem));
1139                         break;
1140
1141                         case 5:
1142                                 NDR_CHECK(ndr_pull_samr_DomInfo5(ndr, NDR_BUFFERS, &r->info5));
1143                         break;
1144
1145                         case 6:
1146                                 NDR_CHECK(ndr_pull_samr_DomInfo6(ndr, NDR_BUFFERS, &r->info6));
1147                         break;
1148
1149                         case 7:
1150                         break;
1151
1152                         case 8:
1153                         break;
1154
1155                         case 9:
1156                         break;
1157
1158                         case 11:
1159                                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation2(ndr, NDR_BUFFERS, &r->general2));
1160                         break;
1161
1162                         case 12:
1163                         break;
1164
1165                         case 13:
1166                         break;
1167
1168                         default:
1169                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1170                 }
1171         }
1172         return NDR_ERR_SUCCESS;
1173 }
1174
1175 _PUBLIC_ void ndr_print_samr_DomainInfo(struct ndr_print *ndr, const char *name, const union samr_DomainInfo *r)
1176 {
1177         int level;
1178         level = ndr_print_get_switch_value(ndr, r);
1179         ndr_print_union(ndr, name, level, "samr_DomainInfo");
1180         switch (level) {
1181                 case 1:
1182                         ndr_print_samr_DomInfo1(ndr, "info1", &r->info1);
1183                 break;
1184
1185                 case 2:
1186                         ndr_print_samr_DomGeneralInformation(ndr, "general", &r->general);
1187                 break;
1188
1189                 case 3:
1190                         ndr_print_samr_DomInfo3(ndr, "info3", &r->info3);
1191                 break;
1192
1193                 case 4:
1194                         ndr_print_samr_DomOEMInformation(ndr, "oem", &r->oem);
1195                 break;
1196
1197                 case 5:
1198                         ndr_print_samr_DomInfo5(ndr, "info5", &r->info5);
1199                 break;
1200
1201                 case 6:
1202                         ndr_print_samr_DomInfo6(ndr, "info6", &r->info6);
1203                 break;
1204
1205                 case 7:
1206                         ndr_print_samr_DomInfo7(ndr, "info7", &r->info7);
1207                 break;
1208
1209                 case 8:
1210                         ndr_print_samr_DomInfo8(ndr, "info8", &r->info8);
1211                 break;
1212
1213                 case 9:
1214                         ndr_print_samr_DomInfo9(ndr, "info9", &r->info9);
1215                 break;
1216
1217                 case 11:
1218                         ndr_print_samr_DomGeneralInformation2(ndr, "general2", &r->general2);
1219                 break;
1220
1221                 case 12:
1222                         ndr_print_samr_DomInfo12(ndr, "info12", &r->info12);
1223                 break;
1224
1225                 case 13:
1226                         ndr_print_samr_DomInfo13(ndr, "info13", &r->info13);
1227                 break;
1228
1229                 default:
1230                         ndr_print_bad_level(ndr, name, level);
1231         }
1232 }
1233
1234 static enum ndr_err_code ndr_push_samr_Ids(struct ndr_push *ndr, int ndr_flags, const struct samr_Ids *r)
1235 {
1236         uint32_t cntr_ids_1;
1237         if (ndr_flags & NDR_SCALARS) {
1238                 NDR_CHECK(ndr_push_align(ndr, 5));
1239                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1240                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ids));
1241                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1242         }
1243         if (ndr_flags & NDR_BUFFERS) {
1244                 if (r->ids) {
1245                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
1246                         for (cntr_ids_1 = 0; cntr_ids_1 < r->count; cntr_ids_1++) {
1247                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ids[cntr_ids_1]));
1248                         }
1249                 }
1250         }
1251         return NDR_ERR_SUCCESS;
1252 }
1253
1254 static enum ndr_err_code ndr_pull_samr_Ids(struct ndr_pull *ndr, int ndr_flags, struct samr_Ids *r)
1255 {
1256         uint32_t _ptr_ids;
1257         uint32_t size_ids_1 = 0;
1258         uint32_t cntr_ids_1;
1259         TALLOC_CTX *_mem_save_ids_0;
1260         TALLOC_CTX *_mem_save_ids_1;
1261         if (ndr_flags & NDR_SCALARS) {
1262                 NDR_CHECK(ndr_pull_align(ndr, 5));
1263                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1264                 if (r->count > 1024) {
1265                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1266                 }
1267                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ids));
1268                 if (_ptr_ids) {
1269                         NDR_PULL_ALLOC(ndr, r->ids);
1270                 } else {
1271                         r->ids = NULL;
1272                 }
1273                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1274         }
1275         if (ndr_flags & NDR_BUFFERS) {
1276                 if (r->ids) {
1277                         _mem_save_ids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1278                         NDR_PULL_SET_MEM_CTX(ndr, r->ids, 0);
1279                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ids));
1280                         size_ids_1 = ndr_get_array_size(ndr, &r->ids);
1281                         NDR_PULL_ALLOC_N(ndr, r->ids, size_ids_1);
1282                         _mem_save_ids_1 = NDR_PULL_GET_MEM_CTX(ndr);
1283                         NDR_PULL_SET_MEM_CTX(ndr, r->ids, 0);
1284                         for (cntr_ids_1 = 0; cntr_ids_1 < size_ids_1; cntr_ids_1++) {
1285                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ids[cntr_ids_1]));
1286                         }
1287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ids_1, 0);
1288                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ids_0, 0);
1289                 }
1290                 if (r->ids) {
1291                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->ids, r->count));
1292                 }
1293         }
1294         return NDR_ERR_SUCCESS;
1295 }
1296
1297 _PUBLIC_ void ndr_print_samr_Ids(struct ndr_print *ndr, const char *name, const struct samr_Ids *r)
1298 {
1299         uint32_t cntr_ids_1;
1300         ndr_print_struct(ndr, name, "samr_Ids");
1301         ndr->depth++;
1302         ndr_print_uint32(ndr, "count", r->count);
1303         ndr_print_ptr(ndr, "ids", r->ids);
1304         ndr->depth++;
1305         if (r->ids) {
1306                 ndr->print(ndr, "%s: ARRAY(%d)", "ids", (int)r->count);
1307                 ndr->depth++;
1308                 for (cntr_ids_1=0;cntr_ids_1<r->count;cntr_ids_1++) {
1309                         char *idx_1=NULL;
1310                         if (asprintf(&idx_1, "[%d]", cntr_ids_1) != -1) {
1311                                 ndr_print_uint32(ndr, "ids", r->ids[cntr_ids_1]);
1312                                 free(idx_1);
1313                         }
1314                 }
1315                 ndr->depth--;
1316         }
1317         ndr->depth--;
1318         ndr->depth--;
1319 }
1320
1321 _PUBLIC_ enum ndr_err_code ndr_push_samr_GroupAttrs(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1322 {
1323         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1324         return NDR_ERR_SUCCESS;
1325 }
1326
1327 _PUBLIC_ enum ndr_err_code ndr_pull_samr_GroupAttrs(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1328 {
1329         uint32_t v;
1330         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1331         *r = v;
1332         return NDR_ERR_SUCCESS;
1333 }
1334
1335 _PUBLIC_ void ndr_print_samr_GroupAttrs(struct ndr_print *ndr, const char *name, uint32_t r)
1336 {
1337         ndr_print_uint32(ndr, name, r);
1338         ndr->depth++;
1339         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_MANDATORY", SE_GROUP_MANDATORY, r);
1340         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_ENABLED_BY_DEFAULT", SE_GROUP_ENABLED_BY_DEFAULT, r);
1341         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_ENABLED", SE_GROUP_ENABLED, r);
1342         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_OWNER", SE_GROUP_OWNER, r);
1343         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_USE_FOR_DENY_ONLY", SE_GROUP_USE_FOR_DENY_ONLY, r);
1344         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_RESOURCE", SE_GROUP_RESOURCE, r);
1345         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_LOGON_ID", SE_GROUP_LOGON_ID, r);
1346         ndr->depth--;
1347 }
1348
1349 static enum ndr_err_code ndr_push_samr_GroupInfoAll(struct ndr_push *ndr, int ndr_flags, const struct samr_GroupInfoAll *r)
1350 {
1351         if (ndr_flags & NDR_SCALARS) {
1352                 NDR_CHECK(ndr_push_align(ndr, 5));
1353                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1354                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
1355                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_members));
1356                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1357                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1358         }
1359         if (ndr_flags & NDR_BUFFERS) {
1360                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1361                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1362         }
1363         return NDR_ERR_SUCCESS;
1364 }
1365
1366 static enum ndr_err_code ndr_pull_samr_GroupInfoAll(struct ndr_pull *ndr, int ndr_flags, struct samr_GroupInfoAll *r)
1367 {
1368         if (ndr_flags & NDR_SCALARS) {
1369                 NDR_CHECK(ndr_pull_align(ndr, 5));
1370                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1371                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
1372                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_members));
1373                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1374                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1375         }
1376         if (ndr_flags & NDR_BUFFERS) {
1377                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1378                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1379         }
1380         return NDR_ERR_SUCCESS;
1381 }
1382
1383 _PUBLIC_ void ndr_print_samr_GroupInfoAll(struct ndr_print *ndr, const char *name, const struct samr_GroupInfoAll *r)
1384 {
1385         ndr_print_struct(ndr, name, "samr_GroupInfoAll");
1386         ndr->depth++;
1387         ndr_print_lsa_String(ndr, "name", &r->name);
1388         ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);
1389         ndr_print_uint32(ndr, "num_members", r->num_members);
1390         ndr_print_lsa_String(ndr, "description", &r->description);
1391         ndr->depth--;
1392 }
1393
1394 static enum ndr_err_code ndr_push_samr_GroupInfoAttributes(struct ndr_push *ndr, int ndr_flags, const struct samr_GroupInfoAttributes *r)
1395 {
1396         if (ndr_flags & NDR_SCALARS) {
1397                 NDR_CHECK(ndr_push_align(ndr, 4));
1398                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
1399                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1400         }
1401         if (ndr_flags & NDR_BUFFERS) {
1402         }
1403         return NDR_ERR_SUCCESS;
1404 }
1405
1406 static enum ndr_err_code ndr_pull_samr_GroupInfoAttributes(struct ndr_pull *ndr, int ndr_flags, struct samr_GroupInfoAttributes *r)
1407 {
1408         if (ndr_flags & NDR_SCALARS) {
1409                 NDR_CHECK(ndr_pull_align(ndr, 4));
1410                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
1411                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1412         }
1413         if (ndr_flags & NDR_BUFFERS) {
1414         }
1415         return NDR_ERR_SUCCESS;
1416 }
1417
1418 _PUBLIC_ void ndr_print_samr_GroupInfoAttributes(struct ndr_print *ndr, const char *name, const struct samr_GroupInfoAttributes *r)
1419 {
1420         ndr_print_struct(ndr, name, "samr_GroupInfoAttributes");
1421         ndr->depth++;
1422         ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);
1423         ndr->depth--;
1424 }
1425
1426 static enum ndr_err_code ndr_push_samr_GroupInfoEnum(struct ndr_push *ndr, int ndr_flags, enum samr_GroupInfoEnum r)
1427 {
1428         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
1429         return NDR_ERR_SUCCESS;
1430 }
1431
1432 static enum ndr_err_code ndr_pull_samr_GroupInfoEnum(struct ndr_pull *ndr, int ndr_flags, enum samr_GroupInfoEnum *r)
1433 {
1434         uint16_t v;
1435         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
1436         *r = v;
1437         return NDR_ERR_SUCCESS;
1438 }
1439
1440 _PUBLIC_ void ndr_print_samr_GroupInfoEnum(struct ndr_print *ndr, const char *name, enum samr_GroupInfoEnum r)
1441 {
1442         const char *val = NULL;
1443
1444         switch (r) {
1445                 case GROUPINFOALL: val = "GROUPINFOALL"; break;
1446                 case GROUPINFONAME: val = "GROUPINFONAME"; break;
1447                 case GROUPINFOATTRIBUTES: val = "GROUPINFOATTRIBUTES"; break;
1448                 case GROUPINFODESCRIPTION: val = "GROUPINFODESCRIPTION"; break;
1449                 case GROUPINFOALL2: val = "GROUPINFOALL2"; break;
1450         }
1451         ndr_print_enum(ndr, name, "ENUM", val, r);
1452 }
1453
1454 static enum ndr_err_code ndr_push_samr_GroupInfo(struct ndr_push *ndr, int ndr_flags, const union samr_GroupInfo *r)
1455 {
1456         if (ndr_flags & NDR_SCALARS) {
1457                 int level = ndr_push_get_switch_value(ndr, r);
1458                 NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, level));
1459                 NDR_CHECK(ndr_push_union_align(ndr, 5));
1460                 switch (level) {
1461                         case GROUPINFOALL: {
1462                                 NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all));
1463                         break; }
1464
1465                         case GROUPINFONAME: {
1466                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1467                         break; }
1468
1469                         case GROUPINFOATTRIBUTES: {
1470                                 NDR_CHECK(ndr_push_samr_GroupInfoAttributes(ndr, NDR_SCALARS, &r->attributes));
1471                         break; }
1472
1473                         case GROUPINFODESCRIPTION: {
1474                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1475                         break; }
1476
1477                         case GROUPINFOALL2: {
1478                                 NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all2));
1479                         break; }
1480
1481                         default:
1482                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1483                 }
1484         }
1485         if (ndr_flags & NDR_BUFFERS) {
1486                 int level = ndr_push_get_switch_value(ndr, r);
1487                 switch (level) {
1488                         case GROUPINFOALL:
1489                                 NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all));
1490                         break;
1491
1492                         case GROUPINFONAME:
1493                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1494                         break;
1495
1496                         case GROUPINFOATTRIBUTES:
1497                         break;
1498
1499                         case GROUPINFODESCRIPTION:
1500                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1501                         break;
1502
1503                         case GROUPINFOALL2:
1504                                 NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all2));
1505                         break;
1506
1507                         default:
1508                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1509                 }
1510         }
1511         return NDR_ERR_SUCCESS;
1512 }
1513
1514 static enum ndr_err_code ndr_pull_samr_GroupInfo(struct ndr_pull *ndr, int ndr_flags, union samr_GroupInfo *r)
1515 {
1516         int level;
1517         uint16_t _level;
1518         level = ndr_pull_get_switch_value(ndr, r);
1519         if (ndr_flags & NDR_SCALARS) {
1520                 NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
1521                 if (_level != level) {
1522                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1523                 }
1524                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
1525                 switch (level) {
1526                         case GROUPINFOALL: {
1527                                 NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all));
1528                         break; }
1529
1530                         case GROUPINFONAME: {
1531                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1532                         break; }
1533
1534                         case GROUPINFOATTRIBUTES: {
1535                                 NDR_CHECK(ndr_pull_samr_GroupInfoAttributes(ndr, NDR_SCALARS, &r->attributes));
1536                         break; }
1537
1538                         case GROUPINFODESCRIPTION: {
1539                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1540                         break; }
1541
1542                         case GROUPINFOALL2: {
1543                                 NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all2));
1544                         break; }
1545
1546                         default:
1547                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1548                 }
1549         }
1550         if (ndr_flags & NDR_BUFFERS) {
1551                 switch (level) {
1552                         case GROUPINFOALL:
1553                                 NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all));
1554                         break;
1555
1556                         case GROUPINFONAME:
1557                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1558                         break;
1559
1560                         case GROUPINFOATTRIBUTES:
1561                         break;
1562
1563                         case GROUPINFODESCRIPTION:
1564                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1565                         break;
1566
1567                         case GROUPINFOALL2:
1568                                 NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all2));
1569                         break;
1570
1571                         default:
1572                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1573                 }
1574         }
1575         return NDR_ERR_SUCCESS;
1576 }
1577
1578 _PUBLIC_ void ndr_print_samr_GroupInfo(struct ndr_print *ndr, const char *name, const union samr_GroupInfo *r)
1579 {
1580         int level;
1581         level = ndr_print_get_switch_value(ndr, r);
1582         ndr_print_union(ndr, name, level, "samr_GroupInfo");
1583         switch (level) {
1584                 case GROUPINFOALL:
1585                         ndr_print_samr_GroupInfoAll(ndr, "all", &r->all);
1586                 break;
1587
1588                 case GROUPINFONAME:
1589                         ndr_print_lsa_String(ndr, "name", &r->name);
1590                 break;
1591
1592                 case GROUPINFOATTRIBUTES:
1593                         ndr_print_samr_GroupInfoAttributes(ndr, "attributes", &r->attributes);
1594                 break;
1595
1596                 case GROUPINFODESCRIPTION:
1597                         ndr_print_lsa_String(ndr, "description", &r->description);
1598                 break;
1599
1600                 case GROUPINFOALL2:
1601                         ndr_print_samr_GroupInfoAll(ndr, "all2", &r->all2);
1602                 break;
1603
1604                 default:
1605                         ndr_print_bad_level(ndr, name, level);
1606         }
1607 }
1608
1609 static enum ndr_err_code ndr_push_samr_RidTypeArray(struct ndr_push *ndr, int ndr_flags, const struct samr_RidTypeArray *r)
1610 {
1611         uint32_t cntr_rids_1;
1612         uint32_t cntr_types_1;
1613         if (ndr_flags & NDR_SCALARS) {
1614                 NDR_CHECK(ndr_push_align(ndr, 5));
1615                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1616                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->rids));
1617                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
1618                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1619         }
1620         if (ndr_flags & NDR_BUFFERS) {
1621                 if (r->rids) {
1622                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
1623                         for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {
1624                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rids[cntr_rids_1]));
1625                         }
1626                 }
1627                 if (r->types) {
1628                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
1629                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
1630                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->types[cntr_types_1]));
1631                         }
1632                 }
1633         }
1634         return NDR_ERR_SUCCESS;
1635 }
1636
1637 static enum ndr_err_code ndr_pull_samr_RidTypeArray(struct ndr_pull *ndr, int ndr_flags, struct samr_RidTypeArray *r)
1638 {
1639         uint32_t _ptr_rids;
1640         uint32_t size_rids_1 = 0;
1641         uint32_t cntr_rids_1;
1642         TALLOC_CTX *_mem_save_rids_0;
1643         TALLOC_CTX *_mem_save_rids_1;
1644         uint32_t _ptr_types;
1645         uint32_t size_types_1 = 0;
1646         uint32_t cntr_types_1;
1647         TALLOC_CTX *_mem_save_types_0;
1648         TALLOC_CTX *_mem_save_types_1;
1649         if (ndr_flags & NDR_SCALARS) {
1650                 NDR_CHECK(ndr_pull_align(ndr, 5));
1651                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1652                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
1653                 if (_ptr_rids) {
1654                         NDR_PULL_ALLOC(ndr, r->rids);
1655                 } else {
1656                         r->rids = NULL;
1657                 }
1658                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
1659                 if (_ptr_types) {
1660                         NDR_PULL_ALLOC(ndr, r->types);
1661                 } else {
1662                         r->types = NULL;
1663                 }
1664                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1665         }
1666         if (ndr_flags & NDR_BUFFERS) {
1667                 if (r->rids) {
1668                         _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1669                         NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
1670                         NDR_CHECK(ndr_pull_array_size(ndr, &r->rids));
1671                         size_rids_1 = ndr_get_array_size(ndr, &r->rids);
1672                         NDR_PULL_ALLOC_N(ndr, r->rids, size_rids_1);
1673                         _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
1674                         NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
1675                         for (cntr_rids_1 = 0; cntr_rids_1 < size_rids_1; cntr_rids_1++) {
1676                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));
1677                         }
1678                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
1679                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
1680                 }
1681                 if (r->types) {
1682                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
1683                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
1684                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
1685                         size_types_1 = ndr_get_array_size(ndr, &r->types);
1686                         NDR_PULL_ALLOC_N(ndr, r->types, size_types_1);
1687                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
1688                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
1689                         for (cntr_types_1 = 0; cntr_types_1 < size_types_1; cntr_types_1++) {
1690                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
1691                         }
1692                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
1693                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
1694                 }
1695                 if (r->rids) {
1696                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->rids, r->count));
1697                 }
1698                 if (r->types) {
1699                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
1700                 }
1701         }
1702         return NDR_ERR_SUCCESS;
1703 }
1704
1705 _PUBLIC_ void ndr_print_samr_RidTypeArray(struct ndr_print *ndr, const char *name, const struct samr_RidTypeArray *r)
1706 {
1707         uint32_t cntr_rids_1;
1708         uint32_t cntr_types_1;
1709         ndr_print_struct(ndr, name, "samr_RidTypeArray");
1710         ndr->depth++;
1711         ndr_print_uint32(ndr, "count", r->count);
1712         ndr_print_ptr(ndr, "rids", r->rids);
1713         ndr->depth++;
1714         if (r->rids) {
1715                 ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->count);
1716                 ndr->depth++;
1717                 for (cntr_rids_1=0;cntr_rids_1<r->count;cntr_rids_1++) {
1718                         char *idx_1=NULL;
1719                         if (asprintf(&idx_1, "[%d]", cntr_rids_1) != -1) {
1720                                 ndr_print_uint32(ndr, "rids", r->rids[cntr_rids_1]);
1721                                 free(idx_1);
1722                         }
1723                 }
1724                 ndr->depth--;
1725         }
1726         ndr->depth--;
1727         ndr_print_ptr(ndr, "types", r->types);
1728         ndr->depth++;
1729         if (r->types) {
1730                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
1731                 ndr->depth++;
1732                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
1733                         char *idx_1=NULL;
1734                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
1735                                 ndr_print_uint32(ndr, "types", r->types[cntr_types_1]);
1736                                 free(idx_1);
1737                         }
1738                 }
1739                 ndr->depth--;
1740         }
1741         ndr->depth--;
1742         ndr->depth--;
1743 }
1744
1745 static enum ndr_err_code ndr_push_samr_AliasInfoAll(struct ndr_push *ndr, int ndr_flags, const struct samr_AliasInfoAll *r)
1746 {
1747         if (ndr_flags & NDR_SCALARS) {
1748                 NDR_CHECK(ndr_push_align(ndr, 5));
1749                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_members));
1751                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1752                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1753         }
1754         if (ndr_flags & NDR_BUFFERS) {
1755                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1756                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1757         }
1758         return NDR_ERR_SUCCESS;
1759 }
1760
1761 static enum ndr_err_code ndr_pull_samr_AliasInfoAll(struct ndr_pull *ndr, int ndr_flags, struct samr_AliasInfoAll *r)
1762 {
1763         if (ndr_flags & NDR_SCALARS) {
1764                 NDR_CHECK(ndr_pull_align(ndr, 5));
1765                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1766                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_members));
1767                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1768                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1769         }
1770         if (ndr_flags & NDR_BUFFERS) {
1771                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1772                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1773         }
1774         return NDR_ERR_SUCCESS;
1775 }
1776
1777 _PUBLIC_ void ndr_print_samr_AliasInfoAll(struct ndr_print *ndr, const char *name, const struct samr_AliasInfoAll *r)
1778 {
1779         ndr_print_struct(ndr, name, "samr_AliasInfoAll");
1780         ndr->depth++;
1781         ndr_print_lsa_String(ndr, "name", &r->name);
1782         ndr_print_uint32(ndr, "num_members", r->num_members);
1783         ndr_print_lsa_String(ndr, "description", &r->description);
1784         ndr->depth--;
1785 }
1786
1787 static enum ndr_err_code ndr_push_samr_AliasInfoEnum(struct ndr_push *ndr, int ndr_flags, enum samr_AliasInfoEnum r)
1788 {
1789         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
1790         return NDR_ERR_SUCCESS;
1791 }
1792
1793 static enum ndr_err_code ndr_pull_samr_AliasInfoEnum(struct ndr_pull *ndr, int ndr_flags, enum samr_AliasInfoEnum *r)
1794 {
1795         uint16_t v;
1796         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
1797         *r = v;
1798         return NDR_ERR_SUCCESS;
1799 }
1800
1801 _PUBLIC_ void ndr_print_samr_AliasInfoEnum(struct ndr_print *ndr, const char *name, enum samr_AliasInfoEnum r)
1802 {
1803         const char *val = NULL;
1804
1805         switch (r) {
1806                 case ALIASINFOALL: val = "ALIASINFOALL"; break;
1807                 case ALIASINFONAME: val = "ALIASINFONAME"; break;
1808                 case ALIASINFODESCRIPTION: val = "ALIASINFODESCRIPTION"; break;
1809         }
1810         ndr_print_enum(ndr, name, "ENUM", val, r);
1811 }
1812
1813 static enum ndr_err_code ndr_push_samr_AliasInfo(struct ndr_push *ndr, int ndr_flags, const union samr_AliasInfo *r)
1814 {
1815         if (ndr_flags & NDR_SCALARS) {
1816                 int level = ndr_push_get_switch_value(ndr, r);
1817                 NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, level));
1818                 NDR_CHECK(ndr_push_union_align(ndr, 5));
1819                 switch (level) {
1820                         case ALIASINFOALL: {
1821                                 NDR_CHECK(ndr_push_samr_AliasInfoAll(ndr, NDR_SCALARS, &r->all));
1822                         break; }
1823
1824                         case ALIASINFONAME: {
1825                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1826                         break; }
1827
1828                         case ALIASINFODESCRIPTION: {
1829                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1830                         break; }
1831
1832                         default:
1833                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1834                 }
1835         }
1836         if (ndr_flags & NDR_BUFFERS) {
1837                 int level = ndr_push_get_switch_value(ndr, r);
1838                 switch (level) {
1839                         case ALIASINFOALL:
1840                                 NDR_CHECK(ndr_push_samr_AliasInfoAll(ndr, NDR_BUFFERS, &r->all));
1841                         break;
1842
1843                         case ALIASINFONAME:
1844                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1845                         break;
1846
1847                         case ALIASINFODESCRIPTION:
1848                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1849                         break;
1850
1851                         default:
1852                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1853                 }
1854         }
1855         return NDR_ERR_SUCCESS;
1856 }
1857
1858 static enum ndr_err_code ndr_pull_samr_AliasInfo(struct ndr_pull *ndr, int ndr_flags, union samr_AliasInfo *r)
1859 {
1860         int level;
1861         uint16_t _level;
1862         level = ndr_pull_get_switch_value(ndr, r);
1863         if (ndr_flags & NDR_SCALARS) {
1864                 NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
1865                 if (_level != level) {
1866                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1867                 }
1868                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
1869                 switch (level) {
1870                         case ALIASINFOALL: {
1871                                 NDR_CHECK(ndr_pull_samr_AliasInfoAll(ndr, NDR_SCALARS, &r->all));
1872                         break; }
1873
1874                         case ALIASINFONAME: {
1875                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1876                         break; }
1877
1878                         case ALIASINFODESCRIPTION: {
1879                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1880                         break; }
1881
1882                         default:
1883                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1884                 }
1885         }
1886         if (ndr_flags & NDR_BUFFERS) {
1887                 switch (level) {
1888                         case ALIASINFOALL:
1889                                 NDR_CHECK(ndr_pull_samr_AliasInfoAll(ndr, NDR_BUFFERS, &r->all));
1890                         break;
1891
1892                         case ALIASINFONAME:
1893                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1894                         break;
1895
1896                         case ALIASINFODESCRIPTION:
1897                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1898                         break;
1899
1900                         default:
1901                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1902                 }
1903         }
1904         return NDR_ERR_SUCCESS;
1905 }
1906
1907 _PUBLIC_ void ndr_print_samr_AliasInfo(struct ndr_print *ndr, const char *name, const union samr_AliasInfo *r)
1908 {
1909         int level;
1910         level = ndr_print_get_switch_value(ndr, r);
1911         ndr_print_union(ndr, name, level, "samr_AliasInfo");
1912         switch (level) {
1913                 case ALIASINFOALL:
1914                         ndr_print_samr_AliasInfoAll(ndr, "all", &r->all);
1915                 break;
1916
1917                 case ALIASINFONAME:
1918                         ndr_print_lsa_String(ndr, "name", &r->name);
1919                 break;
1920
1921                 case ALIASINFODESCRIPTION:
1922                         ndr_print_lsa_String(ndr, "description", &r->description);
1923                 break;
1924
1925                 default:
1926                         ndr_print_bad_level(ndr, name, level);
1927         }
1928 }
1929
1930 static enum ndr_err_code ndr_push_samr_UserInfoLevel(struct ndr_push *ndr, int ndr_flags, enum samr_UserInfoLevel r)
1931 {
1932         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
1933         return NDR_ERR_SUCCESS;
1934 }
1935
1936 static enum ndr_err_code ndr_pull_samr_UserInfoLevel(struct ndr_pull *ndr, int ndr_flags, enum samr_UserInfoLevel *r)
1937 {
1938         uint16_t v;
1939         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
1940         *r = v;
1941         return NDR_ERR_SUCCESS;
1942 }
1943
1944 _PUBLIC_ void ndr_print_samr_UserInfoLevel(struct ndr_print *ndr, const char *name, enum samr_UserInfoLevel r)
1945 {
1946         const char *val = NULL;
1947
1948         switch (r) {
1949                 case UserGeneralInformation: val = "UserGeneralInformation"; break;
1950                 case UserPreferencesInformation: val = "UserPreferencesInformation"; break;
1951                 case UserLogonInformation: val = "UserLogonInformation"; break;
1952                 case UserLogonHoursInformation: val = "UserLogonHoursInformation"; break;
1953                 case UserAccountInformation: val = "UserAccountInformation"; break;
1954                 case UserNameInformation: val = "UserNameInformation"; break;
1955                 case UserAccountNameInformation: val = "UserAccountNameInformation"; break;
1956                 case UserFullNameInformation: val = "UserFullNameInformation"; break;
1957                 case UserPrimaryGroupInformation: val = "UserPrimaryGroupInformation"; break;
1958                 case UserHomeInformation: val = "UserHomeInformation"; break;
1959                 case UserScriptInformation: val = "UserScriptInformation"; break;
1960                 case UserProfileInformation: val = "UserProfileInformation"; break;
1961                 case UserAdminCommentInformation: val = "UserAdminCommentInformation"; break;
1962                 case UserWorkStationsInformation: val = "UserWorkStationsInformation"; break;
1963                 case UserControlInformation: val = "UserControlInformation"; break;
1964                 case UserExpiresInformation: val = "UserExpiresInformation"; break;
1965                 case UserInternal1Information: val = "UserInternal1Information"; break;
1966                 case UserParametersInformation: val = "UserParametersInformation"; break;
1967                 case UserAllInformation: val = "UserAllInformation"; break;
1968                 case UserInternal4Information: val = "UserInternal4Information"; break;
1969                 case UserInternal5Information: val = "UserInternal5Information"; break;
1970                 case UserInternal4InformationNew: val = "UserInternal4InformationNew"; break;
1971                 case UserInternal5InformationNew: val = "UserInternal5InformationNew"; break;
1972         }
1973         ndr_print_enum(ndr, name, "ENUM", val, r);
1974 }
1975
1976 static enum ndr_err_code ndr_push_samr_UserInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo1 *r)
1977 {
1978         if (ndr_flags & NDR_SCALARS) {
1979                 NDR_CHECK(ndr_push_align(ndr, 5));
1980                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
1981                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
1982                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
1983                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1984                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));
1985                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1986         }
1987         if (ndr_flags & NDR_BUFFERS) {
1988                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
1989                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
1990                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1991                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));
1992         }
1993         return NDR_ERR_SUCCESS;
1994 }
1995
1996 static enum ndr_err_code ndr_pull_samr_UserInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo1 *r)
1997 {
1998         if (ndr_flags & NDR_SCALARS) {
1999                 NDR_CHECK(ndr_pull_align(ndr, 5));
2000                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2001                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2002                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
2003                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
2004                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));
2005                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2006         }
2007         if (ndr_flags & NDR_BUFFERS) {
2008                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2009                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2010                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
2011                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));
2012         }
2013         return NDR_ERR_SUCCESS;
2014 }
2015
2016 _PUBLIC_ void ndr_print_samr_UserInfo1(struct ndr_print *ndr, const char *name, const struct samr_UserInfo1 *r)
2017 {
2018         ndr_print_struct(ndr, name, "samr_UserInfo1");
2019         ndr->depth++;
2020         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2021         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2022         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
2023         ndr_print_lsa_String(ndr, "description", &r->description);
2024         ndr_print_lsa_String(ndr, "comment", &r->comment);
2025         ndr->depth--;
2026 }
2027
2028 static enum ndr_err_code ndr_push_samr_UserInfo2(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo2 *r)
2029 {
2030         if (ndr_flags & NDR_SCALARS) {
2031                 NDR_CHECK(ndr_push_align(ndr, 5));
2032                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));
2033                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->unknown));
2034                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->country_code));
2035                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->code_page));
2036                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2037         }
2038         if (ndr_flags & NDR_BUFFERS) {
2039                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));
2040                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->unknown));
2041         }
2042         return NDR_ERR_SUCCESS;
2043 }
2044
2045 static enum ndr_err_code ndr_pull_samr_UserInfo2(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo2 *r)
2046 {
2047         if (ndr_flags & NDR_SCALARS) {
2048                 NDR_CHECK(ndr_pull_align(ndr, 5));
2049                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));
2050                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->unknown));
2051                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->country_code));
2052                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->code_page));
2053                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2054         }
2055         if (ndr_flags & NDR_BUFFERS) {
2056                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));
2057                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->unknown));
2058         }
2059         return NDR_ERR_SUCCESS;
2060 }
2061
2062 _PUBLIC_ void ndr_print_samr_UserInfo2(struct ndr_print *ndr, const char *name, const struct samr_UserInfo2 *r)
2063 {
2064         ndr_print_struct(ndr, name, "samr_UserInfo2");
2065         ndr->depth++;
2066         ndr_print_lsa_String(ndr, "comment", &r->comment);
2067         ndr_print_lsa_String(ndr, "unknown", &r->unknown);
2068         ndr_print_uint16(ndr, "country_code", r->country_code);
2069         ndr_print_uint16(ndr, "code_page", r->code_page);
2070         ndr->depth--;
2071 }
2072
2073 _PUBLIC_ enum ndr_err_code ndr_push_samr_LogonHours(struct ndr_push *ndr, int ndr_flags, const struct samr_LogonHours *r)
2074 {
2075         {
2076                 uint32_t _flags_save_STRUCT = ndr->flags;
2077                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2078                 if (ndr_flags & NDR_SCALARS) {
2079                         NDR_CHECK(ndr_push_align(ndr, 5));
2080                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->units_per_week));
2081                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->bits));
2082                         NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2083                 }
2084                 if (ndr_flags & NDR_BUFFERS) {
2085                         if (r->bits) {
2086                                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 1260));
2087                                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2088                                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->units_per_week / 8));
2089                                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->bits, r->units_per_week / 8));
2090                         }
2091                 }
2092                 ndr->flags = _flags_save_STRUCT;
2093         }
2094         return NDR_ERR_SUCCESS;
2095 }
2096
2097 _PUBLIC_ enum ndr_err_code ndr_pull_samr_LogonHours(struct ndr_pull *ndr, int ndr_flags, struct samr_LogonHours *r)
2098 {
2099         uint32_t _ptr_bits;
2100         uint32_t size_bits_1 = 0;
2101         uint32_t length_bits_1 = 0;
2102         TALLOC_CTX *_mem_save_bits_0;
2103         {
2104                 uint32_t _flags_save_STRUCT = ndr->flags;
2105                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2106                 if (ndr_flags & NDR_SCALARS) {
2107                         NDR_CHECK(ndr_pull_align(ndr, 5));
2108                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->units_per_week));
2109                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bits));
2110                         if (_ptr_bits) {
2111                                 NDR_PULL_ALLOC(ndr, r->bits);
2112                         } else {
2113                                 r->bits = NULL;
2114                         }
2115                         NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2116                 }
2117                 if (ndr_flags & NDR_BUFFERS) {
2118                         if (r->bits) {
2119                                 _mem_save_bits_0 = NDR_PULL_GET_MEM_CTX(ndr);
2120                                 NDR_PULL_SET_MEM_CTX(ndr, r->bits, 0);
2121                                 NDR_CHECK(ndr_pull_array_size(ndr, &r->bits));
2122                                 NDR_CHECK(ndr_pull_array_length(ndr, &r->bits));
2123                                 size_bits_1 = ndr_get_array_size(ndr, &r->bits);
2124                                 length_bits_1 = ndr_get_array_length(ndr, &r->bits);
2125                                 if (length_bits_1 > size_bits_1) {
2126                                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_bits_1, length_bits_1);
2127                                 }
2128                                 NDR_PULL_ALLOC_N(ndr, r->bits, size_bits_1);
2129                                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->bits, length_bits_1));
2130                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bits_0, 0);
2131                         }
2132                         if (r->bits) {
2133                                 NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->bits, 1260));
2134                         }
2135                         if (r->bits) {
2136                                 NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->bits, r->units_per_week / 8));
2137                         }
2138                 }
2139                 ndr->flags = _flags_save_STRUCT;
2140         }
2141         return NDR_ERR_SUCCESS;
2142 }
2143
2144 _PUBLIC_ void ndr_print_samr_LogonHours(struct ndr_print *ndr, const char *name, const struct samr_LogonHours *r)
2145 {
2146         ndr_print_struct(ndr, name, "samr_LogonHours");
2147         {
2148                 uint32_t _flags_save_STRUCT = ndr->flags;
2149                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2150                 ndr->depth++;
2151                 ndr_print_uint16(ndr, "units_per_week", r->units_per_week);
2152                 ndr_print_ptr(ndr, "bits", r->bits);
2153                 ndr->depth++;
2154                 if (r->bits) {
2155                         ndr_print_array_uint8(ndr, "bits", r->bits, r->units_per_week / 8);
2156                 }
2157                 ndr->depth--;
2158                 ndr->depth--;
2159                 ndr->flags = _flags_save_STRUCT;
2160         }
2161 }
2162
2163 static enum ndr_err_code ndr_push_samr_UserInfo3(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo3 *r)
2164 {
2165         if (ndr_flags & NDR_SCALARS) {
2166                 NDR_CHECK(ndr_push_align(ndr, 5));
2167                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2168                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2169                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
2170                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
2171                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2172                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2173                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2174                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2175                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2176                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));
2177                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));
2178                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));
2179                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->allow_password_change));
2180                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_password_change));
2181                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2182                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));
2183                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
2184                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
2185                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2186         }
2187         if (ndr_flags & NDR_BUFFERS) {
2188                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2189                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2190                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2191                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2192                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2193                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2194                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2195                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2196         }
2197         return NDR_ERR_SUCCESS;
2198 }
2199
2200 static enum ndr_err_code ndr_pull_samr_UserInfo3(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo3 *r)
2201 {
2202         if (ndr_flags & NDR_SCALARS) {
2203                 NDR_CHECK(ndr_pull_align(ndr, 5));
2204                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2205                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2206                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
2207                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
2208                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2209                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2210                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2211                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2212                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2213                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));
2214                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));
2215                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));
2216                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->allow_password_change));
2217                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_password_change));
2218                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2219                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));
2220                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
2221                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
2222                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2223         }
2224         if (ndr_flags & NDR_BUFFERS) {
2225                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2226                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2227                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2228                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2229                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2230                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2231                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2232                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2233         }
2234         return NDR_ERR_SUCCESS;
2235 }
2236
2237 _PUBLIC_ void ndr_print_samr_UserInfo3(struct ndr_print *ndr, const char *name, const struct samr_UserInfo3 *r)
2238 {
2239         ndr_print_struct(ndr, name, "samr_UserInfo3");
2240         ndr->depth++;
2241         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2242         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2243         ndr_print_uint32(ndr, "rid", r->rid);
2244         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
2245         ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
2246         ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
2247         ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
2248         ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
2249         ndr_print_lsa_String(ndr, "workstations", &r->workstations);
2250         ndr_print_NTTIME(ndr, "last_logon", r->last_logon);
2251         ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);
2252         ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);
2253         ndr_print_NTTIME(ndr, "allow_password_change", r->allow_password_change);
2254         ndr_print_NTTIME(ndr, "force_password_change", r->force_password_change);
2255         ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
2256         ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);
2257         ndr_print_uint16(ndr, "logon_count", r->logon_count);
2258         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
2259         ndr->depth--;
2260 }
2261
2262 static enum ndr_err_code ndr_push_samr_UserInfo4(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo4 *r)
2263 {
2264         if (ndr_flags & NDR_SCALARS) {
2265                 NDR_CHECK(ndr_push_align(ndr, 5));
2266                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2267                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2268         }
2269         if (ndr_flags & NDR_BUFFERS) {
2270                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2271         }
2272         return NDR_ERR_SUCCESS;
2273 }
2274
2275 static enum ndr_err_code ndr_pull_samr_UserInfo4(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo4 *r)
2276 {
2277         if (ndr_flags & NDR_SCALARS) {
2278                 NDR_CHECK(ndr_pull_align(ndr, 5));
2279                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2280                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2281         }
2282         if (ndr_flags & NDR_BUFFERS) {
2283                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2284         }
2285         return NDR_ERR_SUCCESS;
2286 }
2287
2288 _PUBLIC_ void ndr_print_samr_UserInfo4(struct ndr_print *ndr, const char *name, const struct samr_UserInfo4 *r)
2289 {
2290         ndr_print_struct(ndr, name, "samr_UserInfo4");
2291         ndr->depth++;
2292         ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
2293         ndr->depth--;
2294 }
2295
2296 static enum ndr_err_code ndr_push_samr_UserInfo5(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo5 *r)
2297 {
2298         if (ndr_flags & NDR_SCALARS) {
2299                 NDR_CHECK(ndr_push_align(ndr, 5));
2300                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2301                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2302                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
2303                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
2304                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2305                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2306                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2307                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2308                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
2309                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2310                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));
2311                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));
2312                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2313                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));
2314                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
2315                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));
2316                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
2317                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
2318                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2319         }
2320         if (ndr_flags & NDR_BUFFERS) {
2321                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2322                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2323                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2324                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2325                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2326                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2327                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
2328                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2329                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2330         }
2331         return NDR_ERR_SUCCESS;
2332 }
2333
2334 static enum ndr_err_code ndr_pull_samr_UserInfo5(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo5 *r)
2335 {
2336         if (ndr_flags & NDR_SCALARS) {
2337                 NDR_CHECK(ndr_pull_align(ndr, 5));
2338                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2339                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
2341                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
2342                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2343                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2344                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2345                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2346                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
2347                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2348                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));
2349                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));
2350                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2351                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));
2352                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
2353                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));
2354                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
2355                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
2356                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2357         }
2358         if (ndr_flags & NDR_BUFFERS) {
2359                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2360                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2361                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2362                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2363                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2364                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2365                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
2366                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2367                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2368         }
2369         return NDR_ERR_SUCCESS;
2370 }
2371
2372 _PUBLIC_ void ndr_print_samr_UserInfo5(struct ndr_print *ndr, const char *name, const struct samr_UserInfo5 *r)
2373 {
2374         ndr_print_struct(ndr, name, "samr_UserInfo5");
2375         ndr->depth++;
2376         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2377         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2378         ndr_print_uint32(ndr, "rid", r->rid);
2379         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
2380         ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
2381         ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
2382         ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
2383         ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
2384         ndr_print_lsa_String(ndr, "description", &r->description);
2385         ndr_print_lsa_String(ndr, "workstations", &r->workstations);
2386         ndr_print_NTTIME(ndr, "last_logon", r->last_logon);
2387         ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);
2388         ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
2389         ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);
2390         ndr_print_uint16(ndr, "logon_count", r->logon_count);
2391         ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);
2392         ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);
2393         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
2394         ndr->depth--;
2395 }
2396
2397 static enum ndr_err_code ndr_push_samr_UserInfo6(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo6 *r)
2398 {
2399         if (ndr_flags & NDR_SCALARS) {
2400                 NDR_CHECK(ndr_push_align(ndr, 5));
2401                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2402                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2403                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2404         }
2405         if (ndr_flags & NDR_BUFFERS) {
2406                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2407                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2408         }
2409         return NDR_ERR_SUCCESS;
2410 }
2411
2412 static enum ndr_err_code ndr_pull_samr_UserInfo6(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo6 *r)
2413 {
2414         if (ndr_flags & NDR_SCALARS) {
2415                 NDR_CHECK(ndr_pull_align(ndr, 5));
2416                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2417                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2418                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2419         }
2420         if (ndr_flags & NDR_BUFFERS) {
2421                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2422                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2423         }
2424         return NDR_ERR_SUCCESS;
2425 }
2426
2427 _PUBLIC_ void ndr_print_samr_UserInfo6(struct ndr_print *ndr, const char *name, const struct samr_UserInfo6 *r)
2428 {
2429         ndr_print_struct(ndr, name, "samr_UserInfo6");
2430         ndr->depth++;
2431         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2432         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2433         ndr->depth--;
2434 }
2435
2436 static enum ndr_err_code ndr_push_samr_UserInfo7(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo7 *r)
2437 {
2438         if (ndr_flags & NDR_SCALARS) {
2439                 NDR_CHECK(ndr_push_align(ndr, 5));
2440                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2441                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2442         }
2443         if (ndr_flags & NDR_BUFFERS) {
2444                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2445         }
2446         return NDR_ERR_SUCCESS;
2447 }
2448
2449 static enum ndr_err_code ndr_pull_samr_UserInfo7(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo7 *r)
2450 {
2451         if (ndr_flags & NDR_SCALARS) {
2452                 NDR_CHECK(ndr_pull_align(ndr, 5));
2453                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2454                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2455         }
2456         if (ndr_flags & NDR_BUFFERS) {
2457                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2458         }
2459         return NDR_ERR_SUCCESS;
2460 }
2461
2462 _PUBLIC_ void ndr_print_samr_UserInfo7(struct ndr_print *ndr, const char *name, const struct samr_UserInfo7 *r)
2463 {
2464         ndr_print_struct(ndr, name, "samr_UserInfo7");
2465         ndr->depth++;
2466         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2467         ndr->depth--;
2468 }
2469
2470 static enum ndr_err_code ndr_push_samr_UserInfo8(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo8 *r)
2471 {
2472         if (ndr_flags & NDR_SCALARS) {
2473                 NDR_CHECK(ndr_push_align(ndr, 5));
2474                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2475                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2476         }
2477         if (ndr_flags & NDR_BUFFERS) {
2478                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2479         }
2480         return NDR_ERR_SUCCESS;
2481 }
2482
2483 static enum ndr_err_code ndr_pull_samr_UserInfo8(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo8 *r)
2484 {
2485         if (ndr_flags & NDR_SCALARS) {
2486                 NDR_CHECK(ndr_pull_align(ndr, 5));
2487                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2488                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2489         }
2490         if (ndr_flags & NDR_BUFFERS) {
2491                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2492         }
2493         return NDR_ERR_SUCCESS;
2494 }
2495
2496 _PUBLIC_ void ndr_print_samr_UserInfo8(struct ndr_print *ndr, const char *name, const struct samr_UserInfo8 *r)
2497 {
2498         ndr_print_struct(ndr, name, "samr_UserInfo8");
2499         ndr->depth++;
2500         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2501         ndr->depth--;
2502 }
2503
2504 static enum ndr_err_code ndr_push_samr_UserInfo9(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo9 *r)
2505 {
2506         if (ndr_flags & NDR_SCALARS) {
2507                 NDR_CHECK(ndr_push_align(ndr, 4));
2508                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
2509                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2510         }
2511         if (ndr_flags & NDR_BUFFERS) {
2512         }
2513         return NDR_ERR_SUCCESS;
2514 }
2515
2516 static enum ndr_err_code ndr_pull_samr_UserInfo9(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo9 *r)
2517 {
2518         if (ndr_flags & NDR_SCALARS) {
2519                 NDR_CHECK(ndr_pull_align(ndr, 4));
2520                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
2521                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2522         }
2523         if (ndr_flags & NDR_BUFFERS) {
2524         }
2525         return NDR_ERR_SUCCESS;
2526 }
2527
2528 _PUBLIC_ void ndr_print_samr_UserInfo9(struct ndr_print *ndr, const char *name, const struct samr_UserInfo9 *r)
2529 {
2530         ndr_print_struct(ndr, name, "samr_UserInfo9");
2531         ndr->depth++;
2532         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
2533         ndr->depth--;
2534 }
2535
2536 static enum ndr_err_code ndr_push_samr_UserInfo10(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo10 *r)
2537 {
2538         if (ndr_flags & NDR_SCALARS) {
2539                 NDR_CHECK(ndr_push_align(ndr, 5));
2540                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2541                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2542                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2543         }
2544         if (ndr_flags & NDR_BUFFERS) {
2545                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2546                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2547         }
2548         return NDR_ERR_SUCCESS;
2549 }
2550
2551 static enum ndr_err_code ndr_pull_samr_UserInfo10(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo10 *r)
2552 {
2553         if (ndr_flags & NDR_SCALARS) {
2554                 NDR_CHECK(ndr_pull_align(ndr, 5));
2555                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2556                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2557                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2558         }
2559         if (ndr_flags & NDR_BUFFERS) {
2560                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2561                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2562         }
2563         return NDR_ERR_SUCCESS;
2564 }
2565
2566 _PUBLIC_ void ndr_print_samr_UserInfo10(struct ndr_print *ndr, const char *name, const struct samr_UserInfo10 *r)
2567 {
2568         ndr_print_struct(ndr, name, "samr_UserInfo10");
2569         ndr->depth++;
2570         ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
2571         ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
2572         ndr->depth--;
2573 }
2574
2575 static enum ndr_err_code ndr_push_samr_UserInfo11(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo11 *r)
2576 {
2577         if (ndr_flags & NDR_SCALARS) {
2578                 NDR_CHECK(ndr_push_align(ndr, 5));
2579                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2580                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2581         }
2582         if (ndr_flags & NDR_BUFFERS) {
2583                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2584         }
2585         return NDR_ERR_SUCCESS;
2586 }
2587
2588 static enum ndr_err_code ndr_pull_samr_UserInfo11(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo11 *r)
2589 {
2590         if (ndr_flags & NDR_SCALARS) {
2591                 NDR_CHECK(ndr_pull_align(ndr, 5));
2592                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2593                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2594         }
2595         if (ndr_flags & NDR_BUFFERS) {
2596                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2597         }
2598         return NDR_ERR_SUCCESS;
2599 }
2600
2601 _PUBLIC_ void ndr_print_samr_UserInfo11(struct ndr_print *ndr, const char *name, const struct samr_UserInfo11 *r)
2602 {
2603         ndr_print_struct(ndr, name, "samr_UserInfo11");
2604         ndr->depth++;
2605         ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
2606         ndr->depth--;
2607 }
2608
2609 static enum ndr_err_code ndr_push_samr_UserInfo12(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo12 *r)
2610 {
2611         if (ndr_flags & NDR_SCALARS) {
2612                 NDR_CHECK(ndr_push_align(ndr, 5));
2613                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2614                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2615         }
2616         if (ndr_flags & NDR_BUFFERS) {
2617                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2618         }
2619         return NDR_ERR_SUCCESS;
2620 }
2621
2622 static enum ndr_err_code ndr_pull_samr_UserInfo12(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo12 *r)
2623 {
2624         if (ndr_flags & NDR_SCALARS) {
2625                 NDR_CHECK(ndr_pull_align(ndr, 5));
2626                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2627                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2628         }
2629         if (ndr_flags & NDR_BUFFERS) {
2630                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2631         }
2632         return NDR_ERR_SUCCESS;
2633 }
2634
2635 _PUBLIC_ void ndr_print_samr_UserInfo12(struct ndr_print *ndr, const char *name, const struct samr_UserInfo12 *r)
2636 {
2637         ndr_print_struct(ndr, name, "samr_UserInfo12");
2638         ndr->depth++;
2639         ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
2640         ndr->depth--;
2641 }
2642
2643 static enum ndr_err_code ndr_push_samr_UserInfo13(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo13 *r)
2644 {
2645         if (ndr_flags & NDR_SCALARS) {
2646                 NDR_CHECK(ndr_push_align(ndr, 5));
2647                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
2648                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2649         }
2650         if (ndr_flags & NDR_BUFFERS) {
2651                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
2652         }
2653         return NDR_ERR_SUCCESS;
2654 }
2655
2656 static enum ndr_err_code ndr_pull_samr_UserInfo13(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo13 *r)
2657 {
2658         if (ndr_flags & NDR_SCALARS) {
2659                 NDR_CHECK(ndr_pull_align(ndr, 5));
2660                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
2661                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2662         }
2663         if (ndr_flags & NDR_BUFFERS) {
2664                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
2665         }
2666         return NDR_ERR_SUCCESS;
2667 }
2668
2669 _PUBLIC_ void ndr_print_samr_UserInfo13(struct ndr_print *ndr, const char *name, const struct samr_UserInfo13 *r)
2670 {
2671         ndr_print_struct(ndr, name, "samr_UserInfo13");
2672         ndr->depth++;
2673         ndr_print_lsa_String(ndr, "description", &r->description);
2674         ndr->depth--;
2675 }
2676
2677 static enum ndr_err_code ndr_push_samr_UserInfo14(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo14 *r)
2678 {
2679         if (ndr_flags & NDR_SCALARS) {
2680                 NDR_CHECK(ndr_push_align(ndr, 5));
2681                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2682                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2683         }
2684         if (ndr_flags & NDR_BUFFERS) {
2685                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2686         }
2687         return NDR_ERR_SUCCESS;
2688 }
2689
2690 static enum ndr_err_code ndr_pull_samr_UserInfo14(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo14 *r)
2691 {
2692         if (ndr_flags & NDR_SCALARS) {
2693                 NDR_CHECK(ndr_pull_align(ndr, 5));
2694                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2695                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2696         }
2697         if (ndr_flags & NDR_BUFFERS) {
2698                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2699         }
2700         return NDR_ERR_SUCCESS;
2701 }
2702
2703 _PUBLIC_ void ndr_print_samr_UserInfo14(struct ndr_print *ndr, const char *name, const struct samr_UserInfo14 *r)
2704 {
2705         ndr_print_struct(ndr, name, "samr_UserInfo14");
2706         ndr->depth++;
2707         ndr_print_lsa_String(ndr, "workstations", &r->workstations);
2708         ndr->depth--;
2709 }
2710
2711 static enum ndr_err_code ndr_push_samr_UserInfo16(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo16 *r)
2712 {
2713         if (ndr_flags & NDR_SCALARS) {
2714                 NDR_CHECK(ndr_push_align(ndr, 4));
2715                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
2716                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2717         }
2718         if (ndr_flags & NDR_BUFFERS) {
2719         }
2720         return NDR_ERR_SUCCESS;
2721 }
2722
2723 static enum ndr_err_code ndr_pull_samr_UserInfo16(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo16 *r)
2724 {
2725         if (ndr_flags & NDR_SCALARS) {
2726                 NDR_CHECK(ndr_pull_align(ndr, 4));
2727                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
2728                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2729         }
2730         if (ndr_flags & NDR_BUFFERS) {
2731         }
2732         return NDR_ERR_SUCCESS;
2733 }
2734
2735 _PUBLIC_ void ndr_print_samr_UserInfo16(struct ndr_print *ndr, const char *name, const struct samr_UserInfo16 *r)
2736 {
2737         ndr_print_struct(ndr, name, "samr_UserInfo16");
2738         ndr->depth++;
2739         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
2740         ndr->depth--;
2741 }
2742
2743 static enum ndr_err_code ndr_push_samr_UserInfo17(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo17 *r)
2744 {
2745         if (ndr_flags & NDR_SCALARS) {
2746                 NDR_CHECK(ndr_push_align(ndr, 4));
2747                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
2748                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2749         }
2750         if (ndr_flags & NDR_BUFFERS) {
2751         }
2752         return NDR_ERR_SUCCESS;
2753 }
2754
2755 static enum ndr_err_code ndr_pull_samr_UserInfo17(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo17 *r)
2756 {
2757         if (ndr_flags & NDR_SCALARS) {
2758                 NDR_CHECK(ndr_pull_align(ndr, 4));
2759                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
2760                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2761         }
2762         if (ndr_flags & NDR_BUFFERS) {
2763         }
2764         return NDR_ERR_SUCCESS;
2765 }
2766
2767 _PUBLIC_ void ndr_print_samr_UserInfo17(struct ndr_print *ndr, const char *name, const struct samr_UserInfo17 *r)
2768 {
2769         ndr_print_struct(ndr, name, "samr_UserInfo17");
2770         ndr->depth++;
2771         ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);
2772         ndr->depth--;
2773 }
2774
2775 _PUBLIC_ enum ndr_err_code ndr_push_samr_Password(struct ndr_push *ndr, int ndr_flags, const struct samr_Password *r)
2776 {
2777         {
2778                 uint32_t _flags_save_STRUCT = ndr->flags;
2779                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2780                 if (ndr_flags & NDR_SCALARS) {
2781                         NDR_CHECK(ndr_push_align(ndr, 1));
2782                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
2783                         NDR_CHECK(ndr_push_trailer_align(ndr, 1));
2784                 }
2785                 if (ndr_flags & NDR_BUFFERS) {
2786                 }
2787                 ndr->flags = _flags_save_STRUCT;
2788         }
2789         return NDR_ERR_SUCCESS;
2790 }
2791
2792 _PUBLIC_ enum ndr_err_code ndr_pull_samr_Password(struct ndr_pull *ndr, int ndr_flags, struct samr_Password *r)
2793 {
2794         uint32_t size_hash_0 = 0;
2795         {
2796                 uint32_t _flags_save_STRUCT = ndr->flags;
2797                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2798                 if (ndr_flags & NDR_SCALARS) {
2799                         NDR_CHECK(ndr_pull_align(ndr, 1));
2800                         size_hash_0 = 16;
2801                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->hash, size_hash_0));
2802                         NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
2803                 }
2804                 if (ndr_flags & NDR_BUFFERS) {
2805                 }
2806                 ndr->flags = _flags_save_STRUCT;
2807         }
2808         return NDR_ERR_SUCCESS;
2809 }
2810
2811 _PUBLIC_ void ndr_print_samr_Password(struct ndr_print *ndr, const char *name, const struct samr_Password *r)
2812 {
2813         ndr_print_struct(ndr, name, "samr_Password");
2814         {
2815                 uint32_t _flags_save_STRUCT = ndr->flags;
2816                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2817                 ndr->depth++;
2818                 ndr_print_array_uint8(ndr, "hash", r->hash, 16);
2819                 ndr->depth--;
2820                 ndr->flags = _flags_save_STRUCT;
2821         }
2822 }
2823
2824 static enum ndr_err_code ndr_push_samr_UserInfo18(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo18 *r)
2825 {
2826         if (ndr_flags & NDR_SCALARS) {
2827                 NDR_CHECK(ndr_push_align(ndr, 1));
2828                 NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->nt_pwd));
2829                 NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->lm_pwd));
2830                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->nt_pwd_active));
2831                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->lm_pwd_active));
2832                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
2833                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
2834         }
2835         if (ndr_flags & NDR_BUFFERS) {
2836         }
2837         return NDR_ERR_SUCCESS;
2838 }
2839
2840 static enum ndr_err_code ndr_pull_samr_UserInfo18(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo18 *r)
2841 {
2842         if (ndr_flags & NDR_SCALARS) {
2843                 NDR_CHECK(ndr_pull_align(ndr, 1));
2844                 NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->nt_pwd));
2845                 NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->lm_pwd));
2846                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->nt_pwd_active));
2847                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->lm_pwd_active));
2848                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
2849                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
2850         }
2851         if (ndr_flags & NDR_BUFFERS) {
2852         }
2853         return NDR_ERR_SUCCESS;
2854 }
2855
2856 _PUBLIC_ void ndr_print_samr_UserInfo18(struct ndr_print *ndr, const char *name, const struct samr_UserInfo18 *r)
2857 {
2858         ndr_print_struct(ndr, name, "samr_UserInfo18");
2859         ndr->depth++;
2860         ndr_print_samr_Password(ndr, "nt_pwd", &r->nt_pwd);
2861         ndr_print_samr_Password(ndr, "lm_pwd", &r->lm_pwd);
2862         ndr_print_uint8(ndr, "nt_pwd_active", r->nt_pwd_active);
2863         ndr_print_uint8(ndr, "lm_pwd_active", r->lm_pwd_active);
2864         ndr_print_uint8(ndr, "password_expired", r->password_expired);
2865         ndr->depth--;
2866 }
2867
2868 static enum ndr_err_code ndr_push_samr_UserInfo20(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo20 *r)
2869 {
2870         if (ndr_flags & NDR_SCALARS) {
2871                 NDR_CHECK(ndr_push_align(ndr, 5));
2872                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
2873                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2874         }
2875         if (ndr_flags & NDR_BUFFERS) {
2876                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
2877         }
2878         return NDR_ERR_SUCCESS;
2879 }
2880
2881 static enum ndr_err_code ndr_pull_samr_UserInfo20(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo20 *r)
2882 {
2883         if (ndr_flags & NDR_SCALARS) {
2884                 NDR_CHECK(ndr_pull_align(ndr, 5));
2885                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
2886                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2887         }
2888         if (ndr_flags & NDR_BUFFERS) {
2889                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
2890         }
2891         return NDR_ERR_SUCCESS;
2892 }
2893
2894 _PUBLIC_ void ndr_print_samr_UserInfo20(struct ndr_print *ndr, const char *name, const struct samr_UserInfo20 *r)
2895 {
2896         ndr_print_struct(ndr, name, "samr_UserInfo20");
2897         ndr->depth++;
2898         ndr_print_lsa_BinaryString(ndr, "parameters", &r->parameters);
2899         ndr->depth--;
2900 }
2901
2902 static enum ndr_err_code ndr_push_samr_FieldsPresent(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2903 {
2904         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2905         return NDR_ERR_SUCCESS;
2906 }
2907
2908 static enum ndr_err_code ndr_pull_samr_FieldsPresent(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2909 {
2910         uint32_t v;
2911         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2912         *r = v;
2913         return NDR_ERR_SUCCESS;
2914 }
2915
2916 _PUBLIC_ void ndr_print_samr_FieldsPresent(struct ndr_print *ndr, const char *name, uint32_t r)
2917 {
2918         ndr_print_uint32(ndr, name, r);
2919         ndr->depth++;
2920         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCOUNT_NAME", SAMR_FIELD_ACCOUNT_NAME, r);
2921         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_FULL_NAME", SAMR_FIELD_FULL_NAME, r);
2922         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_RID", SAMR_FIELD_RID, r);
2923         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PRIMARY_GID", SAMR_FIELD_PRIMARY_GID, r);
2924         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_DESCRIPTION", SAMR_FIELD_DESCRIPTION, r);
2925         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_COMMENT", SAMR_FIELD_COMMENT, r);
2926         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_HOME_DIRECTORY", SAMR_FIELD_HOME_DIRECTORY, r);
2927         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_HOME_DRIVE", SAMR_FIELD_HOME_DRIVE, r);
2928         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LOGON_SCRIPT", SAMR_FIELD_LOGON_SCRIPT, r);
2929         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PROFILE_PATH", SAMR_FIELD_PROFILE_PATH, r);
2930         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_WORKSTATIONS", SAMR_FIELD_WORKSTATIONS, r);
2931         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_LOGON", SAMR_FIELD_LAST_LOGON, r);
2932         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_LOGOFF", SAMR_FIELD_LAST_LOGOFF, r);
2933         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LOGON_HOURS", SAMR_FIELD_LOGON_HOURS, r);
2934         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_BAD_PWD_COUNT", SAMR_FIELD_BAD_PWD_COUNT, r);
2935         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_NUM_LOGONS", SAMR_FIELD_NUM_LOGONS, r);
2936         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ALLOW_PWD_CHANGE", SAMR_FIELD_ALLOW_PWD_CHANGE, r);
2937         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_FORCE_PWD_CHANGE", SAMR_FIELD_FORCE_PWD_CHANGE, r);
2938         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_PWD_CHANGE", SAMR_FIELD_LAST_PWD_CHANGE, r);
2939         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCT_EXPIRY", SAMR_FIELD_ACCT_EXPIRY, r);
2940         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCT_FLAGS", SAMR_FIELD_ACCT_FLAGS, r);
2941         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PARAMETERS", SAMR_FIELD_PARAMETERS, r);
2942         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_COUNTRY_CODE", SAMR_FIELD_COUNTRY_CODE, r);
2943         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_CODE_PAGE", SAMR_FIELD_CODE_PAGE, r);
2944         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_NT_PASSWORD_PRESENT", SAMR_FIELD_NT_PASSWORD_PRESENT, r);
2945         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LM_PASSWORD_PRESENT", SAMR_FIELD_LM_PASSWORD_PRESENT, r);
2946         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PRIVATE_DATA", SAMR_FIELD_PRIVATE_DATA, r);
2947         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_EXPIRED_FLAG", SAMR_FIELD_EXPIRED_FLAG, r);
2948         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_SEC_DESC", SAMR_FIELD_SEC_DESC, r);
2949         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_OWF_PWD", SAMR_FIELD_OWF_PWD, r);
2950         ndr->depth--;
2951 }
2952
2953 static enum ndr_err_code ndr_push_samr_UserInfo21(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo21 *r)
2954 {
2955         if (ndr_flags & NDR_SCALARS) {
2956                 NDR_CHECK(ndr_push_align(ndr, 5));
2957                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));
2958                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));
2959                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));
2960                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
2961                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->allow_password_change));
2962                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_password_change));
2963                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2964                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2965                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2966                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2967                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2968                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2969                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
2970                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2971                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));
2972                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
2973                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->lm_owf_password));
2974                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->nt_owf_password));
2975                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->unknown3));
2976                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_count));
2977                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->buffer));
2978                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
2979                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
2980                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
2981                 NDR_CHECK(ndr_push_samr_FieldsPresent(ndr, NDR_SCALARS, r->fields_present));
2982                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2983                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));
2984                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
2985                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->country_code));
2986                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->code_page));
2987                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->lm_password_set));
2988                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->nt_password_set));
2989                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
2990                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->unknown4));
2991                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2992         }
2993         if (ndr_flags & NDR_BUFFERS) {
2994                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2995                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2996                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2997                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2998                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2999                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
3000                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
3001                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
3002                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));
3003                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
3004                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->lm_owf_password));
3005                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->nt_owf_password));
3006                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->unknown3));
3007                 if (r->buffer) {
3008                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->buf_count));
3009                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->buffer, r->buf_count));
3010                 }
3011                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
3012         }
3013         return NDR_ERR_SUCCESS;
3014 }
3015
3016 static enum ndr_err_code ndr_pull_samr_UserInfo21(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo21 *r)
3017 {
3018         uint32_t _ptr_buffer;
3019         uint32_t size_buffer_1 = 0;
3020         TALLOC_CTX *_mem_save_buffer_0;
3021         if (ndr_flags & NDR_SCALARS) {
3022                 NDR_CHECK(ndr_pull_align(ndr, 5));
3023                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));
3024                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));
3025                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));
3026                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
3027                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->allow_password_change));
3028                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_password_change));
3029                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
3030                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
3031                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
3032                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
3033                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
3034                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
3035                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
3036                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
3037                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));
3038                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
3039                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->lm_owf_password));
3040                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->nt_owf_password));
3041                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->unknown3));
3042                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_count));
3043                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
3044                 if (_ptr_buffer) {
3045                         NDR_PULL_ALLOC(ndr, r->buffer);
3046                 } else {
3047                         r->buffer = NULL;
3048                 }
3049                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
3050                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
3051                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
3052                 NDR_CHECK(ndr_pull_samr_FieldsPresent(ndr, NDR_SCALARS, &r->fields_present));
3053                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
3054                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));
3055                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
3056                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->country_code));
3057                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->code_page));
3058                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->lm_password_set));
3059                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->nt_password_set));
3060                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
3061                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->unknown4));
3062                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3063         }
3064         if (ndr_flags & NDR_BUFFERS) {
3065                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
3066                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
3067                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
3068                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
3069                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
3070                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
3071                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
3072                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
3073                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));
3074                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
3075                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->lm_owf_password));
3076                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->nt_owf_password));
3077                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->unknown3));
3078                 if (r->buffer) {
3079                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
3080                         NDR_PULL_SET_MEM_CTX(ndr, r->buffer, 0);
3081                         NDR_CHECK(ndr_pull_array_size(ndr, &r->buffer));
3082                         size_buffer_1 = ndr_get_array_size(ndr, &r->buffer);
3083                         NDR_PULL_ALLOC_N(ndr, r->buffer, size_buffer_1);
3084                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->buffer, size_buffer_1));
3085                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
3086                 }
3087                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
3088                 if (r->buffer) {
3089                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->buffer, r->buf_count));
3090                 }
3091         }
3092         return NDR_ERR_SUCCESS;
3093 }
3094
3095 _PUBLIC_ void ndr_print_samr_UserInfo21(struct ndr_print *ndr, const char *name, const struct samr_UserInfo21 *r)
3096 {
3097         ndr_print_struct(ndr, name, "samr_UserInfo21");
3098         ndr->depth++;
3099         ndr_print_NTTIME(ndr, "last_logon", r->last_logon);
3100         ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);
3101         ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);
3102         ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);
3103         ndr_print_NTTIME(ndr, "allow_password_change", r->allow_password_change);
3104         ndr_print_NTTIME(ndr, "force_password_change", r->force_password_change);
3105         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
3106         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
3107         ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
3108         ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
3109         ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
3110         ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
3111         ndr_print_lsa_String(ndr, "description", &r->description);
3112         ndr_print_lsa_String(ndr, "workstations", &r->workstations);
3113         ndr_print_lsa_String(ndr, "comment", &r->comment);
3114         ndr_print_lsa_BinaryString(ndr, "parameters", &r->parameters);
3115         ndr_print_lsa_BinaryString(ndr, "lm_owf_password", &r->lm_owf_password);
3116         ndr_print_lsa_BinaryString(ndr, "nt_owf_password", &r->nt_owf_password);
3117         ndr_print_lsa_String(ndr, "unknown3", &r->unknown3);
3118         ndr_print_uint32(ndr, "buf_count", r->buf_count);
3119         ndr_print_ptr(ndr, "buffer", r->buffer);
3120         ndr->depth++;
3121         if (r->buffer) {
3122                 ndr_print_array_uint8(ndr, "buffer", r->buffer, r->buf_count);
3123         }
3124         ndr->depth--;
3125         ndr_print_uint32(ndr, "rid", r->rid);
3126         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
3127         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
3128         ndr_print_samr_FieldsPresent(ndr, "fields_present", r->fields_present);
3129         ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
3130         ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);
3131         ndr_print_uint16(ndr, "logon_count", r->logon_count);
3132         ndr_print_uint16(ndr, "country_code", r->country_code);
3133         ndr_print_uint16(ndr, "code_page", r->code_page);
3134         ndr_print_uint8(ndr, "lm_password_set", r->lm_password_set);
3135         ndr_print_uint8(ndr, "nt_password_set", r->nt_password_set);
3136         ndr_print_uint8(ndr, "password_expired", r->password_expired);
3137         ndr_print_uint8(ndr, "unknown4", r->unknown4);
3138         ndr->depth--;
3139 }
3140
3141 _PUBLIC_ enum ndr_err_code ndr_push_samr_CryptPassword(struct ndr_push *ndr, int ndr_flags, const struct samr_CryptPassword *r)
3142 {
3143         {
3144                 uint32_t _flags_save_STRUCT = ndr->flags;
3145                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3146                 if (ndr_flags & NDR_SCALARS) {
3147                         NDR_CHECK(ndr_push_align(ndr, 1));
3148                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 516));
3149                         NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3150                 }
3151                 if (ndr_flags & NDR_BUFFERS) {
3152                 }
3153                 ndr->flags = _flags_save_STRUCT;
3154         }
3155         return NDR_ERR_SUCCESS;
3156 }
3157
3158 _PUBLIC_ enum ndr_err_code ndr_pull_samr_CryptPassword(struct ndr_pull *ndr, int ndr_flags, struct samr_CryptPassword *r)
3159 {
3160         uint32_t size_data_0 = 0;
3161         {
3162                 uint32_t _flags_save_STRUCT = ndr->flags;
3163                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3164                 if (ndr_flags & NDR_SCALARS) {
3165                         NDR_CHECK(ndr_pull_align(ndr, 1));
3166                         size_data_0 = 516;
3167                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, size_data_0));
3168                         NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3169                 }
3170                 if (ndr_flags & NDR_BUFFERS) {
3171                 }
3172                 ndr->flags = _flags_save_STRUCT;
3173         }
3174         return NDR_ERR_SUCCESS;
3175 }
3176
3177 _PUBLIC_ void ndr_print_samr_CryptPassword(struct ndr_print *ndr, const char *name, const struct samr_CryptPassword *r)
3178 {
3179         ndr_print_struct(ndr, name, "samr_CryptPassword");
3180         {
3181                 uint32_t _flags_save_STRUCT = ndr->flags;
3182                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3183                 ndr->depth++;
3184                 ndr_print_array_uint8(ndr, "data", r->data, 516);
3185                 ndr->depth--;
3186                 ndr->flags = _flags_save_STRUCT;
3187         }
3188 }
3189
3190 static enum ndr_err_code ndr_push_samr_UserInfo23(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo23 *r)
3191 {
3192         if (ndr_flags & NDR_SCALARS) {
3193                 NDR_CHECK(ndr_push_align(ndr, 5));
3194                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
3195                 NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
3196                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3197         }
3198         if (ndr_flags & NDR_BUFFERS) {
3199                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
3200         }
3201         return NDR_ERR_SUCCESS;
3202 }
3203
3204 static enum ndr_err_code ndr_pull_samr_UserInfo23(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo23 *r)
3205 {
3206         if (ndr_flags & NDR_SCALARS) {
3207                 NDR_CHECK(ndr_pull_align(ndr, 5));
3208                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
3209                 NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
3210                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3211         }
3212         if (ndr_flags & NDR_BUFFERS) {
3213                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
3214         }
3215         return NDR_ERR_SUCCESS;
3216 }
3217
3218 _PUBLIC_ void ndr_print_samr_UserInfo23(struct ndr_print *ndr, const char *name, const struct samr_UserInfo23 *r)
3219 {
3220         ndr_print_struct(ndr, name, "samr_UserInfo23");
3221         ndr->depth++;
3222         ndr_print_samr_UserInfo21(ndr, "info", &r->info);
3223         ndr_print_samr_CryptPassword(ndr, "password", &r->password);
3224         ndr->depth--;
3225 }
3226
3227 static enum ndr_err_code ndr_push_samr_UserInfo24(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo24 *r)
3228 {
3229         if (ndr_flags & NDR_SCALARS) {
3230                 NDR_CHECK(ndr_push_align(ndr, 1));
3231                 NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
3232                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
3233                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3234         }
3235         if (ndr_flags & NDR_BUFFERS) {
3236         }
3237         return NDR_ERR_SUCCESS;
3238 }
3239
3240 static enum ndr_err_code ndr_pull_samr_UserInfo24(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo24 *r)
3241 {
3242         if (ndr_flags & NDR_SCALARS) {
3243                 NDR_CHECK(ndr_pull_align(ndr, 1));
3244                 NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
3245                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
3246                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3247         }
3248         if (ndr_flags & NDR_BUFFERS) {
3249         }
3250         return NDR_ERR_SUCCESS;
3251 }
3252
3253 _PUBLIC_ void ndr_print_samr_UserInfo24(struct ndr_print *ndr, const char *name, const struct samr_UserInfo24 *r)
3254 {
3255         ndr_print_struct(ndr, name, "samr_UserInfo24");
3256         ndr->depth++;
3257         ndr_print_samr_CryptPassword(ndr, "password", &r->password);
3258         ndr_print_uint8(ndr, "password_expired", r->password_expired);
3259         ndr->depth--;
3260 }
3261
3262 static enum ndr_err_code ndr_push_samr_CryptPasswordEx(struct ndr_push *ndr, int ndr_flags, const struct samr_CryptPasswordEx *r)
3263 {
3264         {
3265                 uint32_t _flags_save_STRUCT = ndr->flags;
3266                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3267                 if (ndr_flags & NDR_SCALARS) {
3268                         NDR_CHECK(ndr_push_align(ndr, 1));
3269                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 532));
3270                         NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3271                 }
3272                 if (ndr_flags & NDR_BUFFERS) {
3273                 }
3274                 ndr->flags = _flags_save_STRUCT;
3275         }
3276         return NDR_ERR_SUCCESS;
3277 }
3278
3279 static enum ndr_err_code ndr_pull_samr_CryptPasswordEx(struct ndr_pull *ndr, int ndr_flags, struct samr_CryptPasswordEx *r)
3280 {
3281         uint32_t size_data_0 = 0;
3282         {
3283                 uint32_t _flags_save_STRUCT = ndr->flags;
3284                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3285                 if (ndr_flags & NDR_SCALARS) {
3286                         NDR_CHECK(ndr_pull_align(ndr, 1));
3287                         size_data_0 = 532;
3288                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, size_data_0));
3289                         NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3290                 }
3291                 if (ndr_flags & NDR_BUFFERS) {
3292                 }
3293                 ndr->flags = _flags_save_STRUCT;
3294         }
3295         return NDR_ERR_SUCCESS;
3296 }
3297
3298 _PUBLIC_ void ndr_print_samr_CryptPasswordEx(struct ndr_print *ndr, const char *name, const struct samr_CryptPasswordEx *r)
3299 {
3300         ndr_print_struct(ndr, name, "samr_CryptPasswordEx");
3301         {
3302                 uint32_t _flags_save_STRUCT = ndr->flags;
3303                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3304                 ndr->depth++;
3305                 ndr_print_array_uint8(ndr, "data", r->data, 532);
3306                 ndr->depth--;
3307                 ndr->flags = _flags_save_STRUCT;
3308         }
3309 }
3310
3311 static enum ndr_err_code ndr_push_samr_UserInfo25(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo25 *r)
3312 {
3313         if (ndr_flags & NDR_SCALARS) {
3314                 NDR_CHECK(ndr_push_align(ndr, 5));
3315                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
3316                 NDR_CHECK(ndr_push_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
3317                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3318         }
3319         if (ndr_flags & NDR_BUFFERS) {
3320                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
3321         }
3322         return NDR_ERR_SUCCESS;
3323 }
3324
3325 static enum ndr_err_code ndr_pull_samr_UserInfo25(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo25 *r)
3326 {
3327         if (ndr_flags & NDR_SCALARS) {
3328                 NDR_CHECK(ndr_pull_align(ndr, 5));
3329                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
3330                 NDR_CHECK(ndr_pull_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
3331                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3332         }
3333         if (ndr_flags & NDR_BUFFERS) {
3334                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
3335         }
3336         return NDR_ERR_SUCCESS;
3337 }
3338
3339 _PUBLIC_ void ndr_print_samr_UserInfo25(struct ndr_print *ndr, const char *name, const struct samr_UserInfo25 *r)
3340 {
3341         ndr_print_struct(ndr, name, "samr_UserInfo25");
3342         ndr->depth++;
3343         ndr_print_samr_UserInfo21(ndr, "info", &r->info);
3344         ndr_print_samr_CryptPasswordEx(ndr, "password", &r->password);
3345         ndr->depth--;
3346 }
3347
3348 static enum ndr_err_code ndr_push_samr_UserInfo26(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo26 *r)
3349 {
3350         if (ndr_flags & NDR_SCALARS) {
3351                 NDR_CHECK(ndr_push_align(ndr, 1));
3352                 NDR_CHECK(ndr_push_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
3353                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
3354                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3355         }
3356         if (ndr_flags & NDR_BUFFERS) {
3357         }
3358         return NDR_ERR_SUCCESS;
3359 }
3360
3361 static enum ndr_err_code ndr_pull_samr_UserInfo26(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo26 *r)
3362 {
3363         if (ndr_flags & NDR_SCALARS) {
3364                 NDR_CHECK(ndr_pull_align(ndr, 1));
3365                 NDR_CHECK(ndr_pull_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
3366                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
3367                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3368         }
3369         if (ndr_flags & NDR_BUFFERS) {
3370         }
3371         return NDR_ERR_SUCCESS;
3372 }
3373
3374 _PUBLIC_ void ndr_print_samr_UserInfo26(struct ndr_print *ndr, const char *name, const struct samr_UserInfo26 *r)
3375 {
3376         ndr_print_struct(ndr, name, "samr_UserInfo26");
3377         ndr->depth++;
3378         ndr_print_samr_CryptPasswordEx(ndr, "password", &r->password);
3379         ndr_print_uint8(ndr, "password_expired", r->password_expired);
3380         ndr->depth--;
3381 }
3382
3383 static enum ndr_err_code ndr_push_samr_UserInfo(struct ndr_push *ndr, int ndr_flags, const union samr_UserInfo *r)
3384 {
3385         if (ndr_flags & NDR_SCALARS) {
3386                 int level = ndr_push_get_switch_value(ndr, r);
3387                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
3388                 NDR_CHECK(ndr_push_union_align(ndr, 5));
3389                 switch (level) {
3390                         case 1: {
3391                                 NDR_CHECK(ndr_push_samr_UserInfo1(ndr, NDR_SCALARS, &r->info1));
3392                         break; }
3393
3394                         case 2: {
3395                                 NDR_CHECK(ndr_push_samr_UserInfo2(ndr, NDR_SCALARS, &r->info2));
3396                         break; }
3397
3398                         case 3: {
3399                                 NDR_CHECK(ndr_push_samr_UserInfo3(ndr, NDR_SCALARS, &r->info3));
3400                         break; }
3401
3402                         case 4: {
3403                                 NDR_CHECK(ndr_push_samr_UserInfo4(ndr, NDR_SCALARS, &r->info4));
3404                         break; }
3405
3406                         case 5: {
3407                                 NDR_CHECK(ndr_push_samr_UserInfo5(ndr, NDR_SCALARS, &r->info5));
3408                         break; }
3409
3410                         case 6: {
3411                                 NDR_CHECK(ndr_push_samr_UserInfo6(ndr, NDR_SCALARS, &r->info6));
3412                         break; }
3413
3414                         case 7: {
3415                                 NDR_CHECK(ndr_push_samr_UserInfo7(ndr, NDR_SCALARS, &r->info7));
3416                         break; }
3417
3418                         case 8: {
3419                                 NDR_CHECK(ndr_push_samr_UserInfo8(ndr, NDR_SCALARS, &r->info8));
3420                         break; }
3421
3422                         case 9: {
3423                                 NDR_CHECK(ndr_push_samr_UserInfo9(ndr, NDR_SCALARS, &r->info9));
3424                         break; }
3425
3426                         case 10: {
3427                                 NDR_CHECK(ndr_push_samr_UserInfo10(ndr, NDR_SCALARS, &r->info10));
3428                         break; }
3429
3430                         case 11: {
3431                                 NDR_CHECK(ndr_push_samr_UserInfo11(ndr, NDR_SCALARS, &r->info11));
3432                         break; }
3433
3434                         case 12: {
3435                                 NDR_CHECK(ndr_push_samr_UserInfo12(ndr, NDR_SCALARS, &r->info12));
3436                         break; }
3437
3438                         case 13: {
3439                                 NDR_CHECK(ndr_push_samr_UserInfo13(ndr, NDR_SCALARS, &r->info13));
3440                         break; }
3441
3442                         case 14: {
3443                                 NDR_CHECK(ndr_push_samr_UserInfo14(ndr, NDR_SCALARS, &r->info14));
3444                         break; }
3445
3446                         case 16: {
3447                                 NDR_CHECK(ndr_push_samr_UserInfo16(ndr, NDR_SCALARS, &r->info16));
3448                         break; }
3449
3450                         case 17: {
3451                                 NDR_CHECK(ndr_push_samr_UserInfo17(ndr, NDR_SCALARS, &r->info17));
3452                         break; }
3453
3454                         case 18: {
3455                                 NDR_CHECK(ndr_push_samr_UserInfo18(ndr, NDR_SCALARS, &r->info18));
3456                         break; }
3457
3458                         case 20: {
3459                                 NDR_CHECK(ndr_push_samr_UserInfo20(ndr, NDR_SCALARS, &r->info20));
3460                         break; }
3461
3462                         case 21: {
3463                                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info21));
3464                         break; }
3465
3466                         case 23: {
3467                                 NDR_CHECK(ndr_push_samr_UserInfo23(ndr, NDR_SCALARS, &r->info23));
3468                         break; }
3469
3470                         case 24: {
3471                                 NDR_CHECK(ndr_push_samr_UserInfo24(ndr, NDR_SCALARS, &r->info24));
3472                         break; }
3473
3474                         case 25: {
3475                                 NDR_CHECK(ndr_push_samr_UserInfo25(ndr, NDR_SCALARS, &r->info25));
3476                         break; }
3477
3478                         case 26: {
3479                                 NDR_CHECK(ndr_push_samr_UserInfo26(ndr, NDR_SCALARS, &r->info26));
3480                         break; }
3481
3482                         default:
3483                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3484                 }
3485         }
3486         if (ndr_flags & NDR_BUFFERS) {
3487                 int level = ndr_push_get_switch_value(ndr, r);
3488                 switch (level) {
3489                         case 1:
3490                                 NDR_CHECK(ndr_push_samr_UserInfo1(ndr, NDR_BUFFERS, &r->info1));
3491                         break;
3492
3493                         case 2:
3494                                 NDR_CHECK(ndr_push_samr_UserInfo2(ndr, NDR_BUFFERS, &r->info2));
3495                         break;
3496
3497                         case 3:
3498                                 NDR_CHECK(ndr_push_samr_UserInfo3(ndr, NDR_BUFFERS, &r->info3));
3499                         break;
3500
3501                         case 4:
3502                                 NDR_CHECK(ndr_push_samr_UserInfo4(ndr, NDR_BUFFERS, &r->info4));
3503                         break;
3504
3505                         case 5:
3506                                 NDR_CHECK(ndr_push_samr_UserInfo5(ndr, NDR_BUFFERS, &r->info5));
3507                         break;
3508
3509                         case 6:
3510                                 NDR_CHECK(ndr_push_samr_UserInfo6(ndr, NDR_BUFFERS, &r->info6));
3511                         break;
3512
3513                         case 7:
3514                                 NDR_CHECK(ndr_push_samr_UserInfo7(ndr, NDR_BUFFERS, &r->info7));
3515                         break;
3516
3517                         case 8:
3518                                 NDR_CHECK(ndr_push_samr_UserInfo8(ndr, NDR_BUFFERS, &r->info8));
3519                         break;
3520
3521                         case 9:
3522                         break;
3523
3524                         case 10:
3525                                 NDR_CHECK(ndr_push_samr_UserInfo10(ndr, NDR_BUFFERS, &r->info10));
3526                         break;
3527
3528                         case 11:
3529                                 NDR_CHECK(ndr_push_samr_UserInfo11(ndr, NDR_BUFFERS, &r->info11));
3530                         break;
3531
3532                         case 12:
3533                                 NDR_CHECK(ndr_push_samr_UserInfo12(ndr, NDR_BUFFERS, &r->info12));
3534                         break;
3535
3536                         case 13:
3537                                 NDR_CHECK(ndr_push_samr_UserInfo13(ndr, NDR_BUFFERS, &r->info13));
3538                         break;
3539
3540                         case 14:
3541                                 NDR_CHECK(ndr_push_samr_UserInfo14(ndr, NDR_BUFFERS, &r->info14));
3542                         break;
3543
3544                         case 16:
3545                         break;
3546
3547                         case 17:
3548                         break;
3549
3550                         case 18:
3551                         break;
3552
3553                         case 20:
3554                                 NDR_CHECK(ndr_push_samr_UserInfo20(ndr, NDR_BUFFERS, &r->info20));
3555                         break;
3556
3557                         case 21:
3558                                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info21));
3559                         break;
3560
3561                         case 23:
3562                                 NDR_CHECK(ndr_push_samr_UserInfo23(ndr, NDR_BUFFERS, &r->info23));
3563                         break;
3564
3565                         case 24:
3566                         break;
3567
3568                         case 25:
3569                                 NDR_CHECK(ndr_push_samr_UserInfo25(ndr, NDR_BUFFERS, &r->info25));
3570                         break;
3571
3572                         case 26:
3573                         break;
3574
3575                         default:
3576                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3577                 }
3578         }
3579         return NDR_ERR_SUCCESS;
3580 }
3581
3582 static enum ndr_err_code ndr_pull_samr_UserInfo(struct ndr_pull *ndr, int ndr_flags, union samr_UserInfo *r)
3583 {
3584         int level;
3585         uint16_t _level;
3586         level = ndr_pull_get_switch_value(ndr, r);
3587         if (ndr_flags & NDR_SCALARS) {
3588                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
3589                 if (_level != level) {
3590                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3591                 }
3592                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
3593                 switch (level) {
3594                         case 1: {
3595                                 NDR_CHECK(ndr_pull_samr_UserInfo1(ndr, NDR_SCALARS, &r->info1));
3596                         break; }
3597
3598                         case 2: {
3599                                 NDR_CHECK(ndr_pull_samr_UserInfo2(ndr, NDR_SCALARS, &r->info2));
3600                         break; }
3601
3602                         case 3: {
3603                                 NDR_CHECK(ndr_pull_samr_UserInfo3(ndr, NDR_SCALARS, &r->info3));
3604                         break; }
3605
3606                         case 4: {
3607                                 NDR_CHECK(ndr_pull_samr_UserInfo4(ndr, NDR_SCALARS, &r->info4));
3608                         break; }
3609
3610                         case 5: {
3611                                 NDR_CHECK(ndr_pull_samr_UserInfo5(ndr, NDR_SCALARS, &r->info5));
3612                         break; }
3613
3614                         case 6: {
3615                                 NDR_CHECK(ndr_pull_samr_UserInfo6(ndr, NDR_SCALARS, &r->info6));
3616                         break; }
3617
3618                         case 7: {
3619                                 NDR_CHECK(ndr_pull_samr_UserInfo7(ndr, NDR_SCALARS, &r->info7));
3620                         break; }
3621
3622                         case 8: {
3623                                 NDR_CHECK(ndr_pull_samr_UserInfo8(ndr, NDR_SCALARS, &r->info8));
3624                         break; }
3625
3626                         case 9: {
3627                                 NDR_CHECK(ndr_pull_samr_UserInfo9(ndr, NDR_SCALARS, &r->info9));
3628                         break; }
3629
3630                         case 10: {
3631                                 NDR_CHECK(ndr_pull_samr_UserInfo10(ndr, NDR_SCALARS, &r->info10));
3632                         break; }
3633
3634                         case 11: {
3635                                 NDR_CHECK(ndr_pull_samr_UserInfo11(ndr, NDR_SCALARS, &r->info11));
3636                         break; }
3637
3638                         case 12: {
3639                                 NDR_CHECK(ndr_pull_samr_UserInfo12(ndr, NDR_SCALARS, &r->info12));
3640                         break; }
3641
3642                         case 13: {
3643                                 NDR_CHECK(ndr_pull_samr_UserInfo13(ndr, NDR_SCALARS, &r->info13));
3644                         break; }
3645
3646                         case 14: {
3647                                 NDR_CHECK(ndr_pull_samr_UserInfo14(ndr, NDR_SCALARS, &r->info14));
3648                         break; }
3649
3650                         case 16: {
3651                                 NDR_CHECK(ndr_pull_samr_UserInfo16(ndr, NDR_SCALARS, &r->info16));
3652                         break; }
3653
3654                         case 17: {
3655                                 NDR_CHECK(ndr_pull_samr_UserInfo17(ndr, NDR_SCALARS, &r->info17));
3656                         break; }
3657
3658                         case 18: {
3659                                 NDR_CHECK(ndr_pull_samr_UserInfo18(ndr, NDR_SCALARS, &r->info18));
3660                         break; }
3661
3662                         case 20: {
3663                                 NDR_CHECK(ndr_pull_samr_UserInfo20(ndr, NDR_SCALARS, &r->info20));
3664                         break; }
3665
3666                         case 21: {
3667                                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info21));
3668                         break; }
3669
3670                         case 23: {
3671                                 NDR_CHECK(ndr_pull_samr_UserInfo23(ndr, NDR_SCALARS, &r->info23));
3672                         break; }
3673
3674                         case 24: {
3675                                 NDR_CHECK(ndr_pull_samr_UserInfo24(ndr, NDR_SCALARS, &r->info24));
3676                         break; }
3677
3678                         case 25: {
3679                                 NDR_CHECK(ndr_pull_samr_UserInfo25(ndr, NDR_SCALARS, &r->info25));
3680                         break; }
3681
3682                         case 26: {
3683                                 NDR_CHECK(ndr_pull_samr_UserInfo26(ndr, NDR_SCALARS, &r->info26));
3684                         break; }
3685
3686                         default:
3687                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3688                 }
3689         }
3690         if (ndr_flags & NDR_BUFFERS) {
3691                 switch (level) {
3692                         case 1:
3693                                 NDR_CHECK(ndr_pull_samr_UserInfo1(ndr, NDR_BUFFERS, &r->info1));
3694                         break;
3695
3696                         case 2:
3697                                 NDR_CHECK(ndr_pull_samr_UserInfo2(ndr, NDR_BUFFERS, &r->info2));
3698                         break;
3699
3700                         case 3:
3701                                 NDR_CHECK(ndr_pull_samr_UserInfo3(ndr, NDR_BUFFERS, &r->info3));
3702                         break;
3703
3704                         case 4:
3705                                 NDR_CHECK(ndr_pull_samr_UserInfo4(ndr, NDR_BUFFERS, &r->info4));
3706                         break;
3707
3708                         case 5:
3709                                 NDR_CHECK(ndr_pull_samr_UserInfo5(ndr, NDR_BUFFERS, &r->info5));
3710                         break;
3711
3712                         case 6:
3713                                 NDR_CHECK(ndr_pull_samr_UserInfo6(ndr, NDR_BUFFERS, &r->info6));
3714                         break;
3715
3716                         case 7:
3717                                 NDR_CHECK(ndr_pull_samr_UserInfo7(ndr, NDR_BUFFERS, &r->info7));
3718                         break;
3719
3720                         case 8:
3721                                 NDR_CHECK(ndr_pull_samr_UserInfo8(ndr, NDR_BUFFERS, &r->info8));
3722                         break;
3723
3724                         case 9:
3725                         break;
3726
3727                         case 10:
3728                                 NDR_CHECK(ndr_pull_samr_UserInfo10(ndr, NDR_BUFFERS, &r->info10));
3729                         break;
3730
3731                         case 11:
3732                                 NDR_CHECK(ndr_pull_samr_UserInfo11(ndr, NDR_BUFFERS, &r->info11));
3733                         break;
3734
3735                         case 12:
3736                                 NDR_CHECK(ndr_pull_samr_UserInfo12(ndr, NDR_BUFFERS, &r->info12));
3737                         break;
3738
3739                         case 13:
3740                                 NDR_CHECK(ndr_pull_samr_UserInfo13(ndr, NDR_BUFFERS, &r->info13));
3741                         break;
3742
3743                         case 14:
3744                                 NDR_CHECK(ndr_pull_samr_UserInfo14(ndr, NDR_BUFFERS, &r->info14));
3745                         break;
3746
3747                         case 16:
3748                         break;
3749
3750                         case 17:
3751                         break;
3752
3753                         case 18:
3754                         break;
3755
3756                         case 20:
3757                                 NDR_CHECK(ndr_pull_samr_UserInfo20(ndr, NDR_BUFFERS, &r->info20));
3758                         break;
3759
3760                         case 21:
3761                                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info21));
3762                         break;
3763
3764                         case 23:
3765                                 NDR_CHECK(ndr_pull_samr_UserInfo23(ndr, NDR_BUFFERS, &r->info23));
3766                         break;
3767
3768                         case 24:
3769                         break;
3770
3771                         case 25:
3772                                 NDR_CHECK(ndr_pull_samr_UserInfo25(ndr, NDR_BUFFERS, &r->info25));
3773                         break;
3774
3775                         case 26:
3776                         break;
3777
3778                         default:
3779                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3780                 }
3781         }
3782         return NDR_ERR_SUCCESS;
3783 }
3784
3785 _PUBLIC_ void ndr_print_samr_UserInfo(struct ndr_print *ndr, const char *name, const union samr_UserInfo *r)
3786 {
3787         int level;
3788         level = ndr_print_get_switch_value(ndr, r);
3789         ndr_print_union(ndr, name, level, "samr_UserInfo");
3790         switch (level) {
3791                 case 1:
3792                         ndr_print_samr_UserInfo1(ndr, "info1", &r->info1);
3793                 break;
3794
3795                 case 2:
3796                         ndr_print_samr_UserInfo2(ndr, "info2", &r->info2);
3797                 break;
3798
3799                 case 3:
3800                         ndr_print_samr_UserInfo3(ndr, "info3", &r->info3);
3801                 break;
3802
3803                 case 4:
3804                         ndr_print_samr_UserInfo4(ndr, "info4", &r->info4);
3805                 break;
3806
3807                 case 5:
3808                         ndr_print_samr_UserInfo5(ndr, "info5", &r->info5);
3809                 break;
3810
3811                 case 6:
3812                         ndr_print_samr_UserInfo6(ndr, "info6", &r->info6);
3813                 break;
3814
3815                 case 7:
3816                         ndr_print_samr_UserInfo7(ndr, "info7", &r->info7);
3817                 break;
3818
3819                 case 8:
3820                         ndr_print_samr_UserInfo8(ndr, "info8", &r->info8);
3821                 break;
3822
3823                 case 9:
3824                         ndr_print_samr_UserInfo9(ndr, "info9", &r->info9);
3825                 break;
3826
3827                 case 10:
3828                         ndr_print_samr_UserInfo10(ndr, "info10", &r->info10);
3829                 break;
3830
3831                 case 11:
3832                         ndr_print_samr_UserInfo11(ndr, "info11", &r->info11);
3833                 break;
3834
3835                 case 12:
3836                         ndr_print_samr_UserInfo12(ndr, "info12", &r->info12);
3837                 break;
3838
3839                 case 13:
3840                         ndr_print_samr_UserInfo13(ndr, "info13", &r->info13);
3841                 break;
3842
3843                 case 14:
3844                         ndr_print_samr_UserInfo14(ndr, "info14", &r->info14);
3845                 break;
3846
3847                 case 16:
3848                         ndr_print_samr_UserInfo16(ndr, "info16", &r->info16);
3849                 break;
3850
3851                 case 17:
3852                         ndr_print_samr_UserInfo17(ndr, "info17", &r->info17);
3853                 break;
3854
3855                 case 18:
3856                         ndr_print_samr_UserInfo18(ndr, "info18", &r->info18);
3857                 break;
3858
3859                 case 20:
3860                         ndr_print_samr_UserInfo20(ndr, "info20", &r->info20);
3861                 break;
3862
3863                 case 21:
3864                         ndr_print_samr_UserInfo21(ndr, "info21", &r->info21);
3865                 break;
3866
3867                 case 23:
3868                         ndr_print_samr_UserInfo23(ndr, "info23", &r->info23);
3869                 break;
3870
3871                 case 24:
3872                         ndr_print_samr_UserInfo24(ndr, "info24", &r->info24);
3873                 break;
3874
3875                 case 25:
3876                         ndr_print_samr_UserInfo25(ndr, "info25", &r->info25);
3877                 break;
3878
3879                 case 26:
3880                         ndr_print_samr_UserInfo26(ndr, "info26", &r->info26);
3881                 break;
3882
3883                 default:
3884                         ndr_print_bad_level(ndr, name, level);
3885         }
3886 }
3887
3888 _PUBLIC_ enum ndr_err_code ndr_push_samr_RidWithAttribute(struct ndr_push *ndr, int ndr_flags, const struct samr_RidWithAttribute *r)
3889 {
3890         if (ndr_flags & NDR_SCALARS) {
3891                 NDR_CHECK(ndr_push_align(ndr, 4));
3892                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
3893                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
3894                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
3895         }
3896         if (ndr_flags & NDR_BUFFERS) {
3897         }
3898         return NDR_ERR_SUCCESS;
3899 }
3900
3901 _PUBLIC_ enum ndr_err_code ndr_pull_samr_RidWithAttribute(struct ndr_pull *ndr, int ndr_flags, struct samr_RidWithAttribute *r)
3902 {
3903         if (ndr_flags & NDR_SCALARS) {
3904                 NDR_CHECK(ndr_pull_align(ndr, 4));
3905                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
3906                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
3907                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
3908         }
3909         if (ndr_flags & NDR_BUFFERS) {
3910         }
3911         return NDR_ERR_SUCCESS;
3912 }
3913
3914 _PUBLIC_ void ndr_print_samr_RidWithAttribute(struct ndr_print *ndr, const char *name, const struct samr_RidWithAttribute *r)
3915 {
3916         ndr_print_struct(ndr, name, "samr_RidWithAttribute");
3917         ndr->depth++;
3918         ndr_print_uint32(ndr, "rid", r->rid);
3919         ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);
3920         ndr->depth--;
3921 }
3922
3923 _PUBLIC_ enum ndr_err_code ndr_push_samr_RidWithAttributeArray(struct ndr_push *ndr, int ndr_flags, const struct samr_RidWithAttributeArray *r)
3924 {
3925         uint32_t cntr_rids_1;
3926         if (ndr_flags & NDR_SCALARS) {
3927                 NDR_CHECK(ndr_push_align(ndr, 5));
3928                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3929                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->rids));
3930                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3931         }
3932         if (ndr_flags & NDR_BUFFERS) {
3933                 if (r->rids) {
3934                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
3935                         for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {
3936                                 NDR_CHECK(ndr_push_samr_RidWithAttribute(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));
3937                         }
3938                 }
3939         }
3940         return NDR_ERR_SUCCESS;
3941 }
3942
3943 _PUBLIC_ enum ndr_err_code ndr_pull_samr_RidWithAttributeArray(struct ndr_pull *ndr, int ndr_flags, struct samr_RidWithAttributeArray *r)
3944 {
3945         uint32_t _ptr_rids;
3946         uint32_t size_rids_1 = 0;
3947         uint32_t cntr_rids_1;
3948         TALLOC_CTX *_mem_save_rids_0;
3949         TALLOC_CTX *_mem_save_rids_1;
3950         if (ndr_flags & NDR_SCALARS) {
3951                 NDR_CHECK(ndr_pull_align(ndr, 5));
3952                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3953                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
3954                 if (_ptr_rids) {
3955                         NDR_PULL_ALLOC(ndr, r->rids);
3956                 } else {
3957                         r->rids = NULL;
3958                 }
3959                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3960         }
3961         if (ndr_flags & NDR_BUFFERS) {
3962                 if (r->rids) {
3963                         _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
3964                         NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
3965                         NDR_CHECK(ndr_pull_array_size(ndr, &r->rids));
3966                         size_rids_1 = ndr_get_array_size(ndr, &r->rids);
3967                         NDR_PULL_ALLOC_N(ndr, r->rids, size_rids_1);
3968                         _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
3969                         NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
3970                         for (cntr_rids_1 = 0; cntr_rids_1 < size_rids_1; cntr_rids_1++) {
3971                                 NDR_CHECK(ndr_pull_samr_RidWithAttribute(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));
3972                         }
3973                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
3974                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
3975                 }
3976                 if (r->rids) {
3977                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->rids, r->count));
3978                 }
3979         }
3980         return NDR_ERR_SUCCESS;
3981 }
3982
3983 _PUBLIC_ void ndr_print_samr_RidWithAttributeArray(struct ndr_print *ndr, const char *name, const struct samr_RidWithAttributeArray *r)
3984 {
3985         uint32_t cntr_rids_1;
3986         ndr_print_struct(ndr, name, "samr_RidWithAttributeArray");
3987         ndr->depth++;
3988         ndr_print_uint32(ndr, "count", r->count);
3989         ndr_print_ptr(ndr, "rids", r->rids);
3990         ndr->depth++;
3991         if (r->rids) {
3992                 ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->count);
3993                 ndr->depth++;
3994                 for (cntr_rids_1=0;cntr_rids_1<r->count;cntr_rids_1++) {
3995                         char *idx_1=NULL;
3996                         if (asprintf(&idx_1, "[%d]", cntr_rids_1) != -1) {
3997                                 ndr_print_samr_RidWithAttribute(ndr, "rids", &r->rids[cntr_rids_1]);
3998                                 free(idx_1);
3999                         }
4000                 }
4001                 ndr->depth--;
4002         }
4003         ndr->depth--;
4004         ndr->depth--;
4005 }
4006
4007 static enum ndr_err_code ndr_push_samr_DispEntryGeneral(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryGeneral *r)
4008 {
4009         if (ndr_flags & NDR_SCALARS) {
4010                 NDR_CHECK(ndr_push_align(ndr, 5));
4011                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
4012                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
4013                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
4014                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
4015                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
4016                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
4017                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4018         }
4019         if (ndr_flags & NDR_BUFFERS) {
4020                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
4021                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
4022                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
4023         }
4024         return NDR_ERR_SUCCESS;
4025 }
4026
4027 static enum ndr_err_code ndr_pull_samr_DispEntryGeneral(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryGeneral *r)
4028 {
4029         if (ndr_flags & NDR_SCALARS) {
4030                 NDR_CHECK(ndr_pull_align(ndr, 5));
4031                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
4032                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
4033                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
4034                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
4035                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
4036                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
4037                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4038         }
4039         if (ndr_flags & NDR_BUFFERS) {
4040                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
4041                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
4042                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
4043         }
4044         return NDR_ERR_SUCCESS;
4045 }
4046
4047 _PUBLIC_ void ndr_print_samr_DispEntryGeneral(struct ndr_print *ndr, const char *name, const struct samr_DispEntryGeneral *r)
4048 {
4049         ndr_print_struct(ndr, name, "samr_DispEntryGeneral");
4050         ndr->depth++;
4051         ndr_print_uint32(ndr, "idx", r->idx);
4052         ndr_print_uint32(ndr, "rid", r->rid);
4053         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
4054         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
4055         ndr_print_lsa_String(ndr, "description", &r->description);
4056         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
4057         ndr->depth--;
4058 }
4059
4060 static enum ndr_err_code ndr_push_samr_DispInfoGeneral(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoGeneral *r)
4061 {
4062         uint32_t cntr_entries_1;
4063         if (ndr_flags & NDR_SCALARS) {
4064                 NDR_CHECK(ndr_push_align(ndr, 5));
4065                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4066                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
4067                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4068         }
4069         if (ndr_flags & NDR_BUFFERS) {
4070                 if (r->entries) {
4071                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
4072                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4073                                 NDR_CHECK(ndr_push_samr_DispEntryGeneral(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4074                         }
4075                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4076                                 NDR_CHECK(ndr_push_samr_DispEntryGeneral(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4077                         }
4078                 }
4079         }
4080         return NDR_ERR_SUCCESS;
4081 }
4082
4083 static enum ndr_err_code ndr_pull_samr_DispInfoGeneral(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoGeneral *r)
4084 {
4085         uint32_t _ptr_entries;
4086         uint32_t size_entries_1 = 0;
4087         uint32_t cntr_entries_1;
4088         TALLOC_CTX *_mem_save_entries_0;
4089         TALLOC_CTX *_mem_save_entries_1;
4090         if (ndr_flags & NDR_SCALARS) {
4091                 NDR_CHECK(ndr_pull_align(ndr, 5));
4092                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4093                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
4094                 if (_ptr_entries) {
4095                         NDR_PULL_ALLOC(ndr, r->entries);
4096                 } else {
4097                         r->entries = NULL;
4098                 }
4099                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4100         }
4101         if (ndr_flags & NDR_BUFFERS) {
4102                 if (r->entries) {
4103                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
4104                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4105                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
4106                         size_entries_1 = ndr_get_array_size(ndr, &r->entries);
4107                         NDR_PULL_ALLOC_N(ndr, r->entries, size_entries_1);
4108                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
4109                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4110                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
4111                                 NDR_CHECK(ndr_pull_samr_DispEntryGeneral(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4112                         }
4113                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
4114                                 NDR_CHECK(ndr_pull_samr_DispEntryGeneral(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4115                         }
4116                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
4117                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
4118                 }
4119                 if (r->entries) {
4120                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
4121                 }
4122         }
4123         return NDR_ERR_SUCCESS;
4124 }
4125
4126 _PUBLIC_ void ndr_print_samr_DispInfoGeneral(struct ndr_print *ndr, const char *name, const struct samr_DispInfoGeneral *r)
4127 {
4128         uint32_t cntr_entries_1;
4129         ndr_print_struct(ndr, name, "samr_DispInfoGeneral");
4130         ndr->depth++;
4131         ndr_print_uint32(ndr, "count", r->count);
4132         ndr_print_ptr(ndr, "entries", r->entries);
4133         ndr->depth++;
4134         if (r->entries) {
4135                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
4136                 ndr->depth++;
4137                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
4138                         char *idx_1=NULL;
4139                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
4140                                 ndr_print_samr_DispEntryGeneral(ndr, "entries", &r->entries[cntr_entries_1]);
4141                                 free(idx_1);
4142                         }
4143                 }
4144                 ndr->depth--;
4145         }
4146         ndr->depth--;
4147         ndr->depth--;
4148 }
4149
4150 static enum ndr_err_code ndr_push_samr_DispEntryFull(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryFull *r)
4151 {
4152         if (ndr_flags & NDR_SCALARS) {
4153                 NDR_CHECK(ndr_push_align(ndr, 5));
4154                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
4155                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
4156                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
4157                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
4158                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
4159                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4160         }
4161         if (ndr_flags & NDR_BUFFERS) {
4162                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
4163                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
4164         }
4165         return NDR_ERR_SUCCESS;
4166 }
4167
4168 static enum ndr_err_code ndr_pull_samr_DispEntryFull(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryFull *r)
4169 {
4170         if (ndr_flags & NDR_SCALARS) {
4171                 NDR_CHECK(ndr_pull_align(ndr, 5));
4172                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
4173                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
4174                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
4175                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
4176                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
4177                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4178         }
4179         if (ndr_flags & NDR_BUFFERS) {
4180                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
4181                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
4182         }
4183         return NDR_ERR_SUCCESS;
4184 }
4185
4186 _PUBLIC_ void ndr_print_samr_DispEntryFull(struct ndr_print *ndr, const char *name, const struct samr_DispEntryFull *r)
4187 {
4188         ndr_print_struct(ndr, name, "samr_DispEntryFull");
4189         ndr->depth++;
4190         ndr_print_uint32(ndr, "idx", r->idx);
4191         ndr_print_uint32(ndr, "rid", r->rid);
4192         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
4193         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
4194         ndr_print_lsa_String(ndr, "description", &r->description);
4195         ndr->depth--;
4196 }
4197
4198 static enum ndr_err_code ndr_push_samr_DispInfoFull(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoFull *r)
4199 {
4200         uint32_t cntr_entries_1;
4201         if (ndr_flags & NDR_SCALARS) {
4202                 NDR_CHECK(ndr_push_align(ndr, 5));
4203                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4204                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
4205                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4206         }
4207         if (ndr_flags & NDR_BUFFERS) {
4208                 if (r->entries) {
4209                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
4210                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4211                                 NDR_CHECK(ndr_push_samr_DispEntryFull(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4212                         }
4213                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4214                                 NDR_CHECK(ndr_push_samr_DispEntryFull(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4215                         }
4216                 }
4217         }
4218         return NDR_ERR_SUCCESS;
4219 }
4220
4221 static enum ndr_err_code ndr_pull_samr_DispInfoFull(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoFull *r)
4222 {
4223         uint32_t _ptr_entries;
4224         uint32_t size_entries_1 = 0;
4225         uint32_t cntr_entries_1;
4226         TALLOC_CTX *_mem_save_entries_0;
4227         TALLOC_CTX *_mem_save_entries_1;
4228         if (ndr_flags & NDR_SCALARS) {
4229                 NDR_CHECK(ndr_pull_align(ndr, 5));
4230                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4231                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
4232                 if (_ptr_entries) {
4233                         NDR_PULL_ALLOC(ndr, r->entries);
4234                 } else {
4235                         r->entries = NULL;
4236                 }
4237                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4238         }
4239         if (ndr_flags & NDR_BUFFERS) {
4240                 if (r->entries) {
4241                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
4242                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4243                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
4244                         size_entries_1 = ndr_get_array_size(ndr, &r->entries);
4245                         NDR_PULL_ALLOC_N(ndr, r->entries, size_entries_1);
4246                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
4247                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4248                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
4249                                 NDR_CHECK(ndr_pull_samr_DispEntryFull(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4250                         }
4251                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
4252                                 NDR_CHECK(ndr_pull_samr_DispEntryFull(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4253                         }
4254                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
4255                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
4256                 }
4257                 if (r->entries) {
4258                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
4259                 }
4260         }
4261         return NDR_ERR_SUCCESS;
4262 }
4263
4264 _PUBLIC_ void ndr_print_samr_DispInfoFull(struct ndr_print *ndr, const char *name, const struct samr_DispInfoFull *r)
4265 {
4266         uint32_t cntr_entries_1;
4267         ndr_print_struct(ndr, name, "samr_DispInfoFull");
4268         ndr->depth++;
4269         ndr_print_uint32(ndr, "count", r->count);
4270         ndr_print_ptr(ndr, "entries", r->entries);
4271         ndr->depth++;
4272         if (r->entries) {
4273                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
4274                 ndr->depth++;
4275                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
4276                         char *idx_1=NULL;
4277                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
4278                                 ndr_print_samr_DispEntryFull(ndr, "entries", &r->entries[cntr_entries_1]);
4279                                 free(idx_1);
4280                         }
4281                 }
4282                 ndr->depth--;
4283         }
4284         ndr->depth--;
4285         ndr->depth--;
4286 }
4287
4288 static enum ndr_err_code ndr_push_samr_DispEntryFullGroup(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryFullGroup *r)
4289 {
4290         if (ndr_flags & NDR_SCALARS) {
4291                 NDR_CHECK(ndr_push_align(ndr, 5));
4292                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
4293                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
4294                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->acct_flags));
4295                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
4296                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
4297                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4298         }
4299         if (ndr_flags & NDR_BUFFERS) {
4300                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
4301                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
4302         }
4303         return NDR_ERR_SUCCESS;
4304 }
4305
4306 static enum ndr_err_code ndr_pull_samr_DispEntryFullGroup(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryFullGroup *r)
4307 {
4308         if (ndr_flags & NDR_SCALARS) {
4309                 NDR_CHECK(ndr_pull_align(ndr, 5));
4310                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
4311                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
4312                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->acct_flags));
4313                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
4314                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
4315                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4316         }
4317         if (ndr_flags & NDR_BUFFERS) {
4318                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
4319                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
4320         }
4321         return NDR_ERR_SUCCESS;
4322 }
4323
4324 _PUBLIC_ void ndr_print_samr_DispEntryFullGroup(struct ndr_print *ndr, const char *name, const struct samr_DispEntryFullGroup *r)
4325 {
4326         ndr_print_struct(ndr, name, "samr_DispEntryFullGroup");
4327         ndr->depth++;
4328         ndr_print_uint32(ndr, "idx", r->idx);
4329         ndr_print_uint32(ndr, "rid", r->rid);
4330         ndr_print_samr_GroupAttrs(ndr, "acct_flags", r->acct_flags);
4331         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
4332         ndr_print_lsa_String(ndr, "description", &r->description);
4333         ndr->depth--;
4334 }
4335
4336 static enum ndr_err_code ndr_push_samr_DispInfoFullGroups(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoFullGroups *r)
4337 {
4338         uint32_t cntr_entries_1;
4339         if (ndr_flags & NDR_SCALARS) {
4340                 NDR_CHECK(ndr_push_align(ndr, 5));
4341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4342                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
4343                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4344         }
4345         if (ndr_flags & NDR_BUFFERS) {
4346                 if (r->entries) {
4347                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
4348                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4349                                 NDR_CHECK(ndr_push_samr_DispEntryFullGroup(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4350                         }
4351                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4352                                 NDR_CHECK(ndr_push_samr_DispEntryFullGroup(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4353                         }
4354                 }
4355         }
4356         return NDR_ERR_SUCCESS;
4357 }
4358
4359 static enum ndr_err_code ndr_pull_samr_DispInfoFullGroups(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoFullGroups *r)
4360 {
4361         uint32_t _ptr_entries;
4362         uint32_t size_entries_1 = 0;
4363         uint32_t cntr_entries_1;
4364         TALLOC_CTX *_mem_save_entries_0;
4365         TALLOC_CTX *_mem_save_entries_1;
4366         if (ndr_flags & NDR_SCALARS) {
4367                 NDR_CHECK(ndr_pull_align(ndr, 5));
4368                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4369                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
4370                 if (_ptr_entries) {
4371                         NDR_PULL_ALLOC(ndr, r->entries);
4372                 } else {
4373                         r->entries = NULL;
4374                 }
4375                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4376         }
4377         if (ndr_flags & NDR_BUFFERS) {
4378                 if (r->entries) {
4379                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
4380                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4381                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
4382                         size_entries_1 = ndr_get_array_size(ndr, &r->entries);
4383                         NDR_PULL_ALLOC_N(ndr, r->entries, size_entries_1);
4384                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
4385                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4386                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
4387                                 NDR_CHECK(ndr_pull_samr_DispEntryFullGroup(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4388                         }
4389                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
4390                                 NDR_CHECK(ndr_pull_samr_DispEntryFullGroup(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4391                         }
4392                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
4393                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
4394                 }
4395                 if (r->entries) {
4396                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
4397                 }
4398         }
4399         return NDR_ERR_SUCCESS;
4400 }
4401
4402 _PUBLIC_ void ndr_print_samr_DispInfoFullGroups(struct ndr_print *ndr, const char *name, const struct samr_DispInfoFullGroups *r)
4403 {
4404         uint32_t cntr_entries_1;
4405         ndr_print_struct(ndr, name, "samr_DispInfoFullGroups");
4406         ndr->depth++;
4407         ndr_print_uint32(ndr, "count", r->count);
4408         ndr_print_ptr(ndr, "entries", r->entries);
4409         ndr->depth++;
4410         if (r->entries) {
4411                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
4412                 ndr->depth++;
4413                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
4414                         char *idx_1=NULL;
4415                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
4416                                 ndr_print_samr_DispEntryFullGroup(ndr, "entries", &r->entries[cntr_entries_1]);
4417                                 free(idx_1);
4418                         }
4419                 }
4420                 ndr->depth--;
4421         }
4422         ndr->depth--;
4423         ndr->depth--;
4424 }
4425
4426 static enum ndr_err_code ndr_push_samr_DispEntryAscii(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryAscii *r)
4427 {
4428         if (ndr_flags & NDR_SCALARS) {
4429                 NDR_CHECK(ndr_push_align(ndr, 5));
4430                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
4431                 NDR_CHECK(ndr_push_lsa_AsciiStringLarge(ndr, NDR_SCALARS, &r->account_name));
4432                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4433         }
4434         if (ndr_flags & NDR_BUFFERS) {
4435                 NDR_CHECK(ndr_push_lsa_AsciiStringLarge(ndr, NDR_BUFFERS, &r->account_name));
4436         }
4437         return NDR_ERR_SUCCESS;
4438 }
4439
4440 static enum ndr_err_code ndr_pull_samr_DispEntryAscii(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryAscii *r)
4441 {
4442         if (ndr_flags & NDR_SCALARS) {
4443                 NDR_CHECK(ndr_pull_align(ndr, 5));
4444                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
4445                 NDR_CHECK(ndr_pull_lsa_AsciiStringLarge(ndr, NDR_SCALARS, &r->account_name));
4446                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4447         }
4448         if (ndr_flags & NDR_BUFFERS) {
4449                 NDR_CHECK(ndr_pull_lsa_AsciiStringLarge(ndr, NDR_BUFFERS, &r->account_name));
4450         }
4451         return NDR_ERR_SUCCESS;
4452 }
4453
4454 _PUBLIC_ void ndr_print_samr_DispEntryAscii(struct ndr_print *ndr, const char *name, const struct samr_DispEntryAscii *r)
4455 {
4456         ndr_print_struct(ndr, name, "samr_DispEntryAscii");
4457         ndr->depth++;
4458         ndr_print_uint32(ndr, "idx", r->idx);
4459         ndr_print_lsa_AsciiStringLarge(ndr, "account_name", &r->account_name);
4460         ndr->depth--;
4461 }
4462
4463 static enum ndr_err_code ndr_push_samr_DispInfoAscii(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoAscii *r)
4464 {
4465         uint32_t cntr_entries_1;
4466         if (ndr_flags & NDR_SCALARS) {
4467                 NDR_CHECK(ndr_push_align(ndr, 5));
4468                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4469                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
4470                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4471         }
4472         if (ndr_flags & NDR_BUFFERS) {
4473                 if (r->entries) {
4474                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
4475                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4476                                 NDR_CHECK(ndr_push_samr_DispEntryAscii(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4477                         }
4478                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4479                                 NDR_CHECK(ndr_push_samr_DispEntryAscii(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4480                         }
4481                 }
4482         }
4483         return NDR_ERR_SUCCESS;
4484 }
4485
4486 static enum ndr_err_code ndr_pull_samr_DispInfoAscii(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoAscii *r)
4487 {
4488         uint32_t _ptr_entries;
4489         uint32_t size_entries_1 = 0;
4490         uint32_t cntr_entries_1;
4491         TALLOC_CTX *_mem_save_entries_0;
4492         TALLOC_CTX *_mem_save_entries_1;
4493         if (ndr_flags & NDR_SCALARS) {
4494                 NDR_CHECK(ndr_pull_align(ndr, 5));
4495                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4496                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
4497                 if (_ptr_entries) {
4498                         NDR_PULL_ALLOC(ndr, r->entries);
4499                 } else {
4500                         r->entries = NULL;
4501                 }
4502                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4503         }
4504         if (ndr_flags & NDR_BUFFERS) {
4505                 if (r->entries) {
4506                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
4507                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4508                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
4509                         size_entries_1 = ndr_get_array_size(ndr, &r->entries);
4510                         NDR_PULL_ALLOC_N(ndr, r->entries, size_entries_1);
4511                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
4512                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4513                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
4514                                 NDR_CHECK(ndr_pull_samr_DispEntryAscii(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4515                         }
4516                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
4517                                 NDR_CHECK(ndr_pull_samr_DispEntryAscii(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4518                         }
4519                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
4520                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
4521                 }
4522                 if (r->entries) {
4523                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
4524                 }
4525         }
4526         return NDR_ERR_SUCCESS;
4527 }
4528
4529 _PUBLIC_ void ndr_print_samr_DispInfoAscii(struct ndr_print *ndr, const char *name, const struct samr_DispInfoAscii *r)
4530 {
4531         uint32_t cntr_entries_1;
4532         ndr_print_struct(ndr, name, "samr_DispInfoAscii");
4533         ndr->depth++;
4534         ndr_print_uint32(ndr, "count", r->count);
4535         ndr_print_ptr(ndr, "entries", r->entries);
4536         ndr->depth++;
4537         if (r->entries) {
4538                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
4539                 ndr->depth++;
4540                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
4541                         char *idx_1=NULL;
4542                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
4543                                 ndr_print_samr_DispEntryAscii(ndr, "entries", &r->entries[cntr_entries_1]);
4544                                 free(idx_1);
4545                         }
4546                 }
4547                 ndr->depth--;
4548         }
4549         ndr->depth--;
4550         ndr->depth--;
4551 }
4552
4553 static enum ndr_err_code ndr_push_samr_DispInfo(struct ndr_push *ndr, int ndr_flags, const union samr_DispInfo *r)
4554 {
4555         if (ndr_flags & NDR_SCALARS) {
4556                 int level = ndr_push_get_switch_value(ndr, r);
4557                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
4558                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4559                 switch (level) {
4560                         case 1: {
4561                                 NDR_CHECK(ndr_push_samr_DispInfoGeneral(ndr, NDR_SCALARS, &r->info1));
4562                         break; }
4563
4564                         case 2: {
4565                                 NDR_CHECK(ndr_push_samr_DispInfoFull(ndr, NDR_SCALARS, &r->info2));
4566                         break; }
4567
4568                         case 3: {
4569                                 NDR_CHECK(ndr_push_samr_DispInfoFullGroups(ndr, NDR_SCALARS, &r->info3));
4570                         break; }
4571
4572                         case 4: {
4573                                 NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info4));
4574                         break; }
4575
4576                         case 5: {
4577                                 NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info5));
4578                         break; }
4579
4580                         default:
4581                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4582                 }
4583         }
4584         if (ndr_flags & NDR_BUFFERS) {
4585                 int level = ndr_push_get_switch_value(ndr, r);
4586                 switch (level) {
4587                         case 1:
4588                                 NDR_CHECK(ndr_push_samr_DispInfoGeneral(ndr, NDR_BUFFERS, &r->info1));
4589                         break;
4590
4591                         case 2:
4592                                 NDR_CHECK(ndr_push_samr_DispInfoFull(ndr, NDR_BUFFERS, &r->info2));
4593                         break;
4594
4595                         case 3:
4596                                 NDR_CHECK(ndr_push_samr_DispInfoFullGroups(ndr, NDR_BUFFERS, &r->info3));
4597                         break;
4598
4599                         case 4:
4600                                 NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info4));
4601                         break;
4602
4603                         case 5:
4604                                 NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info5));
4605                         break;
4606
4607                         default:
4608                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4609                 }
4610         }
4611         return NDR_ERR_SUCCESS;
4612 }
4613
4614 static enum ndr_err_code ndr_pull_samr_DispInfo(struct ndr_pull *ndr, int ndr_flags, union samr_DispInfo *r)
4615 {
4616         int level;
4617         uint16_t _level;
4618         level = ndr_pull_get_switch_value(ndr, r);
4619         if (ndr_flags & NDR_SCALARS) {
4620                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
4621                 if (_level != level) {
4622                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4623                 }
4624                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4625                 switch (level) {
4626                         case 1: {
4627                                 NDR_CHECK(ndr_pull_samr_DispInfoGeneral(ndr, NDR_SCALARS, &r->info1));
4628                         break; }
4629
4630                         case 2: {
4631                                 NDR_CHECK(ndr_pull_samr_DispInfoFull(ndr, NDR_SCALARS, &r->info2));
4632                         break; }
4633
4634                         case 3: {
4635                                 NDR_CHECK(ndr_pull_samr_DispInfoFullGroups(ndr, NDR_SCALARS, &r->info3));
4636                         break; }
4637
4638                         case 4: {
4639                                 NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info4));
4640                         break; }
4641
4642                         case 5: {
4643                                 NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info5));
4644                         break; }
4645
4646                         default:
4647                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4648                 }
4649         }
4650         if (ndr_flags & NDR_BUFFERS) {
4651                 switch (level) {
4652                         case 1:
4653                                 NDR_CHECK(ndr_pull_samr_DispInfoGeneral(ndr, NDR_BUFFERS, &r->info1));
4654                         break;
4655
4656                         case 2:
4657                                 NDR_CHECK(ndr_pull_samr_DispInfoFull(ndr, NDR_BUFFERS, &r->info2));
4658                         break;
4659
4660                         case 3:
4661                                 NDR_CHECK(ndr_pull_samr_DispInfoFullGroups(ndr, NDR_BUFFERS, &r->info3));
4662                         break;
4663
4664                         case 4:
4665                                 NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info4));
4666                         break;
4667
4668                         case 5:
4669                                 NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info5));
4670                         break;
4671
4672                         default:
4673                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4674                 }
4675         }
4676         return NDR_ERR_SUCCESS;
4677 }
4678
4679 _PUBLIC_ void ndr_print_samr_DispInfo(struct ndr_print *ndr, const char *name, const union samr_DispInfo *r)
4680 {
4681         int level;
4682         level = ndr_print_get_switch_value(ndr, r);
4683         ndr_print_union(ndr, name, level, "samr_DispInfo");
4684         switch (level) {
4685                 case 1:
4686                         ndr_print_samr_DispInfoGeneral(ndr, "info1", &r->info1);
4687                 break;
4688
4689                 case 2:
4690                         ndr_print_samr_DispInfoFull(ndr, "info2", &r->info2);
4691                 break;
4692
4693                 case 3:
4694                         ndr_print_samr_DispInfoFullGroups(ndr, "info3", &r->info3);
4695                 break;
4696
4697                 case 4:
4698                         ndr_print_samr_DispInfoAscii(ndr, "info4", &r->info4);
4699                 break;
4700
4701                 case 5:
4702                         ndr_print_samr_DispInfoAscii(ndr, "info5", &r->info5);
4703                 break;
4704
4705                 default:
4706                         ndr_print_bad_level(ndr, name, level);
4707         }
4708 }
4709
4710 static enum ndr_err_code ndr_push_samr_PwInfo(struct ndr_push *ndr, int ndr_flags, const struct samr_PwInfo *r)
4711 {
4712         if (ndr_flags & NDR_SCALARS) {
4713                 NDR_CHECK(ndr_push_align(ndr, 4));
4714                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->min_password_length));
4715                 NDR_CHECK(ndr_push_samr_PasswordProperties(ndr, NDR_SCALARS, r->password_properties));
4716                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4717         }
4718         if (ndr_flags & NDR_BUFFERS) {
4719         }
4720         return NDR_ERR_SUCCESS;
4721 }
4722
4723 static enum ndr_err_code ndr_pull_samr_PwInfo(struct ndr_pull *ndr, int ndr_flags, struct samr_PwInfo *r)
4724 {
4725         if (ndr_flags & NDR_SCALARS) {
4726                 NDR_CHECK(ndr_pull_align(ndr, 4));
4727                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->min_password_length));
4728                 NDR_CHECK(ndr_pull_samr_PasswordProperties(ndr, NDR_SCALARS, &r->password_properties));
4729                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4730         }
4731         if (ndr_flags & NDR_BUFFERS) {
4732         }
4733         return NDR_ERR_SUCCESS;
4734 }
4735
4736 _PUBLIC_ void ndr_print_samr_PwInfo(struct ndr_print *ndr, const char *name, const struct samr_PwInfo *r)
4737 {
4738         ndr_print_struct(ndr, name, "samr_PwInfo");
4739         ndr->depth++;
4740         ndr_print_uint16(ndr, "min_password_length", r->min_password_length);
4741         ndr_print_samr_PasswordProperties(ndr, "password_properties", r->password_properties);
4742         ndr->depth--;
4743 }
4744
4745 static enum ndr_err_code ndr_push_samr_ConnectVersion(struct ndr_push *ndr, int ndr_flags, enum samr_ConnectVersion r)
4746 {
4747         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
4748         return NDR_ERR_SUCCESS;
4749 }
4750
4751 static enum ndr_err_code ndr_pull_samr_ConnectVersion(struct ndr_pull *ndr, int ndr_flags, enum samr_ConnectVersion *r)
4752 {
4753         uint32_t v;
4754         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
4755         *r = v;
4756         return NDR_ERR_SUCCESS;
4757 }
4758
4759 _PUBLIC_ void ndr_print_samr_ConnectVersion(struct ndr_print *ndr, const char *name, enum samr_ConnectVersion r)
4760 {
4761         const char *val = NULL;
4762
4763         switch (r) {
4764                 case SAMR_CONNECT_PRE_W2K: val = "SAMR_CONNECT_PRE_W2K"; break;
4765                 case SAMR_CONNECT_W2K: val = "SAMR_CONNECT_W2K"; break;
4766                 case SAMR_CONNECT_AFTER_W2K: val = "SAMR_CONNECT_AFTER_W2K"; break;
4767         }
4768         ndr_print_enum(ndr, name, "ENUM", val, r);
4769 }
4770
4771 static enum ndr_err_code ndr_push_samr_ChangeReject(struct ndr_push *ndr, int ndr_flags, const struct samr_ChangeReject *r)
4772 {
4773         if (ndr_flags & NDR_SCALARS) {
4774                 NDR_CHECK(ndr_push_align(ndr, 4));
4775                 NDR_CHECK(ndr_push_samr_RejectReason(ndr, NDR_SCALARS, r->reason));
4776                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
4777                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
4778                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4779         }
4780         if (ndr_flags & NDR_BUFFERS) {
4781         }
4782         return NDR_ERR_SUCCESS;
4783 }
4784
4785 static enum ndr_err_code ndr_pull_samr_ChangeReject(struct ndr_pull *ndr, int ndr_flags, struct samr_ChangeReject *r)
4786 {
4787         if (ndr_flags & NDR_SCALARS) {
4788                 NDR_CHECK(ndr_pull_align(ndr, 4));
4789                 NDR_CHECK(ndr_pull_samr_RejectReason(ndr, NDR_SCALARS, &r->reason));
4790                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
4791                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
4792                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4793         }
4794         if (ndr_flags & NDR_BUFFERS) {
4795         }
4796         return NDR_ERR_SUCCESS;
4797 }
4798
4799 _PUBLIC_ void ndr_print_samr_ChangeReject(struct ndr_print *ndr, const char *name, const struct samr_ChangeReject *r)
4800 {
4801         ndr_print_struct(ndr, name, "samr_ChangeReject");
4802         ndr->depth++;
4803         ndr_print_samr_RejectReason(ndr, "reason", r->reason);
4804         ndr_print_uint32(ndr, "unknown1", r->unknown1);
4805         ndr_print_uint32(ndr, "unknown2", r->unknown2);
4806         ndr->depth--;
4807 }
4808
4809 static enum ndr_err_code ndr_push_samr_ConnectInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_ConnectInfo1 *r)
4810 {
4811         if (ndr_flags & NDR_SCALARS) {
4812                 NDR_CHECK(ndr_push_align(ndr, 4));
4813                 NDR_CHECK(ndr_push_samr_ConnectVersion(ndr, NDR_SCALARS, r->client_version));
4814                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
4815                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4816         }
4817         if (ndr_flags & NDR_BUFFERS) {
4818         }
4819         return NDR_ERR_SUCCESS;
4820 }
4821
4822 static enum ndr_err_code ndr_pull_samr_ConnectInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_ConnectInfo1 *r)
4823 {
4824         if (ndr_flags & NDR_SCALARS) {
4825                 NDR_CHECK(ndr_pull_align(ndr, 4));
4826                 NDR_CHECK(ndr_pull_samr_ConnectVersion(ndr, NDR_SCALARS, &r->client_version));
4827                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
4828                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4829         }
4830         if (ndr_flags & NDR_BUFFERS) {
4831         }
4832         return NDR_ERR_SUCCESS;
4833 }
4834
4835 _PUBLIC_ void ndr_print_samr_ConnectInfo1(struct ndr_print *ndr, const char *name, const struct samr_ConnectInfo1 *r)
4836 {
4837         ndr_print_struct(ndr, name, "samr_ConnectInfo1");
4838         ndr->depth++;
4839         ndr_print_samr_ConnectVersion(ndr, "client_version", r->client_version);
4840         ndr_print_uint32(ndr, "unknown2", r->unknown2);
4841         ndr->depth--;
4842 }
4843
4844 static enum ndr_err_code ndr_push_samr_ConnectInfo(struct ndr_push *ndr, int ndr_flags, const union samr_ConnectInfo *r)
4845 {
4846         if (ndr_flags & NDR_SCALARS) {
4847                 int level = ndr_push_get_switch_value(ndr, r);
4848                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4849                 NDR_CHECK(ndr_push_union_align(ndr, 4));
4850                 switch (level) {
4851                         case 1: {
4852                                 NDR_CHECK(ndr_push_samr_ConnectInfo1(ndr, NDR_SCALARS, &r->info1));
4853                         break; }
4854
4855                         default:
4856                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4857                 }
4858         }
4859         if (ndr_flags & NDR_BUFFERS) {
4860                 int level = ndr_push_get_switch_value(ndr, r);
4861                 switch (level) {
4862                         case 1:
4863                         break;
4864
4865                         default:
4866                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4867                 }
4868         }
4869         return NDR_ERR_SUCCESS;
4870 }
4871
4872 static enum ndr_err_code ndr_pull_samr_ConnectInfo(struct ndr_pull *ndr, int ndr_flags, union samr_ConnectInfo *r)
4873 {
4874         int level;
4875         uint32_t _level;
4876         level = ndr_pull_get_switch_value(ndr, r);
4877         if (ndr_flags & NDR_SCALARS) {
4878                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4879                 if (_level != level) {
4880                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4881                 }
4882                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
4883                 switch (level) {
4884                         case 1: {
4885                                 NDR_CHECK(ndr_pull_samr_ConnectInfo1(ndr, NDR_SCALARS, &r->info1));
4886                         break; }
4887
4888                         default:
4889                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4890                 }
4891         }
4892         if (ndr_flags & NDR_BUFFERS) {
4893                 switch (level) {
4894                         case 1:
4895                         break;
4896
4897                         default:
4898                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4899                 }
4900         }
4901         return NDR_ERR_SUCCESS;
4902 }
4903
4904 _PUBLIC_ void ndr_print_samr_ConnectInfo(struct ndr_print *ndr, const char *name, const union samr_ConnectInfo *r)
4905 {
4906         int level;
4907         level = ndr_print_get_switch_value(ndr, r);
4908         ndr_print_union(ndr, name, level, "samr_ConnectInfo");
4909         switch (level) {
4910                 case 1:
4911                         ndr_print_samr_ConnectInfo1(ndr, "info1", &r->info1);
4912                 break;
4913
4914                 default:
4915                         ndr_print_bad_level(ndr, name, level);
4916         }
4917 }
4918
4919 static enum ndr_err_code ndr_push_samr_ValidateFieldsPresent(struct ndr_push *ndr, int ndr_flags, uint32_t r)
4920 {
4921         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4922         return NDR_ERR_SUCCESS;
4923 }
4924
4925 static enum ndr_err_code ndr_pull_samr_ValidateFieldsPresent(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
4926 {
4927         uint32_t v;
4928         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4929         *r = v;
4930         return NDR_ERR_SUCCESS;
4931 }
4932
4933 _PUBLIC_ void ndr_print_samr_ValidateFieldsPresent(struct ndr_print *ndr, const char *name, uint32_t r)
4934 {
4935         ndr_print_uint32(ndr, name, r);
4936         ndr->depth++;
4937         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_LAST_SET", SAMR_VALIDATE_FIELD_PASSWORD_LAST_SET, r);
4938         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_BAD_PASSWORD_TIME", SAMR_VALIDATE_FIELD_BAD_PASSWORD_TIME, r);
4939         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_LOCKOUT_TIME", SAMR_VALIDATE_FIELD_LOCKOUT_TIME, r);
4940         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_BAD_PASSWORD_COUNT", SAMR_VALIDATE_FIELD_BAD_PASSWORD_COUNT, r);
4941         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_HISTORY_LENGTH", SAMR_VALIDATE_FIELD_PASSWORD_HISTORY_LENGTH, r);
4942         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_HISTORY", SAMR_VALIDATE_FIELD_PASSWORD_HISTORY, r);
4943         ndr->depth--;
4944 }
4945
4946 static enum ndr_err_code ndr_push_samr_ValidatePasswordLevel(struct ndr_push *ndr, int ndr_flags, enum samr_ValidatePasswordLevel r)
4947 {
4948         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
4949         return NDR_ERR_SUCCESS;
4950 }
4951
4952 static enum ndr_err_code ndr_pull_samr_ValidatePasswordLevel(struct ndr_pull *ndr, int ndr_flags, enum samr_ValidatePasswordLevel *r)
4953 {
4954         uint16_t v;
4955         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
4956         *r = v;
4957         return NDR_ERR_SUCCESS;
4958 }
4959
4960 _PUBLIC_ void ndr_print_samr_ValidatePasswordLevel(struct ndr_print *ndr, const char *name, enum samr_ValidatePasswordLevel r)
4961 {
4962         const char *val = NULL;
4963
4964         switch (r) {
4965                 case NetValidateAuthentication: val = "NetValidateAuthentication"; break;
4966                 case NetValidatePasswordChange: val = "NetValidatePasswordChange"; break;
4967                 case NetValidatePasswordReset: val = "NetValidatePasswordReset"; break;
4968         }
4969         ndr_print_enum(ndr, name, "ENUM", val, r);
4970 }
4971
4972 static enum ndr_err_code ndr_push_samr_ValidationStatus(struct ndr_push *ndr, int ndr_flags, enum samr_ValidationStatus r)
4973 {
4974         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
4975         return NDR_ERR_SUCCESS;
4976 }
4977
4978 static enum ndr_err_code ndr_pull_samr_ValidationStatus(struct ndr_pull *ndr, int ndr_flags, enum samr_ValidationStatus *r)
4979 {
4980         uint16_t v;
4981         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
4982         *r = v;
4983         return NDR_ERR_SUCCESS;
4984 }
4985
4986 _PUBLIC_ void ndr_print_samr_ValidationStatus(struct ndr_print *ndr, const char *name, enum samr_ValidationStatus r)
4987 {
4988         const char *val = NULL;
4989
4990         switch (r) {
4991                 case SAMR_VALIDATION_STATUS_SUCCESS: val = "SAMR_VALIDATION_STATUS_SUCCESS"; break;
4992                 case SAMR_VALIDATION_STATUS_PASSWORD_MUST_CHANGE: val = "SAMR_VALIDATION_STATUS_PASSWORD_MUST_CHANGE"; break;
4993                 case SAMR_VALIDATION_STATUS_ACCOUNT_LOCKED_OUT: val = "SAMR_VALIDATION_STATUS_ACCOUNT_LOCKED_OUT"; break;
4994                 case SAMR_VALIDATION_STATUS_PASSWORD_EXPIRED: val = "SAMR_VALIDATION_STATUS_PASSWORD_EXPIRED"; break;
4995                 case SAMR_VALIDATION_STATUS_BAD_PASSWORD: val = "SAMR_VALIDATION_STATUS_BAD_PASSWORD"; break;
4996                 case SAMR_VALIDATION_STATUS_PWD_HISTORY_CONFLICT: val = "SAMR_VALIDATION_STATUS_PWD_HISTORY_CONFLICT"; break;
4997                 case SAMR_VALIDATION_STATUS_PWD_TOO_SHORT: val = "SAMR_VALIDATION_STATUS_PWD_TOO_SHORT"; break;
4998                 case SAMR_VALIDATION_STATUS_PWD_TOO_LONG: val = "SAMR_VALIDATION_STATUS_PWD_TOO_LONG"; break;
4999                 case SAMR_VALIDATION_STATUS_NOT_COMPLEX_ENOUGH: val = "SAMR_VALIDATION_STATUS_NOT_COMPLEX_ENOUGH"; break;
5000                 case SAMR_VALIDATION_STATUS_PASSWORD_TOO_RECENT: val = "SAMR_VALIDATION_STATUS_PASSWORD_TOO_RECENT"; break;
5001                 case SAMR_VALIDATION_STATUS_PASSWORD_FILTER_ERROR: val = "SAMR_VALIDATION_STATUS_PASSWORD_FILTER_ERROR"; break;
5002         }
5003         ndr_print_enum(ndr, name, "ENUM", val, r);
5004 }
5005
5006 static enum ndr_err_code ndr_push_samr_ValidationBlob(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidationBlob *r)
5007 {
5008         if (ndr_flags & NDR_SCALARS) {
5009                 NDR_CHECK(ndr_push_align(ndr, 5));
5010                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
5011                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
5012                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5013         }
5014         if (ndr_flags & NDR_BUFFERS) {
5015                 if (r->data) {
5016                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
5017                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
5018                 }
5019         }
5020         return NDR_ERR_SUCCESS;
5021 }
5022
5023 static enum ndr_err_code ndr_pull_samr_ValidationBlob(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidationBlob *r)
5024 {
5025         uint32_t _ptr_data;
5026         uint32_t size_data_1 = 0;
5027         TALLOC_CTX *_mem_save_data_0;
5028         if (ndr_flags & NDR_SCALARS) {
5029                 NDR_CHECK(ndr_pull_align(ndr, 5));
5030                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
5031                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
5032                 if (_ptr_data) {
5033                         NDR_PULL_ALLOC(ndr, r->data);
5034                 } else {
5035                         r->data = NULL;
5036                 }
5037                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5038         }
5039         if (ndr_flags & NDR_BUFFERS) {
5040                 if (r->data) {
5041                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
5042                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
5043                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
5044                         size_data_1 = ndr_get_array_size(ndr, &r->data);
5045                         NDR_PULL_ALLOC_N(ndr, r->data, size_data_1);
5046                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, size_data_1));
5047                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
5048                 }
5049                 if (r->data) {
5050                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
5051                 }
5052         }
5053         return NDR_ERR_SUCCESS;
5054 }
5055
5056 _PUBLIC_ void ndr_print_samr_ValidationBlob(struct ndr_print *ndr, const char *name, const struct samr_ValidationBlob *r)
5057 {
5058         ndr_print_struct(ndr, name, "samr_ValidationBlob");
5059         ndr->depth++;
5060         ndr_print_uint32(ndr, "length", r->length);
5061         ndr_print_ptr(ndr, "data", r->data);
5062         ndr->depth++;
5063         if (r->data) {
5064                 ndr_print_array_uint8(ndr, "data", r->data, r->length);
5065         }
5066         ndr->depth--;
5067         ndr->depth--;
5068 }
5069
5070 static enum ndr_err_code ndr_push_samr_ValidatePasswordInfo(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordInfo *r)
5071 {
5072         uint32_t cntr_pwd_history_1;
5073         if (ndr_flags & NDR_SCALARS) {
5074                 NDR_CHECK(ndr_push_align(ndr, 8));
5075                 NDR_CHECK(ndr_push_samr_ValidateFieldsPresent(ndr, NDR_SCALARS, r->fields_present));
5076                 NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->last_password_change));
5077                 NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->bad_password_time));
5078                 NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->lockout_time));
5079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bad_pwd_count));
5080                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pwd_history_len));
5081                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pwd_history));
5082                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
5083         }
5084         if (ndr_flags & NDR_BUFFERS) {
5085                 if (r->pwd_history) {
5086                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->pwd_history_len));
5087                         for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {
5088                                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->pwd_history[cntr_pwd_history_1]));
5089                         }
5090                         for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {
5091                                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->pwd_history[cntr_pwd_history_1]));
5092                         }
5093                 }
5094         }
5095         return NDR_ERR_SUCCESS;
5096 }
5097
5098 static enum ndr_err_code ndr_pull_samr_ValidatePasswordInfo(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordInfo *r)
5099 {
5100         uint32_t _ptr_pwd_history;
5101         uint32_t size_pwd_history_1 = 0;
5102         uint32_t cntr_pwd_history_1;
5103         TALLOC_CTX *_mem_save_pwd_history_0;
5104         TALLOC_CTX *_mem_save_pwd_history_1;
5105         if (ndr_flags & NDR_SCALARS) {
5106                 NDR_CHECK(ndr_pull_align(ndr, 8));
5107                 NDR_CHECK(ndr_pull_samr_ValidateFieldsPresent(ndr, NDR_SCALARS, &r->fields_present));
5108                 NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->last_password_change));
5109                 NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->bad_password_time));
5110                 NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->lockout_time));
5111                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bad_pwd_count));
5112                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pwd_history_len));
5113                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pwd_history));
5114                 if (_ptr_pwd_history) {
5115                         NDR_PULL_ALLOC(ndr, r->pwd_history);
5116                 } else {
5117                         r->pwd_history = NULL;
5118                 }
5119                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
5120         }
5121         if (ndr_flags & NDR_BUFFERS) {
5122                 if (r->pwd_history) {
5123                         _mem_save_pwd_history_0 = NDR_PULL_GET_MEM_CTX(ndr);
5124                         NDR_PULL_SET_MEM_CTX(ndr, r->pwd_history, 0);
5125                         NDR_CHECK(ndr_pull_array_size(ndr, &r->pwd_history));
5126                         size_pwd_history_1 = ndr_get_array_size(ndr, &r->pwd_history);
5127                         NDR_PULL_ALLOC_N(ndr, r->pwd_history, size_pwd_history_1);
5128                         _mem_save_pwd_history_1 = NDR_PULL_GET_MEM_CTX(ndr);
5129                         NDR_PULL_SET_MEM_CTX(ndr, r->pwd_history, 0);
5130                         for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < size_pwd_history_1; cntr_pwd_history_1++) {
5131                                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->pwd_history[cntr_pwd_history_1]));
5132                         }
5133                         for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < size_pwd_history_1; cntr_pwd_history_1++) {
5134                                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->pwd_history[cntr_pwd_history_1]));
5135                         }
5136                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pwd_history_1, 0);
5137                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pwd_history_0, 0);
5138                 }
5139                 if (r->pwd_history) {
5140                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->pwd_history, r->pwd_history_len));
5141                 }
5142         }
5143         return NDR_ERR_SUCCESS;
5144 }
5145
5146 _PUBLIC_ void ndr_print_samr_ValidatePasswordInfo(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordInfo *r)
5147 {
5148         uint32_t cntr_pwd_history_1;
5149         ndr_print_struct(ndr, name, "samr_ValidatePasswordInfo");
5150         ndr->depth++;
5151         ndr_print_samr_ValidateFieldsPresent(ndr, "fields_present", r->fields_present);
5152         ndr_print_NTTIME_hyper(ndr, "last_password_change", r->last_password_change);
5153         ndr_print_NTTIME_hyper(ndr, "bad_password_time", r->bad_password_time);
5154         ndr_print_NTTIME_hyper(ndr, "lockout_time", r->lockout_time);
5155         ndr_print_uint32(ndr, "bad_pwd_count", r->bad_pwd_count);
5156         ndr_print_uint32(ndr, "pwd_history_len", r->pwd_history_len);
5157         ndr_print_ptr(ndr, "pwd_history", r->pwd_history);
5158         ndr->depth++;
5159         if (r->pwd_history) {
5160                 ndr->print(ndr, "%s: ARRAY(%d)", "pwd_history", (int)r->pwd_history_len);
5161                 ndr->depth++;
5162                 for (cntr_pwd_history_1=0;cntr_pwd_history_1<r->pwd_history_len;cntr_pwd_history_1++) {
5163                         char *idx_1=NULL;
5164                         if (asprintf(&idx_1, "[%d]", cntr_pwd_history_1) != -1) {
5165                                 ndr_print_samr_ValidationBlob(ndr, "pwd_history", &r->pwd_history[cntr_pwd_history_1]);
5166                                 free(idx_1);
5167                         }
5168                 }
5169                 ndr->depth--;
5170         }
5171         ndr->depth--;
5172         ndr->depth--;
5173 }
5174
5175 static enum ndr_err_code ndr_push_samr_ValidatePasswordRepCtr(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordRepCtr *r)
5176 {
5177         if (ndr_flags & NDR_SCALARS) {
5178                 NDR_CHECK(ndr_push_align(ndr, 8));
5179                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5180                 NDR_CHECK(ndr_push_samr_ValidationStatus(ndr, NDR_SCALARS, r->status));
5181                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
5182         }
5183         if (ndr_flags & NDR_BUFFERS) {
5184                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5185         }
5186         return NDR_ERR_SUCCESS;
5187 }
5188
5189 static enum ndr_err_code ndr_pull_samr_ValidatePasswordRepCtr(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordRepCtr *r)
5190 {
5191         if (ndr_flags & NDR_SCALARS) {
5192                 NDR_CHECK(ndr_pull_align(ndr, 8));
5193                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5194                 NDR_CHECK(ndr_pull_samr_ValidationStatus(ndr, NDR_SCALARS, &r->status));
5195                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
5196         }
5197         if (ndr_flags & NDR_BUFFERS) {
5198                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5199         }
5200         return NDR_ERR_SUCCESS;
5201 }
5202
5203 _PUBLIC_ void ndr_print_samr_ValidatePasswordRepCtr(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordRepCtr *r)
5204 {
5205         ndr_print_struct(ndr, name, "samr_ValidatePasswordRepCtr");
5206         ndr->depth++;
5207         ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
5208         ndr_print_samr_ValidationStatus(ndr, "status", r->status);
5209         ndr->depth--;
5210 }
5211
5212 static enum ndr_err_code ndr_push_samr_ValidatePasswordRep(struct ndr_push *ndr, int ndr_flags, const union samr_ValidatePasswordRep *r)
5213 {
5214         if (ndr_flags & NDR_SCALARS) {
5215                 int level = ndr_push_get_switch_value(ndr, r);
5216                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
5217                 NDR_CHECK(ndr_push_union_align(ndr, 8));
5218                 switch (level) {
5219                         case 1: {
5220                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr1));
5221                         break; }
5222
5223                         case 2: {
5224                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr2));
5225                         break; }
5226
5227                         case 3: {
5228                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr3));
5229                         break; }
5230
5231                         default:
5232                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5233                 }
5234         }
5235         if (ndr_flags & NDR_BUFFERS) {
5236                 int level = ndr_push_get_switch_value(ndr, r);
5237                 switch (level) {
5238                         case 1:
5239                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr1));
5240                         break;
5241
5242                         case 2:
5243                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr2));
5244                         break;
5245
5246                         case 3:
5247                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr3));
5248                         break;
5249
5250                         default:
5251                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5252                 }
5253         }
5254         return NDR_ERR_SUCCESS;
5255 }
5256
5257 static enum ndr_err_code ndr_pull_samr_ValidatePasswordRep(struct ndr_pull *ndr, int ndr_flags, union samr_ValidatePasswordRep *r)
5258 {
5259         int level;
5260         uint16_t _level;
5261         level = ndr_pull_get_switch_value(ndr, r);
5262         if (ndr_flags & NDR_SCALARS) {
5263                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
5264                 if (_level != level) {
5265                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5266                 }
5267                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
5268                 switch (level) {
5269                         case 1: {
5270                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr1));
5271                         break; }
5272
5273                         case 2: {
5274                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr2));
5275                         break; }
5276
5277                         case 3: {
5278                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr3));
5279                         break; }
5280
5281                         default:
5282                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5283                 }
5284         }
5285         if (ndr_flags & NDR_BUFFERS) {
5286                 switch (level) {
5287                         case 1:
5288                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr1));
5289                         break;
5290
5291                         case 2:
5292                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr2));
5293                         break;
5294
5295                         case 3:
5296                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr3));
5297                         break;
5298
5299                         default:
5300                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5301                 }
5302         }
5303         return NDR_ERR_SUCCESS;
5304 }
5305
5306 _PUBLIC_ void ndr_print_samr_ValidatePasswordRep(struct ndr_print *ndr, const char *name, const union samr_ValidatePasswordRep *r)
5307 {
5308         int level;
5309         level = ndr_print_get_switch_value(ndr, r);
5310         ndr_print_union(ndr, name, level, "samr_ValidatePasswordRep");
5311         switch (level) {
5312                 case 1:
5313                         ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr1", &r->ctr1);
5314                 break;
5315
5316                 case 2:
5317                         ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr2", &r->ctr2);
5318                 break;
5319
5320                 case 3:
5321                         ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr3", &r->ctr3);
5322                 break;
5323
5324                 default:
5325                         ndr_print_bad_level(ndr, name, level);
5326         }
5327 }
5328
5329 static enum ndr_err_code ndr_push_samr_ValidatePasswordReq3(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq3 *r)
5330 {
5331         if (ndr_flags & NDR_SCALARS) {
5332                 NDR_CHECK(ndr_push_align(ndr, 8));
5333                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5334                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
5335                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
5336                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
5337                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->pwd_must_change_at_next_logon));
5338                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->clear_lockout));
5339                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
5340         }
5341         if (ndr_flags & NDR_BUFFERS) {
5342                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5343                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
5344                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
5345                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
5346         }
5347         return NDR_ERR_SUCCESS;
5348 }
5349
5350 static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq3(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq3 *r)
5351 {
5352         if (ndr_flags & NDR_SCALARS) {
5353                 NDR_CHECK(ndr_pull_align(ndr, 8));
5354                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5355                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
5356                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
5357                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
5358                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->pwd_must_change_at_next_logon));
5359                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->clear_lockout));
5360                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
5361         }
5362         if (ndr_flags & NDR_BUFFERS) {
5363                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5364                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
5365                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
5366                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
5367         }
5368         return NDR_ERR_SUCCESS;
5369 }
5370
5371 _PUBLIC_ void ndr_print_samr_ValidatePasswordReq3(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq3 *r)
5372 {
5373         ndr_print_struct(ndr, name, "samr_ValidatePasswordReq3");
5374         ndr->depth++;
5375         ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
5376         ndr_print_lsa_StringLarge(ndr, "password", &r->password);
5377         ndr_print_lsa_StringLarge(ndr, "account", &r->account);
5378         ndr_print_samr_ValidationBlob(ndr, "hash", &r->hash);
5379         ndr_print_uint8(ndr, "pwd_must_change_at_next_logon", r->pwd_must_change_at_next_logon);
5380         ndr_print_uint8(ndr, "clear_lockout", r->clear_lockout);
5381         ndr->depth--;
5382 }
5383
5384 static enum ndr_err_code ndr_push_samr_ValidatePasswordReq2(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq2 *r)
5385 {
5386         if (ndr_flags & NDR_SCALARS) {
5387                 NDR_CHECK(ndr_push_align(ndr, 8));
5388                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5389                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
5390                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
5391                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
5392                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_matched));
5393                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
5394         }
5395         if (ndr_flags & NDR_BUFFERS) {
5396                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5397                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
5398                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
5399                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
5400         }
5401         return NDR_ERR_SUCCESS;
5402 }
5403
5404 static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq2(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq2 *r)
5405 {
5406         if (ndr_flags & NDR_SCALARS) {
5407                 NDR_CHECK(ndr_pull_align(ndr, 8));
5408                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5409                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
5410                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
5411                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
5412                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_matched));
5413                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
5414         }
5415         if (ndr_flags & NDR_BUFFERS) {
5416                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5417                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
5418                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
5419                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
5420         }
5421         return NDR_ERR_SUCCESS;
5422 }
5423
5424 _PUBLIC_ void ndr_print_samr_ValidatePasswordReq2(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq2 *r)
5425 {
5426         ndr_print_struct(ndr, name, "samr_ValidatePasswordReq2");
5427         ndr->depth++;
5428         ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
5429         ndr_print_lsa_StringLarge(ndr, "password", &r->password);
5430         ndr_print_lsa_StringLarge(ndr, "account", &r->account);
5431         ndr_print_samr_ValidationBlob(ndr, "hash", &r->hash);
5432         ndr_print_uint8(ndr, "password_matched", r->password_matched);
5433         ndr->depth--;
5434 }
5435
5436 static enum ndr_err_code ndr_push_samr_ValidatePasswordReq1(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq1 *r)
5437 {
5438         if (ndr_flags & NDR_SCALARS) {
5439                 NDR_CHECK(ndr_push_align(ndr, 8));
5440                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5441                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_matched));
5442                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
5443         }
5444         if (ndr_flags & NDR_BUFFERS) {
5445                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5446         }
5447         return NDR_ERR_SUCCESS;
5448 }
5449
5450 static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq1(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq1 *r)
5451 {
5452         if (ndr_flags & NDR_SCALARS) {
5453                 NDR_CHECK(ndr_pull_align(ndr, 8));
5454                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5455                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_matched));
5456                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
5457         }
5458         if (ndr_flags & NDR_BUFFERS) {
5459                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5460         }
5461         return NDR_ERR_SUCCESS;
5462 }
5463
5464 _PUBLIC_ void ndr_print_samr_ValidatePasswordReq1(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq1 *r)
5465 {
5466         ndr_print_struct(ndr, name, "samr_ValidatePasswordReq1");
5467         ndr->depth++;
5468         ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
5469         ndr_print_uint8(ndr, "password_matched", r->password_matched);
5470         ndr->depth--;
5471 }
5472
5473 static enum ndr_err_code ndr_push_samr_ValidatePasswordReq(struct ndr_push *ndr, int ndr_flags, const union samr_ValidatePasswordReq *r)
5474 {
5475         if (ndr_flags & NDR_SCALARS) {
5476                 int level = ndr_push_get_switch_value(ndr, r);
5477                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
5478                 NDR_CHECK(ndr_push_union_align(ndr, 8));
5479                 switch (level) {
5480                         case 1: {
5481                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq1(ndr, NDR_SCALARS, &r->req1));
5482                         break; }
5483
5484                         case 2: {
5485                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq2(ndr, NDR_SCALARS, &r->req2));
5486                         break; }
5487
5488                         case 3: {
5489                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq3(ndr, NDR_SCALARS, &r->req3));
5490                         break; }
5491
5492                         default:
5493                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5494                 }
5495         }
5496         if (ndr_flags & NDR_BUFFERS) {
5497                 int level = ndr_push_get_switch_value(ndr, r);
5498                 switch (level) {
5499                         case 1:
5500                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq1(ndr, NDR_BUFFERS, &r->req1));
5501                         break;
5502
5503                         case 2:
5504                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq2(ndr, NDR_BUFFERS, &r->req2));
5505                         break;
5506
5507                         case 3:
5508                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq3(ndr, NDR_BUFFERS, &r->req3));
5509                         break;
5510
5511                         default:
5512                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5513                 }
5514         }
5515         return NDR_ERR_SUCCESS;
5516 }
5517
5518 static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq(struct ndr_pull *ndr, int ndr_flags, union samr_ValidatePasswordReq *r)
5519 {
5520         int level;
5521         uint16_t _level;
5522         level = ndr_pull_get_switch_value(ndr, r);
5523         if (ndr_flags & NDR_SCALARS) {
5524                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
5525                 if (_level != level) {
5526                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5527                 }
5528                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
5529                 switch (level) {
5530                         case 1: {
5531                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq1(ndr, NDR_SCALARS, &r->req1));
5532                         break; }
5533
5534                         case 2: {
5535                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq2(ndr, NDR_SCALARS, &r->req2));
5536                         break; }
5537
5538                         case 3: {
5539                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq3(ndr, NDR_SCALARS, &r->req3));
5540                         break; }
5541
5542                         default:
5543                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5544                 }
5545         }
5546         if (ndr_flags & NDR_BUFFERS) {
5547                 switch (level) {
5548                         case 1:
5549                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq1(ndr, NDR_BUFFERS, &r->req1));
5550                         break;
5551
5552                         case 2:
5553                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq2(ndr, NDR_BUFFERS, &r->req2));
5554                         break;
5555
5556                         case 3:
5557                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq3(ndr, NDR_BUFFERS, &r->req3));
5558                         break;
5559
5560                         default:
5561                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5562                 }
5563         }
5564         return NDR_ERR_SUCCESS;
5565 }
5566
5567 _PUBLIC_ void ndr_print_samr_ValidatePasswordReq(struct ndr_print *ndr, const char *name, const union samr_ValidatePasswordReq *r)
5568 {
5569         int level;
5570         level = ndr_print_get_switch_value(ndr, r);
5571         ndr_print_union(ndr, name, level, "samr_ValidatePasswordReq");
5572         switch (level) {
5573                 case 1:
5574                         ndr_print_samr_ValidatePasswordReq1(ndr, "req1", &r->req1);
5575                 break;
5576
5577                 case 2:
5578                         ndr_print_samr_ValidatePasswordReq2(ndr, "req2", &r->req2);
5579                 break;
5580
5581                 case 3:
5582                         ndr_print_samr_ValidatePasswordReq3(ndr, "req3", &r->req3);
5583                 break;
5584
5585                 default:
5586                         ndr_print_bad_level(ndr, name, level);
5587         }
5588 }
5589
5590 static enum ndr_err_code ndr_push_samr_Connect(struct ndr_push *ndr, int flags, const struct samr_Connect *r)
5591 {
5592         if (flags & NDR_IN) {
5593                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
5594                 if (r->in.system_name) {
5595                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
5596                 }
5597                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
5598         }
5599         if (flags & NDR_OUT) {
5600                 if (r->out.connect_handle == NULL) {
5601                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5602                 }
5603                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
5604                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5605         }
5606         return NDR_ERR_SUCCESS;
5607 }
5608
5609 static enum ndr_err_code ndr_pull_samr_Connect(struct ndr_pull *ndr, int flags, struct samr_Connect *r)
5610 {
5611         uint32_t _ptr_system_name;
5612         TALLOC_CTX *_mem_save_system_name_0;
5613         TALLOC_CTX *_mem_save_connect_handle_0;
5614         if (flags & NDR_IN) {
5615                 ZERO_STRUCT(r->out);
5616
5617                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
5618                 if (_ptr_system_name) {
5619                         NDR_PULL_ALLOC(ndr, r->in.system_name);
5620                 } else {
5621                         r->in.system_name = NULL;
5622                 }
5623                 if (r->in.system_name) {
5624                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5625                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
5626                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
5627                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
5628                 }
5629                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
5630                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
5631                 ZERO_STRUCTP(r->out.connect_handle);
5632         }
5633         if (flags & NDR_OUT) {
5634                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5635                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
5636                 }
5637                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5638                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
5639                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
5640                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
5641                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5642         }
5643         return NDR_ERR_SUCCESS;
5644 }
5645
5646 _PUBLIC_ void ndr_print_samr_Connect(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect *r)
5647 {
5648         ndr_print_struct(ndr, name, "samr_Connect");
5649         ndr->depth++;
5650         if (flags & NDR_SET_VALUES) {
5651                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5652         }
5653         if (flags & NDR_IN) {
5654                 ndr_print_struct(ndr, "in", "samr_Connect");
5655                 ndr->depth++;
5656                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
5657                 ndr->depth++;
5658                 if (r->in.system_name) {
5659                         ndr_print_uint16(ndr, "system_name", *r->in.system_name);
5660                 }
5661                 ndr->depth--;
5662                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
5663                 ndr->depth--;
5664         }
5665         if (flags & NDR_OUT) {
5666                 ndr_print_struct(ndr, "out", "samr_Connect");
5667                 ndr->depth++;
5668                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
5669                 ndr->depth++;
5670                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
5671                 ndr->depth--;
5672                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5673                 ndr->depth--;
5674         }
5675         ndr->depth--;
5676 }
5677
5678 _PUBLIC_ enum ndr_err_code ndr_push_samr_Close(struct ndr_push *ndr, int flags, const struct samr_Close *r)
5679 {
5680         if (flags & NDR_IN) {
5681                 if (r->in.handle == NULL) {
5682                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5683                 }
5684                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5685         }
5686         if (flags & NDR_OUT) {
5687                 if (r->out.handle == NULL) {
5688                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5689                 }
5690                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
5691                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5692         }
5693         return NDR_ERR_SUCCESS;
5694 }
5695
5696 _PUBLIC_ enum ndr_err_code ndr_pull_samr_Close(struct ndr_pull *ndr, int flags, struct samr_Close *r)
5697 {
5698         TALLOC_CTX *_mem_save_handle_0;
5699         if (flags & NDR_IN) {
5700                 ZERO_STRUCT(r->out);
5701
5702                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5703                         NDR_PULL_ALLOC(ndr, r->in.handle);
5704                 }
5705                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5706                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5707                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5708                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5709                 NDR_PULL_ALLOC(ndr, r->out.handle);
5710                 *r->out.handle = *r->in.handle;
5711         }
5712         if (flags & NDR_OUT) {
5713                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5714                         NDR_PULL_ALLOC(ndr, r->out.handle);
5715                 }
5716                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5717                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
5718                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
5719                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5720                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5721         }
5722         return NDR_ERR_SUCCESS;
5723 }
5724
5725 _PUBLIC_ void ndr_print_samr_Close(struct ndr_print *ndr, const char *name, int flags, const struct samr_Close *r)
5726 {
5727         ndr_print_struct(ndr, name, "samr_Close");
5728         ndr->depth++;
5729         if (flags & NDR_SET_VALUES) {
5730                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5731         }
5732         if (flags & NDR_IN) {
5733                 ndr_print_struct(ndr, "in", "samr_Close");
5734                 ndr->depth++;
5735                 ndr_print_ptr(ndr, "handle", r->in.handle);
5736                 ndr->depth++;
5737                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5738                 ndr->depth--;
5739                 ndr->depth--;
5740         }
5741         if (flags & NDR_OUT) {
5742                 ndr_print_struct(ndr, "out", "samr_Close");
5743                 ndr->depth++;
5744                 ndr_print_ptr(ndr, "handle", r->out.handle);
5745                 ndr->depth++;
5746                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
5747                 ndr->depth--;
5748                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5749                 ndr->depth--;
5750         }
5751         ndr->depth--;
5752 }
5753
5754 static enum ndr_err_code ndr_push_samr_SetSecurity(struct ndr_push *ndr, int flags, const struct samr_SetSecurity *r)
5755 {
5756         if (flags & NDR_IN) {
5757                 if (r->in.handle == NULL) {
5758                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5759                 }
5760                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5761                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
5762                 if (r->in.sdbuf == NULL) {
5763                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5764                 }
5765                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sdbuf));
5766         }
5767         if (flags & NDR_OUT) {
5768                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5769         }
5770         return NDR_ERR_SUCCESS;
5771 }
5772
5773 static enum ndr_err_code ndr_pull_samr_SetSecurity(struct ndr_pull *ndr, int flags, struct samr_SetSecurity *r)
5774 {
5775         TALLOC_CTX *_mem_save_handle_0;
5776         TALLOC_CTX *_mem_save_sdbuf_0;
5777         if (flags & NDR_IN) {
5778                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5779                         NDR_PULL_ALLOC(ndr, r->in.handle);
5780                 }
5781                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5782                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5783                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5784                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5785                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
5786                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5787                         NDR_PULL_ALLOC(ndr, r->in.sdbuf);
5788                 }
5789                 _mem_save_sdbuf_0 = NDR_PULL_GET_MEM_CTX(ndr);
5790                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sdbuf, LIBNDR_FLAG_REF_ALLOC);
5791                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sdbuf));
5792                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_0, LIBNDR_FLAG_REF_ALLOC);
5793         }
5794         if (flags & NDR_OUT) {
5795                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5796         }
5797         return NDR_ERR_SUCCESS;
5798 }
5799
5800 _PUBLIC_ void ndr_print_samr_SetSecurity(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetSecurity *r)
5801 {
5802         ndr_print_struct(ndr, name, "samr_SetSecurity");
5803         ndr->depth++;
5804         if (flags & NDR_SET_VALUES) {
5805                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5806         }
5807         if (flags & NDR_IN) {
5808                 ndr_print_struct(ndr, "in", "samr_SetSecurity");
5809                 ndr->depth++;
5810                 ndr_print_ptr(ndr, "handle", r->in.handle);
5811                 ndr->depth++;
5812                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5813                 ndr->depth--;
5814                 ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
5815                 ndr_print_ptr(ndr, "sdbuf", r->in.sdbuf);
5816                 ndr->depth++;
5817                 ndr_print_sec_desc_buf(ndr, "sdbuf", r->in.sdbuf);
5818                 ndr->depth--;
5819                 ndr->depth--;
5820         }
5821         if (flags & NDR_OUT) {
5822                 ndr_print_struct(ndr, "out", "samr_SetSecurity");
5823                 ndr->depth++;
5824                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5825                 ndr->depth--;
5826         }
5827         ndr->depth--;
5828 }
5829
5830 static enum ndr_err_code ndr_push_samr_QuerySecurity(struct ndr_push *ndr, int flags, const struct samr_QuerySecurity *r)
5831 {
5832         if (flags & NDR_IN) {
5833                 if (r->in.handle == NULL) {
5834                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5835                 }
5836                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5837                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
5838         }
5839         if (flags & NDR_OUT) {
5840                 if (r->out.sdbuf == NULL) {
5841                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5842                 }
5843                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sdbuf));
5844                 if (*r->out.sdbuf) {
5845                         NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sdbuf));
5846                 }
5847                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5848         }
5849         return NDR_ERR_SUCCESS;
5850 }
5851
5852 static enum ndr_err_code ndr_pull_samr_QuerySecurity(struct ndr_pull *ndr, int flags, struct samr_QuerySecurity *r)
5853 {
5854         uint32_t _ptr_sdbuf;
5855         TALLOC_CTX *_mem_save_handle_0;
5856         TALLOC_CTX *_mem_save_sdbuf_0;
5857         TALLOC_CTX *_mem_save_sdbuf_1;
5858         if (flags & NDR_IN) {
5859                 ZERO_STRUCT(r->out);
5860
5861                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5862                         NDR_PULL_ALLOC(ndr, r->in.handle);
5863                 }
5864                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5865                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5866                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5867                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5868                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
5869                 NDR_PULL_ALLOC(ndr, r->out.sdbuf);
5870                 ZERO_STRUCTP(r->out.sdbuf);
5871         }
5872         if (flags & NDR_OUT) {
5873                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5874                         NDR_PULL_ALLOC(ndr, r->out.sdbuf);
5875                 }
5876                 _mem_save_sdbuf_0 = NDR_PULL_GET_MEM_CTX(ndr);
5877                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sdbuf, LIBNDR_FLAG_REF_ALLOC);
5878                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sdbuf));
5879                 if (_ptr_sdbuf) {
5880                         NDR_PULL_ALLOC(ndr, *r->out.sdbuf);
5881                 } else {
5882                         *r->out.sdbuf = NULL;
5883                 }
5884                 if (*r->out.sdbuf) {
5885                         _mem_save_sdbuf_1 = NDR_PULL_GET_MEM_CTX(ndr);
5886                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sdbuf, 0);
5887                         NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sdbuf));
5888                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_1, 0);
5889                 }
5890                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_0, LIBNDR_FLAG_REF_ALLOC);
5891                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5892         }
5893         return NDR_ERR_SUCCESS;
5894 }
5895
5896 _PUBLIC_ void ndr_print_samr_QuerySecurity(struct ndr_print *ndr, const char *name, int flags, const struct samr_QuerySecurity *r)
5897 {
5898         ndr_print_struct(ndr, name, "samr_QuerySecurity");
5899         ndr->depth++;
5900         if (flags & NDR_SET_VALUES) {
5901                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5902         }
5903         if (flags & NDR_IN) {
5904                 ndr_print_struct(ndr, "in", "samr_QuerySecurity");
5905                 ndr->depth++;
5906                 ndr_print_ptr(ndr, "handle", r->in.handle);
5907                 ndr->depth++;
5908                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5909                 ndr->depth--;
5910                 ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
5911                 ndr->depth--;
5912         }
5913         if (flags & NDR_OUT) {
5914                 ndr_print_struct(ndr, "out", "samr_QuerySecurity");
5915                 ndr->depth++;
5916                 ndr_print_ptr(ndr, "sdbuf", r->out.sdbuf);
5917                 ndr->depth++;
5918                 ndr_print_ptr(ndr, "sdbuf", *r->out.sdbuf);
5919                 ndr->depth++;
5920                 if (*r->out.sdbuf) {
5921                         ndr_print_sec_desc_buf(ndr, "sdbuf", *r->out.sdbuf);
5922                 }
5923                 ndr->depth--;
5924                 ndr->depth--;
5925                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5926                 ndr->depth--;
5927         }
5928         ndr->depth--;
5929 }
5930
5931 static enum ndr_err_code ndr_push_samr_Shutdown(struct ndr_push *ndr, int flags, const struct samr_Shutdown *r)
5932 {
5933         if (flags & NDR_IN) {
5934                 if (r->in.connect_handle == NULL) {
5935                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5936                 }
5937                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5938         }
5939         if (flags & NDR_OUT) {
5940                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5941         }
5942         return NDR_ERR_SUCCESS;
5943 }
5944
5945 static enum ndr_err_code ndr_pull_samr_Shutdown(struct ndr_pull *ndr, int flags, struct samr_Shutdown *r)
5946 {
5947         TALLOC_CTX *_mem_save_connect_handle_0;
5948         if (flags & NDR_IN) {
5949                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5950                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
5951                 }
5952                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5953                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
5954                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5955                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
5956         }
5957         if (flags & NDR_OUT) {
5958                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5959         }
5960         return NDR_ERR_SUCCESS;
5961 }
5962
5963 _PUBLIC_ void ndr_print_samr_Shutdown(struct ndr_print *ndr, const char *name, int flags, const struct samr_Shutdown *r)
5964 {
5965         ndr_print_struct(ndr, name, "samr_Shutdown");
5966         ndr->depth++;
5967         if (flags & NDR_SET_VALUES) {
5968                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5969         }
5970         if (flags & NDR_IN) {
5971                 ndr_print_struct(ndr, "in", "samr_Shutdown");
5972                 ndr->depth++;
5973                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
5974                 ndr->depth++;
5975                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
5976                 ndr->depth--;
5977                 ndr->depth--;
5978         }
5979         if (flags & NDR_OUT) {
5980                 ndr_print_struct(ndr, "out", "samr_Shutdown");
5981                 ndr->depth++;
5982                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5983                 ndr->depth--;
5984         }
5985         ndr->depth--;
5986 }
5987
5988 static enum ndr_err_code ndr_push_samr_LookupDomain(struct ndr_push *ndr, int flags, const struct samr_LookupDomain *r)
5989 {
5990         if (flags & NDR_IN) {
5991                 if (r->in.connect_handle == NULL) {
5992                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5993                 }
5994                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5995                 if (r->in.domain_name == NULL) {
5996                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5997                 }
5998                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
5999         }
6000         if (flags & NDR_OUT) {
6001                 if (r->out.sid == NULL) {
6002                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6003                 }
6004                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sid));
6005                 if (*r->out.sid) {
6006                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
6007                 }
6008                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6009         }
6010         return NDR_ERR_SUCCESS;
6011 }
6012
6013 static enum ndr_err_code ndr_pull_samr_LookupDomain(struct ndr_pull *ndr, int flags, struct samr_LookupDomain *r)
6014 {
6015         uint32_t _ptr_sid;
6016         TALLOC_CTX *_mem_save_connect_handle_0;
6017         TALLOC_CTX *_mem_save_domain_name_0;
6018         TALLOC_CTX *_mem_save_sid_0;
6019         TALLOC_CTX *_mem_save_sid_1;
6020         if (flags & NDR_IN) {
6021                 ZERO_STRUCT(r->out);
6022
6023                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6024                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
6025                 }
6026                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6027                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
6028                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
6029                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
6030                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6031                         NDR_PULL_ALLOC(ndr, r->in.domain_name);
6032                 }
6033                 _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6034                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_name, LIBNDR_FLAG_REF_ALLOC);
6035                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
6036                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, LIBNDR_FLAG_REF_ALLOC);
6037                 NDR_PULL_ALLOC(ndr, r->out.sid);
6038                 ZERO_STRUCTP(r->out.sid);
6039         }
6040         if (flags & NDR_OUT) {
6041                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6042                         NDR_PULL_ALLOC(ndr, r->out.sid);
6043                 }
6044                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6045                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);
6046                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
6047                 if (_ptr_sid) {
6048                         NDR_PULL_ALLOC(ndr, *r->out.sid);
6049                 } else {
6050                         *r->out.sid = NULL;
6051                 }
6052                 if (*r->out.sid) {
6053                         _mem_save_sid_1 = NDR_PULL_GET_MEM_CTX(ndr);
6054                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sid, 0);
6055                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
6056                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_1, 0);
6057                 }
6058                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
6059                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6060         }
6061         return NDR_ERR_SUCCESS;
6062 }
6063
6064 _PUBLIC_ void ndr_print_samr_LookupDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupDomain *r)
6065 {
6066         ndr_print_struct(ndr, name, "samr_LookupDomain");
6067         ndr->depth++;
6068         if (flags & NDR_SET_VALUES) {
6069                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6070         }
6071         if (flags & NDR_IN) {
6072                 ndr_print_struct(ndr, "in", "samr_LookupDomain");
6073                 ndr->depth++;
6074                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
6075                 ndr->depth++;
6076                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
6077                 ndr->depth--;
6078                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
6079                 ndr->depth++;
6080                 ndr_print_lsa_String(ndr, "domain_name", r->in.domain_name);
6081                 ndr->depth--;
6082                 ndr->depth--;
6083         }
6084         if (flags & NDR_OUT) {
6085                 ndr_print_struct(ndr, "out", "samr_LookupDomain");
6086                 ndr->depth++;
6087                 ndr_print_ptr(ndr, "sid", r->out.sid);
6088                 ndr->depth++;
6089                 ndr_print_ptr(ndr, "sid", *r->out.sid);
6090                 ndr->depth++;
6091                 if (*r->out.sid) {
6092                         ndr_print_dom_sid2(ndr, "sid", *r->out.sid);
6093                 }
6094                 ndr->depth--;
6095                 ndr->depth--;
6096                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6097                 ndr->depth--;
6098         }
6099         ndr->depth--;
6100 }
6101
6102 static enum ndr_err_code ndr_push_samr_EnumDomains(struct ndr_push *ndr, int flags, const struct samr_EnumDomains *r)
6103 {
6104         if (flags & NDR_IN) {
6105                 if (r->in.connect_handle == NULL) {
6106                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6107                 }
6108                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
6109                 if (r->in.resume_handle == NULL) {
6110                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6111                 }
6112                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6113                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
6114         }
6115         if (flags & NDR_OUT) {
6116                 if (r->out.resume_handle == NULL) {
6117                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6118                 }
6119                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6120                 if (r->out.sam == NULL) {
6121                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6122                 }
6123                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
6124                 if (*r->out.sam) {
6125                         NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6126                 }
6127                 if (r->out.num_entries == NULL) {
6128                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6129                 }
6130                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
6131                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6132         }
6133         return NDR_ERR_SUCCESS;
6134 }
6135
6136 static enum ndr_err_code ndr_pull_samr_EnumDomains(struct ndr_pull *ndr, int flags, struct samr_EnumDomains *r)
6137 {
6138         uint32_t _ptr_sam;
6139         TALLOC_CTX *_mem_save_connect_handle_0;
6140         TALLOC_CTX *_mem_save_resume_handle_0;
6141         TALLOC_CTX *_mem_save_sam_0;
6142         TALLOC_CTX *_mem_save_sam_1;
6143         TALLOC_CTX *_mem_save_num_entries_0;
6144         if (flags & NDR_IN) {
6145                 ZERO_STRUCT(r->out);
6146
6147                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6148                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
6149                 }
6150                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6151                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
6152                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
6153                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
6154                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6155                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
6156                 }
6157                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6158                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6159                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6160                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
6162                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6163                 *r->out.resume_handle = *r->in.resume_handle;
6164                 NDR_PULL_ALLOC(ndr, r->out.sam);
6165                 ZERO_STRUCTP(r->out.sam);
6166                 NDR_PULL_ALLOC(ndr, r->out.num_entries);
6167                 ZERO_STRUCTP(r->out.num_entries);
6168         }
6169         if (flags & NDR_OUT) {
6170                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6171                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6172                 }
6173                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6174                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6175                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6176                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6177                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6178                         NDR_PULL_ALLOC(ndr, r->out.sam);
6179                 }
6180                 _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
6181                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
6182                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
6183                 if (_ptr_sam) {
6184                         NDR_PULL_ALLOC(ndr, *r->out.sam);
6185                 } else {
6186                         *r->out.sam = NULL;
6187                 }
6188                 if (*r->out.sam) {
6189                         _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
6190                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
6191                         NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6192                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
6193                 }
6194                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
6195                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6196                         NDR_PULL_ALLOC(ndr, r->out.num_entries);
6197                 }
6198                 _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
6199                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
6200                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
6201                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
6202                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6203         }
6204         return NDR_ERR_SUCCESS;
6205 }
6206
6207 _PUBLIC_ void ndr_print_samr_EnumDomains(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomains *r)
6208 {
6209         ndr_print_struct(ndr, name, "samr_EnumDomains");
6210         ndr->depth++;
6211         if (flags & NDR_SET_VALUES) {
6212                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6213         }
6214         if (flags & NDR_IN) {
6215                 ndr_print_struct(ndr, "in", "samr_EnumDomains");
6216                 ndr->depth++;
6217                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
6218                 ndr->depth++;
6219                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
6220                 ndr->depth--;
6221                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6222                 ndr->depth++;
6223                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6224                 ndr->depth--;
6225                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
6226                 ndr->depth--;
6227         }
6228         if (flags & NDR_OUT) {
6229                 ndr_print_struct(ndr, "out", "samr_EnumDomains");
6230                 ndr->depth++;
6231                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6232                 ndr->depth++;
6233                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6234                 ndr->depth--;
6235                 ndr_print_ptr(ndr, "sam", r->out.sam);
6236                 ndr->depth++;
6237                 ndr_print_ptr(ndr, "sam", *r->out.sam);
6238                 ndr->depth++;
6239                 if (*r->out.sam) {
6240                         ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
6241                 }
6242                 ndr->depth--;
6243                 ndr->depth--;
6244                 ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
6245                 ndr->depth++;
6246                 ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
6247                 ndr->depth--;
6248                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6249                 ndr->depth--;
6250         }
6251         ndr->depth--;
6252 }
6253
6254 _PUBLIC_ enum ndr_err_code ndr_push_samr_OpenDomain(struct ndr_push *ndr, int flags, const struct samr_OpenDomain *r)
6255 {
6256         if (flags & NDR_IN) {
6257                 if (r->in.connect_handle == NULL) {
6258                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6259                 }
6260                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
6261                 NDR_CHECK(ndr_push_samr_DomainAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
6262                 if (r->in.sid == NULL) {
6263                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6264                 }
6265                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
6266         }
6267         if (flags & NDR_OUT) {
6268                 if (r->out.domain_handle == NULL) {
6269                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6270                 }
6271                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.domain_handle));
6272                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6273         }
6274         return NDR_ERR_SUCCESS;
6275 }
6276
6277 _PUBLIC_ enum ndr_err_code ndr_pull_samr_OpenDomain(struct ndr_pull *ndr, int flags, struct samr_OpenDomain *r)
6278 {
6279         TALLOC_CTX *_mem_save_connect_handle_0;
6280         TALLOC_CTX *_mem_save_sid_0;
6281         TALLOC_CTX *_mem_save_domain_handle_0;
6282         if (flags & NDR_IN) {
6283                 ZERO_STRUCT(r->out);
6284
6285                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6286                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
6287                 }
6288                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6289                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
6290                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
6291                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
6292                 NDR_CHECK(ndr_pull_samr_DomainAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
6293                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6294                         NDR_PULL_ALLOC(ndr, r->in.sid);
6295                 }
6296                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6297                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
6298                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
6299                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
6300                 NDR_PULL_ALLOC(ndr, r->out.domain_handle);
6301                 ZERO_STRUCTP(r->out.domain_handle);
6302         }
6303         if (flags & NDR_OUT) {
6304                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6305                         NDR_PULL_ALLOC(ndr, r->out.domain_handle);
6306                 }
6307                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6308                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6309                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.domain_handle));
6310                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6311                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6312         }
6313         return NDR_ERR_SUCCESS;
6314 }
6315
6316 _PUBLIC_ void ndr_print_samr_OpenDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenDomain *r)
6317 {
6318         ndr_print_struct(ndr, name, "samr_OpenDomain");
6319         ndr->depth++;
6320         if (flags & NDR_SET_VALUES) {
6321                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6322         }
6323         if (flags & NDR_IN) {
6324                 ndr_print_struct(ndr, "in", "samr_OpenDomain");
6325                 ndr->depth++;
6326                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
6327                 ndr->depth++;
6328                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
6329                 ndr->depth--;
6330                 ndr_print_samr_DomainAccessMask(ndr, "access_mask", r->in.access_mask);
6331                 ndr_print_ptr(ndr, "sid", r->in.sid);
6332                 ndr->depth++;
6333                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
6334                 ndr->depth--;
6335                 ndr->depth--;
6336         }
6337         if (flags & NDR_OUT) {
6338                 ndr_print_struct(ndr, "out", "samr_OpenDomain");
6339                 ndr->depth++;
6340                 ndr_print_ptr(ndr, "domain_handle", r->out.domain_handle);
6341                 ndr->depth++;
6342                 ndr_print_policy_handle(ndr, "domain_handle", r->out.domain_handle);
6343                 ndr->depth--;
6344                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6345                 ndr->depth--;
6346         }
6347         ndr->depth--;
6348 }
6349
6350 static enum ndr_err_code ndr_push_samr_QueryDomainInfo(struct ndr_push *ndr, int flags, const struct samr_QueryDomainInfo *r)
6351 {
6352         if (flags & NDR_IN) {
6353                 if (r->in.domain_handle == NULL) {
6354                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6355                 }
6356                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6357                 NDR_CHECK(ndr_push_samr_DomainInfoClass(ndr, NDR_SCALARS, r->in.level));
6358         }
6359         if (flags & NDR_OUT) {
6360                 if (r->out.info == NULL) {
6361                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6362                 }
6363                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
6364                 if (*r->out.info) {
6365                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
6366                         NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
6367                 }
6368                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6369         }
6370         return NDR_ERR_SUCCESS;
6371 }
6372
6373 static enum ndr_err_code ndr_pull_samr_QueryDomainInfo(struct ndr_pull *ndr, int flags, struct samr_QueryDomainInfo *r)
6374 {
6375         uint32_t _ptr_info;
6376         TALLOC_CTX *_mem_save_domain_handle_0;
6377         TALLOC_CTX *_mem_save_info_0;
6378         TALLOC_CTX *_mem_save_info_1;
6379         if (flags & NDR_IN) {
6380                 ZERO_STRUCT(r->out);
6381
6382                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6383                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6384                 }
6385                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6386                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6387                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6388                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6389                 NDR_CHECK(ndr_pull_samr_DomainInfoClass(ndr, NDR_SCALARS, &r->in.level));
6390                 NDR_PULL_ALLOC(ndr, r->out.info);
6391                 ZERO_STRUCTP(r->out.info);
6392         }
6393         if (flags & NDR_OUT) {
6394                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6395                         NDR_PULL_ALLOC(ndr, r->out.info);
6396                 }
6397                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6398                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
6399                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
6400                 if (_ptr_info) {
6401                         NDR_PULL_ALLOC(ndr, *r->out.info);
6402                 } else {
6403                         *r->out.info = NULL;
6404                 }
6405                 if (*r->out.info) {
6406                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
6407                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
6408                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
6409                         NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
6410                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
6411                 }
6412                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6413                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6414         }
6415         return NDR_ERR_SUCCESS;
6416 }
6417
6418 _PUBLIC_ void ndr_print_samr_QueryDomainInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDomainInfo *r)
6419 {
6420         ndr_print_struct(ndr, name, "samr_QueryDomainInfo");
6421         ndr->depth++;
6422         if (flags & NDR_SET_VALUES) {
6423                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6424         }
6425         if (flags & NDR_IN) {
6426                 ndr_print_struct(ndr, "in", "samr_QueryDomainInfo");
6427                 ndr->depth++;
6428                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6429                 ndr->depth++;
6430                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6431                 ndr->depth--;
6432                 ndr_print_samr_DomainInfoClass(ndr, "level", r->in.level);
6433                 ndr->depth--;
6434         }
6435         if (flags & NDR_OUT) {
6436                 ndr_print_struct(ndr, "out", "samr_QueryDomainInfo");
6437                 ndr->depth++;
6438                 ndr_print_ptr(ndr, "info", r->out.info);
6439                 ndr->depth++;
6440                 ndr_print_ptr(ndr, "info", *r->out.info);
6441                 ndr->depth++;
6442                 if (*r->out.info) {
6443                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
6444                         ndr_print_samr_DomainInfo(ndr, "info", *r->out.info);
6445                 }
6446                 ndr->depth--;
6447                 ndr->depth--;
6448                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6449                 ndr->depth--;
6450         }
6451         ndr->depth--;
6452 }
6453
6454 static enum ndr_err_code ndr_push_samr_SetDomainInfo(struct ndr_push *ndr, int flags, const struct samr_SetDomainInfo *r)
6455 {
6456         if (flags & NDR_IN) {
6457                 if (r->in.domain_handle == NULL) {
6458                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6459                 }
6460                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6461                 NDR_CHECK(ndr_push_samr_DomainInfoClass(ndr, NDR_SCALARS, r->in.level));
6462                 if (r->in.info == NULL) {
6463                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6464                 }
6465                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
6466                 NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6467         }
6468         if (flags & NDR_OUT) {
6469                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6470         }
6471         return NDR_ERR_SUCCESS;
6472 }
6473
6474 static enum ndr_err_code ndr_pull_samr_SetDomainInfo(struct ndr_pull *ndr, int flags, struct samr_SetDomainInfo *r)
6475 {
6476         TALLOC_CTX *_mem_save_domain_handle_0;
6477         TALLOC_CTX *_mem_save_info_0;
6478         if (flags & NDR_IN) {
6479                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6480                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6481                 }
6482                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6483                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6484                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6485                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6486                 NDR_CHECK(ndr_pull_samr_DomainInfoClass(ndr, NDR_SCALARS, &r->in.level));
6487                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6488                         NDR_PULL_ALLOC(ndr, r->in.info);
6489                 }
6490                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6491                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
6492                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
6493                 NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6494                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6495         }
6496         if (flags & NDR_OUT) {
6497                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6498         }
6499         return NDR_ERR_SUCCESS;
6500 }
6501
6502 _PUBLIC_ void ndr_print_samr_SetDomainInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetDomainInfo *r)
6503 {
6504         ndr_print_struct(ndr, name, "samr_SetDomainInfo");
6505         ndr->depth++;
6506         if (flags & NDR_SET_VALUES) {
6507                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6508         }
6509         if (flags & NDR_IN) {
6510                 ndr_print_struct(ndr, "in", "samr_SetDomainInfo");
6511                 ndr->depth++;
6512                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6513                 ndr->depth++;
6514                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6515                 ndr->depth--;
6516                 ndr_print_samr_DomainInfoClass(ndr, "level", r->in.level);
6517                 ndr_print_ptr(ndr, "info", r->in.info);
6518                 ndr->depth++;
6519                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
6520                 ndr_print_samr_DomainInfo(ndr, "info", r->in.info);
6521                 ndr->depth--;
6522                 ndr->depth--;
6523         }
6524         if (flags & NDR_OUT) {
6525                 ndr_print_struct(ndr, "out", "samr_SetDomainInfo");
6526                 ndr->depth++;
6527                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6528                 ndr->depth--;
6529         }
6530         ndr->depth--;
6531 }
6532
6533 static enum ndr_err_code ndr_push_samr_CreateDomainGroup(struct ndr_push *ndr, int flags, const struct samr_CreateDomainGroup *r)
6534 {
6535         if (flags & NDR_IN) {
6536                 if (r->in.domain_handle == NULL) {
6537                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6538                 }
6539                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6540                 if (r->in.name == NULL) {
6541                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6542                 }
6543                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
6544                 NDR_CHECK(ndr_push_samr_GroupAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
6545         }
6546         if (flags & NDR_OUT) {
6547                 if (r->out.group_handle == NULL) {
6548                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6549                 }
6550                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
6551                 if (r->out.rid == NULL) {
6552                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6553                 }
6554                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
6555                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6556         }
6557         return NDR_ERR_SUCCESS;
6558 }
6559
6560 static enum ndr_err_code ndr_pull_samr_CreateDomainGroup(struct ndr_pull *ndr, int flags, struct samr_CreateDomainGroup *r)
6561 {
6562         TALLOC_CTX *_mem_save_domain_handle_0;
6563         TALLOC_CTX *_mem_save_name_0;
6564         TALLOC_CTX *_mem_save_group_handle_0;
6565         TALLOC_CTX *_mem_save_rid_0;
6566         if (flags & NDR_IN) {
6567                 ZERO_STRUCT(r->out);
6568
6569                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6570                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6571                 }
6572                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6573                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6574                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6575                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6576                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6577                         NDR_PULL_ALLOC(ndr, r->in.name);
6578                 }
6579                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6580                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
6581                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
6582                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
6583                 NDR_CHECK(ndr_pull_samr_GroupAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
6584                 NDR_PULL_ALLOC(ndr, r->out.group_handle);
6585                 ZERO_STRUCTP(r->out.group_handle);
6586                 NDR_PULL_ALLOC(ndr, r->out.rid);
6587                 ZERO_STRUCTP(r->out.rid);
6588         }
6589         if (flags & NDR_OUT) {
6590                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6591                         NDR_PULL_ALLOC(ndr, r->out.group_handle);
6592                 }
6593                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6594                 NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);
6595                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
6596                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
6597                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6598                         NDR_PULL_ALLOC(ndr, r->out.rid);
6599                 }
6600                 _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6601                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
6602                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
6603                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
6604                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6605         }
6606         return NDR_ERR_SUCCESS;
6607 }
6608
6609 _PUBLIC_ void ndr_print_samr_CreateDomainGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateDomainGroup *r)
6610 {
6611         ndr_print_struct(ndr, name, "samr_CreateDomainGroup");
6612         ndr->depth++;
6613         if (flags & NDR_SET_VALUES) {
6614                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6615         }
6616         if (flags & NDR_IN) {
6617                 ndr_print_struct(ndr, "in", "samr_CreateDomainGroup");
6618                 ndr->depth++;
6619                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6620                 ndr->depth++;
6621                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6622                 ndr->depth--;
6623                 ndr_print_ptr(ndr, "name", r->in.name);
6624                 ndr->depth++;
6625                 ndr_print_lsa_String(ndr, "name", r->in.name);
6626                 ndr->depth--;
6627                 ndr_print_samr_GroupAccessMask(ndr, "access_mask", r->in.access_mask);
6628                 ndr->depth--;
6629         }
6630         if (flags & NDR_OUT) {
6631                 ndr_print_struct(ndr, "out", "samr_CreateDomainGroup");
6632                 ndr->depth++;
6633                 ndr_print_ptr(ndr, "group_handle", r->out.group_handle);
6634                 ndr->depth++;
6635                 ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);
6636                 ndr->depth--;
6637                 ndr_print_ptr(ndr, "rid", r->out.rid);
6638                 ndr->depth++;
6639                 ndr_print_uint32(ndr, "rid", *r->out.rid);
6640                 ndr->depth--;
6641                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6642                 ndr->depth--;
6643         }
6644         ndr->depth--;
6645 }
6646
6647 static enum ndr_err_code ndr_push_samr_EnumDomainGroups(struct ndr_push *ndr, int flags, const struct samr_EnumDomainGroups *r)
6648 {
6649         if (flags & NDR_IN) {
6650                 if (r->in.domain_handle == NULL) {
6651                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6652                 }
6653                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6654                 if (r->in.resume_handle == NULL) {
6655                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6656                 }
6657                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6658                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
6659         }
6660         if (flags & NDR_OUT) {
6661                 if (r->out.resume_handle == NULL) {
6662                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6663                 }
6664                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6665                 if (r->out.sam == NULL) {
6666                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6667                 }
6668                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
6669                 if (*r->out.sam) {
6670                         NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6671                 }
6672                 if (r->out.num_entries == NULL) {
6673                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6674                 }
6675                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
6676                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6677         }
6678         return NDR_ERR_SUCCESS;
6679 }
6680
6681 static enum ndr_err_code ndr_pull_samr_EnumDomainGroups(struct ndr_pull *ndr, int flags, struct samr_EnumDomainGroups *r)
6682 {
6683         uint32_t _ptr_sam;
6684         TALLOC_CTX *_mem_save_domain_handle_0;
6685         TALLOC_CTX *_mem_save_resume_handle_0;
6686         TALLOC_CTX *_mem_save_sam_0;
6687         TALLOC_CTX *_mem_save_sam_1;
6688         TALLOC_CTX *_mem_save_num_entries_0;
6689         if (flags & NDR_IN) {
6690                 ZERO_STRUCT(r->out);
6691
6692                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6693                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6694                 }
6695                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6696                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6697                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6698                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6699                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6700                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
6701                 }
6702                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6703                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6704                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6705                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6706                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
6707                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6708                 *r->out.resume_handle = *r->in.resume_handle;
6709                 NDR_PULL_ALLOC(ndr, r->out.sam);
6710                 ZERO_STRUCTP(r->out.sam);
6711                 NDR_PULL_ALLOC(ndr, r->out.num_entries);
6712                 ZERO_STRUCTP(r->out.num_entries);
6713         }
6714         if (flags & NDR_OUT) {
6715                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6716                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6717                 }
6718                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6719                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6720                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6721                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6722                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6723                         NDR_PULL_ALLOC(ndr, r->out.sam);
6724                 }
6725                 _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
6726                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
6727                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
6728                 if (_ptr_sam) {
6729                         NDR_PULL_ALLOC(ndr, *r->out.sam);
6730                 } else {
6731                         *r->out.sam = NULL;
6732                 }
6733                 if (*r->out.sam) {
6734                         _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
6735                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
6736                         NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6737                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
6738                 }
6739                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
6740                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6741                         NDR_PULL_ALLOC(ndr, r->out.num_entries);
6742                 }
6743                 _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
6744                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
6745                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
6746                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
6747                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6748         }
6749         return NDR_ERR_SUCCESS;
6750 }
6751
6752 _PUBLIC_ void ndr_print_samr_EnumDomainGroups(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainGroups *r)
6753 {
6754         ndr_print_struct(ndr, name, "samr_EnumDomainGroups");
6755         ndr->depth++;
6756         if (flags & NDR_SET_VALUES) {
6757                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6758         }
6759         if (flags & NDR_IN) {
6760                 ndr_print_struct(ndr, "in", "samr_EnumDomainGroups");
6761                 ndr->depth++;
6762                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6763                 ndr->depth++;
6764                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6765                 ndr->depth--;
6766                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6767                 ndr->depth++;
6768                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6769                 ndr->depth--;
6770                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
6771                 ndr->depth--;
6772         }
6773         if (flags & NDR_OUT) {
6774                 ndr_print_struct(ndr, "out", "samr_EnumDomainGroups");
6775                 ndr->depth++;
6776                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6777                 ndr->depth++;
6778                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6779                 ndr->depth--;
6780                 ndr_print_ptr(ndr, "sam", r->out.sam);
6781                 ndr->depth++;
6782                 ndr_print_ptr(ndr, "sam", *r->out.sam);
6783                 ndr->depth++;
6784                 if (*r->out.sam) {
6785                         ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
6786                 }
6787                 ndr->depth--;
6788                 ndr->depth--;
6789                 ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
6790                 ndr->depth++;
6791                 ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
6792                 ndr->depth--;
6793                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6794                 ndr->depth--;
6795         }
6796         ndr->depth--;
6797 }
6798
6799 static enum ndr_err_code ndr_push_samr_CreateUser(struct ndr_push *ndr, int flags, const struct samr_CreateUser *r)
6800 {
6801         if (flags & NDR_IN) {
6802                 if (r->in.domain_handle == NULL) {
6803                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6804                 }
6805                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6806                 if (r->in.account_name == NULL) {
6807                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6808                 }
6809                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
6810                 NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
6811         }
6812         if (flags & NDR_OUT) {
6813                 if (r->out.user_handle == NULL) {
6814                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6815                 }
6816                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
6817                 if (r->out.rid == NULL) {
6818                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6819                 }
6820                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
6821                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6822         }
6823         return NDR_ERR_SUCCESS;
6824 }
6825
6826 static enum ndr_err_code ndr_pull_samr_CreateUser(struct ndr_pull *ndr, int flags, struct samr_CreateUser *r)
6827 {
6828         TALLOC_CTX *_mem_save_domain_handle_0;
6829         TALLOC_CTX *_mem_save_account_name_0;
6830         TALLOC_CTX *_mem_save_user_handle_0;
6831         TALLOC_CTX *_mem_save_rid_0;
6832         if (flags & NDR_IN) {
6833                 ZERO_STRUCT(r->out);
6834
6835                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6836                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6837                 }
6838                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6839                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6840                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6841                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6842                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6843                         NDR_PULL_ALLOC(ndr, r->in.account_name);
6844                 }
6845                 _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6846                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account_name, LIBNDR_FLAG_REF_ALLOC);
6847                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
6848                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, LIBNDR_FLAG_REF_ALLOC);
6849                 NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
6850                 NDR_PULL_ALLOC(ndr, r->out.user_handle);
6851                 ZERO_STRUCTP(r->out.user_handle);
6852                 NDR_PULL_ALLOC(ndr, r->out.rid);
6853                 ZERO_STRUCTP(r->out.rid);
6854         }
6855         if (flags & NDR_OUT) {
6856                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6857                         NDR_PULL_ALLOC(ndr, r->out.user_handle);
6858                 }
6859                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6860                 NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
6861                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
6862                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
6863                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6864                         NDR_PULL_ALLOC(ndr, r->out.rid);
6865                 }
6866                 _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6867                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
6868                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
6869                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
6870                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6871         }
6872         return NDR_ERR_SUCCESS;
6873 }
6874
6875 _PUBLIC_ void ndr_print_samr_CreateUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateUser *r)
6876 {
6877         ndr_print_struct(ndr, name, "samr_CreateUser");
6878         ndr->depth++;
6879         if (flags & NDR_SET_VALUES) {
6880                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6881         }
6882         if (flags & NDR_IN) {
6883                 ndr_print_struct(ndr, "in", "samr_CreateUser");
6884                 ndr->depth++;
6885                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6886                 ndr->depth++;
6887                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6888                 ndr->depth--;
6889                 ndr_print_ptr(ndr, "account_name", r->in.account_name);
6890                 ndr->depth++;
6891                 ndr_print_lsa_String(ndr, "account_name", r->in.account_name);
6892                 ndr->depth--;
6893                 ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);
6894                 ndr->depth--;
6895         }
6896         if (flags & NDR_OUT) {
6897                 ndr_print_struct(ndr, "out", "samr_CreateUser");
6898                 ndr->depth++;
6899                 ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
6900                 ndr->depth++;
6901                 ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
6902                 ndr->depth--;
6903                 ndr_print_ptr(ndr, "rid", r->out.rid);
6904                 ndr->depth++;
6905                 ndr_print_uint32(ndr, "rid", *r->out.rid);
6906                 ndr->depth--;
6907                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6908                 ndr->depth--;
6909         }
6910         ndr->depth--;
6911 }
6912
6913 static enum ndr_err_code ndr_push_samr_EnumDomainUsers(struct ndr_push *ndr, int flags, const struct samr_EnumDomainUsers *r)
6914 {
6915         if (flags & NDR_IN) {
6916                 if (r->in.domain_handle == NULL) {
6917                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6918                 }
6919                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6920                 if (r->in.resume_handle == NULL) {
6921                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6922                 }
6923                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6924                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->in.acct_flags));
6925                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
6926         }
6927         if (flags & NDR_OUT) {
6928                 if (r->out.resume_handle == NULL) {
6929                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6930                 }
6931                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6932                 if (r->out.sam == NULL) {
6933                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6934                 }
6935                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
6936                 if (*r->out.sam) {
6937                         NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6938                 }
6939                 if (r->out.num_entries == NULL) {
6940                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6941                 }
6942                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
6943                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6944         }
6945         return NDR_ERR_SUCCESS;
6946 }
6947
6948 static enum ndr_err_code ndr_pull_samr_EnumDomainUsers(struct ndr_pull *ndr, int flags, struct samr_EnumDomainUsers *r)
6949 {
6950         uint32_t _ptr_sam;
6951         TALLOC_CTX *_mem_save_domain_handle_0;
6952         TALLOC_CTX *_mem_save_resume_handle_0;
6953         TALLOC_CTX *_mem_save_sam_0;
6954         TALLOC_CTX *_mem_save_sam_1;
6955         TALLOC_CTX *_mem_save_num_entries_0;
6956         if (flags & NDR_IN) {
6957                 ZERO_STRUCT(r->out);
6958
6959                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6960                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6961                 }
6962                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6963                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6964                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6965                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6966                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6967                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
6968                 }
6969                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6970                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6971                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6972                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6973                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->in.acct_flags));
6974                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
6975                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6976                 *r->out.resume_handle = *r->in.resume_handle;
6977                 NDR_PULL_ALLOC(ndr, r->out.sam);
6978                 ZERO_STRUCTP(r->out.sam);
6979                 NDR_PULL_ALLOC(ndr, r->out.num_entries);
6980                 ZERO_STRUCTP(r->out.num_entries);
6981         }
6982         if (flags & NDR_OUT) {
6983                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6984                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6985                 }
6986                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6987                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6988                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6989                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6990                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6991                         NDR_PULL_ALLOC(ndr, r->out.sam);
6992                 }
6993                 _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
6994                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
6995                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
6996                 if (_ptr_sam) {
6997                         NDR_PULL_ALLOC(ndr, *r->out.sam);
6998                 } else {
6999                         *r->out.sam = NULL;
7000                 }
7001                 if (*r->out.sam) {
7002                         _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
7003                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
7004                         NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
7005                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
7006                 }
7007                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
7008                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7009                         NDR_PULL_ALLOC(ndr, r->out.num_entries);
7010                 }
7011                 _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
7012                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
7013                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
7014                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
7015                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7016         }
7017         return NDR_ERR_SUCCESS;
7018 }
7019
7020 _PUBLIC_ void ndr_print_samr_EnumDomainUsers(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainUsers *r)
7021 {
7022         ndr_print_struct(ndr, name, "samr_EnumDomainUsers");
7023         ndr->depth++;
7024         if (flags & NDR_SET_VALUES) {
7025                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7026         }
7027         if (flags & NDR_IN) {
7028                 ndr_print_struct(ndr, "in", "samr_EnumDomainUsers");
7029                 ndr->depth++;
7030                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7031                 ndr->depth++;
7032                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7033                 ndr->depth--;
7034                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
7035                 ndr->depth++;
7036                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
7037                 ndr->depth--;
7038                 ndr_print_samr_AcctFlags(ndr, "acct_flags", r->in.acct_flags);
7039                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
7040                 ndr->depth--;
7041         }
7042         if (flags & NDR_OUT) {
7043                 ndr_print_struct(ndr, "out", "samr_EnumDomainUsers");
7044                 ndr->depth++;
7045                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
7046                 ndr->depth++;
7047                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
7048                 ndr->depth--;
7049                 ndr_print_ptr(ndr, "sam", r->out.sam);
7050                 ndr->depth++;
7051                 ndr_print_ptr(ndr, "sam", *r->out.sam);
7052                 ndr->depth++;
7053                 if (*r->out.sam) {
7054                         ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
7055                 }
7056                 ndr->depth--;
7057                 ndr->depth--;
7058                 ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
7059                 ndr->depth++;
7060                 ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
7061                 ndr->depth--;
7062                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7063                 ndr->depth--;
7064         }
7065         ndr->depth--;
7066 }
7067
7068 static enum ndr_err_code ndr_push_samr_CreateDomAlias(struct ndr_push *ndr, int flags, const struct samr_CreateDomAlias *r)
7069 {
7070         if (flags & NDR_IN) {
7071                 if (r->in.domain_handle == NULL) {
7072                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7073                 }
7074                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7075                 if (r->in.alias_name == NULL) {
7076                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7077                 }
7078                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.alias_name));
7079                 NDR_CHECK(ndr_push_samr_AliasAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
7080         }
7081         if (flags & NDR_OUT) {
7082                 if (r->out.alias_handle == NULL) {
7083                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7084                 }
7085                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
7086                 if (r->out.rid == NULL) {
7087                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7088                 }
7089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
7090                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7091         }
7092         return NDR_ERR_SUCCESS;
7093 }
7094
7095 static enum ndr_err_code ndr_pull_samr_CreateDomAlias(struct ndr_pull *ndr, int flags, struct samr_CreateDomAlias *r)
7096 {
7097         TALLOC_CTX *_mem_save_domain_handle_0;
7098         TALLOC_CTX *_mem_save_alias_name_0;
7099         TALLOC_CTX *_mem_save_alias_handle_0;
7100         TALLOC_CTX *_mem_save_rid_0;
7101         if (flags & NDR_IN) {
7102                 ZERO_STRUCT(r->out);
7103
7104                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7105                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7106                 }
7107                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7108                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7109                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7110                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7111                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7112                         NDR_PULL_ALLOC(ndr, r->in.alias_name);
7113                 }
7114                 _mem_save_alias_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7115                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_name, LIBNDR_FLAG_REF_ALLOC);
7116                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.alias_name));
7117                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_name_0, LIBNDR_FLAG_REF_ALLOC);
7118                 NDR_CHECK(ndr_pull_samr_AliasAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
7119                 NDR_PULL_ALLOC(ndr, r->out.alias_handle);
7120                 ZERO_STRUCTP(r->out.alias_handle);
7121                 NDR_PULL_ALLOC(ndr, r->out.rid);
7122                 ZERO_STRUCTP(r->out.rid);
7123         }
7124         if (flags & NDR_OUT) {
7125                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7126                         NDR_PULL_ALLOC(ndr, r->out.alias_handle);
7127                 }
7128                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7129                 NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);
7130                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
7131                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
7132                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7133                         NDR_PULL_ALLOC(ndr, r->out.rid);
7134                 }
7135                 _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7136                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
7137                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
7138                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
7139                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7140         }
7141         return NDR_ERR_SUCCESS;
7142 }
7143
7144 _PUBLIC_ void ndr_print_samr_CreateDomAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateDomAlias *r)
7145 {
7146         ndr_print_struct(ndr, name, "samr_CreateDomAlias");
7147         ndr->depth++;
7148         if (flags & NDR_SET_VALUES) {
7149                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7150         }
7151         if (flags & NDR_IN) {
7152                 ndr_print_struct(ndr, "in", "samr_CreateDomAlias");
7153                 ndr->depth++;
7154                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7155                 ndr->depth++;
7156                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7157                 ndr->depth--;
7158                 ndr_print_ptr(ndr, "alias_name", r->in.alias_name);
7159                 ndr->depth++;
7160                 ndr_print_lsa_String(ndr, "alias_name", r->in.alias_name);
7161                 ndr->depth--;
7162                 ndr_print_samr_AliasAccessMask(ndr, "access_mask", r->in.access_mask);
7163                 ndr->depth--;
7164         }
7165         if (flags & NDR_OUT) {
7166                 ndr_print_struct(ndr, "out", "samr_CreateDomAlias");
7167                 ndr->depth++;
7168                 ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);
7169                 ndr->depth++;
7170                 ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);
7171                 ndr->depth--;
7172                 ndr_print_ptr(ndr, "rid", r->out.rid);
7173                 ndr->depth++;
7174                 ndr_print_uint32(ndr, "rid", *r->out.rid);
7175                 ndr->depth--;
7176                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7177                 ndr->depth--;
7178         }
7179         ndr->depth--;
7180 }
7181
7182 static enum ndr_err_code ndr_push_samr_EnumDomainAliases(struct ndr_push *ndr, int flags, const struct samr_EnumDomainAliases *r)
7183 {
7184         if (flags & NDR_IN) {
7185                 if (r->in.domain_handle == NULL) {
7186                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7187                 }
7188                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7189                 if (r->in.resume_handle == NULL) {
7190                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7191                 }
7192                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
7193                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
7194         }
7195         if (flags & NDR_OUT) {
7196                 if (r->out.resume_handle == NULL) {
7197                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7198                 }
7199                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
7200                 if (r->out.sam == NULL) {
7201                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7202                 }
7203                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
7204                 if (*r->out.sam) {
7205                         NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
7206                 }
7207                 if (r->out.num_entries == NULL) {
7208                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7209                 }
7210                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
7211                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7212         }
7213         return NDR_ERR_SUCCESS;
7214 }
7215
7216 static enum ndr_err_code ndr_pull_samr_EnumDomainAliases(struct ndr_pull *ndr, int flags, struct samr_EnumDomainAliases *r)
7217 {
7218         uint32_t _ptr_sam;
7219         TALLOC_CTX *_mem_save_domain_handle_0;
7220         TALLOC_CTX *_mem_save_resume_handle_0;
7221         TALLOC_CTX *_mem_save_sam_0;
7222         TALLOC_CTX *_mem_save_sam_1;
7223         TALLOC_CTX *_mem_save_num_entries_0;
7224         if (flags & NDR_IN) {
7225                 ZERO_STRUCT(r->out);
7226
7227                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7228                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7229                 }
7230                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7231                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7232                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7233                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7234                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7235                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
7236                 }
7237                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7238                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
7239                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
7240                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
7241                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
7242                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
7243                 *r->out.resume_handle = *r->in.resume_handle;
7244                 NDR_PULL_ALLOC(ndr, r->out.sam);
7245                 ZERO_STRUCTP(r->out.sam);
7246                 NDR_PULL_ALLOC(ndr, r->out.num_entries);
7247                 ZERO_STRUCTP(r->out.num_entries);
7248         }
7249         if (flags & NDR_OUT) {
7250                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7251                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
7252                 }
7253                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7254                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
7255                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
7256                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
7257                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7258                         NDR_PULL_ALLOC(ndr, r->out.sam);
7259                 }
7260                 _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
7261                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
7262                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
7263                 if (_ptr_sam) {
7264                         NDR_PULL_ALLOC(ndr, *r->out.sam);
7265                 } else {
7266                         *r->out.sam = NULL;
7267                 }
7268                 if (*r->out.sam) {
7269                         _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
7270                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
7271                         NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
7272                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
7273                 }
7274                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
7275                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7276                         NDR_PULL_ALLOC(ndr, r->out.num_entries);
7277                 }
7278                 _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
7279                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
7280                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
7281                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
7282                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7283         }
7284         return NDR_ERR_SUCCESS;
7285 }
7286
7287 _PUBLIC_ void ndr_print_samr_EnumDomainAliases(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainAliases *r)
7288 {
7289         ndr_print_struct(ndr, name, "samr_EnumDomainAliases");
7290         ndr->depth++;
7291         if (flags & NDR_SET_VALUES) {
7292                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7293         }
7294         if (flags & NDR_IN) {
7295                 ndr_print_struct(ndr, "in", "samr_EnumDomainAliases");
7296                 ndr->depth++;
7297                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7298                 ndr->depth++;
7299                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7300                 ndr->depth--;
7301                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
7302                 ndr->depth++;
7303                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
7304                 ndr->depth--;
7305                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
7306                 ndr->depth--;
7307         }
7308         if (flags & NDR_OUT) {
7309                 ndr_print_struct(ndr, "out", "samr_EnumDomainAliases");
7310                 ndr->depth++;
7311                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
7312                 ndr->depth++;
7313                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
7314                 ndr->depth--;
7315                 ndr_print_ptr(ndr, "sam", r->out.sam);
7316                 ndr->depth++;
7317                 ndr_print_ptr(ndr, "sam", *r->out.sam);
7318                 ndr->depth++;
7319                 if (*r->out.sam) {
7320                         ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
7321                 }
7322                 ndr->depth--;
7323                 ndr->depth--;
7324                 ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
7325                 ndr->depth++;
7326                 ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
7327                 ndr->depth--;
7328                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7329                 ndr->depth--;
7330         }
7331         ndr->depth--;
7332 }
7333
7334 static enum ndr_err_code ndr_push_samr_GetAliasMembership(struct ndr_push *ndr, int flags, const struct samr_GetAliasMembership *r)
7335 {
7336         if (flags & NDR_IN) {
7337                 if (r->in.domain_handle == NULL) {
7338                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7339                 }
7340                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7341                 if (r->in.sids == NULL) {
7342                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7343                 }
7344                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
7345         }
7346         if (flags & NDR_OUT) {
7347                 if (r->out.rids == NULL) {
7348                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7349                 }
7350                 NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
7351                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7352         }
7353         return NDR_ERR_SUCCESS;
7354 }
7355
7356 static enum ndr_err_code ndr_pull_samr_GetAliasMembership(struct ndr_pull *ndr, int flags, struct samr_GetAliasMembership *r)
7357 {
7358         TALLOC_CTX *_mem_save_domain_handle_0;
7359         TALLOC_CTX *_mem_save_sids_0;
7360         TALLOC_CTX *_mem_save_rids_0;
7361         if (flags & NDR_IN) {
7362                 ZERO_STRUCT(r->out);
7363
7364                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7365                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7366                 }
7367                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7368                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7369                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7370                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7371                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7372                         NDR_PULL_ALLOC(ndr, r->in.sids);
7373                 }
7374                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7375                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
7376                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
7377                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
7378                 NDR_PULL_ALLOC(ndr, r->out.rids);
7379                 ZERO_STRUCTP(r->out.rids);
7380         }
7381         if (flags & NDR_OUT) {
7382                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7383                         NDR_PULL_ALLOC(ndr, r->out.rids);
7384                 }
7385                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7386                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
7387                 NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
7388                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
7389                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7390         }
7391         return NDR_ERR_SUCCESS;
7392 }
7393
7394 _PUBLIC_ void ndr_print_samr_GetAliasMembership(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetAliasMembership *r)
7395 {
7396         ndr_print_struct(ndr, name, "samr_GetAliasMembership");
7397         ndr->depth++;
7398         if (flags & NDR_SET_VALUES) {
7399                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7400         }
7401         if (flags & NDR_IN) {
7402                 ndr_print_struct(ndr, "in", "samr_GetAliasMembership");
7403                 ndr->depth++;
7404                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7405                 ndr->depth++;
7406                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7407                 ndr->depth--;
7408                 ndr_print_ptr(ndr, "sids", r->in.sids);
7409                 ndr->depth++;
7410                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
7411                 ndr->depth--;
7412                 ndr->depth--;
7413         }
7414         if (flags & NDR_OUT) {
7415                 ndr_print_struct(ndr, "out", "samr_GetAliasMembership");
7416                 ndr->depth++;
7417                 ndr_print_ptr(ndr, "rids", r->out.rids);
7418                 ndr->depth++;
7419                 ndr_print_samr_Ids(ndr, "rids", r->out.rids);
7420                 ndr->depth--;
7421                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7422                 ndr->depth--;
7423         }
7424         ndr->depth--;
7425 }
7426
7427 _PUBLIC_ enum ndr_err_code ndr_push_samr_LookupNames(struct ndr_push *ndr, int flags, const struct samr_LookupNames *r)
7428 {
7429         uint32_t cntr_names_0;
7430         if (flags & NDR_IN) {
7431                 if (r->in.domain_handle == NULL) {
7432                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7433                 }
7434                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7435                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
7436                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 1000));
7437                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7438                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_names));
7439                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
7440                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
7441                 }
7442                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
7443                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
7444                 }
7445         }
7446         if (flags & NDR_OUT) {
7447                 if (r->out.rids == NULL) {
7448                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7449                 }
7450                 NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
7451                 if (r->out.types == NULL) {
7452                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7453                 }
7454                 NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
7455                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7456         }
7457         return NDR_ERR_SUCCESS;
7458 }
7459
7460 _PUBLIC_ enum ndr_err_code ndr_pull_samr_LookupNames(struct ndr_pull *ndr, int flags, struct samr_LookupNames *r)
7461 {
7462         uint32_t size_names_0 = 0;
7463         uint32_t length_names_0 = 0;
7464         uint32_t cntr_names_0;
7465         TALLOC_CTX *_mem_save_domain_handle_0;
7466         TALLOC_CTX *_mem_save_names_0;
7467         TALLOC_CTX *_mem_save_rids_0;
7468         TALLOC_CTX *_mem_save_types_0;
7469         if (flags & NDR_IN) {
7470                 ZERO_STRUCT(r->out);
7471
7472                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7473                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7474                 }
7475                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7476                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7477                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7478                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7479                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
7480                 if (r->in.num_names > 1000) {
7481                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7482                 }
7483                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
7484                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.names));
7485                 size_names_0 = ndr_get_array_size(ndr, &r->in.names);
7486                 length_names_0 = ndr_get_array_length(ndr, &r->in.names);
7487                 if (length_names_0 > size_names_0) {
7488                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_names_0, length_names_0);
7489                 }
7490                 NDR_PULL_ALLOC_N(ndr, r->in.names, size_names_0);
7491                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
7492                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
7493                 for (cntr_names_0 = 0; cntr_names_0 < length_names_0; cntr_names_0++) {
7494                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
7495                 }
7496                 for (cntr_names_0 = 0; cntr_names_0 < length_names_0; cntr_names_0++) {
7497                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
7498                 }
7499                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
7500                 NDR_PULL_ALLOC(ndr, r->out.rids);
7501                 ZERO_STRUCTP(r->out.rids);
7502                 NDR_PULL_ALLOC(ndr, r->out.types);
7503                 ZERO_STRUCTP(r->out.types);
7504                 if (r->in.names) {
7505                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, 1000));
7506                 }
7507                 if (r->in.names) {
7508                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.names, r->in.num_names));
7509                 }
7510         }
7511         if (flags & NDR_OUT) {
7512                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7513                         NDR_PULL_ALLOC(ndr, r->out.rids);
7514                 }
7515                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7516                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
7517                 NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
7518                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
7519                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7520                         NDR_PULL_ALLOC(ndr, r->out.types);
7521                 }
7522                 _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
7523                 NDR_PULL_SET_MEM_CTX(ndr, r->out.types, LIBNDR_FLAG_REF_ALLOC);
7524                 NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
7525                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, LIBNDR_FLAG_REF_ALLOC);
7526                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7527         }
7528         return NDR_ERR_SUCCESS;
7529 }
7530
7531 _PUBLIC_ void ndr_print_samr_LookupNames(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupNames *r)
7532 {
7533         uint32_t cntr_names_0;
7534         ndr_print_struct(ndr, name, "samr_LookupNames");
7535         ndr->depth++;
7536         if (flags & NDR_SET_VALUES) {
7537                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7538         }
7539         if (flags & NDR_IN) {
7540                 ndr_print_struct(ndr, "in", "samr_LookupNames");
7541                 ndr->depth++;
7542                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7543                 ndr->depth++;
7544                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7545                 ndr->depth--;
7546                 ndr_print_uint32(ndr, "num_names", r->in.num_names);
7547                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->in.num_names);
7548                 ndr->depth++;
7549                 for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
7550                         char *idx_0=NULL;
7551                         if (asprintf(&idx_0, "[%d]", cntr_names_0) != -1) {
7552                                 ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
7553                                 free(idx_0);
7554                         }
7555                 }
7556                 ndr->depth--;
7557                 ndr->depth--;
7558         }
7559         if (flags & NDR_OUT) {
7560                 ndr_print_struct(ndr, "out", "samr_LookupNames");
7561                 ndr->depth++;
7562                 ndr_print_ptr(ndr, "rids", r->out.rids);
7563                 ndr->depth++;
7564                 ndr_print_samr_Ids(ndr, "rids", r->out.rids);
7565                 ndr->depth--;
7566                 ndr_print_ptr(ndr, "types", r->out.types);
7567                 ndr->depth++;
7568                 ndr_print_samr_Ids(ndr, "types", r->out.types);
7569                 ndr->depth--;
7570                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7571                 ndr->depth--;
7572         }
7573         ndr->depth--;
7574 }
7575
7576 static enum ndr_err_code ndr_push_samr_LookupRids(struct ndr_push *ndr, int flags, const struct samr_LookupRids *r)
7577 {
7578         uint32_t cntr_rids_0;
7579         if (flags & NDR_IN) {
7580                 if (r->in.domain_handle == NULL) {
7581                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7582                 }
7583                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7584                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_rids));
7585                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 1000));
7586                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7587                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_rids));
7588                 for (cntr_rids_0 = 0; cntr_rids_0 < r->in.num_rids; cntr_rids_0++) {
7589                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rids[cntr_rids_0]));
7590                 }
7591         }
7592         if (flags & NDR_OUT) {
7593                 if (r->out.names == NULL) {
7594                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7595                 }
7596                 NDR_CHECK(ndr_push_lsa_Strings(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
7597                 if (r->out.types == NULL) {
7598                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7599                 }
7600                 NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
7601                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7602         }
7603         return NDR_ERR_SUCCESS;
7604 }
7605
7606 static enum ndr_err_code ndr_pull_samr_LookupRids(struct ndr_pull *ndr, int flags, struct samr_LookupRids *r)
7607 {
7608         uint32_t size_rids_0 = 0;
7609         uint32_t length_rids_0 = 0;
7610         uint32_t cntr_rids_0;
7611         TALLOC_CTX *_mem_save_domain_handle_0;
7612         TALLOC_CTX *_mem_save_rids_0;
7613         TALLOC_CTX *_mem_save_names_0;
7614         TALLOC_CTX *_mem_save_types_0;
7615         if (flags & NDR_IN) {
7616                 ZERO_STRUCT(r->out);
7617
7618                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7619                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7620                 }
7621                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7622                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7623                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7624                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7625                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_rids));
7626                 if (r->in.num_rids > 1000) {
7627                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7628                 }
7629                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.rids));
7630                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.rids));
7631                 size_rids_0 = ndr_get_array_size(ndr, &r->in.rids);
7632                 length_rids_0 = ndr_get_array_length(ndr, &r->in.rids);
7633                 if (length_rids_0 > size_rids_0) {
7634                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_rids_0, length_rids_0);
7635                 }
7636                 NDR_PULL_ALLOC_N(ndr, r->in.rids, size_rids_0);
7637                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7638                 NDR_PULL_SET_MEM_CTX(ndr, r->in.rids, 0);
7639                 for (cntr_rids_0 = 0; cntr_rids_0 < length_rids_0; cntr_rids_0++) {
7640                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rids[cntr_rids_0]));
7641                 }
7642                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
7643                 NDR_PULL_ALLOC(ndr, r->out.names);
7644                 ZERO_STRUCTP(r->out.names);
7645                 NDR_PULL_ALLOC(ndr, r->out.types);
7646                 ZERO_STRUCTP(r->out.types);
7647                 if (r->in.rids) {
7648                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.rids, 1000));
7649                 }
7650                 if (r->in.rids) {
7651                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.rids, r->in.num_rids));
7652                 }
7653         }
7654         if (flags & NDR_OUT) {
7655                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7656                         NDR_PULL_ALLOC(ndr, r->out.names);
7657                 }
7658                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
7659                 NDR_PULL_SET_MEM_CTX(ndr, r->out.names, LIBNDR_FLAG_REF_ALLOC);
7660                 NDR_CHECK(ndr_pull_lsa_Strings(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
7661                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
7662                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7663                         NDR_PULL_ALLOC(ndr, r->out.types);
7664                 }
7665                 _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
7666                 NDR_PULL_SET_MEM_CTX(ndr, r->out.types, LIBNDR_FLAG_REF_ALLOC);
7667                 NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
7668                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, LIBNDR_FLAG_REF_ALLOC);
7669                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7670         }
7671         return NDR_ERR_SUCCESS;
7672 }
7673
7674 _PUBLIC_ void ndr_print_samr_LookupRids(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupRids *r)
7675 {
7676         uint32_t cntr_rids_0;
7677         ndr_print_struct(ndr, name, "samr_LookupRids");
7678         ndr->depth++;
7679         if (flags & NDR_SET_VALUES) {
7680                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7681         }
7682         if (flags & NDR_IN) {
7683                 ndr_print_struct(ndr, "in", "samr_LookupRids");
7684                 ndr->depth++;
7685                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7686                 ndr->depth++;
7687                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7688                 ndr->depth--;
7689                 ndr_print_uint32(ndr, "num_rids", r->in.num_rids);
7690                 ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->in.num_rids);
7691                 ndr->depth++;
7692                 for (cntr_rids_0=0;cntr_rids_0<r->in.num_rids;cntr_rids_0++) {
7693                         char *idx_0=NULL;
7694                         if (asprintf(&idx_0, "[%d]", cntr_rids_0) != -1) {
7695                                 ndr_print_uint32(ndr, "rids", r->in.rids[cntr_rids_0]);
7696                                 free(idx_0);
7697                         }
7698                 }
7699                 ndr->depth--;
7700                 ndr->depth--;
7701         }
7702         if (flags & NDR_OUT) {
7703                 ndr_print_struct(ndr, "out", "samr_LookupRids");
7704                 ndr->depth++;
7705                 ndr_print_ptr(ndr, "names", r->out.names);
7706                 ndr->depth++;
7707                 ndr_print_lsa_Strings(ndr, "names", r->out.names);
7708                 ndr->depth--;
7709                 ndr_print_ptr(ndr, "types", r->out.types);
7710                 ndr->depth++;
7711                 ndr_print_samr_Ids(ndr, "types", r->out.types);
7712                 ndr->depth--;
7713                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7714                 ndr->depth--;
7715         }
7716         ndr->depth--;
7717 }
7718
7719 static enum ndr_err_code ndr_push_samr_OpenGroup(struct ndr_push *ndr, int flags, const struct samr_OpenGroup *r)
7720 {
7721         if (flags & NDR_IN) {
7722                 if (r->in.domain_handle == NULL) {
7723                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7724                 }
7725                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7726                 NDR_CHECK(ndr_push_samr_GroupAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
7727                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
7728         }
7729         if (flags & NDR_OUT) {
7730                 if (r->out.group_handle == NULL) {
7731                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7732                 }
7733                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
7734                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7735         }
7736         return NDR_ERR_SUCCESS;
7737 }
7738
7739 static enum ndr_err_code ndr_pull_samr_OpenGroup(struct ndr_pull *ndr, int flags, struct samr_OpenGroup *r)
7740 {
7741         TALLOC_CTX *_mem_save_domain_handle_0;
7742         TALLOC_CTX *_mem_save_group_handle_0;
7743         if (flags & NDR_IN) {
7744                 ZERO_STRUCT(r->out);
7745
7746                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7747                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7748                 }
7749                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7750                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7751                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7752                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7753                 NDR_CHECK(ndr_pull_samr_GroupAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
7754                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
7755                 NDR_PULL_ALLOC(ndr, r->out.group_handle);
7756                 ZERO_STRUCTP(r->out.group_handle);
7757         }
7758         if (flags & NDR_OUT) {
7759                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7760                         NDR_PULL_ALLOC(ndr, r->out.group_handle);
7761                 }
7762                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7763                 NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);
7764                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
7765                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7766                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7767         }
7768         return NDR_ERR_SUCCESS;
7769 }
7770
7771 _PUBLIC_ void ndr_print_samr_OpenGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenGroup *r)
7772 {
7773         ndr_print_struct(ndr, name, "samr_OpenGroup");
7774         ndr->depth++;
7775         if (flags & NDR_SET_VALUES) {
7776                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7777         }
7778         if (flags & NDR_IN) {
7779                 ndr_print_struct(ndr, "in", "samr_OpenGroup");
7780                 ndr->depth++;
7781                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7782                 ndr->depth++;
7783                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7784                 ndr->depth--;
7785                 ndr_print_samr_GroupAccessMask(ndr, "access_mask", r->in.access_mask);
7786                 ndr_print_uint32(ndr, "rid", r->in.rid);
7787                 ndr->depth--;
7788         }
7789         if (flags & NDR_OUT) {
7790                 ndr_print_struct(ndr, "out", "samr_OpenGroup");
7791                 ndr->depth++;
7792                 ndr_print_ptr(ndr, "group_handle", r->out.group_handle);
7793                 ndr->depth++;
7794                 ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);
7795                 ndr->depth--;
7796                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7797                 ndr->depth--;
7798         }
7799         ndr->depth--;
7800 }
7801
7802 static enum ndr_err_code ndr_push_samr_QueryGroupInfo(struct ndr_push *ndr, int flags, const struct samr_QueryGroupInfo *r)
7803 {
7804         if (flags & NDR_IN) {
7805                 if (r->in.group_handle == NULL) {
7806                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7807                 }
7808                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7809                 NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, r->in.level));
7810         }
7811         if (flags & NDR_OUT) {
7812                 if (r->out.info == NULL) {
7813                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7814                 }
7815                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
7816                 if (*r->out.info) {
7817                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
7818                         NDR_CHECK(ndr_push_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
7819                 }
7820                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7821         }
7822         return NDR_ERR_SUCCESS;
7823 }
7824
7825 static enum ndr_err_code ndr_pull_samr_QueryGroupInfo(struct ndr_pull *ndr, int flags, struct samr_QueryGroupInfo *r)
7826 {
7827         uint32_t _ptr_info;
7828         TALLOC_CTX *_mem_save_group_handle_0;
7829         TALLOC_CTX *_mem_save_info_0;
7830         TALLOC_CTX *_mem_save_info_1;
7831         if (flags & NDR_IN) {
7832                 ZERO_STRUCT(r->out);
7833
7834                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7835                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
7836                 }
7837                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7838                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
7839                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7840                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7841                 NDR_CHECK(ndr_pull_samr_GroupInfoEnum(ndr, NDR_SCALARS, &r->in.level));
7842                 NDR_PULL_ALLOC(ndr, r->out.info);
7843                 ZERO_STRUCTP(r->out.info);
7844         }
7845         if (flags & NDR_OUT) {
7846                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7847                         NDR_PULL_ALLOC(ndr, r->out.info);
7848                 }
7849                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7850                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
7851                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
7852                 if (_ptr_info) {
7853                         NDR_PULL_ALLOC(ndr, *r->out.info);
7854                 } else {
7855                         *r->out.info = NULL;
7856                 }
7857                 if (*r->out.info) {
7858                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
7859                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
7860                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
7861                         NDR_CHECK(ndr_pull_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
7862                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
7863                 }
7864                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7865                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7866         }
7867         return NDR_ERR_SUCCESS;
7868 }
7869
7870 _PUBLIC_ void ndr_print_samr_QueryGroupInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryGroupInfo *r)
7871 {
7872         ndr_print_struct(ndr, name, "samr_QueryGroupInfo");
7873         ndr->depth++;
7874         if (flags & NDR_SET_VALUES) {
7875                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7876         }
7877         if (flags & NDR_IN) {
7878                 ndr_print_struct(ndr, "in", "samr_QueryGroupInfo");
7879                 ndr->depth++;
7880                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
7881                 ndr->depth++;
7882                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
7883                 ndr->depth--;
7884                 ndr_print_samr_GroupInfoEnum(ndr, "level", r->in.level);
7885                 ndr->depth--;
7886         }
7887         if (flags & NDR_OUT) {
7888                 ndr_print_struct(ndr, "out", "samr_QueryGroupInfo");
7889                 ndr->depth++;
7890                 ndr_print_ptr(ndr, "info", r->out.info);
7891                 ndr->depth++;
7892                 ndr_print_ptr(ndr, "info", *r->out.info);
7893                 ndr->depth++;
7894                 if (*r->out.info) {
7895                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
7896                         ndr_print_samr_GroupInfo(ndr, "info", *r->out.info);
7897                 }
7898                 ndr->depth--;
7899                 ndr->depth--;
7900                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7901                 ndr->depth--;
7902         }
7903         ndr->depth--;
7904 }
7905
7906 static enum ndr_err_code ndr_push_samr_SetGroupInfo(struct ndr_push *ndr, int flags, const struct samr_SetGroupInfo *r)
7907 {
7908         if (flags & NDR_IN) {
7909                 if (r->in.group_handle == NULL) {
7910                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7911                 }
7912                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7913                 NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, r->in.level));
7914                 if (r->in.info == NULL) {
7915                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7916                 }
7917                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
7918                 NDR_CHECK(ndr_push_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
7919         }
7920         if (flags & NDR_OUT) {
7921                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7922         }
7923         return NDR_ERR_SUCCESS;
7924 }
7925
7926 static enum ndr_err_code ndr_pull_samr_SetGroupInfo(struct ndr_pull *ndr, int flags, struct samr_SetGroupInfo *r)
7927 {
7928         TALLOC_CTX *_mem_save_group_handle_0;
7929         TALLOC_CTX *_mem_save_info_0;
7930         if (flags & NDR_IN) {
7931                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7932                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
7933                 }
7934                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7935                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
7936                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7937                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7938                 NDR_CHECK(ndr_pull_samr_GroupInfoEnum(ndr, NDR_SCALARS, &r->in.level));
7939                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7940                         NDR_PULL_ALLOC(ndr, r->in.info);
7941                 }
7942                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7943                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
7944                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
7945                 NDR_CHECK(ndr_pull_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
7946                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7947         }
7948         if (flags & NDR_OUT) {
7949                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7950         }
7951         return NDR_ERR_SUCCESS;
7952 }
7953
7954 _PUBLIC_ void ndr_print_samr_SetGroupInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetGroupInfo *r)
7955 {
7956         ndr_print_struct(ndr, name, "samr_SetGroupInfo");
7957         ndr->depth++;
7958         if (flags & NDR_SET_VALUES) {
7959                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7960         }
7961         if (flags & NDR_IN) {
7962                 ndr_print_struct(ndr, "in", "samr_SetGroupInfo");
7963                 ndr->depth++;
7964                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
7965                 ndr->depth++;
7966                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
7967                 ndr->depth--;
7968                 ndr_print_samr_GroupInfoEnum(ndr, "level", r->in.level);
7969                 ndr_print_ptr(ndr, "info", r->in.info);
7970                 ndr->depth++;
7971                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
7972                 ndr_print_samr_GroupInfo(ndr, "info", r->in.info);
7973                 ndr->depth--;
7974                 ndr->depth--;
7975         }
7976         if (flags & NDR_OUT) {
7977                 ndr_print_struct(ndr, "out", "samr_SetGroupInfo");
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_AddGroupMember(struct ndr_push *ndr, int flags, const struct samr_AddGroupMember *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.rid));
7993                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
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_AddGroupMember(struct ndr_pull *ndr, int flags, struct samr_AddGroupMember *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.rid));
8013                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
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_AddGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddGroupMember *r)
8022 {
8023         ndr_print_struct(ndr, name, "samr_AddGroupMember");
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_AddGroupMember");
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, "rid", r->in.rid);
8036                 ndr_print_uint32(ndr, "flags", r->in.flags);
8037                 ndr->depth--;
8038         }
8039         if (flags & NDR_OUT) {
8040                 ndr_print_struct(ndr, "out", "samr_AddGroupMember");
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_DeleteDomainGroup(struct ndr_push *ndr, int flags, const struct samr_DeleteDomainGroup *r)
8049 {
8050         if (flags & NDR_IN) {
8051                 if (r->in.group_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.group_handle));
8055         }
8056         if (flags & NDR_OUT) {
8057                 if (r->out.group_handle == NULL) {
8058                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8059                 }
8060                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
8061                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8062         }
8063         return NDR_ERR_SUCCESS;
8064 }
8065
8066 static enum ndr_err_code ndr_pull_samr_DeleteDomainGroup(struct ndr_pull *ndr, int flags, struct samr_DeleteDomainGroup *r)
8067 {
8068         TALLOC_CTX *_mem_save_group_handle_0;
8069         if (flags & NDR_IN) {
8070                 ZERO_STRUCT(r->out);
8071
8072                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8073                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
8074                 }
8075                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8076                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
8077                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8078                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
8079                 NDR_PULL_ALLOC(ndr, r->out.group_handle);
8080                 *r->out.group_handle = *r->in.group_handle;
8081         }
8082         if (flags & NDR_OUT) {
8083                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8084                         NDR_PULL_ALLOC(ndr, r->out.group_handle);
8085                 }
8086                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8087                 NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);
8088                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
8089                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
8090                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8091         }
8092         return NDR_ERR_SUCCESS;
8093 }
8094
8095 _PUBLIC_ void ndr_print_samr_DeleteDomainGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteDomainGroup *r)
8096 {
8097         ndr_print_struct(ndr, name, "samr_DeleteDomainGroup");
8098         ndr->depth++;
8099         if (flags & NDR_SET_VALUES) {
8100                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8101         }
8102         if (flags & NDR_IN) {
8103                 ndr_print_struct(ndr, "in", "samr_DeleteDomainGroup");
8104                 ndr->depth++;
8105                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
8106                 ndr->depth++;
8107                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
8108                 ndr->depth--;
8109                 ndr->depth--;
8110         }
8111         if (flags & NDR_OUT) {
8112                 ndr_print_struct(ndr, "out", "samr_DeleteDomainGroup");
8113                 ndr->depth++;
8114                 ndr_print_ptr(ndr, "group_handle", r->out.group_handle);
8115                 ndr->depth++;
8116                 ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);
8117                 ndr->depth--;
8118                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8119                 ndr->depth--;
8120         }
8121         ndr->depth--;
8122 }
8123
8124 static enum ndr_err_code ndr_push_samr_DeleteGroupMember(struct ndr_push *ndr, int flags, const struct samr_DeleteGroupMember *r)
8125 {
8126         if (flags & NDR_IN) {
8127                 if (r->in.group_handle == NULL) {
8128                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8129                 }
8130                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8131                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
8132         }
8133         if (flags & NDR_OUT) {
8134                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8135         }
8136         return NDR_ERR_SUCCESS;
8137 }
8138
8139 static enum ndr_err_code ndr_pull_samr_DeleteGroupMember(struct ndr_pull *ndr, int flags, struct samr_DeleteGroupMember *r)
8140 {
8141         TALLOC_CTX *_mem_save_group_handle_0;
8142         if (flags & NDR_IN) {
8143                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8144                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
8145                 }
8146                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8147                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
8148                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8149                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
8150                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
8151         }
8152         if (flags & NDR_OUT) {
8153                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8154         }
8155         return NDR_ERR_SUCCESS;
8156 }
8157
8158 _PUBLIC_ void ndr_print_samr_DeleteGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteGroupMember *r)
8159 {
8160         ndr_print_struct(ndr, name, "samr_DeleteGroupMember");
8161         ndr->depth++;
8162         if (flags & NDR_SET_VALUES) {
8163                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8164         }
8165         if (flags & NDR_IN) {
8166                 ndr_print_struct(ndr, "in", "samr_DeleteGroupMember");
8167                 ndr->depth++;
8168                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
8169                 ndr->depth++;
8170                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
8171                 ndr->depth--;
8172                 ndr_print_uint32(ndr, "rid", r->in.rid);
8173                 ndr->depth--;
8174         }
8175         if (flags & NDR_OUT) {
8176                 ndr_print_struct(ndr, "out", "samr_DeleteGroupMember");
8177                 ndr->depth++;
8178                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8179                 ndr->depth--;
8180         }
8181         ndr->depth--;
8182 }
8183
8184 static enum ndr_err_code ndr_push_samr_QueryGroupMember(struct ndr_push *ndr, int flags, const struct samr_QueryGroupMember *r)
8185 {
8186         if (flags & NDR_IN) {
8187                 if (r->in.group_handle == NULL) {
8188                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8189                 }
8190                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8191         }
8192         if (flags & NDR_OUT) {
8193                 if (r->out.rids == NULL) {
8194                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8195                 }
8196                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rids));
8197                 if (*r->out.rids) {
8198                         NDR_CHECK(ndr_push_samr_RidTypeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
8199                 }
8200                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8201         }
8202         return NDR_ERR_SUCCESS;
8203 }
8204
8205 static enum ndr_err_code ndr_pull_samr_QueryGroupMember(struct ndr_pull *ndr, int flags, struct samr_QueryGroupMember *r)
8206 {
8207         uint32_t _ptr_rids;
8208         TALLOC_CTX *_mem_save_group_handle_0;
8209         TALLOC_CTX *_mem_save_rids_0;
8210         TALLOC_CTX *_mem_save_rids_1;
8211         if (flags & NDR_IN) {
8212                 ZERO_STRUCT(r->out);
8213
8214                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8215                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
8216                 }
8217                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8218                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
8219                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8220                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
8221                 NDR_PULL_ALLOC(ndr, r->out.rids);
8222                 ZERO_STRUCTP(r->out.rids);
8223         }
8224         if (flags & NDR_OUT) {
8225                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8226                         NDR_PULL_ALLOC(ndr, r->out.rids);
8227                 }
8228                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
8229                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
8230                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
8231                 if (_ptr_rids) {
8232                         NDR_PULL_ALLOC(ndr, *r->out.rids);
8233                 } else {
8234                         *r->out.rids = NULL;
8235                 }
8236                 if (*r->out.rids) {
8237                         _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
8238                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.rids, 0);
8239                         NDR_CHECK(ndr_pull_samr_RidTypeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
8240                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
8241                 }
8242                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
8243                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8244         }
8245         return NDR_ERR_SUCCESS;
8246 }
8247
8248 _PUBLIC_ void ndr_print_samr_QueryGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryGroupMember *r)
8249 {
8250         ndr_print_struct(ndr, name, "samr_QueryGroupMember");
8251         ndr->depth++;
8252         if (flags & NDR_SET_VALUES) {
8253                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8254         }
8255         if (flags & NDR_IN) {
8256                 ndr_print_struct(ndr, "in", "samr_QueryGroupMember");
8257                 ndr->depth++;
8258                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
8259                 ndr->depth++;
8260                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
8261                 ndr->depth--;
8262                 ndr->depth--;
8263         }
8264         if (flags & NDR_OUT) {
8265                 ndr_print_struct(ndr, "out", "samr_QueryGroupMember");
8266                 ndr->depth++;
8267                 ndr_print_ptr(ndr, "rids", r->out.rids);
8268                 ndr->depth++;
8269                 ndr_print_ptr(ndr, "rids", *r->out.rids);
8270                 ndr->depth++;
8271                 if (*r->out.rids) {
8272                         ndr_print_samr_RidTypeArray(ndr, "rids", *r->out.rids);
8273                 }
8274                 ndr->depth--;
8275                 ndr->depth--;
8276                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8277                 ndr->depth--;
8278         }
8279         ndr->depth--;
8280 }
8281
8282 static enum ndr_err_code ndr_push_samr_SetMemberAttributesOfGroup(struct ndr_push *ndr, int flags, const struct samr_SetMemberAttributesOfGroup *r)
8283 {
8284         if (flags & NDR_IN) {
8285                 if (r->in.group_handle == NULL) {
8286                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8287                 }
8288                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8289                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
8290                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
8291         }
8292         if (flags & NDR_OUT) {
8293                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8294         }
8295         return NDR_ERR_SUCCESS;
8296 }
8297
8298 static enum ndr_err_code ndr_pull_samr_SetMemberAttributesOfGroup(struct ndr_pull *ndr, int flags, struct samr_SetMemberAttributesOfGroup *r)
8299 {
8300         TALLOC_CTX *_mem_save_group_handle_0;
8301         if (flags & NDR_IN) {
8302                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8303                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
8304                 }
8305                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8306                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
8307                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8308                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
8309                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
8310                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
8311         }
8312         if (flags & NDR_OUT) {
8313                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8314         }
8315         return NDR_ERR_SUCCESS;
8316 }
8317
8318 _PUBLIC_ void ndr_print_samr_SetMemberAttributesOfGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetMemberAttributesOfGroup *r)
8319 {
8320         ndr_print_struct(ndr, name, "samr_SetMemberAttributesOfGroup");
8321         ndr->depth++;
8322         if (flags & NDR_SET_VALUES) {
8323                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8324         }
8325         if (flags & NDR_IN) {
8326                 ndr_print_struct(ndr, "in", "samr_SetMemberAttributesOfGroup");
8327                 ndr->depth++;
8328                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
8329                 ndr->depth++;
8330                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
8331                 ndr->depth--;
8332                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
8333                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
8334                 ndr->depth--;
8335         }
8336         if (flags & NDR_OUT) {
8337                 ndr_print_struct(ndr, "out", "samr_SetMemberAttributesOfGroup");
8338                 ndr->depth++;
8339                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8340                 ndr->depth--;
8341         }
8342         ndr->depth--;
8343 }
8344
8345 static enum ndr_err_code ndr_push_samr_OpenAlias(struct ndr_push *ndr, int flags, const struct samr_OpenAlias *r)
8346 {
8347         if (flags & NDR_IN) {
8348                 if (r->in.domain_handle == NULL) {
8349                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8350                 }
8351                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
8352                 NDR_CHECK(ndr_push_samr_AliasAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
8353                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
8354         }
8355         if (flags & NDR_OUT) {
8356                 if (r->out.alias_handle == NULL) {
8357                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8358                 }
8359                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
8360                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8361         }
8362         return NDR_ERR_SUCCESS;
8363 }
8364
8365 static enum ndr_err_code ndr_pull_samr_OpenAlias(struct ndr_pull *ndr, int flags, struct samr_OpenAlias *r)
8366 {
8367         TALLOC_CTX *_mem_save_domain_handle_0;
8368         TALLOC_CTX *_mem_save_alias_handle_0;
8369         if (flags & NDR_IN) {
8370                 ZERO_STRUCT(r->out);
8371
8372                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8373                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
8374                 }
8375                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8376                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
8377                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
8378                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
8379                 NDR_CHECK(ndr_pull_samr_AliasAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
8380                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
8381                 NDR_PULL_ALLOC(ndr, r->out.alias_handle);
8382                 ZERO_STRUCTP(r->out.alias_handle);
8383         }
8384         if (flags & NDR_OUT) {
8385                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8386                         NDR_PULL_ALLOC(ndr, r->out.alias_handle);
8387                 }
8388                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8389                 NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8390                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
8391                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8392                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8393         }
8394         return NDR_ERR_SUCCESS;
8395 }
8396
8397 _PUBLIC_ void ndr_print_samr_OpenAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenAlias *r)
8398 {
8399         ndr_print_struct(ndr, name, "samr_OpenAlias");
8400         ndr->depth++;
8401         if (flags & NDR_SET_VALUES) {
8402                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8403         }
8404         if (flags & NDR_IN) {
8405                 ndr_print_struct(ndr, "in", "samr_OpenAlias");
8406                 ndr->depth++;
8407                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
8408                 ndr->depth++;
8409                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
8410                 ndr->depth--;
8411                 ndr_print_samr_AliasAccessMask(ndr, "access_mask", r->in.access_mask);
8412                 ndr_print_uint32(ndr, "rid", r->in.rid);
8413                 ndr->depth--;
8414         }
8415         if (flags & NDR_OUT) {
8416                 ndr_print_struct(ndr, "out", "samr_OpenAlias");
8417                 ndr->depth++;
8418                 ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);
8419                 ndr->depth++;
8420                 ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);
8421                 ndr->depth--;
8422                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8423                 ndr->depth--;
8424         }
8425         ndr->depth--;
8426 }
8427
8428 static enum ndr_err_code ndr_push_samr_QueryAliasInfo(struct ndr_push *ndr, int flags, const struct samr_QueryAliasInfo *r)
8429 {
8430         if (flags & NDR_IN) {
8431                 if (r->in.alias_handle == NULL) {
8432                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8433                 }
8434                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8435                 NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, r->in.level));
8436         }
8437         if (flags & NDR_OUT) {
8438                 if (r->out.info == NULL) {
8439                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8440                 }
8441                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
8442                 if (*r->out.info) {
8443                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
8444                         NDR_CHECK(ndr_push_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8445                 }
8446                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8447         }
8448         return NDR_ERR_SUCCESS;
8449 }
8450
8451 static enum ndr_err_code ndr_pull_samr_QueryAliasInfo(struct ndr_pull *ndr, int flags, struct samr_QueryAliasInfo *r)
8452 {
8453         uint32_t _ptr_info;
8454         TALLOC_CTX *_mem_save_alias_handle_0;
8455         TALLOC_CTX *_mem_save_info_0;
8456         TALLOC_CTX *_mem_save_info_1;
8457         if (flags & NDR_IN) {
8458                 ZERO_STRUCT(r->out);
8459
8460                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8461                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8462                 }
8463                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8464                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8465                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8466                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8467                 NDR_CHECK(ndr_pull_samr_AliasInfoEnum(ndr, NDR_SCALARS, &r->in.level));
8468                 NDR_PULL_ALLOC(ndr, r->out.info);
8469                 ZERO_STRUCTP(r->out.info);
8470         }
8471         if (flags & NDR_OUT) {
8472                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8473                         NDR_PULL_ALLOC(ndr, r->out.info);
8474                 }
8475                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8476                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
8477                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8478                 if (_ptr_info) {
8479                         NDR_PULL_ALLOC(ndr, *r->out.info);
8480                 } else {
8481                         *r->out.info = NULL;
8482                 }
8483                 if (*r->out.info) {
8484                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
8485                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
8486                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
8487                         NDR_CHECK(ndr_pull_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8488                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
8489                 }
8490                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
8491                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8492         }
8493         return NDR_ERR_SUCCESS;
8494 }
8495
8496 _PUBLIC_ void ndr_print_samr_QueryAliasInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryAliasInfo *r)
8497 {
8498         ndr_print_struct(ndr, name, "samr_QueryAliasInfo");
8499         ndr->depth++;
8500         if (flags & NDR_SET_VALUES) {
8501                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8502         }
8503         if (flags & NDR_IN) {
8504                 ndr_print_struct(ndr, "in", "samr_QueryAliasInfo");
8505                 ndr->depth++;
8506                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8507                 ndr->depth++;
8508                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8509                 ndr->depth--;
8510                 ndr_print_samr_AliasInfoEnum(ndr, "level", r->in.level);
8511                 ndr->depth--;
8512         }
8513         if (flags & NDR_OUT) {
8514                 ndr_print_struct(ndr, "out", "samr_QueryAliasInfo");
8515                 ndr->depth++;
8516                 ndr_print_ptr(ndr, "info", r->out.info);
8517                 ndr->depth++;
8518                 ndr_print_ptr(ndr, "info", *r->out.info);
8519                 ndr->depth++;
8520                 if (*r->out.info) {
8521                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
8522                         ndr_print_samr_AliasInfo(ndr, "info", *r->out.info);
8523                 }
8524                 ndr->depth--;
8525                 ndr->depth--;
8526                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8527                 ndr->depth--;
8528         }
8529         ndr->depth--;
8530 }
8531
8532 static enum ndr_err_code ndr_push_samr_SetAliasInfo(struct ndr_push *ndr, int flags, const struct samr_SetAliasInfo *r)
8533 {
8534         if (flags & NDR_IN) {
8535                 if (r->in.alias_handle == NULL) {
8536                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8537                 }
8538                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8539                 NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, r->in.level));
8540                 if (r->in.info == NULL) {
8541                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8542                 }
8543                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
8544                 NDR_CHECK(ndr_push_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8545         }
8546         if (flags & NDR_OUT) {
8547                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8548         }
8549         return NDR_ERR_SUCCESS;
8550 }
8551
8552 static enum ndr_err_code ndr_pull_samr_SetAliasInfo(struct ndr_pull *ndr, int flags, struct samr_SetAliasInfo *r)
8553 {
8554         TALLOC_CTX *_mem_save_alias_handle_0;
8555         TALLOC_CTX *_mem_save_info_0;
8556         if (flags & NDR_IN) {
8557                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8558                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8559                 }
8560                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8561                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8562                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8563                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8564                 NDR_CHECK(ndr_pull_samr_AliasInfoEnum(ndr, NDR_SCALARS, &r->in.level));
8565                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8566                         NDR_PULL_ALLOC(ndr, r->in.info);
8567                 }
8568                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8569                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
8570                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
8571                 NDR_CHECK(ndr_pull_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8572                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
8573         }
8574         if (flags & NDR_OUT) {
8575                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8576         }
8577         return NDR_ERR_SUCCESS;
8578 }
8579
8580 _PUBLIC_ void ndr_print_samr_SetAliasInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetAliasInfo *r)
8581 {
8582         ndr_print_struct(ndr, name, "samr_SetAliasInfo");
8583         ndr->depth++;
8584         if (flags & NDR_SET_VALUES) {
8585                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8586         }
8587         if (flags & NDR_IN) {
8588                 ndr_print_struct(ndr, "in", "samr_SetAliasInfo");
8589                 ndr->depth++;
8590                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8591                 ndr->depth++;
8592                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8593                 ndr->depth--;
8594                 ndr_print_samr_AliasInfoEnum(ndr, "level", r->in.level);
8595                 ndr_print_ptr(ndr, "info", r->in.info);
8596                 ndr->depth++;
8597                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
8598                 ndr_print_samr_AliasInfo(ndr, "info", r->in.info);
8599                 ndr->depth--;
8600                 ndr->depth--;
8601         }
8602         if (flags & NDR_OUT) {
8603                 ndr_print_struct(ndr, "out", "samr_SetAliasInfo");
8604                 ndr->depth++;
8605                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8606                 ndr->depth--;
8607         }
8608         ndr->depth--;
8609 }
8610
8611 static enum ndr_err_code ndr_push_samr_DeleteDomAlias(struct ndr_push *ndr, int flags, const struct samr_DeleteDomAlias *r)
8612 {
8613         if (flags & NDR_IN) {
8614                 if (r->in.alias_handle == NULL) {
8615                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8616                 }
8617                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8618         }
8619         if (flags & NDR_OUT) {
8620                 if (r->out.alias_handle == NULL) {
8621                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8622                 }
8623                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
8624                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8625         }
8626         return NDR_ERR_SUCCESS;
8627 }
8628
8629 static enum ndr_err_code ndr_pull_samr_DeleteDomAlias(struct ndr_pull *ndr, int flags, struct samr_DeleteDomAlias *r)
8630 {
8631         TALLOC_CTX *_mem_save_alias_handle_0;
8632         if (flags & NDR_IN) {
8633                 ZERO_STRUCT(r->out);
8634
8635                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8636                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8637                 }
8638                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8639                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8640                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8641                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8642                 NDR_PULL_ALLOC(ndr, r->out.alias_handle);
8643                 *r->out.alias_handle = *r->in.alias_handle;
8644         }
8645         if (flags & NDR_OUT) {
8646                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8647                         NDR_PULL_ALLOC(ndr, r->out.alias_handle);
8648                 }
8649                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8650                 NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8651                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
8652                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8653                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8654         }
8655         return NDR_ERR_SUCCESS;
8656 }
8657
8658 _PUBLIC_ void ndr_print_samr_DeleteDomAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteDomAlias *r)
8659 {
8660         ndr_print_struct(ndr, name, "samr_DeleteDomAlias");
8661         ndr->depth++;
8662         if (flags & NDR_SET_VALUES) {
8663                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8664         }
8665         if (flags & NDR_IN) {
8666                 ndr_print_struct(ndr, "in", "samr_DeleteDomAlias");
8667                 ndr->depth++;
8668                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8669                 ndr->depth++;
8670                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8671                 ndr->depth--;
8672                 ndr->depth--;
8673         }
8674         if (flags & NDR_OUT) {
8675                 ndr_print_struct(ndr, "out", "samr_DeleteDomAlias");
8676                 ndr->depth++;
8677                 ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);
8678                 ndr->depth++;
8679                 ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);
8680                 ndr->depth--;
8681                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8682                 ndr->depth--;
8683         }
8684         ndr->depth--;
8685 }
8686
8687 static enum ndr_err_code ndr_push_samr_AddAliasMember(struct ndr_push *ndr, int flags, const struct samr_AddAliasMember *r)
8688 {
8689         if (flags & NDR_IN) {
8690                 if (r->in.alias_handle == NULL) {
8691                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8692                 }
8693                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8694                 if (r->in.sid == NULL) {
8695                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8696                 }
8697                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8698         }
8699         if (flags & NDR_OUT) {
8700                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8701         }
8702         return NDR_ERR_SUCCESS;
8703 }
8704
8705 static enum ndr_err_code ndr_pull_samr_AddAliasMember(struct ndr_pull *ndr, int flags, struct samr_AddAliasMember *r)
8706 {
8707         TALLOC_CTX *_mem_save_alias_handle_0;
8708         TALLOC_CTX *_mem_save_sid_0;
8709         if (flags & NDR_IN) {
8710                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8711                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8712                 }
8713                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8714                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8715                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8716                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8717                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8718                         NDR_PULL_ALLOC(ndr, r->in.sid);
8719                 }
8720                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
8721                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
8722                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8723                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
8724         }
8725         if (flags & NDR_OUT) {
8726                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8727         }
8728         return NDR_ERR_SUCCESS;
8729 }
8730
8731 _PUBLIC_ void ndr_print_samr_AddAliasMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddAliasMember *r)
8732 {
8733         ndr_print_struct(ndr, name, "samr_AddAliasMember");
8734         ndr->depth++;
8735         if (flags & NDR_SET_VALUES) {
8736                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8737         }
8738         if (flags & NDR_IN) {
8739                 ndr_print_struct(ndr, "in", "samr_AddAliasMember");
8740                 ndr->depth++;
8741                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8742                 ndr->depth++;
8743                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8744                 ndr->depth--;
8745                 ndr_print_ptr(ndr, "sid", r->in.sid);
8746                 ndr->depth++;
8747                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
8748                 ndr->depth--;
8749                 ndr->depth--;
8750         }
8751         if (flags & NDR_OUT) {
8752                 ndr_print_struct(ndr, "out", "samr_AddAliasMember");
8753                 ndr->depth++;
8754                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8755                 ndr->depth--;
8756         }
8757         ndr->depth--;
8758 }
8759
8760 static enum ndr_err_code ndr_push_samr_DeleteAliasMember(struct ndr_push *ndr, int flags, const struct samr_DeleteAliasMember *r)
8761 {
8762         if (flags & NDR_IN) {
8763                 if (r->in.alias_handle == NULL) {
8764                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8765                 }
8766                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8767                 if (r->in.sid == NULL) {
8768                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8769                 }
8770                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8771         }
8772         if (flags & NDR_OUT) {
8773                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8774         }
8775         return NDR_ERR_SUCCESS;
8776 }
8777
8778 static enum ndr_err_code ndr_pull_samr_DeleteAliasMember(struct ndr_pull *ndr, int flags, struct samr_DeleteAliasMember *r)
8779 {
8780         TALLOC_CTX *_mem_save_alias_handle_0;
8781         TALLOC_CTX *_mem_save_sid_0;
8782         if (flags & NDR_IN) {
8783                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8784                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8785                 }
8786                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8787                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8788                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8789                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8790                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8791                         NDR_PULL_ALLOC(ndr, r->in.sid);
8792                 }
8793                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
8794                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
8795                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8796                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
8797         }
8798         if (flags & NDR_OUT) {
8799                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8800         }
8801         return NDR_ERR_SUCCESS;
8802 }
8803
8804 _PUBLIC_ void ndr_print_samr_DeleteAliasMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteAliasMember *r)
8805 {
8806         ndr_print_struct(ndr, name, "samr_DeleteAliasMember");
8807         ndr->depth++;
8808         if (flags & NDR_SET_VALUES) {
8809                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8810         }
8811         if (flags & NDR_IN) {
8812                 ndr_print_struct(ndr, "in", "samr_DeleteAliasMember");
8813                 ndr->depth++;
8814                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8815                 ndr->depth++;
8816                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8817                 ndr->depth--;
8818                 ndr_print_ptr(ndr, "sid", r->in.sid);
8819                 ndr->depth++;
8820                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
8821                 ndr->depth--;
8822                 ndr->depth--;
8823         }
8824         if (flags & NDR_OUT) {
8825                 ndr_print_struct(ndr, "out", "samr_DeleteAliasMember");
8826                 ndr->depth++;
8827                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8828                 ndr->depth--;
8829         }
8830         ndr->depth--;
8831 }
8832
8833 static enum ndr_err_code ndr_push_samr_GetMembersInAlias(struct ndr_push *ndr, int flags, const struct samr_GetMembersInAlias *r)
8834 {
8835         if (flags & NDR_IN) {
8836                 if (r->in.alias_handle == NULL) {
8837                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8838                 }
8839                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8840         }
8841         if (flags & NDR_OUT) {
8842                 if (r->out.sids == NULL) {
8843                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8844                 }
8845                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
8846                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8847         }
8848         return NDR_ERR_SUCCESS;
8849 }
8850
8851 static enum ndr_err_code ndr_pull_samr_GetMembersInAlias(struct ndr_pull *ndr, int flags, struct samr_GetMembersInAlias *r)
8852 {
8853         TALLOC_CTX *_mem_save_alias_handle_0;
8854         TALLOC_CTX *_mem_save_sids_0;
8855         if (flags & NDR_IN) {
8856                 ZERO_STRUCT(r->out);
8857
8858                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8859                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8860                 }
8861                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8862                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8863                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8864                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8865                 NDR_PULL_ALLOC(ndr, r->out.sids);
8866                 ZERO_STRUCTP(r->out.sids);
8867         }
8868         if (flags & NDR_OUT) {
8869                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8870                         NDR_PULL_ALLOC(ndr, r->out.sids);
8871                 }
8872                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
8873                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
8874                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
8875                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
8876                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8877         }
8878         return NDR_ERR_SUCCESS;
8879 }
8880
8881 _PUBLIC_ void ndr_print_samr_GetMembersInAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetMembersInAlias *r)
8882 {
8883         ndr_print_struct(ndr, name, "samr_GetMembersInAlias");
8884         ndr->depth++;
8885         if (flags & NDR_SET_VALUES) {
8886                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8887         }
8888         if (flags & NDR_IN) {
8889                 ndr_print_struct(ndr, "in", "samr_GetMembersInAlias");
8890                 ndr->depth++;
8891                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8892                 ndr->depth++;
8893                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8894                 ndr->depth--;
8895                 ndr->depth--;
8896         }
8897         if (flags & NDR_OUT) {
8898                 ndr_print_struct(ndr, "out", "samr_GetMembersInAlias");
8899                 ndr->depth++;
8900                 ndr_print_ptr(ndr, "sids", r->out.sids);
8901                 ndr->depth++;
8902                 ndr_print_lsa_SidArray(ndr, "sids", r->out.sids);
8903                 ndr->depth--;
8904                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8905                 ndr->depth--;
8906         }
8907         ndr->depth--;
8908 }
8909
8910 _PUBLIC_ enum ndr_err_code ndr_push_samr_OpenUser(struct ndr_push *ndr, int flags, const struct samr_OpenUser *r)
8911 {
8912         if (flags & NDR_IN) {
8913                 if (r->in.domain_handle == NULL) {
8914                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8915                 }
8916                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
8917                 NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
8918                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
8919         }
8920         if (flags & NDR_OUT) {
8921                 if (r->out.user_handle == NULL) {
8922                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8923                 }
8924                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
8925                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8926         }
8927         return NDR_ERR_SUCCESS;
8928 }
8929
8930 _PUBLIC_ enum ndr_err_code ndr_pull_samr_OpenUser(struct ndr_pull *ndr, int flags, struct samr_OpenUser *r)
8931 {
8932         TALLOC_CTX *_mem_save_domain_handle_0;
8933         TALLOC_CTX *_mem_save_user_handle_0;
8934         if (flags & NDR_IN) {
8935                 ZERO_STRUCT(r->out);
8936
8937                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8938                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
8939                 }
8940                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8941                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
8942                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
8943                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
8944                 NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
8945                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
8946                 NDR_PULL_ALLOC(ndr, r->out.user_handle);
8947                 ZERO_STRUCTP(r->out.user_handle);
8948         }
8949         if (flags & NDR_OUT) {
8950                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8951                         NDR_PULL_ALLOC(ndr, r->out.user_handle);
8952                 }
8953                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8954                 NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
8955                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
8956                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
8957                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8958         }
8959         return NDR_ERR_SUCCESS;
8960 }
8961
8962 _PUBLIC_ void ndr_print_samr_OpenUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenUser *r)
8963 {
8964         ndr_print_struct(ndr, name, "samr_OpenUser");
8965         ndr->depth++;
8966         if (flags & NDR_SET_VALUES) {
8967                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8968         }
8969         if (flags & NDR_IN) {
8970                 ndr_print_struct(ndr, "in", "samr_OpenUser");
8971                 ndr->depth++;
8972                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
8973                 ndr->depth++;
8974                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
8975                 ndr->depth--;
8976                 ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);
8977                 ndr_print_uint32(ndr, "rid", r->in.rid);
8978                 ndr->depth--;
8979         }
8980         if (flags & NDR_OUT) {
8981                 ndr_print_struct(ndr, "out", "samr_OpenUser");
8982                 ndr->depth++;
8983                 ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
8984                 ndr->depth++;
8985                 ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
8986                 ndr->depth--;
8987                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8988                 ndr->depth--;
8989         }
8990         ndr->depth--;
8991 }
8992
8993 static enum ndr_err_code ndr_push_samr_DeleteUser(struct ndr_push *ndr, int flags, const struct samr_DeleteUser *r)
8994 {
8995         if (flags & NDR_IN) {
8996                 if (r->in.user_handle == NULL) {
8997                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8998                 }
8999                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9000         }
9001         if (flags & NDR_OUT) {
9002                 if (r->out.user_handle == NULL) {
9003                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9004                 }
9005                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
9006                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9007         }
9008         return NDR_ERR_SUCCESS;
9009 }
9010
9011 static enum ndr_err_code ndr_pull_samr_DeleteUser(struct ndr_pull *ndr, int flags, struct samr_DeleteUser *r)
9012 {
9013         TALLOC_CTX *_mem_save_user_handle_0;
9014         if (flags & NDR_IN) {
9015                 ZERO_STRUCT(r->out);
9016
9017                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9018                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9019                 }
9020                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9021                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9022                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9023                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9024                 NDR_PULL_ALLOC(ndr, r->out.user_handle);
9025                 *r->out.user_handle = *r->in.user_handle;
9026         }
9027         if (flags & NDR_OUT) {
9028                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9029                         NDR_PULL_ALLOC(ndr, r->out.user_handle);
9030                 }
9031                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9032                 NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
9033                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
9034                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9035                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9036         }
9037         return NDR_ERR_SUCCESS;
9038 }
9039
9040 _PUBLIC_ void ndr_print_samr_DeleteUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteUser *r)
9041 {
9042         ndr_print_struct(ndr, name, "samr_DeleteUser");
9043         ndr->depth++;
9044         if (flags & NDR_SET_VALUES) {
9045                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9046         }
9047         if (flags & NDR_IN) {
9048                 ndr_print_struct(ndr, "in", "samr_DeleteUser");
9049                 ndr->depth++;
9050                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9051                 ndr->depth++;
9052                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9053                 ndr->depth--;
9054                 ndr->depth--;
9055         }
9056         if (flags & NDR_OUT) {
9057                 ndr_print_struct(ndr, "out", "samr_DeleteUser");
9058                 ndr->depth++;
9059                 ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
9060                 ndr->depth++;
9061                 ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
9062                 ndr->depth--;
9063                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9064                 ndr->depth--;
9065         }
9066         ndr->depth--;
9067 }
9068
9069 _PUBLIC_ enum ndr_err_code ndr_push_samr_QueryUserInfo(struct ndr_push *ndr, int flags, const struct samr_QueryUserInfo *r)
9070 {
9071         if (flags & NDR_IN) {
9072                 if (r->in.user_handle == NULL) {
9073                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9074                 }
9075                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9076                 NDR_CHECK(ndr_push_samr_UserInfoLevel(ndr, NDR_SCALARS, r->in.level));
9077         }
9078         if (flags & NDR_OUT) {
9079                 if (r->out.info == NULL) {
9080                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9081                 }
9082                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
9083                 if (*r->out.info) {
9084                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
9085                         NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9086                 }
9087                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9088         }
9089         return NDR_ERR_SUCCESS;
9090 }
9091
9092 _PUBLIC_ enum ndr_err_code ndr_pull_samr_QueryUserInfo(struct ndr_pull *ndr, int flags, struct samr_QueryUserInfo *r)
9093 {
9094         uint32_t _ptr_info;
9095         TALLOC_CTX *_mem_save_user_handle_0;
9096         TALLOC_CTX *_mem_save_info_0;
9097         TALLOC_CTX *_mem_save_info_1;
9098         if (flags & NDR_IN) {
9099                 ZERO_STRUCT(r->out);
9100
9101                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9102                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9103                 }
9104                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9105                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9106                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9107                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9108                 NDR_CHECK(ndr_pull_samr_UserInfoLevel(ndr, NDR_SCALARS, &r->in.level));
9109                 NDR_PULL_ALLOC(ndr, r->out.info);
9110                 ZERO_STRUCTP(r->out.info);
9111         }
9112         if (flags & NDR_OUT) {
9113                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9114                         NDR_PULL_ALLOC(ndr, r->out.info);
9115                 }
9116                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9117                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9118                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9119                 if (_ptr_info) {
9120                         NDR_PULL_ALLOC(ndr, *r->out.info);
9121                 } else {
9122                         *r->out.info = NULL;
9123                 }
9124                 if (*r->out.info) {
9125                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
9126                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
9127                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
9128                         NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9129                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
9130                 }
9131                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9132                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9133         }
9134         return NDR_ERR_SUCCESS;
9135 }
9136
9137 _PUBLIC_ void ndr_print_samr_QueryUserInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryUserInfo *r)
9138 {
9139         ndr_print_struct(ndr, name, "samr_QueryUserInfo");
9140         ndr->depth++;
9141         if (flags & NDR_SET_VALUES) {
9142                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9143         }
9144         if (flags & NDR_IN) {
9145                 ndr_print_struct(ndr, "in", "samr_QueryUserInfo");
9146                 ndr->depth++;
9147                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9148                 ndr->depth++;
9149                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9150                 ndr->depth--;
9151                 ndr_print_samr_UserInfoLevel(ndr, "level", r->in.level);
9152                 ndr->depth--;
9153         }
9154         if (flags & NDR_OUT) {
9155                 ndr_print_struct(ndr, "out", "samr_QueryUserInfo");
9156                 ndr->depth++;
9157                 ndr_print_ptr(ndr, "info", r->out.info);
9158                 ndr->depth++;
9159                 ndr_print_ptr(ndr, "info", *r->out.info);
9160                 ndr->depth++;
9161                 if (*r->out.info) {
9162                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
9163                         ndr_print_samr_UserInfo(ndr, "info", *r->out.info);
9164                 }
9165                 ndr->depth--;
9166                 ndr->depth--;
9167                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9168                 ndr->depth--;
9169         }
9170         ndr->depth--;
9171 }
9172
9173 _PUBLIC_ enum ndr_err_code ndr_push_samr_SetUserInfo(struct ndr_push *ndr, int flags, const struct samr_SetUserInfo *r)
9174 {
9175         if (flags & NDR_IN) {
9176                 if (r->in.user_handle == NULL) {
9177                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9178                 }
9179                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9180                 NDR_CHECK(ndr_push_samr_UserInfoLevel(ndr, NDR_SCALARS, r->in.level));
9181                 if (r->in.info == NULL) {
9182                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9183                 }
9184                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
9185                 NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
9186         }
9187         if (flags & NDR_OUT) {
9188                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9189         }
9190         return NDR_ERR_SUCCESS;
9191 }
9192
9193 _PUBLIC_ enum ndr_err_code ndr_pull_samr_SetUserInfo(struct ndr_pull *ndr, int flags, struct samr_SetUserInfo *r)
9194 {
9195         TALLOC_CTX *_mem_save_user_handle_0;
9196         TALLOC_CTX *_mem_save_info_0;
9197         if (flags & NDR_IN) {
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_CHECK(ndr_pull_samr_UserInfoLevel(ndr, NDR_SCALARS, &r->in.level));
9206                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9207                         NDR_PULL_ALLOC(ndr, r->in.info);
9208                 }
9209                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9210                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
9211                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
9212                 NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
9213                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9214         }
9215         if (flags & NDR_OUT) {
9216                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9217         }
9218         return NDR_ERR_SUCCESS;
9219 }
9220
9221 _PUBLIC_ void ndr_print_samr_SetUserInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetUserInfo *r)
9222 {
9223         ndr_print_struct(ndr, name, "samr_SetUserInfo");
9224         ndr->depth++;
9225         if (flags & NDR_SET_VALUES) {
9226                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9227         }
9228         if (flags & NDR_IN) {
9229                 ndr_print_struct(ndr, "in", "samr_SetUserInfo");
9230                 ndr->depth++;
9231                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9232                 ndr->depth++;
9233                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9234                 ndr->depth--;
9235                 ndr_print_samr_UserInfoLevel(ndr, "level", r->in.level);
9236                 ndr_print_ptr(ndr, "info", r->in.info);
9237                 ndr->depth++;
9238                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
9239                 ndr_print_samr_UserInfo(ndr, "info", r->in.info);
9240                 ndr->depth--;
9241                 ndr->depth--;
9242         }
9243         if (flags & NDR_OUT) {
9244                 ndr_print_struct(ndr, "out", "samr_SetUserInfo");
9245                 ndr->depth++;
9246                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9247                 ndr->depth--;
9248         }
9249         ndr->depth--;
9250 }
9251
9252 static enum ndr_err_code ndr_push_samr_ChangePasswordUser(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser *r)
9253 {
9254         if (flags & NDR_IN) {
9255                 if (r->in.user_handle == NULL) {
9256                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9257                 }
9258                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9259                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_present));
9260                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_lm_crypted));
9261                 if (r->in.old_lm_crypted) {
9262                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.old_lm_crypted));
9263                 }
9264                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_lm_crypted));
9265                 if (r->in.new_lm_crypted) {
9266                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.new_lm_crypted));
9267                 }
9268                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.nt_present));
9269                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_nt_crypted));
9270                 if (r->in.old_nt_crypted) {
9271                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.old_nt_crypted));
9272                 }
9273                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_nt_crypted));
9274                 if (r->in.new_nt_crypted) {
9275                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.new_nt_crypted));
9276                 }
9277                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.cross1_present));
9278                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_cross));
9279                 if (r->in.nt_cross) {
9280                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_cross));
9281                 }
9282                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.cross2_present));
9283                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_cross));
9284                 if (r->in.lm_cross) {
9285                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_cross));
9286                 }
9287         }
9288         if (flags & NDR_OUT) {
9289                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9290         }
9291         return NDR_ERR_SUCCESS;
9292 }
9293
9294 static enum ndr_err_code ndr_pull_samr_ChangePasswordUser(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser *r)
9295 {
9296         uint32_t _ptr_old_lm_crypted;
9297         uint32_t _ptr_new_lm_crypted;
9298         uint32_t _ptr_old_nt_crypted;
9299         uint32_t _ptr_new_nt_crypted;
9300         uint32_t _ptr_nt_cross;
9301         uint32_t _ptr_lm_cross;
9302         TALLOC_CTX *_mem_save_user_handle_0;
9303         TALLOC_CTX *_mem_save_old_lm_crypted_0;
9304         TALLOC_CTX *_mem_save_new_lm_crypted_0;
9305         TALLOC_CTX *_mem_save_old_nt_crypted_0;
9306         TALLOC_CTX *_mem_save_new_nt_crypted_0;
9307         TALLOC_CTX *_mem_save_nt_cross_0;
9308         TALLOC_CTX *_mem_save_lm_cross_0;
9309         if (flags & NDR_IN) {
9310                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9311                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9312                 }
9313                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9314                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9315                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9316                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9317                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_present));
9318                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_lm_crypted));
9319                 if (_ptr_old_lm_crypted) {
9320                         NDR_PULL_ALLOC(ndr, r->in.old_lm_crypted);
9321                 } else {
9322                         r->in.old_lm_crypted = NULL;
9323                 }
9324                 if (r->in.old_lm_crypted) {
9325                         _mem_save_old_lm_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
9326                         NDR_PULL_SET_MEM_CTX(ndr, r->in.old_lm_crypted, 0);
9327                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.old_lm_crypted));
9328                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_lm_crypted_0, 0);
9329                 }
9330                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_lm_crypted));
9331                 if (_ptr_new_lm_crypted) {
9332                         NDR_PULL_ALLOC(ndr, r->in.new_lm_crypted);
9333                 } else {
9334                         r->in.new_lm_crypted = NULL;
9335                 }
9336                 if (r->in.new_lm_crypted) {
9337                         _mem_save_new_lm_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
9338                         NDR_PULL_SET_MEM_CTX(ndr, r->in.new_lm_crypted, 0);
9339                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.new_lm_crypted));
9340                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_lm_crypted_0, 0);
9341                 }
9342                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.nt_present));
9343                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_nt_crypted));
9344                 if (_ptr_old_nt_crypted) {
9345                         NDR_PULL_ALLOC(ndr, r->in.old_nt_crypted);
9346                 } else {
9347                         r->in.old_nt_crypted = NULL;
9348                 }
9349                 if (r->in.old_nt_crypted) {
9350                         _mem_save_old_nt_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
9351                         NDR_PULL_SET_MEM_CTX(ndr, r->in.old_nt_crypted, 0);
9352                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.old_nt_crypted));
9353                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_nt_crypted_0, 0);
9354                 }
9355                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_nt_crypted));
9356                 if (_ptr_new_nt_crypted) {
9357                         NDR_PULL_ALLOC(ndr, r->in.new_nt_crypted);
9358                 } else {
9359                         r->in.new_nt_crypted = NULL;
9360                 }
9361                 if (r->in.new_nt_crypted) {
9362                         _mem_save_new_nt_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
9363                         NDR_PULL_SET_MEM_CTX(ndr, r->in.new_nt_crypted, 0);
9364                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.new_nt_crypted));
9365                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_nt_crypted_0, 0);
9366                 }
9367                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.cross1_present));
9368                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_cross));
9369                 if (_ptr_nt_cross) {
9370                         NDR_PULL_ALLOC(ndr, r->in.nt_cross);
9371                 } else {
9372                         r->in.nt_cross = NULL;
9373                 }
9374                 if (r->in.nt_cross) {
9375                         _mem_save_nt_cross_0 = NDR_PULL_GET_MEM_CTX(ndr);
9376                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_cross, 0);
9377                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_cross));
9378                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_cross_0, 0);
9379                 }
9380                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.cross2_present));
9381                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_cross));
9382                 if (_ptr_lm_cross) {
9383                         NDR_PULL_ALLOC(ndr, r->in.lm_cross);
9384                 } else {
9385                         r->in.lm_cross = NULL;
9386                 }
9387                 if (r->in.lm_cross) {
9388                         _mem_save_lm_cross_0 = NDR_PULL_GET_MEM_CTX(ndr);
9389                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_cross, 0);
9390                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_cross));
9391                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_cross_0, 0);
9392                 }
9393         }
9394         if (flags & NDR_OUT) {
9395                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9396         }
9397         return NDR_ERR_SUCCESS;
9398 }
9399
9400 _PUBLIC_ void ndr_print_samr_ChangePasswordUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser *r)
9401 {
9402         ndr_print_struct(ndr, name, "samr_ChangePasswordUser");
9403         ndr->depth++;
9404         if (flags & NDR_SET_VALUES) {
9405                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9406         }
9407         if (flags & NDR_IN) {
9408                 ndr_print_struct(ndr, "in", "samr_ChangePasswordUser");
9409                 ndr->depth++;
9410                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9411                 ndr->depth++;
9412                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9413                 ndr->depth--;
9414                 ndr_print_uint8(ndr, "lm_present", r->in.lm_present);
9415                 ndr_print_ptr(ndr, "old_lm_crypted", r->in.old_lm_crypted);
9416                 ndr->depth++;
9417                 if (r->in.old_lm_crypted) {
9418                         ndr_print_samr_Password(ndr, "old_lm_crypted", r->in.old_lm_crypted);
9419                 }
9420                 ndr->depth--;
9421                 ndr_print_ptr(ndr, "new_lm_crypted", r->in.new_lm_crypted);
9422                 ndr->depth++;
9423                 if (r->in.new_lm_crypted) {
9424                         ndr_print_samr_Password(ndr, "new_lm_crypted", r->in.new_lm_crypted);
9425                 }
9426                 ndr->depth--;
9427                 ndr_print_uint8(ndr, "nt_present", r->in.nt_present);
9428                 ndr_print_ptr(ndr, "old_nt_crypted", r->in.old_nt_crypted);
9429                 ndr->depth++;
9430                 if (r->in.old_nt_crypted) {
9431                         ndr_print_samr_Password(ndr, "old_nt_crypted", r->in.old_nt_crypted);
9432                 }
9433                 ndr->depth--;
9434                 ndr_print_ptr(ndr, "new_nt_crypted", r->in.new_nt_crypted);
9435                 ndr->depth++;
9436                 if (r->in.new_nt_crypted) {
9437                         ndr_print_samr_Password(ndr, "new_nt_crypted", r->in.new_nt_crypted);
9438                 }
9439                 ndr->depth--;
9440                 ndr_print_uint8(ndr, "cross1_present", r->in.cross1_present);
9441                 ndr_print_ptr(ndr, "nt_cross", r->in.nt_cross);
9442                 ndr->depth++;
9443                 if (r->in.nt_cross) {
9444                         ndr_print_samr_Password(ndr, "nt_cross", r->in.nt_cross);
9445                 }
9446                 ndr->depth--;
9447                 ndr_print_uint8(ndr, "cross2_present", r->in.cross2_present);
9448                 ndr_print_ptr(ndr, "lm_cross", r->in.lm_cross);
9449                 ndr->depth++;
9450                 if (r->in.lm_cross) {
9451                         ndr_print_samr_Password(ndr, "lm_cross", r->in.lm_cross);
9452                 }
9453                 ndr->depth--;
9454                 ndr->depth--;
9455         }
9456         if (flags & NDR_OUT) {
9457                 ndr_print_struct(ndr, "out", "samr_ChangePasswordUser");
9458                 ndr->depth++;
9459                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9460                 ndr->depth--;
9461         }
9462         ndr->depth--;
9463 }
9464
9465 static enum ndr_err_code ndr_push_samr_GetGroupsForUser(struct ndr_push *ndr, int flags, const struct samr_GetGroupsForUser *r)
9466 {
9467         if (flags & NDR_IN) {
9468                 if (r->in.user_handle == NULL) {
9469                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9470                 }
9471                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9472         }
9473         if (flags & NDR_OUT) {
9474                 if (r->out.rids == NULL) {
9475                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9476                 }
9477                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rids));
9478                 if (*r->out.rids) {
9479                         NDR_CHECK(ndr_push_samr_RidWithAttributeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
9480                 }
9481                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9482         }
9483         return NDR_ERR_SUCCESS;
9484 }
9485
9486 static enum ndr_err_code ndr_pull_samr_GetGroupsForUser(struct ndr_pull *ndr, int flags, struct samr_GetGroupsForUser *r)
9487 {
9488         uint32_t _ptr_rids;
9489         TALLOC_CTX *_mem_save_user_handle_0;
9490         TALLOC_CTX *_mem_save_rids_0;
9491         TALLOC_CTX *_mem_save_rids_1;
9492         if (flags & NDR_IN) {
9493                 ZERO_STRUCT(r->out);
9494
9495                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9496                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9497                 }
9498                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9499                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9500                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9501                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9502                 NDR_PULL_ALLOC(ndr, r->out.rids);
9503                 ZERO_STRUCTP(r->out.rids);
9504         }
9505         if (flags & NDR_OUT) {
9506                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9507                         NDR_PULL_ALLOC(ndr, r->out.rids);
9508                 }
9509                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
9510                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
9511                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
9512                 if (_ptr_rids) {
9513                         NDR_PULL_ALLOC(ndr, *r->out.rids);
9514                 } else {
9515                         *r->out.rids = NULL;
9516                 }
9517                 if (*r->out.rids) {
9518                         _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
9519                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.rids, 0);
9520                         NDR_CHECK(ndr_pull_samr_RidWithAttributeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
9521                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
9522                 }
9523                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
9524                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9525         }
9526         return NDR_ERR_SUCCESS;
9527 }
9528
9529 _PUBLIC_ void ndr_print_samr_GetGroupsForUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetGroupsForUser *r)
9530 {
9531         ndr_print_struct(ndr, name, "samr_GetGroupsForUser");
9532         ndr->depth++;
9533         if (flags & NDR_SET_VALUES) {
9534                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9535         }
9536         if (flags & NDR_IN) {
9537                 ndr_print_struct(ndr, "in", "samr_GetGroupsForUser");
9538                 ndr->depth++;
9539                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9540                 ndr->depth++;
9541                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9542                 ndr->depth--;
9543                 ndr->depth--;
9544         }
9545         if (flags & NDR_OUT) {
9546                 ndr_print_struct(ndr, "out", "samr_GetGroupsForUser");
9547                 ndr->depth++;
9548                 ndr_print_ptr(ndr, "rids", r->out.rids);
9549                 ndr->depth++;
9550                 ndr_print_ptr(ndr, "rids", *r->out.rids);
9551                 ndr->depth++;
9552                 if (*r->out.rids) {
9553                         ndr_print_samr_RidWithAttributeArray(ndr, "rids", *r->out.rids);
9554                 }
9555                 ndr->depth--;
9556                 ndr->depth--;
9557                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9558                 ndr->depth--;
9559         }
9560         ndr->depth--;
9561 }
9562
9563 static enum ndr_err_code ndr_push_samr_QueryDisplayInfo(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo *r)
9564 {
9565         if (flags & NDR_IN) {
9566                 if (r->in.domain_handle == NULL) {
9567                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9568                 }
9569                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9570                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9571                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));
9572                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));
9573                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
9574         }
9575         if (flags & NDR_OUT) {
9576                 if (r->out.total_size == NULL) {
9577                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9578                 }
9579                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));
9580                 if (r->out.returned_size == NULL) {
9581                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9582                 }
9583                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));
9584                 if (r->out.info == NULL) {
9585                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9586                 }
9587                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
9588                 NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
9589                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9590         }
9591         return NDR_ERR_SUCCESS;
9592 }
9593
9594 static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo *r)
9595 {
9596         TALLOC_CTX *_mem_save_domain_handle_0;
9597         TALLOC_CTX *_mem_save_total_size_0;
9598         TALLOC_CTX *_mem_save_returned_size_0;
9599         TALLOC_CTX *_mem_save_info_0;
9600         if (flags & NDR_IN) {
9601                 ZERO_STRUCT(r->out);
9602
9603                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9604                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
9605                 }
9606                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9607                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
9608                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9609                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
9610                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
9611                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));
9612                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));
9613                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
9614                 NDR_PULL_ALLOC(ndr, r->out.total_size);
9615                 ZERO_STRUCTP(r->out.total_size);
9616                 NDR_PULL_ALLOC(ndr, r->out.returned_size);
9617                 ZERO_STRUCTP(r->out.returned_size);
9618                 NDR_PULL_ALLOC(ndr, r->out.info);
9619                 ZERO_STRUCTP(r->out.info);
9620         }
9621         if (flags & NDR_OUT) {
9622                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9623                         NDR_PULL_ALLOC(ndr, r->out.total_size);
9624                 }
9625                 _mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
9626                 NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);
9627                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));
9628                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);
9629                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9630                         NDR_PULL_ALLOC(ndr, r->out.returned_size);
9631                 }
9632                 _mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
9633                 NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);
9634                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));
9635                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);
9636                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9637                         NDR_PULL_ALLOC(ndr, r->out.info);
9638                 }
9639                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9640                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9641                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
9642                 NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
9643                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9644                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9645         }
9646         return NDR_ERR_SUCCESS;
9647 }
9648
9649 _PUBLIC_ void ndr_print_samr_QueryDisplayInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo *r)
9650 {
9651         ndr_print_struct(ndr, name, "samr_QueryDisplayInfo");
9652         ndr->depth++;
9653         if (flags & NDR_SET_VALUES) {
9654                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9655         }
9656         if (flags & NDR_IN) {
9657                 ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo");
9658                 ndr->depth++;
9659                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
9660                 ndr->depth++;
9661                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
9662                 ndr->depth--;
9663                 ndr_print_uint16(ndr, "level", r->in.level);
9664                 ndr_print_uint32(ndr, "start_idx", r->in.start_idx);
9665                 ndr_print_uint32(ndr, "max_entries", r->in.max_entries);
9666                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
9667                 ndr->depth--;
9668         }
9669         if (flags & NDR_OUT) {
9670                 ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo");
9671                 ndr->depth++;
9672                 ndr_print_ptr(ndr, "total_size", r->out.total_size);
9673                 ndr->depth++;
9674                 ndr_print_uint32(ndr, "total_size", *r->out.total_size);
9675                 ndr->depth--;
9676                 ndr_print_ptr(ndr, "returned_size", r->out.returned_size);
9677                 ndr->depth++;
9678                 ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);
9679                 ndr->depth--;
9680                 ndr_print_ptr(ndr, "info", r->out.info);
9681                 ndr->depth++;
9682                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
9683                 ndr_print_samr_DispInfo(ndr, "info", r->out.info);
9684                 ndr->depth--;
9685                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9686                 ndr->depth--;
9687         }
9688         ndr->depth--;
9689 }
9690
9691 static enum ndr_err_code ndr_push_samr_GetDisplayEnumerationIndex(struct ndr_push *ndr, int flags, const struct samr_GetDisplayEnumerationIndex *r)
9692 {
9693         if (flags & NDR_IN) {
9694                 if (r->in.domain_handle == NULL) {
9695                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9696                 }
9697                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9698                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9699                 if (r->in.name == NULL) {
9700                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9701                 }
9702                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
9703         }
9704         if (flags & NDR_OUT) {
9705                 if (r->out.idx == NULL) {
9706                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9707                 }
9708                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.idx));
9709                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9710         }
9711         return NDR_ERR_SUCCESS;
9712 }
9713
9714 static enum ndr_err_code ndr_pull_samr_GetDisplayEnumerationIndex(struct ndr_pull *ndr, int flags, struct samr_GetDisplayEnumerationIndex *r)
9715 {
9716         TALLOC_CTX *_mem_save_domain_handle_0;
9717         TALLOC_CTX *_mem_save_name_0;
9718         TALLOC_CTX *_mem_save_idx_0;
9719         if (flags & NDR_IN) {
9720                 ZERO_STRUCT(r->out);
9721
9722                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9723                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
9724                 }
9725                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9726                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
9727                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9728                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
9729                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
9730                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9731                         NDR_PULL_ALLOC(ndr, r->in.name);
9732                 }
9733                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9734                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
9735                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
9736                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
9737                 NDR_PULL_ALLOC(ndr, r->out.idx);
9738                 ZERO_STRUCTP(r->out.idx);
9739         }
9740         if (flags & NDR_OUT) {
9741                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9742                         NDR_PULL_ALLOC(ndr, r->out.idx);
9743                 }
9744                 _mem_save_idx_0 = NDR_PULL_GET_MEM_CTX(ndr);
9745                 NDR_PULL_SET_MEM_CTX(ndr, r->out.idx, LIBNDR_FLAG_REF_ALLOC);
9746                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.idx));
9747                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_idx_0, LIBNDR_FLAG_REF_ALLOC);
9748                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9749         }
9750         return NDR_ERR_SUCCESS;
9751 }
9752
9753 _PUBLIC_ void ndr_print_samr_GetDisplayEnumerationIndex(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDisplayEnumerationIndex *r)
9754 {
9755         ndr_print_struct(ndr, name, "samr_GetDisplayEnumerationIndex");
9756         ndr->depth++;
9757         if (flags & NDR_SET_VALUES) {
9758                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9759         }
9760         if (flags & NDR_IN) {
9761                 ndr_print_struct(ndr, "in", "samr_GetDisplayEnumerationIndex");
9762                 ndr->depth++;
9763                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
9764                 ndr->depth++;
9765                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
9766                 ndr->depth--;
9767                 ndr_print_uint16(ndr, "level", r->in.level);
9768                 ndr_print_ptr(ndr, "name", r->in.name);
9769                 ndr->depth++;
9770                 ndr_print_lsa_String(ndr, "name", r->in.name);
9771                 ndr->depth--;
9772                 ndr->depth--;
9773         }
9774         if (flags & NDR_OUT) {
9775                 ndr_print_struct(ndr, "out", "samr_GetDisplayEnumerationIndex");
9776                 ndr->depth++;
9777                 ndr_print_ptr(ndr, "idx", r->out.idx);
9778                 ndr->depth++;
9779                 ndr_print_uint32(ndr, "idx", *r->out.idx);
9780                 ndr->depth--;
9781                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9782                 ndr->depth--;
9783         }
9784         ndr->depth--;
9785 }
9786
9787 static enum ndr_err_code ndr_push_samr_TestPrivateFunctionsDomain(struct ndr_push *ndr, int flags, const struct samr_TestPrivateFunctionsDomain *r)
9788 {
9789         if (flags & NDR_IN) {
9790                 if (r->in.domain_handle == NULL) {
9791                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9792                 }
9793                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9794         }
9795         if (flags & NDR_OUT) {
9796                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9797         }
9798         return NDR_ERR_SUCCESS;
9799 }
9800
9801 static enum ndr_err_code ndr_pull_samr_TestPrivateFunctionsDomain(struct ndr_pull *ndr, int flags, struct samr_TestPrivateFunctionsDomain *r)
9802 {
9803         TALLOC_CTX *_mem_save_domain_handle_0;
9804         if (flags & NDR_IN) {
9805                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9806                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
9807                 }
9808                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9809                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
9810                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9811                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
9812         }
9813         if (flags & NDR_OUT) {
9814                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9815         }
9816         return NDR_ERR_SUCCESS;
9817 }
9818
9819 _PUBLIC_ void ndr_print_samr_TestPrivateFunctionsDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_TestPrivateFunctionsDomain *r)
9820 {
9821         ndr_print_struct(ndr, name, "samr_TestPrivateFunctionsDomain");
9822         ndr->depth++;
9823         if (flags & NDR_SET_VALUES) {
9824                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9825         }
9826         if (flags & NDR_IN) {
9827                 ndr_print_struct(ndr, "in", "samr_TestPrivateFunctionsDomain");
9828                 ndr->depth++;
9829                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
9830                 ndr->depth++;
9831                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
9832                 ndr->depth--;
9833                 ndr->depth--;
9834         }
9835         if (flags & NDR_OUT) {
9836                 ndr_print_struct(ndr, "out", "samr_TestPrivateFunctionsDomain");
9837                 ndr->depth++;
9838                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9839                 ndr->depth--;
9840         }
9841         ndr->depth--;
9842 }
9843
9844 static enum ndr_err_code ndr_push_samr_TestPrivateFunctionsUser(struct ndr_push *ndr, int flags, const struct samr_TestPrivateFunctionsUser *r)
9845 {
9846         if (flags & NDR_IN) {
9847                 if (r->in.user_handle == NULL) {
9848                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9849                 }
9850                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9851         }
9852         if (flags & NDR_OUT) {
9853                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9854         }
9855         return NDR_ERR_SUCCESS;
9856 }
9857
9858 static enum ndr_err_code ndr_pull_samr_TestPrivateFunctionsUser(struct ndr_pull *ndr, int flags, struct samr_TestPrivateFunctionsUser *r)
9859 {
9860         TALLOC_CTX *_mem_save_user_handle_0;
9861         if (flags & NDR_IN) {
9862                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9863                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9864                 }
9865                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9866                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9867                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9868                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9869         }
9870         if (flags & NDR_OUT) {
9871                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9872         }
9873         return NDR_ERR_SUCCESS;
9874 }
9875
9876 _PUBLIC_ void ndr_print_samr_TestPrivateFunctionsUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_TestPrivateFunctionsUser *r)
9877 {
9878         ndr_print_struct(ndr, name, "samr_TestPrivateFunctionsUser");
9879         ndr->depth++;
9880         if (flags & NDR_SET_VALUES) {
9881                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9882         }
9883         if (flags & NDR_IN) {
9884                 ndr_print_struct(ndr, "in", "samr_TestPrivateFunctionsUser");
9885                 ndr->depth++;
9886                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9887                 ndr->depth++;
9888                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9889                 ndr->depth--;
9890                 ndr->depth--;
9891         }
9892         if (flags & NDR_OUT) {
9893                 ndr_print_struct(ndr, "out", "samr_TestPrivateFunctionsUser");
9894                 ndr->depth++;
9895                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9896                 ndr->depth--;
9897         }
9898         ndr->depth--;
9899 }
9900
9901 _PUBLIC_ enum ndr_err_code ndr_push_samr_GetUserPwInfo(struct ndr_push *ndr, int flags, const struct samr_GetUserPwInfo *r)
9902 {
9903         if (flags & NDR_IN) {
9904                 if (r->in.user_handle == NULL) {
9905                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9906                 }
9907                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9908         }
9909         if (flags & NDR_OUT) {
9910                 if (r->out.info == NULL) {
9911                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9912                 }
9913                 NDR_CHECK(ndr_push_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
9914                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9915         }
9916         return NDR_ERR_SUCCESS;
9917 }
9918
9919 _PUBLIC_ enum ndr_err_code ndr_pull_samr_GetUserPwInfo(struct ndr_pull *ndr, int flags, struct samr_GetUserPwInfo *r)
9920 {
9921         TALLOC_CTX *_mem_save_user_handle_0;
9922         TALLOC_CTX *_mem_save_info_0;
9923         if (flags & NDR_IN) {
9924                 ZERO_STRUCT(r->out);
9925
9926                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9927                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9928                 }
9929                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9930                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9931                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9932                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9933                 NDR_PULL_ALLOC(ndr, r->out.info);
9934                 ZERO_STRUCTP(r->out.info);
9935         }
9936         if (flags & NDR_OUT) {
9937                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9938                         NDR_PULL_ALLOC(ndr, r->out.info);
9939                 }
9940                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9941                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9942                 NDR_CHECK(ndr_pull_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
9943                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9944                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9945         }
9946         return NDR_ERR_SUCCESS;
9947 }
9948
9949 _PUBLIC_ void ndr_print_samr_GetUserPwInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetUserPwInfo *r)
9950 {
9951         ndr_print_struct(ndr, name, "samr_GetUserPwInfo");
9952         ndr->depth++;
9953         if (flags & NDR_SET_VALUES) {
9954                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9955         }
9956         if (flags & NDR_IN) {
9957                 ndr_print_struct(ndr, "in", "samr_GetUserPwInfo");
9958                 ndr->depth++;
9959                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9960                 ndr->depth++;
9961                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9962                 ndr->depth--;
9963                 ndr->depth--;
9964         }
9965         if (flags & NDR_OUT) {
9966                 ndr_print_struct(ndr, "out", "samr_GetUserPwInfo");
9967                 ndr->depth++;
9968                 ndr_print_ptr(ndr, "info", r->out.info);
9969                 ndr->depth++;
9970                 ndr_print_samr_PwInfo(ndr, "info", r->out.info);
9971                 ndr->depth--;
9972                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9973                 ndr->depth--;
9974         }
9975         ndr->depth--;
9976 }
9977
9978 static enum ndr_err_code ndr_push_samr_RemoveMemberFromForeignDomain(struct ndr_push *ndr, int flags, const struct samr_RemoveMemberFromForeignDomain *r)
9979 {
9980         if (flags & NDR_IN) {
9981                 if (r->in.domain_handle == NULL) {
9982                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9983                 }
9984                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9985                 if (r->in.sid == NULL) {
9986                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9987                 }
9988                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
9989         }
9990         if (flags & NDR_OUT) {
9991                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9992         }
9993         return NDR_ERR_SUCCESS;
9994 }
9995
9996 static enum ndr_err_code ndr_pull_samr_RemoveMemberFromForeignDomain(struct ndr_pull *ndr, int flags, struct samr_RemoveMemberFromForeignDomain *r)
9997 {
9998         TALLOC_CTX *_mem_save_domain_handle_0;
9999         TALLOC_CTX *_mem_save_sid_0;
10000         if (flags & NDR_IN) {
10001                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10002                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10003                 }
10004                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10005                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10006                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10007                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10008                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10009                         NDR_PULL_ALLOC(ndr, r->in.sid);
10010                 }
10011                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
10012                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
10013                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
10014                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
10015         }
10016         if (flags & NDR_OUT) {
10017                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10018         }
10019         return NDR_ERR_SUCCESS;
10020 }
10021
10022 _PUBLIC_ void ndr_print_samr_RemoveMemberFromForeignDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_RemoveMemberFromForeignDomain *r)
10023 {
10024         ndr_print_struct(ndr, name, "samr_RemoveMemberFromForeignDomain");
10025         ndr->depth++;
10026         if (flags & NDR_SET_VALUES) {
10027                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10028         }
10029         if (flags & NDR_IN) {
10030                 ndr_print_struct(ndr, "in", "samr_RemoveMemberFromForeignDomain");
10031                 ndr->depth++;
10032                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10033                 ndr->depth++;
10034                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10035                 ndr->depth--;
10036                 ndr_print_ptr(ndr, "sid", r->in.sid);
10037                 ndr->depth++;
10038                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
10039                 ndr->depth--;
10040                 ndr->depth--;
10041         }
10042         if (flags & NDR_OUT) {
10043                 ndr_print_struct(ndr, "out", "samr_RemoveMemberFromForeignDomain");
10044                 ndr->depth++;
10045                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10046                 ndr->depth--;
10047         }
10048         ndr->depth--;
10049 }
10050
10051 static enum ndr_err_code ndr_push_samr_QueryDomainInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryDomainInfo2 *r)
10052 {
10053         if (flags & NDR_IN) {
10054                 if (r->in.domain_handle == NULL) {
10055                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10056                 }
10057                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10058                 NDR_CHECK(ndr_push_samr_DomainInfoClass(ndr, NDR_SCALARS, r->in.level));
10059         }
10060         if (flags & NDR_OUT) {
10061                 if (r->out.info == NULL) {
10062                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10063                 }
10064                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
10065                 if (*r->out.info) {
10066                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
10067                         NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
10068                 }
10069                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10070         }
10071         return NDR_ERR_SUCCESS;
10072 }
10073
10074 static enum ndr_err_code ndr_pull_samr_QueryDomainInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryDomainInfo2 *r)
10075 {
10076         uint32_t _ptr_info;
10077         TALLOC_CTX *_mem_save_domain_handle_0;
10078         TALLOC_CTX *_mem_save_info_0;
10079         TALLOC_CTX *_mem_save_info_1;
10080         if (flags & NDR_IN) {
10081                 ZERO_STRUCT(r->out);
10082
10083                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10084                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10085                 }
10086                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10087                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10088                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10089                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10090                 NDR_CHECK(ndr_pull_samr_DomainInfoClass(ndr, NDR_SCALARS, &r->in.level));
10091                 NDR_PULL_ALLOC(ndr, r->out.info);
10092                 ZERO_STRUCTP(r->out.info);
10093         }
10094         if (flags & NDR_OUT) {
10095                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10096                         NDR_PULL_ALLOC(ndr, r->out.info);
10097                 }
10098                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10099                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
10100                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
10101                 if (_ptr_info) {
10102                         NDR_PULL_ALLOC(ndr, *r->out.info);
10103                 } else {
10104                         *r->out.info = NULL;
10105                 }
10106                 if (*r->out.info) {
10107                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
10108                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
10109                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
10110                         NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
10111                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
10112                 }
10113                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
10114                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10115         }
10116         return NDR_ERR_SUCCESS;
10117 }
10118
10119 _PUBLIC_ void ndr_print_samr_QueryDomainInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDomainInfo2 *r)
10120 {
10121         ndr_print_struct(ndr, name, "samr_QueryDomainInfo2");
10122         ndr->depth++;
10123         if (flags & NDR_SET_VALUES) {
10124                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10125         }
10126         if (flags & NDR_IN) {
10127                 ndr_print_struct(ndr, "in", "samr_QueryDomainInfo2");
10128                 ndr->depth++;
10129                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10130                 ndr->depth++;
10131                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10132                 ndr->depth--;
10133                 ndr_print_samr_DomainInfoClass(ndr, "level", r->in.level);
10134                 ndr->depth--;
10135         }
10136         if (flags & NDR_OUT) {
10137                 ndr_print_struct(ndr, "out", "samr_QueryDomainInfo2");
10138                 ndr->depth++;
10139                 ndr_print_ptr(ndr, "info", r->out.info);
10140                 ndr->depth++;
10141                 ndr_print_ptr(ndr, "info", *r->out.info);
10142                 ndr->depth++;
10143                 if (*r->out.info) {
10144                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
10145                         ndr_print_samr_DomainInfo(ndr, "info", *r->out.info);
10146                 }
10147                 ndr->depth--;
10148                 ndr->depth--;
10149                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10150                 ndr->depth--;
10151         }
10152         ndr->depth--;
10153 }
10154
10155 static enum ndr_err_code ndr_push_samr_QueryUserInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryUserInfo2 *r)
10156 {
10157         if (flags & NDR_IN) {
10158                 if (r->in.user_handle == NULL) {
10159                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10160                 }
10161                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
10162                 NDR_CHECK(ndr_push_samr_UserInfoLevel(ndr, NDR_SCALARS, r->in.level));
10163         }
10164         if (flags & NDR_OUT) {
10165                 if (r->out.info == NULL) {
10166                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10167                 }
10168                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
10169                 if (*r->out.info) {
10170                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
10171                         NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
10172                 }
10173                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10174         }
10175         return NDR_ERR_SUCCESS;
10176 }
10177
10178 static enum ndr_err_code ndr_pull_samr_QueryUserInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryUserInfo2 *r)
10179 {
10180         uint32_t _ptr_info;
10181         TALLOC_CTX *_mem_save_user_handle_0;
10182         TALLOC_CTX *_mem_save_info_0;
10183         TALLOC_CTX *_mem_save_info_1;
10184         if (flags & NDR_IN) {
10185                 ZERO_STRUCT(r->out);
10186
10187                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10188                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
10189                 }
10190                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10191                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
10192                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
10193                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
10194                 NDR_CHECK(ndr_pull_samr_UserInfoLevel(ndr, NDR_SCALARS, &r->in.level));
10195                 NDR_PULL_ALLOC(ndr, r->out.info);
10196                 ZERO_STRUCTP(r->out.info);
10197         }
10198         if (flags & NDR_OUT) {
10199                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10200                         NDR_PULL_ALLOC(ndr, r->out.info);
10201                 }
10202                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10203                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
10204                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
10205                 if (_ptr_info) {
10206                         NDR_PULL_ALLOC(ndr, *r->out.info);
10207                 } else {
10208                         *r->out.info = NULL;
10209                 }
10210                 if (*r->out.info) {
10211                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
10212                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
10213                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
10214                         NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
10215                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
10216                 }
10217                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
10218                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10219         }
10220         return NDR_ERR_SUCCESS;
10221 }
10222
10223 _PUBLIC_ void ndr_print_samr_QueryUserInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryUserInfo2 *r)
10224 {
10225         ndr_print_struct(ndr, name, "samr_QueryUserInfo2");
10226         ndr->depth++;
10227         if (flags & NDR_SET_VALUES) {
10228                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10229         }
10230         if (flags & NDR_IN) {
10231                 ndr_print_struct(ndr, "in", "samr_QueryUserInfo2");
10232                 ndr->depth++;
10233                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
10234                 ndr->depth++;
10235                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
10236                 ndr->depth--;
10237                 ndr_print_samr_UserInfoLevel(ndr, "level", r->in.level);
10238                 ndr->depth--;
10239         }
10240         if (flags & NDR_OUT) {
10241                 ndr_print_struct(ndr, "out", "samr_QueryUserInfo2");
10242                 ndr->depth++;
10243                 ndr_print_ptr(ndr, "info", r->out.info);
10244                 ndr->depth++;
10245                 ndr_print_ptr(ndr, "info", *r->out.info);
10246                 ndr->depth++;
10247                 if (*r->out.info) {
10248                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
10249                         ndr_print_samr_UserInfo(ndr, "info", *r->out.info);
10250                 }
10251                 ndr->depth--;
10252                 ndr->depth--;
10253                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10254                 ndr->depth--;
10255         }
10256         ndr->depth--;
10257 }
10258
10259 static enum ndr_err_code ndr_push_samr_QueryDisplayInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo2 *r)
10260 {
10261         if (flags & NDR_IN) {
10262                 if (r->in.domain_handle == NULL) {
10263                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10264                 }
10265                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10266                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
10267                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));
10268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));
10269                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
10270         }
10271         if (flags & NDR_OUT) {
10272                 if (r->out.total_size == NULL) {
10273                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10274                 }
10275                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));
10276                 if (r->out.returned_size == NULL) {
10277                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10278                 }
10279                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));
10280                 if (r->out.info == NULL) {
10281                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10282                 }
10283                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
10284                 NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
10285                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10286         }
10287         return NDR_ERR_SUCCESS;
10288 }
10289
10290 static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo2 *r)
10291 {
10292         TALLOC_CTX *_mem_save_domain_handle_0;
10293         TALLOC_CTX *_mem_save_total_size_0;
10294         TALLOC_CTX *_mem_save_returned_size_0;
10295         TALLOC_CTX *_mem_save_info_0;
10296         if (flags & NDR_IN) {
10297                 ZERO_STRUCT(r->out);
10298
10299                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10300                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10301                 }
10302                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10303                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10304                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10305                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10306                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10307                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));
10308                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));
10309                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
10310                 NDR_PULL_ALLOC(ndr, r->out.total_size);
10311                 ZERO_STRUCTP(r->out.total_size);
10312                 NDR_PULL_ALLOC(ndr, r->out.returned_size);
10313                 ZERO_STRUCTP(r->out.returned_size);
10314                 NDR_PULL_ALLOC(ndr, r->out.info);
10315                 ZERO_STRUCTP(r->out.info);
10316         }
10317         if (flags & NDR_OUT) {
10318                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10319                         NDR_PULL_ALLOC(ndr, r->out.total_size);
10320                 }
10321                 _mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
10322                 NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);
10323                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));
10324                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);
10325                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10326                         NDR_PULL_ALLOC(ndr, r->out.returned_size);
10327                 }
10328                 _mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
10329                 NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);
10330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));
10331                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);
10332                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10333                         NDR_PULL_ALLOC(ndr, r->out.info);
10334                 }
10335                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10336                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
10337                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
10338                 NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
10339                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
10340                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10341         }
10342         return NDR_ERR_SUCCESS;
10343 }
10344
10345 _PUBLIC_ void ndr_print_samr_QueryDisplayInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo2 *r)
10346 {
10347         ndr_print_struct(ndr, name, "samr_QueryDisplayInfo2");
10348         ndr->depth++;
10349         if (flags & NDR_SET_VALUES) {
10350                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10351         }
10352         if (flags & NDR_IN) {
10353                 ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo2");
10354                 ndr->depth++;
10355                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10356                 ndr->depth++;
10357                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10358                 ndr->depth--;
10359                 ndr_print_uint16(ndr, "level", r->in.level);
10360                 ndr_print_uint32(ndr, "start_idx", r->in.start_idx);
10361                 ndr_print_uint32(ndr, "max_entries", r->in.max_entries);
10362                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
10363                 ndr->depth--;
10364         }
10365         if (flags & NDR_OUT) {
10366                 ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo2");
10367                 ndr->depth++;
10368                 ndr_print_ptr(ndr, "total_size", r->out.total_size);
10369                 ndr->depth++;
10370                 ndr_print_uint32(ndr, "total_size", *r->out.total_size);
10371                 ndr->depth--;
10372                 ndr_print_ptr(ndr, "returned_size", r->out.returned_size);
10373                 ndr->depth++;
10374                 ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);
10375                 ndr->depth--;
10376                 ndr_print_ptr(ndr, "info", r->out.info);
10377                 ndr->depth++;
10378                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
10379                 ndr_print_samr_DispInfo(ndr, "info", r->out.info);
10380                 ndr->depth--;
10381                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10382                 ndr->depth--;
10383         }
10384         ndr->depth--;
10385 }
10386
10387 static enum ndr_err_code ndr_push_samr_GetDisplayEnumerationIndex2(struct ndr_push *ndr, int flags, const struct samr_GetDisplayEnumerationIndex2 *r)
10388 {
10389         if (flags & NDR_IN) {
10390                 if (r->in.domain_handle == NULL) {
10391                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10392                 }
10393                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10394                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
10395                 if (r->in.name == NULL) {
10396                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10397                 }
10398                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
10399         }
10400         if (flags & NDR_OUT) {
10401                 if (r->out.idx == NULL) {
10402                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10403                 }
10404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.idx));
10405                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10406         }
10407         return NDR_ERR_SUCCESS;
10408 }
10409
10410 static enum ndr_err_code ndr_pull_samr_GetDisplayEnumerationIndex2(struct ndr_pull *ndr, int flags, struct samr_GetDisplayEnumerationIndex2 *r)
10411 {
10412         TALLOC_CTX *_mem_save_domain_handle_0;
10413         TALLOC_CTX *_mem_save_name_0;
10414         TALLOC_CTX *_mem_save_idx_0;
10415         if (flags & NDR_IN) {
10416                 ZERO_STRUCT(r->out);
10417
10418                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10419                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10420                 }
10421                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10422                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10423                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10424                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10425                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10426                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10427                         NDR_PULL_ALLOC(ndr, r->in.name);
10428                 }
10429                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10430                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
10431                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
10432                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
10433                 NDR_PULL_ALLOC(ndr, r->out.idx);
10434                 ZERO_STRUCTP(r->out.idx);
10435         }
10436         if (flags & NDR_OUT) {
10437                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10438                         NDR_PULL_ALLOC(ndr, r->out.idx);
10439                 }
10440                 _mem_save_idx_0 = NDR_PULL_GET_MEM_CTX(ndr);
10441                 NDR_PULL_SET_MEM_CTX(ndr, r->out.idx, LIBNDR_FLAG_REF_ALLOC);
10442                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.idx));
10443                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_idx_0, LIBNDR_FLAG_REF_ALLOC);
10444                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10445         }
10446         return NDR_ERR_SUCCESS;
10447 }
10448
10449 _PUBLIC_ void ndr_print_samr_GetDisplayEnumerationIndex2(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDisplayEnumerationIndex2 *r)
10450 {
10451         ndr_print_struct(ndr, name, "samr_GetDisplayEnumerationIndex2");
10452         ndr->depth++;
10453         if (flags & NDR_SET_VALUES) {
10454                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10455         }
10456         if (flags & NDR_IN) {
10457                 ndr_print_struct(ndr, "in", "samr_GetDisplayEnumerationIndex2");
10458                 ndr->depth++;
10459                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10460                 ndr->depth++;
10461                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10462                 ndr->depth--;
10463                 ndr_print_uint16(ndr, "level", r->in.level);
10464                 ndr_print_ptr(ndr, "name", r->in.name);
10465                 ndr->depth++;
10466                 ndr_print_lsa_String(ndr, "name", r->in.name);
10467                 ndr->depth--;
10468                 ndr->depth--;
10469         }
10470         if (flags & NDR_OUT) {
10471                 ndr_print_struct(ndr, "out", "samr_GetDisplayEnumerationIndex2");
10472                 ndr->depth++;
10473                 ndr_print_ptr(ndr, "idx", r->out.idx);
10474                 ndr->depth++;
10475                 ndr_print_uint32(ndr, "idx", *r->out.idx);
10476                 ndr->depth--;
10477                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10478                 ndr->depth--;
10479         }
10480         ndr->depth--;
10481 }
10482
10483 static enum ndr_err_code ndr_push_samr_CreateUser2(struct ndr_push *ndr, int flags, const struct samr_CreateUser2 *r)
10484 {
10485         if (flags & NDR_IN) {
10486                 if (r->in.domain_handle == NULL) {
10487                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10488                 }
10489                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10490                 if (r->in.account_name == NULL) {
10491                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10492                 }
10493                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
10494                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->in.acct_flags));
10495                 NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
10496         }
10497         if (flags & NDR_OUT) {
10498                 if (r->out.user_handle == NULL) {
10499                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10500                 }
10501                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
10502                 if (r->out.access_granted == NULL) {
10503                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10504                 }
10505                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.access_granted));
10506                 if (r->out.rid == NULL) {
10507                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10508                 }
10509                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
10510                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10511         }
10512         return NDR_ERR_SUCCESS;
10513 }
10514
10515 static enum ndr_err_code ndr_pull_samr_CreateUser2(struct ndr_pull *ndr, int flags, struct samr_CreateUser2 *r)
10516 {
10517         TALLOC_CTX *_mem_save_domain_handle_0;
10518         TALLOC_CTX *_mem_save_account_name_0;
10519         TALLOC_CTX *_mem_save_user_handle_0;
10520         TALLOC_CTX *_mem_save_access_granted_0;
10521         TALLOC_CTX *_mem_save_rid_0;
10522         if (flags & NDR_IN) {
10523                 ZERO_STRUCT(r->out);
10524
10525                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10526                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10527                 }
10528                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10529                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10530                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10531                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10532                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10533                         NDR_PULL_ALLOC(ndr, r->in.account_name);
10534                 }
10535                 _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10536                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account_name, LIBNDR_FLAG_REF_ALLOC);
10537                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
10538                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, LIBNDR_FLAG_REF_ALLOC);
10539                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->in.acct_flags));
10540                 NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
10541                 NDR_PULL_ALLOC(ndr, r->out.user_handle);
10542                 ZERO_STRUCTP(r->out.user_handle);
10543                 NDR_PULL_ALLOC(ndr, r->out.access_granted);
10544                 ZERO_STRUCTP(r->out.access_granted);
10545                 NDR_PULL_ALLOC(ndr, r->out.rid);
10546                 ZERO_STRUCTP(r->out.rid);
10547         }
10548         if (flags & NDR_OUT) {
10549                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10550                         NDR_PULL_ALLOC(ndr, r->out.user_handle);
10551                 }
10552                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10553                 NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
10554                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
10555                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
10556                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10557                         NDR_PULL_ALLOC(ndr, r->out.access_granted);
10558                 }
10559                 _mem_save_access_granted_0 = NDR_PULL_GET_MEM_CTX(ndr);
10560                 NDR_PULL_SET_MEM_CTX(ndr, r->out.access_granted, LIBNDR_FLAG_REF_ALLOC);
10561                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.access_granted));
10562                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_access_granted_0, LIBNDR_FLAG_REF_ALLOC);
10563                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10564                         NDR_PULL_ALLOC(ndr, r->out.rid);
10565                 }
10566                 _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
10567                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
10568                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
10569                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
10570                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10571         }
10572         return NDR_ERR_SUCCESS;
10573 }
10574
10575 _PUBLIC_ void ndr_print_samr_CreateUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateUser2 *r)
10576 {
10577         ndr_print_struct(ndr, name, "samr_CreateUser2");
10578         ndr->depth++;
10579         if (flags & NDR_SET_VALUES) {
10580                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10581         }
10582         if (flags & NDR_IN) {
10583                 ndr_print_struct(ndr, "in", "samr_CreateUser2");
10584                 ndr->depth++;
10585                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10586                 ndr->depth++;
10587                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10588                 ndr->depth--;
10589                 ndr_print_ptr(ndr, "account_name", r->in.account_name);
10590                 ndr->depth++;
10591                 ndr_print_lsa_String(ndr, "account_name", r->in.account_name);
10592                 ndr->depth--;
10593                 ndr_print_samr_AcctFlags(ndr, "acct_flags", r->in.acct_flags);
10594                 ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);
10595                 ndr->depth--;
10596         }
10597         if (flags & NDR_OUT) {
10598                 ndr_print_struct(ndr, "out", "samr_CreateUser2");
10599                 ndr->depth++;
10600                 ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
10601                 ndr->depth++;
10602                 ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
10603                 ndr->depth--;
10604                 ndr_print_ptr(ndr, "access_granted", r->out.access_granted);
10605                 ndr->depth++;
10606                 ndr_print_uint32(ndr, "access_granted", *r->out.access_granted);
10607                 ndr->depth--;
10608                 ndr_print_ptr(ndr, "rid", r->out.rid);
10609                 ndr->depth++;
10610                 ndr_print_uint32(ndr, "rid", *r->out.rid);
10611                 ndr->depth--;
10612                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10613                 ndr->depth--;
10614         }
10615         ndr->depth--;
10616 }
10617
10618 static enum ndr_err_code ndr_push_samr_QueryDisplayInfo3(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo3 *r)
10619 {
10620         if (flags & NDR_IN) {
10621                 if (r->in.domain_handle == NULL) {
10622                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10623                 }
10624                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10625                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
10626                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));
10627                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));
10628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
10629         }
10630         if (flags & NDR_OUT) {
10631                 if (r->out.total_size == NULL) {
10632                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10633                 }
10634                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));
10635                 if (r->out.returned_size == NULL) {
10636                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10637                 }
10638                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));
10639                 if (r->out.info == NULL) {
10640                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10641                 }
10642                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
10643                 NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
10644                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10645         }
10646         return NDR_ERR_SUCCESS;
10647 }
10648
10649 static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo3(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo3 *r)
10650 {
10651         TALLOC_CTX *_mem_save_domain_handle_0;
10652         TALLOC_CTX *_mem_save_total_size_0;
10653         TALLOC_CTX *_mem_save_returned_size_0;
10654         TALLOC_CTX *_mem_save_info_0;
10655         if (flags & NDR_IN) {
10656                 ZERO_STRUCT(r->out);
10657
10658                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10659                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10660                 }
10661                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10662                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10663                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10664                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10665                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10666                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));
10667                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));
10668                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
10669                 NDR_PULL_ALLOC(ndr, r->out.total_size);
10670                 ZERO_STRUCTP(r->out.total_size);
10671                 NDR_PULL_ALLOC(ndr, r->out.returned_size);
10672                 ZERO_STRUCTP(r->out.returned_size);
10673                 NDR_PULL_ALLOC(ndr, r->out.info);
10674                 ZERO_STRUCTP(r->out.info);
10675         }
10676         if (flags & NDR_OUT) {
10677                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10678                         NDR_PULL_ALLOC(ndr, r->out.total_size);
10679                 }
10680                 _mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
10681                 NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);
10682                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));
10683                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);
10684                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10685                         NDR_PULL_ALLOC(ndr, r->out.returned_size);
10686                 }
10687                 _mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
10688                 NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);
10689                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));
10690                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);
10691                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10692                         NDR_PULL_ALLOC(ndr, r->out.info);
10693                 }
10694                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10695                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
10696                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
10697                 NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
10698                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
10699                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10700         }
10701         return NDR_ERR_SUCCESS;
10702 }
10703
10704 _PUBLIC_ void ndr_print_samr_QueryDisplayInfo3(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo3 *r)
10705 {
10706         ndr_print_struct(ndr, name, "samr_QueryDisplayInfo3");
10707         ndr->depth++;
10708         if (flags & NDR_SET_VALUES) {
10709                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10710         }
10711         if (flags & NDR_IN) {
10712                 ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo3");
10713                 ndr->depth++;
10714                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10715                 ndr->depth++;
10716                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10717                 ndr->depth--;
10718                 ndr_print_uint16(ndr, "level", r->in.level);
10719                 ndr_print_uint32(ndr, "start_idx", r->in.start_idx);
10720                 ndr_print_uint32(ndr, "max_entries", r->in.max_entries);
10721                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
10722                 ndr->depth--;
10723         }
10724         if (flags & NDR_OUT) {
10725                 ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo3");
10726                 ndr->depth++;
10727                 ndr_print_ptr(ndr, "total_size", r->out.total_size);
10728                 ndr->depth++;
10729                 ndr_print_uint32(ndr, "total_size", *r->out.total_size);
10730                 ndr->depth--;
10731                 ndr_print_ptr(ndr, "returned_size", r->out.returned_size);
10732                 ndr->depth++;
10733                 ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);
10734                 ndr->depth--;
10735                 ndr_print_ptr(ndr, "info", r->out.info);
10736                 ndr->depth++;
10737                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
10738                 ndr_print_samr_DispInfo(ndr, "info", r->out.info);
10739                 ndr->depth--;
10740                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10741                 ndr->depth--;
10742         }
10743         ndr->depth--;
10744 }
10745
10746 static enum ndr_err_code ndr_push_samr_AddMultipleMembersToAlias(struct ndr_push *ndr, int flags, const struct samr_AddMultipleMembersToAlias *r)
10747 {
10748         if (flags & NDR_IN) {
10749                 if (r->in.alias_handle == NULL) {
10750                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10751                 }
10752                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
10753                 if (r->in.sids == NULL) {
10754                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10755                 }
10756                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10757         }
10758         if (flags & NDR_OUT) {
10759                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10760         }
10761         return NDR_ERR_SUCCESS;
10762 }
10763
10764 static enum ndr_err_code ndr_pull_samr_AddMultipleMembersToAlias(struct ndr_pull *ndr, int flags, struct samr_AddMultipleMembersToAlias *r)
10765 {
10766         TALLOC_CTX *_mem_save_alias_handle_0;
10767         TALLOC_CTX *_mem_save_sids_0;
10768         if (flags & NDR_IN) {
10769                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10770                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
10771                 }
10772                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10773                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
10774                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
10775                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
10776                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10777                         NDR_PULL_ALLOC(ndr, r->in.sids);
10778                 }
10779                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
10780                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
10781                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10782                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
10783         }
10784         if (flags & NDR_OUT) {
10785                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10786         }
10787         return NDR_ERR_SUCCESS;
10788 }
10789
10790 _PUBLIC_ void ndr_print_samr_AddMultipleMembersToAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddMultipleMembersToAlias *r)
10791 {
10792         ndr_print_struct(ndr, name, "samr_AddMultipleMembersToAlias");
10793         ndr->depth++;
10794         if (flags & NDR_SET_VALUES) {
10795                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10796         }
10797         if (flags & NDR_IN) {
10798                 ndr_print_struct(ndr, "in", "samr_AddMultipleMembersToAlias");
10799                 ndr->depth++;
10800                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
10801                 ndr->depth++;
10802                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
10803                 ndr->depth--;
10804                 ndr_print_ptr(ndr, "sids", r->in.sids);
10805                 ndr->depth++;
10806                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
10807                 ndr->depth--;
10808                 ndr->depth--;
10809         }
10810         if (flags & NDR_OUT) {
10811                 ndr_print_struct(ndr, "out", "samr_AddMultipleMembersToAlias");
10812                 ndr->depth++;
10813                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10814                 ndr->depth--;
10815         }
10816         ndr->depth--;
10817 }
10818
10819 static enum ndr_err_code ndr_push_samr_RemoveMultipleMembersFromAlias(struct ndr_push *ndr, int flags, const struct samr_RemoveMultipleMembersFromAlias *r)
10820 {
10821         if (flags & NDR_IN) {
10822                 if (r->in.alias_handle == NULL) {
10823                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10824                 }
10825                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
10826                 if (r->in.sids == NULL) {
10827                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10828                 }
10829                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10830         }
10831         if (flags & NDR_OUT) {
10832                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10833         }
10834         return NDR_ERR_SUCCESS;
10835 }
10836
10837 static enum ndr_err_code ndr_pull_samr_RemoveMultipleMembersFromAlias(struct ndr_pull *ndr, int flags, struct samr_RemoveMultipleMembersFromAlias *r)
10838 {
10839         TALLOC_CTX *_mem_save_alias_handle_0;
10840         TALLOC_CTX *_mem_save_sids_0;
10841         if (flags & NDR_IN) {
10842                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10843                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
10844                 }
10845                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10846                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
10847                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
10848                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
10849                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10850                         NDR_PULL_ALLOC(ndr, r->in.sids);
10851                 }
10852                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
10853                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
10854                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10855                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
10856         }
10857         if (flags & NDR_OUT) {
10858                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10859         }
10860         return NDR_ERR_SUCCESS;
10861 }
10862
10863 _PUBLIC_ void ndr_print_samr_RemoveMultipleMembersFromAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_RemoveMultipleMembersFromAlias *r)
10864 {
10865         ndr_print_struct(ndr, name, "samr_RemoveMultipleMembersFromAlias");
10866         ndr->depth++;
10867         if (flags & NDR_SET_VALUES) {
10868                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10869         }
10870         if (flags & NDR_IN) {
10871                 ndr_print_struct(ndr, "in", "samr_RemoveMultipleMembersFromAlias");
10872                 ndr->depth++;
10873                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
10874                 ndr->depth++;
10875                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
10876                 ndr->depth--;
10877                 ndr_print_ptr(ndr, "sids", r->in.sids);
10878                 ndr->depth++;
10879                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
10880                 ndr->depth--;
10881                 ndr->depth--;
10882         }
10883         if (flags & NDR_OUT) {
10884                 ndr_print_struct(ndr, "out", "samr_RemoveMultipleMembersFromAlias");
10885                 ndr->depth++;
10886                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10887                 ndr->depth--;
10888         }
10889         ndr->depth--;
10890 }
10891
10892 static enum ndr_err_code ndr_push_samr_OemChangePasswordUser2(struct ndr_push *ndr, int flags, const struct samr_OemChangePasswordUser2 *r)
10893 {
10894         if (flags & NDR_IN) {
10895                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
10896                 if (r->in.server) {
10897                         NDR_CHECK(ndr_push_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
10898                 }
10899                 if (r->in.account == NULL) {
10900                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10901                 }
10902                 NDR_CHECK(ndr_push_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
10903                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
10904                 if (r->in.password) {
10905                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password));
10906                 }
10907                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hash));
10908                 if (r->in.hash) {
10909                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.hash));
10910                 }
10911         }
10912         if (flags & NDR_OUT) {
10913                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10914         }
10915         return NDR_ERR_SUCCESS;
10916 }
10917
10918 static enum ndr_err_code ndr_pull_samr_OemChangePasswordUser2(struct ndr_pull *ndr, int flags, struct samr_OemChangePasswordUser2 *r)
10919 {
10920         uint32_t _ptr_server;
10921         uint32_t _ptr_password;
10922         uint32_t _ptr_hash;
10923         TALLOC_CTX *_mem_save_server_0;
10924         TALLOC_CTX *_mem_save_account_0;
10925         TALLOC_CTX *_mem_save_password_0;
10926         TALLOC_CTX *_mem_save_hash_0;
10927         if (flags & NDR_IN) {
10928                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
10929                 if (_ptr_server) {
10930                         NDR_PULL_ALLOC(ndr, r->in.server);
10931                 } else {
10932                         r->in.server = NULL;
10933                 }
10934                 if (r->in.server) {
10935                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
10936                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
10937                         NDR_CHECK(ndr_pull_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
10938                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
10939                 }
10940                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10941                         NDR_PULL_ALLOC(ndr, r->in.account);
10942                 }
10943                 _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
10944                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);
10945                 NDR_CHECK(ndr_pull_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
10946                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);
10947                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
10948                 if (_ptr_password) {
10949                         NDR_PULL_ALLOC(ndr, r->in.password);
10950                 } else {
10951                         r->in.password = NULL;
10952                 }
10953                 if (r->in.password) {
10954                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
10955                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
10956                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password));
10957                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
10958                 }
10959                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hash));
10960                 if (_ptr_hash) {
10961                         NDR_PULL_ALLOC(ndr, r->in.hash);
10962                 } else {
10963                         r->in.hash = NULL;
10964                 }
10965                 if (r->in.hash) {
10966                         _mem_save_hash_0 = NDR_PULL_GET_MEM_CTX(ndr);
10967                         NDR_PULL_SET_MEM_CTX(ndr, r->in.hash, 0);
10968                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.hash));
10969                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hash_0, 0);
10970                 }
10971         }
10972         if (flags & NDR_OUT) {
10973                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10974         }
10975         return NDR_ERR_SUCCESS;
10976 }
10977
10978 _PUBLIC_ void ndr_print_samr_OemChangePasswordUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_OemChangePasswordUser2 *r)
10979 {
10980         ndr_print_struct(ndr, name, "samr_OemChangePasswordUser2");
10981         ndr->depth++;
10982         if (flags & NDR_SET_VALUES) {
10983                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10984         }
10985         if (flags & NDR_IN) {
10986                 ndr_print_struct(ndr, "in", "samr_OemChangePasswordUser2");
10987                 ndr->depth++;
10988                 ndr_print_ptr(ndr, "server", r->in.server);
10989                 ndr->depth++;
10990                 if (r->in.server) {
10991                         ndr_print_lsa_AsciiString(ndr, "server", r->in.server);
10992                 }
10993                 ndr->depth--;
10994                 ndr_print_ptr(ndr, "account", r->in.account);
10995                 ndr->depth++;
10996                 ndr_print_lsa_AsciiString(ndr, "account", r->in.account);
10997                 ndr->depth--;
10998                 ndr_print_ptr(ndr, "password", r->in.password);
10999                 ndr->depth++;
11000                 if (r->in.password) {
11001                         ndr_print_samr_CryptPassword(ndr, "password", r->in.password);
11002                 }
11003                 ndr->depth--;
11004                 ndr_print_ptr(ndr, "hash", r->in.hash);
11005                 ndr->depth++;
11006                 if (r->in.hash) {
11007                         ndr_print_samr_Password(ndr, "hash", r->in.hash);
11008                 }
11009                 ndr->depth--;
11010                 ndr->depth--;
11011         }
11012         if (flags & NDR_OUT) {
11013                 ndr_print_struct(ndr, "out", "samr_OemChangePasswordUser2");
11014                 ndr->depth++;
11015                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11016                 ndr->depth--;
11017         }
11018         ndr->depth--;
11019 }
11020
11021 static enum ndr_err_code ndr_push_samr_ChangePasswordUser2(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser2 *r)
11022 {
11023         if (flags & NDR_IN) {
11024                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
11025                 if (r->in.server) {
11026                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
11027                 }
11028                 if (r->in.account == NULL) {
11029                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11030                 }
11031                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
11032                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_password));
11033                 if (r->in.nt_password) {
11034                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
11035                 }
11036                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_verifier));
11037                 if (r->in.nt_verifier) {
11038                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
11039                 }
11040                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_change));
11041                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_password));
11042                 if (r->in.lm_password) {
11043                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
11044                 }
11045                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_verifier));
11046                 if (r->in.lm_verifier) {
11047                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
11048                 }
11049         }
11050         if (flags & NDR_OUT) {
11051                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11052         }
11053         return NDR_ERR_SUCCESS;
11054 }
11055
11056 static enum ndr_err_code ndr_pull_samr_ChangePasswordUser2(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser2 *r)
11057 {
11058         uint32_t _ptr_server;
11059         uint32_t _ptr_nt_password;
11060         uint32_t _ptr_nt_verifier;
11061         uint32_t _ptr_lm_password;
11062         uint32_t _ptr_lm_verifier;
11063         TALLOC_CTX *_mem_save_server_0;
11064         TALLOC_CTX *_mem_save_account_0;
11065         TALLOC_CTX *_mem_save_nt_password_0;
11066         TALLOC_CTX *_mem_save_nt_verifier_0;
11067         TALLOC_CTX *_mem_save_lm_password_0;
11068         TALLOC_CTX *_mem_save_lm_verifier_0;
11069         if (flags & NDR_IN) {
11070                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
11071                 if (_ptr_server) {
11072                         NDR_PULL_ALLOC(ndr, r->in.server);
11073                 } else {
11074                         r->in.server = NULL;
11075                 }
11076                 if (r->in.server) {
11077                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
11078                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
11079                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
11080                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
11081                 }
11082                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11083                         NDR_PULL_ALLOC(ndr, r->in.account);
11084                 }
11085                 _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
11086                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);
11087                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
11088                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);
11089                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_password));
11090                 if (_ptr_nt_password) {
11091                         NDR_PULL_ALLOC(ndr, r->in.nt_password);
11092                 } else {
11093                         r->in.nt_password = NULL;
11094                 }
11095                 if (r->in.nt_password) {
11096                         _mem_save_nt_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
11097                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_password, 0);
11098                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
11099                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_password_0, 0);
11100                 }
11101                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_verifier));
11102                 if (_ptr_nt_verifier) {
11103                         NDR_PULL_ALLOC(ndr, r->in.nt_verifier);
11104                 } else {
11105                         r->in.nt_verifier = NULL;
11106                 }
11107                 if (r->in.nt_verifier) {
11108                         _mem_save_nt_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
11109                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_verifier, 0);
11110                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
11111                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_verifier_0, 0);
11112                 }
11113                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_change));
11114                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_password));
11115                 if (_ptr_lm_password) {
11116                         NDR_PULL_ALLOC(ndr, r->in.lm_password);
11117                 } else {
11118                         r->in.lm_password = NULL;
11119                 }
11120                 if (r->in.lm_password) {
11121                         _mem_save_lm_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
11122                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_password, 0);
11123                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
11124                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_password_0, 0);
11125                 }
11126                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_verifier));
11127                 if (_ptr_lm_verifier) {
11128                         NDR_PULL_ALLOC(ndr, r->in.lm_verifier);
11129                 } else {
11130                         r->in.lm_verifier = NULL;
11131                 }
11132                 if (r->in.lm_verifier) {
11133                         _mem_save_lm_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
11134                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_verifier, 0);
11135                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
11136                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_verifier_0, 0);
11137                 }
11138         }
11139         if (flags & NDR_OUT) {
11140                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11141         }
11142         return NDR_ERR_SUCCESS;
11143 }
11144
11145 _PUBLIC_ void ndr_print_samr_ChangePasswordUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser2 *r)
11146 {
11147         ndr_print_struct(ndr, name, "samr_ChangePasswordUser2");
11148         ndr->depth++;
11149         if (flags & NDR_SET_VALUES) {
11150                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11151         }
11152         if (flags & NDR_IN) {
11153                 ndr_print_struct(ndr, "in", "samr_ChangePasswordUser2");
11154                 ndr->depth++;
11155                 ndr_print_ptr(ndr, "server", r->in.server);
11156                 ndr->depth++;
11157                 if (r->in.server) {
11158                         ndr_print_lsa_String(ndr, "server", r->in.server);
11159                 }
11160                 ndr->depth--;
11161                 ndr_print_ptr(ndr, "account", r->in.account);
11162                 ndr->depth++;
11163                 ndr_print_lsa_String(ndr, "account", r->in.account);
11164                 ndr->depth--;
11165                 ndr_print_ptr(ndr, "nt_password", r->in.nt_password);
11166                 ndr->depth++;
11167                 if (r->in.nt_password) {
11168                         ndr_print_samr_CryptPassword(ndr, "nt_password", r->in.nt_password);
11169                 }
11170                 ndr->depth--;
11171                 ndr_print_ptr(ndr, "nt_verifier", r->in.nt_verifier);
11172                 ndr->depth++;
11173                 if (r->in.nt_verifier) {
11174                         ndr_print_samr_Password(ndr, "nt_verifier", r->in.nt_verifier);
11175                 }
11176                 ndr->depth--;
11177                 ndr_print_uint8(ndr, "lm_change", r->in.lm_change);
11178                 ndr_print_ptr(ndr, "lm_password", r->in.lm_password);
11179                 ndr->depth++;
11180                 if (r->in.lm_password) {
11181                         ndr_print_samr_CryptPassword(ndr, "lm_password", r->in.lm_password);
11182                 }
11183                 ndr->depth--;
11184                 ndr_print_ptr(ndr, "lm_verifier", r->in.lm_verifier);
11185                 ndr->depth++;
11186                 if (r->in.lm_verifier) {
11187                         ndr_print_samr_Password(ndr, "lm_verifier", r->in.lm_verifier);
11188                 }
11189                 ndr->depth--;
11190                 ndr->depth--;
11191         }
11192         if (flags & NDR_OUT) {
11193                 ndr_print_struct(ndr, "out", "samr_ChangePasswordUser2");
11194                 ndr->depth++;
11195                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11196                 ndr->depth--;
11197         }
11198         ndr->depth--;
11199 }
11200
11201 static enum ndr_err_code ndr_push_samr_GetDomPwInfo(struct ndr_push *ndr, int flags, const struct samr_GetDomPwInfo *r)
11202 {
11203         if (flags & NDR_IN) {
11204                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.domain_name));
11205                 if (r->in.domain_name) {
11206                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
11207                 }
11208         }
11209         if (flags & NDR_OUT) {
11210                 if (r->out.info == NULL) {
11211                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11212                 }
11213                 NDR_CHECK(ndr_push_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
11214                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11215         }
11216         return NDR_ERR_SUCCESS;
11217 }
11218
11219 static enum ndr_err_code ndr_pull_samr_GetDomPwInfo(struct ndr_pull *ndr, int flags, struct samr_GetDomPwInfo *r)
11220 {
11221         uint32_t _ptr_domain_name;
11222         TALLOC_CTX *_mem_save_domain_name_0;
11223         TALLOC_CTX *_mem_save_info_0;
11224         if (flags & NDR_IN) {
11225                 ZERO_STRUCT(r->out);
11226
11227                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
11228                 if (_ptr_domain_name) {
11229                         NDR_PULL_ALLOC(ndr, r->in.domain_name);
11230                 } else {
11231                         r->in.domain_name = NULL;
11232                 }
11233                 if (r->in.domain_name) {
11234                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11235                         NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_name, 0);
11236                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
11237                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
11238                 }
11239                 NDR_PULL_ALLOC(ndr, r->out.info);
11240                 ZERO_STRUCTP(r->out.info);
11241         }
11242         if (flags & NDR_OUT) {
11243                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11244                         NDR_PULL_ALLOC(ndr, r->out.info);
11245                 }
11246                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
11247                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
11248                 NDR_CHECK(ndr_pull_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
11249                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
11250                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11251         }
11252         return NDR_ERR_SUCCESS;
11253 }
11254
11255 _PUBLIC_ void ndr_print_samr_GetDomPwInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDomPwInfo *r)
11256 {
11257         ndr_print_struct(ndr, name, "samr_GetDomPwInfo");
11258         ndr->depth++;
11259         if (flags & NDR_SET_VALUES) {
11260                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11261         }
11262         if (flags & NDR_IN) {
11263                 ndr_print_struct(ndr, "in", "samr_GetDomPwInfo");
11264                 ndr->depth++;
11265                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
11266                 ndr->depth++;
11267                 if (r->in.domain_name) {
11268                         ndr_print_lsa_String(ndr, "domain_name", r->in.domain_name);
11269                 }
11270                 ndr->depth--;
11271                 ndr->depth--;
11272         }
11273         if (flags & NDR_OUT) {
11274                 ndr_print_struct(ndr, "out", "samr_GetDomPwInfo");
11275                 ndr->depth++;
11276                 ndr_print_ptr(ndr, "info", r->out.info);
11277                 ndr->depth++;
11278                 ndr_print_samr_PwInfo(ndr, "info", r->out.info);
11279                 ndr->depth--;
11280                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11281                 ndr->depth--;
11282         }
11283         ndr->depth--;
11284 }
11285
11286 static enum ndr_err_code ndr_push_samr_Connect2(struct ndr_push *ndr, int flags, const struct samr_Connect2 *r)
11287 {
11288         if (flags & NDR_IN) {
11289                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
11290                 if (r->in.system_name) {
11291                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11292                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11293                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11294                         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));
11295                 }
11296                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
11297         }
11298         if (flags & NDR_OUT) {
11299                 if (r->out.connect_handle == NULL) {
11300                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11301                 }
11302                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11303                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11304         }
11305         return NDR_ERR_SUCCESS;
11306 }
11307
11308 static enum ndr_err_code ndr_pull_samr_Connect2(struct ndr_pull *ndr, int flags, struct samr_Connect2 *r)
11309 {
11310         uint32_t _ptr_system_name;
11311         uint32_t size_system_name_1 = 0;
11312         uint32_t length_system_name_1 = 0;
11313         TALLOC_CTX *_mem_save_system_name_0;
11314         TALLOC_CTX *_mem_save_connect_handle_0;
11315         if (flags & NDR_IN) {
11316                 ZERO_STRUCT(r->out);
11317
11318                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
11319                 if (_ptr_system_name) {
11320                         NDR_PULL_ALLOC(ndr, r->in.system_name);
11321                 } else {
11322                         r->in.system_name = NULL;
11323                 }
11324                 if (r->in.system_name) {
11325                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11326                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
11327                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
11328                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
11329                         size_system_name_1 = ndr_get_array_size(ndr, &r->in.system_name);
11330                         length_system_name_1 = ndr_get_array_length(ndr, &r->in.system_name);
11331                         if (length_system_name_1 > size_system_name_1) {
11332                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_system_name_1, length_system_name_1);
11333                         }
11334                         NDR_CHECK(ndr_check_string_terminator(ndr, length_system_name_1, sizeof(uint16_t)));
11335                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, length_system_name_1, sizeof(uint16_t), CH_UTF16));
11336                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
11337                 }
11338                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
11339                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11340                 ZERO_STRUCTP(r->out.connect_handle);
11341         }
11342         if (flags & NDR_OUT) {
11343                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11344                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11345                 }
11346                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11347                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
11348                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11349                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
11350                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11351         }
11352         return NDR_ERR_SUCCESS;
11353 }
11354
11355 _PUBLIC_ void ndr_print_samr_Connect2(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect2 *r)
11356 {
11357         ndr_print_struct(ndr, name, "samr_Connect2");
11358         ndr->depth++;
11359         if (flags & NDR_SET_VALUES) {
11360                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11361         }
11362         if (flags & NDR_IN) {
11363                 ndr_print_struct(ndr, "in", "samr_Connect2");
11364                 ndr->depth++;
11365                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
11366                 ndr->depth++;
11367                 if (r->in.system_name) {
11368                         ndr_print_string(ndr, "system_name", r->in.system_name);
11369                 }
11370                 ndr->depth--;
11371                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
11372                 ndr->depth--;
11373         }
11374         if (flags & NDR_OUT) {
11375                 ndr_print_struct(ndr, "out", "samr_Connect2");
11376                 ndr->depth++;
11377                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
11378                 ndr->depth++;
11379                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
11380                 ndr->depth--;
11381                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11382                 ndr->depth--;
11383         }
11384         ndr->depth--;
11385 }
11386
11387 _PUBLIC_ enum ndr_err_code ndr_push_samr_SetUserInfo2(struct ndr_push *ndr, int flags, const struct samr_SetUserInfo2 *r)
11388 {
11389         if (flags & NDR_IN) {
11390                 if (r->in.user_handle == NULL) {
11391                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11392                 }
11393                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
11394                 NDR_CHECK(ndr_push_samr_UserInfoLevel(ndr, NDR_SCALARS, r->in.level));
11395                 if (r->in.info == NULL) {
11396                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11397                 }
11398                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
11399                 NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
11400         }
11401         if (flags & NDR_OUT) {
11402                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11403         }
11404         return NDR_ERR_SUCCESS;
11405 }
11406
11407 _PUBLIC_ enum ndr_err_code ndr_pull_samr_SetUserInfo2(struct ndr_pull *ndr, int flags, struct samr_SetUserInfo2 *r)
11408 {
11409         TALLOC_CTX *_mem_save_user_handle_0;
11410         TALLOC_CTX *_mem_save_info_0;
11411         if (flags & NDR_IN) {
11412                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11413                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
11414                 }
11415                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11416                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
11417                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
11418                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
11419                 NDR_CHECK(ndr_pull_samr_UserInfoLevel(ndr, NDR_SCALARS, &r->in.level));
11420                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11421                         NDR_PULL_ALLOC(ndr, r->in.info);
11422                 }
11423                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
11424                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
11425                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
11426                 NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
11427                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
11428         }
11429         if (flags & NDR_OUT) {
11430                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11431         }
11432         return NDR_ERR_SUCCESS;
11433 }
11434
11435 _PUBLIC_ void ndr_print_samr_SetUserInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetUserInfo2 *r)
11436 {
11437         ndr_print_struct(ndr, name, "samr_SetUserInfo2");
11438         ndr->depth++;
11439         if (flags & NDR_SET_VALUES) {
11440                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11441         }
11442         if (flags & NDR_IN) {
11443                 ndr_print_struct(ndr, "in", "samr_SetUserInfo2");
11444                 ndr->depth++;
11445                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
11446                 ndr->depth++;
11447                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
11448                 ndr->depth--;
11449                 ndr_print_samr_UserInfoLevel(ndr, "level", r->in.level);
11450                 ndr_print_ptr(ndr, "info", r->in.info);
11451                 ndr->depth++;
11452                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
11453                 ndr_print_samr_UserInfo(ndr, "info", r->in.info);
11454                 ndr->depth--;
11455                 ndr->depth--;
11456         }
11457         if (flags & NDR_OUT) {
11458                 ndr_print_struct(ndr, "out", "samr_SetUserInfo2");
11459                 ndr->depth++;
11460                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11461                 ndr->depth--;
11462         }
11463         ndr->depth--;
11464 }
11465
11466 static enum ndr_err_code ndr_push_samr_SetBootKeyInformation(struct ndr_push *ndr, int flags, const struct samr_SetBootKeyInformation *r)
11467 {
11468         if (flags & NDR_IN) {
11469                 if (r->in.connect_handle == NULL) {
11470                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11471                 }
11472                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
11473                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
11474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
11475                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown3));
11476         }
11477         if (flags & NDR_OUT) {
11478                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11479         }
11480         return NDR_ERR_SUCCESS;
11481 }
11482
11483 static enum ndr_err_code ndr_pull_samr_SetBootKeyInformation(struct ndr_pull *ndr, int flags, struct samr_SetBootKeyInformation *r)
11484 {
11485         TALLOC_CTX *_mem_save_connect_handle_0;
11486         if (flags & NDR_IN) {
11487                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11488                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
11489                 }
11490                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11491                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
11492                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
11493                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
11494                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
11495                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
11496                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown3));
11497         }
11498         if (flags & NDR_OUT) {
11499                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11500         }
11501         return NDR_ERR_SUCCESS;
11502 }
11503
11504 _PUBLIC_ void ndr_print_samr_SetBootKeyInformation(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetBootKeyInformation *r)
11505 {
11506         ndr_print_struct(ndr, name, "samr_SetBootKeyInformation");
11507         ndr->depth++;
11508         if (flags & NDR_SET_VALUES) {
11509                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11510         }
11511         if (flags & NDR_IN) {
11512                 ndr_print_struct(ndr, "in", "samr_SetBootKeyInformation");
11513                 ndr->depth++;
11514                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
11515                 ndr->depth++;
11516                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
11517                 ndr->depth--;
11518                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
11519                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
11520                 ndr_print_uint32(ndr, "unknown3", r->in.unknown3);
11521                 ndr->depth--;
11522         }
11523         if (flags & NDR_OUT) {
11524                 ndr_print_struct(ndr, "out", "samr_SetBootKeyInformation");
11525                 ndr->depth++;
11526                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11527                 ndr->depth--;
11528         }
11529         ndr->depth--;
11530 }
11531
11532 static enum ndr_err_code ndr_push_samr_GetBootKeyInformation(struct ndr_push *ndr, int flags, const struct samr_GetBootKeyInformation *r)
11533 {
11534         if (flags & NDR_IN) {
11535                 if (r->in.domain_handle == NULL) {
11536                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11537                 }
11538                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
11539         }
11540         if (flags & NDR_OUT) {
11541                 if (r->out.unknown == NULL) {
11542                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11543                 }
11544                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.unknown));
11545                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11546         }
11547         return NDR_ERR_SUCCESS;
11548 }
11549
11550 static enum ndr_err_code ndr_pull_samr_GetBootKeyInformation(struct ndr_pull *ndr, int flags, struct samr_GetBootKeyInformation *r)
11551 {
11552         TALLOC_CTX *_mem_save_domain_handle_0;
11553         TALLOC_CTX *_mem_save_unknown_0;
11554         if (flags & NDR_IN) {
11555                 ZERO_STRUCT(r->out);
11556
11557                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11558                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
11559                 }
11560                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11561                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
11562                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
11563                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
11564                 NDR_PULL_ALLOC(ndr, r->out.unknown);
11565                 ZERO_STRUCTP(r->out.unknown);
11566         }
11567         if (flags & NDR_OUT) {
11568                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11569                         NDR_PULL_ALLOC(ndr, r->out.unknown);
11570                 }
11571                 _mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);
11572                 NDR_PULL_SET_MEM_CTX(ndr, r->out.unknown, LIBNDR_FLAG_REF_ALLOC);
11573                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.unknown));
11574                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, LIBNDR_FLAG_REF_ALLOC);
11575                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11576         }
11577         return NDR_ERR_SUCCESS;
11578 }
11579
11580 _PUBLIC_ void ndr_print_samr_GetBootKeyInformation(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetBootKeyInformation *r)
11581 {
11582         ndr_print_struct(ndr, name, "samr_GetBootKeyInformation");
11583         ndr->depth++;
11584         if (flags & NDR_SET_VALUES) {
11585                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11586         }
11587         if (flags & NDR_IN) {
11588                 ndr_print_struct(ndr, "in", "samr_GetBootKeyInformation");
11589                 ndr->depth++;
11590                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
11591                 ndr->depth++;
11592                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
11593                 ndr->depth--;
11594                 ndr->depth--;
11595         }
11596         if (flags & NDR_OUT) {
11597                 ndr_print_struct(ndr, "out", "samr_GetBootKeyInformation");
11598                 ndr->depth++;
11599                 ndr_print_ptr(ndr, "unknown", r->out.unknown);
11600                 ndr->depth++;
11601                 ndr_print_uint32(ndr, "unknown", *r->out.unknown);
11602                 ndr->depth--;
11603                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11604                 ndr->depth--;
11605         }
11606         ndr->depth--;
11607 }
11608
11609 static enum ndr_err_code ndr_push_samr_Connect3(struct ndr_push *ndr, int flags, const struct samr_Connect3 *r)
11610 {
11611         if (flags & NDR_IN) {
11612                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
11613                 if (r->in.system_name) {
11614                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11615                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11616                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11617                         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));
11618                 }
11619                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
11620                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
11621         }
11622         if (flags & NDR_OUT) {
11623                 if (r->out.connect_handle == NULL) {
11624                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11625                 }
11626                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11627                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11628         }
11629         return NDR_ERR_SUCCESS;
11630 }
11631
11632 static enum ndr_err_code ndr_pull_samr_Connect3(struct ndr_pull *ndr, int flags, struct samr_Connect3 *r)
11633 {
11634         uint32_t _ptr_system_name;
11635         uint32_t size_system_name_1 = 0;
11636         uint32_t length_system_name_1 = 0;
11637         TALLOC_CTX *_mem_save_system_name_0;
11638         TALLOC_CTX *_mem_save_connect_handle_0;
11639         if (flags & NDR_IN) {
11640                 ZERO_STRUCT(r->out);
11641
11642                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
11643                 if (_ptr_system_name) {
11644                         NDR_PULL_ALLOC(ndr, r->in.system_name);
11645                 } else {
11646                         r->in.system_name = NULL;
11647                 }
11648                 if (r->in.system_name) {
11649                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11650                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
11651                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
11652                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
11653                         size_system_name_1 = ndr_get_array_size(ndr, &r->in.system_name);
11654                         length_system_name_1 = ndr_get_array_length(ndr, &r->in.system_name);
11655                         if (length_system_name_1 > size_system_name_1) {
11656                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_system_name_1, length_system_name_1);
11657                         }
11658                         NDR_CHECK(ndr_check_string_terminator(ndr, length_system_name_1, sizeof(uint16_t)));
11659                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, length_system_name_1, sizeof(uint16_t), CH_UTF16));
11660                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
11661                 }
11662                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
11663                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
11664                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11665                 ZERO_STRUCTP(r->out.connect_handle);
11666         }
11667         if (flags & NDR_OUT) {
11668                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11669                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11670                 }
11671                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11672                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
11673                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11674                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
11675                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11676         }
11677         return NDR_ERR_SUCCESS;
11678 }
11679
11680 _PUBLIC_ void ndr_print_samr_Connect3(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect3 *r)
11681 {
11682         ndr_print_struct(ndr, name, "samr_Connect3");
11683         ndr->depth++;
11684         if (flags & NDR_SET_VALUES) {
11685                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11686         }
11687         if (flags & NDR_IN) {
11688                 ndr_print_struct(ndr, "in", "samr_Connect3");
11689                 ndr->depth++;
11690                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
11691                 ndr->depth++;
11692                 if (r->in.system_name) {
11693                         ndr_print_string(ndr, "system_name", r->in.system_name);
11694                 }
11695                 ndr->depth--;
11696                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
11697                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
11698                 ndr->depth--;
11699         }
11700         if (flags & NDR_OUT) {
11701                 ndr_print_struct(ndr, "out", "samr_Connect3");
11702                 ndr->depth++;
11703                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
11704                 ndr->depth++;
11705                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
11706                 ndr->depth--;
11707                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11708                 ndr->depth--;
11709         }
11710         ndr->depth--;
11711 }
11712
11713 static enum ndr_err_code ndr_push_samr_Connect4(struct ndr_push *ndr, int flags, const struct samr_Connect4 *r)
11714 {
11715         if (flags & NDR_IN) {
11716                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
11717                 if (r->in.system_name) {
11718                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11719                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11720                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11721                         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));
11722                 }
11723                 NDR_CHECK(ndr_push_samr_ConnectVersion(ndr, NDR_SCALARS, r->in.client_version));
11724                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
11725         }
11726         if (flags & NDR_OUT) {
11727                 if (r->out.connect_handle == NULL) {
11728                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11729                 }
11730                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11731                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11732         }
11733         return NDR_ERR_SUCCESS;
11734 }
11735
11736 static enum ndr_err_code ndr_pull_samr_Connect4(struct ndr_pull *ndr, int flags, struct samr_Connect4 *r)
11737 {
11738         uint32_t _ptr_system_name;
11739         uint32_t size_system_name_1 = 0;
11740         uint32_t length_system_name_1 = 0;
11741         TALLOC_CTX *_mem_save_system_name_0;
11742         TALLOC_CTX *_mem_save_connect_handle_0;
11743         if (flags & NDR_IN) {
11744                 ZERO_STRUCT(r->out);
11745
11746                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
11747                 if (_ptr_system_name) {
11748                         NDR_PULL_ALLOC(ndr, r->in.system_name);
11749                 } else {
11750                         r->in.system_name = NULL;
11751                 }
11752                 if (r->in.system_name) {
11753                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11754                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
11755                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
11756                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
11757                         size_system_name_1 = ndr_get_array_size(ndr, &r->in.system_name);
11758                         length_system_name_1 = ndr_get_array_length(ndr, &r->in.system_name);
11759                         if (length_system_name_1 > size_system_name_1) {
11760                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_system_name_1, length_system_name_1);
11761                         }
11762                         NDR_CHECK(ndr_check_string_terminator(ndr, length_system_name_1, sizeof(uint16_t)));
11763                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, length_system_name_1, sizeof(uint16_t), CH_UTF16));
11764                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
11765                 }
11766                 NDR_CHECK(ndr_pull_samr_ConnectVersion(ndr, NDR_SCALARS, &r->in.client_version));
11767                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
11768                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11769                 ZERO_STRUCTP(r->out.connect_handle);
11770         }
11771         if (flags & NDR_OUT) {
11772                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11773                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11774                 }
11775                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11776                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
11777                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11778                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
11779                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11780         }
11781         return NDR_ERR_SUCCESS;
11782 }
11783
11784 _PUBLIC_ void ndr_print_samr_Connect4(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect4 *r)
11785 {
11786         ndr_print_struct(ndr, name, "samr_Connect4");
11787         ndr->depth++;
11788         if (flags & NDR_SET_VALUES) {
11789                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11790         }
11791         if (flags & NDR_IN) {
11792                 ndr_print_struct(ndr, "in", "samr_Connect4");
11793                 ndr->depth++;
11794                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
11795                 ndr->depth++;
11796                 if (r->in.system_name) {
11797                         ndr_print_string(ndr, "system_name", r->in.system_name);
11798                 }
11799                 ndr->depth--;
11800                 ndr_print_samr_ConnectVersion(ndr, "client_version", r->in.client_version);
11801                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
11802                 ndr->depth--;
11803         }
11804         if (flags & NDR_OUT) {
11805                 ndr_print_struct(ndr, "out", "samr_Connect4");
11806                 ndr->depth++;
11807                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
11808                 ndr->depth++;
11809                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
11810                 ndr->depth--;
11811                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11812                 ndr->depth--;
11813         }
11814         ndr->depth--;
11815 }
11816
11817 static enum ndr_err_code ndr_push_samr_ChangePasswordUser3(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser3 *r)
11818 {
11819         if (flags & NDR_IN) {
11820                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
11821                 if (r->in.server) {
11822                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
11823                 }
11824                 if (r->in.account == NULL) {
11825                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11826                 }
11827                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
11828                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_password));
11829                 if (r->in.nt_password) {
11830                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
11831                 }
11832                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_verifier));
11833                 if (r->in.nt_verifier) {
11834                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
11835                 }
11836                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_change));
11837                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_password));
11838                 if (r->in.lm_password) {
11839                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
11840                 }
11841                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_verifier));
11842                 if (r->in.lm_verifier) {
11843                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
11844                 }
11845                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password3));
11846                 if (r->in.password3) {
11847                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password3));
11848                 }
11849         }
11850         if (flags & NDR_OUT) {
11851                 if (r->out.dominfo == NULL) {
11852                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11853                 }
11854                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.dominfo));
11855                 if (*r->out.dominfo) {
11856                         NDR_CHECK(ndr_push_samr_DomInfo1(ndr, NDR_SCALARS, *r->out.dominfo));
11857                 }
11858                 if (r->out.reject == NULL) {
11859                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11860                 }
11861                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.reject));
11862                 if (*r->out.reject) {
11863                         NDR_CHECK(ndr_push_samr_ChangeReject(ndr, NDR_SCALARS, *r->out.reject));
11864                 }
11865                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11866         }
11867         return NDR_ERR_SUCCESS;
11868 }
11869
11870 static enum ndr_err_code ndr_pull_samr_ChangePasswordUser3(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser3 *r)
11871 {
11872         uint32_t _ptr_server;
11873         uint32_t _ptr_nt_password;
11874         uint32_t _ptr_nt_verifier;
11875         uint32_t _ptr_lm_password;
11876         uint32_t _ptr_lm_verifier;
11877         uint32_t _ptr_password3;
11878         uint32_t _ptr_dominfo;
11879         uint32_t _ptr_reject;
11880         TALLOC_CTX *_mem_save_server_0;
11881         TALLOC_CTX *_mem_save_account_0;
11882         TALLOC_CTX *_mem_save_nt_password_0;
11883         TALLOC_CTX *_mem_save_nt_verifier_0;
11884         TALLOC_CTX *_mem_save_lm_password_0;
11885         TALLOC_CTX *_mem_save_lm_verifier_0;
11886         TALLOC_CTX *_mem_save_password3_0;
11887         TALLOC_CTX *_mem_save_dominfo_0;
11888         TALLOC_CTX *_mem_save_dominfo_1;
11889         TALLOC_CTX *_mem_save_reject_0;
11890         TALLOC_CTX *_mem_save_reject_1;
11891         if (flags & NDR_IN) {
11892                 ZERO_STRUCT(r->out);
11893
11894                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
11895                 if (_ptr_server) {
11896                         NDR_PULL_ALLOC(ndr, r->in.server);
11897                 } else {
11898                         r->in.server = NULL;
11899                 }
11900                 if (r->in.server) {
11901                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
11902                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
11903                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
11904                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
11905                 }
11906                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11907                         NDR_PULL_ALLOC(ndr, r->in.account);
11908                 }
11909                 _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
11910                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);
11911                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
11912                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);
11913                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_password));
11914                 if (_ptr_nt_password) {
11915                         NDR_PULL_ALLOC(ndr, r->in.nt_password);
11916                 } else {
11917                         r->in.nt_password = NULL;
11918                 }
11919                 if (r->in.nt_password) {
11920                         _mem_save_nt_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
11921                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_password, 0);
11922                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
11923                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_password_0, 0);
11924                 }
11925                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_verifier));
11926                 if (_ptr_nt_verifier) {
11927                         NDR_PULL_ALLOC(ndr, r->in.nt_verifier);
11928                 } else {
11929                         r->in.nt_verifier = NULL;
11930                 }
11931                 if (r->in.nt_verifier) {
11932                         _mem_save_nt_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
11933                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_verifier, 0);
11934                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
11935                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_verifier_0, 0);
11936                 }
11937                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_change));
11938                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_password));
11939                 if (_ptr_lm_password) {
11940                         NDR_PULL_ALLOC(ndr, r->in.lm_password);
11941                 } else {
11942                         r->in.lm_password = NULL;
11943                 }
11944                 if (r->in.lm_password) {
11945                         _mem_save_lm_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
11946                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_password, 0);
11947                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
11948                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_password_0, 0);
11949                 }
11950                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_verifier));
11951                 if (_ptr_lm_verifier) {
11952                         NDR_PULL_ALLOC(ndr, r->in.lm_verifier);
11953                 } else {
11954                         r->in.lm_verifier = NULL;
11955                 }
11956                 if (r->in.lm_verifier) {
11957                         _mem_save_lm_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
11958                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_verifier, 0);
11959                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
11960                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_verifier_0, 0);
11961                 }
11962                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password3));
11963                 if (_ptr_password3) {
11964                         NDR_PULL_ALLOC(ndr, r->in.password3);
11965                 } else {
11966                         r->in.password3 = NULL;
11967                 }
11968                 if (r->in.password3) {
11969                         _mem_save_password3_0 = NDR_PULL_GET_MEM_CTX(ndr);
11970                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password3, 0);
11971                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password3));
11972                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password3_0, 0);
11973                 }
11974                 NDR_PULL_ALLOC(ndr, r->out.dominfo);
11975                 ZERO_STRUCTP(r->out.dominfo);
11976                 NDR_PULL_ALLOC(ndr, r->out.reject);
11977                 ZERO_STRUCTP(r->out.reject);
11978         }
11979         if (flags & NDR_OUT) {
11980                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11981                         NDR_PULL_ALLOC(ndr, r->out.dominfo);
11982                 }
11983                 _mem_save_dominfo_0 = NDR_PULL_GET_MEM_CTX(ndr);
11984                 NDR_PULL_SET_MEM_CTX(ndr, r->out.dominfo, LIBNDR_FLAG_REF_ALLOC);
11985                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dominfo));
11986                 if (_ptr_dominfo) {
11987                         NDR_PULL_ALLOC(ndr, *r->out.dominfo);
11988                 } else {
11989                         *r->out.dominfo = NULL;
11990                 }
11991                 if (*r->out.dominfo) {
11992                         _mem_save_dominfo_1 = NDR_PULL_GET_MEM_CTX(ndr);
11993                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.dominfo, 0);
11994                         NDR_CHECK(ndr_pull_samr_DomInfo1(ndr, NDR_SCALARS, *r->out.dominfo));
11995                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dominfo_1, 0);
11996                 }
11997                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dominfo_0, LIBNDR_FLAG_REF_ALLOC);
11998                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11999                         NDR_PULL_ALLOC(ndr, r->out.reject);
12000                 }
12001                 _mem_save_reject_0 = NDR_PULL_GET_MEM_CTX(ndr);
12002                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reject, LIBNDR_FLAG_REF_ALLOC);
12003                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_reject));
12004                 if (_ptr_reject) {
12005                         NDR_PULL_ALLOC(ndr, *r->out.reject);
12006                 } else {
12007                         *r->out.reject = NULL;
12008                 }
12009                 if (*r->out.reject) {
12010                         _mem_save_reject_1 = NDR_PULL_GET_MEM_CTX(ndr);
12011                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.reject, 0);
12012                         NDR_CHECK(ndr_pull_samr_ChangeReject(ndr, NDR_SCALARS, *r->out.reject));
12013                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reject_1, 0);
12014                 }
12015                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reject_0, LIBNDR_FLAG_REF_ALLOC);
12016                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12017         }
12018         return NDR_ERR_SUCCESS;
12019 }
12020
12021 _PUBLIC_ void ndr_print_samr_ChangePasswordUser3(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser3 *r)
12022 {
12023         ndr_print_struct(ndr, name, "samr_ChangePasswordUser3");
12024         ndr->depth++;
12025         if (flags & NDR_SET_VALUES) {
12026                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12027         }
12028         if (flags & NDR_IN) {
12029                 ndr_print_struct(ndr, "in", "samr_ChangePasswordUser3");
12030                 ndr->depth++;
12031                 ndr_print_ptr(ndr, "server", r->in.server);
12032                 ndr->depth++;
12033                 if (r->in.server) {
12034                         ndr_print_lsa_String(ndr, "server", r->in.server);
12035                 }
12036                 ndr->depth--;
12037                 ndr_print_ptr(ndr, "account", r->in.account);
12038                 ndr->depth++;
12039                 ndr_print_lsa_String(ndr, "account", r->in.account);
12040                 ndr->depth--;
12041                 ndr_print_ptr(ndr, "nt_password", r->in.nt_password);
12042                 ndr->depth++;
12043                 if (r->in.nt_password) {
12044                         ndr_print_samr_CryptPassword(ndr, "nt_password", r->in.nt_password);
12045                 }
12046                 ndr->depth--;
12047                 ndr_print_ptr(ndr, "nt_verifier", r->in.nt_verifier);
12048                 ndr->depth++;
12049                 if (r->in.nt_verifier) {
12050                         ndr_print_samr_Password(ndr, "nt_verifier", r->in.nt_verifier);
12051                 }
12052                 ndr->depth--;
12053                 ndr_print_uint8(ndr, "lm_change", r->in.lm_change);
12054                 ndr_print_ptr(ndr, "lm_password", r->in.lm_password);
12055                 ndr->depth++;
12056                 if (r->in.lm_password) {
12057                         ndr_print_samr_CryptPassword(ndr, "lm_password", r->in.lm_password);
12058                 }
12059                 ndr->depth--;
12060                 ndr_print_ptr(ndr, "lm_verifier", r->in.lm_verifier);
12061                 ndr->depth++;
12062                 if (r->in.lm_verifier) {
12063                         ndr_print_samr_Password(ndr, "lm_verifier", r->in.lm_verifier);
12064                 }
12065                 ndr->depth--;
12066                 ndr_print_ptr(ndr, "password3", r->in.password3);
12067                 ndr->depth++;
12068                 if (r->in.password3) {
12069                         ndr_print_samr_CryptPassword(ndr, "password3", r->in.password3);
12070                 }
12071                 ndr->depth--;
12072                 ndr->depth--;
12073         }
12074         if (flags & NDR_OUT) {
12075                 ndr_print_struct(ndr, "out", "samr_ChangePasswordUser3");
12076                 ndr->depth++;
12077                 ndr_print_ptr(ndr, "dominfo", r->out.dominfo);
12078                 ndr->depth++;
12079                 ndr_print_ptr(ndr, "dominfo", *r->out.dominfo);
12080                 ndr->depth++;
12081                 if (*r->out.dominfo) {
12082                         ndr_print_samr_DomInfo1(ndr, "dominfo", *r->out.dominfo);
12083                 }
12084                 ndr->depth--;
12085                 ndr->depth--;
12086                 ndr_print_ptr(ndr, "reject", r->out.reject);
12087                 ndr->depth++;
12088                 ndr_print_ptr(ndr, "reject", *r->out.reject);
12089                 ndr->depth++;
12090                 if (*r->out.reject) {
12091                         ndr_print_samr_ChangeReject(ndr, "reject", *r->out.reject);
12092                 }
12093                 ndr->depth--;
12094                 ndr->depth--;
12095                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12096                 ndr->depth--;
12097         }
12098         ndr->depth--;
12099 }
12100
12101 _PUBLIC_ enum ndr_err_code ndr_push_samr_Connect5(struct ndr_push *ndr, int flags, const struct samr_Connect5 *r)
12102 {
12103         if (flags & NDR_IN) {
12104                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
12105                 if (r->in.system_name) {
12106                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
12107                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
12108                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
12109                         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));
12110                 }
12111                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
12112                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level_in));
12113                 if (r->in.info_in == NULL) {
12114                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12115                 }
12116                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info_in, r->in.level_in));
12117                 NDR_CHECK(ndr_push_samr_ConnectInfo(ndr, NDR_SCALARS, r->in.info_in));
12118         }
12119         if (flags & NDR_OUT) {
12120                 if (r->out.level_out == NULL) {
12121                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12122                 }
12123                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
12124                 if (r->out.info_out == NULL) {
12125                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12126                 }
12127                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info_out, *r->out.level_out));
12128                 NDR_CHECK(ndr_push_samr_ConnectInfo(ndr, NDR_SCALARS, r->out.info_out));
12129                 if (r->out.connect_handle == NULL) {
12130                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12131                 }
12132                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
12133                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12134         }
12135         return NDR_ERR_SUCCESS;
12136 }
12137
12138 _PUBLIC_ enum ndr_err_code ndr_pull_samr_Connect5(struct ndr_pull *ndr, int flags, struct samr_Connect5 *r)
12139 {
12140         uint32_t _ptr_system_name;
12141         uint32_t size_system_name_1 = 0;
12142         uint32_t length_system_name_1 = 0;
12143         TALLOC_CTX *_mem_save_system_name_0;
12144         TALLOC_CTX *_mem_save_info_in_0;
12145         TALLOC_CTX *_mem_save_level_out_0;
12146         TALLOC_CTX *_mem_save_info_out_0;
12147         TALLOC_CTX *_mem_save_connect_handle_0;
12148         if (flags & NDR_IN) {
12149                 ZERO_STRUCT(r->out);
12150
12151                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
12152                 if (_ptr_system_name) {
12153                         NDR_PULL_ALLOC(ndr, r->in.system_name);
12154                 } else {
12155                         r->in.system_name = NULL;
12156                 }
12157                 if (r->in.system_name) {
12158                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12159                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
12160                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
12161                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
12162                         size_system_name_1 = ndr_get_array_size(ndr, &r->in.system_name);
12163                         length_system_name_1 = ndr_get_array_length(ndr, &r->in.system_name);
12164                         if (length_system_name_1 > size_system_name_1) {
12165                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_system_name_1, length_system_name_1);
12166                         }
12167                         NDR_CHECK(ndr_check_string_terminator(ndr, length_system_name_1, sizeof(uint16_t)));
12168                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, length_system_name_1, sizeof(uint16_t), CH_UTF16));
12169                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
12170                 }
12171                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
12172                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level_in));
12173                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12174                         NDR_PULL_ALLOC(ndr, r->in.info_in);
12175                 }
12176                 _mem_save_info_in_0 = NDR_PULL_GET_MEM_CTX(ndr);
12177                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_in, LIBNDR_FLAG_REF_ALLOC);
12178                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info_in, r->in.level_in));
12179                 NDR_CHECK(ndr_pull_samr_ConnectInfo(ndr, NDR_SCALARS, r->in.info_in));
12180                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_in_0, LIBNDR_FLAG_REF_ALLOC);
12181                 NDR_PULL_ALLOC(ndr, r->out.level_out);
12182                 ZERO_STRUCTP(r->out.level_out);
12183                 NDR_PULL_ALLOC(ndr, r->out.info_out);
12184                 ZERO_STRUCTP(r->out.info_out);
12185                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
12186                 ZERO_STRUCTP(r->out.connect_handle);
12187         }
12188         if (flags & NDR_OUT) {
12189                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12190                         NDR_PULL_ALLOC(ndr, r->out.level_out);
12191                 }
12192                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
12193                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
12194                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
12195                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
12196                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12197                         NDR_PULL_ALLOC(ndr, r->out.info_out);
12198                 }
12199                 _mem_save_info_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
12200                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_out, LIBNDR_FLAG_REF_ALLOC);
12201                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info_out, *r->out.level_out));
12202                 NDR_CHECK(ndr_pull_samr_ConnectInfo(ndr, NDR_SCALARS, r->out.info_out));
12203                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_out_0, LIBNDR_FLAG_REF_ALLOC);
12204                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12205                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
12206                 }
12207                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12208                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
12209                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
12210                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
12211                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12212         }
12213         return NDR_ERR_SUCCESS;
12214 }
12215
12216 _PUBLIC_ void ndr_print_samr_Connect5(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect5 *r)
12217 {
12218         ndr_print_struct(ndr, name, "samr_Connect5");
12219         ndr->depth++;
12220         if (flags & NDR_SET_VALUES) {
12221                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12222         }
12223         if (flags & NDR_IN) {
12224                 ndr_print_struct(ndr, "in", "samr_Connect5");
12225                 ndr->depth++;
12226                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
12227                 ndr->depth++;
12228                 if (r->in.system_name) {
12229                         ndr_print_string(ndr, "system_name", r->in.system_name);
12230                 }
12231                 ndr->depth--;
12232                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
12233                 ndr_print_uint32(ndr, "level_in", r->in.level_in);
12234                 ndr_print_ptr(ndr, "info_in", r->in.info_in);
12235                 ndr->depth++;
12236                 ndr_print_set_switch_value(ndr, r->in.info_in, r->in.level_in);
12237                 ndr_print_samr_ConnectInfo(ndr, "info_in", r->in.info_in);
12238                 ndr->depth--;
12239                 ndr->depth--;
12240         }
12241         if (flags & NDR_OUT) {
12242                 ndr_print_struct(ndr, "out", "samr_Connect5");
12243                 ndr->depth++;
12244                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
12245                 ndr->depth++;
12246                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
12247                 ndr->depth--;
12248                 ndr_print_ptr(ndr, "info_out", r->out.info_out);
12249                 ndr->depth++;
12250                 ndr_print_set_switch_value(ndr, r->out.info_out, *r->out.level_out);
12251                 ndr_print_samr_ConnectInfo(ndr, "info_out", r->out.info_out);
12252                 ndr->depth--;
12253                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
12254                 ndr->depth++;
12255                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
12256                 ndr->depth--;
12257                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12258                 ndr->depth--;
12259         }
12260         ndr->depth--;
12261 }
12262
12263 static enum ndr_err_code ndr_push_samr_RidToSid(struct ndr_push *ndr, int flags, const struct samr_RidToSid *r)
12264 {
12265         if (flags & NDR_IN) {
12266                 if (r->in.domain_handle == NULL) {
12267                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12268                 }
12269                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
12270                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
12271         }
12272         if (flags & NDR_OUT) {
12273                 if (r->out.sid == NULL) {
12274                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12275                 }
12276                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sid));
12277                 if (*r->out.sid) {
12278                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
12279                 }
12280                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12281         }
12282         return NDR_ERR_SUCCESS;
12283 }
12284
12285 static enum ndr_err_code ndr_pull_samr_RidToSid(struct ndr_pull *ndr, int flags, struct samr_RidToSid *r)
12286 {
12287         uint32_t _ptr_sid;
12288         TALLOC_CTX *_mem_save_domain_handle_0;
12289         TALLOC_CTX *_mem_save_sid_0;
12290         TALLOC_CTX *_mem_save_sid_1;
12291         if (flags & NDR_IN) {
12292                 ZERO_STRUCT(r->out);
12293
12294                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12295                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
12296                 }
12297                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12298                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
12299                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
12300                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
12301                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
12302                 NDR_PULL_ALLOC(ndr, r->out.sid);
12303                 ZERO_STRUCTP(r->out.sid);
12304         }
12305         if (flags & NDR_OUT) {
12306                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12307                         NDR_PULL_ALLOC(ndr, r->out.sid);
12308                 }
12309                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
12310                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);
12311                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
12312                 if (_ptr_sid) {
12313                         NDR_PULL_ALLOC(ndr, *r->out.sid);
12314                 } else {
12315                         *r->out.sid = NULL;
12316                 }
12317                 if (*r->out.sid) {
12318                         _mem_save_sid_1 = NDR_PULL_GET_MEM_CTX(ndr);
12319                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sid, 0);
12320                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
12321                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_1, 0);
12322                 }
12323                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
12324                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12325         }
12326         return NDR_ERR_SUCCESS;
12327 }
12328
12329 _PUBLIC_ void ndr_print_samr_RidToSid(struct ndr_print *ndr, const char *name, int flags, const struct samr_RidToSid *r)
12330 {
12331         ndr_print_struct(ndr, name, "samr_RidToSid");
12332         ndr->depth++;
12333         if (flags & NDR_SET_VALUES) {
12334                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12335         }
12336         if (flags & NDR_IN) {
12337                 ndr_print_struct(ndr, "in", "samr_RidToSid");
12338                 ndr->depth++;
12339                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
12340                 ndr->depth++;
12341                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
12342                 ndr->depth--;
12343                 ndr_print_uint32(ndr, "rid", r->in.rid);
12344                 ndr->depth--;
12345         }
12346         if (flags & NDR_OUT) {
12347                 ndr_print_struct(ndr, "out", "samr_RidToSid");
12348                 ndr->depth++;
12349                 ndr_print_ptr(ndr, "sid", r->out.sid);
12350                 ndr->depth++;
12351                 ndr_print_ptr(ndr, "sid", *r->out.sid);
12352                 ndr->depth++;
12353                 if (*r->out.sid) {
12354                         ndr_print_dom_sid2(ndr, "sid", *r->out.sid);
12355                 }
12356                 ndr->depth--;
12357                 ndr->depth--;
12358                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12359                 ndr->depth--;
12360         }
12361         ndr->depth--;
12362 }
12363
12364 static enum ndr_err_code ndr_push_samr_SetDsrmPassword(struct ndr_push *ndr, int flags, const struct samr_SetDsrmPassword *r)
12365 {
12366         if (flags & NDR_IN) {
12367                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.name));
12368                 if (r->in.name) {
12369                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
12370                 }
12371                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
12372                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hash));
12373                 if (r->in.hash) {
12374                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.hash));
12375                 }
12376         }
12377         if (flags & NDR_OUT) {
12378                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12379         }
12380         return NDR_ERR_SUCCESS;
12381 }
12382
12383 static enum ndr_err_code ndr_pull_samr_SetDsrmPassword(struct ndr_pull *ndr, int flags, struct samr_SetDsrmPassword *r)
12384 {
12385         uint32_t _ptr_name;
12386         uint32_t _ptr_hash;
12387         TALLOC_CTX *_mem_save_name_0;
12388         TALLOC_CTX *_mem_save_hash_0;
12389         if (flags & NDR_IN) {
12390                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
12391                 if (_ptr_name) {
12392                         NDR_PULL_ALLOC(ndr, r->in.name);
12393                 } else {
12394                         r->in.name = NULL;
12395                 }
12396                 if (r->in.name) {
12397                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12398                         NDR_PULL_SET_MEM_CTX(ndr, r->in.name, 0);
12399                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
12400                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
12401                 }
12402                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
12403                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hash));
12404                 if (_ptr_hash) {
12405                         NDR_PULL_ALLOC(ndr, r->in.hash);
12406                 } else {
12407                         r->in.hash = NULL;
12408                 }
12409                 if (r->in.hash) {
12410                         _mem_save_hash_0 = NDR_PULL_GET_MEM_CTX(ndr);
12411                         NDR_PULL_SET_MEM_CTX(ndr, r->in.hash, 0);
12412                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.hash));
12413                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hash_0, 0);
12414                 }
12415         }
12416         if (flags & NDR_OUT) {
12417                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12418         }
12419         return NDR_ERR_SUCCESS;
12420 }
12421
12422 _PUBLIC_ void ndr_print_samr_SetDsrmPassword(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetDsrmPassword *r)
12423 {
12424         ndr_print_struct(ndr, name, "samr_SetDsrmPassword");
12425         ndr->depth++;
12426         if (flags & NDR_SET_VALUES) {
12427                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12428         }
12429         if (flags & NDR_IN) {
12430                 ndr_print_struct(ndr, "in", "samr_SetDsrmPassword");
12431                 ndr->depth++;
12432                 ndr_print_ptr(ndr, "name", r->in.name);
12433                 ndr->depth++;
12434                 if (r->in.name) {
12435                         ndr_print_lsa_String(ndr, "name", r->in.name);
12436                 }
12437                 ndr->depth--;
12438                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
12439                 ndr_print_ptr(ndr, "hash", r->in.hash);
12440                 ndr->depth++;
12441                 if (r->in.hash) {
12442                         ndr_print_samr_Password(ndr, "hash", r->in.hash);
12443                 }
12444                 ndr->depth--;
12445                 ndr->depth--;
12446         }
12447         if (flags & NDR_OUT) {
12448                 ndr_print_struct(ndr, "out", "samr_SetDsrmPassword");
12449                 ndr->depth++;
12450                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12451                 ndr->depth--;
12452         }
12453         ndr->depth--;
12454 }
12455
12456 static enum ndr_err_code ndr_push_samr_ValidatePassword(struct ndr_push *ndr, int flags, const struct samr_ValidatePassword *r)
12457 {
12458         if (flags & NDR_IN) {
12459                 NDR_CHECK(ndr_push_samr_ValidatePasswordLevel(ndr, NDR_SCALARS, r->in.level));
12460                 if (r->in.req == NULL) {
12461                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12462                 }
12463                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
12464                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
12465         }
12466         if (flags & NDR_OUT) {
12467                 if (r->out.rep == NULL) {
12468                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12469                 }
12470                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rep));
12471                 if (*r->out.rep) {
12472                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.rep, r->in.level));
12473                         NDR_CHECK(ndr_push_samr_ValidatePasswordRep(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rep));
12474                 }
12475                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12476         }
12477         return NDR_ERR_SUCCESS;
12478 }
12479
12480 static enum ndr_err_code ndr_pull_samr_ValidatePassword(struct ndr_pull *ndr, int flags, struct samr_ValidatePassword *r)
12481 {
12482         uint32_t _ptr_rep;
12483         TALLOC_CTX *_mem_save_req_0;
12484         TALLOC_CTX *_mem_save_rep_0;
12485         TALLOC_CTX *_mem_save_rep_1;
12486         if (flags & NDR_IN) {
12487                 ZERO_STRUCT(r->out);
12488
12489                 NDR_CHECK(ndr_pull_samr_ValidatePasswordLevel(ndr, NDR_SCALARS, &r->in.level));
12490                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12491                         NDR_PULL_ALLOC(ndr, r->in.req);
12492                 }
12493                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
12494                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
12495                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
12496                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
12497                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
12498                 NDR_PULL_ALLOC(ndr, r->out.rep);
12499                 ZERO_STRUCTP(r->out.rep);
12500         }
12501         if (flags & NDR_OUT) {
12502                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12503                         NDR_PULL_ALLOC(ndr, r->out.rep);
12504                 }
12505                 _mem_save_rep_0 = NDR_PULL_GET_MEM_CTX(ndr);
12506                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rep, LIBNDR_FLAG_REF_ALLOC);
12507                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rep));
12508                 if (_ptr_rep) {
12509                         NDR_PULL_ALLOC(ndr, *r->out.rep);
12510                 } else {
12511                         *r->out.rep = NULL;
12512                 }
12513                 if (*r->out.rep) {
12514                         _mem_save_rep_1 = NDR_PULL_GET_MEM_CTX(ndr);
12515                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.rep, 0);
12516                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.rep, r->in.level));
12517                         NDR_CHECK(ndr_pull_samr_ValidatePasswordRep(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rep));
12518                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rep_1, 0);
12519                 }
12520                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rep_0, LIBNDR_FLAG_REF_ALLOC);
12521                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12522         }
12523         return NDR_ERR_SUCCESS;
12524 }
12525
12526 _PUBLIC_ void ndr_print_samr_ValidatePassword(struct ndr_print *ndr, const char *name, int flags, const struct samr_ValidatePassword *r)
12527 {
12528         ndr_print_struct(ndr, name, "samr_ValidatePassword");
12529         ndr->depth++;
12530         if (flags & NDR_SET_VALUES) {
12531                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12532         }
12533         if (flags & NDR_IN) {
12534                 ndr_print_struct(ndr, "in", "samr_ValidatePassword");
12535                 ndr->depth++;
12536                 ndr_print_samr_ValidatePasswordLevel(ndr, "level", r->in.level);
12537                 ndr_print_ptr(ndr, "req", r->in.req);
12538                 ndr->depth++;
12539                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
12540                 ndr_print_samr_ValidatePasswordReq(ndr, "req", r->in.req);
12541                 ndr->depth--;
12542                 ndr->depth--;
12543         }
12544         if (flags & NDR_OUT) {
12545                 ndr_print_struct(ndr, "out", "samr_ValidatePassword");
12546                 ndr->depth++;
12547                 ndr_print_ptr(ndr, "rep", r->out.rep);
12548                 ndr->depth++;
12549                 ndr_print_ptr(ndr, "rep", *r->out.rep);
12550                 ndr->depth++;
12551                 if (*r->out.rep) {
12552                         ndr_print_set_switch_value(ndr, *r->out.rep, r->in.level);
12553                         ndr_print_samr_ValidatePasswordRep(ndr, "rep", *r->out.rep);
12554                 }
12555                 ndr->depth--;
12556                 ndr->depth--;
12557                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12558                 ndr->depth--;
12559         }
12560         ndr->depth--;
12561 }
12562
12563 static const struct ndr_interface_call samr_calls[] = {
12564         {
12565                 "samr_Connect",
12566                 sizeof(struct samr_Connect),
12567                 (ndr_push_flags_fn_t) ndr_push_samr_Connect,
12568                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect,
12569                 (ndr_print_function_t) ndr_print_samr_Connect,
12570                 false,
12571         },
12572         {
12573                 "samr_Close",
12574                 sizeof(struct samr_Close),
12575                 (ndr_push_flags_fn_t) ndr_push_samr_Close,
12576                 (ndr_pull_flags_fn_t) ndr_pull_samr_Close,
12577                 (ndr_print_function_t) ndr_print_samr_Close,
12578                 false,
12579         },
12580         {
12581                 "samr_SetSecurity",
12582                 sizeof(struct samr_SetSecurity),
12583                 (ndr_push_flags_fn_t) ndr_push_samr_SetSecurity,
12584                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetSecurity,
12585                 (ndr_print_function_t) ndr_print_samr_SetSecurity,
12586                 false,
12587         },
12588         {
12589                 "samr_QuerySecurity",
12590                 sizeof(struct samr_QuerySecurity),
12591                 (ndr_push_flags_fn_t) ndr_push_samr_QuerySecurity,
12592                 (ndr_pull_flags_fn_t) ndr_pull_samr_QuerySecurity,
12593                 (ndr_print_function_t) ndr_print_samr_QuerySecurity,
12594                 false,
12595         },
12596         {
12597                 "samr_Shutdown",
12598                 sizeof(struct samr_Shutdown),
12599                 (ndr_push_flags_fn_t) ndr_push_samr_Shutdown,
12600                 (ndr_pull_flags_fn_t) ndr_pull_samr_Shutdown,
12601                 (ndr_print_function_t) ndr_print_samr_Shutdown,
12602                 false,
12603         },
12604         {
12605                 "samr_LookupDomain",
12606                 sizeof(struct samr_LookupDomain),
12607                 (ndr_push_flags_fn_t) ndr_push_samr_LookupDomain,
12608                 (ndr_pull_flags_fn_t) ndr_pull_samr_LookupDomain,
12609                 (ndr_print_function_t) ndr_print_samr_LookupDomain,
12610                 false,
12611         },
12612         {
12613                 "samr_EnumDomains",
12614                 sizeof(struct samr_EnumDomains),
12615                 (ndr_push_flags_fn_t) ndr_push_samr_EnumDomains,
12616                 (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomains,
12617                 (ndr_print_function_t) ndr_print_samr_EnumDomains,
12618                 false,
12619         },
12620         {
12621                 "samr_OpenDomain",
12622                 sizeof(struct samr_OpenDomain),
12623                 (ndr_push_flags_fn_t) ndr_push_samr_OpenDomain,
12624                 (ndr_pull_flags_fn_t) ndr_pull_samr_OpenDomain,
12625                 (ndr_print_function_t) ndr_print_samr_OpenDomain,
12626                 false,
12627         },
12628         {
12629                 "samr_QueryDomainInfo",
12630                 sizeof(struct samr_QueryDomainInfo),
12631                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDomainInfo,
12632                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDomainInfo,
12633                 (ndr_print_function_t) ndr_print_samr_QueryDomainInfo,
12634                 false,
12635         },
12636         {
12637                 "samr_SetDomainInfo",
12638                 sizeof(struct samr_SetDomainInfo),
12639                 (ndr_push_flags_fn_t) ndr_push_samr_SetDomainInfo,
12640                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetDomainInfo,
12641                 (ndr_print_function_t) ndr_print_samr_SetDomainInfo,
12642                 false,
12643         },
12644         {
12645                 "samr_CreateDomainGroup",
12646                 sizeof(struct samr_CreateDomainGroup),
12647                 (ndr_push_flags_fn_t) ndr_push_samr_CreateDomainGroup,
12648                 (ndr_pull_flags_fn_t) ndr_pull_samr_CreateDomainGroup,
12649                 (ndr_print_function_t) ndr_print_samr_CreateDomainGroup,
12650                 false,
12651         },
12652         {
12653                 "samr_EnumDomainGroups",
12654                 sizeof(struct samr_EnumDomainGroups),
12655                 (ndr_push_flags_fn_t) ndr_push_samr_EnumDomainGroups,
12656                 (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainGroups,
12657                 (ndr_print_function_t) ndr_print_samr_EnumDomainGroups,
12658                 false,
12659         },
12660         {
12661                 "samr_CreateUser",
12662                 sizeof(struct samr_CreateUser),
12663                 (ndr_push_flags_fn_t) ndr_push_samr_CreateUser,
12664                 (ndr_pull_flags_fn_t) ndr_pull_samr_CreateUser,
12665                 (ndr_print_function_t) ndr_print_samr_CreateUser,
12666                 false,
12667         },
12668         {
12669                 "samr_EnumDomainUsers",
12670                 sizeof(struct samr_EnumDomainUsers),
12671                 (ndr_push_flags_fn_t) ndr_push_samr_EnumDomainUsers,
12672                 (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainUsers,
12673                 (ndr_print_function_t) ndr_print_samr_EnumDomainUsers,
12674                 false,
12675         },
12676         {
12677                 "samr_CreateDomAlias",
12678                 sizeof(struct samr_CreateDomAlias),
12679                 (ndr_push_flags_fn_t) ndr_push_samr_CreateDomAlias,
12680                 (ndr_pull_flags_fn_t) ndr_pull_samr_CreateDomAlias,
12681                 (ndr_print_function_t) ndr_print_samr_CreateDomAlias,
12682                 false,
12683         },
12684         {
12685                 "samr_EnumDomainAliases",
12686                 sizeof(struct samr_EnumDomainAliases),
12687                 (ndr_push_flags_fn_t) ndr_push_samr_EnumDomainAliases,
12688                 (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainAliases,
12689                 (ndr_print_function_t) ndr_print_samr_EnumDomainAliases,
12690                 false,
12691         },
12692         {
12693                 "samr_GetAliasMembership",
12694                 sizeof(struct samr_GetAliasMembership),
12695                 (ndr_push_flags_fn_t) ndr_push_samr_GetAliasMembership,
12696                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetAliasMembership,
12697                 (ndr_print_function_t) ndr_print_samr_GetAliasMembership,
12698                 false,
12699         },
12700         {
12701                 "samr_LookupNames",
12702                 sizeof(struct samr_LookupNames),
12703                 (ndr_push_flags_fn_t) ndr_push_samr_LookupNames,
12704                 (ndr_pull_flags_fn_t) ndr_pull_samr_LookupNames,
12705                 (ndr_print_function_t) ndr_print_samr_LookupNames,
12706                 false,
12707         },
12708         {
12709                 "samr_LookupRids",
12710                 sizeof(struct samr_LookupRids),
12711                 (ndr_push_flags_fn_t) ndr_push_samr_LookupRids,
12712                 (ndr_pull_flags_fn_t) ndr_pull_samr_LookupRids,
12713                 (ndr_print_function_t) ndr_print_samr_LookupRids,
12714                 false,
12715         },
12716         {
12717                 "samr_OpenGroup",
12718                 sizeof(struct samr_OpenGroup),
12719                 (ndr_push_flags_fn_t) ndr_push_samr_OpenGroup,
12720                 (ndr_pull_flags_fn_t) ndr_pull_samr_OpenGroup,
12721                 (ndr_print_function_t) ndr_print_samr_OpenGroup,
12722                 false,
12723         },
12724         {
12725                 "samr_QueryGroupInfo",
12726                 sizeof(struct samr_QueryGroupInfo),
12727                 (ndr_push_flags_fn_t) ndr_push_samr_QueryGroupInfo,
12728                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryGroupInfo,
12729                 (ndr_print_function_t) ndr_print_samr_QueryGroupInfo,
12730                 false,
12731         },
12732         {
12733                 "samr_SetGroupInfo",
12734                 sizeof(struct samr_SetGroupInfo),
12735                 (ndr_push_flags_fn_t) ndr_push_samr_SetGroupInfo,
12736                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetGroupInfo,
12737                 (ndr_print_function_t) ndr_print_samr_SetGroupInfo,
12738                 false,
12739         },
12740         {
12741                 "samr_AddGroupMember",
12742                 sizeof(struct samr_AddGroupMember),
12743                 (ndr_push_flags_fn_t) ndr_push_samr_AddGroupMember,
12744                 (ndr_pull_flags_fn_t) ndr_pull_samr_AddGroupMember,
12745                 (ndr_print_function_t) ndr_print_samr_AddGroupMember,
12746                 false,
12747         },
12748         {
12749                 "samr_DeleteDomainGroup",
12750                 sizeof(struct samr_DeleteDomainGroup),
12751                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteDomainGroup,
12752                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteDomainGroup,
12753                 (ndr_print_function_t) ndr_print_samr_DeleteDomainGroup,
12754                 false,
12755         },
12756         {
12757                 "samr_DeleteGroupMember",
12758                 sizeof(struct samr_DeleteGroupMember),
12759                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteGroupMember,
12760                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteGroupMember,
12761                 (ndr_print_function_t) ndr_print_samr_DeleteGroupMember,
12762                 false,
12763         },
12764         {
12765                 "samr_QueryGroupMember",
12766                 sizeof(struct samr_QueryGroupMember),
12767                 (ndr_push_flags_fn_t) ndr_push_samr_QueryGroupMember,
12768                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryGroupMember,
12769                 (ndr_print_function_t) ndr_print_samr_QueryGroupMember,
12770                 false,
12771         },
12772         {
12773                 "samr_SetMemberAttributesOfGroup",
12774                 sizeof(struct samr_SetMemberAttributesOfGroup),
12775                 (ndr_push_flags_fn_t) ndr_push_samr_SetMemberAttributesOfGroup,
12776                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetMemberAttributesOfGroup,
12777                 (ndr_print_function_t) ndr_print_samr_SetMemberAttributesOfGroup,
12778                 false,
12779         },
12780         {
12781                 "samr_OpenAlias",
12782                 sizeof(struct samr_OpenAlias),
12783                 (ndr_push_flags_fn_t) ndr_push_samr_OpenAlias,
12784                 (ndr_pull_flags_fn_t) ndr_pull_samr_OpenAlias,
12785                 (ndr_print_function_t) ndr_print_samr_OpenAlias,
12786                 false,
12787         },
12788         {
12789                 "samr_QueryAliasInfo",
12790                 sizeof(struct samr_QueryAliasInfo),
12791                 (ndr_push_flags_fn_t) ndr_push_samr_QueryAliasInfo,
12792                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryAliasInfo,
12793                 (ndr_print_function_t) ndr_print_samr_QueryAliasInfo,
12794                 false,
12795         },
12796         {
12797                 "samr_SetAliasInfo",
12798                 sizeof(struct samr_SetAliasInfo),
12799                 (ndr_push_flags_fn_t) ndr_push_samr_SetAliasInfo,
12800                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetAliasInfo,
12801                 (ndr_print_function_t) ndr_print_samr_SetAliasInfo,
12802                 false,
12803         },
12804         {
12805                 "samr_DeleteDomAlias",
12806                 sizeof(struct samr_DeleteDomAlias),
12807                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteDomAlias,
12808                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteDomAlias,
12809                 (ndr_print_function_t) ndr_print_samr_DeleteDomAlias,
12810                 false,
12811         },
12812         {
12813                 "samr_AddAliasMember",
12814                 sizeof(struct samr_AddAliasMember),
12815                 (ndr_push_flags_fn_t) ndr_push_samr_AddAliasMember,
12816                 (ndr_pull_flags_fn_t) ndr_pull_samr_AddAliasMember,
12817                 (ndr_print_function_t) ndr_print_samr_AddAliasMember,
12818                 false,
12819         },
12820         {
12821                 "samr_DeleteAliasMember",
12822                 sizeof(struct samr_DeleteAliasMember),
12823                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteAliasMember,
12824                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteAliasMember,
12825                 (ndr_print_function_t) ndr_print_samr_DeleteAliasMember,
12826                 false,
12827         },
12828         {
12829                 "samr_GetMembersInAlias",
12830                 sizeof(struct samr_GetMembersInAlias),
12831                 (ndr_push_flags_fn_t) ndr_push_samr_GetMembersInAlias,
12832                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetMembersInAlias,
12833                 (ndr_print_function_t) ndr_print_samr_GetMembersInAlias,
12834                 false,
12835         },
12836         {
12837                 "samr_OpenUser",
12838                 sizeof(struct samr_OpenUser),
12839                 (ndr_push_flags_fn_t) ndr_push_samr_OpenUser,
12840                 (ndr_pull_flags_fn_t) ndr_pull_samr_OpenUser,
12841                 (ndr_print_function_t) ndr_print_samr_OpenUser,
12842                 false,
12843         },
12844         {
12845                 "samr_DeleteUser",
12846                 sizeof(struct samr_DeleteUser),
12847                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteUser,
12848                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteUser,
12849                 (ndr_print_function_t) ndr_print_samr_DeleteUser,
12850                 false,
12851         },
12852         {
12853                 "samr_QueryUserInfo",
12854                 sizeof(struct samr_QueryUserInfo),
12855                 (ndr_push_flags_fn_t) ndr_push_samr_QueryUserInfo,
12856                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryUserInfo,
12857                 (ndr_print_function_t) ndr_print_samr_QueryUserInfo,
12858                 false,
12859         },
12860         {
12861                 "samr_SetUserInfo",
12862                 sizeof(struct samr_SetUserInfo),
12863                 (ndr_push_flags_fn_t) ndr_push_samr_SetUserInfo,
12864                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetUserInfo,
12865                 (ndr_print_function_t) ndr_print_samr_SetUserInfo,
12866                 false,
12867         },
12868         {
12869                 "samr_ChangePasswordUser",
12870                 sizeof(struct samr_ChangePasswordUser),
12871                 (ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser,
12872                 (ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser,
12873                 (ndr_print_function_t) ndr_print_samr_ChangePasswordUser,
12874                 false,
12875         },
12876         {
12877                 "samr_GetGroupsForUser",
12878                 sizeof(struct samr_GetGroupsForUser),
12879                 (ndr_push_flags_fn_t) ndr_push_samr_GetGroupsForUser,
12880                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetGroupsForUser,
12881                 (ndr_print_function_t) ndr_print_samr_GetGroupsForUser,
12882                 false,
12883         },
12884         {
12885                 "samr_QueryDisplayInfo",
12886                 sizeof(struct samr_QueryDisplayInfo),
12887                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo,
12888                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo,
12889                 (ndr_print_function_t) ndr_print_samr_QueryDisplayInfo,
12890                 false,
12891         },
12892         {
12893                 "samr_GetDisplayEnumerationIndex",
12894                 sizeof(struct samr_GetDisplayEnumerationIndex),
12895                 (ndr_push_flags_fn_t) ndr_push_samr_GetDisplayEnumerationIndex,
12896                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetDisplayEnumerationIndex,
12897                 (ndr_print_function_t) ndr_print_samr_GetDisplayEnumerationIndex,
12898                 false,
12899         },
12900         {
12901                 "samr_TestPrivateFunctionsDomain",
12902                 sizeof(struct samr_TestPrivateFunctionsDomain),
12903                 (ndr_push_flags_fn_t) ndr_push_samr_TestPrivateFunctionsDomain,
12904                 (ndr_pull_flags_fn_t) ndr_pull_samr_TestPrivateFunctionsDomain,
12905                 (ndr_print_function_t) ndr_print_samr_TestPrivateFunctionsDomain,
12906                 false,
12907         },
12908         {
12909                 "samr_TestPrivateFunctionsUser",
12910                 sizeof(struct samr_TestPrivateFunctionsUser),
12911                 (ndr_push_flags_fn_t) ndr_push_samr_TestPrivateFunctionsUser,
12912                 (ndr_pull_flags_fn_t) ndr_pull_samr_TestPrivateFunctionsUser,
12913                 (ndr_print_function_t) ndr_print_samr_TestPrivateFunctionsUser,
12914                 false,
12915         },
12916         {
12917                 "samr_GetUserPwInfo",
12918                 sizeof(struct samr_GetUserPwInfo),
12919                 (ndr_push_flags_fn_t) ndr_push_samr_GetUserPwInfo,
12920                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetUserPwInfo,
12921                 (ndr_print_function_t) ndr_print_samr_GetUserPwInfo,
12922                 false,
12923         },
12924         {
12925                 "samr_RemoveMemberFromForeignDomain",
12926                 sizeof(struct samr_RemoveMemberFromForeignDomain),
12927                 (ndr_push_flags_fn_t) ndr_push_samr_RemoveMemberFromForeignDomain,
12928                 (ndr_pull_flags_fn_t) ndr_pull_samr_RemoveMemberFromForeignDomain,
12929                 (ndr_print_function_t) ndr_print_samr_RemoveMemberFromForeignDomain,
12930                 false,
12931         },
12932         {
12933                 "samr_QueryDomainInfo2",
12934                 sizeof(struct samr_QueryDomainInfo2),
12935                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDomainInfo2,
12936                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDomainInfo2,
12937                 (ndr_print_function_t) ndr_print_samr_QueryDomainInfo2,
12938                 false,
12939         },
12940         {
12941                 "samr_QueryUserInfo2",
12942                 sizeof(struct samr_QueryUserInfo2),
12943                 (ndr_push_flags_fn_t) ndr_push_samr_QueryUserInfo2,
12944                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryUserInfo2,
12945                 (ndr_print_function_t) ndr_print_samr_QueryUserInfo2,
12946                 false,
12947         },
12948         {
12949                 "samr_QueryDisplayInfo2",
12950                 sizeof(struct samr_QueryDisplayInfo2),
12951                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo2,
12952                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo2,
12953                 (ndr_print_function_t) ndr_print_samr_QueryDisplayInfo2,
12954                 false,
12955         },
12956         {
12957                 "samr_GetDisplayEnumerationIndex2",
12958                 sizeof(struct samr_GetDisplayEnumerationIndex2),
12959                 (ndr_push_flags_fn_t) ndr_push_samr_GetDisplayEnumerationIndex2,
12960                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetDisplayEnumerationIndex2,
12961                 (ndr_print_function_t) ndr_print_samr_GetDisplayEnumerationIndex2,
12962                 false,
12963         },
12964         {
12965                 "samr_CreateUser2",
12966                 sizeof(struct samr_CreateUser2),
12967                 (ndr_push_flags_fn_t) ndr_push_samr_CreateUser2,
12968                 (ndr_pull_flags_fn_t) ndr_pull_samr_CreateUser2,
12969                 (ndr_print_function_t) ndr_print_samr_CreateUser2,
12970                 false,
12971         },
12972         {
12973                 "samr_QueryDisplayInfo3",
12974                 sizeof(struct samr_QueryDisplayInfo3),
12975                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo3,
12976                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo3,
12977                 (ndr_print_function_t) ndr_print_samr_QueryDisplayInfo3,
12978                 false,
12979         },
12980         {
12981                 "samr_AddMultipleMembersToAlias",
12982                 sizeof(struct samr_AddMultipleMembersToAlias),
12983                 (ndr_push_flags_fn_t) ndr_push_samr_AddMultipleMembersToAlias,
12984                 (ndr_pull_flags_fn_t) ndr_pull_samr_AddMultipleMembersToAlias,
12985                 (ndr_print_function_t) ndr_print_samr_AddMultipleMembersToAlias,
12986                 false,
12987         },
12988         {
12989                 "samr_RemoveMultipleMembersFromAlias",
12990                 sizeof(struct samr_RemoveMultipleMembersFromAlias),
12991                 (ndr_push_flags_fn_t) ndr_push_samr_RemoveMultipleMembersFromAlias,
12992                 (ndr_pull_flags_fn_t) ndr_pull_samr_RemoveMultipleMembersFromAlias,
12993                 (ndr_print_function_t) ndr_print_samr_RemoveMultipleMembersFromAlias,
12994                 false,
12995         },
12996         {
12997                 "samr_OemChangePasswordUser2",
12998                 sizeof(struct samr_OemChangePasswordUser2),
12999                 (ndr_push_flags_fn_t) ndr_push_samr_OemChangePasswordUser2,
13000                 (ndr_pull_flags_fn_t) ndr_pull_samr_OemChangePasswordUser2,
13001                 (ndr_print_function_t) ndr_print_samr_OemChangePasswordUser2,
13002                 false,
13003         },
13004         {
13005                 "samr_ChangePasswordUser2",
13006                 sizeof(struct samr_ChangePasswordUser2),
13007                 (ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser2,
13008                 (ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser2,
13009                 (ndr_print_function_t) ndr_print_samr_ChangePasswordUser2,
13010                 false,
13011         },
13012         {
13013                 "samr_GetDomPwInfo",
13014                 sizeof(struct samr_GetDomPwInfo),
13015                 (ndr_push_flags_fn_t) ndr_push_samr_GetDomPwInfo,
13016                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetDomPwInfo,
13017                 (ndr_print_function_t) ndr_print_samr_GetDomPwInfo,
13018                 false,
13019         },
13020         {
13021                 "samr_Connect2",
13022                 sizeof(struct samr_Connect2),
13023                 (ndr_push_flags_fn_t) ndr_push_samr_Connect2,
13024                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect2,
13025                 (ndr_print_function_t) ndr_print_samr_Connect2,
13026                 false,
13027         },
13028         {
13029                 "samr_SetUserInfo2",
13030                 sizeof(struct samr_SetUserInfo2),
13031                 (ndr_push_flags_fn_t) ndr_push_samr_SetUserInfo2,
13032                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetUserInfo2,
13033                 (ndr_print_function_t) ndr_print_samr_SetUserInfo2,
13034                 false,
13035         },
13036         {
13037                 "samr_SetBootKeyInformation",
13038                 sizeof(struct samr_SetBootKeyInformation),
13039                 (ndr_push_flags_fn_t) ndr_push_samr_SetBootKeyInformation,
13040                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetBootKeyInformation,
13041                 (ndr_print_function_t) ndr_print_samr_SetBootKeyInformation,
13042                 false,
13043         },
13044         {
13045                 "samr_GetBootKeyInformation",
13046                 sizeof(struct samr_GetBootKeyInformation),
13047                 (ndr_push_flags_fn_t) ndr_push_samr_GetBootKeyInformation,
13048                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetBootKeyInformation,
13049                 (ndr_print_function_t) ndr_print_samr_GetBootKeyInformation,
13050                 false,
13051         },
13052         {
13053                 "samr_Connect3",
13054                 sizeof(struct samr_Connect3),
13055                 (ndr_push_flags_fn_t) ndr_push_samr_Connect3,
13056                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect3,
13057                 (ndr_print_function_t) ndr_print_samr_Connect3,
13058                 false,
13059         },
13060         {
13061                 "samr_Connect4",
13062                 sizeof(struct samr_Connect4),
13063                 (ndr_push_flags_fn_t) ndr_push_samr_Connect4,
13064                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect4,
13065                 (ndr_print_function_t) ndr_print_samr_Connect4,
13066                 false,
13067         },
13068         {
13069                 "samr_ChangePasswordUser3",
13070                 sizeof(struct samr_ChangePasswordUser3),
13071                 (ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser3,
13072                 (ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser3,
13073                 (ndr_print_function_t) ndr_print_samr_ChangePasswordUser3,
13074                 false,
13075         },
13076         {
13077                 "samr_Connect5",
13078                 sizeof(struct samr_Connect5),
13079                 (ndr_push_flags_fn_t) ndr_push_samr_Connect5,
13080                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect5,
13081                 (ndr_print_function_t) ndr_print_samr_Connect5,
13082                 false,
13083         },
13084         {
13085                 "samr_RidToSid",
13086                 sizeof(struct samr_RidToSid),
13087                 (ndr_push_flags_fn_t) ndr_push_samr_RidToSid,
13088                 (ndr_pull_flags_fn_t) ndr_pull_samr_RidToSid,
13089                 (ndr_print_function_t) ndr_print_samr_RidToSid,
13090                 false,
13091         },
13092         {
13093                 "samr_SetDsrmPassword",
13094                 sizeof(struct samr_SetDsrmPassword),
13095                 (ndr_push_flags_fn_t) ndr_push_samr_SetDsrmPassword,
13096                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetDsrmPassword,
13097                 (ndr_print_function_t) ndr_print_samr_SetDsrmPassword,
13098                 false,
13099         },
13100         {
13101                 "samr_ValidatePassword",
13102                 sizeof(struct samr_ValidatePassword),
13103                 (ndr_push_flags_fn_t) ndr_push_samr_ValidatePassword,
13104                 (ndr_pull_flags_fn_t) ndr_pull_samr_ValidatePassword,
13105                 (ndr_print_function_t) ndr_print_samr_ValidatePassword,
13106                 false,
13107         },
13108         { NULL, 0, NULL, NULL, NULL, false }
13109 };
13110
13111 static const char * const samr_endpoint_strings[] = {
13112         "ncacn_np:[\\pipe\\samr]",
13113         "ncacn_ip_tcp:",
13114         "ncalrpc:",
13115 };
13116
13117 static const struct ndr_interface_string_array samr_endpoints = {
13118         .count  = 3,
13119         .names  = samr_endpoint_strings
13120 };
13121
13122 static const char * const samr_authservice_strings[] = {
13123         "host",
13124 };
13125
13126 static const struct ndr_interface_string_array samr_authservices = {
13127         .count  = 1,
13128         .names  = samr_authservice_strings
13129 };
13130
13131
13132 const struct ndr_interface_table ndr_table_samr = {
13133         .name           = "samr",
13134         .syntax_id      = {
13135                 {0x12345778,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xac}},
13136                 NDR_SAMR_VERSION
13137         },
13138         .helpstring     = NDR_SAMR_HELPSTRING,
13139         .num_calls      = 68,
13140         .calls          = samr_calls,
13141         .endpoints      = &samr_endpoints,
13142         .authservices   = &samr_authservices
13143 };
13144