librpc/gen_ndr/ndr_samr.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_samr.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 #include "librpc/gen_ndr/ndr_lsa.h"
   8 #include "librpc/gen_ndr/ndr_security.h"
   9 _PUBLIC_ enum ndr_err_code ndr_push_netr_SamDatabaseID(struct ndr_push *ndr, int ndr_flags, enum netr_SamDatabaseID r)
  10 {
  11         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  12         return NDR_ERR_SUCCESS;
  13 }
  14
  15 _PUBLIC_ enum ndr_err_code ndr_pull_netr_SamDatabaseID(struct ndr_pull *ndr, int ndr_flags, enum netr_SamDatabaseID *r)
  16 {
  17         uint32_t v;
  18         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  19         *r = v;
  20         return NDR_ERR_SUCCESS;
  21 }
  22
  23 _PUBLIC_ void ndr_print_netr_SamDatabaseID(struct ndr_print *ndr, const char *name, enum netr_SamDatabaseID r)
  24 {
  25         const char *val = NULL;
  26
  27         switch (r) {
  28                 case SAM_DATABASE_DOMAIN: val = "SAM_DATABASE_DOMAIN"; break;
  29                 case SAM_DATABASE_BUILTIN: val = "SAM_DATABASE_BUILTIN"; break;
  30                 case SAM_DATABASE_PRIVS: val = "SAM_DATABASE_PRIVS"; break;
  31         }
  32         ndr_print_enum(ndr, name, "ENUM", val, r);
  33 }
  34
  35 _PUBLIC_ enum ndr_err_code ndr_push_samr_RejectReason(struct ndr_push *ndr, int ndr_flags, enum samr_RejectReason r)
  36 {
  37         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  38         return NDR_ERR_SUCCESS;
  39 }
  40
  41 _PUBLIC_ enum ndr_err_code ndr_pull_samr_RejectReason(struct ndr_pull *ndr, int ndr_flags, enum samr_RejectReason *r)
  42 {
  43         uint32_t v;
  44         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  45         *r = v;
  46         return NDR_ERR_SUCCESS;
  47 }
  48
  49 _PUBLIC_ void ndr_print_samr_RejectReason(struct ndr_print *ndr, const char *name, enum samr_RejectReason r)
  50 {
  51         const char *val = NULL;
  52
  53         switch (r) {
  54                 case SAMR_REJECT_OTHER: val = "SAMR_REJECT_OTHER"; break;
  55                 case SAMR_REJECT_TOO_SHORT: val = "SAMR_REJECT_TOO_SHORT"; break;
  56                 case SAMR_REJECT_IN_HISTORY: val = "SAMR_REJECT_IN_HISTORY"; break;
  57                 case SAMR_REJECT_COMPLEXITY: val = "SAMR_REJECT_COMPLEXITY"; break;
  58         }
  59         ndr_print_enum(ndr, name, "ENUM", val, r);
  60 }
  61
  62 _PUBLIC_ enum ndr_err_code ndr_push_samr_AcctFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  63 {
  64         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  65         return NDR_ERR_SUCCESS;
  66 }
  67
  68 _PUBLIC_ enum ndr_err_code ndr_pull_samr_AcctFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  69 {
  70         uint32_t v;
  71         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  72         *r = v;
  73         return NDR_ERR_SUCCESS;
  74 }
  75
  76 _PUBLIC_ void ndr_print_samr_AcctFlags(struct ndr_print *ndr, const char *name, uint32_t r)
  77 {
  78         ndr_print_uint32(ndr, name, r);
  79         ndr->depth++;
  80         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_DISABLED", ACB_DISABLED, r);
  81         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_HOMDIRREQ", ACB_HOMDIRREQ, r);
  82         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_PWNOTREQ", ACB_PWNOTREQ, r);
  83         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_TEMPDUP", ACB_TEMPDUP, r);
  84         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_NORMAL", ACB_NORMAL, r);
  85         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_MNS", ACB_MNS, r);
  86         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_DOMTRUST", ACB_DOMTRUST, r);
  87         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_WSTRUST", ACB_WSTRUST, r);
  88         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_SVRTRUST", ACB_SVRTRUST, r);
  89         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_PWNOEXP", ACB_PWNOEXP, r);
  90         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_AUTOLOCK", ACB_AUTOLOCK, r);
  91         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_ENC_TXT_PWD_ALLOWED", ACB_ENC_TXT_PWD_ALLOWED, r);
  92         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_SMARTCARD_REQUIRED", ACB_SMARTCARD_REQUIRED, r);
  93         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_TRUSTED_FOR_DELEGATION", ACB_TRUSTED_FOR_DELEGATION, r);
  94         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_NOT_DELEGATED", ACB_NOT_DELEGATED, r);
  95         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_USE_DES_KEY_ONLY", ACB_USE_DES_KEY_ONLY, r);
  96         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_DONT_REQUIRE_PREAUTH", ACB_DONT_REQUIRE_PREAUTH, r);
  97         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_PW_EXPIRED", ACB_PW_EXPIRED, r);
  98         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_NO_AUTH_DATA_REQD", ACB_NO_AUTH_DATA_REQD, r);
  99         ndr->depth--;
 100 }
 101
 102 static enum ndr_err_code ndr_push_samr_ConnectAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 103 {
 104         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 105         return NDR_ERR_SUCCESS;
 106 }
 107
 108 static enum ndr_err_code ndr_pull_samr_ConnectAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 109 {
 110         uint32_t v;
 111         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 112         *r = v;
 113         return NDR_ERR_SUCCESS;
 114 }
 115
 116 _PUBLIC_ void ndr_print_samr_ConnectAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 117 {
 118         ndr_print_uint32(ndr, name, r);
 119         ndr->depth++;
 120         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_CONNECT_TO_SERVER", SAMR_ACCESS_CONNECT_TO_SERVER, r);
 121         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_SHUTDOWN_SERVER", SAMR_ACCESS_SHUTDOWN_SERVER, r);
 122         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_INITIALIZE_SERVER", SAMR_ACCESS_INITIALIZE_SERVER, r);
 123         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_CREATE_DOMAIN", SAMR_ACCESS_CREATE_DOMAIN, r);
 124         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_ENUM_DOMAINS", SAMR_ACCESS_ENUM_DOMAINS, r);
 125         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_OPEN_DOMAIN", SAMR_ACCESS_OPEN_DOMAIN, r);
 126         ndr->depth--;
 127 }
 128
 129 static enum ndr_err_code ndr_push_samr_UserAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 130 {
 131         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 132         return NDR_ERR_SUCCESS;
 133 }
 134
 135 static enum ndr_err_code ndr_pull_samr_UserAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 136 {
 137         uint32_t v;
 138         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 139         *r = v;
 140         return NDR_ERR_SUCCESS;
 141 }
 142
 143 _PUBLIC_ void ndr_print_samr_UserAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 144 {
 145         ndr_print_uint32(ndr, name, r);
 146         ndr->depth++;
 147         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_NAME_ETC", SAMR_USER_ACCESS_GET_NAME_ETC, r);
 148         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_LOCALE", SAMR_USER_ACCESS_GET_LOCALE, r);
 149         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_SET_LOC_COM", SAMR_USER_ACCESS_SET_LOC_COM, r);
 150         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_LOGONINFO", SAMR_USER_ACCESS_GET_LOGONINFO, r);
 151         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_ATTRIBUTES", SAMR_USER_ACCESS_GET_ATTRIBUTES, r);
 152         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_SET_ATTRIBUTES", SAMR_USER_ACCESS_SET_ATTRIBUTES, r);
 153         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_CHANGE_PASSWORD", SAMR_USER_ACCESS_CHANGE_PASSWORD, r);
 154         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_SET_PASSWORD", SAMR_USER_ACCESS_SET_PASSWORD, r);
 155         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_GROUPS", SAMR_USER_ACCESS_GET_GROUPS, r);
 156         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_GROUP_MEMBERSHIP", SAMR_USER_ACCESS_GET_GROUP_MEMBERSHIP, r);
 157         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_CHANGE_GROUP_MEMBERSHIP", SAMR_USER_ACCESS_CHANGE_GROUP_MEMBERSHIP, r);
 158         ndr->depth--;
 159 }
 160
 161 static enum ndr_err_code ndr_push_samr_DomainAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 162 {
 163         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 164         return NDR_ERR_SUCCESS;
 165 }
 166
 167 static enum ndr_err_code ndr_pull_samr_DomainAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 168 {
 169         uint32_t v;
 170         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 171         *r = v;
 172         return NDR_ERR_SUCCESS;
 173 }
 174
 175 _PUBLIC_ void ndr_print_samr_DomainAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 176 {
 177         ndr_print_uint32(ndr, name, r);
 178         ndr->depth++;
 179         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1", SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1, r);
 180         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_SET_INFO_1", SAMR_DOMAIN_ACCESS_SET_INFO_1, r);
 181         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2", SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2, r);
 182         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_SET_INFO_2", SAMR_DOMAIN_ACCESS_SET_INFO_2, r);
 183         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_CREATE_USER", SAMR_DOMAIN_ACCESS_CREATE_USER, r);
 184         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_CREATE_GROUP", SAMR_DOMAIN_ACCESS_CREATE_GROUP, r);
 185         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_CREATE_ALIAS", SAMR_DOMAIN_ACCESS_CREATE_ALIAS, r);
 186         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS", SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS, r);
 187         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS", SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS, r);
 188         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT", SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT, r);
 189         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_SET_INFO_3", SAMR_DOMAIN_ACCESS_SET_INFO_3, r);
 190         ndr->depth--;
 191 }
 192
 193 static enum ndr_err_code ndr_push_samr_GroupAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 194 {
 195         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 196         return NDR_ERR_SUCCESS;
 197 }
 198
 199 static enum ndr_err_code ndr_pull_samr_GroupAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 200 {
 201         uint32_t v;
 202         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 203         *r = v;
 204         return NDR_ERR_SUCCESS;
 205 }
 206
 207 _PUBLIC_ void ndr_print_samr_GroupAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 208 {
 209         ndr_print_uint32(ndr, name, r);
 210         ndr->depth++;
 211         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_LOOKUP_INFO", SAMR_GROUP_ACCESS_LOOKUP_INFO, r);
 212         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_SET_INFO", SAMR_GROUP_ACCESS_SET_INFO, r);
 213         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_ADD_MEMBER", SAMR_GROUP_ACCESS_ADD_MEMBER, r);
 214         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_REMOVE_MEMBER", SAMR_GROUP_ACCESS_REMOVE_MEMBER, r);
 215         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_GET_MEMBERS", SAMR_GROUP_ACCESS_GET_MEMBERS, r);
 216         ndr->depth--;
 217 }
 218
 219 static enum ndr_err_code ndr_push_samr_AliasAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 220 {
 221         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 222         return NDR_ERR_SUCCESS;
 223 }
 224
 225 static enum ndr_err_code ndr_pull_samr_AliasAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 226 {
 227         uint32_t v;
 228         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 229         *r = v;
 230         return NDR_ERR_SUCCESS;
 231 }
 232
 233 _PUBLIC_ void ndr_print_samr_AliasAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 234 {
 235         ndr_print_uint32(ndr, name, r);
 236         ndr->depth++;
 237         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_ADD_MEMBER", SAMR_ALIAS_ACCESS_ADD_MEMBER, r);
 238         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_REMOVE_MEMBER", SAMR_ALIAS_ACCESS_REMOVE_MEMBER, r);
 239         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_GET_MEMBERS", SAMR_ALIAS_ACCESS_GET_MEMBERS, r);
 240         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_LOOKUP_INFO", SAMR_ALIAS_ACCESS_LOOKUP_INFO, r);
 241         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_SET_INFO", SAMR_ALIAS_ACCESS_SET_INFO, r);
 242         ndr->depth--;
 243 }
 244
 245 static enum ndr_err_code ndr_push_samr_SamEntry(struct ndr_push *ndr, int ndr_flags, const struct samr_SamEntry *r)
 246 {
 247         if (ndr_flags & NDR_SCALARS) {
 248                 NDR_CHECK(ndr_push_align(ndr, 4));
 249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
 250                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
 251         }
 252         if (ndr_flags & NDR_BUFFERS) {
 253                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
 254         }
 255         return NDR_ERR_SUCCESS;
 256 }
 257
 258 static enum ndr_err_code ndr_pull_samr_SamEntry(struct ndr_pull *ndr, int ndr_flags, struct samr_SamEntry *r)
 259 {
 260         if (ndr_flags & NDR_SCALARS) {
 261                 NDR_CHECK(ndr_pull_align(ndr, 4));
 262                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
 263                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
 264         }
 265         if (ndr_flags & NDR_BUFFERS) {
 266                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
 267         }
 268         return NDR_ERR_SUCCESS;
 269 }
 270
 271 _PUBLIC_ void ndr_print_samr_SamEntry(struct ndr_print *ndr, const char *name, const struct samr_SamEntry *r)
 272 {
 273         ndr_print_struct(ndr, name, "samr_SamEntry");
 274         ndr->depth++;
 275         ndr_print_uint32(ndr, "idx", r->idx);
 276         ndr_print_lsa_String(ndr, "name", &r->name);
 277         ndr->depth--;
 278 }
 279
 280 static enum ndr_err_code ndr_push_samr_SamArray(struct ndr_push *ndr, int ndr_flags, const struct samr_SamArray *r)
 281 {
 282         uint32_t cntr_entries_1;
 283         if (ndr_flags & NDR_SCALARS) {
 284                 NDR_CHECK(ndr_push_align(ndr, 4));
 285                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 286                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
 287         }
 288         if (ndr_flags & NDR_BUFFERS) {
 289                 if (r->entries) {
 290                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 291                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 292                                 NDR_CHECK(ndr_push_samr_SamEntry(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 293                         }
 294                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 295                                 NDR_CHECK(ndr_push_samr_SamEntry(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 296                         }
 297                 }
 298         }
 299         return NDR_ERR_SUCCESS;
 300 }
 301
 302 static enum ndr_err_code ndr_pull_samr_SamArray(struct ndr_pull *ndr, int ndr_flags, struct samr_SamArray *r)
 303 {
 304         uint32_t _ptr_entries;
 305         uint32_t cntr_entries_1;
 306         TALLOC_CTX *_mem_save_entries_0;
 307         TALLOC_CTX *_mem_save_entries_1;
 308         if (ndr_flags & NDR_SCALARS) {
 309                 NDR_CHECK(ndr_pull_align(ndr, 4));
 310                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 311                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
 312                 if (_ptr_entries) {
 313                         NDR_PULL_ALLOC(ndr, r->entries);
 314                 } else {
 315                         r->entries = NULL;
 316                 }
 317         }
 318         if (ndr_flags & NDR_BUFFERS) {
 319                 if (r->entries) {
 320                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
 321                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 322                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
 323                         NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
 324                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
 325                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 326                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 327                                 NDR_CHECK(ndr_pull_samr_SamEntry(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 328                         }
 329                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 330                                 NDR_CHECK(ndr_pull_samr_SamEntry(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 331                         }
 332                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
 333                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
 334                 }
 335                 if (r->entries) {
 336                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
 337                 }
 338         }
 339         return NDR_ERR_SUCCESS;
 340 }
 341
 342 _PUBLIC_ void ndr_print_samr_SamArray(struct ndr_print *ndr, const char *name, const struct samr_SamArray *r)
 343 {
 344         uint32_t cntr_entries_1;
 345         ndr_print_struct(ndr, name, "samr_SamArray");
 346         ndr->depth++;
 347         ndr_print_uint32(ndr, "count", r->count);
 348         ndr_print_ptr(ndr, "entries", r->entries);
 349         ndr->depth++;
 350         if (r->entries) {
 351                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
 352                 ndr->depth++;
 353                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
 354                         char *idx_1=NULL;
 355                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
 356                                 ndr_print_samr_SamEntry(ndr, "entries", &r->entries[cntr_entries_1]);
 357                                 free(idx_1);
 358                         }
 359                 }
 360                 ndr->depth--;
 361         }
 362         ndr->depth--;
 363         ndr->depth--;
 364 }
 365
 366 static enum ndr_err_code ndr_push_samr_Role(struct ndr_push *ndr, int ndr_flags, enum samr_Role r)
 367 {
 368         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 369         return NDR_ERR_SUCCESS;
 370 }
 371
 372 static enum ndr_err_code ndr_pull_samr_Role(struct ndr_pull *ndr, int ndr_flags, enum samr_Role *r)
 373 {
 374         uint32_t v;
 375         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 376         *r = v;
 377         return NDR_ERR_SUCCESS;
 378 }
 379
 380 _PUBLIC_ void ndr_print_samr_Role(struct ndr_print *ndr, const char *name, enum samr_Role r)
 381 {
 382         const char *val = NULL;
 383
 384         switch (r) {
 385                 case SAMR_ROLE_STANDALONE: val = "SAMR_ROLE_STANDALONE"; break;
 386                 case SAMR_ROLE_DOMAIN_MEMBER: val = "SAMR_ROLE_DOMAIN_MEMBER"; break;
 387                 case SAMR_ROLE_DOMAIN_BDC: val = "SAMR_ROLE_DOMAIN_BDC"; break;
 388                 case SAMR_ROLE_DOMAIN_PDC: val = "SAMR_ROLE_DOMAIN_PDC"; break;
 389         }
 390         ndr_print_enum(ndr, name, "ENUM", val, r);
 391 }
 392
 393 _PUBLIC_ enum ndr_err_code ndr_push_samr_PasswordProperties(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 394 {
 395         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 396         return NDR_ERR_SUCCESS;
 397 }
 398
 399 _PUBLIC_ enum ndr_err_code ndr_pull_samr_PasswordProperties(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 400 {
 401         uint32_t v;
 402         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 403         *r = v;
 404         return NDR_ERR_SUCCESS;
 405 }
 406
 407 _PUBLIC_ void ndr_print_samr_PasswordProperties(struct ndr_print *ndr, const char *name, uint32_t r)
 408 {
 409         ndr_print_uint32(ndr, name, r);
 410         ndr->depth++;
 411         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_COMPLEX", DOMAIN_PASSWORD_COMPLEX, r);
 412         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_NO_ANON_CHANGE", DOMAIN_PASSWORD_NO_ANON_CHANGE, r);
 413         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_NO_CLEAR_CHANGE", DOMAIN_PASSWORD_NO_CLEAR_CHANGE, r);
 414         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_LOCKOUT_ADMINS", DOMAIN_PASSWORD_LOCKOUT_ADMINS, r);
 415         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_STORE_CLEARTEXT", DOMAIN_PASSWORD_STORE_CLEARTEXT, r);
 416         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_REFUSE_PASSWORD_CHANGE", DOMAIN_REFUSE_PASSWORD_CHANGE, r);
 417         ndr->depth--;
 418 }
 419
 420 static enum ndr_err_code ndr_push_samr_DomainServerState(struct ndr_push *ndr, int ndr_flags, enum samr_DomainServerState r)
 421 {
 422         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 423         return NDR_ERR_SUCCESS;
 424 }
 425
 426 static enum ndr_err_code ndr_pull_samr_DomainServerState(struct ndr_pull *ndr, int ndr_flags, enum samr_DomainServerState *r)
 427 {
 428         uint32_t v;
 429         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 430         *r = v;
 431         return NDR_ERR_SUCCESS;
 432 }
 433
 434 _PUBLIC_ void ndr_print_samr_DomainServerState(struct ndr_print *ndr, const char *name, enum samr_DomainServerState r)
 435 {
 436         const char *val = NULL;
 437
 438         switch (r) {
 439                 case DOMAIN_SERVER_ENABLED: val = "DOMAIN_SERVER_ENABLED"; break;
 440                 case DOMAIN_SERVER_DISABLED: val = "DOMAIN_SERVER_DISABLED"; break;
 441         }
 442         ndr_print_enum(ndr, name, "ENUM", val, r);
 443 }
 444
 445 static enum ndr_err_code ndr_push_samr_DomInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo1 *r)
 446 {
 447         if (ndr_flags & NDR_SCALARS) {
 448                 NDR_CHECK(ndr_push_align(ndr, 4));
 449                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->min_password_length));
 450                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->password_history_length));
 451                 NDR_CHECK(ndr_push_samr_PasswordProperties(ndr, NDR_SCALARS, r->password_properties));
 452                 NDR_CHECK(ndr_push_dlong(ndr, NDR_SCALARS, r->max_password_age));
 453                 NDR_CHECK(ndr_push_dlong(ndr, NDR_SCALARS, r->min_password_age));
 454         }
 455         if (ndr_flags & NDR_BUFFERS) {
 456         }
 457         return NDR_ERR_SUCCESS;
 458 }
 459
 460 static enum ndr_err_code ndr_pull_samr_DomInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo1 *r)
 461 {
 462         if (ndr_flags & NDR_SCALARS) {
 463                 NDR_CHECK(ndr_pull_align(ndr, 4));
 464                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->min_password_length));
 465                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->password_history_length));
 466                 NDR_CHECK(ndr_pull_samr_PasswordProperties(ndr, NDR_SCALARS, &r->password_properties));
 467                 NDR_CHECK(ndr_pull_dlong(ndr, NDR_SCALARS, &r->max_password_age));
 468                 NDR_CHECK(ndr_pull_dlong(ndr, NDR_SCALARS, &r->min_password_age));
 469         }
 470         if (ndr_flags & NDR_BUFFERS) {
 471         }
 472         return NDR_ERR_SUCCESS;
 473 }
 474
 475 _PUBLIC_ void ndr_print_samr_DomInfo1(struct ndr_print *ndr, const char *name, const struct samr_DomInfo1 *r)
 476 {
 477         ndr_print_struct(ndr, name, "samr_DomInfo1");
 478         ndr->depth++;
 479         ndr_print_uint16(ndr, "min_password_length", r->min_password_length);
 480         ndr_print_uint16(ndr, "password_history_length", r->password_history_length);
 481         ndr_print_samr_PasswordProperties(ndr, "password_properties", r->password_properties);
 482         ndr_print_dlong(ndr, "max_password_age", r->max_password_age);
 483         ndr_print_dlong(ndr, "min_password_age", r->min_password_age);
 484         ndr->depth--;
 485 }
 486
 487 static enum ndr_err_code ndr_push_samr_DomGeneralInformation(struct ndr_push *ndr, int ndr_flags, const struct samr_DomGeneralInformation *r)
 488 {
 489         if (ndr_flags & NDR_SCALARS) {
 490                 NDR_CHECK(ndr_push_align(ndr, 4));
 491                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_logoff_time));
 492                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 493                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 494                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->primary));
 495                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->sequence_num));
 496                 NDR_CHECK(ndr_push_samr_DomainServerState(ndr, NDR_SCALARS, r->domain_server_state));
 497                 NDR_CHECK(ndr_push_samr_Role(ndr, NDR_SCALARS, r->role));
 498                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
 499                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_users));
 500                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_groups));
 501                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_aliases));
 502         }
 503         if (ndr_flags & NDR_BUFFERS) {
 504                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 505                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 506                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 507         }
 508         return NDR_ERR_SUCCESS;
 509 }
 510
 511 static enum ndr_err_code ndr_pull_samr_DomGeneralInformation(struct ndr_pull *ndr, int ndr_flags, struct samr_DomGeneralInformation *r)
 512 {
 513         if (ndr_flags & NDR_SCALARS) {
 514                 NDR_CHECK(ndr_pull_align(ndr, 4));
 515                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_logoff_time));
 516                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 517                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 518                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->primary));
 519                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->sequence_num));
 520                 NDR_CHECK(ndr_pull_samr_DomainServerState(ndr, NDR_SCALARS, &r->domain_server_state));
 521                 NDR_CHECK(ndr_pull_samr_Role(ndr, NDR_SCALARS, &r->role));
 522                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
 523                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_users));
 524                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_groups));
 525                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_aliases));
 526         }
 527         if (ndr_flags & NDR_BUFFERS) {
 528                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 529                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 530                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 531         }
 532         return NDR_ERR_SUCCESS;
 533 }
 534
 535 _PUBLIC_ void ndr_print_samr_DomGeneralInformation(struct ndr_print *ndr, const char *name, const struct samr_DomGeneralInformation *r)
 536 {
 537         ndr_print_struct(ndr, name, "samr_DomGeneralInformation");
 538         ndr->depth++;
 539         ndr_print_NTTIME(ndr, "force_logoff_time", r->force_logoff_time);
 540         ndr_print_lsa_String(ndr, "oem_information", &r->oem_information);
 541         ndr_print_lsa_String(ndr, "domain_name", &r->domain_name);
 542         ndr_print_lsa_String(ndr, "primary", &r->primary);
 543         ndr_print_udlong(ndr, "sequence_num", r->sequence_num);
 544         ndr_print_samr_DomainServerState(ndr, "domain_server_state", r->domain_server_state);
 545         ndr_print_samr_Role(ndr, "role", r->role);
 546         ndr_print_uint32(ndr, "unknown3", r->unknown3);
 547         ndr_print_uint32(ndr, "num_users", r->num_users);
 548         ndr_print_uint32(ndr, "num_groups", r->num_groups);
 549         ndr_print_uint32(ndr, "num_aliases", r->num_aliases);
 550         ndr->depth--;
 551 }
 552
 553 static enum ndr_err_code ndr_push_samr_DomInfo3(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo3 *r)
 554 {
 555         if (ndr_flags & NDR_SCALARS) {
 556                 NDR_CHECK(ndr_push_align(ndr, 4));
 557                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_logoff_time));
 558         }
 559         if (ndr_flags & NDR_BUFFERS) {
 560         }
 561         return NDR_ERR_SUCCESS;
 562 }
 563
 564 static enum ndr_err_code ndr_pull_samr_DomInfo3(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo3 *r)
 565 {
 566         if (ndr_flags & NDR_SCALARS) {
 567                 NDR_CHECK(ndr_pull_align(ndr, 4));
 568                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_logoff_time));
 569         }
 570         if (ndr_flags & NDR_BUFFERS) {
 571         }
 572         return NDR_ERR_SUCCESS;
 573 }
 574
 575 _PUBLIC_ void ndr_print_samr_DomInfo3(struct ndr_print *ndr, const char *name, const struct samr_DomInfo3 *r)
 576 {
 577         ndr_print_struct(ndr, name, "samr_DomInfo3");
 578         ndr->depth++;
 579         ndr_print_NTTIME(ndr, "force_logoff_time", r->force_logoff_time);
 580         ndr->depth--;
 581 }
 582
 583 static enum ndr_err_code ndr_push_samr_DomOEMInformation(struct ndr_push *ndr, int ndr_flags, const struct samr_DomOEMInformation *r)
 584 {
 585         if (ndr_flags & NDR_SCALARS) {
 586                 NDR_CHECK(ndr_push_align(ndr, 4));
 587                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 588         }
 589         if (ndr_flags & NDR_BUFFERS) {
 590                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 591         }
 592         return NDR_ERR_SUCCESS;
 593 }
 594
 595 static enum ndr_err_code ndr_pull_samr_DomOEMInformation(struct ndr_pull *ndr, int ndr_flags, struct samr_DomOEMInformation *r)
 596 {
 597         if (ndr_flags & NDR_SCALARS) {
 598                 NDR_CHECK(ndr_pull_align(ndr, 4));
 599                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 600         }
 601         if (ndr_flags & NDR_BUFFERS) {
 602                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 603         }
 604         return NDR_ERR_SUCCESS;
 605 }
 606
 607 _PUBLIC_ void ndr_print_samr_DomOEMInformation(struct ndr_print *ndr, const char *name, const struct samr_DomOEMInformation *r)
 608 {
 609         ndr_print_struct(ndr, name, "samr_DomOEMInformation");
 610         ndr->depth++;
 611         ndr_print_lsa_String(ndr, "oem_information", &r->oem_information);
 612         ndr->depth--;
 613 }
 614
 615 static enum ndr_err_code ndr_push_samr_DomInfo5(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo5 *r)
 616 {
 617         if (ndr_flags & NDR_SCALARS) {
 618                 NDR_CHECK(ndr_push_align(ndr, 4));
 619                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 620         }
 621         if (ndr_flags & NDR_BUFFERS) {
 622                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 623         }
 624         return NDR_ERR_SUCCESS;
 625 }
 626
 627 static enum ndr_err_code ndr_pull_samr_DomInfo5(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo5 *r)
 628 {
 629         if (ndr_flags & NDR_SCALARS) {
 630                 NDR_CHECK(ndr_pull_align(ndr, 4));
 631                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 632         }
 633         if (ndr_flags & NDR_BUFFERS) {
 634                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 635         }
 636         return NDR_ERR_SUCCESS;
 637 }
 638
 639 _PUBLIC_ void ndr_print_samr_DomInfo5(struct ndr_print *ndr, const char *name, const struct samr_DomInfo5 *r)
 640 {
 641         ndr_print_struct(ndr, name, "samr_DomInfo5");
 642         ndr->depth++;
 643         ndr_print_lsa_String(ndr, "domain_name", &r->domain_name);
 644         ndr->depth--;
 645 }
 646
 647 static enum ndr_err_code ndr_push_samr_DomInfo6(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo6 *r)
 648 {
 649         if (ndr_flags & NDR_SCALARS) {
 650                 NDR_CHECK(ndr_push_align(ndr, 4));
 651                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->primary));
 652         }
 653         if (ndr_flags & NDR_BUFFERS) {
 654                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 655         }
 656         return NDR_ERR_SUCCESS;
 657 }
 658
 659 static enum ndr_err_code ndr_pull_samr_DomInfo6(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo6 *r)
 660 {
 661         if (ndr_flags & NDR_SCALARS) {
 662                 NDR_CHECK(ndr_pull_align(ndr, 4));
 663                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->primary));
 664         }
 665         if (ndr_flags & NDR_BUFFERS) {
 666                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 667         }
 668         return NDR_ERR_SUCCESS;
 669 }
 670
 671 _PUBLIC_ void ndr_print_samr_DomInfo6(struct ndr_print *ndr, const char *name, const struct samr_DomInfo6 *r)
 672 {
 673         ndr_print_struct(ndr, name, "samr_DomInfo6");
 674         ndr->depth++;
 675         ndr_print_lsa_String(ndr, "primary", &r->primary);
 676         ndr->depth--;
 677 }
 678
 679 static enum ndr_err_code ndr_push_samr_DomInfo7(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo7 *r)
 680 {
 681         if (ndr_flags & NDR_SCALARS) {
 682                 NDR_CHECK(ndr_push_align(ndr, 4));
 683                 NDR_CHECK(ndr_push_samr_Role(ndr, NDR_SCALARS, r->role));
 684         }
 685         if (ndr_flags & NDR_BUFFERS) {
 686         }
 687         return NDR_ERR_SUCCESS;
 688 }
 689
 690 static enum ndr_err_code ndr_pull_samr_DomInfo7(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo7 *r)
 691 {
 692         if (ndr_flags & NDR_SCALARS) {
 693                 NDR_CHECK(ndr_pull_align(ndr, 4));
 694                 NDR_CHECK(ndr_pull_samr_Role(ndr, NDR_SCALARS, &r->role));
 695         }
 696         if (ndr_flags & NDR_BUFFERS) {
 697         }
 698         return NDR_ERR_SUCCESS;
 699 }
 700
 701 _PUBLIC_ void ndr_print_samr_DomInfo7(struct ndr_print *ndr, const char *name, const struct samr_DomInfo7 *r)
 702 {
 703         ndr_print_struct(ndr, name, "samr_DomInfo7");
 704         ndr->depth++;
 705         ndr_print_samr_Role(ndr, "role", r->role);
 706         ndr->depth--;
 707 }
 708
 709 static enum ndr_err_code ndr_push_samr_DomInfo8(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo8 *r)
 710 {
 711         if (ndr_flags & NDR_SCALARS) {
 712                 NDR_CHECK(ndr_push_align(ndr, 8));
 713                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->sequence_num));
 714                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->domain_create_time));
 715         }
 716         if (ndr_flags & NDR_BUFFERS) {
 717         }
 718         return NDR_ERR_SUCCESS;
 719 }
 720
 721 static enum ndr_err_code ndr_pull_samr_DomInfo8(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo8 *r)
 722 {
 723         if (ndr_flags & NDR_SCALARS) {
 724                 NDR_CHECK(ndr_pull_align(ndr, 8));
 725                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->sequence_num));
 726                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->domain_create_time));
 727         }
 728         if (ndr_flags & NDR_BUFFERS) {
 729         }
 730         return NDR_ERR_SUCCESS;
 731 }
 732
 733 _PUBLIC_ void ndr_print_samr_DomInfo8(struct ndr_print *ndr, const char *name, const struct samr_DomInfo8 *r)
 734 {
 735         ndr_print_struct(ndr, name, "samr_DomInfo8");
 736         ndr->depth++;
 737         ndr_print_hyper(ndr, "sequence_num", r->sequence_num);
 738         ndr_print_NTTIME(ndr, "domain_create_time", r->domain_create_time);
 739         ndr->depth--;
 740 }
 741
 742 static enum ndr_err_code ndr_push_samr_DomInfo9(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo9 *r)
 743 {
 744         if (ndr_flags & NDR_SCALARS) {
 745                 NDR_CHECK(ndr_push_align(ndr, 4));
 746                 NDR_CHECK(ndr_push_samr_DomainServerState(ndr, NDR_SCALARS, r->domain_server_state));
 747         }
 748         if (ndr_flags & NDR_BUFFERS) {
 749         }
 750         return NDR_ERR_SUCCESS;
 751 }
 752
 753 static enum ndr_err_code ndr_pull_samr_DomInfo9(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo9 *r)
 754 {
 755         if (ndr_flags & NDR_SCALARS) {
 756                 NDR_CHECK(ndr_pull_align(ndr, 4));
 757                 NDR_CHECK(ndr_pull_samr_DomainServerState(ndr, NDR_SCALARS, &r->domain_server_state));
 758         }
 759         if (ndr_flags & NDR_BUFFERS) {
 760         }
 761         return NDR_ERR_SUCCESS;
 762 }
 763
 764 _PUBLIC_ void ndr_print_samr_DomInfo9(struct ndr_print *ndr, const char *name, const struct samr_DomInfo9 *r)
 765 {
 766         ndr_print_struct(ndr, name, "samr_DomInfo9");
 767         ndr->depth++;
 768         ndr_print_samr_DomainServerState(ndr, "domain_server_state", r->domain_server_state);
 769         ndr->depth--;
 770 }
 771
 772 static enum ndr_err_code ndr_push_samr_DomGeneralInformation2(struct ndr_push *ndr, int ndr_flags, const struct samr_DomGeneralInformation2 *r)
 773 {
 774         if (ndr_flags & NDR_SCALARS) {
 775                 NDR_CHECK(ndr_push_align(ndr, 8));
 776                 NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 777                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_duration));
 778                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_window));
 779                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lockout_threshold));
 780         }
 781         if (ndr_flags & NDR_BUFFERS) {
 782                 NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
 783         }
 784         return NDR_ERR_SUCCESS;
 785 }
 786
 787 static enum ndr_err_code ndr_pull_samr_DomGeneralInformation2(struct ndr_pull *ndr, int ndr_flags, struct samr_DomGeneralInformation2 *r)
 788 {
 789         if (ndr_flags & NDR_SCALARS) {
 790                 NDR_CHECK(ndr_pull_align(ndr, 8));
 791                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 792                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_duration));
 793                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_window));
 794                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lockout_threshold));
 795         }
 796         if (ndr_flags & NDR_BUFFERS) {
 797                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
 798         }
 799         return NDR_ERR_SUCCESS;
 800 }
 801
 802 _PUBLIC_ void ndr_print_samr_DomGeneralInformation2(struct ndr_print *ndr, const char *name, const struct samr_DomGeneralInformation2 *r)
 803 {
 804         ndr_print_struct(ndr, name, "samr_DomGeneralInformation2");
 805         ndr->depth++;
 806         ndr_print_samr_DomGeneralInformation(ndr, "general", &r->general);
 807         ndr_print_hyper(ndr, "lockout_duration", r->lockout_duration);
 808         ndr_print_hyper(ndr, "lockout_window", r->lockout_window);
 809         ndr_print_uint16(ndr, "lockout_threshold", r->lockout_threshold);
 810         ndr->depth--;
 811 }
 812
 813 static enum ndr_err_code ndr_push_samr_DomInfo12(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo12 *r)
 814 {
 815         if (ndr_flags & NDR_SCALARS) {
 816                 NDR_CHECK(ndr_push_align(ndr, 8));
 817                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_duration));
 818                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_window));
 819                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lockout_threshold));
 820         }
 821         if (ndr_flags & NDR_BUFFERS) {
 822         }
 823         return NDR_ERR_SUCCESS;
 824 }
 825
 826 static enum ndr_err_code ndr_pull_samr_DomInfo12(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo12 *r)
 827 {
 828         if (ndr_flags & NDR_SCALARS) {
 829                 NDR_CHECK(ndr_pull_align(ndr, 8));
 830                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_duration));
 831                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_window));
 832                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lockout_threshold));
 833         }
 834         if (ndr_flags & NDR_BUFFERS) {
 835         }
 836         return NDR_ERR_SUCCESS;
 837 }
 838
 839 _PUBLIC_ void ndr_print_samr_DomInfo12(struct ndr_print *ndr, const char *name, const struct samr_DomInfo12 *r)
 840 {
 841         ndr_print_struct(ndr, name, "samr_DomInfo12");
 842         ndr->depth++;
 843         ndr_print_hyper(ndr, "lockout_duration", r->lockout_duration);
 844         ndr_print_hyper(ndr, "lockout_window", r->lockout_window);
 845         ndr_print_uint16(ndr, "lockout_threshold", r->lockout_threshold);
 846         ndr->depth--;
 847 }
 848
 849 static enum ndr_err_code ndr_push_samr_DomInfo13(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo13 *r)
 850 {
 851         if (ndr_flags & NDR_SCALARS) {
 852                 NDR_CHECK(ndr_push_align(ndr, 8));
 853                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->sequence_num));
 854                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->domain_create_time));
 855                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->modified_count_at_last_promotion));
 856         }
 857         if (ndr_flags & NDR_BUFFERS) {
 858         }
 859         return NDR_ERR_SUCCESS;
 860 }
 861
 862 static enum ndr_err_code ndr_pull_samr_DomInfo13(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo13 *r)
 863 {
 864         if (ndr_flags & NDR_SCALARS) {
 865                 NDR_CHECK(ndr_pull_align(ndr, 8));
 866                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->sequence_num));
 867                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->domain_create_time));
 868                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->modified_count_at_last_promotion));
 869         }
 870         if (ndr_flags & NDR_BUFFERS) {
 871         }
 872         return NDR_ERR_SUCCESS;
 873 }
 874
 875 _PUBLIC_ void ndr_print_samr_DomInfo13(struct ndr_print *ndr, const char *name, const struct samr_DomInfo13 *r)
 876 {
 877         ndr_print_struct(ndr, name, "samr_DomInfo13");
 878         ndr->depth++;
 879         ndr_print_hyper(ndr, "sequence_num", r->sequence_num);
 880         ndr_print_NTTIME(ndr, "domain_create_time", r->domain_create_time);
 881         ndr_print_hyper(ndr, "modified_count_at_last_promotion", r->modified_count_at_last_promotion);
 882         ndr->depth--;
 883 }
 884
 885 static enum ndr_err_code ndr_push_samr_DomainInfo(struct ndr_push *ndr, int ndr_flags, const union samr_DomainInfo *r)
 886 {
 887         if (ndr_flags & NDR_SCALARS) {
 888                 int level = ndr_push_get_switch_value(ndr, r);
 889                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
 890                 switch (level) {
 891                         case 1: {
 892                                 NDR_CHECK(ndr_push_samr_DomInfo1(ndr, NDR_SCALARS, &r->info1));
 893                         break; }
 894
 895                         case 2: {
 896                                 NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 897                         break; }
 898
 899                         case 3: {
 900                                 NDR_CHECK(ndr_push_samr_DomInfo3(ndr, NDR_SCALARS, &r->info3));
 901                         break; }
 902
 903                         case 4: {
 904                                 NDR_CHECK(ndr_push_samr_DomOEMInformation(ndr, NDR_SCALARS, &r->oem));
 905                         break; }
 906
 907                         case 5: {
 908                                 NDR_CHECK(ndr_push_samr_DomInfo5(ndr, NDR_SCALARS, &r->info5));
 909                         break; }
 910
 911                         case 6: {
 912                                 NDR_CHECK(ndr_push_samr_DomInfo6(ndr, NDR_SCALARS, &r->info6));
 913                         break; }
 914
 915                         case 7: {
 916                                 NDR_CHECK(ndr_push_samr_DomInfo7(ndr, NDR_SCALARS, &r->info7));
 917                         break; }
 918
 919                         case 8: {
 920                                 NDR_CHECK(ndr_push_samr_DomInfo8(ndr, NDR_SCALARS, &r->info8));
 921                         break; }
 922
 923                         case 9: {
 924                                 NDR_CHECK(ndr_push_samr_DomInfo9(ndr, NDR_SCALARS, &r->info9));
 925                         break; }
 926
 927                         case 11: {
 928                                 NDR_CHECK(ndr_push_samr_DomGeneralInformation2(ndr, NDR_SCALARS, &r->general2));
 929                         break; }
 930
 931                         case 12: {
 932                                 NDR_CHECK(ndr_push_samr_DomInfo12(ndr, NDR_SCALARS, &r->info12));
 933                         break; }
 934
 935                         case 13: {
 936                                 NDR_CHECK(ndr_push_samr_DomInfo13(ndr, NDR_SCALARS, &r->info13));
 937                         break; }
 938
 939                         default:
 940                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 941                 }
 942         }
 943         if (ndr_flags & NDR_BUFFERS) {
 944                 int level = ndr_push_get_switch_value(ndr, r);
 945                 switch (level) {
 946                         case 1:
 947                         break;
 948
 949                         case 2:
 950                                 NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
 951                         break;
 952
 953                         case 3:
 954                         break;
 955
 956                         case 4:
 957                                 NDR_CHECK(ndr_push_samr_DomOEMInformation(ndr, NDR_BUFFERS, &r->oem));
 958                         break;
 959
 960                         case 5:
 961                                 NDR_CHECK(ndr_push_samr_DomInfo5(ndr, NDR_BUFFERS, &r->info5));
 962                         break;
 963
 964                         case 6:
 965                                 NDR_CHECK(ndr_push_samr_DomInfo6(ndr, NDR_BUFFERS, &r->info6));
 966                         break;
 967
 968                         case 7:
 969                         break;
 970
 971                         case 8:
 972                         break;
 973
 974                         case 9:
 975                         break;
 976
 977                         case 11:
 978                                 NDR_CHECK(ndr_push_samr_DomGeneralInformation2(ndr, NDR_BUFFERS, &r->general2));
 979                         break;
 980
 981                         case 12:
 982                         break;
 983
 984                         case 13:
 985                         break;
 986
 987                         default:
 988                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 989                 }
 990         }
 991         return NDR_ERR_SUCCESS;
 992 }
 993
 994 static enum ndr_err_code ndr_pull_samr_DomainInfo(struct ndr_pull *ndr, int ndr_flags, union samr_DomainInfo *r)
 995 {
 996         int level;
 997         uint16_t _level;
 998         level = ndr_pull_get_switch_value(ndr, r);
 999         if (ndr_flags & NDR_SCALARS) {
1000                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
1001                 if (_level != level) {
1002                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1003                 }
1004                 switch (level) {
1005                         case 1: {
1006                                 NDR_CHECK(ndr_pull_samr_DomInfo1(ndr, NDR_SCALARS, &r->info1));
1007                         break; }
1008
1009                         case 2: {
1010                                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
1011                         break; }
1012
1013                         case 3: {
1014                                 NDR_CHECK(ndr_pull_samr_DomInfo3(ndr, NDR_SCALARS, &r->info3));
1015                         break; }
1016
1017                         case 4: {
1018                                 NDR_CHECK(ndr_pull_samr_DomOEMInformation(ndr, NDR_SCALARS, &r->oem));
1019                         break; }
1020
1021                         case 5: {
1022                                 NDR_CHECK(ndr_pull_samr_DomInfo5(ndr, NDR_SCALARS, &r->info5));
1023                         break; }
1024
1025                         case 6: {
1026                                 NDR_CHECK(ndr_pull_samr_DomInfo6(ndr, NDR_SCALARS, &r->info6));
1027                         break; }
1028
1029                         case 7: {
1030                                 NDR_CHECK(ndr_pull_samr_DomInfo7(ndr, NDR_SCALARS, &r->info7));
1031                         break; }
1032
1033                         case 8: {
1034                                 NDR_CHECK(ndr_pull_samr_DomInfo8(ndr, NDR_SCALARS, &r->info8));
1035                         break; }
1036
1037                         case 9: {
1038                                 NDR_CHECK(ndr_pull_samr_DomInfo9(ndr, NDR_SCALARS, &r->info9));
1039                         break; }
1040
1041                         case 11: {
1042                                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation2(ndr, NDR_SCALARS, &r->general2));
1043                         break; }
1044
1045                         case 12: {
1046                                 NDR_CHECK(ndr_pull_samr_DomInfo12(ndr, NDR_SCALARS, &r->info12));
1047                         break; }
1048
1049                         case 13: {
1050                                 NDR_CHECK(ndr_pull_samr_DomInfo13(ndr, NDR_SCALARS, &r->info13));
1051                         break; }
1052
1053                         default:
1054                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1055                 }
1056         }
1057         if (ndr_flags & NDR_BUFFERS) {
1058                 switch (level) {
1059                         case 1:
1060                         break;
1061
1062                         case 2:
1063                                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
1064                         break;
1065
1066                         case 3:
1067                         break;
1068
1069                         case 4:
1070                                 NDR_CHECK(ndr_pull_samr_DomOEMInformation(ndr, NDR_BUFFERS, &r->oem));
1071                         break;
1072
1073                         case 5:
1074                                 NDR_CHECK(ndr_pull_samr_DomInfo5(ndr, NDR_BUFFERS, &r->info5));
1075                         break;
1076
1077                         case 6:
1078                                 NDR_CHECK(ndr_pull_samr_DomInfo6(ndr, NDR_BUFFERS, &r->info6));
1079                         break;
1080
1081                         case 7:
1082                         break;
1083
1084                         case 8:
1085                         break;
1086
1087                         case 9:
1088                         break;
1089
1090                         case 11:
1091                                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation2(ndr, NDR_BUFFERS, &r->general2));
1092                         break;
1093
1094                         case 12:
1095                         break;
1096
1097                         case 13:
1098                         break;
1099
1100                         default:
1101                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1102                 }
1103         }
1104         return NDR_ERR_SUCCESS;
1105 }
1106
1107 _PUBLIC_ void ndr_print_samr_DomainInfo(struct ndr_print *ndr, const char *name, const union samr_DomainInfo *r)
1108 {
1109         int level;
1110         level = ndr_print_get_switch_value(ndr, r);
1111         ndr_print_union(ndr, name, level, "samr_DomainInfo");
1112         switch (level) {
1113                 case 1:
1114                         ndr_print_samr_DomInfo1(ndr, "info1", &r->info1);
1115                 break;
1116
1117                 case 2:
1118                         ndr_print_samr_DomGeneralInformation(ndr, "general", &r->general);
1119                 break;
1120
1121                 case 3:
1122                         ndr_print_samr_DomInfo3(ndr, "info3", &r->info3);
1123                 break;
1124
1125                 case 4:
1126                         ndr_print_samr_DomOEMInformation(ndr, "oem", &r->oem);
1127                 break;
1128
1129                 case 5:
1130                         ndr_print_samr_DomInfo5(ndr, "info5", &r->info5);
1131                 break;
1132
1133                 case 6:
1134                         ndr_print_samr_DomInfo6(ndr, "info6", &r->info6);
1135                 break;
1136
1137                 case 7:
1138                         ndr_print_samr_DomInfo7(ndr, "info7", &r->info7);
1139                 break;
1140
1141                 case 8:
1142                         ndr_print_samr_DomInfo8(ndr, "info8", &r->info8);
1143                 break;
1144
1145                 case 9:
1146                         ndr_print_samr_DomInfo9(ndr, "info9", &r->info9);
1147                 break;
1148
1149                 case 11:
1150                         ndr_print_samr_DomGeneralInformation2(ndr, "general2", &r->general2);
1151                 break;
1152
1153                 case 12:
1154                         ndr_print_samr_DomInfo12(ndr, "info12", &r->info12);
1155                 break;
1156
1157                 case 13:
1158                         ndr_print_samr_DomInfo13(ndr, "info13", &r->info13);
1159                 break;
1160
1161                 default:
1162                         ndr_print_bad_level(ndr, name, level);
1163         }
1164 }
1165
1166 static enum ndr_err_code ndr_push_samr_Ids(struct ndr_push *ndr, int ndr_flags, const struct samr_Ids *r)
1167 {
1168         uint32_t cntr_ids_1;
1169         if (ndr_flags & NDR_SCALARS) {
1170                 NDR_CHECK(ndr_push_align(ndr, 4));
1171                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1172                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ids));
1173         }
1174         if (ndr_flags & NDR_BUFFERS) {
1175                 if (r->ids) {
1176                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1177                         for (cntr_ids_1 = 0; cntr_ids_1 < r->count; cntr_ids_1++) {
1178                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ids[cntr_ids_1]));
1179                         }
1180                 }
1181         }
1182         return NDR_ERR_SUCCESS;
1183 }
1184
1185 static enum ndr_err_code ndr_pull_samr_Ids(struct ndr_pull *ndr, int ndr_flags, struct samr_Ids *r)
1186 {
1187         uint32_t _ptr_ids;
1188         uint32_t cntr_ids_1;
1189         TALLOC_CTX *_mem_save_ids_0;
1190         TALLOC_CTX *_mem_save_ids_1;
1191         if (ndr_flags & NDR_SCALARS) {
1192                 NDR_CHECK(ndr_pull_align(ndr, 4));
1193                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1194                 if (r->count < 0 || r->count > 1024) {
1195                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1196                 }
1197                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ids));
1198                 if (_ptr_ids) {
1199                         NDR_PULL_ALLOC(ndr, r->ids);
1200                 } else {
1201                         r->ids = NULL;
1202                 }
1203         }
1204         if (ndr_flags & NDR_BUFFERS) {
1205                 if (r->ids) {
1206                         _mem_save_ids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1207                         NDR_PULL_SET_MEM_CTX(ndr, r->ids, 0);
1208                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ids));
1209                         NDR_PULL_ALLOC_N(ndr, r->ids, ndr_get_array_size(ndr, &r->ids));
1210                         _mem_save_ids_1 = NDR_PULL_GET_MEM_CTX(ndr);
1211                         NDR_PULL_SET_MEM_CTX(ndr, r->ids, 0);
1212                         for (cntr_ids_1 = 0; cntr_ids_1 < r->count; cntr_ids_1++) {
1213                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ids[cntr_ids_1]));
1214                         }
1215                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ids_1, 0);
1216                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ids_0, 0);
1217                 }
1218                 if (r->ids) {
1219                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->ids, r->count));
1220                 }
1221         }
1222         return NDR_ERR_SUCCESS;
1223 }
1224
1225 _PUBLIC_ void ndr_print_samr_Ids(struct ndr_print *ndr, const char *name, const struct samr_Ids *r)
1226 {
1227         uint32_t cntr_ids_1;
1228         ndr_print_struct(ndr, name, "samr_Ids");
1229         ndr->depth++;
1230         ndr_print_uint32(ndr, "count", r->count);
1231         ndr_print_ptr(ndr, "ids", r->ids);
1232         ndr->depth++;
1233         if (r->ids) {
1234                 ndr->print(ndr, "%s: ARRAY(%d)", "ids", (int)r->count);
1235                 ndr->depth++;
1236                 for (cntr_ids_1=0;cntr_ids_1<r->count;cntr_ids_1++) {
1237                         char *idx_1=NULL;
1238                         if (asprintf(&idx_1, "[%d]", cntr_ids_1) != -1) {
1239                                 ndr_print_uint32(ndr, "ids", r->ids[cntr_ids_1]);
1240                                 free(idx_1);
1241                         }
1242                 }
1243                 ndr->depth--;
1244         }
1245         ndr->depth--;
1246         ndr->depth--;
1247 }
1248
1249 _PUBLIC_ enum ndr_err_code ndr_push_samr_GroupAttrs(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1250 {
1251         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1252         return NDR_ERR_SUCCESS;
1253 }
1254
1255 _PUBLIC_ enum ndr_err_code ndr_pull_samr_GroupAttrs(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1256 {
1257         uint32_t v;
1258         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1259         *r = v;
1260         return NDR_ERR_SUCCESS;
1261 }
1262
1263 _PUBLIC_ void ndr_print_samr_GroupAttrs(struct ndr_print *ndr, const char *name, uint32_t r)
1264 {
1265         ndr_print_uint32(ndr, name, r);
1266         ndr->depth++;
1267         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_MANDATORY", SE_GROUP_MANDATORY, r);
1268         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_ENABLED_BY_DEFAULT", SE_GROUP_ENABLED_BY_DEFAULT, r);
1269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_ENABLED", SE_GROUP_ENABLED, r);
1270         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_OWNER", SE_GROUP_OWNER, r);
1271         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_USE_FOR_DENY_ONLY", SE_GROUP_USE_FOR_DENY_ONLY, r);
1272         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_RESOURCE", SE_GROUP_RESOURCE, r);
1273         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_LOGON_ID", SE_GROUP_LOGON_ID, r);
1274         ndr->depth--;
1275 }
1276
1277 static enum ndr_err_code ndr_push_samr_GroupInfoAll(struct ndr_push *ndr, int ndr_flags, const struct samr_GroupInfoAll *r)
1278 {
1279         if (ndr_flags & NDR_SCALARS) {
1280                 NDR_CHECK(ndr_push_align(ndr, 4));
1281                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1282                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
1283                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_members));
1284                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1285         }
1286         if (ndr_flags & NDR_BUFFERS) {
1287                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1288                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1289         }
1290         return NDR_ERR_SUCCESS;
1291 }
1292
1293 static enum ndr_err_code ndr_pull_samr_GroupInfoAll(struct ndr_pull *ndr, int ndr_flags, struct samr_GroupInfoAll *r)
1294 {
1295         if (ndr_flags & NDR_SCALARS) {
1296                 NDR_CHECK(ndr_pull_align(ndr, 4));
1297                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1298                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
1299                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_members));
1300                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1301         }
1302         if (ndr_flags & NDR_BUFFERS) {
1303                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1304                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1305         }
1306         return NDR_ERR_SUCCESS;
1307 }
1308
1309 _PUBLIC_ void ndr_print_samr_GroupInfoAll(struct ndr_print *ndr, const char *name, const struct samr_GroupInfoAll *r)
1310 {
1311         ndr_print_struct(ndr, name, "samr_GroupInfoAll");
1312         ndr->depth++;
1313         ndr_print_lsa_String(ndr, "name", &r->name);
1314         ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);
1315         ndr_print_uint32(ndr, "num_members", r->num_members);
1316         ndr_print_lsa_String(ndr, "description", &r->description);
1317         ndr->depth--;
1318 }
1319
1320 static enum ndr_err_code ndr_push_samr_GroupInfoAttributes(struct ndr_push *ndr, int ndr_flags, const struct samr_GroupInfoAttributes *r)
1321 {
1322         if (ndr_flags & NDR_SCALARS) {
1323                 NDR_CHECK(ndr_push_align(ndr, 4));
1324                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
1325         }
1326         if (ndr_flags & NDR_BUFFERS) {
1327         }
1328         return NDR_ERR_SUCCESS;
1329 }
1330
1331 static enum ndr_err_code ndr_pull_samr_GroupInfoAttributes(struct ndr_pull *ndr, int ndr_flags, struct samr_GroupInfoAttributes *r)
1332 {
1333         if (ndr_flags & NDR_SCALARS) {
1334                 NDR_CHECK(ndr_pull_align(ndr, 4));
1335                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
1336         }
1337         if (ndr_flags & NDR_BUFFERS) {
1338         }
1339         return NDR_ERR_SUCCESS;
1340 }
1341
1342 _PUBLIC_ void ndr_print_samr_GroupInfoAttributes(struct ndr_print *ndr, const char *name, const struct samr_GroupInfoAttributes *r)
1343 {
1344         ndr_print_struct(ndr, name, "samr_GroupInfoAttributes");
1345         ndr->depth++;
1346         ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);
1347         ndr->depth--;
1348 }
1349
1350 static enum ndr_err_code ndr_push_samr_GroupInfoEnum(struct ndr_push *ndr, int ndr_flags, enum samr_GroupInfoEnum r)
1351 {
1352         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
1353         return NDR_ERR_SUCCESS;
1354 }
1355
1356 static enum ndr_err_code ndr_pull_samr_GroupInfoEnum(struct ndr_pull *ndr, int ndr_flags, enum samr_GroupInfoEnum *r)
1357 {
1358         uint16_t v;
1359         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
1360         *r = v;
1361         return NDR_ERR_SUCCESS;
1362 }
1363
1364 _PUBLIC_ void ndr_print_samr_GroupInfoEnum(struct ndr_print *ndr, const char *name, enum samr_GroupInfoEnum r)
1365 {
1366         const char *val = NULL;
1367
1368         switch (r) {
1369                 case GROUPINFOALL: val = "GROUPINFOALL"; break;
1370                 case GROUPINFONAME: val = "GROUPINFONAME"; break;
1371                 case GROUPINFOATTRIBUTES: val = "GROUPINFOATTRIBUTES"; break;
1372                 case GROUPINFODESCRIPTION: val = "GROUPINFODESCRIPTION"; break;
1373                 case GROUPINFOALL2: val = "GROUPINFOALL2"; break;
1374         }
1375         ndr_print_enum(ndr, name, "ENUM", val, r);
1376 }
1377
1378 static enum ndr_err_code ndr_push_samr_GroupInfo(struct ndr_push *ndr, int ndr_flags, const union samr_GroupInfo *r)
1379 {
1380         if (ndr_flags & NDR_SCALARS) {
1381                 int level = ndr_push_get_switch_value(ndr, r);
1382                 NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, level));
1383                 switch (level) {
1384                         case GROUPINFOALL: {
1385                                 NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all));
1386                         break; }
1387
1388                         case GROUPINFONAME: {
1389                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1390                         break; }
1391
1392                         case GROUPINFOATTRIBUTES: {
1393                                 NDR_CHECK(ndr_push_samr_GroupInfoAttributes(ndr, NDR_SCALARS, &r->attributes));
1394                         break; }
1395
1396                         case GROUPINFODESCRIPTION: {
1397                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1398                         break; }
1399
1400                         case GROUPINFOALL2: {
1401                                 NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all2));
1402                         break; }
1403
1404                         default:
1405                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1406                 }
1407         }
1408         if (ndr_flags & NDR_BUFFERS) {
1409                 int level = ndr_push_get_switch_value(ndr, r);
1410                 switch (level) {
1411                         case GROUPINFOALL:
1412                                 NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all));
1413                         break;
1414
1415                         case GROUPINFONAME:
1416                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1417                         break;
1418
1419                         case GROUPINFOATTRIBUTES:
1420                         break;
1421
1422                         case GROUPINFODESCRIPTION:
1423                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1424                         break;
1425
1426                         case GROUPINFOALL2:
1427                                 NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all2));
1428                         break;
1429
1430                         default:
1431                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1432                 }
1433         }
1434         return NDR_ERR_SUCCESS;
1435 }
1436
1437 static enum ndr_err_code ndr_pull_samr_GroupInfo(struct ndr_pull *ndr, int ndr_flags, union samr_GroupInfo *r)
1438 {
1439         int level;
1440         uint16_t _level;
1441         level = ndr_pull_get_switch_value(ndr, r);
1442         if (ndr_flags & NDR_SCALARS) {
1443                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
1444                 if (_level != level) {
1445                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1446                 }
1447                 switch (level) {
1448                         case GROUPINFOALL: {
1449                                 NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all));
1450                         break; }
1451
1452                         case GROUPINFONAME: {
1453                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1454                         break; }
1455
1456                         case GROUPINFOATTRIBUTES: {
1457                                 NDR_CHECK(ndr_pull_samr_GroupInfoAttributes(ndr, NDR_SCALARS, &r->attributes));
1458                         break; }
1459
1460                         case GROUPINFODESCRIPTION: {
1461                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1462                         break; }
1463
1464                         case GROUPINFOALL2: {
1465                                 NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all2));
1466                         break; }
1467
1468                         default:
1469                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1470                 }
1471         }
1472         if (ndr_flags & NDR_BUFFERS) {
1473                 switch (level) {
1474                         case GROUPINFOALL:
1475                                 NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all));
1476                         break;
1477
1478                         case GROUPINFONAME:
1479                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1480                         break;
1481
1482                         case GROUPINFOATTRIBUTES:
1483                         break;
1484
1485                         case GROUPINFODESCRIPTION:
1486                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1487                         break;
1488
1489                         case GROUPINFOALL2:
1490                                 NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all2));
1491                         break;
1492
1493                         default:
1494                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1495                 }
1496         }
1497         return NDR_ERR_SUCCESS;
1498 }
1499
1500 _PUBLIC_ void ndr_print_samr_GroupInfo(struct ndr_print *ndr, const char *name, const union samr_GroupInfo *r)
1501 {
1502         int level;
1503         level = ndr_print_get_switch_value(ndr, r);
1504         ndr_print_union(ndr, name, level, "samr_GroupInfo");
1505         switch (level) {
1506                 case GROUPINFOALL:
1507                         ndr_print_samr_GroupInfoAll(ndr, "all", &r->all);
1508                 break;
1509
1510                 case GROUPINFONAME:
1511                         ndr_print_lsa_String(ndr, "name", &r->name);
1512                 break;
1513
1514                 case GROUPINFOATTRIBUTES:
1515                         ndr_print_samr_GroupInfoAttributes(ndr, "attributes", &r->attributes);
1516                 break;
1517
1518                 case GROUPINFODESCRIPTION:
1519                         ndr_print_lsa_String(ndr, "description", &r->description);
1520                 break;
1521
1522                 case GROUPINFOALL2:
1523                         ndr_print_samr_GroupInfoAll(ndr, "all2", &r->all2);
1524                 break;
1525
1526                 default:
1527                         ndr_print_bad_level(ndr, name, level);
1528         }
1529 }
1530
1531 static enum ndr_err_code ndr_push_samr_RidTypeArray(struct ndr_push *ndr, int ndr_flags, const struct samr_RidTypeArray *r)
1532 {
1533         uint32_t cntr_rids_1;
1534         uint32_t cntr_types_1;
1535         if (ndr_flags & NDR_SCALARS) {
1536                 NDR_CHECK(ndr_push_align(ndr, 4));
1537                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1538                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->rids));
1539                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
1540         }
1541         if (ndr_flags & NDR_BUFFERS) {
1542                 if (r->rids) {
1543                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1544                         for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {
1545                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rids[cntr_rids_1]));
1546                         }
1547                 }
1548                 if (r->types) {
1549                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1550                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
1551                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->types[cntr_types_1]));
1552                         }
1553                 }
1554         }
1555         return NDR_ERR_SUCCESS;
1556 }
1557
1558 static enum ndr_err_code ndr_pull_samr_RidTypeArray(struct ndr_pull *ndr, int ndr_flags, struct samr_RidTypeArray *r)
1559 {
1560         uint32_t _ptr_rids;
1561         uint32_t cntr_rids_1;
1562         TALLOC_CTX *_mem_save_rids_0;
1563         TALLOC_CTX *_mem_save_rids_1;
1564         uint32_t _ptr_types;
1565         uint32_t cntr_types_1;
1566         TALLOC_CTX *_mem_save_types_0;
1567         TALLOC_CTX *_mem_save_types_1;
1568         if (ndr_flags & NDR_SCALARS) {
1569                 NDR_CHECK(ndr_pull_align(ndr, 4));
1570                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1571                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
1572                 if (_ptr_rids) {
1573                         NDR_PULL_ALLOC(ndr, r->rids);
1574                 } else {
1575                         r->rids = NULL;
1576                 }
1577                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
1578                 if (_ptr_types) {
1579                         NDR_PULL_ALLOC(ndr, r->types);
1580                 } else {
1581                         r->types = NULL;
1582                 }
1583         }
1584         if (ndr_flags & NDR_BUFFERS) {
1585                 if (r->rids) {
1586                         _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1587                         NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
1588                         NDR_CHECK(ndr_pull_array_size(ndr, &r->rids));
1589                         NDR_PULL_ALLOC_N(ndr, r->rids, ndr_get_array_size(ndr, &r->rids));
1590                         _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
1591                         NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
1592                         for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {
1593                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));
1594                         }
1595                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
1596                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
1597                 }
1598                 if (r->types) {
1599                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
1600                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
1601                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
1602                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
1603                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
1604                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
1605                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
1606                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
1607                         }
1608                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
1609                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
1610                 }
1611                 if (r->rids) {
1612                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->rids, r->count));
1613                 }
1614                 if (r->types) {
1615                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
1616                 }
1617         }
1618         return NDR_ERR_SUCCESS;
1619 }
1620
1621 _PUBLIC_ void ndr_print_samr_RidTypeArray(struct ndr_print *ndr, const char *name, const struct samr_RidTypeArray *r)
1622 {
1623         uint32_t cntr_rids_1;
1624         uint32_t cntr_types_1;
1625         ndr_print_struct(ndr, name, "samr_RidTypeArray");
1626         ndr->depth++;
1627         ndr_print_uint32(ndr, "count", r->count);
1628         ndr_print_ptr(ndr, "rids", r->rids);
1629         ndr->depth++;
1630         if (r->rids) {
1631                 ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->count);
1632                 ndr->depth++;
1633                 for (cntr_rids_1=0;cntr_rids_1<r->count;cntr_rids_1++) {
1634                         char *idx_1=NULL;
1635                         if (asprintf(&idx_1, "[%d]", cntr_rids_1) != -1) {
1636                                 ndr_print_uint32(ndr, "rids", r->rids[cntr_rids_1]);
1637                                 free(idx_1);
1638                         }
1639                 }
1640                 ndr->depth--;
1641         }
1642         ndr->depth--;
1643         ndr_print_ptr(ndr, "types", r->types);
1644         ndr->depth++;
1645         if (r->types) {
1646                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
1647                 ndr->depth++;
1648                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
1649                         char *idx_1=NULL;
1650                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
1651                                 ndr_print_uint32(ndr, "types", r->types[cntr_types_1]);
1652                                 free(idx_1);
1653                         }
1654                 }
1655                 ndr->depth--;
1656         }
1657         ndr->depth--;
1658         ndr->depth--;
1659 }
1660
1661 static enum ndr_err_code ndr_push_samr_AliasInfoAll(struct ndr_push *ndr, int ndr_flags, const struct samr_AliasInfoAll *r)
1662 {
1663         if (ndr_flags & NDR_SCALARS) {
1664                 NDR_CHECK(ndr_push_align(ndr, 4));
1665                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1666                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_members));
1667                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1668         }
1669         if (ndr_flags & NDR_BUFFERS) {
1670                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1671                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1672         }
1673         return NDR_ERR_SUCCESS;
1674 }
1675
1676 static enum ndr_err_code ndr_pull_samr_AliasInfoAll(struct ndr_pull *ndr, int ndr_flags, struct samr_AliasInfoAll *r)
1677 {
1678         if (ndr_flags & NDR_SCALARS) {
1679                 NDR_CHECK(ndr_pull_align(ndr, 4));
1680                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1681                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_members));
1682                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1683         }
1684         if (ndr_flags & NDR_BUFFERS) {
1685                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1686                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1687         }
1688         return NDR_ERR_SUCCESS;
1689 }
1690
1691 _PUBLIC_ void ndr_print_samr_AliasInfoAll(struct ndr_print *ndr, const char *name, const struct samr_AliasInfoAll *r)
1692 {
1693         ndr_print_struct(ndr, name, "samr_AliasInfoAll");
1694         ndr->depth++;
1695         ndr_print_lsa_String(ndr, "name", &r->name);
1696         ndr_print_uint32(ndr, "num_members", r->num_members);
1697         ndr_print_lsa_String(ndr, "description", &r->description);
1698         ndr->depth--;
1699 }
1700
1701 static enum ndr_err_code ndr_push_samr_AliasInfoEnum(struct ndr_push *ndr, int ndr_flags, enum samr_AliasInfoEnum r)
1702 {
1703         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
1704         return NDR_ERR_SUCCESS;
1705 }
1706
1707 static enum ndr_err_code ndr_pull_samr_AliasInfoEnum(struct ndr_pull *ndr, int ndr_flags, enum samr_AliasInfoEnum *r)
1708 {
1709         uint16_t v;
1710         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
1711         *r = v;
1712         return NDR_ERR_SUCCESS;
1713 }
1714
1715 _PUBLIC_ void ndr_print_samr_AliasInfoEnum(struct ndr_print *ndr, const char *name, enum samr_AliasInfoEnum r)
1716 {
1717         const char *val = NULL;
1718
1719         switch (r) {
1720                 case ALIASINFOALL: val = "ALIASINFOALL"; break;
1721                 case ALIASINFONAME: val = "ALIASINFONAME"; break;
1722                 case ALIASINFODESCRIPTION: val = "ALIASINFODESCRIPTION"; break;
1723         }
1724         ndr_print_enum(ndr, name, "ENUM", val, r);
1725 }
1726
1727 static enum ndr_err_code ndr_push_samr_AliasInfo(struct ndr_push *ndr, int ndr_flags, const union samr_AliasInfo *r)
1728 {
1729         if (ndr_flags & NDR_SCALARS) {
1730                 int level = ndr_push_get_switch_value(ndr, r);
1731                 NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, level));
1732                 switch (level) {
1733                         case ALIASINFOALL: {
1734                                 NDR_CHECK(ndr_push_samr_AliasInfoAll(ndr, NDR_SCALARS, &r->all));
1735                         break; }
1736
1737                         case ALIASINFONAME: {
1738                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1739                         break; }
1740
1741                         case ALIASINFODESCRIPTION: {
1742                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1743                         break; }
1744
1745                         default:
1746                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1747                 }
1748         }
1749         if (ndr_flags & NDR_BUFFERS) {
1750                 int level = ndr_push_get_switch_value(ndr, r);
1751                 switch (level) {
1752                         case ALIASINFOALL:
1753                                 NDR_CHECK(ndr_push_samr_AliasInfoAll(ndr, NDR_BUFFERS, &r->all));
1754                         break;
1755
1756                         case ALIASINFONAME:
1757                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1758                         break;
1759
1760                         case ALIASINFODESCRIPTION:
1761                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1762                         break;
1763
1764                         default:
1765                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1766                 }
1767         }
1768         return NDR_ERR_SUCCESS;
1769 }
1770
1771 static enum ndr_err_code ndr_pull_samr_AliasInfo(struct ndr_pull *ndr, int ndr_flags, union samr_AliasInfo *r)
1772 {
1773         int level;
1774         uint16_t _level;
1775         level = ndr_pull_get_switch_value(ndr, r);
1776         if (ndr_flags & NDR_SCALARS) {
1777                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
1778                 if (_level != level) {
1779                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1780                 }
1781                 switch (level) {
1782                         case ALIASINFOALL: {
1783                                 NDR_CHECK(ndr_pull_samr_AliasInfoAll(ndr, NDR_SCALARS, &r->all));
1784                         break; }
1785
1786                         case ALIASINFONAME: {
1787                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1788                         break; }
1789
1790                         case ALIASINFODESCRIPTION: {
1791                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1792                         break; }
1793
1794                         default:
1795                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1796                 }
1797         }
1798         if (ndr_flags & NDR_BUFFERS) {
1799                 switch (level) {
1800                         case ALIASINFOALL:
1801                                 NDR_CHECK(ndr_pull_samr_AliasInfoAll(ndr, NDR_BUFFERS, &r->all));
1802                         break;
1803
1804                         case ALIASINFONAME:
1805                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1806                         break;
1807
1808                         case ALIASINFODESCRIPTION:
1809                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1810                         break;
1811
1812                         default:
1813                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1814                 }
1815         }
1816         return NDR_ERR_SUCCESS;
1817 }
1818
1819 _PUBLIC_ void ndr_print_samr_AliasInfo(struct ndr_print *ndr, const char *name, const union samr_AliasInfo *r)
1820 {
1821         int level;
1822         level = ndr_print_get_switch_value(ndr, r);
1823         ndr_print_union(ndr, name, level, "samr_AliasInfo");
1824         switch (level) {
1825                 case ALIASINFOALL:
1826                         ndr_print_samr_AliasInfoAll(ndr, "all", &r->all);
1827                 break;
1828
1829                 case ALIASINFONAME:
1830                         ndr_print_lsa_String(ndr, "name", &r->name);
1831                 break;
1832
1833                 case ALIASINFODESCRIPTION:
1834                         ndr_print_lsa_String(ndr, "description", &r->description);
1835                 break;
1836
1837                 default:
1838                         ndr_print_bad_level(ndr, name, level);
1839         }
1840 }
1841
1842 static enum ndr_err_code ndr_push_samr_UserInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo1 *r)
1843 {
1844         if (ndr_flags & NDR_SCALARS) {
1845                 NDR_CHECK(ndr_push_align(ndr, 4));
1846                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
1847                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
1848                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
1849                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1850                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));
1851         }
1852         if (ndr_flags & NDR_BUFFERS) {
1853                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
1854                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
1855                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1856                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));
1857         }
1858         return NDR_ERR_SUCCESS;
1859 }
1860
1861 static enum ndr_err_code ndr_pull_samr_UserInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo1 *r)
1862 {
1863         if (ndr_flags & NDR_SCALARS) {
1864                 NDR_CHECK(ndr_pull_align(ndr, 4));
1865                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
1866                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
1867                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
1868                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1869                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));
1870         }
1871         if (ndr_flags & NDR_BUFFERS) {
1872                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
1873                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
1874                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1875                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));
1876         }
1877         return NDR_ERR_SUCCESS;
1878 }
1879
1880 _PUBLIC_ void ndr_print_samr_UserInfo1(struct ndr_print *ndr, const char *name, const struct samr_UserInfo1 *r)
1881 {
1882         ndr_print_struct(ndr, name, "samr_UserInfo1");
1883         ndr->depth++;
1884         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
1885         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
1886         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
1887         ndr_print_lsa_String(ndr, "description", &r->description);
1888         ndr_print_lsa_String(ndr, "comment", &r->comment);
1889         ndr->depth--;
1890 }
1891
1892 static enum ndr_err_code ndr_push_samr_UserInfo2(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo2 *r)
1893 {
1894         if (ndr_flags & NDR_SCALARS) {
1895                 NDR_CHECK(ndr_push_align(ndr, 4));
1896                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));
1897                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->unknown));
1898                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->country_code));
1899                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->code_page));
1900         }
1901         if (ndr_flags & NDR_BUFFERS) {
1902                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));
1903                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->unknown));
1904         }
1905         return NDR_ERR_SUCCESS;
1906 }
1907
1908 static enum ndr_err_code ndr_pull_samr_UserInfo2(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo2 *r)
1909 {
1910         if (ndr_flags & NDR_SCALARS) {
1911                 NDR_CHECK(ndr_pull_align(ndr, 4));
1912                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));
1913                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->unknown));
1914                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->country_code));
1915                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->code_page));
1916         }
1917         if (ndr_flags & NDR_BUFFERS) {
1918                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));
1919                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->unknown));
1920         }
1921         return NDR_ERR_SUCCESS;
1922 }
1923
1924 _PUBLIC_ void ndr_print_samr_UserInfo2(struct ndr_print *ndr, const char *name, const struct samr_UserInfo2 *r)
1925 {
1926         ndr_print_struct(ndr, name, "samr_UserInfo2");
1927         ndr->depth++;
1928         ndr_print_lsa_String(ndr, "comment", &r->comment);
1929         ndr_print_lsa_String(ndr, "unknown", &r->unknown);
1930         ndr_print_uint16(ndr, "country_code", r->country_code);
1931         ndr_print_uint16(ndr, "code_page", r->code_page);
1932         ndr->depth--;
1933 }
1934
1935 _PUBLIC_ enum ndr_err_code ndr_push_samr_LogonHours(struct ndr_push *ndr, int ndr_flags, const struct samr_LogonHours *r)
1936 {
1937         {
1938                 uint32_t _flags_save_STRUCT = ndr->flags;
1939                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1940                 if (ndr_flags & NDR_SCALARS) {
1941                         NDR_CHECK(ndr_push_align(ndr, 4));
1942                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->units_per_week));
1943                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->bits));
1944                 }
1945                 if (ndr_flags & NDR_BUFFERS) {
1946                         if (r->bits) {
1947                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1260));
1948                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1949                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->units_per_week / 8));
1950                                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->bits, r->units_per_week / 8));
1951                         }
1952                 }
1953                 ndr->flags = _flags_save_STRUCT;
1954         }
1955         return NDR_ERR_SUCCESS;
1956 }
1957
1958 _PUBLIC_ enum ndr_err_code ndr_pull_samr_LogonHours(struct ndr_pull *ndr, int ndr_flags, struct samr_LogonHours *r)
1959 {
1960         uint32_t _ptr_bits;
1961         TALLOC_CTX *_mem_save_bits_0;
1962         {
1963                 uint32_t _flags_save_STRUCT = ndr->flags;
1964                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1965                 if (ndr_flags & NDR_SCALARS) {
1966                         NDR_CHECK(ndr_pull_align(ndr, 4));
1967                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->units_per_week));
1968                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bits));
1969                         if (_ptr_bits) {
1970                                 NDR_PULL_ALLOC(ndr, r->bits);
1971                         } else {
1972                                 r->bits = NULL;
1973                         }
1974                 }
1975                 if (ndr_flags & NDR_BUFFERS) {
1976                         if (r->bits) {
1977                                 _mem_save_bits_0 = NDR_PULL_GET_MEM_CTX(ndr);
1978                                 NDR_PULL_SET_MEM_CTX(ndr, r->bits, 0);
1979                                 NDR_CHECK(ndr_pull_array_size(ndr, &r->bits));
1980                                 NDR_CHECK(ndr_pull_array_length(ndr, &r->bits));
1981                                 if (ndr_get_array_length(ndr, &r->bits) > ndr_get_array_size(ndr, &r->bits)) {
1982                                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->bits), ndr_get_array_length(ndr, &r->bits));
1983                                 }
1984                                 NDR_PULL_ALLOC_N(ndr, r->bits, ndr_get_array_size(ndr, &r->bits));
1985                                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->bits, ndr_get_array_length(ndr, &r->bits)));
1986                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bits_0, 0);
1987                         }
1988                         if (r->bits) {
1989                                 NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->bits, 1260));
1990                         }
1991                         if (r->bits) {
1992                                 NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->bits, r->units_per_week / 8));
1993                         }
1994                 }
1995                 ndr->flags = _flags_save_STRUCT;
1996         }
1997         return NDR_ERR_SUCCESS;
1998 }
1999
2000 _PUBLIC_ void ndr_print_samr_LogonHours(struct ndr_print *ndr, const char *name, const struct samr_LogonHours *r)
2001 {
2002         ndr_print_struct(ndr, name, "samr_LogonHours");
2003         {
2004                 uint32_t _flags_save_STRUCT = ndr->flags;
2005                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2006                 ndr->depth++;
2007                 ndr_print_uint16(ndr, "units_per_week", r->units_per_week);
2008                 ndr_print_ptr(ndr, "bits", r->bits);
2009                 ndr->depth++;
2010                 if (r->bits) {
2011                         ndr_print_array_uint8(ndr, "bits", r->bits, r->units_per_week / 8);
2012                 }
2013                 ndr->depth--;
2014                 ndr->depth--;
2015                 ndr->flags = _flags_save_STRUCT;
2016         }
2017 }
2018
2019 static enum ndr_err_code ndr_push_samr_UserInfo3(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo3 *r)
2020 {
2021         if (ndr_flags & NDR_SCALARS) {
2022                 NDR_CHECK(ndr_push_align(ndr, 4));
2023                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2024                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2025                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
2026                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
2027                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2028                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2029                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2030                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2031                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2032                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));
2033                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));
2034                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));
2035                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->allow_password_change));
2036                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_password_change));
2037                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2038                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));
2039                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
2040                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
2041         }
2042         if (ndr_flags & NDR_BUFFERS) {
2043                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2044                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2045                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2046                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2047                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2048                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2049                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2050                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2051         }
2052         return NDR_ERR_SUCCESS;
2053 }
2054
2055 static enum ndr_err_code ndr_pull_samr_UserInfo3(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo3 *r)
2056 {
2057         if (ndr_flags & NDR_SCALARS) {
2058                 NDR_CHECK(ndr_pull_align(ndr, 4));
2059                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2060                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2061                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
2062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
2063                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2064                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2065                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2066                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2067                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2068                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));
2069                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));
2070                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));
2071                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->allow_password_change));
2072                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_password_change));
2073                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2074                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));
2075                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
2076                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
2077         }
2078         if (ndr_flags & NDR_BUFFERS) {
2079                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2080                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2081                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2082                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2083                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2084                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2085                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2086                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2087         }
2088         return NDR_ERR_SUCCESS;
2089 }
2090
2091 _PUBLIC_ void ndr_print_samr_UserInfo3(struct ndr_print *ndr, const char *name, const struct samr_UserInfo3 *r)
2092 {
2093         ndr_print_struct(ndr, name, "samr_UserInfo3");
2094         ndr->depth++;
2095         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2096         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2097         ndr_print_uint32(ndr, "rid", r->rid);
2098         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
2099         ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
2100         ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
2101         ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
2102         ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
2103         ndr_print_lsa_String(ndr, "workstations", &r->workstations);
2104         ndr_print_NTTIME(ndr, "last_logon", r->last_logon);
2105         ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);
2106         ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);
2107         ndr_print_NTTIME(ndr, "allow_password_change", r->allow_password_change);
2108         ndr_print_NTTIME(ndr, "force_password_change", r->force_password_change);
2109         ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
2110         ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);
2111         ndr_print_uint16(ndr, "logon_count", r->logon_count);
2112         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
2113         ndr->depth--;
2114 }
2115
2116 static enum ndr_err_code ndr_push_samr_UserInfo4(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo4 *r)
2117 {
2118         if (ndr_flags & NDR_SCALARS) {
2119                 NDR_CHECK(ndr_push_align(ndr, 4));
2120                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2121         }
2122         if (ndr_flags & NDR_BUFFERS) {
2123                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2124         }
2125         return NDR_ERR_SUCCESS;
2126 }
2127
2128 static enum ndr_err_code ndr_pull_samr_UserInfo4(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo4 *r)
2129 {
2130         if (ndr_flags & NDR_SCALARS) {
2131                 NDR_CHECK(ndr_pull_align(ndr, 4));
2132                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2133         }
2134         if (ndr_flags & NDR_BUFFERS) {
2135                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2136         }
2137         return NDR_ERR_SUCCESS;
2138 }
2139
2140 _PUBLIC_ void ndr_print_samr_UserInfo4(struct ndr_print *ndr, const char *name, const struct samr_UserInfo4 *r)
2141 {
2142         ndr_print_struct(ndr, name, "samr_UserInfo4");
2143         ndr->depth++;
2144         ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
2145         ndr->depth--;
2146 }
2147
2148 static enum ndr_err_code ndr_push_samr_UserInfo5(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo5 *r)
2149 {
2150         if (ndr_flags & NDR_SCALARS) {
2151                 NDR_CHECK(ndr_push_align(ndr, 4));
2152                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2153                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2154                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
2155                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
2156                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2157                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2158                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2159                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2160                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
2161                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2162                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));
2163                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));
2164                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2165                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));
2166                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
2167                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));
2168                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
2169                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
2170         }
2171         if (ndr_flags & NDR_BUFFERS) {
2172                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2173                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2174                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2175                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2176                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2177                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2178                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
2179                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2180                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2181         }
2182         return NDR_ERR_SUCCESS;
2183 }
2184
2185 static enum ndr_err_code ndr_pull_samr_UserInfo5(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo5 *r)
2186 {
2187         if (ndr_flags & NDR_SCALARS) {
2188                 NDR_CHECK(ndr_pull_align(ndr, 4));
2189                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2190                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2191                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
2192                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
2193                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2194                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2195                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2196                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2197                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
2198                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2199                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));
2200                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));
2201                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2202                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));
2203                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
2204                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));
2205                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
2206                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
2207         }
2208         if (ndr_flags & NDR_BUFFERS) {
2209                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2210                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2211                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2212                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2213                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2214                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2215                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
2216                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2217                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2218         }
2219         return NDR_ERR_SUCCESS;
2220 }
2221
2222 _PUBLIC_ void ndr_print_samr_UserInfo5(struct ndr_print *ndr, const char *name, const struct samr_UserInfo5 *r)
2223 {
2224         ndr_print_struct(ndr, name, "samr_UserInfo5");
2225         ndr->depth++;
2226         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2227         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2228         ndr_print_uint32(ndr, "rid", r->rid);
2229         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
2230         ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
2231         ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
2232         ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
2233         ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
2234         ndr_print_lsa_String(ndr, "description", &r->description);
2235         ndr_print_lsa_String(ndr, "workstations", &r->workstations);
2236         ndr_print_NTTIME(ndr, "last_logon", r->last_logon);
2237         ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);
2238         ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
2239         ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);
2240         ndr_print_uint16(ndr, "logon_count", r->logon_count);
2241         ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);
2242         ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);
2243         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
2244         ndr->depth--;
2245 }
2246
2247 static enum ndr_err_code ndr_push_samr_UserInfo6(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo6 *r)
2248 {
2249         if (ndr_flags & NDR_SCALARS) {
2250                 NDR_CHECK(ndr_push_align(ndr, 4));
2251                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2252                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2253         }
2254         if (ndr_flags & NDR_BUFFERS) {
2255                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2256                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2257         }
2258         return NDR_ERR_SUCCESS;
2259 }
2260
2261 static enum ndr_err_code ndr_pull_samr_UserInfo6(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo6 *r)
2262 {
2263         if (ndr_flags & NDR_SCALARS) {
2264                 NDR_CHECK(ndr_pull_align(ndr, 4));
2265                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2266                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2267         }
2268         if (ndr_flags & NDR_BUFFERS) {
2269                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2270                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2271         }
2272         return NDR_ERR_SUCCESS;
2273 }
2274
2275 _PUBLIC_ void ndr_print_samr_UserInfo6(struct ndr_print *ndr, const char *name, const struct samr_UserInfo6 *r)
2276 {
2277         ndr_print_struct(ndr, name, "samr_UserInfo6");
2278         ndr->depth++;
2279         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2280         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2281         ndr->depth--;
2282 }
2283
2284 static enum ndr_err_code ndr_push_samr_UserInfo7(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo7 *r)
2285 {
2286         if (ndr_flags & NDR_SCALARS) {
2287                 NDR_CHECK(ndr_push_align(ndr, 4));
2288                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2289         }
2290         if (ndr_flags & NDR_BUFFERS) {
2291                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2292         }
2293         return NDR_ERR_SUCCESS;
2294 }
2295
2296 static enum ndr_err_code ndr_pull_samr_UserInfo7(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo7 *r)
2297 {
2298         if (ndr_flags & NDR_SCALARS) {
2299                 NDR_CHECK(ndr_pull_align(ndr, 4));
2300                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2301         }
2302         if (ndr_flags & NDR_BUFFERS) {
2303                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2304         }
2305         return NDR_ERR_SUCCESS;
2306 }
2307
2308 _PUBLIC_ void ndr_print_samr_UserInfo7(struct ndr_print *ndr, const char *name, const struct samr_UserInfo7 *r)
2309 {
2310         ndr_print_struct(ndr, name, "samr_UserInfo7");
2311         ndr->depth++;
2312         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2313         ndr->depth--;
2314 }
2315
2316 static enum ndr_err_code ndr_push_samr_UserInfo8(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo8 *r)
2317 {
2318         if (ndr_flags & NDR_SCALARS) {
2319                 NDR_CHECK(ndr_push_align(ndr, 4));
2320                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2321         }
2322         if (ndr_flags & NDR_BUFFERS) {
2323                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2324         }
2325         return NDR_ERR_SUCCESS;
2326 }
2327
2328 static enum ndr_err_code ndr_pull_samr_UserInfo8(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo8 *r)
2329 {
2330         if (ndr_flags & NDR_SCALARS) {
2331                 NDR_CHECK(ndr_pull_align(ndr, 4));
2332                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2333         }
2334         if (ndr_flags & NDR_BUFFERS) {
2335                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2336         }
2337         return NDR_ERR_SUCCESS;
2338 }
2339
2340 _PUBLIC_ void ndr_print_samr_UserInfo8(struct ndr_print *ndr, const char *name, const struct samr_UserInfo8 *r)
2341 {
2342         ndr_print_struct(ndr, name, "samr_UserInfo8");
2343         ndr->depth++;
2344         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2345         ndr->depth--;
2346 }
2347
2348 static enum ndr_err_code ndr_push_samr_UserInfo9(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo9 *r)
2349 {
2350         if (ndr_flags & NDR_SCALARS) {
2351                 NDR_CHECK(ndr_push_align(ndr, 4));
2352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
2353         }
2354         if (ndr_flags & NDR_BUFFERS) {
2355         }
2356         return NDR_ERR_SUCCESS;
2357 }
2358
2359 static enum ndr_err_code ndr_pull_samr_UserInfo9(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo9 *r)
2360 {
2361         if (ndr_flags & NDR_SCALARS) {
2362                 NDR_CHECK(ndr_pull_align(ndr, 4));
2363                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
2364         }
2365         if (ndr_flags & NDR_BUFFERS) {
2366         }
2367         return NDR_ERR_SUCCESS;
2368 }
2369
2370 _PUBLIC_ void ndr_print_samr_UserInfo9(struct ndr_print *ndr, const char *name, const struct samr_UserInfo9 *r)
2371 {
2372         ndr_print_struct(ndr, name, "samr_UserInfo9");
2373         ndr->depth++;
2374         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
2375         ndr->depth--;
2376 }
2377
2378 static enum ndr_err_code ndr_push_samr_UserInfo10(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo10 *r)
2379 {
2380         if (ndr_flags & NDR_SCALARS) {
2381                 NDR_CHECK(ndr_push_align(ndr, 4));
2382                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2383                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2384         }
2385         if (ndr_flags & NDR_BUFFERS) {
2386                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2387                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2388         }
2389         return NDR_ERR_SUCCESS;
2390 }
2391
2392 static enum ndr_err_code ndr_pull_samr_UserInfo10(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo10 *r)
2393 {
2394         if (ndr_flags & NDR_SCALARS) {
2395                 NDR_CHECK(ndr_pull_align(ndr, 4));
2396                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2397                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2398         }
2399         if (ndr_flags & NDR_BUFFERS) {
2400                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2401                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2402         }
2403         return NDR_ERR_SUCCESS;
2404 }
2405
2406 _PUBLIC_ void ndr_print_samr_UserInfo10(struct ndr_print *ndr, const char *name, const struct samr_UserInfo10 *r)
2407 {
2408         ndr_print_struct(ndr, name, "samr_UserInfo10");
2409         ndr->depth++;
2410         ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
2411         ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
2412         ndr->depth--;
2413 }
2414
2415 static enum ndr_err_code ndr_push_samr_UserInfo11(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo11 *r)
2416 {
2417         if (ndr_flags & NDR_SCALARS) {
2418                 NDR_CHECK(ndr_push_align(ndr, 4));
2419                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2420         }
2421         if (ndr_flags & NDR_BUFFERS) {
2422                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2423         }
2424         return NDR_ERR_SUCCESS;
2425 }
2426
2427 static enum ndr_err_code ndr_pull_samr_UserInfo11(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo11 *r)
2428 {
2429         if (ndr_flags & NDR_SCALARS) {
2430                 NDR_CHECK(ndr_pull_align(ndr, 4));
2431                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2432         }
2433         if (ndr_flags & NDR_BUFFERS) {
2434                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2435         }
2436         return NDR_ERR_SUCCESS;
2437 }
2438
2439 _PUBLIC_ void ndr_print_samr_UserInfo11(struct ndr_print *ndr, const char *name, const struct samr_UserInfo11 *r)
2440 {
2441         ndr_print_struct(ndr, name, "samr_UserInfo11");
2442         ndr->depth++;
2443         ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
2444         ndr->depth--;
2445 }
2446
2447 static enum ndr_err_code ndr_push_samr_UserInfo12(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo12 *r)
2448 {
2449         if (ndr_flags & NDR_SCALARS) {
2450                 NDR_CHECK(ndr_push_align(ndr, 4));
2451                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2452         }
2453         if (ndr_flags & NDR_BUFFERS) {
2454                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2455         }
2456         return NDR_ERR_SUCCESS;
2457 }
2458
2459 static enum ndr_err_code ndr_pull_samr_UserInfo12(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo12 *r)
2460 {
2461         if (ndr_flags & NDR_SCALARS) {
2462                 NDR_CHECK(ndr_pull_align(ndr, 4));
2463                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2464         }
2465         if (ndr_flags & NDR_BUFFERS) {
2466                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2467         }
2468         return NDR_ERR_SUCCESS;
2469 }
2470
2471 _PUBLIC_ void ndr_print_samr_UserInfo12(struct ndr_print *ndr, const char *name, const struct samr_UserInfo12 *r)
2472 {
2473         ndr_print_struct(ndr, name, "samr_UserInfo12");
2474         ndr->depth++;
2475         ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
2476         ndr->depth--;
2477 }
2478
2479 static enum ndr_err_code ndr_push_samr_UserInfo13(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo13 *r)
2480 {
2481         if (ndr_flags & NDR_SCALARS) {
2482                 NDR_CHECK(ndr_push_align(ndr, 4));
2483                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
2484         }
2485         if (ndr_flags & NDR_BUFFERS) {
2486                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
2487         }
2488         return NDR_ERR_SUCCESS;
2489 }
2490
2491 static enum ndr_err_code ndr_pull_samr_UserInfo13(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo13 *r)
2492 {
2493         if (ndr_flags & NDR_SCALARS) {
2494                 NDR_CHECK(ndr_pull_align(ndr, 4));
2495                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
2496         }
2497         if (ndr_flags & NDR_BUFFERS) {
2498                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
2499         }
2500         return NDR_ERR_SUCCESS;
2501 }
2502
2503 _PUBLIC_ void ndr_print_samr_UserInfo13(struct ndr_print *ndr, const char *name, const struct samr_UserInfo13 *r)
2504 {
2505         ndr_print_struct(ndr, name, "samr_UserInfo13");
2506         ndr->depth++;
2507         ndr_print_lsa_String(ndr, "description", &r->description);
2508         ndr->depth--;
2509 }
2510
2511 static enum ndr_err_code ndr_push_samr_UserInfo14(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo14 *r)
2512 {
2513         if (ndr_flags & NDR_SCALARS) {
2514                 NDR_CHECK(ndr_push_align(ndr, 4));
2515                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2516         }
2517         if (ndr_flags & NDR_BUFFERS) {
2518                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2519         }
2520         return NDR_ERR_SUCCESS;
2521 }
2522
2523 static enum ndr_err_code ndr_pull_samr_UserInfo14(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo14 *r)
2524 {
2525         if (ndr_flags & NDR_SCALARS) {
2526                 NDR_CHECK(ndr_pull_align(ndr, 4));
2527                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2528         }
2529         if (ndr_flags & NDR_BUFFERS) {
2530                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2531         }
2532         return NDR_ERR_SUCCESS;
2533 }
2534
2535 _PUBLIC_ void ndr_print_samr_UserInfo14(struct ndr_print *ndr, const char *name, const struct samr_UserInfo14 *r)
2536 {
2537         ndr_print_struct(ndr, name, "samr_UserInfo14");
2538         ndr->depth++;
2539         ndr_print_lsa_String(ndr, "workstations", &r->workstations);
2540         ndr->depth--;
2541 }
2542
2543 static enum ndr_err_code ndr_push_samr_UserInfo16(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo16 *r)
2544 {
2545         if (ndr_flags & NDR_SCALARS) {
2546                 NDR_CHECK(ndr_push_align(ndr, 4));
2547                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
2548         }
2549         if (ndr_flags & NDR_BUFFERS) {
2550         }
2551         return NDR_ERR_SUCCESS;
2552 }
2553
2554 static enum ndr_err_code ndr_pull_samr_UserInfo16(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo16 *r)
2555 {
2556         if (ndr_flags & NDR_SCALARS) {
2557                 NDR_CHECK(ndr_pull_align(ndr, 4));
2558                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
2559         }
2560         if (ndr_flags & NDR_BUFFERS) {
2561         }
2562         return NDR_ERR_SUCCESS;
2563 }
2564
2565 _PUBLIC_ void ndr_print_samr_UserInfo16(struct ndr_print *ndr, const char *name, const struct samr_UserInfo16 *r)
2566 {
2567         ndr_print_struct(ndr, name, "samr_UserInfo16");
2568         ndr->depth++;
2569         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
2570         ndr->depth--;
2571 }
2572
2573 static enum ndr_err_code ndr_push_samr_UserInfo17(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo17 *r)
2574 {
2575         if (ndr_flags & NDR_SCALARS) {
2576                 NDR_CHECK(ndr_push_align(ndr, 4));
2577                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
2578         }
2579         if (ndr_flags & NDR_BUFFERS) {
2580         }
2581         return NDR_ERR_SUCCESS;
2582 }
2583
2584 static enum ndr_err_code ndr_pull_samr_UserInfo17(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo17 *r)
2585 {
2586         if (ndr_flags & NDR_SCALARS) {
2587                 NDR_CHECK(ndr_pull_align(ndr, 4));
2588                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
2589         }
2590         if (ndr_flags & NDR_BUFFERS) {
2591         }
2592         return NDR_ERR_SUCCESS;
2593 }
2594
2595 _PUBLIC_ void ndr_print_samr_UserInfo17(struct ndr_print *ndr, const char *name, const struct samr_UserInfo17 *r)
2596 {
2597         ndr_print_struct(ndr, name, "samr_UserInfo17");
2598         ndr->depth++;
2599         ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);
2600         ndr->depth--;
2601 }
2602
2603 _PUBLIC_ enum ndr_err_code ndr_push_samr_Password(struct ndr_push *ndr, int ndr_flags, const struct samr_Password *r)
2604 {
2605         {
2606                 uint32_t _flags_save_STRUCT = ndr->flags;
2607                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2608                 if (ndr_flags & NDR_SCALARS) {
2609                         NDR_CHECK(ndr_push_align(ndr, 1));
2610                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
2611                 }
2612                 if (ndr_flags & NDR_BUFFERS) {
2613                 }
2614                 ndr->flags = _flags_save_STRUCT;
2615         }
2616         return NDR_ERR_SUCCESS;
2617 }
2618
2619 _PUBLIC_ enum ndr_err_code ndr_pull_samr_Password(struct ndr_pull *ndr, int ndr_flags, struct samr_Password *r)
2620 {
2621         {
2622                 uint32_t _flags_save_STRUCT = ndr->flags;
2623                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2624                 if (ndr_flags & NDR_SCALARS) {
2625                         NDR_CHECK(ndr_pull_align(ndr, 1));
2626                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
2627                 }
2628                 if (ndr_flags & NDR_BUFFERS) {
2629                 }
2630                 ndr->flags = _flags_save_STRUCT;
2631         }
2632         return NDR_ERR_SUCCESS;
2633 }
2634
2635 _PUBLIC_ void ndr_print_samr_Password(struct ndr_print *ndr, const char *name, const struct samr_Password *r)
2636 {
2637         ndr_print_struct(ndr, name, "samr_Password");
2638         {
2639                 uint32_t _flags_save_STRUCT = ndr->flags;
2640                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2641                 ndr->depth++;
2642                 ndr_print_array_uint8(ndr, "hash", r->hash, 16);
2643                 ndr->depth--;
2644                 ndr->flags = _flags_save_STRUCT;
2645         }
2646 }
2647
2648 static enum ndr_err_code ndr_push_samr_UserInfo18(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo18 *r)
2649 {
2650         if (ndr_flags & NDR_SCALARS) {
2651                 NDR_CHECK(ndr_push_align(ndr, 1));
2652                 NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->nt_pwd));
2653                 NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->lm_pwd));
2654                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->nt_pwd_active));
2655                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->lm_pwd_active));
2656                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
2657         }
2658         if (ndr_flags & NDR_BUFFERS) {
2659         }
2660         return NDR_ERR_SUCCESS;
2661 }
2662
2663 static enum ndr_err_code ndr_pull_samr_UserInfo18(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo18 *r)
2664 {
2665         if (ndr_flags & NDR_SCALARS) {
2666                 NDR_CHECK(ndr_pull_align(ndr, 1));
2667                 NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->nt_pwd));
2668                 NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->lm_pwd));
2669                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->nt_pwd_active));
2670                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->lm_pwd_active));
2671                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
2672         }
2673         if (ndr_flags & NDR_BUFFERS) {
2674         }
2675         return NDR_ERR_SUCCESS;
2676 }
2677
2678 _PUBLIC_ void ndr_print_samr_UserInfo18(struct ndr_print *ndr, const char *name, const struct samr_UserInfo18 *r)
2679 {
2680         ndr_print_struct(ndr, name, "samr_UserInfo18");
2681         ndr->depth++;
2682         ndr_print_samr_Password(ndr, "nt_pwd", &r->nt_pwd);
2683         ndr_print_samr_Password(ndr, "lm_pwd", &r->lm_pwd);
2684         ndr_print_uint8(ndr, "nt_pwd_active", r->nt_pwd_active);
2685         ndr_print_uint8(ndr, "lm_pwd_active", r->lm_pwd_active);
2686         ndr_print_uint8(ndr, "password_expired", r->password_expired);
2687         ndr->depth--;
2688 }
2689
2690 static enum ndr_err_code ndr_push_samr_UserInfo20(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo20 *r)
2691 {
2692         if (ndr_flags & NDR_SCALARS) {
2693                 NDR_CHECK(ndr_push_align(ndr, 4));
2694                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
2695         }
2696         if (ndr_flags & NDR_BUFFERS) {
2697                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
2698         }
2699         return NDR_ERR_SUCCESS;
2700 }
2701
2702 static enum ndr_err_code ndr_pull_samr_UserInfo20(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo20 *r)
2703 {
2704         if (ndr_flags & NDR_SCALARS) {
2705                 NDR_CHECK(ndr_pull_align(ndr, 4));
2706                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
2707         }
2708         if (ndr_flags & NDR_BUFFERS) {
2709                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
2710         }
2711         return NDR_ERR_SUCCESS;
2712 }
2713
2714 _PUBLIC_ void ndr_print_samr_UserInfo20(struct ndr_print *ndr, const char *name, const struct samr_UserInfo20 *r)
2715 {
2716         ndr_print_struct(ndr, name, "samr_UserInfo20");
2717         ndr->depth++;
2718         ndr_print_lsa_BinaryString(ndr, "parameters", &r->parameters);
2719         ndr->depth--;
2720 }
2721
2722 static enum ndr_err_code ndr_push_samr_FieldsPresent(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2723 {
2724         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2725         return NDR_ERR_SUCCESS;
2726 }
2727
2728 static enum ndr_err_code ndr_pull_samr_FieldsPresent(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2729 {
2730         uint32_t v;
2731         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2732         *r = v;
2733         return NDR_ERR_SUCCESS;
2734 }
2735
2736 _PUBLIC_ void ndr_print_samr_FieldsPresent(struct ndr_print *ndr, const char *name, uint32_t r)
2737 {
2738         ndr_print_uint32(ndr, name, r);
2739         ndr->depth++;
2740         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCOUNT_NAME", SAMR_FIELD_ACCOUNT_NAME, r);
2741         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_FULL_NAME", SAMR_FIELD_FULL_NAME, r);
2742         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_RID", SAMR_FIELD_RID, r);
2743         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PRIMARY_GID", SAMR_FIELD_PRIMARY_GID, r);
2744         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_DESCRIPTION", SAMR_FIELD_DESCRIPTION, r);
2745         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_COMMENT", SAMR_FIELD_COMMENT, r);
2746         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_HOME_DIRECTORY", SAMR_FIELD_HOME_DIRECTORY, r);
2747         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_HOME_DRIVE", SAMR_FIELD_HOME_DRIVE, r);
2748         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LOGON_SCRIPT", SAMR_FIELD_LOGON_SCRIPT, r);
2749         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PROFILE_PATH", SAMR_FIELD_PROFILE_PATH, r);
2750         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_WORKSTATIONS", SAMR_FIELD_WORKSTATIONS, r);
2751         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_LOGON", SAMR_FIELD_LAST_LOGON, r);
2752         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_LOGOFF", SAMR_FIELD_LAST_LOGOFF, r);
2753         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LOGON_HOURS", SAMR_FIELD_LOGON_HOURS, r);
2754         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_BAD_PWD_COUNT", SAMR_FIELD_BAD_PWD_COUNT, r);
2755         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_NUM_LOGONS", SAMR_FIELD_NUM_LOGONS, r);
2756         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ALLOW_PWD_CHANGE", SAMR_FIELD_ALLOW_PWD_CHANGE, r);
2757         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_FORCE_PWD_CHANGE", SAMR_FIELD_FORCE_PWD_CHANGE, r);
2758         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_PWD_CHANGE", SAMR_FIELD_LAST_PWD_CHANGE, r);
2759         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCT_EXPIRY", SAMR_FIELD_ACCT_EXPIRY, r);
2760         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCT_FLAGS", SAMR_FIELD_ACCT_FLAGS, r);
2761         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PARAMETERS", SAMR_FIELD_PARAMETERS, r);
2762         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_COUNTRY_CODE", SAMR_FIELD_COUNTRY_CODE, r);
2763         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_CODE_PAGE", SAMR_FIELD_CODE_PAGE, r);
2764         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_NT_PASSWORD_PRESENT", SAMR_FIELD_NT_PASSWORD_PRESENT, r);
2765         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LM_PASSWORD_PRESENT", SAMR_FIELD_LM_PASSWORD_PRESENT, r);
2766         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PRIVATE_DATA", SAMR_FIELD_PRIVATE_DATA, r);
2767         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_EXPIRED_FLAG", SAMR_FIELD_EXPIRED_FLAG, r);
2768         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_SEC_DESC", SAMR_FIELD_SEC_DESC, r);
2769         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_OWF_PWD", SAMR_FIELD_OWF_PWD, r);
2770         ndr->depth--;
2771 }
2772
2773 static enum ndr_err_code ndr_push_samr_UserInfo21(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo21 *r)
2774 {
2775         if (ndr_flags & NDR_SCALARS) {
2776                 NDR_CHECK(ndr_push_align(ndr, 4));
2777                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));
2778                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));
2779                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));
2780                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
2781                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->allow_password_change));
2782                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_password_change));
2783                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2784                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2785                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2786                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2787                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2788                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2789                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
2790                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2791                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));
2792                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
2793                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->lm_owf_password));
2794                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->nt_owf_password));
2795                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->unknown3));
2796                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_count));
2797                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->buffer));
2798                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
2799                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
2800                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
2801                 NDR_CHECK(ndr_push_samr_FieldsPresent(ndr, NDR_SCALARS, r->fields_present));
2802                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2803                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));
2804                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
2805                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->country_code));
2806                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->code_page));
2807                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->lm_password_set));
2808                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->nt_password_set));
2809                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
2810                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->unknown4));
2811         }
2812         if (ndr_flags & NDR_BUFFERS) {
2813                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2814                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2815                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2816                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2817                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2818                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2819                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
2820                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2821                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));
2822                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
2823                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->lm_owf_password));
2824                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->nt_owf_password));
2825                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->unknown3));
2826                 if (r->buffer) {
2827                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_count));
2828                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->buffer, r->buf_count));
2829                 }
2830                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2831         }
2832         return NDR_ERR_SUCCESS;
2833 }
2834
2835 static enum ndr_err_code ndr_pull_samr_UserInfo21(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo21 *r)
2836 {
2837         uint32_t _ptr_buffer;
2838         TALLOC_CTX *_mem_save_buffer_0;
2839         if (ndr_flags & NDR_SCALARS) {
2840                 NDR_CHECK(ndr_pull_align(ndr, 4));
2841                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));
2842                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));
2843                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));
2844                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
2845                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->allow_password_change));
2846                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_password_change));
2847                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2848                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2849                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2850                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2851                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2852                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2853                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
2854                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2855                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));
2856                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
2857                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->lm_owf_password));
2858                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->nt_owf_password));
2859                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->unknown3));
2860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_count));
2861                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
2862                 if (_ptr_buffer) {
2863                         NDR_PULL_ALLOC(ndr, r->buffer);
2864                 } else {
2865                         r->buffer = NULL;
2866                 }
2867                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
2868                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
2869                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
2870                 NDR_CHECK(ndr_pull_samr_FieldsPresent(ndr, NDR_SCALARS, &r->fields_present));
2871                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2872                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));
2873                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
2874                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->country_code));
2875                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->code_page));
2876                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->lm_password_set));
2877                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->nt_password_set));
2878                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
2879                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->unknown4));
2880         }
2881         if (ndr_flags & NDR_BUFFERS) {
2882                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2883                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2884                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2885                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2886                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2887                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2888                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
2889                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2890                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));
2891                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
2892                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->lm_owf_password));
2893                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->nt_owf_password));
2894                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->unknown3));
2895                 if (r->buffer) {
2896                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
2897                         NDR_PULL_SET_MEM_CTX(ndr, r->buffer, 0);
2898                         NDR_CHECK(ndr_pull_array_size(ndr, &r->buffer));
2899                         NDR_PULL_ALLOC_N(ndr, r->buffer, ndr_get_array_size(ndr, &r->buffer));
2900                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->buffer, ndr_get_array_size(ndr, &r->buffer)));
2901                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
2902                 }
2903                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2904                 if (r->buffer) {
2905                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->buffer, r->buf_count));
2906                 }
2907         }
2908         return NDR_ERR_SUCCESS;
2909 }
2910
2911 _PUBLIC_ void ndr_print_samr_UserInfo21(struct ndr_print *ndr, const char *name, const struct samr_UserInfo21 *r)
2912 {
2913         ndr_print_struct(ndr, name, "samr_UserInfo21");
2914         ndr->depth++;
2915         ndr_print_NTTIME(ndr, "last_logon", r->last_logon);
2916         ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);
2917         ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);
2918         ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);
2919         ndr_print_NTTIME(ndr, "allow_password_change", r->allow_password_change);
2920         ndr_print_NTTIME(ndr, "force_password_change", r->force_password_change);
2921         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2922         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2923         ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
2924         ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
2925         ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
2926         ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
2927         ndr_print_lsa_String(ndr, "description", &r->description);
2928         ndr_print_lsa_String(ndr, "workstations", &r->workstations);
2929         ndr_print_lsa_String(ndr, "comment", &r->comment);
2930         ndr_print_lsa_BinaryString(ndr, "parameters", &r->parameters);
2931         ndr_print_lsa_BinaryString(ndr, "lm_owf_password", &r->lm_owf_password);
2932         ndr_print_lsa_BinaryString(ndr, "nt_owf_password", &r->nt_owf_password);
2933         ndr_print_lsa_String(ndr, "unknown3", &r->unknown3);
2934         ndr_print_uint32(ndr, "buf_count", r->buf_count);
2935         ndr_print_ptr(ndr, "buffer", r->buffer);
2936         ndr->depth++;
2937         if (r->buffer) {
2938                 ndr_print_array_uint8(ndr, "buffer", r->buffer, r->buf_count);
2939         }
2940         ndr->depth--;
2941         ndr_print_uint32(ndr, "rid", r->rid);
2942         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
2943         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
2944         ndr_print_samr_FieldsPresent(ndr, "fields_present", r->fields_present);
2945         ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
2946         ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);
2947         ndr_print_uint16(ndr, "logon_count", r->logon_count);
2948         ndr_print_uint16(ndr, "country_code", r->country_code);
2949         ndr_print_uint16(ndr, "code_page", r->code_page);
2950         ndr_print_uint8(ndr, "lm_password_set", r->lm_password_set);
2951         ndr_print_uint8(ndr, "nt_password_set", r->nt_password_set);
2952         ndr_print_uint8(ndr, "password_expired", r->password_expired);
2953         ndr_print_uint8(ndr, "unknown4", r->unknown4);
2954         ndr->depth--;
2955 }
2956
2957 _PUBLIC_ enum ndr_err_code ndr_push_samr_CryptPassword(struct ndr_push *ndr, int ndr_flags, const struct samr_CryptPassword *r)
2958 {
2959         {
2960                 uint32_t _flags_save_STRUCT = ndr->flags;
2961                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2962                 if (ndr_flags & NDR_SCALARS) {
2963                         NDR_CHECK(ndr_push_align(ndr, 1));
2964                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 516));
2965                 }
2966                 if (ndr_flags & NDR_BUFFERS) {
2967                 }
2968                 ndr->flags = _flags_save_STRUCT;
2969         }
2970         return NDR_ERR_SUCCESS;
2971 }
2972
2973 _PUBLIC_ enum ndr_err_code ndr_pull_samr_CryptPassword(struct ndr_pull *ndr, int ndr_flags, struct samr_CryptPassword *r)
2974 {
2975         {
2976                 uint32_t _flags_save_STRUCT = ndr->flags;
2977                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2978                 if (ndr_flags & NDR_SCALARS) {
2979                         NDR_CHECK(ndr_pull_align(ndr, 1));
2980                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, 516));
2981                 }
2982                 if (ndr_flags & NDR_BUFFERS) {
2983                 }
2984                 ndr->flags = _flags_save_STRUCT;
2985         }
2986         return NDR_ERR_SUCCESS;
2987 }
2988
2989 _PUBLIC_ void ndr_print_samr_CryptPassword(struct ndr_print *ndr, const char *name, const struct samr_CryptPassword *r)
2990 {
2991         ndr_print_struct(ndr, name, "samr_CryptPassword");
2992         {
2993                 uint32_t _flags_save_STRUCT = ndr->flags;
2994                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2995                 ndr->depth++;
2996                 ndr_print_array_uint8(ndr, "data", r->data, 516);
2997                 ndr->depth--;
2998                 ndr->flags = _flags_save_STRUCT;
2999         }
3000 }
3001
3002 static enum ndr_err_code ndr_push_samr_UserInfo23(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo23 *r)
3003 {
3004         if (ndr_flags & NDR_SCALARS) {
3005                 NDR_CHECK(ndr_push_align(ndr, 4));
3006                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
3007                 NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
3008         }
3009         if (ndr_flags & NDR_BUFFERS) {
3010                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
3011         }
3012         return NDR_ERR_SUCCESS;
3013 }
3014
3015 static enum ndr_err_code ndr_pull_samr_UserInfo23(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo23 *r)
3016 {
3017         if (ndr_flags & NDR_SCALARS) {
3018                 NDR_CHECK(ndr_pull_align(ndr, 4));
3019                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
3020                 NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
3021         }
3022         if (ndr_flags & NDR_BUFFERS) {
3023                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
3024         }
3025         return NDR_ERR_SUCCESS;
3026 }
3027
3028 _PUBLIC_ void ndr_print_samr_UserInfo23(struct ndr_print *ndr, const char *name, const struct samr_UserInfo23 *r)
3029 {
3030         ndr_print_struct(ndr, name, "samr_UserInfo23");
3031         ndr->depth++;
3032         ndr_print_samr_UserInfo21(ndr, "info", &r->info);
3033         ndr_print_samr_CryptPassword(ndr, "password", &r->password);
3034         ndr->depth--;
3035 }
3036
3037 static enum ndr_err_code ndr_push_samr_UserInfo24(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo24 *r)
3038 {
3039         if (ndr_flags & NDR_SCALARS) {
3040                 NDR_CHECK(ndr_push_align(ndr, 1));
3041                 NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
3042                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
3043         }
3044         if (ndr_flags & NDR_BUFFERS) {
3045         }
3046         return NDR_ERR_SUCCESS;
3047 }
3048
3049 static enum ndr_err_code ndr_pull_samr_UserInfo24(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo24 *r)
3050 {
3051         if (ndr_flags & NDR_SCALARS) {
3052                 NDR_CHECK(ndr_pull_align(ndr, 1));
3053                 NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
3054                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
3055         }
3056         if (ndr_flags & NDR_BUFFERS) {
3057         }
3058         return NDR_ERR_SUCCESS;
3059 }
3060
3061 _PUBLIC_ void ndr_print_samr_UserInfo24(struct ndr_print *ndr, const char *name, const struct samr_UserInfo24 *r)
3062 {
3063         ndr_print_struct(ndr, name, "samr_UserInfo24");
3064         ndr->depth++;
3065         ndr_print_samr_CryptPassword(ndr, "password", &r->password);
3066         ndr_print_uint8(ndr, "password_expired", r->password_expired);
3067         ndr->depth--;
3068 }
3069
3070 static enum ndr_err_code ndr_push_samr_CryptPasswordEx(struct ndr_push *ndr, int ndr_flags, const struct samr_CryptPasswordEx *r)
3071 {
3072         {
3073                 uint32_t _flags_save_STRUCT = ndr->flags;
3074                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3075                 if (ndr_flags & NDR_SCALARS) {
3076                         NDR_CHECK(ndr_push_align(ndr, 1));
3077                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 532));
3078                 }
3079                 if (ndr_flags & NDR_BUFFERS) {
3080                 }
3081                 ndr->flags = _flags_save_STRUCT;
3082         }
3083         return NDR_ERR_SUCCESS;
3084 }
3085
3086 static enum ndr_err_code ndr_pull_samr_CryptPasswordEx(struct ndr_pull *ndr, int ndr_flags, struct samr_CryptPasswordEx *r)
3087 {
3088         {
3089                 uint32_t _flags_save_STRUCT = ndr->flags;
3090                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3091                 if (ndr_flags & NDR_SCALARS) {
3092                         NDR_CHECK(ndr_pull_align(ndr, 1));
3093                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, 532));
3094                 }
3095                 if (ndr_flags & NDR_BUFFERS) {
3096                 }
3097                 ndr->flags = _flags_save_STRUCT;
3098         }
3099         return NDR_ERR_SUCCESS;
3100 }
3101
3102 _PUBLIC_ void ndr_print_samr_CryptPasswordEx(struct ndr_print *ndr, const char *name, const struct samr_CryptPasswordEx *r)
3103 {
3104         ndr_print_struct(ndr, name, "samr_CryptPasswordEx");
3105         {
3106                 uint32_t _flags_save_STRUCT = ndr->flags;
3107                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3108                 ndr->depth++;
3109                 ndr_print_array_uint8(ndr, "data", r->data, 532);
3110                 ndr->depth--;
3111                 ndr->flags = _flags_save_STRUCT;
3112         }
3113 }
3114
3115 static enum ndr_err_code ndr_push_samr_UserInfo25(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo25 *r)
3116 {
3117         if (ndr_flags & NDR_SCALARS) {
3118                 NDR_CHECK(ndr_push_align(ndr, 4));
3119                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
3120                 NDR_CHECK(ndr_push_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
3121         }
3122         if (ndr_flags & NDR_BUFFERS) {
3123                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
3124         }
3125         return NDR_ERR_SUCCESS;
3126 }
3127
3128 static enum ndr_err_code ndr_pull_samr_UserInfo25(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo25 *r)
3129 {
3130         if (ndr_flags & NDR_SCALARS) {
3131                 NDR_CHECK(ndr_pull_align(ndr, 4));
3132                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
3133                 NDR_CHECK(ndr_pull_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
3134         }
3135         if (ndr_flags & NDR_BUFFERS) {
3136                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
3137         }
3138         return NDR_ERR_SUCCESS;
3139 }
3140
3141 _PUBLIC_ void ndr_print_samr_UserInfo25(struct ndr_print *ndr, const char *name, const struct samr_UserInfo25 *r)
3142 {
3143         ndr_print_struct(ndr, name, "samr_UserInfo25");
3144         ndr->depth++;
3145         ndr_print_samr_UserInfo21(ndr, "info", &r->info);
3146         ndr_print_samr_CryptPasswordEx(ndr, "password", &r->password);
3147         ndr->depth--;
3148 }
3149
3150 static enum ndr_err_code ndr_push_samr_UserInfo26(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo26 *r)
3151 {
3152         if (ndr_flags & NDR_SCALARS) {
3153                 NDR_CHECK(ndr_push_align(ndr, 1));
3154                 NDR_CHECK(ndr_push_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
3155                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
3156         }
3157         if (ndr_flags & NDR_BUFFERS) {
3158         }
3159         return NDR_ERR_SUCCESS;
3160 }
3161
3162 static enum ndr_err_code ndr_pull_samr_UserInfo26(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo26 *r)
3163 {
3164         if (ndr_flags & NDR_SCALARS) {
3165                 NDR_CHECK(ndr_pull_align(ndr, 1));
3166                 NDR_CHECK(ndr_pull_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
3167                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
3168         }
3169         if (ndr_flags & NDR_BUFFERS) {
3170         }
3171         return NDR_ERR_SUCCESS;
3172 }
3173
3174 _PUBLIC_ void ndr_print_samr_UserInfo26(struct ndr_print *ndr, const char *name, const struct samr_UserInfo26 *r)
3175 {
3176         ndr_print_struct(ndr, name, "samr_UserInfo26");
3177         ndr->depth++;
3178         ndr_print_samr_CryptPasswordEx(ndr, "password", &r->password);
3179         ndr_print_uint8(ndr, "password_expired", r->password_expired);
3180         ndr->depth--;
3181 }
3182
3183 static enum ndr_err_code ndr_push_samr_UserInfo(struct ndr_push *ndr, int ndr_flags, const union samr_UserInfo *r)
3184 {
3185         if (ndr_flags & NDR_SCALARS) {
3186                 int level = ndr_push_get_switch_value(ndr, r);
3187                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
3188                 switch (level) {
3189                         case 1: {
3190                                 NDR_CHECK(ndr_push_samr_UserInfo1(ndr, NDR_SCALARS, &r->info1));
3191                         break; }
3192
3193                         case 2: {
3194                                 NDR_CHECK(ndr_push_samr_UserInfo2(ndr, NDR_SCALARS, &r->info2));
3195                         break; }
3196
3197                         case 3: {
3198                                 NDR_CHECK(ndr_push_samr_UserInfo3(ndr, NDR_SCALARS, &r->info3));
3199                         break; }
3200
3201                         case 4: {
3202                                 NDR_CHECK(ndr_push_samr_UserInfo4(ndr, NDR_SCALARS, &r->info4));
3203                         break; }
3204
3205                         case 5: {
3206                                 NDR_CHECK(ndr_push_samr_UserInfo5(ndr, NDR_SCALARS, &r->info5));
3207                         break; }
3208
3209                         case 6: {
3210                                 NDR_CHECK(ndr_push_samr_UserInfo6(ndr, NDR_SCALARS, &r->info6));
3211                         break; }
3212
3213                         case 7: {
3214                                 NDR_CHECK(ndr_push_samr_UserInfo7(ndr, NDR_SCALARS, &r->info7));
3215                         break; }
3216
3217                         case 8: {
3218                                 NDR_CHECK(ndr_push_samr_UserInfo8(ndr, NDR_SCALARS, &r->info8));
3219                         break; }
3220
3221                         case 9: {
3222                                 NDR_CHECK(ndr_push_samr_UserInfo9(ndr, NDR_SCALARS, &r->info9));
3223                         break; }
3224
3225                         case 10: {
3226                                 NDR_CHECK(ndr_push_samr_UserInfo10(ndr, NDR_SCALARS, &r->info10));
3227                         break; }
3228
3229                         case 11: {
3230                                 NDR_CHECK(ndr_push_samr_UserInfo11(ndr, NDR_SCALARS, &r->info11));
3231                         break; }
3232
3233                         case 12: {
3234                                 NDR_CHECK(ndr_push_samr_UserInfo12(ndr, NDR_SCALARS, &r->info12));
3235                         break; }
3236
3237                         case 13: {
3238                                 NDR_CHECK(ndr_push_samr_UserInfo13(ndr, NDR_SCALARS, &r->info13));
3239                         break; }
3240
3241                         case 14: {
3242                                 NDR_CHECK(ndr_push_samr_UserInfo14(ndr, NDR_SCALARS, &r->info14));
3243                         break; }
3244
3245                         case 16: {
3246                                 NDR_CHECK(ndr_push_samr_UserInfo16(ndr, NDR_SCALARS, &r->info16));
3247                         break; }
3248
3249                         case 17: {
3250                                 NDR_CHECK(ndr_push_samr_UserInfo17(ndr, NDR_SCALARS, &r->info17));
3251                         break; }
3252
3253                         case 18: {
3254                                 NDR_CHECK(ndr_push_samr_UserInfo18(ndr, NDR_SCALARS, &r->info18));
3255                         break; }
3256
3257                         case 20: {
3258                                 NDR_CHECK(ndr_push_samr_UserInfo20(ndr, NDR_SCALARS, &r->info20));
3259                         break; }
3260
3261                         case 21: {
3262                                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info21));
3263                         break; }
3264
3265                         case 23: {
3266                                 NDR_CHECK(ndr_push_samr_UserInfo23(ndr, NDR_SCALARS, &r->info23));
3267                         break; }
3268
3269                         case 24: {
3270                                 NDR_CHECK(ndr_push_samr_UserInfo24(ndr, NDR_SCALARS, &r->info24));
3271                         break; }
3272
3273                         case 25: {
3274                                 NDR_CHECK(ndr_push_samr_UserInfo25(ndr, NDR_SCALARS, &r->info25));
3275                         break; }
3276
3277                         case 26: {
3278                                 NDR_CHECK(ndr_push_samr_UserInfo26(ndr, NDR_SCALARS, &r->info26));
3279                         break; }
3280
3281                         default:
3282                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3283                 }
3284         }
3285         if (ndr_flags & NDR_BUFFERS) {
3286                 int level = ndr_push_get_switch_value(ndr, r);
3287                 switch (level) {
3288                         case 1:
3289                                 NDR_CHECK(ndr_push_samr_UserInfo1(ndr, NDR_BUFFERS, &r->info1));
3290                         break;
3291
3292                         case 2:
3293                                 NDR_CHECK(ndr_push_samr_UserInfo2(ndr, NDR_BUFFERS, &r->info2));
3294                         break;
3295
3296                         case 3:
3297                                 NDR_CHECK(ndr_push_samr_UserInfo3(ndr, NDR_BUFFERS, &r->info3));
3298                         break;
3299
3300                         case 4:
3301                                 NDR_CHECK(ndr_push_samr_UserInfo4(ndr, NDR_BUFFERS, &r->info4));
3302                         break;
3303
3304                         case 5:
3305                                 NDR_CHECK(ndr_push_samr_UserInfo5(ndr, NDR_BUFFERS, &r->info5));
3306                         break;
3307
3308                         case 6:
3309                                 NDR_CHECK(ndr_push_samr_UserInfo6(ndr, NDR_BUFFERS, &r->info6));
3310                         break;
3311
3312                         case 7:
3313                                 NDR_CHECK(ndr_push_samr_UserInfo7(ndr, NDR_BUFFERS, &r->info7));
3314                         break;
3315
3316                         case 8:
3317                                 NDR_CHECK(ndr_push_samr_UserInfo8(ndr, NDR_BUFFERS, &r->info8));
3318                         break;
3319
3320                         case 9:
3321                         break;
3322
3323                         case 10:
3324                                 NDR_CHECK(ndr_push_samr_UserInfo10(ndr, NDR_BUFFERS, &r->info10));
3325                         break;
3326
3327                         case 11:
3328                                 NDR_CHECK(ndr_push_samr_UserInfo11(ndr, NDR_BUFFERS, &r->info11));
3329                         break;
3330
3331                         case 12:
3332                                 NDR_CHECK(ndr_push_samr_UserInfo12(ndr, NDR_BUFFERS, &r->info12));
3333                         break;
3334
3335                         case 13:
3336                                 NDR_CHECK(ndr_push_samr_UserInfo13(ndr, NDR_BUFFERS, &r->info13));
3337                         break;
3338
3339                         case 14:
3340                                 NDR_CHECK(ndr_push_samr_UserInfo14(ndr, NDR_BUFFERS, &r->info14));
3341                         break;
3342
3343                         case 16:
3344                         break;
3345
3346                         case 17:
3347                         break;
3348
3349                         case 18:
3350                         break;
3351
3352                         case 20:
3353                                 NDR_CHECK(ndr_push_samr_UserInfo20(ndr, NDR_BUFFERS, &r->info20));
3354                         break;
3355
3356                         case 21:
3357                                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info21));
3358                         break;
3359
3360                         case 23:
3361                                 NDR_CHECK(ndr_push_samr_UserInfo23(ndr, NDR_BUFFERS, &r->info23));
3362                         break;
3363
3364                         case 24:
3365                         break;
3366
3367                         case 25:
3368                                 NDR_CHECK(ndr_push_samr_UserInfo25(ndr, NDR_BUFFERS, &r->info25));
3369                         break;
3370
3371                         case 26:
3372                         break;
3373
3374                         default:
3375                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3376                 }
3377         }
3378         return NDR_ERR_SUCCESS;
3379 }
3380
3381 static enum ndr_err_code ndr_pull_samr_UserInfo(struct ndr_pull *ndr, int ndr_flags, union samr_UserInfo *r)
3382 {
3383         int level;
3384         uint16_t _level;
3385         level = ndr_pull_get_switch_value(ndr, r);
3386         if (ndr_flags & NDR_SCALARS) {
3387                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
3388                 if (_level != level) {
3389                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3390                 }
3391                 switch (level) {
3392                         case 1: {
3393                                 NDR_CHECK(ndr_pull_samr_UserInfo1(ndr, NDR_SCALARS, &r->info1));
3394                         break; }
3395
3396                         case 2: {
3397                                 NDR_CHECK(ndr_pull_samr_UserInfo2(ndr, NDR_SCALARS, &r->info2));
3398                         break; }
3399
3400                         case 3: {
3401                                 NDR_CHECK(ndr_pull_samr_UserInfo3(ndr, NDR_SCALARS, &r->info3));
3402                         break; }
3403
3404                         case 4: {
3405                                 NDR_CHECK(ndr_pull_samr_UserInfo4(ndr, NDR_SCALARS, &r->info4));
3406                         break; }
3407
3408                         case 5: {
3409                                 NDR_CHECK(ndr_pull_samr_UserInfo5(ndr, NDR_SCALARS, &r->info5));
3410                         break; }
3411
3412                         case 6: {
3413                                 NDR_CHECK(ndr_pull_samr_UserInfo6(ndr, NDR_SCALARS, &r->info6));
3414                         break; }
3415
3416                         case 7: {
3417                                 NDR_CHECK(ndr_pull_samr_UserInfo7(ndr, NDR_SCALARS, &r->info7));
3418                         break; }
3419
3420                         case 8: {
3421                                 NDR_CHECK(ndr_pull_samr_UserInfo8(ndr, NDR_SCALARS, &r->info8));
3422                         break; }
3423
3424                         case 9: {
3425                                 NDR_CHECK(ndr_pull_samr_UserInfo9(ndr, NDR_SCALARS, &r->info9));
3426                         break; }
3427
3428                         case 10: {
3429                                 NDR_CHECK(ndr_pull_samr_UserInfo10(ndr, NDR_SCALARS, &r->info10));
3430                         break; }
3431
3432                         case 11: {
3433                                 NDR_CHECK(ndr_pull_samr_UserInfo11(ndr, NDR_SCALARS, &r->info11));
3434                         break; }
3435
3436                         case 12: {
3437                                 NDR_CHECK(ndr_pull_samr_UserInfo12(ndr, NDR_SCALARS, &r->info12));
3438                         break; }
3439
3440                         case 13: {
3441                                 NDR_CHECK(ndr_pull_samr_UserInfo13(ndr, NDR_SCALARS, &r->info13));
3442                         break; }
3443
3444                         case 14: {
3445                                 NDR_CHECK(ndr_pull_samr_UserInfo14(ndr, NDR_SCALARS, &r->info14));
3446                         break; }
3447
3448                         case 16: {
3449                                 NDR_CHECK(ndr_pull_samr_UserInfo16(ndr, NDR_SCALARS, &r->info16));
3450                         break; }
3451
3452                         case 17: {
3453                                 NDR_CHECK(ndr_pull_samr_UserInfo17(ndr, NDR_SCALARS, &r->info17));
3454                         break; }
3455
3456                         case 18: {
3457                                 NDR_CHECK(ndr_pull_samr_UserInfo18(ndr, NDR_SCALARS, &r->info18));
3458                         break; }
3459
3460                         case 20: {
3461                                 NDR_CHECK(ndr_pull_samr_UserInfo20(ndr, NDR_SCALARS, &r->info20));
3462                         break; }
3463
3464                         case 21: {
3465                                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info21));
3466                         break; }
3467
3468                         case 23: {
3469                                 NDR_CHECK(ndr_pull_samr_UserInfo23(ndr, NDR_SCALARS, &r->info23));
3470                         break; }
3471
3472                         case 24: {
3473                                 NDR_CHECK(ndr_pull_samr_UserInfo24(ndr, NDR_SCALARS, &r->info24));
3474                         break; }
3475
3476                         case 25: {
3477                                 NDR_CHECK(ndr_pull_samr_UserInfo25(ndr, NDR_SCALARS, &r->info25));
3478                         break; }
3479
3480                         case 26: {
3481                                 NDR_CHECK(ndr_pull_samr_UserInfo26(ndr, NDR_SCALARS, &r->info26));
3482                         break; }
3483
3484                         default:
3485                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3486                 }
3487         }
3488         if (ndr_flags & NDR_BUFFERS) {
3489                 switch (level) {
3490                         case 1:
3491                                 NDR_CHECK(ndr_pull_samr_UserInfo1(ndr, NDR_BUFFERS, &r->info1));
3492                         break;
3493
3494                         case 2:
3495                                 NDR_CHECK(ndr_pull_samr_UserInfo2(ndr, NDR_BUFFERS, &r->info2));
3496                         break;
3497
3498                         case 3:
3499                                 NDR_CHECK(ndr_pull_samr_UserInfo3(ndr, NDR_BUFFERS, &r->info3));
3500                         break;
3501
3502                         case 4:
3503                                 NDR_CHECK(ndr_pull_samr_UserInfo4(ndr, NDR_BUFFERS, &r->info4));
3504                         break;
3505
3506                         case 5:
3507                                 NDR_CHECK(ndr_pull_samr_UserInfo5(ndr, NDR_BUFFERS, &r->info5));
3508                         break;
3509
3510                         case 6:
3511                                 NDR_CHECK(ndr_pull_samr_UserInfo6(ndr, NDR_BUFFERS, &r->info6));
3512                         break;
3513
3514                         case 7:
3515                                 NDR_CHECK(ndr_pull_samr_UserInfo7(ndr, NDR_BUFFERS, &r->info7));
3516                         break;
3517
3518                         case 8:
3519                                 NDR_CHECK(ndr_pull_samr_UserInfo8(ndr, NDR_BUFFERS, &r->info8));
3520                         break;
3521
3522                         case 9:
3523                         break;
3524
3525                         case 10:
3526                                 NDR_CHECK(ndr_pull_samr_UserInfo10(ndr, NDR_BUFFERS, &r->info10));
3527                         break;
3528
3529                         case 11:
3530                                 NDR_CHECK(ndr_pull_samr_UserInfo11(ndr, NDR_BUFFERS, &r->info11));
3531                         break;
3532
3533                         case 12:
3534                                 NDR_CHECK(ndr_pull_samr_UserInfo12(ndr, NDR_BUFFERS, &r->info12));
3535                         break;
3536
3537                         case 13:
3538                                 NDR_CHECK(ndr_pull_samr_UserInfo13(ndr, NDR_BUFFERS, &r->info13));
3539                         break;
3540
3541                         case 14:
3542                                 NDR_CHECK(ndr_pull_samr_UserInfo14(ndr, NDR_BUFFERS, &r->info14));
3543                         break;
3544
3545                         case 16:
3546                         break;
3547
3548                         case 17:
3549                         break;
3550
3551                         case 18:
3552                         break;
3553
3554                         case 20:
3555                                 NDR_CHECK(ndr_pull_samr_UserInfo20(ndr, NDR_BUFFERS, &r->info20));
3556                         break;
3557
3558                         case 21:
3559                                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info21));
3560                         break;
3561
3562                         case 23:
3563                                 NDR_CHECK(ndr_pull_samr_UserInfo23(ndr, NDR_BUFFERS, &r->info23));
3564                         break;
3565
3566                         case 24:
3567                         break;
3568
3569                         case 25:
3570                                 NDR_CHECK(ndr_pull_samr_UserInfo25(ndr, NDR_BUFFERS, &r->info25));
3571                         break;
3572
3573                         case 26:
3574                         break;
3575
3576                         default:
3577                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3578                 }
3579         }
3580         return NDR_ERR_SUCCESS;
3581 }
3582
3583 _PUBLIC_ void ndr_print_samr_UserInfo(struct ndr_print *ndr, const char *name, const union samr_UserInfo *r)
3584 {
3585         int level;
3586         level = ndr_print_get_switch_value(ndr, r);
3587         ndr_print_union(ndr, name, level, "samr_UserInfo");
3588         switch (level) {
3589                 case 1:
3590                         ndr_print_samr_UserInfo1(ndr, "info1", &r->info1);
3591                 break;
3592
3593                 case 2:
3594                         ndr_print_samr_UserInfo2(ndr, "info2", &r->info2);
3595                 break;
3596
3597                 case 3:
3598                         ndr_print_samr_UserInfo3(ndr, "info3", &r->info3);
3599                 break;
3600
3601                 case 4:
3602                         ndr_print_samr_UserInfo4(ndr, "info4", &r->info4);
3603                 break;
3604
3605                 case 5:
3606                         ndr_print_samr_UserInfo5(ndr, "info5", &r->info5);
3607                 break;
3608
3609                 case 6:
3610                         ndr_print_samr_UserInfo6(ndr, "info6", &r->info6);
3611                 break;
3612
3613                 case 7:
3614                         ndr_print_samr_UserInfo7(ndr, "info7", &r->info7);
3615                 break;
3616
3617                 case 8:
3618                         ndr_print_samr_UserInfo8(ndr, "info8", &r->info8);
3619                 break;
3620
3621                 case 9:
3622                         ndr_print_samr_UserInfo9(ndr, "info9", &r->info9);
3623                 break;
3624
3625                 case 10:
3626                         ndr_print_samr_UserInfo10(ndr, "info10", &r->info10);
3627                 break;
3628
3629                 case 11:
3630                         ndr_print_samr_UserInfo11(ndr, "info11", &r->info11);
3631                 break;
3632
3633                 case 12:
3634                         ndr_print_samr_UserInfo12(ndr, "info12", &r->info12);
3635                 break;
3636
3637                 case 13:
3638                         ndr_print_samr_UserInfo13(ndr, "info13", &r->info13);
3639                 break;
3640
3641                 case 14:
3642                         ndr_print_samr_UserInfo14(ndr, "info14", &r->info14);
3643                 break;
3644
3645                 case 16:
3646                         ndr_print_samr_UserInfo16(ndr, "info16", &r->info16);
3647                 break;
3648
3649                 case 17:
3650                         ndr_print_samr_UserInfo17(ndr, "info17", &r->info17);
3651                 break;
3652
3653                 case 18:
3654                         ndr_print_samr_UserInfo18(ndr, "info18", &r->info18);
3655                 break;
3656
3657                 case 20:
3658                         ndr_print_samr_UserInfo20(ndr, "info20", &r->info20);
3659                 break;
3660
3661                 case 21:
3662                         ndr_print_samr_UserInfo21(ndr, "info21", &r->info21);
3663                 break;
3664
3665                 case 23:
3666                         ndr_print_samr_UserInfo23(ndr, "info23", &r->info23);
3667                 break;
3668
3669                 case 24:
3670                         ndr_print_samr_UserInfo24(ndr, "info24", &r->info24);
3671                 break;
3672
3673                 case 25:
3674                         ndr_print_samr_UserInfo25(ndr, "info25", &r->info25);
3675                 break;
3676
3677                 case 26:
3678                         ndr_print_samr_UserInfo26(ndr, "info26", &r->info26);
3679                 break;
3680
3681                 default:
3682                         ndr_print_bad_level(ndr, name, level);
3683         }
3684 }
3685
3686 _PUBLIC_ enum ndr_err_code ndr_push_samr_RidWithAttribute(struct ndr_push *ndr, int ndr_flags, const struct samr_RidWithAttribute *r)
3687 {
3688         if (ndr_flags & NDR_SCALARS) {
3689                 NDR_CHECK(ndr_push_align(ndr, 4));
3690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
3691                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
3692         }
3693         if (ndr_flags & NDR_BUFFERS) {
3694         }
3695         return NDR_ERR_SUCCESS;
3696 }
3697
3698 _PUBLIC_ enum ndr_err_code ndr_pull_samr_RidWithAttribute(struct ndr_pull *ndr, int ndr_flags, struct samr_RidWithAttribute *r)
3699 {
3700         if (ndr_flags & NDR_SCALARS) {
3701                 NDR_CHECK(ndr_pull_align(ndr, 4));
3702                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
3703                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
3704         }
3705         if (ndr_flags & NDR_BUFFERS) {
3706         }
3707         return NDR_ERR_SUCCESS;
3708 }
3709
3710 _PUBLIC_ void ndr_print_samr_RidWithAttribute(struct ndr_print *ndr, const char *name, const struct samr_RidWithAttribute *r)
3711 {
3712         ndr_print_struct(ndr, name, "samr_RidWithAttribute");
3713         ndr->depth++;
3714         ndr_print_uint32(ndr, "rid", r->rid);
3715         ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);
3716         ndr->depth--;
3717 }
3718
3719 _PUBLIC_ enum ndr_err_code ndr_push_samr_RidWithAttributeArray(struct ndr_push *ndr, int ndr_flags, const struct samr_RidWithAttributeArray *r)
3720 {
3721         uint32_t cntr_rids_1;
3722         if (ndr_flags & NDR_SCALARS) {
3723                 NDR_CHECK(ndr_push_align(ndr, 4));
3724                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3725                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->rids));
3726         }
3727         if (ndr_flags & NDR_BUFFERS) {
3728                 if (r->rids) {
3729                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3730                         for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {
3731                                 NDR_CHECK(ndr_push_samr_RidWithAttribute(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));
3732                         }
3733                 }
3734         }
3735         return NDR_ERR_SUCCESS;
3736 }
3737
3738 _PUBLIC_ enum ndr_err_code ndr_pull_samr_RidWithAttributeArray(struct ndr_pull *ndr, int ndr_flags, struct samr_RidWithAttributeArray *r)
3739 {
3740         uint32_t _ptr_rids;
3741         uint32_t cntr_rids_1;
3742         TALLOC_CTX *_mem_save_rids_0;
3743         TALLOC_CTX *_mem_save_rids_1;
3744         if (ndr_flags & NDR_SCALARS) {
3745                 NDR_CHECK(ndr_pull_align(ndr, 4));
3746                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3747                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
3748                 if (_ptr_rids) {
3749                         NDR_PULL_ALLOC(ndr, r->rids);
3750                 } else {
3751                         r->rids = NULL;
3752                 }
3753         }
3754         if (ndr_flags & NDR_BUFFERS) {
3755                 if (r->rids) {
3756                         _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
3757                         NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
3758                         NDR_CHECK(ndr_pull_array_size(ndr, &r->rids));
3759                         NDR_PULL_ALLOC_N(ndr, r->rids, ndr_get_array_size(ndr, &r->rids));
3760                         _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
3761                         NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
3762                         for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {
3763                                 NDR_CHECK(ndr_pull_samr_RidWithAttribute(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));
3764                         }
3765                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
3766                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
3767                 }
3768                 if (r->rids) {
3769                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->rids, r->count));
3770                 }
3771         }
3772         return NDR_ERR_SUCCESS;
3773 }
3774
3775 _PUBLIC_ void ndr_print_samr_RidWithAttributeArray(struct ndr_print *ndr, const char *name, const struct samr_RidWithAttributeArray *r)
3776 {
3777         uint32_t cntr_rids_1;
3778         ndr_print_struct(ndr, name, "samr_RidWithAttributeArray");
3779         ndr->depth++;
3780         ndr_print_uint32(ndr, "count", r->count);
3781         ndr_print_ptr(ndr, "rids", r->rids);
3782         ndr->depth++;
3783         if (r->rids) {
3784                 ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->count);
3785                 ndr->depth++;
3786                 for (cntr_rids_1=0;cntr_rids_1<r->count;cntr_rids_1++) {
3787                         char *idx_1=NULL;
3788                         if (asprintf(&idx_1, "[%d]", cntr_rids_1) != -1) {
3789                                 ndr_print_samr_RidWithAttribute(ndr, "rids", &r->rids[cntr_rids_1]);
3790                                 free(idx_1);
3791                         }
3792                 }
3793                 ndr->depth--;
3794         }
3795         ndr->depth--;
3796         ndr->depth--;
3797 }
3798
3799 static enum ndr_err_code ndr_push_samr_DispEntryGeneral(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryGeneral *r)
3800 {
3801         if (ndr_flags & NDR_SCALARS) {
3802                 NDR_CHECK(ndr_push_align(ndr, 4));
3803                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
3804                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
3805                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
3806                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
3807                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
3808                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
3809         }
3810         if (ndr_flags & NDR_BUFFERS) {
3811                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
3812                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
3813                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
3814         }
3815         return NDR_ERR_SUCCESS;
3816 }
3817
3818 static enum ndr_err_code ndr_pull_samr_DispEntryGeneral(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryGeneral *r)
3819 {
3820         if (ndr_flags & NDR_SCALARS) {
3821                 NDR_CHECK(ndr_pull_align(ndr, 4));
3822                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
3823                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
3824                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
3825                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
3826                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
3827                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
3828         }
3829         if (ndr_flags & NDR_BUFFERS) {
3830                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
3831                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
3832                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
3833         }
3834         return NDR_ERR_SUCCESS;
3835 }
3836
3837 _PUBLIC_ void ndr_print_samr_DispEntryGeneral(struct ndr_print *ndr, const char *name, const struct samr_DispEntryGeneral *r)
3838 {
3839         ndr_print_struct(ndr, name, "samr_DispEntryGeneral");
3840         ndr->depth++;
3841         ndr_print_uint32(ndr, "idx", r->idx);
3842         ndr_print_uint32(ndr, "rid", r->rid);
3843         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
3844         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
3845         ndr_print_lsa_String(ndr, "description", &r->description);
3846         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
3847         ndr->depth--;
3848 }
3849
3850 static enum ndr_err_code ndr_push_samr_DispInfoGeneral(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoGeneral *r)
3851 {
3852         uint32_t cntr_entries_1;
3853         if (ndr_flags & NDR_SCALARS) {
3854                 NDR_CHECK(ndr_push_align(ndr, 4));
3855                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3856                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
3857         }
3858         if (ndr_flags & NDR_BUFFERS) {
3859                 if (r->entries) {
3860                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3861                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
3862                                 NDR_CHECK(ndr_push_samr_DispEntryGeneral(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
3863                         }
3864                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
3865                                 NDR_CHECK(ndr_push_samr_DispEntryGeneral(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
3866                         }
3867                 }
3868         }
3869         return NDR_ERR_SUCCESS;
3870 }
3871
3872 static enum ndr_err_code ndr_pull_samr_DispInfoGeneral(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoGeneral *r)
3873 {
3874         uint32_t _ptr_entries;
3875         uint32_t cntr_entries_1;
3876         TALLOC_CTX *_mem_save_entries_0;
3877         TALLOC_CTX *_mem_save_entries_1;
3878         if (ndr_flags & NDR_SCALARS) {
3879                 NDR_CHECK(ndr_pull_align(ndr, 4));
3880                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3881                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
3882                 if (_ptr_entries) {
3883                         NDR_PULL_ALLOC(ndr, r->entries);
3884                 } else {
3885                         r->entries = NULL;
3886                 }
3887         }
3888         if (ndr_flags & NDR_BUFFERS) {
3889                 if (r->entries) {
3890                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
3891                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
3892                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
3893                         NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
3894                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
3895                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
3896                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
3897                                 NDR_CHECK(ndr_pull_samr_DispEntryGeneral(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
3898                         }
3899                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
3900                                 NDR_CHECK(ndr_pull_samr_DispEntryGeneral(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
3901                         }
3902                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
3903                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
3904                 }
3905                 if (r->entries) {
3906                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
3907                 }
3908         }
3909         return NDR_ERR_SUCCESS;
3910 }
3911
3912 _PUBLIC_ void ndr_print_samr_DispInfoGeneral(struct ndr_print *ndr, const char *name, const struct samr_DispInfoGeneral *r)
3913 {
3914         uint32_t cntr_entries_1;
3915         ndr_print_struct(ndr, name, "samr_DispInfoGeneral");
3916         ndr->depth++;
3917         ndr_print_uint32(ndr, "count", r->count);
3918         ndr_print_ptr(ndr, "entries", r->entries);
3919         ndr->depth++;
3920         if (r->entries) {
3921                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
3922                 ndr->depth++;
3923                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
3924                         char *idx_1=NULL;
3925                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
3926                                 ndr_print_samr_DispEntryGeneral(ndr, "entries", &r->entries[cntr_entries_1]);
3927                                 free(idx_1);
3928                         }
3929                 }
3930                 ndr->depth--;
3931         }
3932         ndr->depth--;
3933         ndr->depth--;
3934 }
3935
3936 static enum ndr_err_code ndr_push_samr_DispEntryFull(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryFull *r)
3937 {
3938         if (ndr_flags & NDR_SCALARS) {
3939                 NDR_CHECK(ndr_push_align(ndr, 4));
3940                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
3941                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
3942                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
3943                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
3944                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
3945         }
3946         if (ndr_flags & NDR_BUFFERS) {
3947                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
3948                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
3949         }
3950         return NDR_ERR_SUCCESS;
3951 }
3952
3953 static enum ndr_err_code ndr_pull_samr_DispEntryFull(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryFull *r)
3954 {
3955         if (ndr_flags & NDR_SCALARS) {
3956                 NDR_CHECK(ndr_pull_align(ndr, 4));
3957                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
3958                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
3959                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
3960                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
3961                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
3962         }
3963         if (ndr_flags & NDR_BUFFERS) {
3964                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
3965                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
3966         }
3967         return NDR_ERR_SUCCESS;
3968 }
3969
3970 _PUBLIC_ void ndr_print_samr_DispEntryFull(struct ndr_print *ndr, const char *name, const struct samr_DispEntryFull *r)
3971 {
3972         ndr_print_struct(ndr, name, "samr_DispEntryFull");
3973         ndr->depth++;
3974         ndr_print_uint32(ndr, "idx", r->idx);
3975         ndr_print_uint32(ndr, "rid", r->rid);
3976         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
3977         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
3978         ndr_print_lsa_String(ndr, "description", &r->description);
3979         ndr->depth--;
3980 }
3981
3982 static enum ndr_err_code ndr_push_samr_DispInfoFull(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoFull *r)
3983 {
3984         uint32_t cntr_entries_1;
3985         if (ndr_flags & NDR_SCALARS) {
3986                 NDR_CHECK(ndr_push_align(ndr, 4));
3987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3988                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
3989         }
3990         if (ndr_flags & NDR_BUFFERS) {
3991                 if (r->entries) {
3992                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3993                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
3994                                 NDR_CHECK(ndr_push_samr_DispEntryFull(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
3995                         }
3996                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
3997                                 NDR_CHECK(ndr_push_samr_DispEntryFull(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
3998                         }
3999                 }
4000         }
4001         return NDR_ERR_SUCCESS;
4002 }
4003
4004 static enum ndr_err_code ndr_pull_samr_DispInfoFull(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoFull *r)
4005 {
4006         uint32_t _ptr_entries;
4007         uint32_t cntr_entries_1;
4008         TALLOC_CTX *_mem_save_entries_0;
4009         TALLOC_CTX *_mem_save_entries_1;
4010         if (ndr_flags & NDR_SCALARS) {
4011                 NDR_CHECK(ndr_pull_align(ndr, 4));
4012                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4013                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
4014                 if (_ptr_entries) {
4015                         NDR_PULL_ALLOC(ndr, r->entries);
4016                 } else {
4017                         r->entries = NULL;
4018                 }
4019         }
4020         if (ndr_flags & NDR_BUFFERS) {
4021                 if (r->entries) {
4022                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
4023                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4024                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
4025                         NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
4026                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
4027                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4028                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4029                                 NDR_CHECK(ndr_pull_samr_DispEntryFull(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4030                         }
4031                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4032                                 NDR_CHECK(ndr_pull_samr_DispEntryFull(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4033                         }
4034                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
4035                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
4036                 }
4037                 if (r->entries) {
4038                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
4039                 }
4040         }
4041         return NDR_ERR_SUCCESS;
4042 }
4043
4044 _PUBLIC_ void ndr_print_samr_DispInfoFull(struct ndr_print *ndr, const char *name, const struct samr_DispInfoFull *r)
4045 {
4046         uint32_t cntr_entries_1;
4047         ndr_print_struct(ndr, name, "samr_DispInfoFull");
4048         ndr->depth++;
4049         ndr_print_uint32(ndr, "count", r->count);
4050         ndr_print_ptr(ndr, "entries", r->entries);
4051         ndr->depth++;
4052         if (r->entries) {
4053                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
4054                 ndr->depth++;
4055                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
4056                         char *idx_1=NULL;
4057                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
4058                                 ndr_print_samr_DispEntryFull(ndr, "entries", &r->entries[cntr_entries_1]);
4059                                 free(idx_1);
4060                         }
4061                 }
4062                 ndr->depth--;
4063         }
4064         ndr->depth--;
4065         ndr->depth--;
4066 }
4067
4068 static enum ndr_err_code ndr_push_samr_DispEntryFullGroup(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryFullGroup *r)
4069 {
4070         if (ndr_flags & NDR_SCALARS) {
4071                 NDR_CHECK(ndr_push_align(ndr, 4));
4072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
4073                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
4074                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->acct_flags));
4075                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
4076                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
4077         }
4078         if (ndr_flags & NDR_BUFFERS) {
4079                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
4080                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
4081         }
4082         return NDR_ERR_SUCCESS;
4083 }
4084
4085 static enum ndr_err_code ndr_pull_samr_DispEntryFullGroup(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryFullGroup *r)
4086 {
4087         if (ndr_flags & NDR_SCALARS) {
4088                 NDR_CHECK(ndr_pull_align(ndr, 4));
4089                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
4090                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
4091                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->acct_flags));
4092                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
4093                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
4094         }
4095         if (ndr_flags & NDR_BUFFERS) {
4096                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
4097                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
4098         }
4099         return NDR_ERR_SUCCESS;
4100 }
4101
4102 _PUBLIC_ void ndr_print_samr_DispEntryFullGroup(struct ndr_print *ndr, const char *name, const struct samr_DispEntryFullGroup *r)
4103 {
4104         ndr_print_struct(ndr, name, "samr_DispEntryFullGroup");
4105         ndr->depth++;
4106         ndr_print_uint32(ndr, "idx", r->idx);
4107         ndr_print_uint32(ndr, "rid", r->rid);
4108         ndr_print_samr_GroupAttrs(ndr, "acct_flags", r->acct_flags);
4109         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
4110         ndr_print_lsa_String(ndr, "description", &r->description);
4111         ndr->depth--;
4112 }
4113
4114 static enum ndr_err_code ndr_push_samr_DispInfoFullGroups(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoFullGroups *r)
4115 {
4116         uint32_t cntr_entries_1;
4117         if (ndr_flags & NDR_SCALARS) {
4118                 NDR_CHECK(ndr_push_align(ndr, 4));
4119                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4120                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
4121         }
4122         if (ndr_flags & NDR_BUFFERS) {
4123                 if (r->entries) {
4124                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4125                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4126                                 NDR_CHECK(ndr_push_samr_DispEntryFullGroup(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4127                         }
4128                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4129                                 NDR_CHECK(ndr_push_samr_DispEntryFullGroup(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4130                         }
4131                 }
4132         }
4133         return NDR_ERR_SUCCESS;
4134 }
4135
4136 static enum ndr_err_code ndr_pull_samr_DispInfoFullGroups(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoFullGroups *r)
4137 {
4138         uint32_t _ptr_entries;
4139         uint32_t cntr_entries_1;
4140         TALLOC_CTX *_mem_save_entries_0;
4141         TALLOC_CTX *_mem_save_entries_1;
4142         if (ndr_flags & NDR_SCALARS) {
4143                 NDR_CHECK(ndr_pull_align(ndr, 4));
4144                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4145                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
4146                 if (_ptr_entries) {
4147                         NDR_PULL_ALLOC(ndr, r->entries);
4148                 } else {
4149                         r->entries = NULL;
4150                 }
4151         }
4152         if (ndr_flags & NDR_BUFFERS) {
4153                 if (r->entries) {
4154                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
4155                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4156                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
4157                         NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
4158                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
4159                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4160                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4161                                 NDR_CHECK(ndr_pull_samr_DispEntryFullGroup(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4162                         }
4163                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4164                                 NDR_CHECK(ndr_pull_samr_DispEntryFullGroup(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4165                         }
4166                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
4167                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
4168                 }
4169                 if (r->entries) {
4170                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
4171                 }
4172         }
4173         return NDR_ERR_SUCCESS;
4174 }
4175
4176 _PUBLIC_ void ndr_print_samr_DispInfoFullGroups(struct ndr_print *ndr, const char *name, const struct samr_DispInfoFullGroups *r)
4177 {
4178         uint32_t cntr_entries_1;
4179         ndr_print_struct(ndr, name, "samr_DispInfoFullGroups");
4180         ndr->depth++;
4181         ndr_print_uint32(ndr, "count", r->count);
4182         ndr_print_ptr(ndr, "entries", r->entries);
4183         ndr->depth++;
4184         if (r->entries) {
4185                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
4186                 ndr->depth++;
4187                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
4188                         char *idx_1=NULL;
4189                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
4190                                 ndr_print_samr_DispEntryFullGroup(ndr, "entries", &r->entries[cntr_entries_1]);
4191                                 free(idx_1);
4192                         }
4193                 }
4194                 ndr->depth--;
4195         }
4196         ndr->depth--;
4197         ndr->depth--;
4198 }
4199
4200 static enum ndr_err_code ndr_push_samr_DispEntryAscii(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryAscii *r)
4201 {
4202         if (ndr_flags & NDR_SCALARS) {
4203                 NDR_CHECK(ndr_push_align(ndr, 4));
4204                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
4205                 NDR_CHECK(ndr_push_lsa_AsciiStringLarge(ndr, NDR_SCALARS, &r->account_name));
4206         }
4207         if (ndr_flags & NDR_BUFFERS) {
4208                 NDR_CHECK(ndr_push_lsa_AsciiStringLarge(ndr, NDR_BUFFERS, &r->account_name));
4209         }
4210         return NDR_ERR_SUCCESS;
4211 }
4212
4213 static enum ndr_err_code ndr_pull_samr_DispEntryAscii(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryAscii *r)
4214 {
4215         if (ndr_flags & NDR_SCALARS) {
4216                 NDR_CHECK(ndr_pull_align(ndr, 4));
4217                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
4218                 NDR_CHECK(ndr_pull_lsa_AsciiStringLarge(ndr, NDR_SCALARS, &r->account_name));
4219         }
4220         if (ndr_flags & NDR_BUFFERS) {
4221                 NDR_CHECK(ndr_pull_lsa_AsciiStringLarge(ndr, NDR_BUFFERS, &r->account_name));
4222         }
4223         return NDR_ERR_SUCCESS;
4224 }
4225
4226 _PUBLIC_ void ndr_print_samr_DispEntryAscii(struct ndr_print *ndr, const char *name, const struct samr_DispEntryAscii *r)
4227 {
4228         ndr_print_struct(ndr, name, "samr_DispEntryAscii");
4229         ndr->depth++;
4230         ndr_print_uint32(ndr, "idx", r->idx);
4231         ndr_print_lsa_AsciiStringLarge(ndr, "account_name", &r->account_name);
4232         ndr->depth--;
4233 }
4234
4235 static enum ndr_err_code ndr_push_samr_DispInfoAscii(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoAscii *r)
4236 {
4237         uint32_t cntr_entries_1;
4238         if (ndr_flags & NDR_SCALARS) {
4239                 NDR_CHECK(ndr_push_align(ndr, 4));
4240                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4241                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
4242         }
4243         if (ndr_flags & NDR_BUFFERS) {
4244                 if (r->entries) {
4245                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4246                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4247                                 NDR_CHECK(ndr_push_samr_DispEntryAscii(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4248                         }
4249                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4250                                 NDR_CHECK(ndr_push_samr_DispEntryAscii(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4251                         }
4252                 }
4253         }
4254         return NDR_ERR_SUCCESS;
4255 }
4256
4257 static enum ndr_err_code ndr_pull_samr_DispInfoAscii(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoAscii *r)
4258 {
4259         uint32_t _ptr_entries;
4260         uint32_t cntr_entries_1;
4261         TALLOC_CTX *_mem_save_entries_0;
4262         TALLOC_CTX *_mem_save_entries_1;
4263         if (ndr_flags & NDR_SCALARS) {
4264                 NDR_CHECK(ndr_pull_align(ndr, 4));
4265                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4266                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
4267                 if (_ptr_entries) {
4268                         NDR_PULL_ALLOC(ndr, r->entries);
4269                 } else {
4270                         r->entries = NULL;
4271                 }
4272         }
4273         if (ndr_flags & NDR_BUFFERS) {
4274                 if (r->entries) {
4275                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
4276                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4277                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
4278                         NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
4279                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
4280                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4281                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4282                                 NDR_CHECK(ndr_pull_samr_DispEntryAscii(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4283                         }
4284                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4285                                 NDR_CHECK(ndr_pull_samr_DispEntryAscii(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4286                         }
4287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
4288                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
4289                 }
4290                 if (r->entries) {
4291                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
4292                 }
4293         }
4294         return NDR_ERR_SUCCESS;
4295 }
4296
4297 _PUBLIC_ void ndr_print_samr_DispInfoAscii(struct ndr_print *ndr, const char *name, const struct samr_DispInfoAscii *r)
4298 {
4299         uint32_t cntr_entries_1;
4300         ndr_print_struct(ndr, name, "samr_DispInfoAscii");
4301         ndr->depth++;
4302         ndr_print_uint32(ndr, "count", r->count);
4303         ndr_print_ptr(ndr, "entries", r->entries);
4304         ndr->depth++;
4305         if (r->entries) {
4306                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
4307                 ndr->depth++;
4308                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
4309                         char *idx_1=NULL;
4310                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
4311                                 ndr_print_samr_DispEntryAscii(ndr, "entries", &r->entries[cntr_entries_1]);
4312                                 free(idx_1);
4313                         }
4314                 }
4315                 ndr->depth--;
4316         }
4317         ndr->depth--;
4318         ndr->depth--;
4319 }
4320
4321 static enum ndr_err_code ndr_push_samr_DispInfo(struct ndr_push *ndr, int ndr_flags, const union samr_DispInfo *r)
4322 {
4323         if (ndr_flags & NDR_SCALARS) {
4324                 int level = ndr_push_get_switch_value(ndr, r);
4325                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
4326                 switch (level) {
4327                         case 1: {
4328                                 NDR_CHECK(ndr_push_samr_DispInfoGeneral(ndr, NDR_SCALARS, &r->info1));
4329                         break; }
4330
4331                         case 2: {
4332                                 NDR_CHECK(ndr_push_samr_DispInfoFull(ndr, NDR_SCALARS, &r->info2));
4333                         break; }
4334
4335                         case 3: {
4336                                 NDR_CHECK(ndr_push_samr_DispInfoFullGroups(ndr, NDR_SCALARS, &r->info3));
4337                         break; }
4338
4339                         case 4: {
4340                                 NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info4));
4341                         break; }
4342
4343                         case 5: {
4344                                 NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info5));
4345                         break; }
4346
4347                         default:
4348                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4349                 }
4350         }
4351         if (ndr_flags & NDR_BUFFERS) {
4352                 int level = ndr_push_get_switch_value(ndr, r);
4353                 switch (level) {
4354                         case 1:
4355                                 NDR_CHECK(ndr_push_samr_DispInfoGeneral(ndr, NDR_BUFFERS, &r->info1));
4356                         break;
4357
4358                         case 2:
4359                                 NDR_CHECK(ndr_push_samr_DispInfoFull(ndr, NDR_BUFFERS, &r->info2));
4360                         break;
4361
4362                         case 3:
4363                                 NDR_CHECK(ndr_push_samr_DispInfoFullGroups(ndr, NDR_BUFFERS, &r->info3));
4364                         break;
4365
4366                         case 4:
4367                                 NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info4));
4368                         break;
4369
4370                         case 5:
4371                                 NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info5));
4372                         break;
4373
4374                         default:
4375                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4376                 }
4377         }
4378         return NDR_ERR_SUCCESS;
4379 }
4380
4381 static enum ndr_err_code ndr_pull_samr_DispInfo(struct ndr_pull *ndr, int ndr_flags, union samr_DispInfo *r)
4382 {
4383         int level;
4384         uint16_t _level;
4385         level = ndr_pull_get_switch_value(ndr, r);
4386         if (ndr_flags & NDR_SCALARS) {
4387                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
4388                 if (_level != level) {
4389                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4390                 }
4391                 switch (level) {
4392                         case 1: {
4393                                 NDR_CHECK(ndr_pull_samr_DispInfoGeneral(ndr, NDR_SCALARS, &r->info1));
4394                         break; }
4395
4396                         case 2: {
4397                                 NDR_CHECK(ndr_pull_samr_DispInfoFull(ndr, NDR_SCALARS, &r->info2));
4398                         break; }
4399
4400                         case 3: {
4401                                 NDR_CHECK(ndr_pull_samr_DispInfoFullGroups(ndr, NDR_SCALARS, &r->info3));
4402                         break; }
4403
4404                         case 4: {
4405                                 NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info4));
4406                         break; }
4407
4408                         case 5: {
4409                                 NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info5));
4410                         break; }
4411
4412                         default:
4413                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4414                 }
4415         }
4416         if (ndr_flags & NDR_BUFFERS) {
4417                 switch (level) {
4418                         case 1:
4419                                 NDR_CHECK(ndr_pull_samr_DispInfoGeneral(ndr, NDR_BUFFERS, &r->info1));
4420                         break;
4421
4422                         case 2:
4423                                 NDR_CHECK(ndr_pull_samr_DispInfoFull(ndr, NDR_BUFFERS, &r->info2));
4424                         break;
4425
4426                         case 3:
4427                                 NDR_CHECK(ndr_pull_samr_DispInfoFullGroups(ndr, NDR_BUFFERS, &r->info3));
4428                         break;
4429
4430                         case 4:
4431                                 NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info4));
4432                         break;
4433
4434                         case 5:
4435                                 NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info5));
4436                         break;
4437
4438                         default:
4439                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4440                 }
4441         }
4442         return NDR_ERR_SUCCESS;
4443 }
4444
4445 _PUBLIC_ void ndr_print_samr_DispInfo(struct ndr_print *ndr, const char *name, const union samr_DispInfo *r)
4446 {
4447         int level;
4448         level = ndr_print_get_switch_value(ndr, r);
4449         ndr_print_union(ndr, name, level, "samr_DispInfo");
4450         switch (level) {
4451                 case 1:
4452                         ndr_print_samr_DispInfoGeneral(ndr, "info1", &r->info1);
4453                 break;
4454
4455                 case 2:
4456                         ndr_print_samr_DispInfoFull(ndr, "info2", &r->info2);
4457                 break;
4458
4459                 case 3:
4460                         ndr_print_samr_DispInfoFullGroups(ndr, "info3", &r->info3);
4461                 break;
4462
4463                 case 4:
4464                         ndr_print_samr_DispInfoAscii(ndr, "info4", &r->info4);
4465                 break;
4466
4467                 case 5:
4468                         ndr_print_samr_DispInfoAscii(ndr, "info5", &r->info5);
4469                 break;
4470
4471                 default:
4472                         ndr_print_bad_level(ndr, name, level);
4473         }
4474 }
4475
4476 static enum ndr_err_code ndr_push_samr_PwInfo(struct ndr_push *ndr, int ndr_flags, const struct samr_PwInfo *r)
4477 {
4478         if (ndr_flags & NDR_SCALARS) {
4479                 NDR_CHECK(ndr_push_align(ndr, 4));
4480                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->min_password_length));
4481                 NDR_CHECK(ndr_push_samr_PasswordProperties(ndr, NDR_SCALARS, r->password_properties));
4482         }
4483         if (ndr_flags & NDR_BUFFERS) {
4484         }
4485         return NDR_ERR_SUCCESS;
4486 }
4487
4488 static enum ndr_err_code ndr_pull_samr_PwInfo(struct ndr_pull *ndr, int ndr_flags, struct samr_PwInfo *r)
4489 {
4490         if (ndr_flags & NDR_SCALARS) {
4491                 NDR_CHECK(ndr_pull_align(ndr, 4));
4492                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->min_password_length));
4493                 NDR_CHECK(ndr_pull_samr_PasswordProperties(ndr, NDR_SCALARS, &r->password_properties));
4494         }
4495         if (ndr_flags & NDR_BUFFERS) {
4496         }
4497         return NDR_ERR_SUCCESS;
4498 }
4499
4500 _PUBLIC_ void ndr_print_samr_PwInfo(struct ndr_print *ndr, const char *name, const struct samr_PwInfo *r)
4501 {
4502         ndr_print_struct(ndr, name, "samr_PwInfo");
4503         ndr->depth++;
4504         ndr_print_uint16(ndr, "min_password_length", r->min_password_length);
4505         ndr_print_samr_PasswordProperties(ndr, "password_properties", r->password_properties);
4506         ndr->depth--;
4507 }
4508
4509 static enum ndr_err_code ndr_push_samr_ConnectVersion(struct ndr_push *ndr, int ndr_flags, enum samr_ConnectVersion r)
4510 {
4511         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
4512         return NDR_ERR_SUCCESS;
4513 }
4514
4515 static enum ndr_err_code ndr_pull_samr_ConnectVersion(struct ndr_pull *ndr, int ndr_flags, enum samr_ConnectVersion *r)
4516 {
4517         uint16_t v;
4518         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
4519         *r = v;
4520         return NDR_ERR_SUCCESS;
4521 }
4522
4523 _PUBLIC_ void ndr_print_samr_ConnectVersion(struct ndr_print *ndr, const char *name, enum samr_ConnectVersion r)
4524 {
4525         const char *val = NULL;
4526
4527         switch (r) {
4528                 case SAMR_CONNECT_PRE_W2K: val = "SAMR_CONNECT_PRE_W2K"; break;
4529                 case SAMR_CONNECT_W2K: val = "SAMR_CONNECT_W2K"; break;
4530                 case SAMR_CONNECT_AFTER_W2K: val = "SAMR_CONNECT_AFTER_W2K"; break;
4531         }
4532         ndr_print_enum(ndr, name, "ENUM", val, r);
4533 }
4534
4535 static enum ndr_err_code ndr_push_samr_ChangeReject(struct ndr_push *ndr, int ndr_flags, const struct samr_ChangeReject *r)
4536 {
4537         if (ndr_flags & NDR_SCALARS) {
4538                 NDR_CHECK(ndr_push_align(ndr, 4));
4539                 NDR_CHECK(ndr_push_samr_RejectReason(ndr, NDR_SCALARS, r->reason));
4540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
4541                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
4542         }
4543         if (ndr_flags & NDR_BUFFERS) {
4544         }
4545         return NDR_ERR_SUCCESS;
4546 }
4547
4548 static enum ndr_err_code ndr_pull_samr_ChangeReject(struct ndr_pull *ndr, int ndr_flags, struct samr_ChangeReject *r)
4549 {
4550         if (ndr_flags & NDR_SCALARS) {
4551                 NDR_CHECK(ndr_pull_align(ndr, 4));
4552                 NDR_CHECK(ndr_pull_samr_RejectReason(ndr, NDR_SCALARS, &r->reason));
4553                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
4554                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
4555         }
4556         if (ndr_flags & NDR_BUFFERS) {
4557         }
4558         return NDR_ERR_SUCCESS;
4559 }
4560
4561 _PUBLIC_ void ndr_print_samr_ChangeReject(struct ndr_print *ndr, const char *name, const struct samr_ChangeReject *r)
4562 {
4563         ndr_print_struct(ndr, name, "samr_ChangeReject");
4564         ndr->depth++;
4565         ndr_print_samr_RejectReason(ndr, "reason", r->reason);
4566         ndr_print_uint32(ndr, "unknown1", r->unknown1);
4567         ndr_print_uint32(ndr, "unknown2", r->unknown2);
4568         ndr->depth--;
4569 }
4570
4571 static enum ndr_err_code ndr_push_samr_ConnectInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_ConnectInfo1 *r)
4572 {
4573         if (ndr_flags & NDR_SCALARS) {
4574                 NDR_CHECK(ndr_push_align(ndr, 4));
4575                 NDR_CHECK(ndr_push_samr_ConnectVersion(ndr, NDR_SCALARS, r->client_version));
4576                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
4577         }
4578         if (ndr_flags & NDR_BUFFERS) {
4579         }
4580         return NDR_ERR_SUCCESS;
4581 }
4582
4583 static enum ndr_err_code ndr_pull_samr_ConnectInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_ConnectInfo1 *r)
4584 {
4585         if (ndr_flags & NDR_SCALARS) {
4586                 NDR_CHECK(ndr_pull_align(ndr, 4));
4587                 NDR_CHECK(ndr_pull_samr_ConnectVersion(ndr, NDR_SCALARS, &r->client_version));
4588                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
4589         }
4590         if (ndr_flags & NDR_BUFFERS) {
4591         }
4592         return NDR_ERR_SUCCESS;
4593 }
4594
4595 _PUBLIC_ void ndr_print_samr_ConnectInfo1(struct ndr_print *ndr, const char *name, const struct samr_ConnectInfo1 *r)
4596 {
4597         ndr_print_struct(ndr, name, "samr_ConnectInfo1");
4598         ndr->depth++;
4599         ndr_print_samr_ConnectVersion(ndr, "client_version", r->client_version);
4600         ndr_print_uint32(ndr, "unknown2", r->unknown2);
4601         ndr->depth--;
4602 }
4603
4604 static enum ndr_err_code ndr_push_samr_ConnectInfo(struct ndr_push *ndr, int ndr_flags, const union samr_ConnectInfo *r)
4605 {
4606         if (ndr_flags & NDR_SCALARS) {
4607                 int level = ndr_push_get_switch_value(ndr, r);
4608                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4609                 switch (level) {
4610                         case 1: {
4611                                 NDR_CHECK(ndr_push_samr_ConnectInfo1(ndr, NDR_SCALARS, &r->info1));
4612                         break; }
4613
4614                         default:
4615                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4616                 }
4617         }
4618         if (ndr_flags & NDR_BUFFERS) {
4619                 int level = ndr_push_get_switch_value(ndr, r);
4620                 switch (level) {
4621                         case 1:
4622                         break;
4623
4624                         default:
4625                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4626                 }
4627         }
4628         return NDR_ERR_SUCCESS;
4629 }
4630
4631 static enum ndr_err_code ndr_pull_samr_ConnectInfo(struct ndr_pull *ndr, int ndr_flags, union samr_ConnectInfo *r)
4632 {
4633         int level;
4634         uint32_t _level;
4635         level = ndr_pull_get_switch_value(ndr, r);
4636         if (ndr_flags & NDR_SCALARS) {
4637                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4638                 if (_level != level) {
4639                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4640                 }
4641                 switch (level) {
4642                         case 1: {
4643                                 NDR_CHECK(ndr_pull_samr_ConnectInfo1(ndr, NDR_SCALARS, &r->info1));
4644                         break; }
4645
4646                         default:
4647                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4648                 }
4649         }
4650         if (ndr_flags & NDR_BUFFERS) {
4651                 switch (level) {
4652                         case 1:
4653                         break;
4654
4655                         default:
4656                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4657                 }
4658         }
4659         return NDR_ERR_SUCCESS;
4660 }
4661
4662 _PUBLIC_ void ndr_print_samr_ConnectInfo(struct ndr_print *ndr, const char *name, const union samr_ConnectInfo *r)
4663 {
4664         int level;
4665         level = ndr_print_get_switch_value(ndr, r);
4666         ndr_print_union(ndr, name, level, "samr_ConnectInfo");
4667         switch (level) {
4668                 case 1:
4669                         ndr_print_samr_ConnectInfo1(ndr, "info1", &r->info1);
4670                 break;
4671
4672                 default:
4673                         ndr_print_bad_level(ndr, name, level);
4674         }
4675 }
4676
4677 static enum ndr_err_code ndr_push_samr_ValidateFieldsPresent(struct ndr_push *ndr, int ndr_flags, uint32_t r)
4678 {
4679         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4680         return NDR_ERR_SUCCESS;
4681 }
4682
4683 static enum ndr_err_code ndr_pull_samr_ValidateFieldsPresent(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
4684 {
4685         uint32_t v;
4686         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4687         *r = v;
4688         return NDR_ERR_SUCCESS;
4689 }
4690
4691 _PUBLIC_ void ndr_print_samr_ValidateFieldsPresent(struct ndr_print *ndr, const char *name, uint32_t r)
4692 {
4693         ndr_print_uint32(ndr, name, r);
4694         ndr->depth++;
4695         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_LAST_SET", SAMR_VALIDATE_FIELD_PASSWORD_LAST_SET, r);
4696         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_BAD_PASSWORD_TIME", SAMR_VALIDATE_FIELD_BAD_PASSWORD_TIME, r);
4697         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_LOCKOUT_TIME", SAMR_VALIDATE_FIELD_LOCKOUT_TIME, r);
4698         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_BAD_PASSWORD_COUNT", SAMR_VALIDATE_FIELD_BAD_PASSWORD_COUNT, r);
4699         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_HISTORY_LENGTH", SAMR_VALIDATE_FIELD_PASSWORD_HISTORY_LENGTH, r);
4700         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_HISTORY", SAMR_VALIDATE_FIELD_PASSWORD_HISTORY, r);
4701         ndr->depth--;
4702 }
4703
4704 static enum ndr_err_code ndr_push_samr_ValidatePasswordLevel(struct ndr_push *ndr, int ndr_flags, enum samr_ValidatePasswordLevel r)
4705 {
4706         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
4707         return NDR_ERR_SUCCESS;
4708 }
4709
4710 static enum ndr_err_code ndr_pull_samr_ValidatePasswordLevel(struct ndr_pull *ndr, int ndr_flags, enum samr_ValidatePasswordLevel *r)
4711 {
4712         uint16_t v;
4713         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
4714         *r = v;
4715         return NDR_ERR_SUCCESS;
4716 }
4717
4718 _PUBLIC_ void ndr_print_samr_ValidatePasswordLevel(struct ndr_print *ndr, const char *name, enum samr_ValidatePasswordLevel r)
4719 {
4720         const char *val = NULL;
4721
4722         switch (r) {
4723                 case NetValidateAuthentication: val = "NetValidateAuthentication"; break;
4724                 case NetValidatePasswordChange: val = "NetValidatePasswordChange"; break;
4725                 case NetValidatePasswordReset: val = "NetValidatePasswordReset"; break;
4726         }
4727         ndr_print_enum(ndr, name, "ENUM", val, r);
4728 }
4729
4730 static enum ndr_err_code ndr_push_samr_ValidationStatus(struct ndr_push *ndr, int ndr_flags, enum samr_ValidationStatus r)
4731 {
4732         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
4733         return NDR_ERR_SUCCESS;
4734 }
4735
4736 static enum ndr_err_code ndr_pull_samr_ValidationStatus(struct ndr_pull *ndr, int ndr_flags, enum samr_ValidationStatus *r)
4737 {
4738         uint16_t v;
4739         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
4740         *r = v;
4741         return NDR_ERR_SUCCESS;
4742 }
4743
4744 _PUBLIC_ void ndr_print_samr_ValidationStatus(struct ndr_print *ndr, const char *name, enum samr_ValidationStatus r)
4745 {
4746         const char *val = NULL;
4747
4748         switch (r) {
4749                 case SAMR_VALIDATION_STATUS_SUCCESS: val = "SAMR_VALIDATION_STATUS_SUCCESS"; break;
4750                 case SAMR_VALIDATION_STATUS_PASSWORD_MUST_CHANGE: val = "SAMR_VALIDATION_STATUS_PASSWORD_MUST_CHANGE"; break;
4751                 case SAMR_VALIDATION_STATUS_ACCOUNT_LOCKED_OUT: val = "SAMR_VALIDATION_STATUS_ACCOUNT_LOCKED_OUT"; break;
4752                 case SAMR_VALIDATION_STATUS_BAD_PASSWORD: val = "SAMR_VALIDATION_STATUS_BAD_PASSWORD"; break;
4753                 case SAMR_VALIDATION_STATUS_PWD_HISTORY_CONFLICT: val = "SAMR_VALIDATION_STATUS_PWD_HISTORY_CONFLICT"; break;
4754                 case SAMR_VALIDATION_STATUS_PWD_TOO_SHORT: val = "SAMR_VALIDATION_STATUS_PWD_TOO_SHORT"; break;
4755                 case SAMR_VALIDATION_STATUS_PWD_TOO_LONG: val = "SAMR_VALIDATION_STATUS_PWD_TOO_LONG"; break;
4756                 case SAMR_VALIDATION_STATUS_NOT_COMPLEX_ENOUGH: val = "SAMR_VALIDATION_STATUS_NOT_COMPLEX_ENOUGH"; break;
4757                 case SAMR_VALIDATION_STATUS_PASSWORD_TOO_RECENT: val = "SAMR_VALIDATION_STATUS_PASSWORD_TOO_RECENT"; break;
4758         }
4759         ndr_print_enum(ndr, name, "ENUM", val, r);
4760 }
4761
4762 static enum ndr_err_code ndr_push_samr_ValidationBlob(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidationBlob *r)
4763 {
4764         if (ndr_flags & NDR_SCALARS) {
4765                 NDR_CHECK(ndr_push_align(ndr, 4));
4766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
4767                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
4768         }
4769         if (ndr_flags & NDR_BUFFERS) {
4770                 if (r->data) {
4771                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
4772                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
4773                 }
4774         }
4775         return NDR_ERR_SUCCESS;
4776 }
4777
4778 static enum ndr_err_code ndr_pull_samr_ValidationBlob(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidationBlob *r)
4779 {
4780         uint32_t _ptr_data;
4781         TALLOC_CTX *_mem_save_data_0;
4782         if (ndr_flags & NDR_SCALARS) {
4783                 NDR_CHECK(ndr_pull_align(ndr, 4));
4784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
4785                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
4786                 if (_ptr_data) {
4787                         NDR_PULL_ALLOC(ndr, r->data);
4788                 } else {
4789                         r->data = NULL;
4790                 }
4791         }
4792         if (ndr_flags & NDR_BUFFERS) {
4793                 if (r->data) {
4794                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
4795                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
4796                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
4797                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
4798                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
4799                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
4800                 }
4801                 if (r->data) {
4802                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
4803                 }
4804         }
4805         return NDR_ERR_SUCCESS;
4806 }
4807
4808 _PUBLIC_ void ndr_print_samr_ValidationBlob(struct ndr_print *ndr, const char *name, const struct samr_ValidationBlob *r)
4809 {
4810         ndr_print_struct(ndr, name, "samr_ValidationBlob");
4811         ndr->depth++;
4812         ndr_print_uint32(ndr, "length", r->length);
4813         ndr_print_ptr(ndr, "data", r->data);
4814         ndr->depth++;
4815         if (r->data) {
4816                 ndr_print_array_uint8(ndr, "data", r->data, r->length);
4817         }
4818         ndr->depth--;
4819         ndr->depth--;
4820 }
4821
4822 static enum ndr_err_code ndr_push_samr_ValidatePasswordInfo(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordInfo *r)
4823 {
4824         uint32_t cntr_pwd_history_1;
4825         if (ndr_flags & NDR_SCALARS) {
4826                 NDR_CHECK(ndr_push_align(ndr, 8));
4827                 NDR_CHECK(ndr_push_samr_ValidateFieldsPresent(ndr, NDR_SCALARS, r->fields_present));
4828                 NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->last_password_change));
4829                 NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->bad_password_time));
4830                 NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->lockout_time));
4831                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bad_pwd_count));
4832                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pwd_history_len));
4833                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pwd_history));
4834         }
4835         if (ndr_flags & NDR_BUFFERS) {
4836                 if (r->pwd_history) {
4837                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pwd_history_len));
4838                         for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {
4839                                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->pwd_history[cntr_pwd_history_1]));
4840                         }
4841                         for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {
4842                                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->pwd_history[cntr_pwd_history_1]));
4843                         }
4844                 }
4845         }
4846         return NDR_ERR_SUCCESS;
4847 }
4848
4849 static enum ndr_err_code ndr_pull_samr_ValidatePasswordInfo(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordInfo *r)
4850 {
4851         uint32_t _ptr_pwd_history;
4852         uint32_t cntr_pwd_history_1;
4853         TALLOC_CTX *_mem_save_pwd_history_0;
4854         TALLOC_CTX *_mem_save_pwd_history_1;
4855         if (ndr_flags & NDR_SCALARS) {
4856                 NDR_CHECK(ndr_pull_align(ndr, 8));
4857                 NDR_CHECK(ndr_pull_samr_ValidateFieldsPresent(ndr, NDR_SCALARS, &r->fields_present));
4858                 NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->last_password_change));
4859                 NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->bad_password_time));
4860                 NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->lockout_time));
4861                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bad_pwd_count));
4862                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pwd_history_len));
4863                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pwd_history));
4864                 if (_ptr_pwd_history) {
4865                         NDR_PULL_ALLOC(ndr, r->pwd_history);
4866                 } else {
4867                         r->pwd_history = NULL;
4868                 }
4869         }
4870         if (ndr_flags & NDR_BUFFERS) {
4871                 if (r->pwd_history) {
4872                         _mem_save_pwd_history_0 = NDR_PULL_GET_MEM_CTX(ndr);
4873                         NDR_PULL_SET_MEM_CTX(ndr, r->pwd_history, 0);
4874                         NDR_CHECK(ndr_pull_array_size(ndr, &r->pwd_history));
4875                         NDR_PULL_ALLOC_N(ndr, r->pwd_history, ndr_get_array_size(ndr, &r->pwd_history));
4876                         _mem_save_pwd_history_1 = NDR_PULL_GET_MEM_CTX(ndr);
4877                         NDR_PULL_SET_MEM_CTX(ndr, r->pwd_history, 0);
4878                         for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {
4879                                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->pwd_history[cntr_pwd_history_1]));
4880                         }
4881                         for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {
4882                                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->pwd_history[cntr_pwd_history_1]));
4883                         }
4884                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pwd_history_1, 0);
4885                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pwd_history_0, 0);
4886                 }
4887                 if (r->pwd_history) {
4888                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->pwd_history, r->pwd_history_len));
4889                 }
4890         }
4891         return NDR_ERR_SUCCESS;
4892 }
4893
4894 _PUBLIC_ void ndr_print_samr_ValidatePasswordInfo(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordInfo *r)
4895 {
4896         uint32_t cntr_pwd_history_1;
4897         ndr_print_struct(ndr, name, "samr_ValidatePasswordInfo");
4898         ndr->depth++;
4899         ndr_print_samr_ValidateFieldsPresent(ndr, "fields_present", r->fields_present);
4900         ndr_print_NTTIME_hyper(ndr, "last_password_change", r->last_password_change);
4901         ndr_print_NTTIME_hyper(ndr, "bad_password_time", r->bad_password_time);
4902         ndr_print_NTTIME_hyper(ndr, "lockout_time", r->lockout_time);
4903         ndr_print_uint32(ndr, "bad_pwd_count", r->bad_pwd_count);
4904         ndr_print_uint32(ndr, "pwd_history_len", r->pwd_history_len);
4905         ndr_print_ptr(ndr, "pwd_history", r->pwd_history);
4906         ndr->depth++;
4907         if (r->pwd_history) {
4908                 ndr->print(ndr, "%s: ARRAY(%d)", "pwd_history", (int)r->pwd_history_len);
4909                 ndr->depth++;
4910                 for (cntr_pwd_history_1=0;cntr_pwd_history_1<r->pwd_history_len;cntr_pwd_history_1++) {
4911                         char *idx_1=NULL;
4912                         if (asprintf(&idx_1, "[%d]", cntr_pwd_history_1) != -1) {
4913                                 ndr_print_samr_ValidationBlob(ndr, "pwd_history", &r->pwd_history[cntr_pwd_history_1]);
4914                                 free(idx_1);
4915                         }
4916                 }
4917                 ndr->depth--;
4918         }
4919         ndr->depth--;
4920         ndr->depth--;
4921 }
4922
4923 static enum ndr_err_code ndr_push_samr_ValidatePasswordRepCtr(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordRepCtr *r)
4924 {
4925         if (ndr_flags & NDR_SCALARS) {
4926                 NDR_CHECK(ndr_push_align(ndr, 8));
4927                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
4928                 NDR_CHECK(ndr_push_samr_ValidationStatus(ndr, NDR_SCALARS, r->status));
4929         }
4930         if (ndr_flags & NDR_BUFFERS) {
4931                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
4932         }
4933         return NDR_ERR_SUCCESS;
4934 }
4935
4936 static enum ndr_err_code ndr_pull_samr_ValidatePasswordRepCtr(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordRepCtr *r)
4937 {
4938         if (ndr_flags & NDR_SCALARS) {
4939                 NDR_CHECK(ndr_pull_align(ndr, 8));
4940                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
4941                 NDR_CHECK(ndr_pull_samr_ValidationStatus(ndr, NDR_SCALARS, &r->status));
4942         }
4943         if (ndr_flags & NDR_BUFFERS) {
4944                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
4945         }
4946         return NDR_ERR_SUCCESS;
4947 }
4948
4949 _PUBLIC_ void ndr_print_samr_ValidatePasswordRepCtr(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordRepCtr *r)
4950 {
4951         ndr_print_struct(ndr, name, "samr_ValidatePasswordRepCtr");
4952         ndr->depth++;
4953         ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
4954         ndr_print_samr_ValidationStatus(ndr, "status", r->status);
4955         ndr->depth--;
4956 }
4957
4958 static enum ndr_err_code ndr_push_samr_ValidatePasswordRep(struct ndr_push *ndr, int ndr_flags, const union samr_ValidatePasswordRep *r)
4959 {
4960         if (ndr_flags & NDR_SCALARS) {
4961                 int level = ndr_push_get_switch_value(ndr, r);
4962                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
4963                 switch (level) {
4964                         case 1: {
4965                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr1));
4966                         break; }
4967
4968                         case 2: {
4969                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr2));
4970                         break; }
4971
4972                         case 3: {
4973                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr3));
4974                         break; }
4975
4976                         default:
4977                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4978                 }
4979         }
4980         if (ndr_flags & NDR_BUFFERS) {
4981                 int level = ndr_push_get_switch_value(ndr, r);
4982                 switch (level) {
4983                         case 1:
4984                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr1));
4985                         break;
4986
4987                         case 2:
4988                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr2));
4989                         break;
4990
4991                         case 3:
4992                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr3));
4993                         break;
4994
4995                         default:
4996                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4997                 }
4998         }
4999         return NDR_ERR_SUCCESS;
5000 }
5001
5002 static enum ndr_err_code ndr_pull_samr_ValidatePasswordRep(struct ndr_pull *ndr, int ndr_flags, union samr_ValidatePasswordRep *r)
5003 {
5004         int level;
5005         uint16_t _level;
5006         level = ndr_pull_get_switch_value(ndr, r);
5007         if (ndr_flags & NDR_SCALARS) {
5008                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
5009                 if (_level != level) {
5010                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5011                 }
5012                 switch (level) {
5013                         case 1: {
5014                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr1));
5015                         break; }
5016
5017                         case 2: {
5018                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr2));
5019                         break; }
5020
5021                         case 3: {
5022                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr3));
5023                         break; }
5024
5025                         default:
5026                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5027                 }
5028         }
5029         if (ndr_flags & NDR_BUFFERS) {
5030                 switch (level) {
5031                         case 1:
5032                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr1));
5033                         break;
5034
5035                         case 2:
5036                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr2));
5037                         break;
5038
5039                         case 3:
5040                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr3));
5041                         break;
5042
5043                         default:
5044                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5045                 }
5046         }
5047         return NDR_ERR_SUCCESS;
5048 }
5049
5050 _PUBLIC_ void ndr_print_samr_ValidatePasswordRep(struct ndr_print *ndr, const char *name, const union samr_ValidatePasswordRep *r)
5051 {
5052         int level;
5053         level = ndr_print_get_switch_value(ndr, r);
5054         ndr_print_union(ndr, name, level, "samr_ValidatePasswordRep");
5055         switch (level) {
5056                 case 1:
5057                         ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr1", &r->ctr1);
5058                 break;
5059
5060                 case 2:
5061                         ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr2", &r->ctr2);
5062                 break;
5063
5064                 case 3:
5065                         ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr3", &r->ctr3);
5066                 break;
5067
5068                 default:
5069                         ndr_print_bad_level(ndr, name, level);
5070         }
5071 }
5072
5073 static enum ndr_err_code ndr_push_samr_ValidatePasswordReq3(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq3 *r)
5074 {
5075         if (ndr_flags & NDR_SCALARS) {
5076                 NDR_CHECK(ndr_push_align(ndr, 8));
5077                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5078                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
5079                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
5080                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
5081                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->pwd_must_change_at_next_logon));
5082                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->clear_lockout));
5083         }
5084         if (ndr_flags & NDR_BUFFERS) {
5085                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5086                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
5087                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
5088                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
5089         }
5090         return NDR_ERR_SUCCESS;
5091 }
5092
5093 static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq3(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq3 *r)
5094 {
5095         if (ndr_flags & NDR_SCALARS) {
5096                 NDR_CHECK(ndr_pull_align(ndr, 8));
5097                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5098                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
5099                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
5100                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
5101                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->pwd_must_change_at_next_logon));
5102                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->clear_lockout));
5103         }
5104         if (ndr_flags & NDR_BUFFERS) {
5105                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5106                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
5107                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
5108                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
5109         }
5110         return NDR_ERR_SUCCESS;
5111 }
5112
5113 _PUBLIC_ void ndr_print_samr_ValidatePasswordReq3(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq3 *r)
5114 {
5115         ndr_print_struct(ndr, name, "samr_ValidatePasswordReq3");
5116         ndr->depth++;
5117         ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
5118         ndr_print_lsa_StringLarge(ndr, "password", &r->password);
5119         ndr_print_lsa_StringLarge(ndr, "account", &r->account);
5120         ndr_print_samr_ValidationBlob(ndr, "hash", &r->hash);
5121         ndr_print_uint8(ndr, "pwd_must_change_at_next_logon", r->pwd_must_change_at_next_logon);
5122         ndr_print_uint8(ndr, "clear_lockout", r->clear_lockout);
5123         ndr->depth--;
5124 }
5125
5126 static enum ndr_err_code ndr_push_samr_ValidatePasswordReq2(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq2 *r)
5127 {
5128         if (ndr_flags & NDR_SCALARS) {
5129                 NDR_CHECK(ndr_push_align(ndr, 8));
5130                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5131                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
5132                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
5133                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
5134                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_matched));
5135         }
5136         if (ndr_flags & NDR_BUFFERS) {
5137                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5138                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
5139                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
5140                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
5141         }
5142         return NDR_ERR_SUCCESS;
5143 }
5144
5145 static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq2(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq2 *r)
5146 {
5147         if (ndr_flags & NDR_SCALARS) {
5148                 NDR_CHECK(ndr_pull_align(ndr, 8));
5149                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5150                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
5151                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
5152                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
5153                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_matched));
5154         }
5155         if (ndr_flags & NDR_BUFFERS) {
5156                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5157                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
5158                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
5159                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
5160         }
5161         return NDR_ERR_SUCCESS;
5162 }
5163
5164 _PUBLIC_ void ndr_print_samr_ValidatePasswordReq2(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq2 *r)
5165 {
5166         ndr_print_struct(ndr, name, "samr_ValidatePasswordReq2");
5167         ndr->depth++;
5168         ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
5169         ndr_print_lsa_StringLarge(ndr, "password", &r->password);
5170         ndr_print_lsa_StringLarge(ndr, "account", &r->account);
5171         ndr_print_samr_ValidationBlob(ndr, "hash", &r->hash);
5172         ndr_print_uint8(ndr, "password_matched", r->password_matched);
5173         ndr->depth--;
5174 }
5175
5176 static enum ndr_err_code ndr_push_samr_ValidatePasswordReq1(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq1 *r)
5177 {
5178         if (ndr_flags & NDR_SCALARS) {
5179                 NDR_CHECK(ndr_push_align(ndr, 8));
5180                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5181                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_matched));
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_ValidatePasswordReq1(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq1 *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_uint8(ndr, NDR_SCALARS, &r->password_matched));
5195         }
5196         if (ndr_flags & NDR_BUFFERS) {
5197                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5198         }
5199         return NDR_ERR_SUCCESS;
5200 }
5201
5202 _PUBLIC_ void ndr_print_samr_ValidatePasswordReq1(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq1 *r)
5203 {
5204         ndr_print_struct(ndr, name, "samr_ValidatePasswordReq1");
5205         ndr->depth++;
5206         ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
5207         ndr_print_uint8(ndr, "password_matched", r->password_matched);
5208         ndr->depth--;
5209 }
5210
5211 static enum ndr_err_code ndr_push_samr_ValidatePasswordReq(struct ndr_push *ndr, int ndr_flags, const union samr_ValidatePasswordReq *r)
5212 {
5213         if (ndr_flags & NDR_SCALARS) {
5214                 int level = ndr_push_get_switch_value(ndr, r);
5215                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
5216                 switch (level) {
5217                         case 1: {
5218                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq1(ndr, NDR_SCALARS, &r->req1));
5219                         break; }
5220
5221                         case 2: {
5222                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq2(ndr, NDR_SCALARS, &r->req2));
5223                         break; }
5224
5225                         case 3: {
5226                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq3(ndr, NDR_SCALARS, &r->req3));
5227                         break; }
5228
5229                         default:
5230                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5231                 }
5232         }
5233         if (ndr_flags & NDR_BUFFERS) {
5234                 int level = ndr_push_get_switch_value(ndr, r);
5235                 switch (level) {
5236                         case 1:
5237                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq1(ndr, NDR_BUFFERS, &r->req1));
5238                         break;
5239
5240                         case 2:
5241                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq2(ndr, NDR_BUFFERS, &r->req2));
5242                         break;
5243
5244                         case 3:
5245                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq3(ndr, NDR_BUFFERS, &r->req3));
5246                         break;
5247
5248                         default:
5249                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5250                 }
5251         }
5252         return NDR_ERR_SUCCESS;
5253 }
5254
5255 static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq(struct ndr_pull *ndr, int ndr_flags, union samr_ValidatePasswordReq *r)
5256 {
5257         int level;
5258         uint16_t _level;
5259         level = ndr_pull_get_switch_value(ndr, r);
5260         if (ndr_flags & NDR_SCALARS) {
5261                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
5262                 if (_level != level) {
5263                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5264                 }
5265                 switch (level) {
5266                         case 1: {
5267                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq1(ndr, NDR_SCALARS, &r->req1));
5268                         break; }
5269
5270                         case 2: {
5271                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq2(ndr, NDR_SCALARS, &r->req2));
5272                         break; }
5273
5274                         case 3: {
5275                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq3(ndr, NDR_SCALARS, &r->req3));
5276                         break; }
5277
5278                         default:
5279                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5280                 }
5281         }
5282         if (ndr_flags & NDR_BUFFERS) {
5283                 switch (level) {
5284                         case 1:
5285                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq1(ndr, NDR_BUFFERS, &r->req1));
5286                         break;
5287
5288                         case 2:
5289                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq2(ndr, NDR_BUFFERS, &r->req2));
5290                         break;
5291
5292                         case 3:
5293                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq3(ndr, NDR_BUFFERS, &r->req3));
5294                         break;
5295
5296                         default:
5297                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5298                 }
5299         }
5300         return NDR_ERR_SUCCESS;
5301 }
5302
5303 _PUBLIC_ void ndr_print_samr_ValidatePasswordReq(struct ndr_print *ndr, const char *name, const union samr_ValidatePasswordReq *r)
5304 {
5305         int level;
5306         level = ndr_print_get_switch_value(ndr, r);
5307         ndr_print_union(ndr, name, level, "samr_ValidatePasswordReq");
5308         switch (level) {
5309                 case 1:
5310                         ndr_print_samr_ValidatePasswordReq1(ndr, "req1", &r->req1);
5311                 break;
5312
5313                 case 2:
5314                         ndr_print_samr_ValidatePasswordReq2(ndr, "req2", &r->req2);
5315                 break;
5316
5317                 case 3:
5318                         ndr_print_samr_ValidatePasswordReq3(ndr, "req3", &r->req3);
5319                 break;
5320
5321                 default:
5322                         ndr_print_bad_level(ndr, name, level);
5323         }
5324 }
5325
5326 static enum ndr_err_code ndr_push_samr_Connect(struct ndr_push *ndr, int flags, const struct samr_Connect *r)
5327 {
5328         if (flags & NDR_IN) {
5329                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
5330                 if (r->in.system_name) {
5331                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
5332                 }
5333                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
5334         }
5335         if (flags & NDR_OUT) {
5336                 if (r->out.connect_handle == NULL) {
5337                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5338                 }
5339                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
5340                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5341         }
5342         return NDR_ERR_SUCCESS;
5343 }
5344
5345 static enum ndr_err_code ndr_pull_samr_Connect(struct ndr_pull *ndr, int flags, struct samr_Connect *r)
5346 {
5347         uint32_t _ptr_system_name;
5348         TALLOC_CTX *_mem_save_system_name_0;
5349         TALLOC_CTX *_mem_save_connect_handle_0;
5350         if (flags & NDR_IN) {
5351                 ZERO_STRUCT(r->out);
5352
5353                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
5354                 if (_ptr_system_name) {
5355                         NDR_PULL_ALLOC(ndr, r->in.system_name);
5356                 } else {
5357                         r->in.system_name = NULL;
5358                 }
5359                 if (r->in.system_name) {
5360                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5361                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
5362                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
5363                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
5364                 }
5365                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
5366                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
5367                 ZERO_STRUCTP(r->out.connect_handle);
5368         }
5369         if (flags & NDR_OUT) {
5370                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5371                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
5372                 }
5373                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5374                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
5375                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
5376                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
5377                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5378         }
5379         return NDR_ERR_SUCCESS;
5380 }
5381
5382 _PUBLIC_ void ndr_print_samr_Connect(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect *r)
5383 {
5384         ndr_print_struct(ndr, name, "samr_Connect");
5385         ndr->depth++;
5386         if (flags & NDR_SET_VALUES) {
5387                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5388         }
5389         if (flags & NDR_IN) {
5390                 ndr_print_struct(ndr, "in", "samr_Connect");
5391                 ndr->depth++;
5392                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
5393                 ndr->depth++;
5394                 if (r->in.system_name) {
5395                         ndr_print_uint16(ndr, "system_name", *r->in.system_name);
5396                 }
5397                 ndr->depth--;
5398                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
5399                 ndr->depth--;
5400         }
5401         if (flags & NDR_OUT) {
5402                 ndr_print_struct(ndr, "out", "samr_Connect");
5403                 ndr->depth++;
5404                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
5405                 ndr->depth++;
5406                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
5407                 ndr->depth--;
5408                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5409                 ndr->depth--;
5410         }
5411         ndr->depth--;
5412 }
5413
5414 _PUBLIC_ enum ndr_err_code ndr_push_samr_Close(struct ndr_push *ndr, int flags, const struct samr_Close *r)
5415 {
5416         if (flags & NDR_IN) {
5417                 if (r->in.handle == NULL) {
5418                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5419                 }
5420                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5421         }
5422         if (flags & NDR_OUT) {
5423                 if (r->out.handle == NULL) {
5424                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5425                 }
5426                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
5427                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5428         }
5429         return NDR_ERR_SUCCESS;
5430 }
5431
5432 _PUBLIC_ enum ndr_err_code ndr_pull_samr_Close(struct ndr_pull *ndr, int flags, struct samr_Close *r)
5433 {
5434         TALLOC_CTX *_mem_save_handle_0;
5435         if (flags & NDR_IN) {
5436                 ZERO_STRUCT(r->out);
5437
5438                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5439                         NDR_PULL_ALLOC(ndr, r->in.handle);
5440                 }
5441                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5442                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5443                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5444                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5445                 NDR_PULL_ALLOC(ndr, r->out.handle);
5446                 *r->out.handle = *r->in.handle;
5447         }
5448         if (flags & NDR_OUT) {
5449                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5450                         NDR_PULL_ALLOC(ndr, r->out.handle);
5451                 }
5452                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5453                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
5454                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
5455                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5456                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5457         }
5458         return NDR_ERR_SUCCESS;
5459 }
5460
5461 _PUBLIC_ void ndr_print_samr_Close(struct ndr_print *ndr, const char *name, int flags, const struct samr_Close *r)
5462 {
5463         ndr_print_struct(ndr, name, "samr_Close");
5464         ndr->depth++;
5465         if (flags & NDR_SET_VALUES) {
5466                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5467         }
5468         if (flags & NDR_IN) {
5469                 ndr_print_struct(ndr, "in", "samr_Close");
5470                 ndr->depth++;
5471                 ndr_print_ptr(ndr, "handle", r->in.handle);
5472                 ndr->depth++;
5473                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5474                 ndr->depth--;
5475                 ndr->depth--;
5476         }
5477         if (flags & NDR_OUT) {
5478                 ndr_print_struct(ndr, "out", "samr_Close");
5479                 ndr->depth++;
5480                 ndr_print_ptr(ndr, "handle", r->out.handle);
5481                 ndr->depth++;
5482                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
5483                 ndr->depth--;
5484                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5485                 ndr->depth--;
5486         }
5487         ndr->depth--;
5488 }
5489
5490 static enum ndr_err_code ndr_push_samr_SetSecurity(struct ndr_push *ndr, int flags, const struct samr_SetSecurity *r)
5491 {
5492         if (flags & NDR_IN) {
5493                 if (r->in.handle == NULL) {
5494                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5495                 }
5496                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5497                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
5498                 if (r->in.sdbuf == NULL) {
5499                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5500                 }
5501                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sdbuf));
5502         }
5503         if (flags & NDR_OUT) {
5504                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5505         }
5506         return NDR_ERR_SUCCESS;
5507 }
5508
5509 static enum ndr_err_code ndr_pull_samr_SetSecurity(struct ndr_pull *ndr, int flags, struct samr_SetSecurity *r)
5510 {
5511         TALLOC_CTX *_mem_save_handle_0;
5512         TALLOC_CTX *_mem_save_sdbuf_0;
5513         if (flags & NDR_IN) {
5514                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5515                         NDR_PULL_ALLOC(ndr, r->in.handle);
5516                 }
5517                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5518                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5519                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5520                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5521                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
5522                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5523                         NDR_PULL_ALLOC(ndr, r->in.sdbuf);
5524                 }
5525                 _mem_save_sdbuf_0 = NDR_PULL_GET_MEM_CTX(ndr);
5526                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sdbuf, LIBNDR_FLAG_REF_ALLOC);
5527                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sdbuf));
5528                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_0, LIBNDR_FLAG_REF_ALLOC);
5529         }
5530         if (flags & NDR_OUT) {
5531                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5532         }
5533         return NDR_ERR_SUCCESS;
5534 }
5535
5536 _PUBLIC_ void ndr_print_samr_SetSecurity(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetSecurity *r)
5537 {
5538         ndr_print_struct(ndr, name, "samr_SetSecurity");
5539         ndr->depth++;
5540         if (flags & NDR_SET_VALUES) {
5541                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5542         }
5543         if (flags & NDR_IN) {
5544                 ndr_print_struct(ndr, "in", "samr_SetSecurity");
5545                 ndr->depth++;
5546                 ndr_print_ptr(ndr, "handle", r->in.handle);
5547                 ndr->depth++;
5548                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5549                 ndr->depth--;
5550                 ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
5551                 ndr_print_ptr(ndr, "sdbuf", r->in.sdbuf);
5552                 ndr->depth++;
5553                 ndr_print_sec_desc_buf(ndr, "sdbuf", r->in.sdbuf);
5554                 ndr->depth--;
5555                 ndr->depth--;
5556         }
5557         if (flags & NDR_OUT) {
5558                 ndr_print_struct(ndr, "out", "samr_SetSecurity");
5559                 ndr->depth++;
5560                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5561                 ndr->depth--;
5562         }
5563         ndr->depth--;
5564 }
5565
5566 static enum ndr_err_code ndr_push_samr_QuerySecurity(struct ndr_push *ndr, int flags, const struct samr_QuerySecurity *r)
5567 {
5568         if (flags & NDR_IN) {
5569                 if (r->in.handle == NULL) {
5570                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5571                 }
5572                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5573                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
5574         }
5575         if (flags & NDR_OUT) {
5576                 if (r->out.sdbuf == NULL) {
5577                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5578                 }
5579                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sdbuf));
5580                 if (*r->out.sdbuf) {
5581                         NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sdbuf));
5582                 }
5583                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5584         }
5585         return NDR_ERR_SUCCESS;
5586 }
5587
5588 static enum ndr_err_code ndr_pull_samr_QuerySecurity(struct ndr_pull *ndr, int flags, struct samr_QuerySecurity *r)
5589 {
5590         uint32_t _ptr_sdbuf;
5591         TALLOC_CTX *_mem_save_handle_0;
5592         TALLOC_CTX *_mem_save_sdbuf_0;
5593         TALLOC_CTX *_mem_save_sdbuf_1;
5594         if (flags & NDR_IN) {
5595                 ZERO_STRUCT(r->out);
5596
5597                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5598                         NDR_PULL_ALLOC(ndr, r->in.handle);
5599                 }
5600                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5601                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5602                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5603                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5604                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
5605                 NDR_PULL_ALLOC(ndr, r->out.sdbuf);
5606                 ZERO_STRUCTP(r->out.sdbuf);
5607         }
5608         if (flags & NDR_OUT) {
5609                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5610                         NDR_PULL_ALLOC(ndr, r->out.sdbuf);
5611                 }
5612                 _mem_save_sdbuf_0 = NDR_PULL_GET_MEM_CTX(ndr);
5613                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sdbuf, LIBNDR_FLAG_REF_ALLOC);
5614                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sdbuf));
5615                 if (_ptr_sdbuf) {
5616                         NDR_PULL_ALLOC(ndr, *r->out.sdbuf);
5617                 } else {
5618                         *r->out.sdbuf = NULL;
5619                 }
5620                 if (*r->out.sdbuf) {
5621                         _mem_save_sdbuf_1 = NDR_PULL_GET_MEM_CTX(ndr);
5622                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sdbuf, 0);
5623                         NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sdbuf));
5624                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_1, 0);
5625                 }
5626                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_0, LIBNDR_FLAG_REF_ALLOC);
5627                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5628         }
5629         return NDR_ERR_SUCCESS;
5630 }
5631
5632 _PUBLIC_ void ndr_print_samr_QuerySecurity(struct ndr_print *ndr, const char *name, int flags, const struct samr_QuerySecurity *r)
5633 {
5634         ndr_print_struct(ndr, name, "samr_QuerySecurity");
5635         ndr->depth++;
5636         if (flags & NDR_SET_VALUES) {
5637                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5638         }
5639         if (flags & NDR_IN) {
5640                 ndr_print_struct(ndr, "in", "samr_QuerySecurity");
5641                 ndr->depth++;
5642                 ndr_print_ptr(ndr, "handle", r->in.handle);
5643                 ndr->depth++;
5644                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5645                 ndr->depth--;
5646                 ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
5647                 ndr->depth--;
5648         }
5649         if (flags & NDR_OUT) {
5650                 ndr_print_struct(ndr, "out", "samr_QuerySecurity");
5651                 ndr->depth++;
5652                 ndr_print_ptr(ndr, "sdbuf", r->out.sdbuf);
5653                 ndr->depth++;
5654                 ndr_print_ptr(ndr, "sdbuf", *r->out.sdbuf);
5655                 ndr->depth++;
5656                 if (*r->out.sdbuf) {
5657                         ndr_print_sec_desc_buf(ndr, "sdbuf", *r->out.sdbuf);
5658                 }
5659                 ndr->depth--;
5660                 ndr->depth--;
5661                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5662                 ndr->depth--;
5663         }
5664         ndr->depth--;
5665 }
5666
5667 static enum ndr_err_code ndr_push_samr_Shutdown(struct ndr_push *ndr, int flags, const struct samr_Shutdown *r)
5668 {
5669         if (flags & NDR_IN) {
5670                 if (r->in.connect_handle == NULL) {
5671                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5672                 }
5673                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5674         }
5675         if (flags & NDR_OUT) {
5676                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5677         }
5678         return NDR_ERR_SUCCESS;
5679 }
5680
5681 static enum ndr_err_code ndr_pull_samr_Shutdown(struct ndr_pull *ndr, int flags, struct samr_Shutdown *r)
5682 {
5683         TALLOC_CTX *_mem_save_connect_handle_0;
5684         if (flags & NDR_IN) {
5685                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5686                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
5687                 }
5688                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5689                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
5690                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5691                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
5692         }
5693         if (flags & NDR_OUT) {
5694                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5695         }
5696         return NDR_ERR_SUCCESS;
5697 }
5698
5699 _PUBLIC_ void ndr_print_samr_Shutdown(struct ndr_print *ndr, const char *name, int flags, const struct samr_Shutdown *r)
5700 {
5701         ndr_print_struct(ndr, name, "samr_Shutdown");
5702         ndr->depth++;
5703         if (flags & NDR_SET_VALUES) {
5704                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5705         }
5706         if (flags & NDR_IN) {
5707                 ndr_print_struct(ndr, "in", "samr_Shutdown");
5708                 ndr->depth++;
5709                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
5710                 ndr->depth++;
5711                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
5712                 ndr->depth--;
5713                 ndr->depth--;
5714         }
5715         if (flags & NDR_OUT) {
5716                 ndr_print_struct(ndr, "out", "samr_Shutdown");
5717                 ndr->depth++;
5718                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5719                 ndr->depth--;
5720         }
5721         ndr->depth--;
5722 }
5723
5724 static enum ndr_err_code ndr_push_samr_LookupDomain(struct ndr_push *ndr, int flags, const struct samr_LookupDomain *r)
5725 {
5726         if (flags & NDR_IN) {
5727                 if (r->in.connect_handle == NULL) {
5728                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5729                 }
5730                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5731                 if (r->in.domain_name == NULL) {
5732                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5733                 }
5734                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
5735         }
5736         if (flags & NDR_OUT) {
5737                 if (r->out.sid == NULL) {
5738                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5739                 }
5740                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sid));
5741                 if (*r->out.sid) {
5742                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
5743                 }
5744                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5745         }
5746         return NDR_ERR_SUCCESS;
5747 }
5748
5749 static enum ndr_err_code ndr_pull_samr_LookupDomain(struct ndr_pull *ndr, int flags, struct samr_LookupDomain *r)
5750 {
5751         uint32_t _ptr_sid;
5752         TALLOC_CTX *_mem_save_connect_handle_0;
5753         TALLOC_CTX *_mem_save_domain_name_0;
5754         TALLOC_CTX *_mem_save_sid_0;
5755         TALLOC_CTX *_mem_save_sid_1;
5756         if (flags & NDR_IN) {
5757                 ZERO_STRUCT(r->out);
5758
5759                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5760                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
5761                 }
5762                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5763                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
5764                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5765                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
5766                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5767                         NDR_PULL_ALLOC(ndr, r->in.domain_name);
5768                 }
5769                 _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5770                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_name, LIBNDR_FLAG_REF_ALLOC);
5771                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
5772                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, LIBNDR_FLAG_REF_ALLOC);
5773                 NDR_PULL_ALLOC(ndr, r->out.sid);
5774                 ZERO_STRUCTP(r->out.sid);
5775         }
5776         if (flags & NDR_OUT) {
5777                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5778                         NDR_PULL_ALLOC(ndr, r->out.sid);
5779                 }
5780                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
5781                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);
5782                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
5783                 if (_ptr_sid) {
5784                         NDR_PULL_ALLOC(ndr, *r->out.sid);
5785                 } else {
5786                         *r->out.sid = NULL;
5787                 }
5788                 if (*r->out.sid) {
5789                         _mem_save_sid_1 = NDR_PULL_GET_MEM_CTX(ndr);
5790                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sid, 0);
5791                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
5792                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_1, 0);
5793                 }
5794                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
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_LookupDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupDomain *r)
5801 {
5802         ndr_print_struct(ndr, name, "samr_LookupDomain");
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_LookupDomain");
5809                 ndr->depth++;
5810                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
5811                 ndr->depth++;
5812                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
5813                 ndr->depth--;
5814                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
5815                 ndr->depth++;
5816                 ndr_print_lsa_String(ndr, "domain_name", r->in.domain_name);
5817                 ndr->depth--;
5818                 ndr->depth--;
5819         }
5820         if (flags & NDR_OUT) {
5821                 ndr_print_struct(ndr, "out", "samr_LookupDomain");
5822                 ndr->depth++;
5823                 ndr_print_ptr(ndr, "sid", r->out.sid);
5824                 ndr->depth++;
5825                 ndr_print_ptr(ndr, "sid", *r->out.sid);
5826                 ndr->depth++;
5827                 if (*r->out.sid) {
5828                         ndr_print_dom_sid2(ndr, "sid", *r->out.sid);
5829                 }
5830                 ndr->depth--;
5831                 ndr->depth--;
5832                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5833                 ndr->depth--;
5834         }
5835         ndr->depth--;
5836 }
5837
5838 static enum ndr_err_code ndr_push_samr_EnumDomains(struct ndr_push *ndr, int flags, const struct samr_EnumDomains *r)
5839 {
5840         if (flags & NDR_IN) {
5841                 if (r->in.connect_handle == NULL) {
5842                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5843                 }
5844                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5845                 if (r->in.resume_handle == NULL) {
5846                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5847                 }
5848                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
5849                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
5850         }
5851         if (flags & NDR_OUT) {
5852                 if (r->out.resume_handle == NULL) {
5853                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5854                 }
5855                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
5856                 if (r->out.sam == NULL) {
5857                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5858                 }
5859                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
5860                 if (*r->out.sam) {
5861                         NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
5862                 }
5863                 if (r->out.num_entries == NULL) {
5864                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5865                 }
5866                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
5867                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5868         }
5869         return NDR_ERR_SUCCESS;
5870 }
5871
5872 static enum ndr_err_code ndr_pull_samr_EnumDomains(struct ndr_pull *ndr, int flags, struct samr_EnumDomains *r)
5873 {
5874         uint32_t _ptr_sam;
5875         TALLOC_CTX *_mem_save_connect_handle_0;
5876         TALLOC_CTX *_mem_save_resume_handle_0;
5877         TALLOC_CTX *_mem_save_sam_0;
5878         TALLOC_CTX *_mem_save_sam_1;
5879         TALLOC_CTX *_mem_save_num_entries_0;
5880         if (flags & NDR_IN) {
5881                 ZERO_STRUCT(r->out);
5882
5883                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5884                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
5885                 }
5886                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5887                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
5888                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5889                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
5890                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5891                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
5892                 }
5893                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5894                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
5895                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
5896                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
5897                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
5898                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
5899                 *r->out.resume_handle = *r->in.resume_handle;
5900                 NDR_PULL_ALLOC(ndr, r->out.sam);
5901                 ZERO_STRUCTP(r->out.sam);
5902                 NDR_PULL_ALLOC(ndr, r->out.num_entries);
5903                 ZERO_STRUCTP(r->out.num_entries);
5904         }
5905         if (flags & NDR_OUT) {
5906                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5907                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
5908                 }
5909                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5910                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
5911                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
5912                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
5913                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5914                         NDR_PULL_ALLOC(ndr, r->out.sam);
5915                 }
5916                 _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
5917                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
5918                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
5919                 if (_ptr_sam) {
5920                         NDR_PULL_ALLOC(ndr, *r->out.sam);
5921                 } else {
5922                         *r->out.sam = NULL;
5923                 }
5924                 if (*r->out.sam) {
5925                         _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
5926                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
5927                         NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
5928                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
5929                 }
5930                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
5931                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5932                         NDR_PULL_ALLOC(ndr, r->out.num_entries);
5933                 }
5934                 _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
5935                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
5936                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
5937                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
5938                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5939         }
5940         return NDR_ERR_SUCCESS;
5941 }
5942
5943 _PUBLIC_ void ndr_print_samr_EnumDomains(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomains *r)
5944 {
5945         ndr_print_struct(ndr, name, "samr_EnumDomains");
5946         ndr->depth++;
5947         if (flags & NDR_SET_VALUES) {
5948                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5949         }
5950         if (flags & NDR_IN) {
5951                 ndr_print_struct(ndr, "in", "samr_EnumDomains");
5952                 ndr->depth++;
5953                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
5954                 ndr->depth++;
5955                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
5956                 ndr->depth--;
5957                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
5958                 ndr->depth++;
5959                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
5960                 ndr->depth--;
5961                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
5962                 ndr->depth--;
5963         }
5964         if (flags & NDR_OUT) {
5965                 ndr_print_struct(ndr, "out", "samr_EnumDomains");
5966                 ndr->depth++;
5967                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
5968                 ndr->depth++;
5969                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
5970                 ndr->depth--;
5971                 ndr_print_ptr(ndr, "sam", r->out.sam);
5972                 ndr->depth++;
5973                 ndr_print_ptr(ndr, "sam", *r->out.sam);
5974                 ndr->depth++;
5975                 if (*r->out.sam) {
5976                         ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
5977                 }
5978                 ndr->depth--;
5979                 ndr->depth--;
5980                 ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
5981                 ndr->depth++;
5982                 ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
5983                 ndr->depth--;
5984                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5985                 ndr->depth--;
5986         }
5987         ndr->depth--;
5988 }
5989
5990 _PUBLIC_ enum ndr_err_code ndr_push_samr_OpenDomain(struct ndr_push *ndr, int flags, const struct samr_OpenDomain *r)
5991 {
5992         if (flags & NDR_IN) {
5993                 if (r->in.connect_handle == NULL) {
5994                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5995                 }
5996                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5997                 NDR_CHECK(ndr_push_samr_DomainAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
5998                 if (r->in.sid == NULL) {
5999                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6000                 }
6001                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
6002         }
6003         if (flags & NDR_OUT) {
6004                 if (r->out.domain_handle == NULL) {
6005                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6006                 }
6007                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.domain_handle));
6008                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6009         }
6010         return NDR_ERR_SUCCESS;
6011 }
6012
6013 _PUBLIC_ enum ndr_err_code ndr_pull_samr_OpenDomain(struct ndr_pull *ndr, int flags, struct samr_OpenDomain *r)
6014 {
6015         TALLOC_CTX *_mem_save_connect_handle_0;
6016         TALLOC_CTX *_mem_save_sid_0;
6017         TALLOC_CTX *_mem_save_domain_handle_0;
6018         if (flags & NDR_IN) {
6019                 ZERO_STRUCT(r->out);
6020
6021                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6022                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
6023                 }
6024                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6025                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
6026                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
6027                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
6028                 NDR_CHECK(ndr_pull_samr_DomainAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
6029                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6030                         NDR_PULL_ALLOC(ndr, r->in.sid);
6031                 }
6032                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6033                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
6034                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
6035                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
6036                 NDR_PULL_ALLOC(ndr, r->out.domain_handle);
6037                 ZERO_STRUCTP(r->out.domain_handle);
6038         }
6039         if (flags & NDR_OUT) {
6040                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6041                         NDR_PULL_ALLOC(ndr, r->out.domain_handle);
6042                 }
6043                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6044                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6045                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.domain_handle));
6046                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6047                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6048         }
6049         return NDR_ERR_SUCCESS;
6050 }
6051
6052 _PUBLIC_ void ndr_print_samr_OpenDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenDomain *r)
6053 {
6054         ndr_print_struct(ndr, name, "samr_OpenDomain");
6055         ndr->depth++;
6056         if (flags & NDR_SET_VALUES) {
6057                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6058         }
6059         if (flags & NDR_IN) {
6060                 ndr_print_struct(ndr, "in", "samr_OpenDomain");
6061                 ndr->depth++;
6062                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
6063                 ndr->depth++;
6064                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
6065                 ndr->depth--;
6066                 ndr_print_samr_DomainAccessMask(ndr, "access_mask", r->in.access_mask);
6067                 ndr_print_ptr(ndr, "sid", r->in.sid);
6068                 ndr->depth++;
6069                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
6070                 ndr->depth--;
6071                 ndr->depth--;
6072         }
6073         if (flags & NDR_OUT) {
6074                 ndr_print_struct(ndr, "out", "samr_OpenDomain");
6075                 ndr->depth++;
6076                 ndr_print_ptr(ndr, "domain_handle", r->out.domain_handle);
6077                 ndr->depth++;
6078                 ndr_print_policy_handle(ndr, "domain_handle", r->out.domain_handle);
6079                 ndr->depth--;
6080                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6081                 ndr->depth--;
6082         }
6083         ndr->depth--;
6084 }
6085
6086 static enum ndr_err_code ndr_push_samr_QueryDomainInfo(struct ndr_push *ndr, int flags, const struct samr_QueryDomainInfo *r)
6087 {
6088         if (flags & NDR_IN) {
6089                 if (r->in.domain_handle == NULL) {
6090                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6091                 }
6092                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6093                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
6094         }
6095         if (flags & NDR_OUT) {
6096                 if (r->out.info == NULL) {
6097                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6098                 }
6099                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
6100                 if (*r->out.info) {
6101                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
6102                         NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
6103                 }
6104                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6105         }
6106         return NDR_ERR_SUCCESS;
6107 }
6108
6109 static enum ndr_err_code ndr_pull_samr_QueryDomainInfo(struct ndr_pull *ndr, int flags, struct samr_QueryDomainInfo *r)
6110 {
6111         uint32_t _ptr_info;
6112         TALLOC_CTX *_mem_save_domain_handle_0;
6113         TALLOC_CTX *_mem_save_info_0;
6114         TALLOC_CTX *_mem_save_info_1;
6115         if (flags & NDR_IN) {
6116                 ZERO_STRUCT(r->out);
6117
6118                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6119                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6120                 }
6121                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6122                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6123                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6124                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6125                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
6126                 NDR_PULL_ALLOC(ndr, r->out.info);
6127                 ZERO_STRUCTP(r->out.info);
6128         }
6129         if (flags & NDR_OUT) {
6130                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6131                         NDR_PULL_ALLOC(ndr, r->out.info);
6132                 }
6133                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6134                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
6135                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
6136                 if (_ptr_info) {
6137                         NDR_PULL_ALLOC(ndr, *r->out.info);
6138                 } else {
6139                         *r->out.info = NULL;
6140                 }
6141                 if (*r->out.info) {
6142                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
6143                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
6144                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
6145                         NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
6146                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
6147                 }
6148                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6149                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6150         }
6151         return NDR_ERR_SUCCESS;
6152 }
6153
6154 _PUBLIC_ void ndr_print_samr_QueryDomainInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDomainInfo *r)
6155 {
6156         ndr_print_struct(ndr, name, "samr_QueryDomainInfo");
6157         ndr->depth++;
6158         if (flags & NDR_SET_VALUES) {
6159                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6160         }
6161         if (flags & NDR_IN) {
6162                 ndr_print_struct(ndr, "in", "samr_QueryDomainInfo");
6163                 ndr->depth++;
6164                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6165                 ndr->depth++;
6166                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6167                 ndr->depth--;
6168                 ndr_print_uint16(ndr, "level", r->in.level);
6169                 ndr->depth--;
6170         }
6171         if (flags & NDR_OUT) {
6172                 ndr_print_struct(ndr, "out", "samr_QueryDomainInfo");
6173                 ndr->depth++;
6174                 ndr_print_ptr(ndr, "info", r->out.info);
6175                 ndr->depth++;
6176                 ndr_print_ptr(ndr, "info", *r->out.info);
6177                 ndr->depth++;
6178                 if (*r->out.info) {
6179                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
6180                         ndr_print_samr_DomainInfo(ndr, "info", *r->out.info);
6181                 }
6182                 ndr->depth--;
6183                 ndr->depth--;
6184                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6185                 ndr->depth--;
6186         }
6187         ndr->depth--;
6188 }
6189
6190 static enum ndr_err_code ndr_push_samr_SetDomainInfo(struct ndr_push *ndr, int flags, const struct samr_SetDomainInfo *r)
6191 {
6192         if (flags & NDR_IN) {
6193                 if (r->in.domain_handle == NULL) {
6194                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6195                 }
6196                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6197                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
6198                 if (r->in.info == NULL) {
6199                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6200                 }
6201                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
6202                 NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6203         }
6204         if (flags & NDR_OUT) {
6205                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6206         }
6207         return NDR_ERR_SUCCESS;
6208 }
6209
6210 static enum ndr_err_code ndr_pull_samr_SetDomainInfo(struct ndr_pull *ndr, int flags, struct samr_SetDomainInfo *r)
6211 {
6212         TALLOC_CTX *_mem_save_domain_handle_0;
6213         TALLOC_CTX *_mem_save_info_0;
6214         if (flags & NDR_IN) {
6215                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6216                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6217                 }
6218                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6219                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6220                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6221                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6222                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
6223                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6224                         NDR_PULL_ALLOC(ndr, r->in.info);
6225                 }
6226                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6227                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
6228                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
6229                 NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6230                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6231         }
6232         if (flags & NDR_OUT) {
6233                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6234         }
6235         return NDR_ERR_SUCCESS;
6236 }
6237
6238 _PUBLIC_ void ndr_print_samr_SetDomainInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetDomainInfo *r)
6239 {
6240         ndr_print_struct(ndr, name, "samr_SetDomainInfo");
6241         ndr->depth++;
6242         if (flags & NDR_SET_VALUES) {
6243                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6244         }
6245         if (flags & NDR_IN) {
6246                 ndr_print_struct(ndr, "in", "samr_SetDomainInfo");
6247                 ndr->depth++;
6248                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6249                 ndr->depth++;
6250                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6251                 ndr->depth--;
6252                 ndr_print_uint16(ndr, "level", r->in.level);
6253                 ndr_print_ptr(ndr, "info", r->in.info);
6254                 ndr->depth++;
6255                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
6256                 ndr_print_samr_DomainInfo(ndr, "info", r->in.info);
6257                 ndr->depth--;
6258                 ndr->depth--;
6259         }
6260         if (flags & NDR_OUT) {
6261                 ndr_print_struct(ndr, "out", "samr_SetDomainInfo");
6262                 ndr->depth++;
6263                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6264                 ndr->depth--;
6265         }
6266         ndr->depth--;
6267 }
6268
6269 static enum ndr_err_code ndr_push_samr_CreateDomainGroup(struct ndr_push *ndr, int flags, const struct samr_CreateDomainGroup *r)
6270 {
6271         if (flags & NDR_IN) {
6272                 if (r->in.domain_handle == NULL) {
6273                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6274                 }
6275                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6276                 if (r->in.name == NULL) {
6277                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6278                 }
6279                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
6280                 NDR_CHECK(ndr_push_samr_GroupAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
6281         }
6282         if (flags & NDR_OUT) {
6283                 if (r->out.group_handle == NULL) {
6284                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6285                 }
6286                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
6287                 if (r->out.rid == NULL) {
6288                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6289                 }
6290                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
6291                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6292         }
6293         return NDR_ERR_SUCCESS;
6294 }
6295
6296 static enum ndr_err_code ndr_pull_samr_CreateDomainGroup(struct ndr_pull *ndr, int flags, struct samr_CreateDomainGroup *r)
6297 {
6298         TALLOC_CTX *_mem_save_domain_handle_0;
6299         TALLOC_CTX *_mem_save_name_0;
6300         TALLOC_CTX *_mem_save_group_handle_0;
6301         TALLOC_CTX *_mem_save_rid_0;
6302         if (flags & NDR_IN) {
6303                 ZERO_STRUCT(r->out);
6304
6305                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6306                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6307                 }
6308                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6309                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6310                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6311                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6312                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6313                         NDR_PULL_ALLOC(ndr, r->in.name);
6314                 }
6315                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6316                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
6317                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
6318                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
6319                 NDR_CHECK(ndr_pull_samr_GroupAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
6320                 NDR_PULL_ALLOC(ndr, r->out.group_handle);
6321                 ZERO_STRUCTP(r->out.group_handle);
6322                 NDR_PULL_ALLOC(ndr, r->out.rid);
6323                 ZERO_STRUCTP(r->out.rid);
6324         }
6325         if (flags & NDR_OUT) {
6326                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6327                         NDR_PULL_ALLOC(ndr, r->out.group_handle);
6328                 }
6329                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6330                 NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);
6331                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
6332                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
6333                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6334                         NDR_PULL_ALLOC(ndr, r->out.rid);
6335                 }
6336                 _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6337                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
6338                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
6339                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
6340                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6341         }
6342         return NDR_ERR_SUCCESS;
6343 }
6344
6345 _PUBLIC_ void ndr_print_samr_CreateDomainGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateDomainGroup *r)
6346 {
6347         ndr_print_struct(ndr, name, "samr_CreateDomainGroup");
6348         ndr->depth++;
6349         if (flags & NDR_SET_VALUES) {
6350                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6351         }
6352         if (flags & NDR_IN) {
6353                 ndr_print_struct(ndr, "in", "samr_CreateDomainGroup");
6354                 ndr->depth++;
6355                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6356                 ndr->depth++;
6357                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6358                 ndr->depth--;
6359                 ndr_print_ptr(ndr, "name", r->in.name);
6360                 ndr->depth++;
6361                 ndr_print_lsa_String(ndr, "name", r->in.name);
6362                 ndr->depth--;
6363                 ndr_print_samr_GroupAccessMask(ndr, "access_mask", r->in.access_mask);
6364                 ndr->depth--;
6365         }
6366         if (flags & NDR_OUT) {
6367                 ndr_print_struct(ndr, "out", "samr_CreateDomainGroup");
6368                 ndr->depth++;
6369                 ndr_print_ptr(ndr, "group_handle", r->out.group_handle);
6370                 ndr->depth++;
6371                 ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);
6372                 ndr->depth--;
6373                 ndr_print_ptr(ndr, "rid", r->out.rid);
6374                 ndr->depth++;
6375                 ndr_print_uint32(ndr, "rid", *r->out.rid);
6376                 ndr->depth--;
6377                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6378                 ndr->depth--;
6379         }
6380         ndr->depth--;
6381 }
6382
6383 static enum ndr_err_code ndr_push_samr_EnumDomainGroups(struct ndr_push *ndr, int flags, const struct samr_EnumDomainGroups *r)
6384 {
6385         if (flags & NDR_IN) {
6386                 if (r->in.domain_handle == NULL) {
6387                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6388                 }
6389                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6390                 if (r->in.resume_handle == NULL) {
6391                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6392                 }
6393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6394                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
6395         }
6396         if (flags & NDR_OUT) {
6397                 if (r->out.resume_handle == NULL) {
6398                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6399                 }
6400                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6401                 if (r->out.sam == NULL) {
6402                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6403                 }
6404                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
6405                 if (*r->out.sam) {
6406                         NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6407                 }
6408                 if (r->out.num_entries == NULL) {
6409                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6410                 }
6411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
6412                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6413         }
6414         return NDR_ERR_SUCCESS;
6415 }
6416
6417 static enum ndr_err_code ndr_pull_samr_EnumDomainGroups(struct ndr_pull *ndr, int flags, struct samr_EnumDomainGroups *r)
6418 {
6419         uint32_t _ptr_sam;
6420         TALLOC_CTX *_mem_save_domain_handle_0;
6421         TALLOC_CTX *_mem_save_resume_handle_0;
6422         TALLOC_CTX *_mem_save_sam_0;
6423         TALLOC_CTX *_mem_save_sam_1;
6424         TALLOC_CTX *_mem_save_num_entries_0;
6425         if (flags & NDR_IN) {
6426                 ZERO_STRUCT(r->out);
6427
6428                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6429                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6430                 }
6431                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6432                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6433                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6434                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6435                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6436                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
6437                 }
6438                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6439                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6440                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6441                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6442                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
6443                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6444                 *r->out.resume_handle = *r->in.resume_handle;
6445                 NDR_PULL_ALLOC(ndr, r->out.sam);
6446                 ZERO_STRUCTP(r->out.sam);
6447                 NDR_PULL_ALLOC(ndr, r->out.num_entries);
6448                 ZERO_STRUCTP(r->out.num_entries);
6449         }
6450         if (flags & NDR_OUT) {
6451                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6452                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6453                 }
6454                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6455                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6457                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6458                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6459                         NDR_PULL_ALLOC(ndr, r->out.sam);
6460                 }
6461                 _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
6462                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
6463                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
6464                 if (_ptr_sam) {
6465                         NDR_PULL_ALLOC(ndr, *r->out.sam);
6466                 } else {
6467                         *r->out.sam = NULL;
6468                 }
6469                 if (*r->out.sam) {
6470                         _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
6471                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
6472                         NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6473                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
6474                 }
6475                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
6476                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6477                         NDR_PULL_ALLOC(ndr, r->out.num_entries);
6478                 }
6479                 _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
6480                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
6481                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
6482                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
6483                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6484         }
6485         return NDR_ERR_SUCCESS;
6486 }
6487
6488 _PUBLIC_ void ndr_print_samr_EnumDomainGroups(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainGroups *r)
6489 {
6490         ndr_print_struct(ndr, name, "samr_EnumDomainGroups");
6491         ndr->depth++;
6492         if (flags & NDR_SET_VALUES) {
6493                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6494         }
6495         if (flags & NDR_IN) {
6496                 ndr_print_struct(ndr, "in", "samr_EnumDomainGroups");
6497                 ndr->depth++;
6498                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6499                 ndr->depth++;
6500                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6501                 ndr->depth--;
6502                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6503                 ndr->depth++;
6504                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6505                 ndr->depth--;
6506                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
6507                 ndr->depth--;
6508         }
6509         if (flags & NDR_OUT) {
6510                 ndr_print_struct(ndr, "out", "samr_EnumDomainGroups");
6511                 ndr->depth++;
6512                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6513                 ndr->depth++;
6514                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6515                 ndr->depth--;
6516                 ndr_print_ptr(ndr, "sam", r->out.sam);
6517                 ndr->depth++;
6518                 ndr_print_ptr(ndr, "sam", *r->out.sam);
6519                 ndr->depth++;
6520                 if (*r->out.sam) {
6521                         ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
6522                 }
6523                 ndr->depth--;
6524                 ndr->depth--;
6525                 ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
6526                 ndr->depth++;
6527                 ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
6528                 ndr->depth--;
6529                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6530                 ndr->depth--;
6531         }
6532         ndr->depth--;
6533 }
6534
6535 static enum ndr_err_code ndr_push_samr_CreateUser(struct ndr_push *ndr, int flags, const struct samr_CreateUser *r)
6536 {
6537         if (flags & NDR_IN) {
6538                 if (r->in.domain_handle == NULL) {
6539                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6540                 }
6541                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6542                 if (r->in.account_name == NULL) {
6543                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6544                 }
6545                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
6546                 NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
6547         }
6548         if (flags & NDR_OUT) {
6549                 if (r->out.user_handle == NULL) {
6550                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6551                 }
6552                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
6553                 if (r->out.rid == NULL) {
6554                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6555                 }
6556                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
6557                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6558         }
6559         return NDR_ERR_SUCCESS;
6560 }
6561
6562 static enum ndr_err_code ndr_pull_samr_CreateUser(struct ndr_pull *ndr, int flags, struct samr_CreateUser *r)
6563 {
6564         TALLOC_CTX *_mem_save_domain_handle_0;
6565         TALLOC_CTX *_mem_save_account_name_0;
6566         TALLOC_CTX *_mem_save_user_handle_0;
6567         TALLOC_CTX *_mem_save_rid_0;
6568         if (flags & NDR_IN) {
6569                 ZERO_STRUCT(r->out);
6570
6571                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6572                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6573                 }
6574                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6575                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6576                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6577                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6578                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6579                         NDR_PULL_ALLOC(ndr, r->in.account_name);
6580                 }
6581                 _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6582                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account_name, LIBNDR_FLAG_REF_ALLOC);
6583                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
6584                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, LIBNDR_FLAG_REF_ALLOC);
6585                 NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
6586                 NDR_PULL_ALLOC(ndr, r->out.user_handle);
6587                 ZERO_STRUCTP(r->out.user_handle);
6588                 NDR_PULL_ALLOC(ndr, r->out.rid);
6589                 ZERO_STRUCTP(r->out.rid);
6590         }
6591         if (flags & NDR_OUT) {
6592                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6593                         NDR_PULL_ALLOC(ndr, r->out.user_handle);
6594                 }
6595                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6596                 NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
6597                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
6598                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
6599                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6600                         NDR_PULL_ALLOC(ndr, r->out.rid);
6601                 }
6602                 _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6603                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
6604                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
6605                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
6606                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6607         }
6608         return NDR_ERR_SUCCESS;
6609 }
6610
6611 _PUBLIC_ void ndr_print_samr_CreateUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateUser *r)
6612 {
6613         ndr_print_struct(ndr, name, "samr_CreateUser");
6614         ndr->depth++;
6615         if (flags & NDR_SET_VALUES) {
6616                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6617         }
6618         if (flags & NDR_IN) {
6619                 ndr_print_struct(ndr, "in", "samr_CreateUser");
6620                 ndr->depth++;
6621                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6622                 ndr->depth++;
6623                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6624                 ndr->depth--;
6625                 ndr_print_ptr(ndr, "account_name", r->in.account_name);
6626                 ndr->depth++;
6627                 ndr_print_lsa_String(ndr, "account_name", r->in.account_name);
6628                 ndr->depth--;
6629                 ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);
6630                 ndr->depth--;
6631         }
6632         if (flags & NDR_OUT) {
6633                 ndr_print_struct(ndr, "out", "samr_CreateUser");
6634                 ndr->depth++;
6635                 ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
6636                 ndr->depth++;
6637                 ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
6638                 ndr->depth--;
6639                 ndr_print_ptr(ndr, "rid", r->out.rid);
6640                 ndr->depth++;
6641                 ndr_print_uint32(ndr, "rid", *r->out.rid);
6642                 ndr->depth--;
6643                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6644                 ndr->depth--;
6645         }
6646         ndr->depth--;
6647 }
6648
6649 static enum ndr_err_code ndr_push_samr_EnumDomainUsers(struct ndr_push *ndr, int flags, const struct samr_EnumDomainUsers *r)
6650 {
6651         if (flags & NDR_IN) {
6652                 if (r->in.domain_handle == NULL) {
6653                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6654                 }
6655                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6656                 if (r->in.resume_handle == NULL) {
6657                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6658                 }
6659                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6660                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->in.acct_flags));
6661                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
6662         }
6663         if (flags & NDR_OUT) {
6664                 if (r->out.resume_handle == NULL) {
6665                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6666                 }
6667                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6668                 if (r->out.sam == NULL) {
6669                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6670                 }
6671                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
6672                 if (*r->out.sam) {
6673                         NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6674                 }
6675                 if (r->out.num_entries == NULL) {
6676                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6677                 }
6678                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
6679                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6680         }
6681         return NDR_ERR_SUCCESS;
6682 }
6683
6684 static enum ndr_err_code ndr_pull_samr_EnumDomainUsers(struct ndr_pull *ndr, int flags, struct samr_EnumDomainUsers *r)
6685 {
6686         uint32_t _ptr_sam;
6687         TALLOC_CTX *_mem_save_domain_handle_0;
6688         TALLOC_CTX *_mem_save_resume_handle_0;
6689         TALLOC_CTX *_mem_save_sam_0;
6690         TALLOC_CTX *_mem_save_sam_1;
6691         TALLOC_CTX *_mem_save_num_entries_0;
6692         if (flags & NDR_IN) {
6693                 ZERO_STRUCT(r->out);
6694
6695                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6696                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6697                 }
6698                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6699                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6700                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6701                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6702                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6703                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
6704                 }
6705                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6706                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6707                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6708                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6709                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->in.acct_flags));
6710                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
6711                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6712                 *r->out.resume_handle = *r->in.resume_handle;
6713                 NDR_PULL_ALLOC(ndr, r->out.sam);
6714                 ZERO_STRUCTP(r->out.sam);
6715                 NDR_PULL_ALLOC(ndr, r->out.num_entries);
6716                 ZERO_STRUCTP(r->out.num_entries);
6717         }
6718         if (flags & NDR_OUT) {
6719                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6720                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6721                 }
6722                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6723                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6724                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6725                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6726                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6727                         NDR_PULL_ALLOC(ndr, r->out.sam);
6728                 }
6729                 _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
6730                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
6731                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
6732                 if (_ptr_sam) {
6733                         NDR_PULL_ALLOC(ndr, *r->out.sam);
6734                 } else {
6735                         *r->out.sam = NULL;
6736                 }
6737                 if (*r->out.sam) {
6738                         _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
6739                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
6740                         NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6741                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
6742                 }
6743                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
6744                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6745                         NDR_PULL_ALLOC(ndr, r->out.num_entries);
6746                 }
6747                 _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
6748                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
6749                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
6750                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
6751                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6752         }
6753         return NDR_ERR_SUCCESS;
6754 }
6755
6756 _PUBLIC_ void ndr_print_samr_EnumDomainUsers(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainUsers *r)
6757 {
6758         ndr_print_struct(ndr, name, "samr_EnumDomainUsers");
6759         ndr->depth++;
6760         if (flags & NDR_SET_VALUES) {
6761                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6762         }
6763         if (flags & NDR_IN) {
6764                 ndr_print_struct(ndr, "in", "samr_EnumDomainUsers");
6765                 ndr->depth++;
6766                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6767                 ndr->depth++;
6768                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6769                 ndr->depth--;
6770                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6771                 ndr->depth++;
6772                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6773                 ndr->depth--;
6774                 ndr_print_samr_AcctFlags(ndr, "acct_flags", r->in.acct_flags);
6775                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
6776                 ndr->depth--;
6777         }
6778         if (flags & NDR_OUT) {
6779                 ndr_print_struct(ndr, "out", "samr_EnumDomainUsers");
6780                 ndr->depth++;
6781                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6782                 ndr->depth++;
6783                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6784                 ndr->depth--;
6785                 ndr_print_ptr(ndr, "sam", r->out.sam);
6786                 ndr->depth++;
6787                 ndr_print_ptr(ndr, "sam", *r->out.sam);
6788                 ndr->depth++;
6789                 if (*r->out.sam) {
6790                         ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
6791                 }
6792                 ndr->depth--;
6793                 ndr->depth--;
6794                 ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
6795                 ndr->depth++;
6796                 ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
6797                 ndr->depth--;
6798                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6799                 ndr->depth--;
6800         }
6801         ndr->depth--;
6802 }
6803
6804 static enum ndr_err_code ndr_push_samr_CreateDomAlias(struct ndr_push *ndr, int flags, const struct samr_CreateDomAlias *r)
6805 {
6806         if (flags & NDR_IN) {
6807                 if (r->in.domain_handle == NULL) {
6808                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6809                 }
6810                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6811                 if (r->in.alias_name == NULL) {
6812                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6813                 }
6814                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.alias_name));
6815                 NDR_CHECK(ndr_push_samr_AliasAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
6816         }
6817         if (flags & NDR_OUT) {
6818                 if (r->out.alias_handle == NULL) {
6819                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6820                 }
6821                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
6822                 if (r->out.rid == NULL) {
6823                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6824                 }
6825                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
6826                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6827         }
6828         return NDR_ERR_SUCCESS;
6829 }
6830
6831 static enum ndr_err_code ndr_pull_samr_CreateDomAlias(struct ndr_pull *ndr, int flags, struct samr_CreateDomAlias *r)
6832 {
6833         TALLOC_CTX *_mem_save_domain_handle_0;
6834         TALLOC_CTX *_mem_save_alias_name_0;
6835         TALLOC_CTX *_mem_save_alias_handle_0;
6836         TALLOC_CTX *_mem_save_rid_0;
6837         if (flags & NDR_IN) {
6838                 ZERO_STRUCT(r->out);
6839
6840                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6841                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6842                 }
6843                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6844                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6845                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6846                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6847                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6848                         NDR_PULL_ALLOC(ndr, r->in.alias_name);
6849                 }
6850                 _mem_save_alias_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6851                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_name, LIBNDR_FLAG_REF_ALLOC);
6852                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.alias_name));
6853                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_name_0, LIBNDR_FLAG_REF_ALLOC);
6854                 NDR_CHECK(ndr_pull_samr_AliasAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
6855                 NDR_PULL_ALLOC(ndr, r->out.alias_handle);
6856                 ZERO_STRUCTP(r->out.alias_handle);
6857                 NDR_PULL_ALLOC(ndr, r->out.rid);
6858                 ZERO_STRUCTP(r->out.rid);
6859         }
6860         if (flags & NDR_OUT) {
6861                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6862                         NDR_PULL_ALLOC(ndr, r->out.alias_handle);
6863                 }
6864                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6865                 NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);
6866                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
6867                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
6868                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6869                         NDR_PULL_ALLOC(ndr, r->out.rid);
6870                 }
6871                 _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6872                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
6873                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
6874                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
6875                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6876         }
6877         return NDR_ERR_SUCCESS;
6878 }
6879
6880 _PUBLIC_ void ndr_print_samr_CreateDomAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateDomAlias *r)
6881 {
6882         ndr_print_struct(ndr, name, "samr_CreateDomAlias");
6883         ndr->depth++;
6884         if (flags & NDR_SET_VALUES) {
6885                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6886         }
6887         if (flags & NDR_IN) {
6888                 ndr_print_struct(ndr, "in", "samr_CreateDomAlias");
6889                 ndr->depth++;
6890                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6891                 ndr->depth++;
6892                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6893                 ndr->depth--;
6894                 ndr_print_ptr(ndr, "alias_name", r->in.alias_name);
6895                 ndr->depth++;
6896                 ndr_print_lsa_String(ndr, "alias_name", r->in.alias_name);
6897                 ndr->depth--;
6898                 ndr_print_samr_AliasAccessMask(ndr, "access_mask", r->in.access_mask);
6899                 ndr->depth--;
6900         }
6901         if (flags & NDR_OUT) {
6902                 ndr_print_struct(ndr, "out", "samr_CreateDomAlias");
6903                 ndr->depth++;
6904                 ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);
6905                 ndr->depth++;
6906                 ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);
6907                 ndr->depth--;
6908                 ndr_print_ptr(ndr, "rid", r->out.rid);
6909                 ndr->depth++;
6910                 ndr_print_uint32(ndr, "rid", *r->out.rid);
6911                 ndr->depth--;
6912                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6913                 ndr->depth--;
6914         }
6915         ndr->depth--;
6916 }
6917
6918 static enum ndr_err_code ndr_push_samr_EnumDomainAliases(struct ndr_push *ndr, int flags, const struct samr_EnumDomainAliases *r)
6919 {
6920         if (flags & NDR_IN) {
6921                 if (r->in.domain_handle == NULL) {
6922                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6923                 }
6924                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6925                 if (r->in.resume_handle == NULL) {
6926                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6927                 }
6928                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6929                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
6930         }
6931         if (flags & NDR_OUT) {
6932                 if (r->out.resume_handle == NULL) {
6933                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6934                 }
6935                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6936                 if (r->out.sam == NULL) {
6937                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6938                 }
6939                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
6940                 if (*r->out.sam) {
6941                         NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6942                 }
6943                 if (r->out.num_entries == NULL) {
6944                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6945                 }
6946                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
6947                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6948         }
6949         return NDR_ERR_SUCCESS;
6950 }
6951
6952 static enum ndr_err_code ndr_pull_samr_EnumDomainAliases(struct ndr_pull *ndr, int flags, struct samr_EnumDomainAliases *r)
6953 {
6954         uint32_t _ptr_sam;
6955         TALLOC_CTX *_mem_save_domain_handle_0;
6956         TALLOC_CTX *_mem_save_resume_handle_0;
6957         TALLOC_CTX *_mem_save_sam_0;
6958         TALLOC_CTX *_mem_save_sam_1;
6959         TALLOC_CTX *_mem_save_num_entries_0;
6960         if (flags & NDR_IN) {
6961                 ZERO_STRUCT(r->out);
6962
6963                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6964                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6965                 }
6966                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6967                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6968                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6969                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6970                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6971                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
6972                 }
6973                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6974                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6975                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6976                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6977                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
6978                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6979                 *r->out.resume_handle = *r->in.resume_handle;
6980                 NDR_PULL_ALLOC(ndr, r->out.sam);
6981                 ZERO_STRUCTP(r->out.sam);
6982                 NDR_PULL_ALLOC(ndr, r->out.num_entries);
6983                 ZERO_STRUCTP(r->out.num_entries);
6984         }
6985         if (flags & NDR_OUT) {
6986                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6987                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6988                 }
6989                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6990                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6991                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6992                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6993                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6994                         NDR_PULL_ALLOC(ndr, r->out.sam);
6995                 }
6996                 _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
6997                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
6998                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
6999                 if (_ptr_sam) {
7000                         NDR_PULL_ALLOC(ndr, *r->out.sam);
7001                 } else {
7002                         *r->out.sam = NULL;
7003                 }
7004                 if (*r->out.sam) {
7005                         _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
7006                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
7007                         NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
7008                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
7009                 }
7010                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
7011                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7012                         NDR_PULL_ALLOC(ndr, r->out.num_entries);
7013                 }
7014                 _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
7015                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
7016                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
7017                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
7018                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7019         }
7020         return NDR_ERR_SUCCESS;
7021 }
7022
7023 _PUBLIC_ void ndr_print_samr_EnumDomainAliases(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainAliases *r)
7024 {
7025         ndr_print_struct(ndr, name, "samr_EnumDomainAliases");
7026         ndr->depth++;
7027         if (flags & NDR_SET_VALUES) {
7028                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7029         }
7030         if (flags & NDR_IN) {
7031                 ndr_print_struct(ndr, "in", "samr_EnumDomainAliases");
7032                 ndr->depth++;
7033                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7034                 ndr->depth++;
7035                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7036                 ndr->depth--;
7037                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
7038                 ndr->depth++;
7039                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
7040                 ndr->depth--;
7041                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
7042                 ndr->depth--;
7043         }
7044         if (flags & NDR_OUT) {
7045                 ndr_print_struct(ndr, "out", "samr_EnumDomainAliases");
7046                 ndr->depth++;
7047                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
7048                 ndr->depth++;
7049                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
7050                 ndr->depth--;
7051                 ndr_print_ptr(ndr, "sam", r->out.sam);
7052                 ndr->depth++;
7053                 ndr_print_ptr(ndr, "sam", *r->out.sam);
7054                 ndr->depth++;
7055                 if (*r->out.sam) {
7056                         ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
7057                 }
7058                 ndr->depth--;
7059                 ndr->depth--;
7060                 ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
7061                 ndr->depth++;
7062                 ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
7063                 ndr->depth--;
7064                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7065                 ndr->depth--;
7066         }
7067         ndr->depth--;
7068 }
7069
7070 static enum ndr_err_code ndr_push_samr_GetAliasMembership(struct ndr_push *ndr, int flags, const struct samr_GetAliasMembership *r)
7071 {
7072         if (flags & NDR_IN) {
7073                 if (r->in.domain_handle == NULL) {
7074                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7075                 }
7076                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7077                 if (r->in.sids == NULL) {
7078                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7079                 }
7080                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
7081         }
7082         if (flags & NDR_OUT) {
7083                 if (r->out.rids == NULL) {
7084                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7085                 }
7086                 NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
7087                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7088         }
7089         return NDR_ERR_SUCCESS;
7090 }
7091
7092 static enum ndr_err_code ndr_pull_samr_GetAliasMembership(struct ndr_pull *ndr, int flags, struct samr_GetAliasMembership *r)
7093 {
7094         TALLOC_CTX *_mem_save_domain_handle_0;
7095         TALLOC_CTX *_mem_save_sids_0;
7096         TALLOC_CTX *_mem_save_rids_0;
7097         if (flags & NDR_IN) {
7098                 ZERO_STRUCT(r->out);
7099
7100                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7101                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7102                 }
7103                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7104                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7105                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7106                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7107                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7108                         NDR_PULL_ALLOC(ndr, r->in.sids);
7109                 }
7110                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7111                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
7112                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
7113                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
7114                 NDR_PULL_ALLOC(ndr, r->out.rids);
7115                 ZERO_STRUCTP(r->out.rids);
7116         }
7117         if (flags & NDR_OUT) {
7118                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7119                         NDR_PULL_ALLOC(ndr, r->out.rids);
7120                 }
7121                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7122                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
7123                 NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
7124                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
7125                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7126         }
7127         return NDR_ERR_SUCCESS;
7128 }
7129
7130 _PUBLIC_ void ndr_print_samr_GetAliasMembership(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetAliasMembership *r)
7131 {
7132         ndr_print_struct(ndr, name, "samr_GetAliasMembership");
7133         ndr->depth++;
7134         if (flags & NDR_SET_VALUES) {
7135                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7136         }
7137         if (flags & NDR_IN) {
7138                 ndr_print_struct(ndr, "in", "samr_GetAliasMembership");
7139                 ndr->depth++;
7140                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7141                 ndr->depth++;
7142                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7143                 ndr->depth--;
7144                 ndr_print_ptr(ndr, "sids", r->in.sids);
7145                 ndr->depth++;
7146                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
7147                 ndr->depth--;
7148                 ndr->depth--;
7149         }
7150         if (flags & NDR_OUT) {
7151                 ndr_print_struct(ndr, "out", "samr_GetAliasMembership");
7152                 ndr->depth++;
7153                 ndr_print_ptr(ndr, "rids", r->out.rids);
7154                 ndr->depth++;
7155                 ndr_print_samr_Ids(ndr, "rids", r->out.rids);
7156                 ndr->depth--;
7157                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7158                 ndr->depth--;
7159         }
7160         ndr->depth--;
7161 }
7162
7163 _PUBLIC_ enum ndr_err_code ndr_push_samr_LookupNames(struct ndr_push *ndr, int flags, const struct samr_LookupNames *r)
7164 {
7165         uint32_t cntr_names_0;
7166         if (flags & NDR_IN) {
7167                 if (r->in.domain_handle == NULL) {
7168                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7169                 }
7170                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7171                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
7172                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1000));
7173                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7174                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
7175                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
7176                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
7177                 }
7178                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
7179                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
7180                 }
7181         }
7182         if (flags & NDR_OUT) {
7183                 if (r->out.rids == NULL) {
7184                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7185                 }
7186                 NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
7187                 if (r->out.types == NULL) {
7188                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7189                 }
7190                 NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
7191                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7192         }
7193         return NDR_ERR_SUCCESS;
7194 }
7195
7196 _PUBLIC_ enum ndr_err_code ndr_pull_samr_LookupNames(struct ndr_pull *ndr, int flags, struct samr_LookupNames *r)
7197 {
7198         uint32_t cntr_names_0;
7199         TALLOC_CTX *_mem_save_domain_handle_0;
7200         TALLOC_CTX *_mem_save_names_0;
7201         TALLOC_CTX *_mem_save_rids_0;
7202         TALLOC_CTX *_mem_save_types_0;
7203         if (flags & NDR_IN) {
7204                 ZERO_STRUCT(r->out);
7205
7206                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7207                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7208                 }
7209                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7210                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7211                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7212                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7213                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
7214                 if (r->in.num_names < 0 || r->in.num_names > 1000) {
7215                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7216                 }
7217                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
7218                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.names));
7219                 if (ndr_get_array_length(ndr, &r->in.names) > ndr_get_array_size(ndr, &r->in.names)) {
7220                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.names), ndr_get_array_length(ndr, &r->in.names));
7221                 }
7222                 NDR_PULL_ALLOC_N(ndr, r->in.names, ndr_get_array_size(ndr, &r->in.names));
7223                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
7224                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
7225                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
7226                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
7227                 }
7228                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
7229                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
7230                 }
7231                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
7232                 NDR_PULL_ALLOC(ndr, r->out.rids);
7233                 ZERO_STRUCTP(r->out.rids);
7234                 NDR_PULL_ALLOC(ndr, r->out.types);
7235                 ZERO_STRUCTP(r->out.types);
7236                 if (r->in.names) {
7237                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, 1000));
7238                 }
7239                 if (r->in.names) {
7240                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.names, r->in.num_names));
7241                 }
7242         }
7243         if (flags & NDR_OUT) {
7244                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7245                         NDR_PULL_ALLOC(ndr, r->out.rids);
7246                 }
7247                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7248                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
7249                 NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
7250                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
7251                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7252                         NDR_PULL_ALLOC(ndr, r->out.types);
7253                 }
7254                 _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
7255                 NDR_PULL_SET_MEM_CTX(ndr, r->out.types, LIBNDR_FLAG_REF_ALLOC);
7256                 NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
7257                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, LIBNDR_FLAG_REF_ALLOC);
7258                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7259         }
7260         return NDR_ERR_SUCCESS;
7261 }
7262
7263 _PUBLIC_ void ndr_print_samr_LookupNames(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupNames *r)
7264 {
7265         uint32_t cntr_names_0;
7266         ndr_print_struct(ndr, name, "samr_LookupNames");
7267         ndr->depth++;
7268         if (flags & NDR_SET_VALUES) {
7269                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7270         }
7271         if (flags & NDR_IN) {
7272                 ndr_print_struct(ndr, "in", "samr_LookupNames");
7273                 ndr->depth++;
7274                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7275                 ndr->depth++;
7276                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7277                 ndr->depth--;
7278                 ndr_print_uint32(ndr, "num_names", r->in.num_names);
7279                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->in.num_names);
7280                 ndr->depth++;
7281                 for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
7282                         char *idx_0=NULL;
7283                         if (asprintf(&idx_0, "[%d]", cntr_names_0) != -1) {
7284                                 ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
7285                                 free(idx_0);
7286                         }
7287                 }
7288                 ndr->depth--;
7289                 ndr->depth--;
7290         }
7291         if (flags & NDR_OUT) {
7292                 ndr_print_struct(ndr, "out", "samr_LookupNames");
7293                 ndr->depth++;
7294                 ndr_print_ptr(ndr, "rids", r->out.rids);
7295                 ndr->depth++;
7296                 ndr_print_samr_Ids(ndr, "rids", r->out.rids);
7297                 ndr->depth--;
7298                 ndr_print_ptr(ndr, "types", r->out.types);
7299                 ndr->depth++;
7300                 ndr_print_samr_Ids(ndr, "types", r->out.types);
7301                 ndr->depth--;
7302                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7303                 ndr->depth--;
7304         }
7305         ndr->depth--;
7306 }
7307
7308 static enum ndr_err_code ndr_push_samr_LookupRids(struct ndr_push *ndr, int flags, const struct samr_LookupRids *r)
7309 {
7310         uint32_t cntr_rids_0;
7311         if (flags & NDR_IN) {
7312                 if (r->in.domain_handle == NULL) {
7313                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7314                 }
7315                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7316                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_rids));
7317                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1000));
7318                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_rids));
7320                 for (cntr_rids_0 = 0; cntr_rids_0 < r->in.num_rids; cntr_rids_0++) {
7321                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rids[cntr_rids_0]));
7322                 }
7323         }
7324         if (flags & NDR_OUT) {
7325                 if (r->out.names == NULL) {
7326                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7327                 }
7328                 NDR_CHECK(ndr_push_lsa_Strings(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
7329                 if (r->out.types == NULL) {
7330                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7331                 }
7332                 NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
7333                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7334         }
7335         return NDR_ERR_SUCCESS;
7336 }
7337
7338 static enum ndr_err_code ndr_pull_samr_LookupRids(struct ndr_pull *ndr, int flags, struct samr_LookupRids *r)
7339 {
7340         uint32_t cntr_rids_0;
7341         TALLOC_CTX *_mem_save_domain_handle_0;
7342         TALLOC_CTX *_mem_save_rids_0;
7343         TALLOC_CTX *_mem_save_names_0;
7344         TALLOC_CTX *_mem_save_types_0;
7345         if (flags & NDR_IN) {
7346                 ZERO_STRUCT(r->out);
7347
7348                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7349                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7350                 }
7351                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7352                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7353                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7354                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7355                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_rids));
7356                 if (r->in.num_rids < 0 || r->in.num_rids > 1000) {
7357                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7358                 }
7359                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.rids));
7360                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.rids));
7361                 if (ndr_get_array_length(ndr, &r->in.rids) > ndr_get_array_size(ndr, &r->in.rids)) {
7362                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.rids), ndr_get_array_length(ndr, &r->in.rids));
7363                 }
7364                 NDR_PULL_ALLOC_N(ndr, r->in.rids, ndr_get_array_size(ndr, &r->in.rids));
7365                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7366                 NDR_PULL_SET_MEM_CTX(ndr, r->in.rids, 0);
7367                 for (cntr_rids_0 = 0; cntr_rids_0 < r->in.num_rids; cntr_rids_0++) {
7368                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rids[cntr_rids_0]));
7369                 }
7370                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
7371                 NDR_PULL_ALLOC(ndr, r->out.names);
7372                 ZERO_STRUCTP(r->out.names);
7373                 NDR_PULL_ALLOC(ndr, r->out.types);
7374                 ZERO_STRUCTP(r->out.types);
7375                 if (r->in.rids) {
7376                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.rids, 1000));
7377                 }
7378                 if (r->in.rids) {
7379                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.rids, r->in.num_rids));
7380                 }
7381         }
7382         if (flags & NDR_OUT) {
7383                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7384                         NDR_PULL_ALLOC(ndr, r->out.names);
7385                 }
7386                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
7387                 NDR_PULL_SET_MEM_CTX(ndr, r->out.names, LIBNDR_FLAG_REF_ALLOC);
7388                 NDR_CHECK(ndr_pull_lsa_Strings(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
7389                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
7390                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7391                         NDR_PULL_ALLOC(ndr, r->out.types);
7392                 }
7393                 _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
7394                 NDR_PULL_SET_MEM_CTX(ndr, r->out.types, LIBNDR_FLAG_REF_ALLOC);
7395                 NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
7396                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, LIBNDR_FLAG_REF_ALLOC);
7397                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7398         }
7399         return NDR_ERR_SUCCESS;
7400 }
7401
7402 _PUBLIC_ void ndr_print_samr_LookupRids(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupRids *r)
7403 {
7404         uint32_t cntr_rids_0;
7405         ndr_print_struct(ndr, name, "samr_LookupRids");
7406         ndr->depth++;
7407         if (flags & NDR_SET_VALUES) {
7408                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7409         }
7410         if (flags & NDR_IN) {
7411                 ndr_print_struct(ndr, "in", "samr_LookupRids");
7412                 ndr->depth++;
7413                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7414                 ndr->depth++;
7415                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7416                 ndr->depth--;
7417                 ndr_print_uint32(ndr, "num_rids", r->in.num_rids);
7418                 ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->in.num_rids);
7419                 ndr->depth++;
7420                 for (cntr_rids_0=0;cntr_rids_0<r->in.num_rids;cntr_rids_0++) {
7421                         char *idx_0=NULL;
7422                         if (asprintf(&idx_0, "[%d]", cntr_rids_0) != -1) {
7423                                 ndr_print_uint32(ndr, "rids", r->in.rids[cntr_rids_0]);
7424                                 free(idx_0);
7425                         }
7426                 }
7427                 ndr->depth--;
7428                 ndr->depth--;
7429         }
7430         if (flags & NDR_OUT) {
7431                 ndr_print_struct(ndr, "out", "samr_LookupRids");
7432                 ndr->depth++;
7433                 ndr_print_ptr(ndr, "names", r->out.names);
7434                 ndr->depth++;
7435                 ndr_print_lsa_Strings(ndr, "names", r->out.names);
7436                 ndr->depth--;
7437                 ndr_print_ptr(ndr, "types", r->out.types);
7438                 ndr->depth++;
7439                 ndr_print_samr_Ids(ndr, "types", r->out.types);
7440                 ndr->depth--;
7441                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7442                 ndr->depth--;
7443         }
7444         ndr->depth--;
7445 }
7446
7447 static enum ndr_err_code ndr_push_samr_OpenGroup(struct ndr_push *ndr, int flags, const struct samr_OpenGroup *r)
7448 {
7449         if (flags & NDR_IN) {
7450                 if (r->in.domain_handle == NULL) {
7451                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7452                 }
7453                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7454                 NDR_CHECK(ndr_push_samr_GroupAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
7455                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
7456         }
7457         if (flags & NDR_OUT) {
7458                 if (r->out.group_handle == NULL) {
7459                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7460                 }
7461                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
7462                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7463         }
7464         return NDR_ERR_SUCCESS;
7465 }
7466
7467 static enum ndr_err_code ndr_pull_samr_OpenGroup(struct ndr_pull *ndr, int flags, struct samr_OpenGroup *r)
7468 {
7469         TALLOC_CTX *_mem_save_domain_handle_0;
7470         TALLOC_CTX *_mem_save_group_handle_0;
7471         if (flags & NDR_IN) {
7472                 ZERO_STRUCT(r->out);
7473
7474                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7475                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7476                 }
7477                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7478                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7479                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7480                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7481                 NDR_CHECK(ndr_pull_samr_GroupAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
7482                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
7483                 NDR_PULL_ALLOC(ndr, r->out.group_handle);
7484                 ZERO_STRUCTP(r->out.group_handle);
7485         }
7486         if (flags & NDR_OUT) {
7487                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7488                         NDR_PULL_ALLOC(ndr, r->out.group_handle);
7489                 }
7490                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7491                 NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);
7492                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
7493                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7494                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7495         }
7496         return NDR_ERR_SUCCESS;
7497 }
7498
7499 _PUBLIC_ void ndr_print_samr_OpenGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenGroup *r)
7500 {
7501         ndr_print_struct(ndr, name, "samr_OpenGroup");
7502         ndr->depth++;
7503         if (flags & NDR_SET_VALUES) {
7504                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7505         }
7506         if (flags & NDR_IN) {
7507                 ndr_print_struct(ndr, "in", "samr_OpenGroup");
7508                 ndr->depth++;
7509                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7510                 ndr->depth++;
7511                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7512                 ndr->depth--;
7513                 ndr_print_samr_GroupAccessMask(ndr, "access_mask", r->in.access_mask);
7514                 ndr_print_uint32(ndr, "rid", r->in.rid);
7515                 ndr->depth--;
7516         }
7517         if (flags & NDR_OUT) {
7518                 ndr_print_struct(ndr, "out", "samr_OpenGroup");
7519                 ndr->depth++;
7520                 ndr_print_ptr(ndr, "group_handle", r->out.group_handle);
7521                 ndr->depth++;
7522                 ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);
7523                 ndr->depth--;
7524                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7525                 ndr->depth--;
7526         }
7527         ndr->depth--;
7528 }
7529
7530 static enum ndr_err_code ndr_push_samr_QueryGroupInfo(struct ndr_push *ndr, int flags, const struct samr_QueryGroupInfo *r)
7531 {
7532         if (flags & NDR_IN) {
7533                 if (r->in.group_handle == NULL) {
7534                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7535                 }
7536                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7537                 NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, r->in.level));
7538         }
7539         if (flags & NDR_OUT) {
7540                 if (r->out.info == NULL) {
7541                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7542                 }
7543                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
7544                 if (*r->out.info) {
7545                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
7546                         NDR_CHECK(ndr_push_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
7547                 }
7548                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7549         }
7550         return NDR_ERR_SUCCESS;
7551 }
7552
7553 static enum ndr_err_code ndr_pull_samr_QueryGroupInfo(struct ndr_pull *ndr, int flags, struct samr_QueryGroupInfo *r)
7554 {
7555         uint32_t _ptr_info;
7556         TALLOC_CTX *_mem_save_group_handle_0;
7557         TALLOC_CTX *_mem_save_info_0;
7558         TALLOC_CTX *_mem_save_info_1;
7559         if (flags & NDR_IN) {
7560                 ZERO_STRUCT(r->out);
7561
7562                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7563                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
7564                 }
7565                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7566                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
7567                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7568                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7569                 NDR_CHECK(ndr_pull_samr_GroupInfoEnum(ndr, NDR_SCALARS, &r->in.level));
7570                 NDR_PULL_ALLOC(ndr, r->out.info);
7571                 ZERO_STRUCTP(r->out.info);
7572         }
7573         if (flags & NDR_OUT) {
7574                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7575                         NDR_PULL_ALLOC(ndr, r->out.info);
7576                 }
7577                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7578                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
7579                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
7580                 if (_ptr_info) {
7581                         NDR_PULL_ALLOC(ndr, *r->out.info);
7582                 } else {
7583                         *r->out.info = NULL;
7584                 }
7585                 if (*r->out.info) {
7586                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
7587                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
7588                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
7589                         NDR_CHECK(ndr_pull_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
7590                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
7591                 }
7592                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7593                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7594         }
7595         return NDR_ERR_SUCCESS;
7596 }
7597
7598 _PUBLIC_ void ndr_print_samr_QueryGroupInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryGroupInfo *r)
7599 {
7600         ndr_print_struct(ndr, name, "samr_QueryGroupInfo");
7601         ndr->depth++;
7602         if (flags & NDR_SET_VALUES) {
7603                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7604         }
7605         if (flags & NDR_IN) {
7606                 ndr_print_struct(ndr, "in", "samr_QueryGroupInfo");
7607                 ndr->depth++;
7608                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
7609                 ndr->depth++;
7610                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
7611                 ndr->depth--;
7612                 ndr_print_samr_GroupInfoEnum(ndr, "level", r->in.level);
7613                 ndr->depth--;
7614         }
7615         if (flags & NDR_OUT) {
7616                 ndr_print_struct(ndr, "out", "samr_QueryGroupInfo");
7617                 ndr->depth++;
7618                 ndr_print_ptr(ndr, "info", r->out.info);
7619                 ndr->depth++;
7620                 ndr_print_ptr(ndr, "info", *r->out.info);
7621                 ndr->depth++;
7622                 if (*r->out.info) {
7623                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
7624                         ndr_print_samr_GroupInfo(ndr, "info", *r->out.info);
7625                 }
7626                 ndr->depth--;
7627                 ndr->depth--;
7628                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7629                 ndr->depth--;
7630         }
7631         ndr->depth--;
7632 }
7633
7634 static enum ndr_err_code ndr_push_samr_SetGroupInfo(struct ndr_push *ndr, int flags, const struct samr_SetGroupInfo *r)
7635 {
7636         if (flags & NDR_IN) {
7637                 if (r->in.group_handle == NULL) {
7638                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7639                 }
7640                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7641                 NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, r->in.level));
7642                 if (r->in.info == NULL) {
7643                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7644                 }
7645                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
7646                 NDR_CHECK(ndr_push_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
7647         }
7648         if (flags & NDR_OUT) {
7649                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7650         }
7651         return NDR_ERR_SUCCESS;
7652 }
7653
7654 static enum ndr_err_code ndr_pull_samr_SetGroupInfo(struct ndr_pull *ndr, int flags, struct samr_SetGroupInfo *r)
7655 {
7656         TALLOC_CTX *_mem_save_group_handle_0;
7657         TALLOC_CTX *_mem_save_info_0;
7658         if (flags & NDR_IN) {
7659                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7660                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
7661                 }
7662                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7663                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
7664                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7665                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7666                 NDR_CHECK(ndr_pull_samr_GroupInfoEnum(ndr, NDR_SCALARS, &r->in.level));
7667                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7668                         NDR_PULL_ALLOC(ndr, r->in.info);
7669                 }
7670                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7671                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
7672                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
7673                 NDR_CHECK(ndr_pull_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
7674                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7675         }
7676         if (flags & NDR_OUT) {
7677                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7678         }
7679         return NDR_ERR_SUCCESS;
7680 }
7681
7682 _PUBLIC_ void ndr_print_samr_SetGroupInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetGroupInfo *r)
7683 {
7684         ndr_print_struct(ndr, name, "samr_SetGroupInfo");
7685         ndr->depth++;
7686         if (flags & NDR_SET_VALUES) {
7687                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7688         }
7689         if (flags & NDR_IN) {
7690                 ndr_print_struct(ndr, "in", "samr_SetGroupInfo");
7691                 ndr->depth++;
7692                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
7693                 ndr->depth++;
7694                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
7695                 ndr->depth--;
7696                 ndr_print_samr_GroupInfoEnum(ndr, "level", r->in.level);
7697                 ndr_print_ptr(ndr, "info", r->in.info);
7698                 ndr->depth++;
7699                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
7700                 ndr_print_samr_GroupInfo(ndr, "info", r->in.info);
7701                 ndr->depth--;
7702                 ndr->depth--;
7703         }
7704         if (flags & NDR_OUT) {
7705                 ndr_print_struct(ndr, "out", "samr_SetGroupInfo");
7706                 ndr->depth++;
7707                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7708                 ndr->depth--;
7709         }
7710         ndr->depth--;
7711 }
7712
7713 static enum ndr_err_code ndr_push_samr_AddGroupMember(struct ndr_push *ndr, int flags, const struct samr_AddGroupMember *r)
7714 {
7715         if (flags & NDR_IN) {
7716                 if (r->in.group_handle == NULL) {
7717                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7718                 }
7719                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7720                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
7721                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
7722         }
7723         if (flags & NDR_OUT) {
7724                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7725         }
7726         return NDR_ERR_SUCCESS;
7727 }
7728
7729 static enum ndr_err_code ndr_pull_samr_AddGroupMember(struct ndr_pull *ndr, int flags, struct samr_AddGroupMember *r)
7730 {
7731         TALLOC_CTX *_mem_save_group_handle_0;
7732         if (flags & NDR_IN) {
7733                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7734                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
7735                 }
7736                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7737                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
7738                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7739                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7740                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
7741                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
7742         }
7743         if (flags & NDR_OUT) {
7744                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7745         }
7746         return NDR_ERR_SUCCESS;
7747 }
7748
7749 _PUBLIC_ void ndr_print_samr_AddGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddGroupMember *r)
7750 {
7751         ndr_print_struct(ndr, name, "samr_AddGroupMember");
7752         ndr->depth++;
7753         if (flags & NDR_SET_VALUES) {
7754                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7755         }
7756         if (flags & NDR_IN) {
7757                 ndr_print_struct(ndr, "in", "samr_AddGroupMember");
7758                 ndr->depth++;
7759                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
7760                 ndr->depth++;
7761                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
7762                 ndr->depth--;
7763                 ndr_print_uint32(ndr, "rid", r->in.rid);
7764                 ndr_print_uint32(ndr, "flags", r->in.flags);
7765                 ndr->depth--;
7766         }
7767         if (flags & NDR_OUT) {
7768                 ndr_print_struct(ndr, "out", "samr_AddGroupMember");
7769                 ndr->depth++;
7770                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7771                 ndr->depth--;
7772         }
7773         ndr->depth--;
7774 }
7775
7776 static enum ndr_err_code ndr_push_samr_DeleteDomainGroup(struct ndr_push *ndr, int flags, const struct samr_DeleteDomainGroup *r)
7777 {
7778         if (flags & NDR_IN) {
7779                 if (r->in.group_handle == NULL) {
7780                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7781                 }
7782                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7783         }
7784         if (flags & NDR_OUT) {
7785                 if (r->out.group_handle == NULL) {
7786                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7787                 }
7788                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
7789                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7790         }
7791         return NDR_ERR_SUCCESS;
7792 }
7793
7794 static enum ndr_err_code ndr_pull_samr_DeleteDomainGroup(struct ndr_pull *ndr, int flags, struct samr_DeleteDomainGroup *r)
7795 {
7796         TALLOC_CTX *_mem_save_group_handle_0;
7797         if (flags & NDR_IN) {
7798                 ZERO_STRUCT(r->out);
7799
7800                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7801                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
7802                 }
7803                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7804                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
7805                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7806                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7807                 NDR_PULL_ALLOC(ndr, r->out.group_handle);
7808                 *r->out.group_handle = *r->in.group_handle;
7809         }
7810         if (flags & NDR_OUT) {
7811                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7812                         NDR_PULL_ALLOC(ndr, r->out.group_handle);
7813                 }
7814                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7815                 NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);
7816                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
7817                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7818                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7819         }
7820         return NDR_ERR_SUCCESS;
7821 }
7822
7823 _PUBLIC_ void ndr_print_samr_DeleteDomainGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteDomainGroup *r)
7824 {
7825         ndr_print_struct(ndr, name, "samr_DeleteDomainGroup");
7826         ndr->depth++;
7827         if (flags & NDR_SET_VALUES) {
7828                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7829         }
7830         if (flags & NDR_IN) {
7831                 ndr_print_struct(ndr, "in", "samr_DeleteDomainGroup");
7832                 ndr->depth++;
7833                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
7834                 ndr->depth++;
7835                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
7836                 ndr->depth--;
7837                 ndr->depth--;
7838         }
7839         if (flags & NDR_OUT) {
7840                 ndr_print_struct(ndr, "out", "samr_DeleteDomainGroup");
7841                 ndr->depth++;
7842                 ndr_print_ptr(ndr, "group_handle", r->out.group_handle);
7843                 ndr->depth++;
7844                 ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);
7845                 ndr->depth--;
7846                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7847                 ndr->depth--;
7848         }
7849         ndr->depth--;
7850 }
7851
7852 static enum ndr_err_code ndr_push_samr_DeleteGroupMember(struct ndr_push *ndr, int flags, const struct samr_DeleteGroupMember *r)
7853 {
7854         if (flags & NDR_IN) {
7855                 if (r->in.group_handle == NULL) {
7856                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7857                 }
7858                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7859                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
7860         }
7861         if (flags & NDR_OUT) {
7862                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7863         }
7864         return NDR_ERR_SUCCESS;
7865 }
7866
7867 static enum ndr_err_code ndr_pull_samr_DeleteGroupMember(struct ndr_pull *ndr, int flags, struct samr_DeleteGroupMember *r)
7868 {
7869         TALLOC_CTX *_mem_save_group_handle_0;
7870         if (flags & NDR_IN) {
7871                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7872                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
7873                 }
7874                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7875                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
7876                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7877                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7878                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
7879         }
7880         if (flags & NDR_OUT) {
7881                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7882         }
7883         return NDR_ERR_SUCCESS;
7884 }
7885
7886 _PUBLIC_ void ndr_print_samr_DeleteGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteGroupMember *r)
7887 {
7888         ndr_print_struct(ndr, name, "samr_DeleteGroupMember");
7889         ndr->depth++;
7890         if (flags & NDR_SET_VALUES) {
7891                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7892         }
7893         if (flags & NDR_IN) {
7894                 ndr_print_struct(ndr, "in", "samr_DeleteGroupMember");
7895                 ndr->depth++;
7896                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
7897                 ndr->depth++;
7898                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
7899                 ndr->depth--;
7900                 ndr_print_uint32(ndr, "rid", r->in.rid);
7901                 ndr->depth--;
7902         }
7903         if (flags & NDR_OUT) {
7904                 ndr_print_struct(ndr, "out", "samr_DeleteGroupMember");
7905                 ndr->depth++;
7906                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7907                 ndr->depth--;
7908         }
7909         ndr->depth--;
7910 }
7911
7912 static enum ndr_err_code ndr_push_samr_QueryGroupMember(struct ndr_push *ndr, int flags, const struct samr_QueryGroupMember *r)
7913 {
7914         if (flags & NDR_IN) {
7915                 if (r->in.group_handle == NULL) {
7916                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7917                 }
7918                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7919         }
7920         if (flags & NDR_OUT) {
7921                 if (r->out.rids == NULL) {
7922                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7923                 }
7924                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rids));
7925                 if (*r->out.rids) {
7926                         NDR_CHECK(ndr_push_samr_RidTypeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
7927                 }
7928                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7929         }
7930         return NDR_ERR_SUCCESS;
7931 }
7932
7933 static enum ndr_err_code ndr_pull_samr_QueryGroupMember(struct ndr_pull *ndr, int flags, struct samr_QueryGroupMember *r)
7934 {
7935         uint32_t _ptr_rids;
7936         TALLOC_CTX *_mem_save_group_handle_0;
7937         TALLOC_CTX *_mem_save_rids_0;
7938         TALLOC_CTX *_mem_save_rids_1;
7939         if (flags & NDR_IN) {
7940                 ZERO_STRUCT(r->out);
7941
7942                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7943                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
7944                 }
7945                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7946                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
7947                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7948                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7949                 NDR_PULL_ALLOC(ndr, r->out.rids);
7950                 ZERO_STRUCTP(r->out.rids);
7951         }
7952         if (flags & NDR_OUT) {
7953                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7954                         NDR_PULL_ALLOC(ndr, r->out.rids);
7955                 }
7956                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7957                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
7958                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
7959                 if (_ptr_rids) {
7960                         NDR_PULL_ALLOC(ndr, *r->out.rids);
7961                 } else {
7962                         *r->out.rids = NULL;
7963                 }
7964                 if (*r->out.rids) {
7965                         _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
7966                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.rids, 0);
7967                         NDR_CHECK(ndr_pull_samr_RidTypeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
7968                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
7969                 }
7970                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
7971                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7972         }
7973         return NDR_ERR_SUCCESS;
7974 }
7975
7976 _PUBLIC_ void ndr_print_samr_QueryGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryGroupMember *r)
7977 {
7978         ndr_print_struct(ndr, name, "samr_QueryGroupMember");
7979         ndr->depth++;
7980         if (flags & NDR_SET_VALUES) {
7981                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7982         }
7983         if (flags & NDR_IN) {
7984                 ndr_print_struct(ndr, "in", "samr_QueryGroupMember");
7985                 ndr->depth++;
7986                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
7987                 ndr->depth++;
7988                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
7989                 ndr->depth--;
7990                 ndr->depth--;
7991         }
7992         if (flags & NDR_OUT) {
7993                 ndr_print_struct(ndr, "out", "samr_QueryGroupMember");
7994                 ndr->depth++;
7995                 ndr_print_ptr(ndr, "rids", r->out.rids);
7996                 ndr->depth++;
7997                 ndr_print_ptr(ndr, "rids", *r->out.rids);
7998                 ndr->depth++;
7999                 if (*r->out.rids) {
8000                         ndr_print_samr_RidTypeArray(ndr, "rids", *r->out.rids);
8001                 }
8002                 ndr->depth--;
8003                 ndr->depth--;
8004                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8005                 ndr->depth--;
8006         }
8007         ndr->depth--;
8008 }
8009
8010 static enum ndr_err_code ndr_push_samr_SetMemberAttributesOfGroup(struct ndr_push *ndr, int flags, const struct samr_SetMemberAttributesOfGroup *r)
8011 {
8012         if (flags & NDR_IN) {
8013                 if (r->in.group_handle == NULL) {
8014                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8015                 }
8016                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8017                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
8018                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
8019         }
8020         if (flags & NDR_OUT) {
8021                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8022         }
8023         return NDR_ERR_SUCCESS;
8024 }
8025
8026 static enum ndr_err_code ndr_pull_samr_SetMemberAttributesOfGroup(struct ndr_pull *ndr, int flags, struct samr_SetMemberAttributesOfGroup *r)
8027 {
8028         TALLOC_CTX *_mem_save_group_handle_0;
8029         if (flags & NDR_IN) {
8030                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8031                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
8032                 }
8033                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8034                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
8035                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8036                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
8037                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
8038                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
8039         }
8040         if (flags & NDR_OUT) {
8041                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8042         }
8043         return NDR_ERR_SUCCESS;
8044 }
8045
8046 _PUBLIC_ void ndr_print_samr_SetMemberAttributesOfGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetMemberAttributesOfGroup *r)
8047 {
8048         ndr_print_struct(ndr, name, "samr_SetMemberAttributesOfGroup");
8049         ndr->depth++;
8050         if (flags & NDR_SET_VALUES) {
8051                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8052         }
8053         if (flags & NDR_IN) {
8054                 ndr_print_struct(ndr, "in", "samr_SetMemberAttributesOfGroup");
8055                 ndr->depth++;
8056                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
8057                 ndr->depth++;
8058                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
8059                 ndr->depth--;
8060                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
8061                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
8062                 ndr->depth--;
8063         }
8064         if (flags & NDR_OUT) {
8065                 ndr_print_struct(ndr, "out", "samr_SetMemberAttributesOfGroup");
8066                 ndr->depth++;
8067                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8068                 ndr->depth--;
8069         }
8070         ndr->depth--;
8071 }
8072
8073 static enum ndr_err_code ndr_push_samr_OpenAlias(struct ndr_push *ndr, int flags, const struct samr_OpenAlias *r)
8074 {
8075         if (flags & NDR_IN) {
8076                 if (r->in.domain_handle == NULL) {
8077                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8078                 }
8079                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
8080                 NDR_CHECK(ndr_push_samr_AliasAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
8081                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
8082         }
8083         if (flags & NDR_OUT) {
8084                 if (r->out.alias_handle == NULL) {
8085                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8086                 }
8087                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
8088                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8089         }
8090         return NDR_ERR_SUCCESS;
8091 }
8092
8093 static enum ndr_err_code ndr_pull_samr_OpenAlias(struct ndr_pull *ndr, int flags, struct samr_OpenAlias *r)
8094 {
8095         TALLOC_CTX *_mem_save_domain_handle_0;
8096         TALLOC_CTX *_mem_save_alias_handle_0;
8097         if (flags & NDR_IN) {
8098                 ZERO_STRUCT(r->out);
8099
8100                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8101                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
8102                 }
8103                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8104                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
8105                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
8106                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
8107                 NDR_CHECK(ndr_pull_samr_AliasAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
8108                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
8109                 NDR_PULL_ALLOC(ndr, r->out.alias_handle);
8110                 ZERO_STRUCTP(r->out.alias_handle);
8111         }
8112         if (flags & NDR_OUT) {
8113                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8114                         NDR_PULL_ALLOC(ndr, r->out.alias_handle);
8115                 }
8116                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8117                 NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8118                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
8119                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8120                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8121         }
8122         return NDR_ERR_SUCCESS;
8123 }
8124
8125 _PUBLIC_ void ndr_print_samr_OpenAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenAlias *r)
8126 {
8127         ndr_print_struct(ndr, name, "samr_OpenAlias");
8128         ndr->depth++;
8129         if (flags & NDR_SET_VALUES) {
8130                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8131         }
8132         if (flags & NDR_IN) {
8133                 ndr_print_struct(ndr, "in", "samr_OpenAlias");
8134                 ndr->depth++;
8135                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
8136                 ndr->depth++;
8137                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
8138                 ndr->depth--;
8139                 ndr_print_samr_AliasAccessMask(ndr, "access_mask", r->in.access_mask);
8140                 ndr_print_uint32(ndr, "rid", r->in.rid);
8141                 ndr->depth--;
8142         }
8143         if (flags & NDR_OUT) {
8144                 ndr_print_struct(ndr, "out", "samr_OpenAlias");
8145                 ndr->depth++;
8146                 ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);
8147                 ndr->depth++;
8148                 ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);
8149                 ndr->depth--;
8150                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8151                 ndr->depth--;
8152         }
8153         ndr->depth--;
8154 }
8155
8156 static enum ndr_err_code ndr_push_samr_QueryAliasInfo(struct ndr_push *ndr, int flags, const struct samr_QueryAliasInfo *r)
8157 {
8158         if (flags & NDR_IN) {
8159                 if (r->in.alias_handle == NULL) {
8160                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8161                 }
8162                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8163                 NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, r->in.level));
8164         }
8165         if (flags & NDR_OUT) {
8166                 if (r->out.info == NULL) {
8167                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8168                 }
8169                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
8170                 if (*r->out.info) {
8171                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
8172                         NDR_CHECK(ndr_push_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8173                 }
8174                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8175         }
8176         return NDR_ERR_SUCCESS;
8177 }
8178
8179 static enum ndr_err_code ndr_pull_samr_QueryAliasInfo(struct ndr_pull *ndr, int flags, struct samr_QueryAliasInfo *r)
8180 {
8181         uint32_t _ptr_info;
8182         TALLOC_CTX *_mem_save_alias_handle_0;
8183         TALLOC_CTX *_mem_save_info_0;
8184         TALLOC_CTX *_mem_save_info_1;
8185         if (flags & NDR_IN) {
8186                 ZERO_STRUCT(r->out);
8187
8188                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8189                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8190                 }
8191                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8192                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8193                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8194                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8195                 NDR_CHECK(ndr_pull_samr_AliasInfoEnum(ndr, NDR_SCALARS, &r->in.level));
8196                 NDR_PULL_ALLOC(ndr, r->out.info);
8197                 ZERO_STRUCTP(r->out.info);
8198         }
8199         if (flags & NDR_OUT) {
8200                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8201                         NDR_PULL_ALLOC(ndr, r->out.info);
8202                 }
8203                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8204                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
8205                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8206                 if (_ptr_info) {
8207                         NDR_PULL_ALLOC(ndr, *r->out.info);
8208                 } else {
8209                         *r->out.info = NULL;
8210                 }
8211                 if (*r->out.info) {
8212                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
8213                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
8214                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
8215                         NDR_CHECK(ndr_pull_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8216                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
8217                 }
8218                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
8219                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8220         }
8221         return NDR_ERR_SUCCESS;
8222 }
8223
8224 _PUBLIC_ void ndr_print_samr_QueryAliasInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryAliasInfo *r)
8225 {
8226         ndr_print_struct(ndr, name, "samr_QueryAliasInfo");
8227         ndr->depth++;
8228         if (flags & NDR_SET_VALUES) {
8229                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8230         }
8231         if (flags & NDR_IN) {
8232                 ndr_print_struct(ndr, "in", "samr_QueryAliasInfo");
8233                 ndr->depth++;
8234                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8235                 ndr->depth++;
8236                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8237                 ndr->depth--;
8238                 ndr_print_samr_AliasInfoEnum(ndr, "level", r->in.level);
8239                 ndr->depth--;
8240         }
8241         if (flags & NDR_OUT) {
8242                 ndr_print_struct(ndr, "out", "samr_QueryAliasInfo");
8243                 ndr->depth++;
8244                 ndr_print_ptr(ndr, "info", r->out.info);
8245                 ndr->depth++;
8246                 ndr_print_ptr(ndr, "info", *r->out.info);
8247                 ndr->depth++;
8248                 if (*r->out.info) {
8249                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
8250                         ndr_print_samr_AliasInfo(ndr, "info", *r->out.info);
8251                 }
8252                 ndr->depth--;
8253                 ndr->depth--;
8254                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8255                 ndr->depth--;
8256         }
8257         ndr->depth--;
8258 }
8259
8260 static enum ndr_err_code ndr_push_samr_SetAliasInfo(struct ndr_push *ndr, int flags, const struct samr_SetAliasInfo *r)
8261 {
8262         if (flags & NDR_IN) {
8263                 if (r->in.alias_handle == NULL) {
8264                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8265                 }
8266                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8267                 NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, r->in.level));
8268                 if (r->in.info == NULL) {
8269                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8270                 }
8271                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
8272                 NDR_CHECK(ndr_push_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8273         }
8274         if (flags & NDR_OUT) {
8275                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8276         }
8277         return NDR_ERR_SUCCESS;
8278 }
8279
8280 static enum ndr_err_code ndr_pull_samr_SetAliasInfo(struct ndr_pull *ndr, int flags, struct samr_SetAliasInfo *r)
8281 {
8282         TALLOC_CTX *_mem_save_alias_handle_0;
8283         TALLOC_CTX *_mem_save_info_0;
8284         if (flags & NDR_IN) {
8285                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8286                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8287                 }
8288                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8289                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8290                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8291                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8292                 NDR_CHECK(ndr_pull_samr_AliasInfoEnum(ndr, NDR_SCALARS, &r->in.level));
8293                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8294                         NDR_PULL_ALLOC(ndr, r->in.info);
8295                 }
8296                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8297                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
8298                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
8299                 NDR_CHECK(ndr_pull_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8300                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
8301         }
8302         if (flags & NDR_OUT) {
8303                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8304         }
8305         return NDR_ERR_SUCCESS;
8306 }
8307
8308 _PUBLIC_ void ndr_print_samr_SetAliasInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetAliasInfo *r)
8309 {
8310         ndr_print_struct(ndr, name, "samr_SetAliasInfo");
8311         ndr->depth++;
8312         if (flags & NDR_SET_VALUES) {
8313                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8314         }
8315         if (flags & NDR_IN) {
8316                 ndr_print_struct(ndr, "in", "samr_SetAliasInfo");
8317                 ndr->depth++;
8318                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8319                 ndr->depth++;
8320                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8321                 ndr->depth--;
8322                 ndr_print_samr_AliasInfoEnum(ndr, "level", r->in.level);
8323                 ndr_print_ptr(ndr, "info", r->in.info);
8324                 ndr->depth++;
8325                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
8326                 ndr_print_samr_AliasInfo(ndr, "info", r->in.info);
8327                 ndr->depth--;
8328                 ndr->depth--;
8329         }
8330         if (flags & NDR_OUT) {
8331                 ndr_print_struct(ndr, "out", "samr_SetAliasInfo");
8332                 ndr->depth++;
8333                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8334                 ndr->depth--;
8335         }
8336         ndr->depth--;
8337 }
8338
8339 static enum ndr_err_code ndr_push_samr_DeleteDomAlias(struct ndr_push *ndr, int flags, const struct samr_DeleteDomAlias *r)
8340 {
8341         if (flags & NDR_IN) {
8342                 if (r->in.alias_handle == NULL) {
8343                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8344                 }
8345                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8346         }
8347         if (flags & NDR_OUT) {
8348                 if (r->out.alias_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->out.alias_handle));
8352                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8353         }
8354         return NDR_ERR_SUCCESS;
8355 }
8356
8357 static enum ndr_err_code ndr_pull_samr_DeleteDomAlias(struct ndr_pull *ndr, int flags, struct samr_DeleteDomAlias *r)
8358 {
8359         TALLOC_CTX *_mem_save_alias_handle_0;
8360         if (flags & NDR_IN) {
8361                 ZERO_STRUCT(r->out);
8362
8363                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8364                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8365                 }
8366                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8367                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8368                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8369                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8370                 NDR_PULL_ALLOC(ndr, r->out.alias_handle);
8371                 *r->out.alias_handle = *r->in.alias_handle;
8372         }
8373         if (flags & NDR_OUT) {
8374                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8375                         NDR_PULL_ALLOC(ndr, r->out.alias_handle);
8376                 }
8377                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8378                 NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8379                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
8380                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8381                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8382         }
8383         return NDR_ERR_SUCCESS;
8384 }
8385
8386 _PUBLIC_ void ndr_print_samr_DeleteDomAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteDomAlias *r)
8387 {
8388         ndr_print_struct(ndr, name, "samr_DeleteDomAlias");
8389         ndr->depth++;
8390         if (flags & NDR_SET_VALUES) {
8391                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8392         }
8393         if (flags & NDR_IN) {
8394                 ndr_print_struct(ndr, "in", "samr_DeleteDomAlias");
8395                 ndr->depth++;
8396                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8397                 ndr->depth++;
8398                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8399                 ndr->depth--;
8400                 ndr->depth--;
8401         }
8402         if (flags & NDR_OUT) {
8403                 ndr_print_struct(ndr, "out", "samr_DeleteDomAlias");
8404                 ndr->depth++;
8405                 ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);
8406                 ndr->depth++;
8407                 ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);
8408                 ndr->depth--;
8409                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8410                 ndr->depth--;
8411         }
8412         ndr->depth--;
8413 }
8414
8415 static enum ndr_err_code ndr_push_samr_AddAliasMember(struct ndr_push *ndr, int flags, const struct samr_AddAliasMember *r)
8416 {
8417         if (flags & NDR_IN) {
8418                 if (r->in.alias_handle == NULL) {
8419                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8420                 }
8421                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8422                 if (r->in.sid == NULL) {
8423                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8424                 }
8425                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8426         }
8427         if (flags & NDR_OUT) {
8428                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8429         }
8430         return NDR_ERR_SUCCESS;
8431 }
8432
8433 static enum ndr_err_code ndr_pull_samr_AddAliasMember(struct ndr_pull *ndr, int flags, struct samr_AddAliasMember *r)
8434 {
8435         TALLOC_CTX *_mem_save_alias_handle_0;
8436         TALLOC_CTX *_mem_save_sid_0;
8437         if (flags & NDR_IN) {
8438                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8439                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8440                 }
8441                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8442                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8443                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8444                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8445                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8446                         NDR_PULL_ALLOC(ndr, r->in.sid);
8447                 }
8448                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
8449                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
8450                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8451                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
8452         }
8453         if (flags & NDR_OUT) {
8454                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8455         }
8456         return NDR_ERR_SUCCESS;
8457 }
8458
8459 _PUBLIC_ void ndr_print_samr_AddAliasMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddAliasMember *r)
8460 {
8461         ndr_print_struct(ndr, name, "samr_AddAliasMember");
8462         ndr->depth++;
8463         if (flags & NDR_SET_VALUES) {
8464                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8465         }
8466         if (flags & NDR_IN) {
8467                 ndr_print_struct(ndr, "in", "samr_AddAliasMember");
8468                 ndr->depth++;
8469                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8470                 ndr->depth++;
8471                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8472                 ndr->depth--;
8473                 ndr_print_ptr(ndr, "sid", r->in.sid);
8474                 ndr->depth++;
8475                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
8476                 ndr->depth--;
8477                 ndr->depth--;
8478         }
8479         if (flags & NDR_OUT) {
8480                 ndr_print_struct(ndr, "out", "samr_AddAliasMember");
8481                 ndr->depth++;
8482                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8483                 ndr->depth--;
8484         }
8485         ndr->depth--;
8486 }
8487
8488 static enum ndr_err_code ndr_push_samr_DeleteAliasMember(struct ndr_push *ndr, int flags, const struct samr_DeleteAliasMember *r)
8489 {
8490         if (flags & NDR_IN) {
8491                 if (r->in.alias_handle == NULL) {
8492                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8493                 }
8494                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8495                 if (r->in.sid == NULL) {
8496                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8497                 }
8498                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8499         }
8500         if (flags & NDR_OUT) {
8501                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8502         }
8503         return NDR_ERR_SUCCESS;
8504 }
8505
8506 static enum ndr_err_code ndr_pull_samr_DeleteAliasMember(struct ndr_pull *ndr, int flags, struct samr_DeleteAliasMember *r)
8507 {
8508         TALLOC_CTX *_mem_save_alias_handle_0;
8509         TALLOC_CTX *_mem_save_sid_0;
8510         if (flags & NDR_IN) {
8511                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8512                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8513                 }
8514                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8515                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8516                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8517                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8518                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8519                         NDR_PULL_ALLOC(ndr, r->in.sid);
8520                 }
8521                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
8522                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
8523                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8524                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
8525         }
8526         if (flags & NDR_OUT) {
8527                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8528         }
8529         return NDR_ERR_SUCCESS;
8530 }
8531
8532 _PUBLIC_ void ndr_print_samr_DeleteAliasMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteAliasMember *r)
8533 {
8534         ndr_print_struct(ndr, name, "samr_DeleteAliasMember");
8535         ndr->depth++;
8536         if (flags & NDR_SET_VALUES) {
8537                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8538         }
8539         if (flags & NDR_IN) {
8540                 ndr_print_struct(ndr, "in", "samr_DeleteAliasMember");
8541                 ndr->depth++;
8542                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8543                 ndr->depth++;
8544                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8545                 ndr->depth--;
8546                 ndr_print_ptr(ndr, "sid", r->in.sid);
8547                 ndr->depth++;
8548                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
8549                 ndr->depth--;
8550                 ndr->depth--;
8551         }
8552         if (flags & NDR_OUT) {
8553                 ndr_print_struct(ndr, "out", "samr_DeleteAliasMember");
8554                 ndr->depth++;
8555                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8556                 ndr->depth--;
8557         }
8558         ndr->depth--;
8559 }
8560
8561 static enum ndr_err_code ndr_push_samr_GetMembersInAlias(struct ndr_push *ndr, int flags, const struct samr_GetMembersInAlias *r)
8562 {
8563         if (flags & NDR_IN) {
8564                 if (r->in.alias_handle == NULL) {
8565                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8566                 }
8567                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8568         }
8569         if (flags & NDR_OUT) {
8570                 if (r->out.sids == NULL) {
8571                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8572                 }
8573                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
8574                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8575         }
8576         return NDR_ERR_SUCCESS;
8577 }
8578
8579 static enum ndr_err_code ndr_pull_samr_GetMembersInAlias(struct ndr_pull *ndr, int flags, struct samr_GetMembersInAlias *r)
8580 {
8581         TALLOC_CTX *_mem_save_alias_handle_0;
8582         TALLOC_CTX *_mem_save_sids_0;
8583         if (flags & NDR_IN) {
8584                 ZERO_STRUCT(r->out);
8585
8586                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8587                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8588                 }
8589                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8590                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8591                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8592                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8593                 NDR_PULL_ALLOC(ndr, r->out.sids);
8594                 ZERO_STRUCTP(r->out.sids);
8595         }
8596         if (flags & NDR_OUT) {
8597                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8598                         NDR_PULL_ALLOC(ndr, r->out.sids);
8599                 }
8600                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
8601                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
8602                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
8603                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
8604                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8605         }
8606         return NDR_ERR_SUCCESS;
8607 }
8608
8609 _PUBLIC_ void ndr_print_samr_GetMembersInAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetMembersInAlias *r)
8610 {
8611         ndr_print_struct(ndr, name, "samr_GetMembersInAlias");
8612         ndr->depth++;
8613         if (flags & NDR_SET_VALUES) {
8614                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8615         }
8616         if (flags & NDR_IN) {
8617                 ndr_print_struct(ndr, "in", "samr_GetMembersInAlias");
8618                 ndr->depth++;
8619                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8620                 ndr->depth++;
8621                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8622                 ndr->depth--;
8623                 ndr->depth--;
8624         }
8625         if (flags & NDR_OUT) {
8626                 ndr_print_struct(ndr, "out", "samr_GetMembersInAlias");
8627                 ndr->depth++;
8628                 ndr_print_ptr(ndr, "sids", r->out.sids);
8629                 ndr->depth++;
8630                 ndr_print_lsa_SidArray(ndr, "sids", r->out.sids);
8631                 ndr->depth--;
8632                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8633                 ndr->depth--;
8634         }
8635         ndr->depth--;
8636 }
8637
8638 _PUBLIC_ enum ndr_err_code ndr_push_samr_OpenUser(struct ndr_push *ndr, int flags, const struct samr_OpenUser *r)
8639 {
8640         if (flags & NDR_IN) {
8641                 if (r->in.domain_handle == NULL) {
8642                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8643                 }
8644                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
8645                 NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
8646                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
8647         }
8648         if (flags & NDR_OUT) {
8649                 if (r->out.user_handle == NULL) {
8650                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8651                 }
8652                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
8653                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8654         }
8655         return NDR_ERR_SUCCESS;
8656 }
8657
8658 _PUBLIC_ enum ndr_err_code ndr_pull_samr_OpenUser(struct ndr_pull *ndr, int flags, struct samr_OpenUser *r)
8659 {
8660         TALLOC_CTX *_mem_save_domain_handle_0;
8661         TALLOC_CTX *_mem_save_user_handle_0;
8662         if (flags & NDR_IN) {
8663                 ZERO_STRUCT(r->out);
8664
8665                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8666                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
8667                 }
8668                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8669                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
8670                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
8671                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
8672                 NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
8673                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
8674                 NDR_PULL_ALLOC(ndr, r->out.user_handle);
8675                 ZERO_STRUCTP(r->out.user_handle);
8676         }
8677         if (flags & NDR_OUT) {
8678                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8679                         NDR_PULL_ALLOC(ndr, r->out.user_handle);
8680                 }
8681                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8682                 NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
8683                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
8684                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
8685                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8686         }
8687         return NDR_ERR_SUCCESS;
8688 }
8689
8690 _PUBLIC_ void ndr_print_samr_OpenUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenUser *r)
8691 {
8692         ndr_print_struct(ndr, name, "samr_OpenUser");
8693         ndr->depth++;
8694         if (flags & NDR_SET_VALUES) {
8695                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8696         }
8697         if (flags & NDR_IN) {
8698                 ndr_print_struct(ndr, "in", "samr_OpenUser");
8699                 ndr->depth++;
8700                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
8701                 ndr->depth++;
8702                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
8703                 ndr->depth--;
8704                 ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);
8705                 ndr_print_uint32(ndr, "rid", r->in.rid);
8706                 ndr->depth--;
8707         }
8708         if (flags & NDR_OUT) {
8709                 ndr_print_struct(ndr, "out", "samr_OpenUser");
8710                 ndr->depth++;
8711                 ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
8712                 ndr->depth++;
8713                 ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
8714                 ndr->depth--;
8715                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8716                 ndr->depth--;
8717         }
8718         ndr->depth--;
8719 }
8720
8721 static enum ndr_err_code ndr_push_samr_DeleteUser(struct ndr_push *ndr, int flags, const struct samr_DeleteUser *r)
8722 {
8723         if (flags & NDR_IN) {
8724                 if (r->in.user_handle == NULL) {
8725                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8726                 }
8727                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
8728         }
8729         if (flags & NDR_OUT) {
8730                 if (r->out.user_handle == NULL) {
8731                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8732                 }
8733                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
8734                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8735         }
8736         return NDR_ERR_SUCCESS;
8737 }
8738
8739 static enum ndr_err_code ndr_pull_samr_DeleteUser(struct ndr_pull *ndr, int flags, struct samr_DeleteUser *r)
8740 {
8741         TALLOC_CTX *_mem_save_user_handle_0;
8742         if (flags & NDR_IN) {
8743                 ZERO_STRUCT(r->out);
8744
8745                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8746                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
8747                 }
8748                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8749                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
8750                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
8751                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
8752                 NDR_PULL_ALLOC(ndr, r->out.user_handle);
8753                 *r->out.user_handle = *r->in.user_handle;
8754         }
8755         if (flags & NDR_OUT) {
8756                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8757                         NDR_PULL_ALLOC(ndr, r->out.user_handle);
8758                 }
8759                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8760                 NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
8761                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
8762                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
8763                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8764         }
8765         return NDR_ERR_SUCCESS;
8766 }
8767
8768 _PUBLIC_ void ndr_print_samr_DeleteUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteUser *r)
8769 {
8770         ndr_print_struct(ndr, name, "samr_DeleteUser");
8771         ndr->depth++;
8772         if (flags & NDR_SET_VALUES) {
8773                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8774         }
8775         if (flags & NDR_IN) {
8776                 ndr_print_struct(ndr, "in", "samr_DeleteUser");
8777                 ndr->depth++;
8778                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
8779                 ndr->depth++;
8780                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
8781                 ndr->depth--;
8782                 ndr->depth--;
8783         }
8784         if (flags & NDR_OUT) {
8785                 ndr_print_struct(ndr, "out", "samr_DeleteUser");
8786                 ndr->depth++;
8787                 ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
8788                 ndr->depth++;
8789                 ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
8790                 ndr->depth--;
8791                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8792                 ndr->depth--;
8793         }
8794         ndr->depth--;
8795 }
8796
8797 _PUBLIC_ enum ndr_err_code ndr_push_samr_QueryUserInfo(struct ndr_push *ndr, int flags, const struct samr_QueryUserInfo *r)
8798 {
8799         if (flags & NDR_IN) {
8800                 if (r->in.user_handle == NULL) {
8801                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8802                 }
8803                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
8804                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
8805         }
8806         if (flags & NDR_OUT) {
8807                 if (r->out.info == NULL) {
8808                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8809                 }
8810                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
8811                 if (*r->out.info) {
8812                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
8813                         NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8814                 }
8815                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8816         }
8817         return NDR_ERR_SUCCESS;
8818 }
8819
8820 _PUBLIC_ enum ndr_err_code ndr_pull_samr_QueryUserInfo(struct ndr_pull *ndr, int flags, struct samr_QueryUserInfo *r)
8821 {
8822         uint32_t _ptr_info;
8823         TALLOC_CTX *_mem_save_user_handle_0;
8824         TALLOC_CTX *_mem_save_info_0;
8825         TALLOC_CTX *_mem_save_info_1;
8826         if (flags & NDR_IN) {
8827                 ZERO_STRUCT(r->out);
8828
8829                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8830                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
8831                 }
8832                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8833                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
8834                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
8835                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
8836                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
8837                 NDR_PULL_ALLOC(ndr, r->out.info);
8838                 ZERO_STRUCTP(r->out.info);
8839         }
8840         if (flags & NDR_OUT) {
8841                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8842                         NDR_PULL_ALLOC(ndr, r->out.info);
8843                 }
8844                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8845                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
8846                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8847                 if (_ptr_info) {
8848                         NDR_PULL_ALLOC(ndr, *r->out.info);
8849                 } else {
8850                         *r->out.info = NULL;
8851                 }
8852                 if (*r->out.info) {
8853                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
8854                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
8855                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
8856                         NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8857                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
8858                 }
8859                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
8860                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8861         }
8862         return NDR_ERR_SUCCESS;
8863 }
8864
8865 _PUBLIC_ void ndr_print_samr_QueryUserInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryUserInfo *r)
8866 {
8867         ndr_print_struct(ndr, name, "samr_QueryUserInfo");
8868         ndr->depth++;
8869         if (flags & NDR_SET_VALUES) {
8870                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8871         }
8872         if (flags & NDR_IN) {
8873                 ndr_print_struct(ndr, "in", "samr_QueryUserInfo");
8874                 ndr->depth++;
8875                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
8876                 ndr->depth++;
8877                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
8878                 ndr->depth--;
8879                 ndr_print_uint16(ndr, "level", r->in.level);
8880                 ndr->depth--;
8881         }
8882         if (flags & NDR_OUT) {
8883                 ndr_print_struct(ndr, "out", "samr_QueryUserInfo");
8884                 ndr->depth++;
8885                 ndr_print_ptr(ndr, "info", r->out.info);
8886                 ndr->depth++;
8887                 ndr_print_ptr(ndr, "info", *r->out.info);
8888                 ndr->depth++;
8889                 if (*r->out.info) {
8890                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
8891                         ndr_print_samr_UserInfo(ndr, "info", *r->out.info);
8892                 }
8893                 ndr->depth--;
8894                 ndr->depth--;
8895                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8896                 ndr->depth--;
8897         }
8898         ndr->depth--;
8899 }
8900
8901 _PUBLIC_ enum ndr_err_code ndr_push_samr_SetUserInfo(struct ndr_push *ndr, int flags, const struct samr_SetUserInfo *r)
8902 {
8903         if (flags & NDR_IN) {
8904                 if (r->in.user_handle == NULL) {
8905                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8906                 }
8907                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
8908                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
8909                 if (r->in.info == NULL) {
8910                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8911                 }
8912                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
8913                 NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8914         }
8915         if (flags & NDR_OUT) {
8916                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8917         }
8918         return NDR_ERR_SUCCESS;
8919 }
8920
8921 _PUBLIC_ enum ndr_err_code ndr_pull_samr_SetUserInfo(struct ndr_pull *ndr, int flags, struct samr_SetUserInfo *r)
8922 {
8923         TALLOC_CTX *_mem_save_user_handle_0;
8924         TALLOC_CTX *_mem_save_info_0;
8925         if (flags & NDR_IN) {
8926                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8927                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
8928                 }
8929                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8930                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
8931                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
8932                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
8933                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
8934                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8935                         NDR_PULL_ALLOC(ndr, r->in.info);
8936                 }
8937                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8938                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
8939                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
8940                 NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8941                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
8942         }
8943         if (flags & NDR_OUT) {
8944                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8945         }
8946         return NDR_ERR_SUCCESS;
8947 }
8948
8949 _PUBLIC_ void ndr_print_samr_SetUserInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetUserInfo *r)
8950 {
8951         ndr_print_struct(ndr, name, "samr_SetUserInfo");
8952         ndr->depth++;
8953         if (flags & NDR_SET_VALUES) {
8954                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8955         }
8956         if (flags & NDR_IN) {
8957                 ndr_print_struct(ndr, "in", "samr_SetUserInfo");
8958                 ndr->depth++;
8959                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
8960                 ndr->depth++;
8961                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
8962                 ndr->depth--;
8963                 ndr_print_uint16(ndr, "level", r->in.level);
8964                 ndr_print_ptr(ndr, "info", r->in.info);
8965                 ndr->depth++;
8966                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
8967                 ndr_print_samr_UserInfo(ndr, "info", r->in.info);
8968                 ndr->depth--;
8969                 ndr->depth--;
8970         }
8971         if (flags & NDR_OUT) {
8972                 ndr_print_struct(ndr, "out", "samr_SetUserInfo");
8973                 ndr->depth++;
8974                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8975                 ndr->depth--;
8976         }
8977         ndr->depth--;
8978 }
8979
8980 static enum ndr_err_code ndr_push_samr_ChangePasswordUser(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser *r)
8981 {
8982         if (flags & NDR_IN) {
8983                 if (r->in.user_handle == NULL) {
8984                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8985                 }
8986                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
8987                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_present));
8988                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_lm_crypted));
8989                 if (r->in.old_lm_crypted) {
8990                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.old_lm_crypted));
8991                 }
8992                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_lm_crypted));
8993                 if (r->in.new_lm_crypted) {
8994                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.new_lm_crypted));
8995                 }
8996                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.nt_present));
8997                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_nt_crypted));
8998                 if (r->in.old_nt_crypted) {
8999                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.old_nt_crypted));
9000                 }
9001                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_nt_crypted));
9002                 if (r->in.new_nt_crypted) {
9003                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.new_nt_crypted));
9004                 }
9005                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.cross1_present));
9006                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_cross));
9007                 if (r->in.nt_cross) {
9008                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_cross));
9009                 }
9010                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.cross2_present));
9011                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_cross));
9012                 if (r->in.lm_cross) {
9013                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_cross));
9014                 }
9015         }
9016         if (flags & NDR_OUT) {
9017                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9018         }
9019         return NDR_ERR_SUCCESS;
9020 }
9021
9022 static enum ndr_err_code ndr_pull_samr_ChangePasswordUser(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser *r)
9023 {
9024         uint32_t _ptr_old_lm_crypted;
9025         uint32_t _ptr_new_lm_crypted;
9026         uint32_t _ptr_old_nt_crypted;
9027         uint32_t _ptr_new_nt_crypted;
9028         uint32_t _ptr_nt_cross;
9029         uint32_t _ptr_lm_cross;
9030         TALLOC_CTX *_mem_save_user_handle_0;
9031         TALLOC_CTX *_mem_save_old_lm_crypted_0;
9032         TALLOC_CTX *_mem_save_new_lm_crypted_0;
9033         TALLOC_CTX *_mem_save_old_nt_crypted_0;
9034         TALLOC_CTX *_mem_save_new_nt_crypted_0;
9035         TALLOC_CTX *_mem_save_nt_cross_0;
9036         TALLOC_CTX *_mem_save_lm_cross_0;
9037         if (flags & NDR_IN) {
9038                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9039                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9040                 }
9041                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9042                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9043                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9044                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9045                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_present));
9046                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_lm_crypted));
9047                 if (_ptr_old_lm_crypted) {
9048                         NDR_PULL_ALLOC(ndr, r->in.old_lm_crypted);
9049                 } else {
9050                         r->in.old_lm_crypted = NULL;
9051                 }
9052                 if (r->in.old_lm_crypted) {
9053                         _mem_save_old_lm_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
9054                         NDR_PULL_SET_MEM_CTX(ndr, r->in.old_lm_crypted, 0);
9055                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.old_lm_crypted));
9056                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_lm_crypted_0, 0);
9057                 }
9058                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_lm_crypted));
9059                 if (_ptr_new_lm_crypted) {
9060                         NDR_PULL_ALLOC(ndr, r->in.new_lm_crypted);
9061                 } else {
9062                         r->in.new_lm_crypted = NULL;
9063                 }
9064                 if (r->in.new_lm_crypted) {
9065                         _mem_save_new_lm_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
9066                         NDR_PULL_SET_MEM_CTX(ndr, r->in.new_lm_crypted, 0);
9067                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.new_lm_crypted));
9068                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_lm_crypted_0, 0);
9069                 }
9070                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.nt_present));
9071                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_nt_crypted));
9072                 if (_ptr_old_nt_crypted) {
9073                         NDR_PULL_ALLOC(ndr, r->in.old_nt_crypted);
9074                 } else {
9075                         r->in.old_nt_crypted = NULL;
9076                 }
9077                 if (r->in.old_nt_crypted) {
9078                         _mem_save_old_nt_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
9079                         NDR_PULL_SET_MEM_CTX(ndr, r->in.old_nt_crypted, 0);
9080                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.old_nt_crypted));
9081                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_nt_crypted_0, 0);
9082                 }
9083                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_nt_crypted));
9084                 if (_ptr_new_nt_crypted) {
9085                         NDR_PULL_ALLOC(ndr, r->in.new_nt_crypted);
9086                 } else {
9087                         r->in.new_nt_crypted = NULL;
9088                 }
9089                 if (r->in.new_nt_crypted) {
9090                         _mem_save_new_nt_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
9091                         NDR_PULL_SET_MEM_CTX(ndr, r->in.new_nt_crypted, 0);
9092                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.new_nt_crypted));
9093                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_nt_crypted_0, 0);
9094                 }
9095                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.cross1_present));
9096                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_cross));
9097                 if (_ptr_nt_cross) {
9098                         NDR_PULL_ALLOC(ndr, r->in.nt_cross);
9099                 } else {
9100                         r->in.nt_cross = NULL;
9101                 }
9102                 if (r->in.nt_cross) {
9103                         _mem_save_nt_cross_0 = NDR_PULL_GET_MEM_CTX(ndr);
9104                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_cross, 0);
9105                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_cross));
9106                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_cross_0, 0);
9107                 }
9108                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.cross2_present));
9109                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_cross));
9110                 if (_ptr_lm_cross) {
9111                         NDR_PULL_ALLOC(ndr, r->in.lm_cross);
9112                 } else {
9113                         r->in.lm_cross = NULL;
9114                 }
9115                 if (r->in.lm_cross) {
9116                         _mem_save_lm_cross_0 = NDR_PULL_GET_MEM_CTX(ndr);
9117                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_cross, 0);
9118                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_cross));
9119                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_cross_0, 0);
9120                 }
9121         }
9122         if (flags & NDR_OUT) {
9123                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9124         }
9125         return NDR_ERR_SUCCESS;
9126 }
9127
9128 _PUBLIC_ void ndr_print_samr_ChangePasswordUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser *r)
9129 {
9130         ndr_print_struct(ndr, name, "samr_ChangePasswordUser");
9131         ndr->depth++;
9132         if (flags & NDR_SET_VALUES) {
9133                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9134         }
9135         if (flags & NDR_IN) {
9136                 ndr_print_struct(ndr, "in", "samr_ChangePasswordUser");
9137                 ndr->depth++;
9138                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9139                 ndr->depth++;
9140                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9141                 ndr->depth--;
9142                 ndr_print_uint8(ndr, "lm_present", r->in.lm_present);
9143                 ndr_print_ptr(ndr, "old_lm_crypted", r->in.old_lm_crypted);
9144                 ndr->depth++;
9145                 if (r->in.old_lm_crypted) {
9146                         ndr_print_samr_Password(ndr, "old_lm_crypted", r->in.old_lm_crypted);
9147                 }
9148                 ndr->depth--;
9149                 ndr_print_ptr(ndr, "new_lm_crypted", r->in.new_lm_crypted);
9150                 ndr->depth++;
9151                 if (r->in.new_lm_crypted) {
9152                         ndr_print_samr_Password(ndr, "new_lm_crypted", r->in.new_lm_crypted);
9153                 }
9154                 ndr->depth--;
9155                 ndr_print_uint8(ndr, "nt_present", r->in.nt_present);
9156                 ndr_print_ptr(ndr, "old_nt_crypted", r->in.old_nt_crypted);
9157                 ndr->depth++;
9158                 if (r->in.old_nt_crypted) {
9159                         ndr_print_samr_Password(ndr, "old_nt_crypted", r->in.old_nt_crypted);
9160                 }
9161                 ndr->depth--;
9162                 ndr_print_ptr(ndr, "new_nt_crypted", r->in.new_nt_crypted);
9163                 ndr->depth++;
9164                 if (r->in.new_nt_crypted) {
9165                         ndr_print_samr_Password(ndr, "new_nt_crypted", r->in.new_nt_crypted);
9166                 }
9167                 ndr->depth--;
9168                 ndr_print_uint8(ndr, "cross1_present", r->in.cross1_present);
9169                 ndr_print_ptr(ndr, "nt_cross", r->in.nt_cross);
9170                 ndr->depth++;
9171                 if (r->in.nt_cross) {
9172                         ndr_print_samr_Password(ndr, "nt_cross", r->in.nt_cross);
9173                 }
9174                 ndr->depth--;
9175                 ndr_print_uint8(ndr, "cross2_present", r->in.cross2_present);
9176                 ndr_print_ptr(ndr, "lm_cross", r->in.lm_cross);
9177                 ndr->depth++;
9178                 if (r->in.lm_cross) {
9179                         ndr_print_samr_Password(ndr, "lm_cross", r->in.lm_cross);
9180                 }
9181                 ndr->depth--;
9182                 ndr->depth--;
9183         }
9184         if (flags & NDR_OUT) {
9185                 ndr_print_struct(ndr, "out", "samr_ChangePasswordUser");
9186                 ndr->depth++;
9187                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9188                 ndr->depth--;
9189         }
9190         ndr->depth--;
9191 }
9192
9193 static enum ndr_err_code ndr_push_samr_GetGroupsForUser(struct ndr_push *ndr, int flags, const struct samr_GetGroupsForUser *r)
9194 {
9195         if (flags & NDR_IN) {
9196                 if (r->in.user_handle == NULL) {
9197                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9198                 }
9199                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9200         }
9201         if (flags & NDR_OUT) {
9202                 if (r->out.rids == NULL) {
9203                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9204                 }
9205                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rids));
9206                 if (*r->out.rids) {
9207                         NDR_CHECK(ndr_push_samr_RidWithAttributeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
9208                 }
9209                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9210         }
9211         return NDR_ERR_SUCCESS;
9212 }
9213
9214 static enum ndr_err_code ndr_pull_samr_GetGroupsForUser(struct ndr_pull *ndr, int flags, struct samr_GetGroupsForUser *r)
9215 {
9216         uint32_t _ptr_rids;
9217         TALLOC_CTX *_mem_save_user_handle_0;
9218         TALLOC_CTX *_mem_save_rids_0;
9219         TALLOC_CTX *_mem_save_rids_1;
9220         if (flags & NDR_IN) {
9221                 ZERO_STRUCT(r->out);
9222
9223                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9224                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9225                 }
9226                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9227                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9228                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9229                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9230                 NDR_PULL_ALLOC(ndr, r->out.rids);
9231                 ZERO_STRUCTP(r->out.rids);
9232         }
9233         if (flags & NDR_OUT) {
9234                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9235                         NDR_PULL_ALLOC(ndr, r->out.rids);
9236                 }
9237                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
9238                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
9239                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
9240                 if (_ptr_rids) {
9241                         NDR_PULL_ALLOC(ndr, *r->out.rids);
9242                 } else {
9243                         *r->out.rids = NULL;
9244                 }
9245                 if (*r->out.rids) {
9246                         _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
9247                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.rids, 0);
9248                         NDR_CHECK(ndr_pull_samr_RidWithAttributeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
9249                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
9250                 }
9251                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
9252                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9253         }
9254         return NDR_ERR_SUCCESS;
9255 }
9256
9257 _PUBLIC_ void ndr_print_samr_GetGroupsForUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetGroupsForUser *r)
9258 {
9259         ndr_print_struct(ndr, name, "samr_GetGroupsForUser");
9260         ndr->depth++;
9261         if (flags & NDR_SET_VALUES) {
9262                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9263         }
9264         if (flags & NDR_IN) {
9265                 ndr_print_struct(ndr, "in", "samr_GetGroupsForUser");
9266                 ndr->depth++;
9267                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9268                 ndr->depth++;
9269                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9270                 ndr->depth--;
9271                 ndr->depth--;
9272         }
9273         if (flags & NDR_OUT) {
9274                 ndr_print_struct(ndr, "out", "samr_GetGroupsForUser");
9275                 ndr->depth++;
9276                 ndr_print_ptr(ndr, "rids", r->out.rids);
9277                 ndr->depth++;
9278                 ndr_print_ptr(ndr, "rids", *r->out.rids);
9279                 ndr->depth++;
9280                 if (*r->out.rids) {
9281                         ndr_print_samr_RidWithAttributeArray(ndr, "rids", *r->out.rids);
9282                 }
9283                 ndr->depth--;
9284                 ndr->depth--;
9285                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9286                 ndr->depth--;
9287         }
9288         ndr->depth--;
9289 }
9290
9291 static enum ndr_err_code ndr_push_samr_QueryDisplayInfo(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo *r)
9292 {
9293         if (flags & NDR_IN) {
9294                 if (r->in.domain_handle == NULL) {
9295                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9296                 }
9297                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9298                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));
9300                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));
9301                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
9302         }
9303         if (flags & NDR_OUT) {
9304                 if (r->out.total_size == NULL) {
9305                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9306                 }
9307                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));
9308                 if (r->out.returned_size == NULL) {
9309                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9310                 }
9311                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));
9312                 if (r->out.info == NULL) {
9313                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9314                 }
9315                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
9316                 NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
9317                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9318         }
9319         return NDR_ERR_SUCCESS;
9320 }
9321
9322 static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo *r)
9323 {
9324         TALLOC_CTX *_mem_save_domain_handle_0;
9325         TALLOC_CTX *_mem_save_total_size_0;
9326         TALLOC_CTX *_mem_save_returned_size_0;
9327         TALLOC_CTX *_mem_save_info_0;
9328         if (flags & NDR_IN) {
9329                 ZERO_STRUCT(r->out);
9330
9331                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9332                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
9333                 }
9334                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9335                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
9336                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9337                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
9338                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
9339                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));
9340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));
9341                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
9342                 NDR_PULL_ALLOC(ndr, r->out.total_size);
9343                 ZERO_STRUCTP(r->out.total_size);
9344                 NDR_PULL_ALLOC(ndr, r->out.returned_size);
9345                 ZERO_STRUCTP(r->out.returned_size);
9346                 NDR_PULL_ALLOC(ndr, r->out.info);
9347                 ZERO_STRUCTP(r->out.info);
9348         }
9349         if (flags & NDR_OUT) {
9350                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9351                         NDR_PULL_ALLOC(ndr, r->out.total_size);
9352                 }
9353                 _mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
9354                 NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);
9355                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));
9356                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);
9357                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9358                         NDR_PULL_ALLOC(ndr, r->out.returned_size);
9359                 }
9360                 _mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
9361                 NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);
9362                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));
9363                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);
9364                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9365                         NDR_PULL_ALLOC(ndr, r->out.info);
9366                 }
9367                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9368                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9369                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
9370                 NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
9371                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9372                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9373         }
9374         return NDR_ERR_SUCCESS;
9375 }
9376
9377 _PUBLIC_ void ndr_print_samr_QueryDisplayInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo *r)
9378 {
9379         ndr_print_struct(ndr, name, "samr_QueryDisplayInfo");
9380         ndr->depth++;
9381         if (flags & NDR_SET_VALUES) {
9382                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9383         }
9384         if (flags & NDR_IN) {
9385                 ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo");
9386                 ndr->depth++;
9387                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
9388                 ndr->depth++;
9389                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
9390                 ndr->depth--;
9391                 ndr_print_uint16(ndr, "level", r->in.level);
9392                 ndr_print_uint32(ndr, "start_idx", r->in.start_idx);
9393                 ndr_print_uint32(ndr, "max_entries", r->in.max_entries);
9394                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
9395                 ndr->depth--;
9396         }
9397         if (flags & NDR_OUT) {
9398                 ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo");
9399                 ndr->depth++;
9400                 ndr_print_ptr(ndr, "total_size", r->out.total_size);
9401                 ndr->depth++;
9402                 ndr_print_uint32(ndr, "total_size", *r->out.total_size);
9403                 ndr->depth--;
9404                 ndr_print_ptr(ndr, "returned_size", r->out.returned_size);
9405                 ndr->depth++;
9406                 ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);
9407                 ndr->depth--;
9408                 ndr_print_ptr(ndr, "info", r->out.info);
9409                 ndr->depth++;
9410                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
9411                 ndr_print_samr_DispInfo(ndr, "info", r->out.info);
9412                 ndr->depth--;
9413                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9414                 ndr->depth--;
9415         }
9416         ndr->depth--;
9417 }
9418
9419 static enum ndr_err_code ndr_push_samr_GetDisplayEnumerationIndex(struct ndr_push *ndr, int flags, const struct samr_GetDisplayEnumerationIndex *r)
9420 {
9421         if (flags & NDR_IN) {
9422                 if (r->in.domain_handle == NULL) {
9423                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9424                 }
9425                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9426                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9427                 if (r->in.name == NULL) {
9428                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9429                 }
9430                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
9431         }
9432         if (flags & NDR_OUT) {
9433                 if (r->out.idx == NULL) {
9434                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9435                 }
9436                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.idx));
9437                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9438         }
9439         return NDR_ERR_SUCCESS;
9440 }
9441
9442 static enum ndr_err_code ndr_pull_samr_GetDisplayEnumerationIndex(struct ndr_pull *ndr, int flags, struct samr_GetDisplayEnumerationIndex *r)
9443 {
9444         TALLOC_CTX *_mem_save_domain_handle_0;
9445         TALLOC_CTX *_mem_save_name_0;
9446         TALLOC_CTX *_mem_save_idx_0;
9447         if (flags & NDR_IN) {
9448                 ZERO_STRUCT(r->out);
9449
9450                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9451                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
9452                 }
9453                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9454                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
9455                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9456                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
9457                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
9458                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9459                         NDR_PULL_ALLOC(ndr, r->in.name);
9460                 }
9461                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9462                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
9463                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
9464                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
9465                 NDR_PULL_ALLOC(ndr, r->out.idx);
9466                 ZERO_STRUCTP(r->out.idx);
9467         }
9468         if (flags & NDR_OUT) {
9469                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9470                         NDR_PULL_ALLOC(ndr, r->out.idx);
9471                 }
9472                 _mem_save_idx_0 = NDR_PULL_GET_MEM_CTX(ndr);
9473                 NDR_PULL_SET_MEM_CTX(ndr, r->out.idx, LIBNDR_FLAG_REF_ALLOC);
9474                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.idx));
9475                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_idx_0, LIBNDR_FLAG_REF_ALLOC);
9476                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9477         }
9478         return NDR_ERR_SUCCESS;
9479 }
9480
9481 _PUBLIC_ void ndr_print_samr_GetDisplayEnumerationIndex(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDisplayEnumerationIndex *r)
9482 {
9483         ndr_print_struct(ndr, name, "samr_GetDisplayEnumerationIndex");
9484         ndr->depth++;
9485         if (flags & NDR_SET_VALUES) {
9486                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9487         }
9488         if (flags & NDR_IN) {
9489                 ndr_print_struct(ndr, "in", "samr_GetDisplayEnumerationIndex");
9490                 ndr->depth++;
9491                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
9492                 ndr->depth++;
9493                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
9494                 ndr->depth--;
9495                 ndr_print_uint16(ndr, "level", r->in.level);
9496                 ndr_print_ptr(ndr, "name", r->in.name);
9497                 ndr->depth++;
9498                 ndr_print_lsa_String(ndr, "name", r->in.name);
9499                 ndr->depth--;
9500                 ndr->depth--;
9501         }
9502         if (flags & NDR_OUT) {
9503                 ndr_print_struct(ndr, "out", "samr_GetDisplayEnumerationIndex");
9504                 ndr->depth++;
9505                 ndr_print_ptr(ndr, "idx", r->out.idx);
9506                 ndr->depth++;
9507                 ndr_print_uint32(ndr, "idx", *r->out.idx);
9508                 ndr->depth--;
9509                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9510                 ndr->depth--;
9511         }
9512         ndr->depth--;
9513 }
9514
9515 static enum ndr_err_code ndr_push_samr_TestPrivateFunctionsDomain(struct ndr_push *ndr, int flags, const struct samr_TestPrivateFunctionsDomain *r)
9516 {
9517         if (flags & NDR_IN) {
9518                 if (r->in.domain_handle == NULL) {
9519                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9520                 }
9521                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9522         }
9523         if (flags & NDR_OUT) {
9524                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9525         }
9526         return NDR_ERR_SUCCESS;
9527 }
9528
9529 static enum ndr_err_code ndr_pull_samr_TestPrivateFunctionsDomain(struct ndr_pull *ndr, int flags, struct samr_TestPrivateFunctionsDomain *r)
9530 {
9531         TALLOC_CTX *_mem_save_domain_handle_0;
9532         if (flags & NDR_IN) {
9533                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9534                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
9535                 }
9536                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9537                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
9538                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9539                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
9540         }
9541         if (flags & NDR_OUT) {
9542                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9543         }
9544         return NDR_ERR_SUCCESS;
9545 }
9546
9547 _PUBLIC_ void ndr_print_samr_TestPrivateFunctionsDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_TestPrivateFunctionsDomain *r)
9548 {
9549         ndr_print_struct(ndr, name, "samr_TestPrivateFunctionsDomain");
9550         ndr->depth++;
9551         if (flags & NDR_SET_VALUES) {
9552                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9553         }
9554         if (flags & NDR_IN) {
9555                 ndr_print_struct(ndr, "in", "samr_TestPrivateFunctionsDomain");
9556                 ndr->depth++;
9557                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
9558                 ndr->depth++;
9559                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
9560                 ndr->depth--;
9561                 ndr->depth--;
9562         }
9563         if (flags & NDR_OUT) {
9564                 ndr_print_struct(ndr, "out", "samr_TestPrivateFunctionsDomain");
9565                 ndr->depth++;
9566                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9567                 ndr->depth--;
9568         }
9569         ndr->depth--;
9570 }
9571
9572 static enum ndr_err_code ndr_push_samr_TestPrivateFunctionsUser(struct ndr_push *ndr, int flags, const struct samr_TestPrivateFunctionsUser *r)
9573 {
9574         if (flags & NDR_IN) {
9575                 if (r->in.user_handle == NULL) {
9576                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9577                 }
9578                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9579         }
9580         if (flags & NDR_OUT) {
9581                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9582         }
9583         return NDR_ERR_SUCCESS;
9584 }
9585
9586 static enum ndr_err_code ndr_pull_samr_TestPrivateFunctionsUser(struct ndr_pull *ndr, int flags, struct samr_TestPrivateFunctionsUser *r)
9587 {
9588         TALLOC_CTX *_mem_save_user_handle_0;
9589         if (flags & NDR_IN) {
9590                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9591                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9592                 }
9593                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9594                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9595                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9596                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9597         }
9598         if (flags & NDR_OUT) {
9599                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9600         }
9601         return NDR_ERR_SUCCESS;
9602 }
9603
9604 _PUBLIC_ void ndr_print_samr_TestPrivateFunctionsUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_TestPrivateFunctionsUser *r)
9605 {
9606         ndr_print_struct(ndr, name, "samr_TestPrivateFunctionsUser");
9607         ndr->depth++;
9608         if (flags & NDR_SET_VALUES) {
9609                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9610         }
9611         if (flags & NDR_IN) {
9612                 ndr_print_struct(ndr, "in", "samr_TestPrivateFunctionsUser");
9613                 ndr->depth++;
9614                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9615                 ndr->depth++;
9616                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9617                 ndr->depth--;
9618                 ndr->depth--;
9619         }
9620         if (flags & NDR_OUT) {
9621                 ndr_print_struct(ndr, "out", "samr_TestPrivateFunctionsUser");
9622                 ndr->depth++;
9623                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9624                 ndr->depth--;
9625         }
9626         ndr->depth--;
9627 }
9628
9629 _PUBLIC_ enum ndr_err_code ndr_push_samr_GetUserPwInfo(struct ndr_push *ndr, int flags, const struct samr_GetUserPwInfo *r)
9630 {
9631         if (flags & NDR_IN) {
9632                 if (r->in.user_handle == NULL) {
9633                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9634                 }
9635                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9636         }
9637         if (flags & NDR_OUT) {
9638                 if (r->out.info == NULL) {
9639                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9640                 }
9641                 NDR_CHECK(ndr_push_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
9642                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9643         }
9644         return NDR_ERR_SUCCESS;
9645 }
9646
9647 _PUBLIC_ enum ndr_err_code ndr_pull_samr_GetUserPwInfo(struct ndr_pull *ndr, int flags, struct samr_GetUserPwInfo *r)
9648 {
9649         TALLOC_CTX *_mem_save_user_handle_0;
9650         TALLOC_CTX *_mem_save_info_0;
9651         if (flags & NDR_IN) {
9652                 ZERO_STRUCT(r->out);
9653
9654                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9655                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9656                 }
9657                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9658                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9659                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9660                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9661                 NDR_PULL_ALLOC(ndr, r->out.info);
9662                 ZERO_STRUCTP(r->out.info);
9663         }
9664         if (flags & NDR_OUT) {
9665                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9666                         NDR_PULL_ALLOC(ndr, r->out.info);
9667                 }
9668                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9669                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9670                 NDR_CHECK(ndr_pull_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
9671                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9672                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9673         }
9674         return NDR_ERR_SUCCESS;
9675 }
9676
9677 _PUBLIC_ void ndr_print_samr_GetUserPwInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetUserPwInfo *r)
9678 {
9679         ndr_print_struct(ndr, name, "samr_GetUserPwInfo");
9680         ndr->depth++;
9681         if (flags & NDR_SET_VALUES) {
9682                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9683         }
9684         if (flags & NDR_IN) {
9685                 ndr_print_struct(ndr, "in", "samr_GetUserPwInfo");
9686                 ndr->depth++;
9687                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9688                 ndr->depth++;
9689                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9690                 ndr->depth--;
9691                 ndr->depth--;
9692         }
9693         if (flags & NDR_OUT) {
9694                 ndr_print_struct(ndr, "out", "samr_GetUserPwInfo");
9695                 ndr->depth++;
9696                 ndr_print_ptr(ndr, "info", r->out.info);
9697                 ndr->depth++;
9698                 ndr_print_samr_PwInfo(ndr, "info", r->out.info);
9699                 ndr->depth--;
9700                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9701                 ndr->depth--;
9702         }
9703         ndr->depth--;
9704 }
9705
9706 static enum ndr_err_code ndr_push_samr_RemoveMemberFromForeignDomain(struct ndr_push *ndr, int flags, const struct samr_RemoveMemberFromForeignDomain *r)
9707 {
9708         if (flags & NDR_IN) {
9709                 if (r->in.domain_handle == NULL) {
9710                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9711                 }
9712                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9713                 if (r->in.sid == NULL) {
9714                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9715                 }
9716                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
9717         }
9718         if (flags & NDR_OUT) {
9719                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9720         }
9721         return NDR_ERR_SUCCESS;
9722 }
9723
9724 static enum ndr_err_code ndr_pull_samr_RemoveMemberFromForeignDomain(struct ndr_pull *ndr, int flags, struct samr_RemoveMemberFromForeignDomain *r)
9725 {
9726         TALLOC_CTX *_mem_save_domain_handle_0;
9727         TALLOC_CTX *_mem_save_sid_0;
9728         if (flags & NDR_IN) {
9729                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9730                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
9731                 }
9732                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9733                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
9734                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9735                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
9736                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9737                         NDR_PULL_ALLOC(ndr, r->in.sid);
9738                 }
9739                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
9740                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
9741                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
9742                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
9743         }
9744         if (flags & NDR_OUT) {
9745                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9746         }
9747         return NDR_ERR_SUCCESS;
9748 }
9749
9750 _PUBLIC_ void ndr_print_samr_RemoveMemberFromForeignDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_RemoveMemberFromForeignDomain *r)
9751 {
9752         ndr_print_struct(ndr, name, "samr_RemoveMemberFromForeignDomain");
9753         ndr->depth++;
9754         if (flags & NDR_SET_VALUES) {
9755                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9756         }
9757         if (flags & NDR_IN) {
9758                 ndr_print_struct(ndr, "in", "samr_RemoveMemberFromForeignDomain");
9759                 ndr->depth++;
9760                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
9761                 ndr->depth++;
9762                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
9763                 ndr->depth--;
9764                 ndr_print_ptr(ndr, "sid", r->in.sid);
9765                 ndr->depth++;
9766                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
9767                 ndr->depth--;
9768                 ndr->depth--;
9769         }
9770         if (flags & NDR_OUT) {
9771                 ndr_print_struct(ndr, "out", "samr_RemoveMemberFromForeignDomain");
9772                 ndr->depth++;
9773                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9774                 ndr->depth--;
9775         }
9776         ndr->depth--;
9777 }
9778
9779 static enum ndr_err_code ndr_push_samr_QueryDomainInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryDomainInfo2 *r)
9780 {
9781         if (flags & NDR_IN) {
9782                 if (r->in.domain_handle == NULL) {
9783                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9784                 }
9785                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9786                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9787         }
9788         if (flags & NDR_OUT) {
9789                 if (r->out.info == NULL) {
9790                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9791                 }
9792                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
9793                 if (*r->out.info) {
9794                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
9795                         NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9796                 }
9797                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9798         }
9799         return NDR_ERR_SUCCESS;
9800 }
9801
9802 static enum ndr_err_code ndr_pull_samr_QueryDomainInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryDomainInfo2 *r)
9803 {
9804         uint32_t _ptr_info;
9805         TALLOC_CTX *_mem_save_domain_handle_0;
9806         TALLOC_CTX *_mem_save_info_0;
9807         TALLOC_CTX *_mem_save_info_1;
9808         if (flags & NDR_IN) {
9809                 ZERO_STRUCT(r->out);
9810
9811                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9812                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
9813                 }
9814                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9815                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
9816                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9817                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
9818                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
9819                 NDR_PULL_ALLOC(ndr, r->out.info);
9820                 ZERO_STRUCTP(r->out.info);
9821         }
9822         if (flags & NDR_OUT) {
9823                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9824                         NDR_PULL_ALLOC(ndr, r->out.info);
9825                 }
9826                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9827                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9828                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9829                 if (_ptr_info) {
9830                         NDR_PULL_ALLOC(ndr, *r->out.info);
9831                 } else {
9832                         *r->out.info = NULL;
9833                 }
9834                 if (*r->out.info) {
9835                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
9836                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
9837                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
9838                         NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9839                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
9840                 }
9841                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9842                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9843         }
9844         return NDR_ERR_SUCCESS;
9845 }
9846
9847 _PUBLIC_ void ndr_print_samr_QueryDomainInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDomainInfo2 *r)
9848 {
9849         ndr_print_struct(ndr, name, "samr_QueryDomainInfo2");
9850         ndr->depth++;
9851         if (flags & NDR_SET_VALUES) {
9852                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9853         }
9854         if (flags & NDR_IN) {
9855                 ndr_print_struct(ndr, "in", "samr_QueryDomainInfo2");
9856                 ndr->depth++;
9857                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
9858                 ndr->depth++;
9859                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
9860                 ndr->depth--;
9861                 ndr_print_uint16(ndr, "level", r->in.level);
9862                 ndr->depth--;
9863         }
9864         if (flags & NDR_OUT) {
9865                 ndr_print_struct(ndr, "out", "samr_QueryDomainInfo2");
9866                 ndr->depth++;
9867                 ndr_print_ptr(ndr, "info", r->out.info);
9868                 ndr->depth++;
9869                 ndr_print_ptr(ndr, "info", *r->out.info);
9870                 ndr->depth++;
9871                 if (*r->out.info) {
9872                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
9873                         ndr_print_samr_DomainInfo(ndr, "info", *r->out.info);
9874                 }
9875                 ndr->depth--;
9876                 ndr->depth--;
9877                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9878                 ndr->depth--;
9879         }
9880         ndr->depth--;
9881 }
9882
9883 static enum ndr_err_code ndr_push_samr_QueryUserInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryUserInfo2 *r)
9884 {
9885         if (flags & NDR_IN) {
9886                 if (r->in.user_handle == NULL) {
9887                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9888                 }
9889                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9890                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9891         }
9892         if (flags & NDR_OUT) {
9893                 if (r->out.info == NULL) {
9894                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9895                 }
9896                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
9897                 if (*r->out.info) {
9898                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
9899                         NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9900                 }
9901                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9902         }
9903         return NDR_ERR_SUCCESS;
9904 }
9905
9906 static enum ndr_err_code ndr_pull_samr_QueryUserInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryUserInfo2 *r)
9907 {
9908         uint32_t _ptr_info;
9909         TALLOC_CTX *_mem_save_user_handle_0;
9910         TALLOC_CTX *_mem_save_info_0;
9911         TALLOC_CTX *_mem_save_info_1;
9912         if (flags & NDR_IN) {
9913                 ZERO_STRUCT(r->out);
9914
9915                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9916                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9917                 }
9918                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9919                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9920                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9921                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9922                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
9923                 NDR_PULL_ALLOC(ndr, r->out.info);
9924                 ZERO_STRUCTP(r->out.info);
9925         }
9926         if (flags & NDR_OUT) {
9927                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9928                         NDR_PULL_ALLOC(ndr, r->out.info);
9929                 }
9930                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9931                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9932                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9933                 if (_ptr_info) {
9934                         NDR_PULL_ALLOC(ndr, *r->out.info);
9935                 } else {
9936                         *r->out.info = NULL;
9937                 }
9938                 if (*r->out.info) {
9939                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
9940                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
9941                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
9942                         NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9943                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
9944                 }
9945                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9946                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9947         }
9948         return NDR_ERR_SUCCESS;
9949 }
9950
9951 _PUBLIC_ void ndr_print_samr_QueryUserInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryUserInfo2 *r)
9952 {
9953         ndr_print_struct(ndr, name, "samr_QueryUserInfo2");
9954         ndr->depth++;
9955         if (flags & NDR_SET_VALUES) {
9956                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9957         }
9958         if (flags & NDR_IN) {
9959                 ndr_print_struct(ndr, "in", "samr_QueryUserInfo2");
9960                 ndr->depth++;
9961                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9962                 ndr->depth++;
9963                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9964                 ndr->depth--;
9965                 ndr_print_uint16(ndr, "level", r->in.level);
9966                 ndr->depth--;
9967         }
9968         if (flags & NDR_OUT) {
9969                 ndr_print_struct(ndr, "out", "samr_QueryUserInfo2");
9970                 ndr->depth++;
9971                 ndr_print_ptr(ndr, "info", r->out.info);
9972                 ndr->depth++;
9973                 ndr_print_ptr(ndr, "info", *r->out.info);
9974                 ndr->depth++;
9975                 if (*r->out.info) {
9976                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
9977                         ndr_print_samr_UserInfo(ndr, "info", *r->out.info);
9978                 }
9979                 ndr->depth--;
9980                 ndr->depth--;
9981                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9982                 ndr->depth--;
9983         }
9984         ndr->depth--;
9985 }
9986
9987 static enum ndr_err_code ndr_push_samr_QueryDisplayInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo2 *r)
9988 {
9989         if (flags & NDR_IN) {
9990                 if (r->in.domain_handle == NULL) {
9991                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9992                 }
9993                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9994                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9995                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));
9996                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));
9997                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
9998         }
9999         if (flags & NDR_OUT) {
10000                 if (r->out.total_size == NULL) {
10001                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10002                 }
10003                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));
10004                 if (r->out.returned_size == NULL) {
10005                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10006                 }
10007                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));
10008                 if (r->out.info == NULL) {
10009                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10010                 }
10011                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
10012                 NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
10013                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10014         }
10015         return NDR_ERR_SUCCESS;
10016 }
10017
10018 static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo2 *r)
10019 {
10020         TALLOC_CTX *_mem_save_domain_handle_0;
10021         TALLOC_CTX *_mem_save_total_size_0;
10022         TALLOC_CTX *_mem_save_returned_size_0;
10023         TALLOC_CTX *_mem_save_info_0;
10024         if (flags & NDR_IN) {
10025                 ZERO_STRUCT(r->out);
10026
10027                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10028                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10029                 }
10030                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10031                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10032                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10033                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10034                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10035                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));
10036                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));
10037                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
10038                 NDR_PULL_ALLOC(ndr, r->out.total_size);
10039                 ZERO_STRUCTP(r->out.total_size);
10040                 NDR_PULL_ALLOC(ndr, r->out.returned_size);
10041                 ZERO_STRUCTP(r->out.returned_size);
10042                 NDR_PULL_ALLOC(ndr, r->out.info);
10043                 ZERO_STRUCTP(r->out.info);
10044         }
10045         if (flags & NDR_OUT) {
10046                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10047                         NDR_PULL_ALLOC(ndr, r->out.total_size);
10048                 }
10049                 _mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
10050                 NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);
10051                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));
10052                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);
10053                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10054                         NDR_PULL_ALLOC(ndr, r->out.returned_size);
10055                 }
10056                 _mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
10057                 NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);
10058                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));
10059                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);
10060                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10061                         NDR_PULL_ALLOC(ndr, r->out.info);
10062                 }
10063                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10064                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
10065                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
10066                 NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
10067                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
10068                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10069         }
10070         return NDR_ERR_SUCCESS;
10071 }
10072
10073 _PUBLIC_ void ndr_print_samr_QueryDisplayInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo2 *r)
10074 {
10075         ndr_print_struct(ndr, name, "samr_QueryDisplayInfo2");
10076         ndr->depth++;
10077         if (flags & NDR_SET_VALUES) {
10078                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10079         }
10080         if (flags & NDR_IN) {
10081                 ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo2");
10082                 ndr->depth++;
10083                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10084                 ndr->depth++;
10085                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10086                 ndr->depth--;
10087                 ndr_print_uint16(ndr, "level", r->in.level);
10088                 ndr_print_uint32(ndr, "start_idx", r->in.start_idx);
10089                 ndr_print_uint32(ndr, "max_entries", r->in.max_entries);
10090                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
10091                 ndr->depth--;
10092         }
10093         if (flags & NDR_OUT) {
10094                 ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo2");
10095                 ndr->depth++;
10096                 ndr_print_ptr(ndr, "total_size", r->out.total_size);
10097                 ndr->depth++;
10098                 ndr_print_uint32(ndr, "total_size", *r->out.total_size);
10099                 ndr->depth--;
10100                 ndr_print_ptr(ndr, "returned_size", r->out.returned_size);
10101                 ndr->depth++;
10102                 ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);
10103                 ndr->depth--;
10104                 ndr_print_ptr(ndr, "info", r->out.info);
10105                 ndr->depth++;
10106                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
10107                 ndr_print_samr_DispInfo(ndr, "info", r->out.info);
10108                 ndr->depth--;
10109                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10110                 ndr->depth--;
10111         }
10112         ndr->depth--;
10113 }
10114
10115 static enum ndr_err_code ndr_push_samr_GetDisplayEnumerationIndex2(struct ndr_push *ndr, int flags, const struct samr_GetDisplayEnumerationIndex2 *r)
10116 {
10117         if (flags & NDR_IN) {
10118                 if (r->in.domain_handle == NULL) {
10119                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10120                 }
10121                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10122                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
10123                 if (r->in.name == NULL) {
10124                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10125                 }
10126                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
10127         }
10128         if (flags & NDR_OUT) {
10129                 if (r->out.idx == NULL) {
10130                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10131                 }
10132                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.idx));
10133                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10134         }
10135         return NDR_ERR_SUCCESS;
10136 }
10137
10138 static enum ndr_err_code ndr_pull_samr_GetDisplayEnumerationIndex2(struct ndr_pull *ndr, int flags, struct samr_GetDisplayEnumerationIndex2 *r)
10139 {
10140         TALLOC_CTX *_mem_save_domain_handle_0;
10141         TALLOC_CTX *_mem_save_name_0;
10142         TALLOC_CTX *_mem_save_idx_0;
10143         if (flags & NDR_IN) {
10144                 ZERO_STRUCT(r->out);
10145
10146                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10147                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10148                 }
10149                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10150                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10151                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10152                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10153                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10154                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10155                         NDR_PULL_ALLOC(ndr, r->in.name);
10156                 }
10157                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10158                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
10159                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
10160                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
10161                 NDR_PULL_ALLOC(ndr, r->out.idx);
10162                 ZERO_STRUCTP(r->out.idx);
10163         }
10164         if (flags & NDR_OUT) {
10165                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10166                         NDR_PULL_ALLOC(ndr, r->out.idx);
10167                 }
10168                 _mem_save_idx_0 = NDR_PULL_GET_MEM_CTX(ndr);
10169                 NDR_PULL_SET_MEM_CTX(ndr, r->out.idx, LIBNDR_FLAG_REF_ALLOC);
10170                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.idx));
10171                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_idx_0, LIBNDR_FLAG_REF_ALLOC);
10172                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10173         }
10174         return NDR_ERR_SUCCESS;
10175 }
10176
10177 _PUBLIC_ void ndr_print_samr_GetDisplayEnumerationIndex2(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDisplayEnumerationIndex2 *r)
10178 {
10179         ndr_print_struct(ndr, name, "samr_GetDisplayEnumerationIndex2");
10180         ndr->depth++;
10181         if (flags & NDR_SET_VALUES) {
10182                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10183         }
10184         if (flags & NDR_IN) {
10185                 ndr_print_struct(ndr, "in", "samr_GetDisplayEnumerationIndex2");
10186                 ndr->depth++;
10187                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10188                 ndr->depth++;
10189                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10190                 ndr->depth--;
10191                 ndr_print_uint16(ndr, "level", r->in.level);
10192                 ndr_print_ptr(ndr, "name", r->in.name);
10193                 ndr->depth++;
10194                 ndr_print_lsa_String(ndr, "name", r->in.name);
10195                 ndr->depth--;
10196                 ndr->depth--;
10197         }
10198         if (flags & NDR_OUT) {
10199                 ndr_print_struct(ndr, "out", "samr_GetDisplayEnumerationIndex2");
10200                 ndr->depth++;
10201                 ndr_print_ptr(ndr, "idx", r->out.idx);
10202                 ndr->depth++;
10203                 ndr_print_uint32(ndr, "idx", *r->out.idx);
10204                 ndr->depth--;
10205                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10206                 ndr->depth--;
10207         }
10208         ndr->depth--;
10209 }
10210
10211 static enum ndr_err_code ndr_push_samr_CreateUser2(struct ndr_push *ndr, int flags, const struct samr_CreateUser2 *r)
10212 {
10213         if (flags & NDR_IN) {
10214                 if (r->in.domain_handle == NULL) {
10215                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10216                 }
10217                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10218                 if (r->in.account_name == NULL) {
10219                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10220                 }
10221                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
10222                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->in.acct_flags));
10223                 NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
10224         }
10225         if (flags & NDR_OUT) {
10226                 if (r->out.user_handle == NULL) {
10227                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10228                 }
10229                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
10230                 if (r->out.access_granted == NULL) {
10231                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10232                 }
10233                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.access_granted));
10234                 if (r->out.rid == NULL) {
10235                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10236                 }
10237                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
10238                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10239         }
10240         return NDR_ERR_SUCCESS;
10241 }
10242
10243 static enum ndr_err_code ndr_pull_samr_CreateUser2(struct ndr_pull *ndr, int flags, struct samr_CreateUser2 *r)
10244 {
10245         TALLOC_CTX *_mem_save_domain_handle_0;
10246         TALLOC_CTX *_mem_save_account_name_0;
10247         TALLOC_CTX *_mem_save_user_handle_0;
10248         TALLOC_CTX *_mem_save_access_granted_0;
10249         TALLOC_CTX *_mem_save_rid_0;
10250         if (flags & NDR_IN) {
10251                 ZERO_STRUCT(r->out);
10252
10253                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10254                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10255                 }
10256                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10257                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10258                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10259                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10260                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10261                         NDR_PULL_ALLOC(ndr, r->in.account_name);
10262                 }
10263                 _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10264                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account_name, LIBNDR_FLAG_REF_ALLOC);
10265                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
10266                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, LIBNDR_FLAG_REF_ALLOC);
10267                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->in.acct_flags));
10268                 NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
10269                 NDR_PULL_ALLOC(ndr, r->out.user_handle);
10270                 ZERO_STRUCTP(r->out.user_handle);
10271                 NDR_PULL_ALLOC(ndr, r->out.access_granted);
10272                 ZERO_STRUCTP(r->out.access_granted);
10273                 NDR_PULL_ALLOC(ndr, r->out.rid);
10274                 ZERO_STRUCTP(r->out.rid);
10275         }
10276         if (flags & NDR_OUT) {
10277                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10278                         NDR_PULL_ALLOC(ndr, r->out.user_handle);
10279                 }
10280                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10281                 NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
10282                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
10283                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
10284                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10285                         NDR_PULL_ALLOC(ndr, r->out.access_granted);
10286                 }
10287                 _mem_save_access_granted_0 = NDR_PULL_GET_MEM_CTX(ndr);
10288                 NDR_PULL_SET_MEM_CTX(ndr, r->out.access_granted, LIBNDR_FLAG_REF_ALLOC);
10289                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.access_granted));
10290                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_access_granted_0, LIBNDR_FLAG_REF_ALLOC);
10291                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10292                         NDR_PULL_ALLOC(ndr, r->out.rid);
10293                 }
10294                 _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
10295                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
10296                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
10297                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
10298                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10299         }
10300         return NDR_ERR_SUCCESS;
10301 }
10302
10303 _PUBLIC_ void ndr_print_samr_CreateUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateUser2 *r)
10304 {
10305         ndr_print_struct(ndr, name, "samr_CreateUser2");
10306         ndr->depth++;
10307         if (flags & NDR_SET_VALUES) {
10308                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10309         }
10310         if (flags & NDR_IN) {
10311                 ndr_print_struct(ndr, "in", "samr_CreateUser2");
10312                 ndr->depth++;
10313                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10314                 ndr->depth++;
10315                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10316                 ndr->depth--;
10317                 ndr_print_ptr(ndr, "account_name", r->in.account_name);
10318                 ndr->depth++;
10319                 ndr_print_lsa_String(ndr, "account_name", r->in.account_name);
10320                 ndr->depth--;
10321                 ndr_print_samr_AcctFlags(ndr, "acct_flags", r->in.acct_flags);
10322                 ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);
10323                 ndr->depth--;
10324         }
10325         if (flags & NDR_OUT) {
10326                 ndr_print_struct(ndr, "out", "samr_CreateUser2");
10327                 ndr->depth++;
10328                 ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
10329                 ndr->depth++;
10330                 ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
10331                 ndr->depth--;
10332                 ndr_print_ptr(ndr, "access_granted", r->out.access_granted);
10333                 ndr->depth++;
10334                 ndr_print_uint32(ndr, "access_granted", *r->out.access_granted);
10335                 ndr->depth--;
10336                 ndr_print_ptr(ndr, "rid", r->out.rid);
10337                 ndr->depth++;
10338                 ndr_print_uint32(ndr, "rid", *r->out.rid);
10339                 ndr->depth--;
10340                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10341                 ndr->depth--;
10342         }
10343         ndr->depth--;
10344 }
10345
10346 static enum ndr_err_code ndr_push_samr_QueryDisplayInfo3(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo3 *r)
10347 {
10348         if (flags & NDR_IN) {
10349                 if (r->in.domain_handle == NULL) {
10350                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10351                 }
10352                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10353                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
10354                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));
10355                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));
10356                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
10357         }
10358         if (flags & NDR_OUT) {
10359                 if (r->out.total_size == NULL) {
10360                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10361                 }
10362                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));
10363                 if (r->out.returned_size == NULL) {
10364                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10365                 }
10366                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));
10367                 if (r->out.info == NULL) {
10368                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10369                 }
10370                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
10371                 NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
10372                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10373         }
10374         return NDR_ERR_SUCCESS;
10375 }
10376
10377 static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo3(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo3 *r)
10378 {
10379         TALLOC_CTX *_mem_save_domain_handle_0;
10380         TALLOC_CTX *_mem_save_total_size_0;
10381         TALLOC_CTX *_mem_save_returned_size_0;
10382         TALLOC_CTX *_mem_save_info_0;
10383         if (flags & NDR_IN) {
10384                 ZERO_STRUCT(r->out);
10385
10386                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10387                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10388                 }
10389                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10390                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10391                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10392                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10393                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10394                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));
10395                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));
10396                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
10397                 NDR_PULL_ALLOC(ndr, r->out.total_size);
10398                 ZERO_STRUCTP(r->out.total_size);
10399                 NDR_PULL_ALLOC(ndr, r->out.returned_size);
10400                 ZERO_STRUCTP(r->out.returned_size);
10401                 NDR_PULL_ALLOC(ndr, r->out.info);
10402                 ZERO_STRUCTP(r->out.info);
10403         }
10404         if (flags & NDR_OUT) {
10405                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10406                         NDR_PULL_ALLOC(ndr, r->out.total_size);
10407                 }
10408                 _mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
10409                 NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);
10410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));
10411                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);
10412                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10413                         NDR_PULL_ALLOC(ndr, r->out.returned_size);
10414                 }
10415                 _mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
10416                 NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);
10417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));
10418                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);
10419                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10420                         NDR_PULL_ALLOC(ndr, r->out.info);
10421                 }
10422                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10423                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
10424                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
10425                 NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
10426                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
10427                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10428         }
10429         return NDR_ERR_SUCCESS;
10430 }
10431
10432 _PUBLIC_ void ndr_print_samr_QueryDisplayInfo3(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo3 *r)
10433 {
10434         ndr_print_struct(ndr, name, "samr_QueryDisplayInfo3");
10435         ndr->depth++;
10436         if (flags & NDR_SET_VALUES) {
10437                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10438         }
10439         if (flags & NDR_IN) {
10440                 ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo3");
10441                 ndr->depth++;
10442                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10443                 ndr->depth++;
10444                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10445                 ndr->depth--;
10446                 ndr_print_uint16(ndr, "level", r->in.level);
10447                 ndr_print_uint32(ndr, "start_idx", r->in.start_idx);
10448                 ndr_print_uint32(ndr, "max_entries", r->in.max_entries);
10449                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
10450                 ndr->depth--;
10451         }
10452         if (flags & NDR_OUT) {
10453                 ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo3");
10454                 ndr->depth++;
10455                 ndr_print_ptr(ndr, "total_size", r->out.total_size);
10456                 ndr->depth++;
10457                 ndr_print_uint32(ndr, "total_size", *r->out.total_size);
10458                 ndr->depth--;
10459                 ndr_print_ptr(ndr, "returned_size", r->out.returned_size);
10460                 ndr->depth++;
10461                 ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);
10462                 ndr->depth--;
10463                 ndr_print_ptr(ndr, "info", r->out.info);
10464                 ndr->depth++;
10465                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
10466                 ndr_print_samr_DispInfo(ndr, "info", r->out.info);
10467                 ndr->depth--;
10468                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10469                 ndr->depth--;
10470         }
10471         ndr->depth--;
10472 }
10473
10474 static enum ndr_err_code ndr_push_samr_AddMultipleMembersToAlias(struct ndr_push *ndr, int flags, const struct samr_AddMultipleMembersToAlias *r)
10475 {
10476         if (flags & NDR_IN) {
10477                 if (r->in.alias_handle == NULL) {
10478                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10479                 }
10480                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
10481                 if (r->in.sids == NULL) {
10482                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10483                 }
10484                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10485         }
10486         if (flags & NDR_OUT) {
10487                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10488         }
10489         return NDR_ERR_SUCCESS;
10490 }
10491
10492 static enum ndr_err_code ndr_pull_samr_AddMultipleMembersToAlias(struct ndr_pull *ndr, int flags, struct samr_AddMultipleMembersToAlias *r)
10493 {
10494         TALLOC_CTX *_mem_save_alias_handle_0;
10495         TALLOC_CTX *_mem_save_sids_0;
10496         if (flags & NDR_IN) {
10497                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10498                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
10499                 }
10500                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10501                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
10502                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
10503                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
10504                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10505                         NDR_PULL_ALLOC(ndr, r->in.sids);
10506                 }
10507                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
10508                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
10509                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10510                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
10511         }
10512         if (flags & NDR_OUT) {
10513                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10514         }
10515         return NDR_ERR_SUCCESS;
10516 }
10517
10518 _PUBLIC_ void ndr_print_samr_AddMultipleMembersToAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddMultipleMembersToAlias *r)
10519 {
10520         ndr_print_struct(ndr, name, "samr_AddMultipleMembersToAlias");
10521         ndr->depth++;
10522         if (flags & NDR_SET_VALUES) {
10523                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10524         }
10525         if (flags & NDR_IN) {
10526                 ndr_print_struct(ndr, "in", "samr_AddMultipleMembersToAlias");
10527                 ndr->depth++;
10528                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
10529                 ndr->depth++;
10530                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
10531                 ndr->depth--;
10532                 ndr_print_ptr(ndr, "sids", r->in.sids);
10533                 ndr->depth++;
10534                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
10535                 ndr->depth--;
10536                 ndr->depth--;
10537         }
10538         if (flags & NDR_OUT) {
10539                 ndr_print_struct(ndr, "out", "samr_AddMultipleMembersToAlias");
10540                 ndr->depth++;
10541                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10542                 ndr->depth--;
10543         }
10544         ndr->depth--;
10545 }
10546
10547 static enum ndr_err_code ndr_push_samr_RemoveMultipleMembersFromAlias(struct ndr_push *ndr, int flags, const struct samr_RemoveMultipleMembersFromAlias *r)
10548 {
10549         if (flags & NDR_IN) {
10550                 if (r->in.alias_handle == NULL) {
10551                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10552                 }
10553                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
10554                 if (r->in.sids == NULL) {
10555                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10556                 }
10557                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10558         }
10559         if (flags & NDR_OUT) {
10560                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10561         }
10562         return NDR_ERR_SUCCESS;
10563 }
10564
10565 static enum ndr_err_code ndr_pull_samr_RemoveMultipleMembersFromAlias(struct ndr_pull *ndr, int flags, struct samr_RemoveMultipleMembersFromAlias *r)
10566 {
10567         TALLOC_CTX *_mem_save_alias_handle_0;
10568         TALLOC_CTX *_mem_save_sids_0;
10569         if (flags & NDR_IN) {
10570                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10571                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
10572                 }
10573                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10574                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
10575                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
10576                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
10577                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10578                         NDR_PULL_ALLOC(ndr, r->in.sids);
10579                 }
10580                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
10581                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
10582                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10583                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
10584         }
10585         if (flags & NDR_OUT) {
10586                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10587         }
10588         return NDR_ERR_SUCCESS;
10589 }
10590
10591 _PUBLIC_ void ndr_print_samr_RemoveMultipleMembersFromAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_RemoveMultipleMembersFromAlias *r)
10592 {
10593         ndr_print_struct(ndr, name, "samr_RemoveMultipleMembersFromAlias");
10594         ndr->depth++;
10595         if (flags & NDR_SET_VALUES) {
10596                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10597         }
10598         if (flags & NDR_IN) {
10599                 ndr_print_struct(ndr, "in", "samr_RemoveMultipleMembersFromAlias");
10600                 ndr->depth++;
10601                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
10602                 ndr->depth++;
10603                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
10604                 ndr->depth--;
10605                 ndr_print_ptr(ndr, "sids", r->in.sids);
10606                 ndr->depth++;
10607                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
10608                 ndr->depth--;
10609                 ndr->depth--;
10610         }
10611         if (flags & NDR_OUT) {
10612                 ndr_print_struct(ndr, "out", "samr_RemoveMultipleMembersFromAlias");
10613                 ndr->depth++;
10614                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10615                 ndr->depth--;
10616         }
10617         ndr->depth--;
10618 }
10619
10620 static enum ndr_err_code ndr_push_samr_OemChangePasswordUser2(struct ndr_push *ndr, int flags, const struct samr_OemChangePasswordUser2 *r)
10621 {
10622         if (flags & NDR_IN) {
10623                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
10624                 if (r->in.server) {
10625                         NDR_CHECK(ndr_push_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
10626                 }
10627                 if (r->in.account == NULL) {
10628                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10629                 }
10630                 NDR_CHECK(ndr_push_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
10631                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
10632                 if (r->in.password) {
10633                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password));
10634                 }
10635                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hash));
10636                 if (r->in.hash) {
10637                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.hash));
10638                 }
10639         }
10640         if (flags & NDR_OUT) {
10641                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10642         }
10643         return NDR_ERR_SUCCESS;
10644 }
10645
10646 static enum ndr_err_code ndr_pull_samr_OemChangePasswordUser2(struct ndr_pull *ndr, int flags, struct samr_OemChangePasswordUser2 *r)
10647 {
10648         uint32_t _ptr_server;
10649         uint32_t _ptr_password;
10650         uint32_t _ptr_hash;
10651         TALLOC_CTX *_mem_save_server_0;
10652         TALLOC_CTX *_mem_save_account_0;
10653         TALLOC_CTX *_mem_save_password_0;
10654         TALLOC_CTX *_mem_save_hash_0;
10655         if (flags & NDR_IN) {
10656                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
10657                 if (_ptr_server) {
10658                         NDR_PULL_ALLOC(ndr, r->in.server);
10659                 } else {
10660                         r->in.server = NULL;
10661                 }
10662                 if (r->in.server) {
10663                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
10664                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
10665                         NDR_CHECK(ndr_pull_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
10666                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
10667                 }
10668                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10669                         NDR_PULL_ALLOC(ndr, r->in.account);
10670                 }
10671                 _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
10672                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);
10673                 NDR_CHECK(ndr_pull_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
10674                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);
10675                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
10676                 if (_ptr_password) {
10677                         NDR_PULL_ALLOC(ndr, r->in.password);
10678                 } else {
10679                         r->in.password = NULL;
10680                 }
10681                 if (r->in.password) {
10682                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
10683                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
10684                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password));
10685                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
10686                 }
10687                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hash));
10688                 if (_ptr_hash) {
10689                         NDR_PULL_ALLOC(ndr, r->in.hash);
10690                 } else {
10691                         r->in.hash = NULL;
10692                 }
10693                 if (r->in.hash) {
10694                         _mem_save_hash_0 = NDR_PULL_GET_MEM_CTX(ndr);
10695                         NDR_PULL_SET_MEM_CTX(ndr, r->in.hash, 0);
10696                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.hash));
10697                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hash_0, 0);
10698                 }
10699         }
10700         if (flags & NDR_OUT) {
10701                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10702         }
10703         return NDR_ERR_SUCCESS;
10704 }
10705
10706 _PUBLIC_ void ndr_print_samr_OemChangePasswordUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_OemChangePasswordUser2 *r)
10707 {
10708         ndr_print_struct(ndr, name, "samr_OemChangePasswordUser2");
10709         ndr->depth++;
10710         if (flags & NDR_SET_VALUES) {
10711                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10712         }
10713         if (flags & NDR_IN) {
10714                 ndr_print_struct(ndr, "in", "samr_OemChangePasswordUser2");
10715                 ndr->depth++;
10716                 ndr_print_ptr(ndr, "server", r->in.server);
10717                 ndr->depth++;
10718                 if (r->in.server) {
10719                         ndr_print_lsa_AsciiString(ndr, "server", r->in.server);
10720                 }
10721                 ndr->depth--;
10722                 ndr_print_ptr(ndr, "account", r->in.account);
10723                 ndr->depth++;
10724                 ndr_print_lsa_AsciiString(ndr, "account", r->in.account);
10725                 ndr->depth--;
10726                 ndr_print_ptr(ndr, "password", r->in.password);
10727                 ndr->depth++;
10728                 if (r->in.password) {
10729                         ndr_print_samr_CryptPassword(ndr, "password", r->in.password);
10730                 }
10731                 ndr->depth--;
10732                 ndr_print_ptr(ndr, "hash", r->in.hash);
10733                 ndr->depth++;
10734                 if (r->in.hash) {
10735                         ndr_print_samr_Password(ndr, "hash", r->in.hash);
10736                 }
10737                 ndr->depth--;
10738                 ndr->depth--;
10739         }
10740         if (flags & NDR_OUT) {
10741                 ndr_print_struct(ndr, "out", "samr_OemChangePasswordUser2");
10742                 ndr->depth++;
10743                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10744                 ndr->depth--;
10745         }
10746         ndr->depth--;
10747 }
10748
10749 static enum ndr_err_code ndr_push_samr_ChangePasswordUser2(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser2 *r)
10750 {
10751         if (flags & NDR_IN) {
10752                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
10753                 if (r->in.server) {
10754                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
10755                 }
10756                 if (r->in.account == NULL) {
10757                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10758                 }
10759                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
10760                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_password));
10761                 if (r->in.nt_password) {
10762                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
10763                 }
10764                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_verifier));
10765                 if (r->in.nt_verifier) {
10766                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
10767                 }
10768                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_change));
10769                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_password));
10770                 if (r->in.lm_password) {
10771                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
10772                 }
10773                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_verifier));
10774                 if (r->in.lm_verifier) {
10775                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
10776                 }
10777         }
10778         if (flags & NDR_OUT) {
10779                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10780         }
10781         return NDR_ERR_SUCCESS;
10782 }
10783
10784 static enum ndr_err_code ndr_pull_samr_ChangePasswordUser2(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser2 *r)
10785 {
10786         uint32_t _ptr_server;
10787         uint32_t _ptr_nt_password;
10788         uint32_t _ptr_nt_verifier;
10789         uint32_t _ptr_lm_password;
10790         uint32_t _ptr_lm_verifier;
10791         TALLOC_CTX *_mem_save_server_0;
10792         TALLOC_CTX *_mem_save_account_0;
10793         TALLOC_CTX *_mem_save_nt_password_0;
10794         TALLOC_CTX *_mem_save_nt_verifier_0;
10795         TALLOC_CTX *_mem_save_lm_password_0;
10796         TALLOC_CTX *_mem_save_lm_verifier_0;
10797         if (flags & NDR_IN) {
10798                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
10799                 if (_ptr_server) {
10800                         NDR_PULL_ALLOC(ndr, r->in.server);
10801                 } else {
10802                         r->in.server = NULL;
10803                 }
10804                 if (r->in.server) {
10805                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
10806                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
10807                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
10808                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
10809                 }
10810                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10811                         NDR_PULL_ALLOC(ndr, r->in.account);
10812                 }
10813                 _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
10814                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);
10815                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
10816                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);
10817                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_password));
10818                 if (_ptr_nt_password) {
10819                         NDR_PULL_ALLOC(ndr, r->in.nt_password);
10820                 } else {
10821                         r->in.nt_password = NULL;
10822                 }
10823                 if (r->in.nt_password) {
10824                         _mem_save_nt_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
10825                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_password, 0);
10826                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
10827                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_password_0, 0);
10828                 }
10829                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_verifier));
10830                 if (_ptr_nt_verifier) {
10831                         NDR_PULL_ALLOC(ndr, r->in.nt_verifier);
10832                 } else {
10833                         r->in.nt_verifier = NULL;
10834                 }
10835                 if (r->in.nt_verifier) {
10836                         _mem_save_nt_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
10837                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_verifier, 0);
10838                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
10839                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_verifier_0, 0);
10840                 }
10841                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_change));
10842                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_password));
10843                 if (_ptr_lm_password) {
10844                         NDR_PULL_ALLOC(ndr, r->in.lm_password);
10845                 } else {
10846                         r->in.lm_password = NULL;
10847                 }
10848                 if (r->in.lm_password) {
10849                         _mem_save_lm_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
10850                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_password, 0);
10851                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
10852                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_password_0, 0);
10853                 }
10854                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_verifier));
10855                 if (_ptr_lm_verifier) {
10856                         NDR_PULL_ALLOC(ndr, r->in.lm_verifier);
10857                 } else {
10858                         r->in.lm_verifier = NULL;
10859                 }
10860                 if (r->in.lm_verifier) {
10861                         _mem_save_lm_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
10862                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_verifier, 0);
10863                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
10864                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_verifier_0, 0);
10865                 }
10866         }
10867         if (flags & NDR_OUT) {
10868                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10869         }
10870         return NDR_ERR_SUCCESS;
10871 }
10872
10873 _PUBLIC_ void ndr_print_samr_ChangePasswordUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser2 *r)
10874 {
10875         ndr_print_struct(ndr, name, "samr_ChangePasswordUser2");
10876         ndr->depth++;
10877         if (flags & NDR_SET_VALUES) {
10878                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10879         }
10880         if (flags & NDR_IN) {
10881                 ndr_print_struct(ndr, "in", "samr_ChangePasswordUser2");
10882                 ndr->depth++;
10883                 ndr_print_ptr(ndr, "server", r->in.server);
10884                 ndr->depth++;
10885                 if (r->in.server) {
10886                         ndr_print_lsa_String(ndr, "server", r->in.server);
10887                 }
10888                 ndr->depth--;
10889                 ndr_print_ptr(ndr, "account", r->in.account);
10890                 ndr->depth++;
10891                 ndr_print_lsa_String(ndr, "account", r->in.account);
10892                 ndr->depth--;
10893                 ndr_print_ptr(ndr, "nt_password", r->in.nt_password);
10894                 ndr->depth++;
10895                 if (r->in.nt_password) {
10896                         ndr_print_samr_CryptPassword(ndr, "nt_password", r->in.nt_password);
10897                 }
10898                 ndr->depth--;
10899                 ndr_print_ptr(ndr, "nt_verifier", r->in.nt_verifier);
10900                 ndr->depth++;
10901                 if (r->in.nt_verifier) {
10902                         ndr_print_samr_Password(ndr, "nt_verifier", r->in.nt_verifier);
10903                 }
10904                 ndr->depth--;
10905                 ndr_print_uint8(ndr, "lm_change", r->in.lm_change);
10906                 ndr_print_ptr(ndr, "lm_password", r->in.lm_password);
10907                 ndr->depth++;
10908                 if (r->in.lm_password) {
10909                         ndr_print_samr_CryptPassword(ndr, "lm_password", r->in.lm_password);
10910                 }
10911                 ndr->depth--;
10912                 ndr_print_ptr(ndr, "lm_verifier", r->in.lm_verifier);
10913                 ndr->depth++;
10914                 if (r->in.lm_verifier) {
10915                         ndr_print_samr_Password(ndr, "lm_verifier", r->in.lm_verifier);
10916                 }
10917                 ndr->depth--;
10918                 ndr->depth--;
10919         }
10920         if (flags & NDR_OUT) {
10921                 ndr_print_struct(ndr, "out", "samr_ChangePasswordUser2");
10922                 ndr->depth++;
10923                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10924                 ndr->depth--;
10925         }
10926         ndr->depth--;
10927 }
10928
10929 static enum ndr_err_code ndr_push_samr_GetDomPwInfo(struct ndr_push *ndr, int flags, const struct samr_GetDomPwInfo *r)
10930 {
10931         if (flags & NDR_IN) {
10932                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.domain_name));
10933                 if (r->in.domain_name) {
10934                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
10935                 }
10936         }
10937         if (flags & NDR_OUT) {
10938                 if (r->out.info == NULL) {
10939                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10940                 }
10941                 NDR_CHECK(ndr_push_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
10942                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10943         }
10944         return NDR_ERR_SUCCESS;
10945 }
10946
10947 static enum ndr_err_code ndr_pull_samr_GetDomPwInfo(struct ndr_pull *ndr, int flags, struct samr_GetDomPwInfo *r)
10948 {
10949         uint32_t _ptr_domain_name;
10950         TALLOC_CTX *_mem_save_domain_name_0;
10951         TALLOC_CTX *_mem_save_info_0;
10952         if (flags & NDR_IN) {
10953                 ZERO_STRUCT(r->out);
10954
10955                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
10956                 if (_ptr_domain_name) {
10957                         NDR_PULL_ALLOC(ndr, r->in.domain_name);
10958                 } else {
10959                         r->in.domain_name = NULL;
10960                 }
10961                 if (r->in.domain_name) {
10962                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10963                         NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_name, 0);
10964                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
10965                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
10966                 }
10967                 NDR_PULL_ALLOC(ndr, r->out.info);
10968                 ZERO_STRUCTP(r->out.info);
10969         }
10970         if (flags & NDR_OUT) {
10971                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10972                         NDR_PULL_ALLOC(ndr, r->out.info);
10973                 }
10974                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10975                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
10976                 NDR_CHECK(ndr_pull_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
10977                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
10978                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10979         }
10980         return NDR_ERR_SUCCESS;
10981 }
10982
10983 _PUBLIC_ void ndr_print_samr_GetDomPwInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDomPwInfo *r)
10984 {
10985         ndr_print_struct(ndr, name, "samr_GetDomPwInfo");
10986         ndr->depth++;
10987         if (flags & NDR_SET_VALUES) {
10988                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10989         }
10990         if (flags & NDR_IN) {
10991                 ndr_print_struct(ndr, "in", "samr_GetDomPwInfo");
10992                 ndr->depth++;
10993                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
10994                 ndr->depth++;
10995                 if (r->in.domain_name) {
10996                         ndr_print_lsa_String(ndr, "domain_name", r->in.domain_name);
10997                 }
10998                 ndr->depth--;
10999                 ndr->depth--;
11000         }
11001         if (flags & NDR_OUT) {
11002                 ndr_print_struct(ndr, "out", "samr_GetDomPwInfo");
11003                 ndr->depth++;
11004                 ndr_print_ptr(ndr, "info", r->out.info);
11005                 ndr->depth++;
11006                 ndr_print_samr_PwInfo(ndr, "info", r->out.info);
11007                 ndr->depth--;
11008                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11009                 ndr->depth--;
11010         }
11011         ndr->depth--;
11012 }
11013
11014 static enum ndr_err_code ndr_push_samr_Connect2(struct ndr_push *ndr, int flags, const struct samr_Connect2 *r)
11015 {
11016         if (flags & NDR_IN) {
11017                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
11018                 if (r->in.system_name) {
11019                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11020                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11021                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11022                         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));
11023                 }
11024                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
11025         }
11026         if (flags & NDR_OUT) {
11027                 if (r->out.connect_handle == NULL) {
11028                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11029                 }
11030                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11031                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11032         }
11033         return NDR_ERR_SUCCESS;
11034 }
11035
11036 static enum ndr_err_code ndr_pull_samr_Connect2(struct ndr_pull *ndr, int flags, struct samr_Connect2 *r)
11037 {
11038         uint32_t _ptr_system_name;
11039         TALLOC_CTX *_mem_save_system_name_0;
11040         TALLOC_CTX *_mem_save_connect_handle_0;
11041         if (flags & NDR_IN) {
11042                 ZERO_STRUCT(r->out);
11043
11044                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
11045                 if (_ptr_system_name) {
11046                         NDR_PULL_ALLOC(ndr, r->in.system_name);
11047                 } else {
11048                         r->in.system_name = NULL;
11049                 }
11050                 if (r->in.system_name) {
11051                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11052                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
11053                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
11054                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
11055                         if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
11056                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.system_name), ndr_get_array_length(ndr, &r->in.system_name));
11057                         }
11058                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
11059                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t), CH_UTF16));
11060                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
11061                 }
11062                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
11063                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11064                 ZERO_STRUCTP(r->out.connect_handle);
11065         }
11066         if (flags & NDR_OUT) {
11067                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11068                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11069                 }
11070                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11071                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
11072                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11073                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
11074                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11075         }
11076         return NDR_ERR_SUCCESS;
11077 }
11078
11079 _PUBLIC_ void ndr_print_samr_Connect2(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect2 *r)
11080 {
11081         ndr_print_struct(ndr, name, "samr_Connect2");
11082         ndr->depth++;
11083         if (flags & NDR_SET_VALUES) {
11084                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11085         }
11086         if (flags & NDR_IN) {
11087                 ndr_print_struct(ndr, "in", "samr_Connect2");
11088                 ndr->depth++;
11089                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
11090                 ndr->depth++;
11091                 if (r->in.system_name) {
11092                         ndr_print_string(ndr, "system_name", r->in.system_name);
11093                 }
11094                 ndr->depth--;
11095                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
11096                 ndr->depth--;
11097         }
11098         if (flags & NDR_OUT) {
11099                 ndr_print_struct(ndr, "out", "samr_Connect2");
11100                 ndr->depth++;
11101                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
11102                 ndr->depth++;
11103                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
11104                 ndr->depth--;
11105                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11106                 ndr->depth--;
11107         }
11108         ndr->depth--;
11109 }
11110
11111 _PUBLIC_ enum ndr_err_code ndr_push_samr_SetUserInfo2(struct ndr_push *ndr, int flags, const struct samr_SetUserInfo2 *r)
11112 {
11113         if (flags & NDR_IN) {
11114                 if (r->in.user_handle == NULL) {
11115                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11116                 }
11117                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
11118                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
11119                 if (r->in.info == NULL) {
11120                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11121                 }
11122                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
11123                 NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
11124         }
11125         if (flags & NDR_OUT) {
11126                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11127         }
11128         return NDR_ERR_SUCCESS;
11129 }
11130
11131 _PUBLIC_ enum ndr_err_code ndr_pull_samr_SetUserInfo2(struct ndr_pull *ndr, int flags, struct samr_SetUserInfo2 *r)
11132 {
11133         TALLOC_CTX *_mem_save_user_handle_0;
11134         TALLOC_CTX *_mem_save_info_0;
11135         if (flags & NDR_IN) {
11136                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11137                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
11138                 }
11139                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11140                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
11141                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
11142                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
11143                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
11144                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11145                         NDR_PULL_ALLOC(ndr, r->in.info);
11146                 }
11147                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
11148                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
11149                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
11150                 NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
11151                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
11152         }
11153         if (flags & NDR_OUT) {
11154                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11155         }
11156         return NDR_ERR_SUCCESS;
11157 }
11158
11159 _PUBLIC_ void ndr_print_samr_SetUserInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetUserInfo2 *r)
11160 {
11161         ndr_print_struct(ndr, name, "samr_SetUserInfo2");
11162         ndr->depth++;
11163         if (flags & NDR_SET_VALUES) {
11164                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11165         }
11166         if (flags & NDR_IN) {
11167                 ndr_print_struct(ndr, "in", "samr_SetUserInfo2");
11168                 ndr->depth++;
11169                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
11170                 ndr->depth++;
11171                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
11172                 ndr->depth--;
11173                 ndr_print_uint16(ndr, "level", r->in.level);
11174                 ndr_print_ptr(ndr, "info", r->in.info);
11175                 ndr->depth++;
11176                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
11177                 ndr_print_samr_UserInfo(ndr, "info", r->in.info);
11178                 ndr->depth--;
11179                 ndr->depth--;
11180         }
11181         if (flags & NDR_OUT) {
11182                 ndr_print_struct(ndr, "out", "samr_SetUserInfo2");
11183                 ndr->depth++;
11184                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11185                 ndr->depth--;
11186         }
11187         ndr->depth--;
11188 }
11189
11190 static enum ndr_err_code ndr_push_samr_SetBootKeyInformation(struct ndr_push *ndr, int flags, const struct samr_SetBootKeyInformation *r)
11191 {
11192         if (flags & NDR_IN) {
11193                 if (r->in.connect_handle == NULL) {
11194                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11195                 }
11196                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
11197                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
11198                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
11199                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown3));
11200         }
11201         if (flags & NDR_OUT) {
11202                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11203         }
11204         return NDR_ERR_SUCCESS;
11205 }
11206
11207 static enum ndr_err_code ndr_pull_samr_SetBootKeyInformation(struct ndr_pull *ndr, int flags, struct samr_SetBootKeyInformation *r)
11208 {
11209         TALLOC_CTX *_mem_save_connect_handle_0;
11210         if (flags & NDR_IN) {
11211                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11212                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
11213                 }
11214                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11215                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
11216                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
11217                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
11218                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
11219                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
11220                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown3));
11221         }
11222         if (flags & NDR_OUT) {
11223                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11224         }
11225         return NDR_ERR_SUCCESS;
11226 }
11227
11228 _PUBLIC_ void ndr_print_samr_SetBootKeyInformation(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetBootKeyInformation *r)
11229 {
11230         ndr_print_struct(ndr, name, "samr_SetBootKeyInformation");
11231         ndr->depth++;
11232         if (flags & NDR_SET_VALUES) {
11233                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11234         }
11235         if (flags & NDR_IN) {
11236                 ndr_print_struct(ndr, "in", "samr_SetBootKeyInformation");
11237                 ndr->depth++;
11238                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
11239                 ndr->depth++;
11240                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
11241                 ndr->depth--;
11242                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
11243                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
11244                 ndr_print_uint32(ndr, "unknown3", r->in.unknown3);
11245                 ndr->depth--;
11246         }
11247         if (flags & NDR_OUT) {
11248                 ndr_print_struct(ndr, "out", "samr_SetBootKeyInformation");
11249                 ndr->depth++;
11250                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11251                 ndr->depth--;
11252         }
11253         ndr->depth--;
11254 }
11255
11256 static enum ndr_err_code ndr_push_samr_GetBootKeyInformation(struct ndr_push *ndr, int flags, const struct samr_GetBootKeyInformation *r)
11257 {
11258         if (flags & NDR_IN) {
11259                 if (r->in.domain_handle == NULL) {
11260                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11261                 }
11262                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
11263         }
11264         if (flags & NDR_OUT) {
11265                 if (r->out.unknown == NULL) {
11266                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11267                 }
11268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.unknown));
11269                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11270         }
11271         return NDR_ERR_SUCCESS;
11272 }
11273
11274 static enum ndr_err_code ndr_pull_samr_GetBootKeyInformation(struct ndr_pull *ndr, int flags, struct samr_GetBootKeyInformation *r)
11275 {
11276         TALLOC_CTX *_mem_save_domain_handle_0;
11277         TALLOC_CTX *_mem_save_unknown_0;
11278         if (flags & NDR_IN) {
11279                 ZERO_STRUCT(r->out);
11280
11281                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11282                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
11283                 }
11284                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11285                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
11286                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
11287                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
11288                 NDR_PULL_ALLOC(ndr, r->out.unknown);
11289                 ZERO_STRUCTP(r->out.unknown);
11290         }
11291         if (flags & NDR_OUT) {
11292                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11293                         NDR_PULL_ALLOC(ndr, r->out.unknown);
11294                 }
11295                 _mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);
11296                 NDR_PULL_SET_MEM_CTX(ndr, r->out.unknown, LIBNDR_FLAG_REF_ALLOC);
11297                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.unknown));
11298                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, LIBNDR_FLAG_REF_ALLOC);
11299                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11300         }
11301         return NDR_ERR_SUCCESS;
11302 }
11303
11304 _PUBLIC_ void ndr_print_samr_GetBootKeyInformation(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetBootKeyInformation *r)
11305 {
11306         ndr_print_struct(ndr, name, "samr_GetBootKeyInformation");
11307         ndr->depth++;
11308         if (flags & NDR_SET_VALUES) {
11309                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11310         }
11311         if (flags & NDR_IN) {
11312                 ndr_print_struct(ndr, "in", "samr_GetBootKeyInformation");
11313                 ndr->depth++;
11314                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
11315                 ndr->depth++;
11316                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
11317                 ndr->depth--;
11318                 ndr->depth--;
11319         }
11320         if (flags & NDR_OUT) {
11321                 ndr_print_struct(ndr, "out", "samr_GetBootKeyInformation");
11322                 ndr->depth++;
11323                 ndr_print_ptr(ndr, "unknown", r->out.unknown);
11324                 ndr->depth++;
11325                 ndr_print_uint32(ndr, "unknown", *r->out.unknown);
11326                 ndr->depth--;
11327                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11328                 ndr->depth--;
11329         }
11330         ndr->depth--;
11331 }
11332
11333 static enum ndr_err_code ndr_push_samr_Connect3(struct ndr_push *ndr, int flags, const struct samr_Connect3 *r)
11334 {
11335         if (flags & NDR_IN) {
11336                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
11337                 if (r->in.system_name) {
11338                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11339                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11340                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11341                         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));
11342                 }
11343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
11344                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
11345         }
11346         if (flags & NDR_OUT) {
11347                 if (r->out.connect_handle == NULL) {
11348                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11349                 }
11350                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11351                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11352         }
11353         return NDR_ERR_SUCCESS;
11354 }
11355
11356 static enum ndr_err_code ndr_pull_samr_Connect3(struct ndr_pull *ndr, int flags, struct samr_Connect3 *r)
11357 {
11358         uint32_t _ptr_system_name;
11359         TALLOC_CTX *_mem_save_system_name_0;
11360         TALLOC_CTX *_mem_save_connect_handle_0;
11361         if (flags & NDR_IN) {
11362                 ZERO_STRUCT(r->out);
11363
11364                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
11365                 if (_ptr_system_name) {
11366                         NDR_PULL_ALLOC(ndr, r->in.system_name);
11367                 } else {
11368                         r->in.system_name = NULL;
11369                 }
11370                 if (r->in.system_name) {
11371                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11372                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
11373                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
11374                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
11375                         if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
11376                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.system_name), ndr_get_array_length(ndr, &r->in.system_name));
11377                         }
11378                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
11379                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t), CH_UTF16));
11380                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
11381                 }
11382                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
11383                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
11384                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11385                 ZERO_STRUCTP(r->out.connect_handle);
11386         }
11387         if (flags & NDR_OUT) {
11388                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11389                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11390                 }
11391                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11392                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
11393                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11394                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
11395                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11396         }
11397         return NDR_ERR_SUCCESS;
11398 }
11399
11400 _PUBLIC_ void ndr_print_samr_Connect3(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect3 *r)
11401 {
11402         ndr_print_struct(ndr, name, "samr_Connect3");
11403         ndr->depth++;
11404         if (flags & NDR_SET_VALUES) {
11405                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11406         }
11407         if (flags & NDR_IN) {
11408                 ndr_print_struct(ndr, "in", "samr_Connect3");
11409                 ndr->depth++;
11410                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
11411                 ndr->depth++;
11412                 if (r->in.system_name) {
11413                         ndr_print_string(ndr, "system_name", r->in.system_name);
11414                 }
11415                 ndr->depth--;
11416                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
11417                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
11418                 ndr->depth--;
11419         }
11420         if (flags & NDR_OUT) {
11421                 ndr_print_struct(ndr, "out", "samr_Connect3");
11422                 ndr->depth++;
11423                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
11424                 ndr->depth++;
11425                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
11426                 ndr->depth--;
11427                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11428                 ndr->depth--;
11429         }
11430         ndr->depth--;
11431 }
11432
11433 static enum ndr_err_code ndr_push_samr_Connect4(struct ndr_push *ndr, int flags, const struct samr_Connect4 *r)
11434 {
11435         if (flags & NDR_IN) {
11436                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
11437                 if (r->in.system_name) {
11438                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11439                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11440                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11441                         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));
11442                 }
11443                 NDR_CHECK(ndr_push_samr_ConnectVersion(ndr, NDR_SCALARS, r->in.client_version));
11444                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
11445         }
11446         if (flags & NDR_OUT) {
11447                 if (r->out.connect_handle == NULL) {
11448                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11449                 }
11450                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11451                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11452         }
11453         return NDR_ERR_SUCCESS;
11454 }
11455
11456 static enum ndr_err_code ndr_pull_samr_Connect4(struct ndr_pull *ndr, int flags, struct samr_Connect4 *r)
11457 {
11458         uint32_t _ptr_system_name;
11459         TALLOC_CTX *_mem_save_system_name_0;
11460         TALLOC_CTX *_mem_save_connect_handle_0;
11461         if (flags & NDR_IN) {
11462                 ZERO_STRUCT(r->out);
11463
11464                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
11465                 if (_ptr_system_name) {
11466                         NDR_PULL_ALLOC(ndr, r->in.system_name);
11467                 } else {
11468                         r->in.system_name = NULL;
11469                 }
11470                 if (r->in.system_name) {
11471                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11472                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
11473                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
11474                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
11475                         if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
11476                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.system_name), ndr_get_array_length(ndr, &r->in.system_name));
11477                         }
11478                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
11479                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t), CH_UTF16));
11480                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
11481                 }
11482                 NDR_CHECK(ndr_pull_samr_ConnectVersion(ndr, NDR_SCALARS, &r->in.client_version));
11483                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
11484                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11485                 ZERO_STRUCTP(r->out.connect_handle);
11486         }
11487         if (flags & NDR_OUT) {
11488                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11489                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11490                 }
11491                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11492                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
11493                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11494                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
11495                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11496         }
11497         return NDR_ERR_SUCCESS;
11498 }
11499
11500 _PUBLIC_ void ndr_print_samr_Connect4(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect4 *r)
11501 {
11502         ndr_print_struct(ndr, name, "samr_Connect4");
11503         ndr->depth++;
11504         if (flags & NDR_SET_VALUES) {
11505                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11506         }
11507         if (flags & NDR_IN) {
11508                 ndr_print_struct(ndr, "in", "samr_Connect4");
11509                 ndr->depth++;
11510                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
11511                 ndr->depth++;
11512                 if (r->in.system_name) {
11513                         ndr_print_string(ndr, "system_name", r->in.system_name);
11514                 }
11515                 ndr->depth--;
11516                 ndr_print_samr_ConnectVersion(ndr, "client_version", r->in.client_version);
11517                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
11518                 ndr->depth--;
11519         }
11520         if (flags & NDR_OUT) {
11521                 ndr_print_struct(ndr, "out", "samr_Connect4");
11522                 ndr->depth++;
11523                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
11524                 ndr->depth++;
11525                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
11526                 ndr->depth--;
11527                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11528                 ndr->depth--;
11529         }
11530         ndr->depth--;
11531 }
11532
11533 static enum ndr_err_code ndr_push_samr_ChangePasswordUser3(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser3 *r)
11534 {
11535         if (flags & NDR_IN) {
11536                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
11537                 if (r->in.server) {
11538                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
11539                 }
11540                 if (r->in.account == NULL) {
11541                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11542                 }
11543                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
11544                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_password));
11545                 if (r->in.nt_password) {
11546                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
11547                 }
11548                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_verifier));
11549                 if (r->in.nt_verifier) {
11550                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
11551                 }
11552                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_change));
11553                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_password));
11554                 if (r->in.lm_password) {
11555                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
11556                 }
11557                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_verifier));
11558                 if (r->in.lm_verifier) {
11559                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
11560                 }
11561                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password3));
11562                 if (r->in.password3) {
11563                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password3));
11564                 }
11565         }
11566         if (flags & NDR_OUT) {
11567                 if (r->out.dominfo == NULL) {
11568                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11569                 }
11570                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.dominfo));
11571                 if (*r->out.dominfo) {
11572                         NDR_CHECK(ndr_push_samr_DomInfo1(ndr, NDR_SCALARS, *r->out.dominfo));
11573                 }
11574                 if (r->out.reject == NULL) {
11575                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11576                 }
11577                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.reject));
11578                 if (*r->out.reject) {
11579                         NDR_CHECK(ndr_push_samr_ChangeReject(ndr, NDR_SCALARS, *r->out.reject));
11580                 }
11581                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11582         }
11583         return NDR_ERR_SUCCESS;
11584 }
11585
11586 static enum ndr_err_code ndr_pull_samr_ChangePasswordUser3(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser3 *r)
11587 {
11588         uint32_t _ptr_server;
11589         uint32_t _ptr_nt_password;
11590         uint32_t _ptr_nt_verifier;
11591         uint32_t _ptr_lm_password;
11592         uint32_t _ptr_lm_verifier;
11593         uint32_t _ptr_password3;
11594         uint32_t _ptr_dominfo;
11595         uint32_t _ptr_reject;
11596         TALLOC_CTX *_mem_save_server_0;
11597         TALLOC_CTX *_mem_save_account_0;
11598         TALLOC_CTX *_mem_save_nt_password_0;
11599         TALLOC_CTX *_mem_save_nt_verifier_0;
11600         TALLOC_CTX *_mem_save_lm_password_0;
11601         TALLOC_CTX *_mem_save_lm_verifier_0;
11602         TALLOC_CTX *_mem_save_password3_0;
11603         TALLOC_CTX *_mem_save_dominfo_0;
11604         TALLOC_CTX *_mem_save_dominfo_1;
11605         TALLOC_CTX *_mem_save_reject_0;
11606         TALLOC_CTX *_mem_save_reject_1;
11607         if (flags & NDR_IN) {
11608                 ZERO_STRUCT(r->out);
11609
11610                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
11611                 if (_ptr_server) {
11612                         NDR_PULL_ALLOC(ndr, r->in.server);
11613                 } else {
11614                         r->in.server = NULL;
11615                 }
11616                 if (r->in.server) {
11617                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
11618                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
11619                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
11620                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
11621                 }
11622                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11623                         NDR_PULL_ALLOC(ndr, r->in.account);
11624                 }
11625                 _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
11626                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);
11627                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
11628                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);
11629                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_password));
11630                 if (_ptr_nt_password) {
11631                         NDR_PULL_ALLOC(ndr, r->in.nt_password);
11632                 } else {
11633                         r->in.nt_password = NULL;
11634                 }
11635                 if (r->in.nt_password) {
11636                         _mem_save_nt_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
11637                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_password, 0);
11638                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
11639                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_password_0, 0);
11640                 }
11641                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_verifier));
11642                 if (_ptr_nt_verifier) {
11643                         NDR_PULL_ALLOC(ndr, r->in.nt_verifier);
11644                 } else {
11645                         r->in.nt_verifier = NULL;
11646                 }
11647                 if (r->in.nt_verifier) {
11648                         _mem_save_nt_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
11649                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_verifier, 0);
11650                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
11651                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_verifier_0, 0);
11652                 }
11653                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_change));
11654                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_password));
11655                 if (_ptr_lm_password) {
11656                         NDR_PULL_ALLOC(ndr, r->in.lm_password);
11657                 } else {
11658                         r->in.lm_password = NULL;
11659                 }
11660                 if (r->in.lm_password) {
11661                         _mem_save_lm_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
11662                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_password, 0);
11663                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
11664                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_password_0, 0);
11665                 }
11666                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_verifier));
11667                 if (_ptr_lm_verifier) {
11668                         NDR_PULL_ALLOC(ndr, r->in.lm_verifier);
11669                 } else {
11670                         r->in.lm_verifier = NULL;
11671                 }
11672                 if (r->in.lm_verifier) {
11673                         _mem_save_lm_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
11674                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_verifier, 0);
11675                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
11676                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_verifier_0, 0);
11677                 }
11678                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password3));
11679                 if (_ptr_password3) {
11680                         NDR_PULL_ALLOC(ndr, r->in.password3);
11681                 } else {
11682                         r->in.password3 = NULL;
11683                 }
11684                 if (r->in.password3) {
11685                         _mem_save_password3_0 = NDR_PULL_GET_MEM_CTX(ndr);
11686                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password3, 0);
11687                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password3));
11688                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password3_0, 0);
11689                 }
11690                 NDR_PULL_ALLOC(ndr, r->out.dominfo);
11691                 ZERO_STRUCTP(r->out.dominfo);
11692                 NDR_PULL_ALLOC(ndr, r->out.reject);
11693                 ZERO_STRUCTP(r->out.reject);
11694         }
11695         if (flags & NDR_OUT) {
11696                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11697                         NDR_PULL_ALLOC(ndr, r->out.dominfo);
11698                 }
11699                 _mem_save_dominfo_0 = NDR_PULL_GET_MEM_CTX(ndr);
11700                 NDR_PULL_SET_MEM_CTX(ndr, r->out.dominfo, LIBNDR_FLAG_REF_ALLOC);
11701                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dominfo));
11702                 if (_ptr_dominfo) {
11703                         NDR_PULL_ALLOC(ndr, *r->out.dominfo);
11704                 } else {
11705                         *r->out.dominfo = NULL;
11706                 }
11707                 if (*r->out.dominfo) {
11708                         _mem_save_dominfo_1 = NDR_PULL_GET_MEM_CTX(ndr);
11709                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.dominfo, 0);
11710                         NDR_CHECK(ndr_pull_samr_DomInfo1(ndr, NDR_SCALARS, *r->out.dominfo));
11711                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dominfo_1, 0);
11712                 }
11713                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dominfo_0, LIBNDR_FLAG_REF_ALLOC);
11714                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11715                         NDR_PULL_ALLOC(ndr, r->out.reject);
11716                 }
11717                 _mem_save_reject_0 = NDR_PULL_GET_MEM_CTX(ndr);
11718                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reject, LIBNDR_FLAG_REF_ALLOC);
11719                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_reject));
11720                 if (_ptr_reject) {
11721                         NDR_PULL_ALLOC(ndr, *r->out.reject);
11722                 } else {
11723                         *r->out.reject = NULL;
11724                 }
11725                 if (*r->out.reject) {
11726                         _mem_save_reject_1 = NDR_PULL_GET_MEM_CTX(ndr);
11727                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.reject, 0);
11728                         NDR_CHECK(ndr_pull_samr_ChangeReject(ndr, NDR_SCALARS, *r->out.reject));
11729                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reject_1, 0);
11730                 }
11731                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reject_0, LIBNDR_FLAG_REF_ALLOC);
11732                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11733         }
11734         return NDR_ERR_SUCCESS;
11735 }
11736
11737 _PUBLIC_ void ndr_print_samr_ChangePasswordUser3(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser3 *r)
11738 {
11739         ndr_print_struct(ndr, name, "samr_ChangePasswordUser3");
11740         ndr->depth++;
11741         if (flags & NDR_SET_VALUES) {
11742                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11743         }
11744         if (flags & NDR_IN) {
11745                 ndr_print_struct(ndr, "in", "samr_ChangePasswordUser3");
11746                 ndr->depth++;
11747                 ndr_print_ptr(ndr, "server", r->in.server);
11748                 ndr->depth++;
11749                 if (r->in.server) {
11750                         ndr_print_lsa_String(ndr, "server", r->in.server);
11751                 }
11752                 ndr->depth--;
11753                 ndr_print_ptr(ndr, "account", r->in.account);
11754                 ndr->depth++;
11755                 ndr_print_lsa_String(ndr, "account", r->in.account);
11756                 ndr->depth--;
11757                 ndr_print_ptr(ndr, "nt_password", r->in.nt_password);
11758                 ndr->depth++;
11759                 if (r->in.nt_password) {
11760                         ndr_print_samr_CryptPassword(ndr, "nt_password", r->in.nt_password);
11761                 }
11762                 ndr->depth--;
11763                 ndr_print_ptr(ndr, "nt_verifier", r->in.nt_verifier);
11764                 ndr->depth++;
11765                 if (r->in.nt_verifier) {
11766                         ndr_print_samr_Password(ndr, "nt_verifier", r->in.nt_verifier);
11767                 }
11768                 ndr->depth--;
11769                 ndr_print_uint8(ndr, "lm_change", r->in.lm_change);
11770                 ndr_print_ptr(ndr, "lm_password", r->in.lm_password);
11771                 ndr->depth++;
11772                 if (r->in.lm_password) {
11773                         ndr_print_samr_CryptPassword(ndr, "lm_password", r->in.lm_password);
11774                 }
11775                 ndr->depth--;
11776                 ndr_print_ptr(ndr, "lm_verifier", r->in.lm_verifier);
11777                 ndr->depth++;
11778                 if (r->in.lm_verifier) {
11779                         ndr_print_samr_Password(ndr, "lm_verifier", r->in.lm_verifier);
11780                 }
11781                 ndr->depth--;
11782                 ndr_print_ptr(ndr, "password3", r->in.password3);
11783                 ndr->depth++;
11784                 if (r->in.password3) {
11785                         ndr_print_samr_CryptPassword(ndr, "password3", r->in.password3);
11786                 }
11787                 ndr->depth--;
11788                 ndr->depth--;
11789         }
11790         if (flags & NDR_OUT) {
11791                 ndr_print_struct(ndr, "out", "samr_ChangePasswordUser3");
11792                 ndr->depth++;
11793                 ndr_print_ptr(ndr, "dominfo", r->out.dominfo);
11794                 ndr->depth++;
11795                 ndr_print_ptr(ndr, "dominfo", *r->out.dominfo);
11796                 ndr->depth++;
11797                 if (*r->out.dominfo) {
11798                         ndr_print_samr_DomInfo1(ndr, "dominfo", *r->out.dominfo);
11799                 }
11800                 ndr->depth--;
11801                 ndr->depth--;
11802                 ndr_print_ptr(ndr, "reject", r->out.reject);
11803                 ndr->depth++;
11804                 ndr_print_ptr(ndr, "reject", *r->out.reject);
11805                 ndr->depth++;
11806                 if (*r->out.reject) {
11807                         ndr_print_samr_ChangeReject(ndr, "reject", *r->out.reject);
11808                 }
11809                 ndr->depth--;
11810                 ndr->depth--;
11811                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11812                 ndr->depth--;
11813         }
11814         ndr->depth--;
11815 }
11816
11817 _PUBLIC_ enum ndr_err_code ndr_push_samr_Connect5(struct ndr_push *ndr, int flags, const struct samr_Connect5 *r)
11818 {
11819         if (flags & NDR_IN) {
11820                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
11821                 if (r->in.system_name) {
11822                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11823                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11824                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11825                         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));
11826                 }
11827                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
11828                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level_in));
11829                 if (r->in.info_in == NULL) {
11830                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11831                 }
11832                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info_in, r->in.level_in));
11833                 NDR_CHECK(ndr_push_samr_ConnectInfo(ndr, NDR_SCALARS, r->in.info_in));
11834         }
11835         if (flags & NDR_OUT) {
11836                 if (r->out.level_out == NULL) {
11837                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11838                 }
11839                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
11840                 if (r->out.info_out == NULL) {
11841                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11842                 }
11843                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info_out, *r->out.level_out));
11844                 NDR_CHECK(ndr_push_samr_ConnectInfo(ndr, NDR_SCALARS, r->out.info_out));
11845                 if (r->out.connect_handle == NULL) {
11846                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11847                 }
11848                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11849                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11850         }
11851         return NDR_ERR_SUCCESS;
11852 }
11853
11854 _PUBLIC_ enum ndr_err_code ndr_pull_samr_Connect5(struct ndr_pull *ndr, int flags, struct samr_Connect5 *r)
11855 {
11856         uint32_t _ptr_system_name;
11857         TALLOC_CTX *_mem_save_system_name_0;
11858         TALLOC_CTX *_mem_save_info_in_0;
11859         TALLOC_CTX *_mem_save_level_out_0;
11860         TALLOC_CTX *_mem_save_info_out_0;
11861         TALLOC_CTX *_mem_save_connect_handle_0;
11862         if (flags & NDR_IN) {
11863                 ZERO_STRUCT(r->out);
11864
11865                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
11866                 if (_ptr_system_name) {
11867                         NDR_PULL_ALLOC(ndr, r->in.system_name);
11868                 } else {
11869                         r->in.system_name = NULL;
11870                 }
11871                 if (r->in.system_name) {
11872                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11873                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
11874                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
11875                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
11876                         if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
11877                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.system_name), ndr_get_array_length(ndr, &r->in.system_name));
11878                         }
11879                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
11880                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t), CH_UTF16));
11881                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
11882                 }
11883                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
11884                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level_in));
11885                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11886                         NDR_PULL_ALLOC(ndr, r->in.info_in);
11887                 }
11888                 _mem_save_info_in_0 = NDR_PULL_GET_MEM_CTX(ndr);
11889                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_in, LIBNDR_FLAG_REF_ALLOC);
11890                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info_in, r->in.level_in));
11891                 NDR_CHECK(ndr_pull_samr_ConnectInfo(ndr, NDR_SCALARS, r->in.info_in));
11892                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_in_0, LIBNDR_FLAG_REF_ALLOC);
11893                 NDR_PULL_ALLOC(ndr, r->out.level_out);
11894                 ZERO_STRUCTP(r->out.level_out);
11895                 NDR_PULL_ALLOC(ndr, r->out.info_out);
11896                 ZERO_STRUCTP(r->out.info_out);
11897                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11898                 ZERO_STRUCTP(r->out.connect_handle);
11899         }
11900         if (flags & NDR_OUT) {
11901                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11902                         NDR_PULL_ALLOC(ndr, r->out.level_out);
11903                 }
11904                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
11905                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
11906                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
11907                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
11908                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11909                         NDR_PULL_ALLOC(ndr, r->out.info_out);
11910                 }
11911                 _mem_save_info_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
11912                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_out, LIBNDR_FLAG_REF_ALLOC);
11913                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info_out, *r->out.level_out));
11914                 NDR_CHECK(ndr_pull_samr_ConnectInfo(ndr, NDR_SCALARS, r->out.info_out));
11915                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_out_0, LIBNDR_FLAG_REF_ALLOC);
11916                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11917                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11918                 }
11919                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11920                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
11921                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11922                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
11923                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11924         }
11925         return NDR_ERR_SUCCESS;
11926 }
11927
11928 _PUBLIC_ void ndr_print_samr_Connect5(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect5 *r)
11929 {
11930         ndr_print_struct(ndr, name, "samr_Connect5");
11931         ndr->depth++;
11932         if (flags & NDR_SET_VALUES) {
11933                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11934         }
11935         if (flags & NDR_IN) {
11936                 ndr_print_struct(ndr, "in", "samr_Connect5");
11937                 ndr->depth++;
11938                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
11939                 ndr->depth++;
11940                 if (r->in.system_name) {
11941                         ndr_print_string(ndr, "system_name", r->in.system_name);
11942                 }
11943                 ndr->depth--;
11944                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
11945                 ndr_print_uint32(ndr, "level_in", r->in.level_in);
11946                 ndr_print_ptr(ndr, "info_in", r->in.info_in);
11947                 ndr->depth++;
11948                 ndr_print_set_switch_value(ndr, r->in.info_in, r->in.level_in);
11949                 ndr_print_samr_ConnectInfo(ndr, "info_in", r->in.info_in);
11950                 ndr->depth--;
11951                 ndr->depth--;
11952         }
11953         if (flags & NDR_OUT) {
11954                 ndr_print_struct(ndr, "out", "samr_Connect5");
11955                 ndr->depth++;
11956                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
11957                 ndr->depth++;
11958                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
11959                 ndr->depth--;
11960                 ndr_print_ptr(ndr, "info_out", r->out.info_out);
11961                 ndr->depth++;
11962                 ndr_print_set_switch_value(ndr, r->out.info_out, *r->out.level_out);
11963                 ndr_print_samr_ConnectInfo(ndr, "info_out", r->out.info_out);
11964                 ndr->depth--;
11965                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
11966                 ndr->depth++;
11967                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
11968                 ndr->depth--;
11969                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11970                 ndr->depth--;
11971         }
11972         ndr->depth--;
11973 }
11974
11975 static enum ndr_err_code ndr_push_samr_RidToSid(struct ndr_push *ndr, int flags, const struct samr_RidToSid *r)
11976 {
11977         if (flags & NDR_IN) {
11978                 if (r->in.domain_handle == NULL) {
11979                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11980                 }
11981                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
11982                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
11983         }
11984         if (flags & NDR_OUT) {
11985                 if (r->out.sid == NULL) {
11986                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11987                 }
11988                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sid));
11989                 if (*r->out.sid) {
11990                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
11991                 }
11992                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11993         }
11994         return NDR_ERR_SUCCESS;
11995 }
11996
11997 static enum ndr_err_code ndr_pull_samr_RidToSid(struct ndr_pull *ndr, int flags, struct samr_RidToSid *r)
11998 {
11999         uint32_t _ptr_sid;
12000         TALLOC_CTX *_mem_save_domain_handle_0;
12001         TALLOC_CTX *_mem_save_sid_0;
12002         TALLOC_CTX *_mem_save_sid_1;
12003         if (flags & NDR_IN) {
12004                 ZERO_STRUCT(r->out);
12005
12006                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12007                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
12008                 }
12009                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12010                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
12011                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
12012                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
12013                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
12014                 NDR_PULL_ALLOC(ndr, r->out.sid);
12015                 ZERO_STRUCTP(r->out.sid);
12016         }
12017         if (flags & NDR_OUT) {
12018                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12019                         NDR_PULL_ALLOC(ndr, r->out.sid);
12020                 }
12021                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
12022                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);
12023                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
12024                 if (_ptr_sid) {
12025                         NDR_PULL_ALLOC(ndr, *r->out.sid);
12026                 } else {
12027                         *r->out.sid = NULL;
12028                 }
12029                 if (*r->out.sid) {
12030                         _mem_save_sid_1 = NDR_PULL_GET_MEM_CTX(ndr);
12031                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sid, 0);
12032                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
12033                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_1, 0);
12034                 }
12035                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
12036                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12037         }
12038         return NDR_ERR_SUCCESS;
12039 }
12040
12041 _PUBLIC_ void ndr_print_samr_RidToSid(struct ndr_print *ndr, const char *name, int flags, const struct samr_RidToSid *r)
12042 {
12043         ndr_print_struct(ndr, name, "samr_RidToSid");
12044         ndr->depth++;
12045         if (flags & NDR_SET_VALUES) {
12046                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12047         }
12048         if (flags & NDR_IN) {
12049                 ndr_print_struct(ndr, "in", "samr_RidToSid");
12050                 ndr->depth++;
12051                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
12052                 ndr->depth++;
12053                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
12054                 ndr->depth--;
12055                 ndr_print_uint32(ndr, "rid", r->in.rid);
12056                 ndr->depth--;
12057         }
12058         if (flags & NDR_OUT) {
12059                 ndr_print_struct(ndr, "out", "samr_RidToSid");
12060                 ndr->depth++;
12061                 ndr_print_ptr(ndr, "sid", r->out.sid);
12062                 ndr->depth++;
12063                 ndr_print_ptr(ndr, "sid", *r->out.sid);
12064                 ndr->depth++;
12065                 if (*r->out.sid) {
12066                         ndr_print_dom_sid2(ndr, "sid", *r->out.sid);
12067                 }
12068                 ndr->depth--;
12069                 ndr->depth--;
12070                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12071                 ndr->depth--;
12072         }
12073         ndr->depth--;
12074 }
12075
12076 static enum ndr_err_code ndr_push_samr_SetDsrmPassword(struct ndr_push *ndr, int flags, const struct samr_SetDsrmPassword *r)
12077 {
12078         if (flags & NDR_IN) {
12079                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.name));
12080                 if (r->in.name) {
12081                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
12082                 }
12083                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
12084                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hash));
12085                 if (r->in.hash) {
12086                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.hash));
12087                 }
12088         }
12089         if (flags & NDR_OUT) {
12090                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12091         }
12092         return NDR_ERR_SUCCESS;
12093 }
12094
12095 static enum ndr_err_code ndr_pull_samr_SetDsrmPassword(struct ndr_pull *ndr, int flags, struct samr_SetDsrmPassword *r)
12096 {
12097         uint32_t _ptr_name;
12098         uint32_t _ptr_hash;
12099         TALLOC_CTX *_mem_save_name_0;
12100         TALLOC_CTX *_mem_save_hash_0;
12101         if (flags & NDR_IN) {
12102                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
12103                 if (_ptr_name) {
12104                         NDR_PULL_ALLOC(ndr, r->in.name);
12105                 } else {
12106                         r->in.name = NULL;
12107                 }
12108                 if (r->in.name) {
12109                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12110                         NDR_PULL_SET_MEM_CTX(ndr, r->in.name, 0);
12111                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
12112                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
12113                 }
12114                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
12115                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hash));
12116                 if (_ptr_hash) {
12117                         NDR_PULL_ALLOC(ndr, r->in.hash);
12118                 } else {
12119                         r->in.hash = NULL;
12120                 }
12121                 if (r->in.hash) {
12122                         _mem_save_hash_0 = NDR_PULL_GET_MEM_CTX(ndr);
12123                         NDR_PULL_SET_MEM_CTX(ndr, r->in.hash, 0);
12124                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.hash));
12125                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hash_0, 0);
12126                 }
12127         }
12128         if (flags & NDR_OUT) {
12129                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12130         }
12131         return NDR_ERR_SUCCESS;
12132 }
12133
12134 _PUBLIC_ void ndr_print_samr_SetDsrmPassword(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetDsrmPassword *r)
12135 {
12136         ndr_print_struct(ndr, name, "samr_SetDsrmPassword");
12137         ndr->depth++;
12138         if (flags & NDR_SET_VALUES) {
12139                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12140         }
12141         if (flags & NDR_IN) {
12142                 ndr_print_struct(ndr, "in", "samr_SetDsrmPassword");
12143                 ndr->depth++;
12144                 ndr_print_ptr(ndr, "name", r->in.name);
12145                 ndr->depth++;
12146                 if (r->in.name) {
12147                         ndr_print_lsa_String(ndr, "name", r->in.name);
12148                 }
12149                 ndr->depth--;
12150                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
12151                 ndr_print_ptr(ndr, "hash", r->in.hash);
12152                 ndr->depth++;
12153                 if (r->in.hash) {
12154                         ndr_print_samr_Password(ndr, "hash", r->in.hash);
12155                 }
12156                 ndr->depth--;
12157                 ndr->depth--;
12158         }
12159         if (flags & NDR_OUT) {
12160                 ndr_print_struct(ndr, "out", "samr_SetDsrmPassword");
12161                 ndr->depth++;
12162                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12163                 ndr->depth--;
12164         }
12165         ndr->depth--;
12166 }
12167
12168 static enum ndr_err_code ndr_push_samr_ValidatePassword(struct ndr_push *ndr, int flags, const struct samr_ValidatePassword *r)
12169 {
12170         if (flags & NDR_IN) {
12171                 NDR_CHECK(ndr_push_samr_ValidatePasswordLevel(ndr, NDR_SCALARS, r->in.level));
12172                 if (r->in.req == NULL) {
12173                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12174                 }
12175                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
12176                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
12177         }
12178         if (flags & NDR_OUT) {
12179                 if (r->out.rep == NULL) {
12180                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12181                 }
12182                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rep));
12183                 if (*r->out.rep) {
12184                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.rep, r->in.level));
12185                         NDR_CHECK(ndr_push_samr_ValidatePasswordRep(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rep));
12186                 }
12187                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12188         }
12189         return NDR_ERR_SUCCESS;
12190 }
12191
12192 static enum ndr_err_code ndr_pull_samr_ValidatePassword(struct ndr_pull *ndr, int flags, struct samr_ValidatePassword *r)
12193 {
12194         uint32_t _ptr_rep;
12195         TALLOC_CTX *_mem_save_req_0;
12196         TALLOC_CTX *_mem_save_rep_0;
12197         TALLOC_CTX *_mem_save_rep_1;
12198         if (flags & NDR_IN) {
12199                 ZERO_STRUCT(r->out);
12200
12201                 NDR_CHECK(ndr_pull_samr_ValidatePasswordLevel(ndr, NDR_SCALARS, &r->in.level));
12202                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12203                         NDR_PULL_ALLOC(ndr, r->in.req);
12204                 }
12205                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
12206                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
12207                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
12208                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
12209                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
12210                 NDR_PULL_ALLOC(ndr, r->out.rep);
12211                 ZERO_STRUCTP(r->out.rep);
12212         }
12213         if (flags & NDR_OUT) {
12214                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12215                         NDR_PULL_ALLOC(ndr, r->out.rep);
12216                 }
12217                 _mem_save_rep_0 = NDR_PULL_GET_MEM_CTX(ndr);
12218                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rep, LIBNDR_FLAG_REF_ALLOC);
12219                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rep));
12220                 if (_ptr_rep) {
12221                         NDR_PULL_ALLOC(ndr, *r->out.rep);
12222                 } else {
12223                         *r->out.rep = NULL;
12224                 }
12225                 if (*r->out.rep) {
12226                         _mem_save_rep_1 = NDR_PULL_GET_MEM_CTX(ndr);
12227                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.rep, 0);
12228                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.rep, r->in.level));
12229                         NDR_CHECK(ndr_pull_samr_ValidatePasswordRep(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rep));
12230                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rep_1, 0);
12231                 }
12232                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rep_0, LIBNDR_FLAG_REF_ALLOC);
12233                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12234         }
12235         return NDR_ERR_SUCCESS;
12236 }
12237
12238 _PUBLIC_ void ndr_print_samr_ValidatePassword(struct ndr_print *ndr, const char *name, int flags, const struct samr_ValidatePassword *r)
12239 {
12240         ndr_print_struct(ndr, name, "samr_ValidatePassword");
12241         ndr->depth++;
12242         if (flags & NDR_SET_VALUES) {
12243                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12244         }
12245         if (flags & NDR_IN) {
12246                 ndr_print_struct(ndr, "in", "samr_ValidatePassword");
12247                 ndr->depth++;
12248                 ndr_print_samr_ValidatePasswordLevel(ndr, "level", r->in.level);
12249                 ndr_print_ptr(ndr, "req", r->in.req);
12250                 ndr->depth++;
12251                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
12252                 ndr_print_samr_ValidatePasswordReq(ndr, "req", r->in.req);
12253                 ndr->depth--;
12254                 ndr->depth--;
12255         }
12256         if (flags & NDR_OUT) {
12257                 ndr_print_struct(ndr, "out", "samr_ValidatePassword");
12258                 ndr->depth++;
12259                 ndr_print_ptr(ndr, "rep", r->out.rep);
12260                 ndr->depth++;
12261                 ndr_print_ptr(ndr, "rep", *r->out.rep);
12262                 ndr->depth++;
12263                 if (*r->out.rep) {
12264                         ndr_print_set_switch_value(ndr, *r->out.rep, r->in.level);
12265                         ndr_print_samr_ValidatePasswordRep(ndr, "rep", *r->out.rep);
12266                 }
12267                 ndr->depth--;
12268                 ndr->depth--;
12269                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12270                 ndr->depth--;
12271         }
12272         ndr->depth--;
12273 }
12274
12275 static const struct ndr_interface_call samr_calls[] = {
12276         {
12277                 "samr_Connect",
12278                 sizeof(struct samr_Connect),
12279                 (ndr_push_flags_fn_t) ndr_push_samr_Connect,
12280                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect,
12281                 (ndr_print_function_t) ndr_print_samr_Connect,
12282                 false,
12283         },
12284         {
12285                 "samr_Close",
12286                 sizeof(struct samr_Close),
12287                 (ndr_push_flags_fn_t) ndr_push_samr_Close,
12288                 (ndr_pull_flags_fn_t) ndr_pull_samr_Close,
12289                 (ndr_print_function_t) ndr_print_samr_Close,
12290                 false,
12291         },
12292         {
12293                 "samr_SetSecurity",
12294                 sizeof(struct samr_SetSecurity),
12295                 (ndr_push_flags_fn_t) ndr_push_samr_SetSecurity,
12296                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetSecurity,
12297                 (ndr_print_function_t) ndr_print_samr_SetSecurity,
12298                 false,
12299         },
12300         {
12301                 "samr_QuerySecurity",
12302                 sizeof(struct samr_QuerySecurity),
12303                 (ndr_push_flags_fn_t) ndr_push_samr_QuerySecurity,
12304                 (ndr_pull_flags_fn_t) ndr_pull_samr_QuerySecurity,
12305                 (ndr_print_function_t) ndr_print_samr_QuerySecurity,
12306                 false,
12307         },
12308         {
12309                 "samr_Shutdown",
12310                 sizeof(struct samr_Shutdown),
12311                 (ndr_push_flags_fn_t) ndr_push_samr_Shutdown,
12312                 (ndr_pull_flags_fn_t) ndr_pull_samr_Shutdown,
12313                 (ndr_print_function_t) ndr_print_samr_Shutdown,
12314                 false,
12315         },
12316         {
12317                 "samr_LookupDomain",
12318                 sizeof(struct samr_LookupDomain),
12319                 (ndr_push_flags_fn_t) ndr_push_samr_LookupDomain,
12320                 (ndr_pull_flags_fn_t) ndr_pull_samr_LookupDomain,
12321                 (ndr_print_function_t) ndr_print_samr_LookupDomain,
12322                 false,
12323         },
12324         {
12325                 "samr_EnumDomains",
12326                 sizeof(struct samr_EnumDomains),
12327                 (ndr_push_flags_fn_t) ndr_push_samr_EnumDomains,
12328                 (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomains,
12329                 (ndr_print_function_t) ndr_print_samr_EnumDomains,
12330                 false,
12331         },
12332         {
12333                 "samr_OpenDomain",
12334                 sizeof(struct samr_OpenDomain),
12335                 (ndr_push_flags_fn_t) ndr_push_samr_OpenDomain,
12336                 (ndr_pull_flags_fn_t) ndr_pull_samr_OpenDomain,
12337                 (ndr_print_function_t) ndr_print_samr_OpenDomain,
12338                 false,
12339         },
12340         {
12341                 "samr_QueryDomainInfo",
12342                 sizeof(struct samr_QueryDomainInfo),
12343                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDomainInfo,
12344                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDomainInfo,
12345                 (ndr_print_function_t) ndr_print_samr_QueryDomainInfo,
12346                 false,
12347         },
12348         {
12349                 "samr_SetDomainInfo",
12350                 sizeof(struct samr_SetDomainInfo),
12351                 (ndr_push_flags_fn_t) ndr_push_samr_SetDomainInfo,
12352                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetDomainInfo,
12353                 (ndr_print_function_t) ndr_print_samr_SetDomainInfo,
12354                 false,
12355         },
12356         {
12357                 "samr_CreateDomainGroup",
12358                 sizeof(struct samr_CreateDomainGroup),
12359                 (ndr_push_flags_fn_t) ndr_push_samr_CreateDomainGroup,
12360                 (ndr_pull_flags_fn_t) ndr_pull_samr_CreateDomainGroup,
12361                 (ndr_print_function_t) ndr_print_samr_CreateDomainGroup,
12362                 false,
12363         },
12364         {
12365                 "samr_EnumDomainGroups",
12366                 sizeof(struct samr_EnumDomainGroups),
12367                 (ndr_push_flags_fn_t) ndr_push_samr_EnumDomainGroups,
12368                 (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainGroups,
12369                 (ndr_print_function_t) ndr_print_samr_EnumDomainGroups,
12370                 false,
12371         },
12372         {
12373                 "samr_CreateUser",
12374                 sizeof(struct samr_CreateUser),
12375                 (ndr_push_flags_fn_t) ndr_push_samr_CreateUser,
12376                 (ndr_pull_flags_fn_t) ndr_pull_samr_CreateUser,
12377                 (ndr_print_function_t) ndr_print_samr_CreateUser,
12378                 false,
12379         },
12380         {
12381                 "samr_EnumDomainUsers",
12382                 sizeof(struct samr_EnumDomainUsers),
12383                 (ndr_push_flags_fn_t) ndr_push_samr_EnumDomainUsers,
12384                 (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainUsers,
12385                 (ndr_print_function_t) ndr_print_samr_EnumDomainUsers,
12386                 false,
12387         },
12388         {
12389                 "samr_CreateDomAlias",
12390                 sizeof(struct samr_CreateDomAlias),
12391                 (ndr_push_flags_fn_t) ndr_push_samr_CreateDomAlias,
12392                 (ndr_pull_flags_fn_t) ndr_pull_samr_CreateDomAlias,
12393                 (ndr_print_function_t) ndr_print_samr_CreateDomAlias,
12394                 false,
12395         },
12396         {
12397                 "samr_EnumDomainAliases",
12398                 sizeof(struct samr_EnumDomainAliases),
12399                 (ndr_push_flags_fn_t) ndr_push_samr_EnumDomainAliases,
12400                 (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainAliases,
12401                 (ndr_print_function_t) ndr_print_samr_EnumDomainAliases,
12402                 false,
12403         },
12404         {
12405                 "samr_GetAliasMembership",
12406                 sizeof(struct samr_GetAliasMembership),
12407                 (ndr_push_flags_fn_t) ndr_push_samr_GetAliasMembership,
12408                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetAliasMembership,
12409                 (ndr_print_function_t) ndr_print_samr_GetAliasMembership,
12410                 false,
12411         },
12412         {
12413                 "samr_LookupNames",
12414                 sizeof(struct samr_LookupNames),
12415                 (ndr_push_flags_fn_t) ndr_push_samr_LookupNames,
12416                 (ndr_pull_flags_fn_t) ndr_pull_samr_LookupNames,
12417                 (ndr_print_function_t) ndr_print_samr_LookupNames,
12418                 false,
12419         },
12420         {
12421                 "samr_LookupRids",
12422                 sizeof(struct samr_LookupRids),
12423                 (ndr_push_flags_fn_t) ndr_push_samr_LookupRids,
12424                 (ndr_pull_flags_fn_t) ndr_pull_samr_LookupRids,
12425                 (ndr_print_function_t) ndr_print_samr_LookupRids,
12426                 false,
12427         },
12428         {
12429                 "samr_OpenGroup",
12430                 sizeof(struct samr_OpenGroup),
12431                 (ndr_push_flags_fn_t) ndr_push_samr_OpenGroup,
12432                 (ndr_pull_flags_fn_t) ndr_pull_samr_OpenGroup,
12433                 (ndr_print_function_t) ndr_print_samr_OpenGroup,
12434                 false,
12435         },
12436         {
12437                 "samr_QueryGroupInfo",
12438                 sizeof(struct samr_QueryGroupInfo),
12439                 (ndr_push_flags_fn_t) ndr_push_samr_QueryGroupInfo,
12440                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryGroupInfo,
12441                 (ndr_print_function_t) ndr_print_samr_QueryGroupInfo,
12442                 false,
12443         },
12444         {
12445                 "samr_SetGroupInfo",
12446                 sizeof(struct samr_SetGroupInfo),
12447                 (ndr_push_flags_fn_t) ndr_push_samr_SetGroupInfo,
12448                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetGroupInfo,
12449                 (ndr_print_function_t) ndr_print_samr_SetGroupInfo,
12450                 false,
12451         },
12452         {
12453                 "samr_AddGroupMember",
12454                 sizeof(struct samr_AddGroupMember),
12455                 (ndr_push_flags_fn_t) ndr_push_samr_AddGroupMember,
12456                 (ndr_pull_flags_fn_t) ndr_pull_samr_AddGroupMember,
12457                 (ndr_print_function_t) ndr_print_samr_AddGroupMember,
12458                 false,
12459         },
12460         {
12461                 "samr_DeleteDomainGroup",
12462                 sizeof(struct samr_DeleteDomainGroup),
12463                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteDomainGroup,
12464                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteDomainGroup,
12465                 (ndr_print_function_t) ndr_print_samr_DeleteDomainGroup,
12466                 false,
12467         },
12468         {
12469                 "samr_DeleteGroupMember",
12470                 sizeof(struct samr_DeleteGroupMember),
12471                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteGroupMember,
12472                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteGroupMember,
12473                 (ndr_print_function_t) ndr_print_samr_DeleteGroupMember,
12474                 false,
12475         },
12476         {
12477                 "samr_QueryGroupMember",
12478                 sizeof(struct samr_QueryGroupMember),
12479                 (ndr_push_flags_fn_t) ndr_push_samr_QueryGroupMember,
12480                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryGroupMember,
12481                 (ndr_print_function_t) ndr_print_samr_QueryGroupMember,
12482                 false,
12483         },
12484         {
12485                 "samr_SetMemberAttributesOfGroup",
12486                 sizeof(struct samr_SetMemberAttributesOfGroup),
12487                 (ndr_push_flags_fn_t) ndr_push_samr_SetMemberAttributesOfGroup,
12488                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetMemberAttributesOfGroup,
12489                 (ndr_print_function_t) ndr_print_samr_SetMemberAttributesOfGroup,
12490                 false,
12491         },
12492         {
12493                 "samr_OpenAlias",
12494                 sizeof(struct samr_OpenAlias),
12495                 (ndr_push_flags_fn_t) ndr_push_samr_OpenAlias,
12496                 (ndr_pull_flags_fn_t) ndr_pull_samr_OpenAlias,
12497                 (ndr_print_function_t) ndr_print_samr_OpenAlias,
12498                 false,
12499         },
12500         {
12501                 "samr_QueryAliasInfo",
12502                 sizeof(struct samr_QueryAliasInfo),
12503                 (ndr_push_flags_fn_t) ndr_push_samr_QueryAliasInfo,
12504                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryAliasInfo,
12505                 (ndr_print_function_t) ndr_print_samr_QueryAliasInfo,
12506                 false,
12507         },
12508         {
12509                 "samr_SetAliasInfo",
12510                 sizeof(struct samr_SetAliasInfo),
12511                 (ndr_push_flags_fn_t) ndr_push_samr_SetAliasInfo,
12512                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetAliasInfo,
12513                 (ndr_print_function_t) ndr_print_samr_SetAliasInfo,
12514                 false,
12515         },
12516         {
12517                 "samr_DeleteDomAlias",
12518                 sizeof(struct samr_DeleteDomAlias),
12519                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteDomAlias,
12520                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteDomAlias,
12521                 (ndr_print_function_t) ndr_print_samr_DeleteDomAlias,
12522                 false,
12523         },
12524         {
12525                 "samr_AddAliasMember",
12526                 sizeof(struct samr_AddAliasMember),
12527                 (ndr_push_flags_fn_t) ndr_push_samr_AddAliasMember,
12528                 (ndr_pull_flags_fn_t) ndr_pull_samr_AddAliasMember,
12529                 (ndr_print_function_t) ndr_print_samr_AddAliasMember,
12530                 false,
12531         },
12532         {
12533                 "samr_DeleteAliasMember",
12534                 sizeof(struct samr_DeleteAliasMember),
12535                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteAliasMember,
12536                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteAliasMember,
12537                 (ndr_print_function_t) ndr_print_samr_DeleteAliasMember,
12538                 false,
12539         },
12540         {
12541                 "samr_GetMembersInAlias",
12542                 sizeof(struct samr_GetMembersInAlias),
12543                 (ndr_push_flags_fn_t) ndr_push_samr_GetMembersInAlias,
12544                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetMembersInAlias,
12545                 (ndr_print_function_t) ndr_print_samr_GetMembersInAlias,
12546                 false,
12547         },
12548         {
12549                 "samr_OpenUser",
12550                 sizeof(struct samr_OpenUser),
12551                 (ndr_push_flags_fn_t) ndr_push_samr_OpenUser,
12552                 (ndr_pull_flags_fn_t) ndr_pull_samr_OpenUser,
12553                 (ndr_print_function_t) ndr_print_samr_OpenUser,
12554                 false,
12555         },
12556         {
12557                 "samr_DeleteUser",
12558                 sizeof(struct samr_DeleteUser),
12559                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteUser,
12560                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteUser,
12561                 (ndr_print_function_t) ndr_print_samr_DeleteUser,
12562                 false,
12563         },
12564         {
12565                 "samr_QueryUserInfo",
12566                 sizeof(struct samr_QueryUserInfo),
12567                 (ndr_push_flags_fn_t) ndr_push_samr_QueryUserInfo,
12568                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryUserInfo,
12569                 (ndr_print_function_t) ndr_print_samr_QueryUserInfo,
12570                 false,
12571         },
12572         {
12573                 "samr_SetUserInfo",
12574                 sizeof(struct samr_SetUserInfo),
12575                 (ndr_push_flags_fn_t) ndr_push_samr_SetUserInfo,
12576                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetUserInfo,
12577                 (ndr_print_function_t) ndr_print_samr_SetUserInfo,
12578                 false,
12579         },
12580         {
12581                 "samr_ChangePasswordUser",
12582                 sizeof(struct samr_ChangePasswordUser),
12583                 (ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser,
12584                 (ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser,
12585                 (ndr_print_function_t) ndr_print_samr_ChangePasswordUser,
12586                 false,
12587         },
12588         {
12589                 "samr_GetGroupsForUser",
12590                 sizeof(struct samr_GetGroupsForUser),
12591                 (ndr_push_flags_fn_t) ndr_push_samr_GetGroupsForUser,
12592                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetGroupsForUser,
12593                 (ndr_print_function_t) ndr_print_samr_GetGroupsForUser,
12594                 false,
12595         },
12596         {
12597                 "samr_QueryDisplayInfo",
12598                 sizeof(struct samr_QueryDisplayInfo),
12599                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo,
12600                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo,
12601                 (ndr_print_function_t) ndr_print_samr_QueryDisplayInfo,
12602                 false,
12603         },
12604         {
12605                 "samr_GetDisplayEnumerationIndex",
12606                 sizeof(struct samr_GetDisplayEnumerationIndex),
12607                 (ndr_push_flags_fn_t) ndr_push_samr_GetDisplayEnumerationIndex,
12608                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetDisplayEnumerationIndex,
12609                 (ndr_print_function_t) ndr_print_samr_GetDisplayEnumerationIndex,
12610                 false,
12611         },
12612         {
12613                 "samr_TestPrivateFunctionsDomain",
12614                 sizeof(struct samr_TestPrivateFunctionsDomain),
12615                 (ndr_push_flags_fn_t) ndr_push_samr_TestPrivateFunctionsDomain,
12616                 (ndr_pull_flags_fn_t) ndr_pull_samr_TestPrivateFunctionsDomain,
12617                 (ndr_print_function_t) ndr_print_samr_TestPrivateFunctionsDomain,
12618                 false,
12619         },
12620         {
12621                 "samr_TestPrivateFunctionsUser",
12622                 sizeof(struct samr_TestPrivateFunctionsUser),
12623                 (ndr_push_flags_fn_t) ndr_push_samr_TestPrivateFunctionsUser,
12624                 (ndr_pull_flags_fn_t) ndr_pull_samr_TestPrivateFunctionsUser,
12625                 (ndr_print_function_t) ndr_print_samr_TestPrivateFunctionsUser,
12626                 false,
12627         },
12628         {
12629                 "samr_GetUserPwInfo",
12630                 sizeof(struct samr_GetUserPwInfo),
12631                 (ndr_push_flags_fn_t) ndr_push_samr_GetUserPwInfo,
12632                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetUserPwInfo,
12633                 (ndr_print_function_t) ndr_print_samr_GetUserPwInfo,
12634                 false,
12635         },
12636         {
12637                 "samr_RemoveMemberFromForeignDomain",
12638                 sizeof(struct samr_RemoveMemberFromForeignDomain),
12639                 (ndr_push_flags_fn_t) ndr_push_samr_RemoveMemberFromForeignDomain,
12640                 (ndr_pull_flags_fn_t) ndr_pull_samr_RemoveMemberFromForeignDomain,
12641                 (ndr_print_function_t) ndr_print_samr_RemoveMemberFromForeignDomain,
12642                 false,
12643         },
12644         {
12645                 "samr_QueryDomainInfo2",
12646                 sizeof(struct samr_QueryDomainInfo2),
12647                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDomainInfo2,
12648                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDomainInfo2,
12649                 (ndr_print_function_t) ndr_print_samr_QueryDomainInfo2,
12650                 false,
12651         },
12652         {
12653                 "samr_QueryUserInfo2",
12654                 sizeof(struct samr_QueryUserInfo2),
12655                 (ndr_push_flags_fn_t) ndr_push_samr_QueryUserInfo2,
12656                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryUserInfo2,
12657                 (ndr_print_function_t) ndr_print_samr_QueryUserInfo2,
12658                 false,
12659         },
12660         {
12661                 "samr_QueryDisplayInfo2",
12662                 sizeof(struct samr_QueryDisplayInfo2),
12663                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo2,
12664                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo2,
12665                 (ndr_print_function_t) ndr_print_samr_QueryDisplayInfo2,
12666                 false,
12667         },
12668         {
12669                 "samr_GetDisplayEnumerationIndex2",
12670                 sizeof(struct samr_GetDisplayEnumerationIndex2),
12671                 (ndr_push_flags_fn_t) ndr_push_samr_GetDisplayEnumerationIndex2,
12672                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetDisplayEnumerationIndex2,
12673                 (ndr_print_function_t) ndr_print_samr_GetDisplayEnumerationIndex2,
12674                 false,
12675         },
12676         {
12677                 "samr_CreateUser2",
12678                 sizeof(struct samr_CreateUser2),
12679                 (ndr_push_flags_fn_t) ndr_push_samr_CreateUser2,
12680                 (ndr_pull_flags_fn_t) ndr_pull_samr_CreateUser2,
12681                 (ndr_print_function_t) ndr_print_samr_CreateUser2,
12682                 false,
12683         },
12684         {
12685                 "samr_QueryDisplayInfo3",
12686                 sizeof(struct samr_QueryDisplayInfo3),
12687                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo3,
12688                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo3,
12689                 (ndr_print_function_t) ndr_print_samr_QueryDisplayInfo3,
12690                 false,
12691         },
12692         {
12693                 "samr_AddMultipleMembersToAlias",
12694                 sizeof(struct samr_AddMultipleMembersToAlias),
12695                 (ndr_push_flags_fn_t) ndr_push_samr_AddMultipleMembersToAlias,
12696                 (ndr_pull_flags_fn_t) ndr_pull_samr_AddMultipleMembersToAlias,
12697                 (ndr_print_function_t) ndr_print_samr_AddMultipleMembersToAlias,
12698                 false,
12699         },
12700         {
12701                 "samr_RemoveMultipleMembersFromAlias",
12702                 sizeof(struct samr_RemoveMultipleMembersFromAlias),
12703                 (ndr_push_flags_fn_t) ndr_push_samr_RemoveMultipleMembersFromAlias,
12704                 (ndr_pull_flags_fn_t) ndr_pull_samr_RemoveMultipleMembersFromAlias,
12705                 (ndr_print_function_t) ndr_print_samr_RemoveMultipleMembersFromAlias,
12706                 false,
12707         },
12708         {
12709                 "samr_OemChangePasswordUser2",
12710                 sizeof(struct samr_OemChangePasswordUser2),
12711                 (ndr_push_flags_fn_t) ndr_push_samr_OemChangePasswordUser2,
12712                 (ndr_pull_flags_fn_t) ndr_pull_samr_OemChangePasswordUser2,
12713                 (ndr_print_function_t) ndr_print_samr_OemChangePasswordUser2,
12714                 false,
12715         },
12716         {
12717                 "samr_ChangePasswordUser2",
12718                 sizeof(struct samr_ChangePasswordUser2),
12719                 (ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser2,
12720                 (ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser2,
12721                 (ndr_print_function_t) ndr_print_samr_ChangePasswordUser2,
12722                 false,
12723         },
12724         {
12725                 "samr_GetDomPwInfo",
12726                 sizeof(struct samr_GetDomPwInfo),
12727                 (ndr_push_flags_fn_t) ndr_push_samr_GetDomPwInfo,
12728                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetDomPwInfo,
12729                 (ndr_print_function_t) ndr_print_samr_GetDomPwInfo,
12730                 false,
12731         },
12732         {
12733                 "samr_Connect2",
12734                 sizeof(struct samr_Connect2),
12735                 (ndr_push_flags_fn_t) ndr_push_samr_Connect2,
12736                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect2,
12737                 (ndr_print_function_t) ndr_print_samr_Connect2,
12738                 false,
12739         },
12740         {
12741                 "samr_SetUserInfo2",
12742                 sizeof(struct samr_SetUserInfo2),
12743                 (ndr_push_flags_fn_t) ndr_push_samr_SetUserInfo2,
12744                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetUserInfo2,
12745                 (ndr_print_function_t) ndr_print_samr_SetUserInfo2,
12746                 false,
12747         },
12748         {
12749                 "samr_SetBootKeyInformation",
12750                 sizeof(struct samr_SetBootKeyInformation),
12751                 (ndr_push_flags_fn_t) ndr_push_samr_SetBootKeyInformation,
12752                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetBootKeyInformation,
12753                 (ndr_print_function_t) ndr_print_samr_SetBootKeyInformation,
12754                 false,
12755         },
12756         {
12757                 "samr_GetBootKeyInformation",
12758                 sizeof(struct samr_GetBootKeyInformation),
12759                 (ndr_push_flags_fn_t) ndr_push_samr_GetBootKeyInformation,
12760                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetBootKeyInformation,
12761                 (ndr_print_function_t) ndr_print_samr_GetBootKeyInformation,
12762                 false,
12763         },
12764         {
12765                 "samr_Connect3",
12766                 sizeof(struct samr_Connect3),
12767                 (ndr_push_flags_fn_t) ndr_push_samr_Connect3,
12768                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect3,
12769                 (ndr_print_function_t) ndr_print_samr_Connect3,
12770                 false,
12771         },
12772         {
12773                 "samr_Connect4",
12774                 sizeof(struct samr_Connect4),
12775                 (ndr_push_flags_fn_t) ndr_push_samr_Connect4,
12776                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect4,
12777                 (ndr_print_function_t) ndr_print_samr_Connect4,
12778                 false,
12779         },
12780         {
12781                 "samr_ChangePasswordUser3",
12782                 sizeof(struct samr_ChangePasswordUser3),
12783                 (ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser3,
12784                 (ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser3,
12785                 (ndr_print_function_t) ndr_print_samr_ChangePasswordUser3,
12786                 false,
12787         },
12788         {
12789                 "samr_Connect5",
12790                 sizeof(struct samr_Connect5),
12791                 (ndr_push_flags_fn_t) ndr_push_samr_Connect5,
12792                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect5,
12793                 (ndr_print_function_t) ndr_print_samr_Connect5,
12794                 false,
12795         },
12796         {
12797                 "samr_RidToSid",
12798                 sizeof(struct samr_RidToSid),
12799                 (ndr_push_flags_fn_t) ndr_push_samr_RidToSid,
12800                 (ndr_pull_flags_fn_t) ndr_pull_samr_RidToSid,
12801                 (ndr_print_function_t) ndr_print_samr_RidToSid,
12802                 false,
12803         },
12804         {
12805                 "samr_SetDsrmPassword",
12806                 sizeof(struct samr_SetDsrmPassword),
12807                 (ndr_push_flags_fn_t) ndr_push_samr_SetDsrmPassword,
12808                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetDsrmPassword,
12809                 (ndr_print_function_t) ndr_print_samr_SetDsrmPassword,
12810                 false,
12811         },
12812         {
12813                 "samr_ValidatePassword",
12814                 sizeof(struct samr_ValidatePassword),
12815                 (ndr_push_flags_fn_t) ndr_push_samr_ValidatePassword,
12816                 (ndr_pull_flags_fn_t) ndr_pull_samr_ValidatePassword,
12817                 (ndr_print_function_t) ndr_print_samr_ValidatePassword,
12818                 false,
12819         },
12820         { NULL, 0, NULL, NULL, NULL, false }
12821 };
12822
12823 static const char * const samr_endpoint_strings[] = {
12824         "ncacn_np:[\\pipe\\samr]",
12825         "ncacn_ip_tcp:",
12826         "ncalrpc:",
12827 };
12828
12829 static const struct ndr_interface_string_array samr_endpoints = {
12830         .count  = 3,
12831         .names  = samr_endpoint_strings
12832 };
12833
12834 static const char * const samr_authservice_strings[] = {
12835         "host",
12836 };
12837
12838 static const struct ndr_interface_string_array samr_authservices = {
12839         .count  = 1,
12840         .names  = samr_authservice_strings
12841 };
12842
12843
12844 const struct ndr_interface_table ndr_table_samr = {
12845         .name           = "samr",
12846         .syntax_id      = {
12847                 {0x12345778,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xac}},
12848                 NDR_SAMR_VERSION
12849         },
12850         .helpstring     = NDR_SAMR_HELPSTRING,
12851         .num_calls      = 68,
12852         .calls          = samr_calls,
12853         .endpoints      = &samr_endpoints,
12854         .authservices   = &samr_authservices
12855 };
12856