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_LOOKUP_DOMAIN", SAMR_ACCESS_LOOKUP_DOMAIN, r);
 126         ndr->depth--;
 127 }
 128
 129 static enum ndr_err_code ndr_push_samr_UserAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 130 {
 131         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 132         return NDR_ERR_SUCCESS;
 133 }
 134
 135 static enum ndr_err_code ndr_pull_samr_UserAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 136 {
 137         uint32_t v;
 138         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 139         *r = v;
 140         return NDR_ERR_SUCCESS;
 141 }
 142
 143 _PUBLIC_ void ndr_print_samr_UserAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 144 {
 145         ndr_print_uint32(ndr, name, r);
 146         ndr->depth++;
 147         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_NAME_ETC", SAMR_USER_ACCESS_GET_NAME_ETC, r);
 148         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_LOCALE", SAMR_USER_ACCESS_GET_LOCALE, r);
 149         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_SET_LOC_COM", SAMR_USER_ACCESS_SET_LOC_COM, r);
 150         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_LOGONINFO", SAMR_USER_ACCESS_GET_LOGONINFO, r);
 151         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_ATTRIBUTES", SAMR_USER_ACCESS_GET_ATTRIBUTES, r);
 152         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_SET_ATTRIBUTES", SAMR_USER_ACCESS_SET_ATTRIBUTES, r);
 153         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_CHANGE_PASSWORD", SAMR_USER_ACCESS_CHANGE_PASSWORD, r);
 154         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_SET_PASSWORD", SAMR_USER_ACCESS_SET_PASSWORD, r);
 155         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_GROUPS", SAMR_USER_ACCESS_GET_GROUPS, r);
 156         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_GROUP_MEMBERSHIP", SAMR_USER_ACCESS_GET_GROUP_MEMBERSHIP, r);
 157         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_CHANGE_GROUP_MEMBERSHIP", SAMR_USER_ACCESS_CHANGE_GROUP_MEMBERSHIP, r);
 158         ndr->depth--;
 159 }
 160
 161 static enum ndr_err_code ndr_push_samr_DomainAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 162 {
 163         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 164         return NDR_ERR_SUCCESS;
 165 }
 166
 167 static enum ndr_err_code ndr_pull_samr_DomainAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 168 {
 169         uint32_t v;
 170         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 171         *r = v;
 172         return NDR_ERR_SUCCESS;
 173 }
 174
 175 _PUBLIC_ void ndr_print_samr_DomainAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 176 {
 177         ndr_print_uint32(ndr, name, r);
 178         ndr->depth++;
 179         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1", SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1, r);
 180         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_SET_INFO_1", SAMR_DOMAIN_ACCESS_SET_INFO_1, r);
 181         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2", SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2, r);
 182         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_SET_INFO_2", SAMR_DOMAIN_ACCESS_SET_INFO_2, r);
 183         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_CREATE_USER", SAMR_DOMAIN_ACCESS_CREATE_USER, r);
 184         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_CREATE_GROUP", SAMR_DOMAIN_ACCESS_CREATE_GROUP, r);
 185         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_CREATE_ALIAS", SAMR_DOMAIN_ACCESS_CREATE_ALIAS, r);
 186         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS", SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS, r);
 187         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS", SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS, r);
 188         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT", SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT, r);
 189         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_SET_INFO_3", SAMR_DOMAIN_ACCESS_SET_INFO_3, r);
 190         ndr->depth--;
 191 }
 192
 193 static enum ndr_err_code ndr_push_samr_GroupAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 194 {
 195         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 196         return NDR_ERR_SUCCESS;
 197 }
 198
 199 static enum ndr_err_code ndr_pull_samr_GroupAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 200 {
 201         uint32_t v;
 202         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 203         *r = v;
 204         return NDR_ERR_SUCCESS;
 205 }
 206
 207 _PUBLIC_ void ndr_print_samr_GroupAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 208 {
 209         ndr_print_uint32(ndr, name, r);
 210         ndr->depth++;
 211         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_LOOKUP_INFO", SAMR_GROUP_ACCESS_LOOKUP_INFO, r);
 212         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_SET_INFO", SAMR_GROUP_ACCESS_SET_INFO, r);
 213         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_ADD_MEMBER", SAMR_GROUP_ACCESS_ADD_MEMBER, r);
 214         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_REMOVE_MEMBER", SAMR_GROUP_ACCESS_REMOVE_MEMBER, r);
 215         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_GET_MEMBERS", SAMR_GROUP_ACCESS_GET_MEMBERS, r);
 216         ndr->depth--;
 217 }
 218
 219 static enum ndr_err_code ndr_push_samr_AliasAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 220 {
 221         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 222         return NDR_ERR_SUCCESS;
 223 }
 224
 225 static enum ndr_err_code ndr_pull_samr_AliasAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 226 {
 227         uint32_t v;
 228         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 229         *r = v;
 230         return NDR_ERR_SUCCESS;
 231 }
 232
 233 _PUBLIC_ void ndr_print_samr_AliasAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 234 {
 235         ndr_print_uint32(ndr, name, r);
 236         ndr->depth++;
 237         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_ADD_MEMBER", SAMR_ALIAS_ACCESS_ADD_MEMBER, r);
 238         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_REMOVE_MEMBER", SAMR_ALIAS_ACCESS_REMOVE_MEMBER, r);
 239         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_GET_MEMBERS", SAMR_ALIAS_ACCESS_GET_MEMBERS, r);
 240         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_LOOKUP_INFO", SAMR_ALIAS_ACCESS_LOOKUP_INFO, r);
 241         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_SET_INFO", SAMR_ALIAS_ACCESS_SET_INFO, r);
 242         ndr->depth--;
 243 }
 244
 245 static enum ndr_err_code ndr_push_samr_SamEntry(struct ndr_push *ndr, int ndr_flags, const struct samr_SamEntry *r)
 246 {
 247         if (ndr_flags & NDR_SCALARS) {
 248                 NDR_CHECK(ndr_push_align(ndr, 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 size_entries_1 = 0;
 306         uint32_t cntr_entries_1;
 307         TALLOC_CTX *_mem_save_entries_0;
 308         TALLOC_CTX *_mem_save_entries_1;
 309         if (ndr_flags & NDR_SCALARS) {
 310                 NDR_CHECK(ndr_pull_align(ndr, 4));
 311                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 312                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
 313                 if (_ptr_entries) {
 314                         NDR_PULL_ALLOC(ndr, r->entries);
 315                 } else {
 316                         r->entries = NULL;
 317                 }
 318         }
 319         if (ndr_flags & NDR_BUFFERS) {
 320                 if (r->entries) {
 321                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
 322                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 323                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
 324                         size_entries_1 = ndr_get_array_size(ndr, &r->entries);
 325                         NDR_PULL_ALLOC_N(ndr, r->entries, size_entries_1);
 326                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
 327                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 328                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
 329                                 NDR_CHECK(ndr_pull_samr_SamEntry(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 330                         }
 331                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
 332                                 NDR_CHECK(ndr_pull_samr_SamEntry(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 333                         }
 334                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
 335                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
 336                 }
 337                 if (r->entries) {
 338                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
 339                 }
 340         }
 341         return NDR_ERR_SUCCESS;
 342 }
 343
 344 _PUBLIC_ void ndr_print_samr_SamArray(struct ndr_print *ndr, const char *name, const struct samr_SamArray *r)
 345 {
 346         uint32_t cntr_entries_1;
 347         ndr_print_struct(ndr, name, "samr_SamArray");
 348         ndr->depth++;
 349         ndr_print_uint32(ndr, "count", r->count);
 350         ndr_print_ptr(ndr, "entries", r->entries);
 351         ndr->depth++;
 352         if (r->entries) {
 353                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
 354                 ndr->depth++;
 355                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
 356                         char *idx_1=NULL;
 357                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
 358                                 ndr_print_samr_SamEntry(ndr, "entries", &r->entries[cntr_entries_1]);
 359                                 free(idx_1);
 360                         }
 361                 }
 362                 ndr->depth--;
 363         }
 364         ndr->depth--;
 365         ndr->depth--;
 366 }
 367
 368 static enum ndr_err_code ndr_push_samr_Role(struct ndr_push *ndr, int ndr_flags, enum samr_Role r)
 369 {
 370         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 371         return NDR_ERR_SUCCESS;
 372 }
 373
 374 static enum ndr_err_code ndr_pull_samr_Role(struct ndr_pull *ndr, int ndr_flags, enum samr_Role *r)
 375 {
 376         uint32_t v;
 377         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 378         *r = v;
 379         return NDR_ERR_SUCCESS;
 380 }
 381
 382 _PUBLIC_ void ndr_print_samr_Role(struct ndr_print *ndr, const char *name, enum samr_Role r)
 383 {
 384         const char *val = NULL;
 385
 386         switch (r) {
 387                 case SAMR_ROLE_STANDALONE: val = "SAMR_ROLE_STANDALONE"; break;
 388                 case SAMR_ROLE_DOMAIN_MEMBER: val = "SAMR_ROLE_DOMAIN_MEMBER"; break;
 389                 case SAMR_ROLE_DOMAIN_BDC: val = "SAMR_ROLE_DOMAIN_BDC"; break;
 390                 case SAMR_ROLE_DOMAIN_PDC: val = "SAMR_ROLE_DOMAIN_PDC"; break;
 391         }
 392         ndr_print_enum(ndr, name, "ENUM", val, r);
 393 }
 394
 395 _PUBLIC_ enum ndr_err_code ndr_push_samr_PasswordProperties(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 396 {
 397         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 398         return NDR_ERR_SUCCESS;
 399 }
 400
 401 _PUBLIC_ enum ndr_err_code ndr_pull_samr_PasswordProperties(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 402 {
 403         uint32_t v;
 404         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 405         *r = v;
 406         return NDR_ERR_SUCCESS;
 407 }
 408
 409 _PUBLIC_ void ndr_print_samr_PasswordProperties(struct ndr_print *ndr, const char *name, uint32_t r)
 410 {
 411         ndr_print_uint32(ndr, name, r);
 412         ndr->depth++;
 413         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_COMPLEX", DOMAIN_PASSWORD_COMPLEX, r);
 414         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_NO_ANON_CHANGE", DOMAIN_PASSWORD_NO_ANON_CHANGE, r);
 415         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_NO_CLEAR_CHANGE", DOMAIN_PASSWORD_NO_CLEAR_CHANGE, r);
 416         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_LOCKOUT_ADMINS", DOMAIN_PASSWORD_LOCKOUT_ADMINS, r);
 417         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_STORE_CLEARTEXT", DOMAIN_PASSWORD_STORE_CLEARTEXT, r);
 418         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_REFUSE_PASSWORD_CHANGE", DOMAIN_REFUSE_PASSWORD_CHANGE, r);
 419         ndr->depth--;
 420 }
 421
 422 static enum ndr_err_code ndr_push_samr_DomainServerState(struct ndr_push *ndr, int ndr_flags, enum samr_DomainServerState r)
 423 {
 424         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 425         return NDR_ERR_SUCCESS;
 426 }
 427
 428 static enum ndr_err_code ndr_pull_samr_DomainServerState(struct ndr_pull *ndr, int ndr_flags, enum samr_DomainServerState *r)
 429 {
 430         uint32_t v;
 431         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 432         *r = v;
 433         return NDR_ERR_SUCCESS;
 434 }
 435
 436 _PUBLIC_ void ndr_print_samr_DomainServerState(struct ndr_print *ndr, const char *name, enum samr_DomainServerState r)
 437 {
 438         const char *val = NULL;
 439
 440         switch (r) {
 441                 case DOMAIN_SERVER_ENABLED: val = "DOMAIN_SERVER_ENABLED"; break;
 442                 case DOMAIN_SERVER_DISABLED: val = "DOMAIN_SERVER_DISABLED"; break;
 443         }
 444         ndr_print_enum(ndr, name, "ENUM", val, r);
 445 }
 446
 447 static enum ndr_err_code ndr_push_samr_DomInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo1 *r)
 448 {
 449         if (ndr_flags & NDR_SCALARS) {
 450                 NDR_CHECK(ndr_push_align(ndr, 4));
 451                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->min_password_length));
 452                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->password_history_length));
 453                 NDR_CHECK(ndr_push_samr_PasswordProperties(ndr, NDR_SCALARS, r->password_properties));
 454                 NDR_CHECK(ndr_push_dlong(ndr, NDR_SCALARS, r->max_password_age));
 455                 NDR_CHECK(ndr_push_dlong(ndr, NDR_SCALARS, r->min_password_age));
 456         }
 457         if (ndr_flags & NDR_BUFFERS) {
 458         }
 459         return NDR_ERR_SUCCESS;
 460 }
 461
 462 static enum ndr_err_code ndr_pull_samr_DomInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo1 *r)
 463 {
 464         if (ndr_flags & NDR_SCALARS) {
 465                 NDR_CHECK(ndr_pull_align(ndr, 4));
 466                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->min_password_length));
 467                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->password_history_length));
 468                 NDR_CHECK(ndr_pull_samr_PasswordProperties(ndr, NDR_SCALARS, &r->password_properties));
 469                 NDR_CHECK(ndr_pull_dlong(ndr, NDR_SCALARS, &r->max_password_age));
 470                 NDR_CHECK(ndr_pull_dlong(ndr, NDR_SCALARS, &r->min_password_age));
 471         }
 472         if (ndr_flags & NDR_BUFFERS) {
 473         }
 474         return NDR_ERR_SUCCESS;
 475 }
 476
 477 _PUBLIC_ void ndr_print_samr_DomInfo1(struct ndr_print *ndr, const char *name, const struct samr_DomInfo1 *r)
 478 {
 479         ndr_print_struct(ndr, name, "samr_DomInfo1");
 480         ndr->depth++;
 481         ndr_print_uint16(ndr, "min_password_length", r->min_password_length);
 482         ndr_print_uint16(ndr, "password_history_length", r->password_history_length);
 483         ndr_print_samr_PasswordProperties(ndr, "password_properties", r->password_properties);
 484         ndr_print_dlong(ndr, "max_password_age", r->max_password_age);
 485         ndr_print_dlong(ndr, "min_password_age", r->min_password_age);
 486         ndr->depth--;
 487 }
 488
 489 static enum ndr_err_code ndr_push_samr_DomGeneralInformation(struct ndr_push *ndr, int ndr_flags, const struct samr_DomGeneralInformation *r)
 490 {
 491         if (ndr_flags & NDR_SCALARS) {
 492                 NDR_CHECK(ndr_push_align(ndr, 4));
 493                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_logoff_time));
 494                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 495                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 496                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->primary));
 497                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->sequence_num));
 498                 NDR_CHECK(ndr_push_samr_DomainServerState(ndr, NDR_SCALARS, r->domain_server_state));
 499                 NDR_CHECK(ndr_push_samr_Role(ndr, NDR_SCALARS, r->role));
 500                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
 501                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_users));
 502                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_groups));
 503                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_aliases));
 504         }
 505         if (ndr_flags & NDR_BUFFERS) {
 506                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 507                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 508                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 509         }
 510         return NDR_ERR_SUCCESS;
 511 }
 512
 513 static enum ndr_err_code ndr_pull_samr_DomGeneralInformation(struct ndr_pull *ndr, int ndr_flags, struct samr_DomGeneralInformation *r)
 514 {
 515         if (ndr_flags & NDR_SCALARS) {
 516                 NDR_CHECK(ndr_pull_align(ndr, 4));
 517                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_logoff_time));
 518                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 519                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 520                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->primary));
 521                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->sequence_num));
 522                 NDR_CHECK(ndr_pull_samr_DomainServerState(ndr, NDR_SCALARS, &r->domain_server_state));
 523                 NDR_CHECK(ndr_pull_samr_Role(ndr, NDR_SCALARS, &r->role));
 524                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
 525                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_users));
 526                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_groups));
 527                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_aliases));
 528         }
 529         if (ndr_flags & NDR_BUFFERS) {
 530                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 531                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 532                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 533         }
 534         return NDR_ERR_SUCCESS;
 535 }
 536
 537 _PUBLIC_ void ndr_print_samr_DomGeneralInformation(struct ndr_print *ndr, const char *name, const struct samr_DomGeneralInformation *r)
 538 {
 539         ndr_print_struct(ndr, name, "samr_DomGeneralInformation");
 540         ndr->depth++;
 541         ndr_print_NTTIME(ndr, "force_logoff_time", r->force_logoff_time);
 542         ndr_print_lsa_String(ndr, "oem_information", &r->oem_information);
 543         ndr_print_lsa_String(ndr, "domain_name", &r->domain_name);
 544         ndr_print_lsa_String(ndr, "primary", &r->primary);
 545         ndr_print_udlong(ndr, "sequence_num", r->sequence_num);
 546         ndr_print_samr_DomainServerState(ndr, "domain_server_state", r->domain_server_state);
 547         ndr_print_samr_Role(ndr, "role", r->role);
 548         ndr_print_uint32(ndr, "unknown3", r->unknown3);
 549         ndr_print_uint32(ndr, "num_users", r->num_users);
 550         ndr_print_uint32(ndr, "num_groups", r->num_groups);
 551         ndr_print_uint32(ndr, "num_aliases", r->num_aliases);
 552         ndr->depth--;
 553 }
 554
 555 static enum ndr_err_code ndr_push_samr_DomInfo3(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo3 *r)
 556 {
 557         if (ndr_flags & NDR_SCALARS) {
 558                 NDR_CHECK(ndr_push_align(ndr, 4));
 559                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_logoff_time));
 560         }
 561         if (ndr_flags & NDR_BUFFERS) {
 562         }
 563         return NDR_ERR_SUCCESS;
 564 }
 565
 566 static enum ndr_err_code ndr_pull_samr_DomInfo3(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo3 *r)
 567 {
 568         if (ndr_flags & NDR_SCALARS) {
 569                 NDR_CHECK(ndr_pull_align(ndr, 4));
 570                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_logoff_time));
 571         }
 572         if (ndr_flags & NDR_BUFFERS) {
 573         }
 574         return NDR_ERR_SUCCESS;
 575 }
 576
 577 _PUBLIC_ void ndr_print_samr_DomInfo3(struct ndr_print *ndr, const char *name, const struct samr_DomInfo3 *r)
 578 {
 579         ndr_print_struct(ndr, name, "samr_DomInfo3");
 580         ndr->depth++;
 581         ndr_print_NTTIME(ndr, "force_logoff_time", r->force_logoff_time);
 582         ndr->depth--;
 583 }
 584
 585 static enum ndr_err_code ndr_push_samr_DomOEMInformation(struct ndr_push *ndr, int ndr_flags, const struct samr_DomOEMInformation *r)
 586 {
 587         if (ndr_flags & NDR_SCALARS) {
 588                 NDR_CHECK(ndr_push_align(ndr, 4));
 589                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 590         }
 591         if (ndr_flags & NDR_BUFFERS) {
 592                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 593         }
 594         return NDR_ERR_SUCCESS;
 595 }
 596
 597 static enum ndr_err_code ndr_pull_samr_DomOEMInformation(struct ndr_pull *ndr, int ndr_flags, struct samr_DomOEMInformation *r)
 598 {
 599         if (ndr_flags & NDR_SCALARS) {
 600                 NDR_CHECK(ndr_pull_align(ndr, 4));
 601                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 602         }
 603         if (ndr_flags & NDR_BUFFERS) {
 604                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 605         }
 606         return NDR_ERR_SUCCESS;
 607 }
 608
 609 _PUBLIC_ void ndr_print_samr_DomOEMInformation(struct ndr_print *ndr, const char *name, const struct samr_DomOEMInformation *r)
 610 {
 611         ndr_print_struct(ndr, name, "samr_DomOEMInformation");
 612         ndr->depth++;
 613         ndr_print_lsa_String(ndr, "oem_information", &r->oem_information);
 614         ndr->depth--;
 615 }
 616
 617 static enum ndr_err_code ndr_push_samr_DomInfo5(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo5 *r)
 618 {
 619         if (ndr_flags & NDR_SCALARS) {
 620                 NDR_CHECK(ndr_push_align(ndr, 4));
 621                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 622         }
 623         if (ndr_flags & NDR_BUFFERS) {
 624                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 625         }
 626         return NDR_ERR_SUCCESS;
 627 }
 628
 629 static enum ndr_err_code ndr_pull_samr_DomInfo5(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo5 *r)
 630 {
 631         if (ndr_flags & NDR_SCALARS) {
 632                 NDR_CHECK(ndr_pull_align(ndr, 4));
 633                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 634         }
 635         if (ndr_flags & NDR_BUFFERS) {
 636                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 637         }
 638         return NDR_ERR_SUCCESS;
 639 }
 640
 641 _PUBLIC_ void ndr_print_samr_DomInfo5(struct ndr_print *ndr, const char *name, const struct samr_DomInfo5 *r)
 642 {
 643         ndr_print_struct(ndr, name, "samr_DomInfo5");
 644         ndr->depth++;
 645         ndr_print_lsa_String(ndr, "domain_name", &r->domain_name);
 646         ndr->depth--;
 647 }
 648
 649 static enum ndr_err_code ndr_push_samr_DomInfo6(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo6 *r)
 650 {
 651         if (ndr_flags & NDR_SCALARS) {
 652                 NDR_CHECK(ndr_push_align(ndr, 4));
 653                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->primary));
 654         }
 655         if (ndr_flags & NDR_BUFFERS) {
 656                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 657         }
 658         return NDR_ERR_SUCCESS;
 659 }
 660
 661 static enum ndr_err_code ndr_pull_samr_DomInfo6(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo6 *r)
 662 {
 663         if (ndr_flags & NDR_SCALARS) {
 664                 NDR_CHECK(ndr_pull_align(ndr, 4));
 665                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->primary));
 666         }
 667         if (ndr_flags & NDR_BUFFERS) {
 668                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 669         }
 670         return NDR_ERR_SUCCESS;
 671 }
 672
 673 _PUBLIC_ void ndr_print_samr_DomInfo6(struct ndr_print *ndr, const char *name, const struct samr_DomInfo6 *r)
 674 {
 675         ndr_print_struct(ndr, name, "samr_DomInfo6");
 676         ndr->depth++;
 677         ndr_print_lsa_String(ndr, "primary", &r->primary);
 678         ndr->depth--;
 679 }
 680
 681 static enum ndr_err_code ndr_push_samr_DomInfo7(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo7 *r)
 682 {
 683         if (ndr_flags & NDR_SCALARS) {
 684                 NDR_CHECK(ndr_push_align(ndr, 4));
 685                 NDR_CHECK(ndr_push_samr_Role(ndr, NDR_SCALARS, r->role));
 686         }
 687         if (ndr_flags & NDR_BUFFERS) {
 688         }
 689         return NDR_ERR_SUCCESS;
 690 }
 691
 692 static enum ndr_err_code ndr_pull_samr_DomInfo7(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo7 *r)
 693 {
 694         if (ndr_flags & NDR_SCALARS) {
 695                 NDR_CHECK(ndr_pull_align(ndr, 4));
 696                 NDR_CHECK(ndr_pull_samr_Role(ndr, NDR_SCALARS, &r->role));
 697         }
 698         if (ndr_flags & NDR_BUFFERS) {
 699         }
 700         return NDR_ERR_SUCCESS;
 701 }
 702
 703 _PUBLIC_ void ndr_print_samr_DomInfo7(struct ndr_print *ndr, const char *name, const struct samr_DomInfo7 *r)
 704 {
 705         ndr_print_struct(ndr, name, "samr_DomInfo7");
 706         ndr->depth++;
 707         ndr_print_samr_Role(ndr, "role", r->role);
 708         ndr->depth--;
 709 }
 710
 711 static enum ndr_err_code ndr_push_samr_DomInfo8(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo8 *r)
 712 {
 713         if (ndr_flags & NDR_SCALARS) {
 714                 NDR_CHECK(ndr_push_align(ndr, 8));
 715                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->sequence_num));
 716                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->domain_create_time));
 717         }
 718         if (ndr_flags & NDR_BUFFERS) {
 719         }
 720         return NDR_ERR_SUCCESS;
 721 }
 722
 723 static enum ndr_err_code ndr_pull_samr_DomInfo8(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo8 *r)
 724 {
 725         if (ndr_flags & NDR_SCALARS) {
 726                 NDR_CHECK(ndr_pull_align(ndr, 8));
 727                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->sequence_num));
 728                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->domain_create_time));
 729         }
 730         if (ndr_flags & NDR_BUFFERS) {
 731         }
 732         return NDR_ERR_SUCCESS;
 733 }
 734
 735 _PUBLIC_ void ndr_print_samr_DomInfo8(struct ndr_print *ndr, const char *name, const struct samr_DomInfo8 *r)
 736 {
 737         ndr_print_struct(ndr, name, "samr_DomInfo8");
 738         ndr->depth++;
 739         ndr_print_hyper(ndr, "sequence_num", r->sequence_num);
 740         ndr_print_NTTIME(ndr, "domain_create_time", r->domain_create_time);
 741         ndr->depth--;
 742 }
 743
 744 static enum ndr_err_code ndr_push_samr_DomInfo9(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo9 *r)
 745 {
 746         if (ndr_flags & NDR_SCALARS) {
 747                 NDR_CHECK(ndr_push_align(ndr, 4));
 748                 NDR_CHECK(ndr_push_samr_DomainServerState(ndr, NDR_SCALARS, r->domain_server_state));
 749         }
 750         if (ndr_flags & NDR_BUFFERS) {
 751         }
 752         return NDR_ERR_SUCCESS;
 753 }
 754
 755 static enum ndr_err_code ndr_pull_samr_DomInfo9(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo9 *r)
 756 {
 757         if (ndr_flags & NDR_SCALARS) {
 758                 NDR_CHECK(ndr_pull_align(ndr, 4));
 759                 NDR_CHECK(ndr_pull_samr_DomainServerState(ndr, NDR_SCALARS, &r->domain_server_state));
 760         }
 761         if (ndr_flags & NDR_BUFFERS) {
 762         }
 763         return NDR_ERR_SUCCESS;
 764 }
 765
 766 _PUBLIC_ void ndr_print_samr_DomInfo9(struct ndr_print *ndr, const char *name, const struct samr_DomInfo9 *r)
 767 {
 768         ndr_print_struct(ndr, name, "samr_DomInfo9");
 769         ndr->depth++;
 770         ndr_print_samr_DomainServerState(ndr, "domain_server_state", r->domain_server_state);
 771         ndr->depth--;
 772 }
 773
 774 static enum ndr_err_code ndr_push_samr_DomGeneralInformation2(struct ndr_push *ndr, int ndr_flags, const struct samr_DomGeneralInformation2 *r)
 775 {
 776         if (ndr_flags & NDR_SCALARS) {
 777                 NDR_CHECK(ndr_push_align(ndr, 8));
 778                 NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 779                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_duration));
 780                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_window));
 781                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lockout_threshold));
 782         }
 783         if (ndr_flags & NDR_BUFFERS) {
 784                 NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
 785         }
 786         return NDR_ERR_SUCCESS;
 787 }
 788
 789 static enum ndr_err_code ndr_pull_samr_DomGeneralInformation2(struct ndr_pull *ndr, int ndr_flags, struct samr_DomGeneralInformation2 *r)
 790 {
 791         if (ndr_flags & NDR_SCALARS) {
 792                 NDR_CHECK(ndr_pull_align(ndr, 8));
 793                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 794                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_duration));
 795                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_window));
 796                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lockout_threshold));
 797         }
 798         if (ndr_flags & NDR_BUFFERS) {
 799                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
 800         }
 801         return NDR_ERR_SUCCESS;
 802 }
 803
 804 _PUBLIC_ void ndr_print_samr_DomGeneralInformation2(struct ndr_print *ndr, const char *name, const struct samr_DomGeneralInformation2 *r)
 805 {
 806         ndr_print_struct(ndr, name, "samr_DomGeneralInformation2");
 807         ndr->depth++;
 808         ndr_print_samr_DomGeneralInformation(ndr, "general", &r->general);
 809         ndr_print_hyper(ndr, "lockout_duration", r->lockout_duration);
 810         ndr_print_hyper(ndr, "lockout_window", r->lockout_window);
 811         ndr_print_uint16(ndr, "lockout_threshold", r->lockout_threshold);
 812         ndr->depth--;
 813 }
 814
 815 static enum ndr_err_code ndr_push_samr_DomInfo12(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo12 *r)
 816 {
 817         if (ndr_flags & NDR_SCALARS) {
 818                 NDR_CHECK(ndr_push_align(ndr, 8));
 819                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_duration));
 820                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_window));
 821                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lockout_threshold));
 822         }
 823         if (ndr_flags & NDR_BUFFERS) {
 824         }
 825         return NDR_ERR_SUCCESS;
 826 }
 827
 828 static enum ndr_err_code ndr_pull_samr_DomInfo12(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo12 *r)
 829 {
 830         if (ndr_flags & NDR_SCALARS) {
 831                 NDR_CHECK(ndr_pull_align(ndr, 8));
 832                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_duration));
 833                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_window));
 834                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lockout_threshold));
 835         }
 836         if (ndr_flags & NDR_BUFFERS) {
 837         }
 838         return NDR_ERR_SUCCESS;
 839 }
 840
 841 _PUBLIC_ void ndr_print_samr_DomInfo12(struct ndr_print *ndr, const char *name, const struct samr_DomInfo12 *r)
 842 {
 843         ndr_print_struct(ndr, name, "samr_DomInfo12");
 844         ndr->depth++;
 845         ndr_print_hyper(ndr, "lockout_duration", r->lockout_duration);
 846         ndr_print_hyper(ndr, "lockout_window", r->lockout_window);
 847         ndr_print_uint16(ndr, "lockout_threshold", r->lockout_threshold);
 848         ndr->depth--;
 849 }
 850
 851 static enum ndr_err_code ndr_push_samr_DomInfo13(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo13 *r)
 852 {
 853         if (ndr_flags & NDR_SCALARS) {
 854                 NDR_CHECK(ndr_push_align(ndr, 8));
 855                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->sequence_num));
 856                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->domain_create_time));
 857                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->modified_count_at_last_promotion));
 858         }
 859         if (ndr_flags & NDR_BUFFERS) {
 860         }
 861         return NDR_ERR_SUCCESS;
 862 }
 863
 864 static enum ndr_err_code ndr_pull_samr_DomInfo13(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo13 *r)
 865 {
 866         if (ndr_flags & NDR_SCALARS) {
 867                 NDR_CHECK(ndr_pull_align(ndr, 8));
 868                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->sequence_num));
 869                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->domain_create_time));
 870                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->modified_count_at_last_promotion));
 871         }
 872         if (ndr_flags & NDR_BUFFERS) {
 873         }
 874         return NDR_ERR_SUCCESS;
 875 }
 876
 877 _PUBLIC_ void ndr_print_samr_DomInfo13(struct ndr_print *ndr, const char *name, const struct samr_DomInfo13 *r)
 878 {
 879         ndr_print_struct(ndr, name, "samr_DomInfo13");
 880         ndr->depth++;
 881         ndr_print_hyper(ndr, "sequence_num", r->sequence_num);
 882         ndr_print_NTTIME(ndr, "domain_create_time", r->domain_create_time);
 883         ndr_print_hyper(ndr, "modified_count_at_last_promotion", r->modified_count_at_last_promotion);
 884         ndr->depth--;
 885 }
 886
 887 static enum ndr_err_code ndr_push_samr_DomainInfo(struct ndr_push *ndr, int ndr_flags, const union samr_DomainInfo *r)
 888 {
 889         if (ndr_flags & NDR_SCALARS) {
 890                 int level = ndr_push_get_switch_value(ndr, r);
 891                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
 892                 switch (level) {
 893                         case 1: {
 894                                 NDR_CHECK(ndr_push_samr_DomInfo1(ndr, NDR_SCALARS, &r->info1));
 895                         break; }
 896
 897                         case 2: {
 898                                 NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 899                         break; }
 900
 901                         case 3: {
 902                                 NDR_CHECK(ndr_push_samr_DomInfo3(ndr, NDR_SCALARS, &r->info3));
 903                         break; }
 904
 905                         case 4: {
 906                                 NDR_CHECK(ndr_push_samr_DomOEMInformation(ndr, NDR_SCALARS, &r->oem));
 907                         break; }
 908
 909                         case 5: {
 910                                 NDR_CHECK(ndr_push_samr_DomInfo5(ndr, NDR_SCALARS, &r->info5));
 911                         break; }
 912
 913                         case 6: {
 914                                 NDR_CHECK(ndr_push_samr_DomInfo6(ndr, NDR_SCALARS, &r->info6));
 915                         break; }
 916
 917                         case 7: {
 918                                 NDR_CHECK(ndr_push_samr_DomInfo7(ndr, NDR_SCALARS, &r->info7));
 919                         break; }
 920
 921                         case 8: {
 922                                 NDR_CHECK(ndr_push_samr_DomInfo8(ndr, NDR_SCALARS, &r->info8));
 923                         break; }
 924
 925                         case 9: {
 926                                 NDR_CHECK(ndr_push_samr_DomInfo9(ndr, NDR_SCALARS, &r->info9));
 927                         break; }
 928
 929                         case 11: {
 930                                 NDR_CHECK(ndr_push_samr_DomGeneralInformation2(ndr, NDR_SCALARS, &r->general2));
 931                         break; }
 932
 933                         case 12: {
 934                                 NDR_CHECK(ndr_push_samr_DomInfo12(ndr, NDR_SCALARS, &r->info12));
 935                         break; }
 936
 937                         case 13: {
 938                                 NDR_CHECK(ndr_push_samr_DomInfo13(ndr, NDR_SCALARS, &r->info13));
 939                         break; }
 940
 941                         default:
 942                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 943                 }
 944         }
 945         if (ndr_flags & NDR_BUFFERS) {
 946                 int level = ndr_push_get_switch_value(ndr, r);
 947                 switch (level) {
 948                         case 1:
 949                         break;
 950
 951                         case 2:
 952                                 NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
 953                         break;
 954
 955                         case 3:
 956                         break;
 957
 958                         case 4:
 959                                 NDR_CHECK(ndr_push_samr_DomOEMInformation(ndr, NDR_BUFFERS, &r->oem));
 960                         break;
 961
 962                         case 5:
 963                                 NDR_CHECK(ndr_push_samr_DomInfo5(ndr, NDR_BUFFERS, &r->info5));
 964                         break;
 965
 966                         case 6:
 967                                 NDR_CHECK(ndr_push_samr_DomInfo6(ndr, NDR_BUFFERS, &r->info6));
 968                         break;
 969
 970                         case 7:
 971                         break;
 972
 973                         case 8:
 974                         break;
 975
 976                         case 9:
 977                         break;
 978
 979                         case 11:
 980                                 NDR_CHECK(ndr_push_samr_DomGeneralInformation2(ndr, NDR_BUFFERS, &r->general2));
 981                         break;
 982
 983                         case 12:
 984                         break;
 985
 986                         case 13:
 987                         break;
 988
 989                         default:
 990                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 991                 }
 992         }
 993         return NDR_ERR_SUCCESS;
 994 }
 995
 996 static enum ndr_err_code ndr_pull_samr_DomainInfo(struct ndr_pull *ndr, int ndr_flags, union samr_DomainInfo *r)
 997 {
 998         int level;
 999         uint16_t _level;
1000         level = ndr_pull_get_switch_value(ndr, r);
1001         if (ndr_flags & NDR_SCALARS) {
1002                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
1003                 if (_level != level) {
1004                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1005                 }
1006                 switch (level) {
1007                         case 1: {
1008                                 NDR_CHECK(ndr_pull_samr_DomInfo1(ndr, NDR_SCALARS, &r->info1));
1009                         break; }
1010
1011                         case 2: {
1012                                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
1013                         break; }
1014
1015                         case 3: {
1016                                 NDR_CHECK(ndr_pull_samr_DomInfo3(ndr, NDR_SCALARS, &r->info3));
1017                         break; }
1018
1019                         case 4: {
1020                                 NDR_CHECK(ndr_pull_samr_DomOEMInformation(ndr, NDR_SCALARS, &r->oem));
1021                         break; }
1022
1023                         case 5: {
1024                                 NDR_CHECK(ndr_pull_samr_DomInfo5(ndr, NDR_SCALARS, &r->info5));
1025                         break; }
1026
1027                         case 6: {
1028                                 NDR_CHECK(ndr_pull_samr_DomInfo6(ndr, NDR_SCALARS, &r->info6));
1029                         break; }
1030
1031                         case 7: {
1032                                 NDR_CHECK(ndr_pull_samr_DomInfo7(ndr, NDR_SCALARS, &r->info7));
1033                         break; }
1034
1035                         case 8: {
1036                                 NDR_CHECK(ndr_pull_samr_DomInfo8(ndr, NDR_SCALARS, &r->info8));
1037                         break; }
1038
1039                         case 9: {
1040                                 NDR_CHECK(ndr_pull_samr_DomInfo9(ndr, NDR_SCALARS, &r->info9));
1041                         break; }
1042
1043                         case 11: {
1044                                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation2(ndr, NDR_SCALARS, &r->general2));
1045                         break; }
1046
1047                         case 12: {
1048                                 NDR_CHECK(ndr_pull_samr_DomInfo12(ndr, NDR_SCALARS, &r->info12));
1049                         break; }
1050
1051                         case 13: {
1052                                 NDR_CHECK(ndr_pull_samr_DomInfo13(ndr, NDR_SCALARS, &r->info13));
1053                         break; }
1054
1055                         default:
1056                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1057                 }
1058         }
1059         if (ndr_flags & NDR_BUFFERS) {
1060                 switch (level) {
1061                         case 1:
1062                         break;
1063
1064                         case 2:
1065                                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
1066                         break;
1067
1068                         case 3:
1069                         break;
1070
1071                         case 4:
1072                                 NDR_CHECK(ndr_pull_samr_DomOEMInformation(ndr, NDR_BUFFERS, &r->oem));
1073                         break;
1074
1075                         case 5:
1076                                 NDR_CHECK(ndr_pull_samr_DomInfo5(ndr, NDR_BUFFERS, &r->info5));
1077                         break;
1078
1079                         case 6:
1080                                 NDR_CHECK(ndr_pull_samr_DomInfo6(ndr, NDR_BUFFERS, &r->info6));
1081                         break;
1082
1083                         case 7:
1084                         break;
1085
1086                         case 8:
1087                         break;
1088
1089                         case 9:
1090                         break;
1091
1092                         case 11:
1093                                 NDR_CHECK(ndr_pull_samr_DomGeneralInformation2(ndr, NDR_BUFFERS, &r->general2));
1094                         break;
1095
1096                         case 12:
1097                         break;
1098
1099                         case 13:
1100                         break;
1101
1102                         default:
1103                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1104                 }
1105         }
1106         return NDR_ERR_SUCCESS;
1107 }
1108
1109 _PUBLIC_ void ndr_print_samr_DomainInfo(struct ndr_print *ndr, const char *name, const union samr_DomainInfo *r)
1110 {
1111         int level;
1112         level = ndr_print_get_switch_value(ndr, r);
1113         ndr_print_union(ndr, name, level, "samr_DomainInfo");
1114         switch (level) {
1115                 case 1:
1116                         ndr_print_samr_DomInfo1(ndr, "info1", &r->info1);
1117                 break;
1118
1119                 case 2:
1120                         ndr_print_samr_DomGeneralInformation(ndr, "general", &r->general);
1121                 break;
1122
1123                 case 3:
1124                         ndr_print_samr_DomInfo3(ndr, "info3", &r->info3);
1125                 break;
1126
1127                 case 4:
1128                         ndr_print_samr_DomOEMInformation(ndr, "oem", &r->oem);
1129                 break;
1130
1131                 case 5:
1132                         ndr_print_samr_DomInfo5(ndr, "info5", &r->info5);
1133                 break;
1134
1135                 case 6:
1136                         ndr_print_samr_DomInfo6(ndr, "info6", &r->info6);
1137                 break;
1138
1139                 case 7:
1140                         ndr_print_samr_DomInfo7(ndr, "info7", &r->info7);
1141                 break;
1142
1143                 case 8:
1144                         ndr_print_samr_DomInfo8(ndr, "info8", &r->info8);
1145                 break;
1146
1147                 case 9:
1148                         ndr_print_samr_DomInfo9(ndr, "info9", &r->info9);
1149                 break;
1150
1151                 case 11:
1152                         ndr_print_samr_DomGeneralInformation2(ndr, "general2", &r->general2);
1153                 break;
1154
1155                 case 12:
1156                         ndr_print_samr_DomInfo12(ndr, "info12", &r->info12);
1157                 break;
1158
1159                 case 13:
1160                         ndr_print_samr_DomInfo13(ndr, "info13", &r->info13);
1161                 break;
1162
1163                 default:
1164                         ndr_print_bad_level(ndr, name, level);
1165         }
1166 }
1167
1168 static enum ndr_err_code ndr_push_samr_Ids(struct ndr_push *ndr, int ndr_flags, const struct samr_Ids *r)
1169 {
1170         uint32_t cntr_ids_1;
1171         if (ndr_flags & NDR_SCALARS) {
1172                 NDR_CHECK(ndr_push_align(ndr, 4));
1173                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1174                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ids));
1175         }
1176         if (ndr_flags & NDR_BUFFERS) {
1177                 if (r->ids) {
1178                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1179                         for (cntr_ids_1 = 0; cntr_ids_1 < r->count; cntr_ids_1++) {
1180                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ids[cntr_ids_1]));
1181                         }
1182                 }
1183         }
1184         return NDR_ERR_SUCCESS;
1185 }
1186
1187 static enum ndr_err_code ndr_pull_samr_Ids(struct ndr_pull *ndr, int ndr_flags, struct samr_Ids *r)
1188 {
1189         uint32_t _ptr_ids;
1190         uint32_t size_ids_1 = 0;
1191         uint32_t cntr_ids_1;
1192         TALLOC_CTX *_mem_save_ids_0;
1193         TALLOC_CTX *_mem_save_ids_1;
1194         if (ndr_flags & NDR_SCALARS) {
1195                 NDR_CHECK(ndr_pull_align(ndr, 4));
1196                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1197                 if (r->count > 1024) {
1198                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1199                 }
1200                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ids));
1201                 if (_ptr_ids) {
1202                         NDR_PULL_ALLOC(ndr, r->ids);
1203                 } else {
1204                         r->ids = NULL;
1205                 }
1206         }
1207         if (ndr_flags & NDR_BUFFERS) {
1208                 if (r->ids) {
1209                         _mem_save_ids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1210                         NDR_PULL_SET_MEM_CTX(ndr, r->ids, 0);
1211                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ids));
1212                         size_ids_1 = ndr_get_array_size(ndr, &r->ids);
1213                         NDR_PULL_ALLOC_N(ndr, r->ids, size_ids_1);
1214                         _mem_save_ids_1 = NDR_PULL_GET_MEM_CTX(ndr);
1215                         NDR_PULL_SET_MEM_CTX(ndr, r->ids, 0);
1216                         for (cntr_ids_1 = 0; cntr_ids_1 < size_ids_1; cntr_ids_1++) {
1217                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ids[cntr_ids_1]));
1218                         }
1219                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ids_1, 0);
1220                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ids_0, 0);
1221                 }
1222                 if (r->ids) {
1223                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->ids, r->count));
1224                 }
1225         }
1226         return NDR_ERR_SUCCESS;
1227 }
1228
1229 _PUBLIC_ void ndr_print_samr_Ids(struct ndr_print *ndr, const char *name, const struct samr_Ids *r)
1230 {
1231         uint32_t cntr_ids_1;
1232         ndr_print_struct(ndr, name, "samr_Ids");
1233         ndr->depth++;
1234         ndr_print_uint32(ndr, "count", r->count);
1235         ndr_print_ptr(ndr, "ids", r->ids);
1236         ndr->depth++;
1237         if (r->ids) {
1238                 ndr->print(ndr, "%s: ARRAY(%d)", "ids", (int)r->count);
1239                 ndr->depth++;
1240                 for (cntr_ids_1=0;cntr_ids_1<r->count;cntr_ids_1++) {
1241                         char *idx_1=NULL;
1242                         if (asprintf(&idx_1, "[%d]", cntr_ids_1) != -1) {
1243                                 ndr_print_uint32(ndr, "ids", r->ids[cntr_ids_1]);
1244                                 free(idx_1);
1245                         }
1246                 }
1247                 ndr->depth--;
1248         }
1249         ndr->depth--;
1250         ndr->depth--;
1251 }
1252
1253 _PUBLIC_ enum ndr_err_code ndr_push_samr_GroupAttrs(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1254 {
1255         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1256         return NDR_ERR_SUCCESS;
1257 }
1258
1259 _PUBLIC_ enum ndr_err_code ndr_pull_samr_GroupAttrs(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1260 {
1261         uint32_t v;
1262         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1263         *r = v;
1264         return NDR_ERR_SUCCESS;
1265 }
1266
1267 _PUBLIC_ void ndr_print_samr_GroupAttrs(struct ndr_print *ndr, const char *name, uint32_t r)
1268 {
1269         ndr_print_uint32(ndr, name, r);
1270         ndr->depth++;
1271         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_MANDATORY", SE_GROUP_MANDATORY, r);
1272         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_ENABLED_BY_DEFAULT", SE_GROUP_ENABLED_BY_DEFAULT, r);
1273         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_ENABLED", SE_GROUP_ENABLED, r);
1274         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_OWNER", SE_GROUP_OWNER, r);
1275         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_USE_FOR_DENY_ONLY", SE_GROUP_USE_FOR_DENY_ONLY, r);
1276         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_RESOURCE", SE_GROUP_RESOURCE, r);
1277         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_LOGON_ID", SE_GROUP_LOGON_ID, r);
1278         ndr->depth--;
1279 }
1280
1281 static enum ndr_err_code ndr_push_samr_GroupInfoAll(struct ndr_push *ndr, int ndr_flags, const struct samr_GroupInfoAll *r)
1282 {
1283         if (ndr_flags & NDR_SCALARS) {
1284                 NDR_CHECK(ndr_push_align(ndr, 4));
1285                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1286                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
1287                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_members));
1288                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1289         }
1290         if (ndr_flags & NDR_BUFFERS) {
1291                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1292                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1293         }
1294         return NDR_ERR_SUCCESS;
1295 }
1296
1297 static enum ndr_err_code ndr_pull_samr_GroupInfoAll(struct ndr_pull *ndr, int ndr_flags, struct samr_GroupInfoAll *r)
1298 {
1299         if (ndr_flags & NDR_SCALARS) {
1300                 NDR_CHECK(ndr_pull_align(ndr, 4));
1301                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1302                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
1303                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_members));
1304                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1305         }
1306         if (ndr_flags & NDR_BUFFERS) {
1307                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1308                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1309         }
1310         return NDR_ERR_SUCCESS;
1311 }
1312
1313 _PUBLIC_ void ndr_print_samr_GroupInfoAll(struct ndr_print *ndr, const char *name, const struct samr_GroupInfoAll *r)
1314 {
1315         ndr_print_struct(ndr, name, "samr_GroupInfoAll");
1316         ndr->depth++;
1317         ndr_print_lsa_String(ndr, "name", &r->name);
1318         ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);
1319         ndr_print_uint32(ndr, "num_members", r->num_members);
1320         ndr_print_lsa_String(ndr, "description", &r->description);
1321         ndr->depth--;
1322 }
1323
1324 static enum ndr_err_code ndr_push_samr_GroupInfoAttributes(struct ndr_push *ndr, int ndr_flags, const struct samr_GroupInfoAttributes *r)
1325 {
1326         if (ndr_flags & NDR_SCALARS) {
1327                 NDR_CHECK(ndr_push_align(ndr, 4));
1328                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
1329         }
1330         if (ndr_flags & NDR_BUFFERS) {
1331         }
1332         return NDR_ERR_SUCCESS;
1333 }
1334
1335 static enum ndr_err_code ndr_pull_samr_GroupInfoAttributes(struct ndr_pull *ndr, int ndr_flags, struct samr_GroupInfoAttributes *r)
1336 {
1337         if (ndr_flags & NDR_SCALARS) {
1338                 NDR_CHECK(ndr_pull_align(ndr, 4));
1339                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
1340         }
1341         if (ndr_flags & NDR_BUFFERS) {
1342         }
1343         return NDR_ERR_SUCCESS;
1344 }
1345
1346 _PUBLIC_ void ndr_print_samr_GroupInfoAttributes(struct ndr_print *ndr, const char *name, const struct samr_GroupInfoAttributes *r)
1347 {
1348         ndr_print_struct(ndr, name, "samr_GroupInfoAttributes");
1349         ndr->depth++;
1350         ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);
1351         ndr->depth--;
1352 }
1353
1354 static enum ndr_err_code ndr_push_samr_GroupInfoEnum(struct ndr_push *ndr, int ndr_flags, enum samr_GroupInfoEnum r)
1355 {
1356         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
1357         return NDR_ERR_SUCCESS;
1358 }
1359
1360 static enum ndr_err_code ndr_pull_samr_GroupInfoEnum(struct ndr_pull *ndr, int ndr_flags, enum samr_GroupInfoEnum *r)
1361 {
1362         uint16_t v;
1363         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
1364         *r = v;
1365         return NDR_ERR_SUCCESS;
1366 }
1367
1368 _PUBLIC_ void ndr_print_samr_GroupInfoEnum(struct ndr_print *ndr, const char *name, enum samr_GroupInfoEnum r)
1369 {
1370         const char *val = NULL;
1371
1372         switch (r) {
1373                 case GROUPINFOALL: val = "GROUPINFOALL"; break;
1374                 case GROUPINFONAME: val = "GROUPINFONAME"; break;
1375                 case GROUPINFOATTRIBUTES: val = "GROUPINFOATTRIBUTES"; break;
1376                 case GROUPINFODESCRIPTION: val = "GROUPINFODESCRIPTION"; break;
1377                 case GROUPINFOALL2: val = "GROUPINFOALL2"; break;
1378         }
1379         ndr_print_enum(ndr, name, "ENUM", val, r);
1380 }
1381
1382 static enum ndr_err_code ndr_push_samr_GroupInfo(struct ndr_push *ndr, int ndr_flags, const union samr_GroupInfo *r)
1383 {
1384         if (ndr_flags & NDR_SCALARS) {
1385                 int level = ndr_push_get_switch_value(ndr, r);
1386                 NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, level));
1387                 switch (level) {
1388                         case GROUPINFOALL: {
1389                                 NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all));
1390                         break; }
1391
1392                         case GROUPINFONAME: {
1393                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1394                         break; }
1395
1396                         case GROUPINFOATTRIBUTES: {
1397                                 NDR_CHECK(ndr_push_samr_GroupInfoAttributes(ndr, NDR_SCALARS, &r->attributes));
1398                         break; }
1399
1400                         case GROUPINFODESCRIPTION: {
1401                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1402                         break; }
1403
1404                         case GROUPINFOALL2: {
1405                                 NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all2));
1406                         break; }
1407
1408                         default:
1409                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1410                 }
1411         }
1412         if (ndr_flags & NDR_BUFFERS) {
1413                 int level = ndr_push_get_switch_value(ndr, r);
1414                 switch (level) {
1415                         case GROUPINFOALL:
1416                                 NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all));
1417                         break;
1418
1419                         case GROUPINFONAME:
1420                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1421                         break;
1422
1423                         case GROUPINFOATTRIBUTES:
1424                         break;
1425
1426                         case GROUPINFODESCRIPTION:
1427                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1428                         break;
1429
1430                         case GROUPINFOALL2:
1431                                 NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all2));
1432                         break;
1433
1434                         default:
1435                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1436                 }
1437         }
1438         return NDR_ERR_SUCCESS;
1439 }
1440
1441 static enum ndr_err_code ndr_pull_samr_GroupInfo(struct ndr_pull *ndr, int ndr_flags, union samr_GroupInfo *r)
1442 {
1443         int level;
1444         uint16_t _level;
1445         level = ndr_pull_get_switch_value(ndr, r);
1446         if (ndr_flags & NDR_SCALARS) {
1447                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
1448                 if (_level != level) {
1449                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1450                 }
1451                 switch (level) {
1452                         case GROUPINFOALL: {
1453                                 NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all));
1454                         break; }
1455
1456                         case GROUPINFONAME: {
1457                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1458                         break; }
1459
1460                         case GROUPINFOATTRIBUTES: {
1461                                 NDR_CHECK(ndr_pull_samr_GroupInfoAttributes(ndr, NDR_SCALARS, &r->attributes));
1462                         break; }
1463
1464                         case GROUPINFODESCRIPTION: {
1465                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1466                         break; }
1467
1468                         case GROUPINFOALL2: {
1469                                 NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all2));
1470                         break; }
1471
1472                         default:
1473                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1474                 }
1475         }
1476         if (ndr_flags & NDR_BUFFERS) {
1477                 switch (level) {
1478                         case GROUPINFOALL:
1479                                 NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all));
1480                         break;
1481
1482                         case GROUPINFONAME:
1483                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1484                         break;
1485
1486                         case GROUPINFOATTRIBUTES:
1487                         break;
1488
1489                         case GROUPINFODESCRIPTION:
1490                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1491                         break;
1492
1493                         case GROUPINFOALL2:
1494                                 NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all2));
1495                         break;
1496
1497                         default:
1498                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1499                 }
1500         }
1501         return NDR_ERR_SUCCESS;
1502 }
1503
1504 _PUBLIC_ void ndr_print_samr_GroupInfo(struct ndr_print *ndr, const char *name, const union samr_GroupInfo *r)
1505 {
1506         int level;
1507         level = ndr_print_get_switch_value(ndr, r);
1508         ndr_print_union(ndr, name, level, "samr_GroupInfo");
1509         switch (level) {
1510                 case GROUPINFOALL:
1511                         ndr_print_samr_GroupInfoAll(ndr, "all", &r->all);
1512                 break;
1513
1514                 case GROUPINFONAME:
1515                         ndr_print_lsa_String(ndr, "name", &r->name);
1516                 break;
1517
1518                 case GROUPINFOATTRIBUTES:
1519                         ndr_print_samr_GroupInfoAttributes(ndr, "attributes", &r->attributes);
1520                 break;
1521
1522                 case GROUPINFODESCRIPTION:
1523                         ndr_print_lsa_String(ndr, "description", &r->description);
1524                 break;
1525
1526                 case GROUPINFOALL2:
1527                         ndr_print_samr_GroupInfoAll(ndr, "all2", &r->all2);
1528                 break;
1529
1530                 default:
1531                         ndr_print_bad_level(ndr, name, level);
1532         }
1533 }
1534
1535 static enum ndr_err_code ndr_push_samr_RidTypeArray(struct ndr_push *ndr, int ndr_flags, const struct samr_RidTypeArray *r)
1536 {
1537         uint32_t cntr_rids_1;
1538         uint32_t cntr_types_1;
1539         if (ndr_flags & NDR_SCALARS) {
1540                 NDR_CHECK(ndr_push_align(ndr, 4));
1541                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1542                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->rids));
1543                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
1544         }
1545         if (ndr_flags & NDR_BUFFERS) {
1546                 if (r->rids) {
1547                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1548                         for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {
1549                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rids[cntr_rids_1]));
1550                         }
1551                 }
1552                 if (r->types) {
1553                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1554                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
1555                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->types[cntr_types_1]));
1556                         }
1557                 }
1558         }
1559         return NDR_ERR_SUCCESS;
1560 }
1561
1562 static enum ndr_err_code ndr_pull_samr_RidTypeArray(struct ndr_pull *ndr, int ndr_flags, struct samr_RidTypeArray *r)
1563 {
1564         uint32_t _ptr_rids;
1565         uint32_t size_rids_1 = 0;
1566         uint32_t cntr_rids_1;
1567         TALLOC_CTX *_mem_save_rids_0;
1568         TALLOC_CTX *_mem_save_rids_1;
1569         uint32_t _ptr_types;
1570         uint32_t size_types_1 = 0;
1571         uint32_t cntr_types_1;
1572         TALLOC_CTX *_mem_save_types_0;
1573         TALLOC_CTX *_mem_save_types_1;
1574         if (ndr_flags & NDR_SCALARS) {
1575                 NDR_CHECK(ndr_pull_align(ndr, 4));
1576                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1577                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
1578                 if (_ptr_rids) {
1579                         NDR_PULL_ALLOC(ndr, r->rids);
1580                 } else {
1581                         r->rids = NULL;
1582                 }
1583                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
1584                 if (_ptr_types) {
1585                         NDR_PULL_ALLOC(ndr, r->types);
1586                 } else {
1587                         r->types = NULL;
1588                 }
1589         }
1590         if (ndr_flags & NDR_BUFFERS) {
1591                 if (r->rids) {
1592                         _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1593                         NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
1594                         NDR_CHECK(ndr_pull_array_size(ndr, &r->rids));
1595                         size_rids_1 = ndr_get_array_size(ndr, &r->rids);
1596                         NDR_PULL_ALLOC_N(ndr, r->rids, size_rids_1);
1597                         _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
1598                         NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
1599                         for (cntr_rids_1 = 0; cntr_rids_1 < size_rids_1; cntr_rids_1++) {
1600                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));
1601                         }
1602                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
1603                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
1604                 }
1605                 if (r->types) {
1606                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
1607                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
1608                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
1609                         size_types_1 = ndr_get_array_size(ndr, &r->types);
1610                         NDR_PULL_ALLOC_N(ndr, r->types, size_types_1);
1611                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
1612                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
1613                         for (cntr_types_1 = 0; cntr_types_1 < size_types_1; cntr_types_1++) {
1614                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
1615                         }
1616                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
1617                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
1618                 }
1619                 if (r->rids) {
1620                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->rids, r->count));
1621                 }
1622                 if (r->types) {
1623                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
1624                 }
1625         }
1626         return NDR_ERR_SUCCESS;
1627 }
1628
1629 _PUBLIC_ void ndr_print_samr_RidTypeArray(struct ndr_print *ndr, const char *name, const struct samr_RidTypeArray *r)
1630 {
1631         uint32_t cntr_rids_1;
1632         uint32_t cntr_types_1;
1633         ndr_print_struct(ndr, name, "samr_RidTypeArray");
1634         ndr->depth++;
1635         ndr_print_uint32(ndr, "count", r->count);
1636         ndr_print_ptr(ndr, "rids", r->rids);
1637         ndr->depth++;
1638         if (r->rids) {
1639                 ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->count);
1640                 ndr->depth++;
1641                 for (cntr_rids_1=0;cntr_rids_1<r->count;cntr_rids_1++) {
1642                         char *idx_1=NULL;
1643                         if (asprintf(&idx_1, "[%d]", cntr_rids_1) != -1) {
1644                                 ndr_print_uint32(ndr, "rids", r->rids[cntr_rids_1]);
1645                                 free(idx_1);
1646                         }
1647                 }
1648                 ndr->depth--;
1649         }
1650         ndr->depth--;
1651         ndr_print_ptr(ndr, "types", r->types);
1652         ndr->depth++;
1653         if (r->types) {
1654                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
1655                 ndr->depth++;
1656                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
1657                         char *idx_1=NULL;
1658                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
1659                                 ndr_print_uint32(ndr, "types", r->types[cntr_types_1]);
1660                                 free(idx_1);
1661                         }
1662                 }
1663                 ndr->depth--;
1664         }
1665         ndr->depth--;
1666         ndr->depth--;
1667 }
1668
1669 static enum ndr_err_code ndr_push_samr_AliasInfoAll(struct ndr_push *ndr, int ndr_flags, const struct samr_AliasInfoAll *r)
1670 {
1671         if (ndr_flags & NDR_SCALARS) {
1672                 NDR_CHECK(ndr_push_align(ndr, 4));
1673                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1674                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_members));
1675                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1676         }
1677         if (ndr_flags & NDR_BUFFERS) {
1678                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1679                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1680         }
1681         return NDR_ERR_SUCCESS;
1682 }
1683
1684 static enum ndr_err_code ndr_pull_samr_AliasInfoAll(struct ndr_pull *ndr, int ndr_flags, struct samr_AliasInfoAll *r)
1685 {
1686         if (ndr_flags & NDR_SCALARS) {
1687                 NDR_CHECK(ndr_pull_align(ndr, 4));
1688                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1689                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_members));
1690                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1691         }
1692         if (ndr_flags & NDR_BUFFERS) {
1693                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1694                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1695         }
1696         return NDR_ERR_SUCCESS;
1697 }
1698
1699 _PUBLIC_ void ndr_print_samr_AliasInfoAll(struct ndr_print *ndr, const char *name, const struct samr_AliasInfoAll *r)
1700 {
1701         ndr_print_struct(ndr, name, "samr_AliasInfoAll");
1702         ndr->depth++;
1703         ndr_print_lsa_String(ndr, "name", &r->name);
1704         ndr_print_uint32(ndr, "num_members", r->num_members);
1705         ndr_print_lsa_String(ndr, "description", &r->description);
1706         ndr->depth--;
1707 }
1708
1709 static enum ndr_err_code ndr_push_samr_AliasInfoEnum(struct ndr_push *ndr, int ndr_flags, enum samr_AliasInfoEnum r)
1710 {
1711         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
1712         return NDR_ERR_SUCCESS;
1713 }
1714
1715 static enum ndr_err_code ndr_pull_samr_AliasInfoEnum(struct ndr_pull *ndr, int ndr_flags, enum samr_AliasInfoEnum *r)
1716 {
1717         uint16_t v;
1718         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
1719         *r = v;
1720         return NDR_ERR_SUCCESS;
1721 }
1722
1723 _PUBLIC_ void ndr_print_samr_AliasInfoEnum(struct ndr_print *ndr, const char *name, enum samr_AliasInfoEnum r)
1724 {
1725         const char *val = NULL;
1726
1727         switch (r) {
1728                 case ALIASINFOALL: val = "ALIASINFOALL"; break;
1729                 case ALIASINFONAME: val = "ALIASINFONAME"; break;
1730                 case ALIASINFODESCRIPTION: val = "ALIASINFODESCRIPTION"; break;
1731         }
1732         ndr_print_enum(ndr, name, "ENUM", val, r);
1733 }
1734
1735 static enum ndr_err_code ndr_push_samr_AliasInfo(struct ndr_push *ndr, int ndr_flags, const union samr_AliasInfo *r)
1736 {
1737         if (ndr_flags & NDR_SCALARS) {
1738                 int level = ndr_push_get_switch_value(ndr, r);
1739                 NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, level));
1740                 switch (level) {
1741                         case ALIASINFOALL: {
1742                                 NDR_CHECK(ndr_push_samr_AliasInfoAll(ndr, NDR_SCALARS, &r->all));
1743                         break; }
1744
1745                         case ALIASINFONAME: {
1746                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1747                         break; }
1748
1749                         case ALIASINFODESCRIPTION: {
1750                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1751                         break; }
1752
1753                         default:
1754                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1755                 }
1756         }
1757         if (ndr_flags & NDR_BUFFERS) {
1758                 int level = ndr_push_get_switch_value(ndr, r);
1759                 switch (level) {
1760                         case ALIASINFOALL:
1761                                 NDR_CHECK(ndr_push_samr_AliasInfoAll(ndr, NDR_BUFFERS, &r->all));
1762                         break;
1763
1764                         case ALIASINFONAME:
1765                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1766                         break;
1767
1768                         case ALIASINFODESCRIPTION:
1769                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1770                         break;
1771
1772                         default:
1773                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1774                 }
1775         }
1776         return NDR_ERR_SUCCESS;
1777 }
1778
1779 static enum ndr_err_code ndr_pull_samr_AliasInfo(struct ndr_pull *ndr, int ndr_flags, union samr_AliasInfo *r)
1780 {
1781         int level;
1782         uint16_t _level;
1783         level = ndr_pull_get_switch_value(ndr, r);
1784         if (ndr_flags & NDR_SCALARS) {
1785                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
1786                 if (_level != level) {
1787                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1788                 }
1789                 switch (level) {
1790                         case ALIASINFOALL: {
1791                                 NDR_CHECK(ndr_pull_samr_AliasInfoAll(ndr, NDR_SCALARS, &r->all));
1792                         break; }
1793
1794                         case ALIASINFONAME: {
1795                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1796                         break; }
1797
1798                         case ALIASINFODESCRIPTION: {
1799                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1800                         break; }
1801
1802                         default:
1803                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1804                 }
1805         }
1806         if (ndr_flags & NDR_BUFFERS) {
1807                 switch (level) {
1808                         case ALIASINFOALL:
1809                                 NDR_CHECK(ndr_pull_samr_AliasInfoAll(ndr, NDR_BUFFERS, &r->all));
1810                         break;
1811
1812                         case ALIASINFONAME:
1813                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1814                         break;
1815
1816                         case ALIASINFODESCRIPTION:
1817                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1818                         break;
1819
1820                         default:
1821                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1822                 }
1823         }
1824         return NDR_ERR_SUCCESS;
1825 }
1826
1827 _PUBLIC_ void ndr_print_samr_AliasInfo(struct ndr_print *ndr, const char *name, const union samr_AliasInfo *r)
1828 {
1829         int level;
1830         level = ndr_print_get_switch_value(ndr, r);
1831         ndr_print_union(ndr, name, level, "samr_AliasInfo");
1832         switch (level) {
1833                 case ALIASINFOALL:
1834                         ndr_print_samr_AliasInfoAll(ndr, "all", &r->all);
1835                 break;
1836
1837                 case ALIASINFONAME:
1838                         ndr_print_lsa_String(ndr, "name", &r->name);
1839                 break;
1840
1841                 case ALIASINFODESCRIPTION:
1842                         ndr_print_lsa_String(ndr, "description", &r->description);
1843                 break;
1844
1845                 default:
1846                         ndr_print_bad_level(ndr, name, level);
1847         }
1848 }
1849
1850 static enum ndr_err_code ndr_push_samr_UserInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo1 *r)
1851 {
1852         if (ndr_flags & NDR_SCALARS) {
1853                 NDR_CHECK(ndr_push_align(ndr, 4));
1854                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
1855                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
1856                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
1857                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
1858                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));
1859         }
1860         if (ndr_flags & NDR_BUFFERS) {
1861                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
1862                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
1863                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
1864                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));
1865         }
1866         return NDR_ERR_SUCCESS;
1867 }
1868
1869 static enum ndr_err_code ndr_pull_samr_UserInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo1 *r)
1870 {
1871         if (ndr_flags & NDR_SCALARS) {
1872                 NDR_CHECK(ndr_pull_align(ndr, 4));
1873                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
1874                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
1875                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
1876                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
1877                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));
1878         }
1879         if (ndr_flags & NDR_BUFFERS) {
1880                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
1881                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
1882                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
1883                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));
1884         }
1885         return NDR_ERR_SUCCESS;
1886 }
1887
1888 _PUBLIC_ void ndr_print_samr_UserInfo1(struct ndr_print *ndr, const char *name, const struct samr_UserInfo1 *r)
1889 {
1890         ndr_print_struct(ndr, name, "samr_UserInfo1");
1891         ndr->depth++;
1892         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
1893         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
1894         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
1895         ndr_print_lsa_String(ndr, "description", &r->description);
1896         ndr_print_lsa_String(ndr, "comment", &r->comment);
1897         ndr->depth--;
1898 }
1899
1900 static enum ndr_err_code ndr_push_samr_UserInfo2(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo2 *r)
1901 {
1902         if (ndr_flags & NDR_SCALARS) {
1903                 NDR_CHECK(ndr_push_align(ndr, 4));
1904                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));
1905                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->unknown));
1906                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->country_code));
1907                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->code_page));
1908         }
1909         if (ndr_flags & NDR_BUFFERS) {
1910                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));
1911                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->unknown));
1912         }
1913         return NDR_ERR_SUCCESS;
1914 }
1915
1916 static enum ndr_err_code ndr_pull_samr_UserInfo2(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo2 *r)
1917 {
1918         if (ndr_flags & NDR_SCALARS) {
1919                 NDR_CHECK(ndr_pull_align(ndr, 4));
1920                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));
1921                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->unknown));
1922                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->country_code));
1923                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->code_page));
1924         }
1925         if (ndr_flags & NDR_BUFFERS) {
1926                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));
1927                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->unknown));
1928         }
1929         return NDR_ERR_SUCCESS;
1930 }
1931
1932 _PUBLIC_ void ndr_print_samr_UserInfo2(struct ndr_print *ndr, const char *name, const struct samr_UserInfo2 *r)
1933 {
1934         ndr_print_struct(ndr, name, "samr_UserInfo2");
1935         ndr->depth++;
1936         ndr_print_lsa_String(ndr, "comment", &r->comment);
1937         ndr_print_lsa_String(ndr, "unknown", &r->unknown);
1938         ndr_print_uint16(ndr, "country_code", r->country_code);
1939         ndr_print_uint16(ndr, "code_page", r->code_page);
1940         ndr->depth--;
1941 }
1942
1943 _PUBLIC_ enum ndr_err_code ndr_push_samr_LogonHours(struct ndr_push *ndr, int ndr_flags, const struct samr_LogonHours *r)
1944 {
1945         {
1946                 uint32_t _flags_save_STRUCT = ndr->flags;
1947                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1948                 if (ndr_flags & NDR_SCALARS) {
1949                         NDR_CHECK(ndr_push_align(ndr, 4));
1950                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->units_per_week));
1951                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->bits));
1952                 }
1953                 if (ndr_flags & NDR_BUFFERS) {
1954                         if (r->bits) {
1955                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1260));
1956                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1957                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->units_per_week / 8));
1958                                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->bits, r->units_per_week / 8));
1959                         }
1960                 }
1961                 ndr->flags = _flags_save_STRUCT;
1962         }
1963         return NDR_ERR_SUCCESS;
1964 }
1965
1966 _PUBLIC_ enum ndr_err_code ndr_pull_samr_LogonHours(struct ndr_pull *ndr, int ndr_flags, struct samr_LogonHours *r)
1967 {
1968         uint32_t _ptr_bits;
1969         uint32_t size_bits_1 = 0;
1970         uint32_t length_bits_1 = 0;
1971         TALLOC_CTX *_mem_save_bits_0;
1972         {
1973                 uint32_t _flags_save_STRUCT = ndr->flags;
1974                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1975                 if (ndr_flags & NDR_SCALARS) {
1976                         NDR_CHECK(ndr_pull_align(ndr, 4));
1977                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->units_per_week));
1978                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bits));
1979                         if (_ptr_bits) {
1980                                 NDR_PULL_ALLOC(ndr, r->bits);
1981                         } else {
1982                                 r->bits = NULL;
1983                         }
1984                 }
1985                 if (ndr_flags & NDR_BUFFERS) {
1986                         if (r->bits) {
1987                                 _mem_save_bits_0 = NDR_PULL_GET_MEM_CTX(ndr);
1988                                 NDR_PULL_SET_MEM_CTX(ndr, r->bits, 0);
1989                                 NDR_CHECK(ndr_pull_array_size(ndr, &r->bits));
1990                                 NDR_CHECK(ndr_pull_array_length(ndr, &r->bits));
1991                                 size_bits_1 = ndr_get_array_size(ndr, &r->bits);
1992                                 length_bits_1 = ndr_get_array_length(ndr, &r->bits);
1993                                 if (length_bits_1 > size_bits_1) {
1994                                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_bits_1, length_bits_1);
1995                                 }
1996                                 NDR_PULL_ALLOC_N(ndr, r->bits, size_bits_1);
1997                                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->bits, length_bits_1));
1998                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bits_0, 0);
1999                         }
2000                         if (r->bits) {
2001                                 NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->bits, 1260));
2002                         }
2003                         if (r->bits) {
2004                                 NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->bits, r->units_per_week / 8));
2005                         }
2006                 }
2007                 ndr->flags = _flags_save_STRUCT;
2008         }
2009         return NDR_ERR_SUCCESS;
2010 }
2011
2012 _PUBLIC_ void ndr_print_samr_LogonHours(struct ndr_print *ndr, const char *name, const struct samr_LogonHours *r)
2013 {
2014         ndr_print_struct(ndr, name, "samr_LogonHours");
2015         {
2016                 uint32_t _flags_save_STRUCT = ndr->flags;
2017                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2018                 ndr->depth++;
2019                 ndr_print_uint16(ndr, "units_per_week", r->units_per_week);
2020                 ndr_print_ptr(ndr, "bits", r->bits);
2021                 ndr->depth++;
2022                 if (r->bits) {
2023                         ndr_print_array_uint8(ndr, "bits", r->bits, r->units_per_week / 8);
2024                 }
2025                 ndr->depth--;
2026                 ndr->depth--;
2027                 ndr->flags = _flags_save_STRUCT;
2028         }
2029 }
2030
2031 static enum ndr_err_code ndr_push_samr_UserInfo3(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo3 *r)
2032 {
2033         if (ndr_flags & NDR_SCALARS) {
2034                 NDR_CHECK(ndr_push_align(ndr, 4));
2035                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2036                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2037                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
2038                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
2039                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2040                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2041                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2042                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2043                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2044                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));
2045                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));
2046                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));
2047                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->allow_password_change));
2048                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_password_change));
2049                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2050                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));
2051                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
2052                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
2053         }
2054         if (ndr_flags & NDR_BUFFERS) {
2055                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2056                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2057                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2058                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2059                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2060                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2061                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2062                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2063         }
2064         return NDR_ERR_SUCCESS;
2065 }
2066
2067 static enum ndr_err_code ndr_pull_samr_UserInfo3(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo3 *r)
2068 {
2069         if (ndr_flags & NDR_SCALARS) {
2070                 NDR_CHECK(ndr_pull_align(ndr, 4));
2071                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2072                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2073                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
2074                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
2075                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2076                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2077                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2078                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2079                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2080                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));
2081                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));
2082                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));
2083                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->allow_password_change));
2084                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_password_change));
2085                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2086                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));
2087                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
2088                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
2089         }
2090         if (ndr_flags & NDR_BUFFERS) {
2091                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2092                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2093                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2094                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2095                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2096                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2097                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2098                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2099         }
2100         return NDR_ERR_SUCCESS;
2101 }
2102
2103 _PUBLIC_ void ndr_print_samr_UserInfo3(struct ndr_print *ndr, const char *name, const struct samr_UserInfo3 *r)
2104 {
2105         ndr_print_struct(ndr, name, "samr_UserInfo3");
2106         ndr->depth++;
2107         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2108         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2109         ndr_print_uint32(ndr, "rid", r->rid);
2110         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
2111         ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
2112         ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
2113         ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
2114         ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
2115         ndr_print_lsa_String(ndr, "workstations", &r->workstations);
2116         ndr_print_NTTIME(ndr, "last_logon", r->last_logon);
2117         ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);
2118         ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);
2119         ndr_print_NTTIME(ndr, "allow_password_change", r->allow_password_change);
2120         ndr_print_NTTIME(ndr, "force_password_change", r->force_password_change);
2121         ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
2122         ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);
2123         ndr_print_uint16(ndr, "logon_count", r->logon_count);
2124         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
2125         ndr->depth--;
2126 }
2127
2128 static enum ndr_err_code ndr_push_samr_UserInfo4(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo4 *r)
2129 {
2130         if (ndr_flags & NDR_SCALARS) {
2131                 NDR_CHECK(ndr_push_align(ndr, 4));
2132                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2133         }
2134         if (ndr_flags & NDR_BUFFERS) {
2135                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2136         }
2137         return NDR_ERR_SUCCESS;
2138 }
2139
2140 static enum ndr_err_code ndr_pull_samr_UserInfo4(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo4 *r)
2141 {
2142         if (ndr_flags & NDR_SCALARS) {
2143                 NDR_CHECK(ndr_pull_align(ndr, 4));
2144                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2145         }
2146         if (ndr_flags & NDR_BUFFERS) {
2147                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2148         }
2149         return NDR_ERR_SUCCESS;
2150 }
2151
2152 _PUBLIC_ void ndr_print_samr_UserInfo4(struct ndr_print *ndr, const char *name, const struct samr_UserInfo4 *r)
2153 {
2154         ndr_print_struct(ndr, name, "samr_UserInfo4");
2155         ndr->depth++;
2156         ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
2157         ndr->depth--;
2158 }
2159
2160 static enum ndr_err_code ndr_push_samr_UserInfo5(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo5 *r)
2161 {
2162         if (ndr_flags & NDR_SCALARS) {
2163                 NDR_CHECK(ndr_push_align(ndr, 4));
2164                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2165                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2166                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
2167                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
2168                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2169                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2170                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2171                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2172                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
2173                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2174                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));
2175                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));
2176                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2177                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));
2178                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
2179                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));
2180                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
2181                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
2182         }
2183         if (ndr_flags & NDR_BUFFERS) {
2184                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2185                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2186                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2187                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2188                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2189                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2190                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
2191                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2192                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2193         }
2194         return NDR_ERR_SUCCESS;
2195 }
2196
2197 static enum ndr_err_code ndr_pull_samr_UserInfo5(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo5 *r)
2198 {
2199         if (ndr_flags & NDR_SCALARS) {
2200                 NDR_CHECK(ndr_pull_align(ndr, 4));
2201                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2202                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2203                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
2204                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
2205                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2206                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2207                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2208                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2209                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
2210                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2211                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));
2212                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));
2213                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2214                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));
2215                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
2216                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));
2217                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
2218                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
2219         }
2220         if (ndr_flags & NDR_BUFFERS) {
2221                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2222                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2223                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2224                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2225                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2226                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2227                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
2228                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2229                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2230         }
2231         return NDR_ERR_SUCCESS;
2232 }
2233
2234 _PUBLIC_ void ndr_print_samr_UserInfo5(struct ndr_print *ndr, const char *name, const struct samr_UserInfo5 *r)
2235 {
2236         ndr_print_struct(ndr, name, "samr_UserInfo5");
2237         ndr->depth++;
2238         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2239         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2240         ndr_print_uint32(ndr, "rid", r->rid);
2241         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
2242         ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
2243         ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
2244         ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
2245         ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
2246         ndr_print_lsa_String(ndr, "description", &r->description);
2247         ndr_print_lsa_String(ndr, "workstations", &r->workstations);
2248         ndr_print_NTTIME(ndr, "last_logon", r->last_logon);
2249         ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);
2250         ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
2251         ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);
2252         ndr_print_uint16(ndr, "logon_count", r->logon_count);
2253         ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);
2254         ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);
2255         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
2256         ndr->depth--;
2257 }
2258
2259 static enum ndr_err_code ndr_push_samr_UserInfo6(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo6 *r)
2260 {
2261         if (ndr_flags & NDR_SCALARS) {
2262                 NDR_CHECK(ndr_push_align(ndr, 4));
2263                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2264                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2265         }
2266         if (ndr_flags & NDR_BUFFERS) {
2267                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2268                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2269         }
2270         return NDR_ERR_SUCCESS;
2271 }
2272
2273 static enum ndr_err_code ndr_pull_samr_UserInfo6(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo6 *r)
2274 {
2275         if (ndr_flags & NDR_SCALARS) {
2276                 NDR_CHECK(ndr_pull_align(ndr, 4));
2277                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2278                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2279         }
2280         if (ndr_flags & NDR_BUFFERS) {
2281                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2282                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2283         }
2284         return NDR_ERR_SUCCESS;
2285 }
2286
2287 _PUBLIC_ void ndr_print_samr_UserInfo6(struct ndr_print *ndr, const char *name, const struct samr_UserInfo6 *r)
2288 {
2289         ndr_print_struct(ndr, name, "samr_UserInfo6");
2290         ndr->depth++;
2291         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2292         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2293         ndr->depth--;
2294 }
2295
2296 static enum ndr_err_code ndr_push_samr_UserInfo7(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo7 *r)
2297 {
2298         if (ndr_flags & NDR_SCALARS) {
2299                 NDR_CHECK(ndr_push_align(ndr, 4));
2300                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2301         }
2302         if (ndr_flags & NDR_BUFFERS) {
2303                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2304         }
2305         return NDR_ERR_SUCCESS;
2306 }
2307
2308 static enum ndr_err_code ndr_pull_samr_UserInfo7(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo7 *r)
2309 {
2310         if (ndr_flags & NDR_SCALARS) {
2311                 NDR_CHECK(ndr_pull_align(ndr, 4));
2312                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2313         }
2314         if (ndr_flags & NDR_BUFFERS) {
2315                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2316         }
2317         return NDR_ERR_SUCCESS;
2318 }
2319
2320 _PUBLIC_ void ndr_print_samr_UserInfo7(struct ndr_print *ndr, const char *name, const struct samr_UserInfo7 *r)
2321 {
2322         ndr_print_struct(ndr, name, "samr_UserInfo7");
2323         ndr->depth++;
2324         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2325         ndr->depth--;
2326 }
2327
2328 static enum ndr_err_code ndr_push_samr_UserInfo8(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo8 *r)
2329 {
2330         if (ndr_flags & NDR_SCALARS) {
2331                 NDR_CHECK(ndr_push_align(ndr, 4));
2332                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2333         }
2334         if (ndr_flags & NDR_BUFFERS) {
2335                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2336         }
2337         return NDR_ERR_SUCCESS;
2338 }
2339
2340 static enum ndr_err_code ndr_pull_samr_UserInfo8(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo8 *r)
2341 {
2342         if (ndr_flags & NDR_SCALARS) {
2343                 NDR_CHECK(ndr_pull_align(ndr, 4));
2344                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2345         }
2346         if (ndr_flags & NDR_BUFFERS) {
2347                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2348         }
2349         return NDR_ERR_SUCCESS;
2350 }
2351
2352 _PUBLIC_ void ndr_print_samr_UserInfo8(struct ndr_print *ndr, const char *name, const struct samr_UserInfo8 *r)
2353 {
2354         ndr_print_struct(ndr, name, "samr_UserInfo8");
2355         ndr->depth++;
2356         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2357         ndr->depth--;
2358 }
2359
2360 static enum ndr_err_code ndr_push_samr_UserInfo9(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo9 *r)
2361 {
2362         if (ndr_flags & NDR_SCALARS) {
2363                 NDR_CHECK(ndr_push_align(ndr, 4));
2364                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
2365         }
2366         if (ndr_flags & NDR_BUFFERS) {
2367         }
2368         return NDR_ERR_SUCCESS;
2369 }
2370
2371 static enum ndr_err_code ndr_pull_samr_UserInfo9(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo9 *r)
2372 {
2373         if (ndr_flags & NDR_SCALARS) {
2374                 NDR_CHECK(ndr_pull_align(ndr, 4));
2375                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
2376         }
2377         if (ndr_flags & NDR_BUFFERS) {
2378         }
2379         return NDR_ERR_SUCCESS;
2380 }
2381
2382 _PUBLIC_ void ndr_print_samr_UserInfo9(struct ndr_print *ndr, const char *name, const struct samr_UserInfo9 *r)
2383 {
2384         ndr_print_struct(ndr, name, "samr_UserInfo9");
2385         ndr->depth++;
2386         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
2387         ndr->depth--;
2388 }
2389
2390 static enum ndr_err_code ndr_push_samr_UserInfo10(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo10 *r)
2391 {
2392         if (ndr_flags & NDR_SCALARS) {
2393                 NDR_CHECK(ndr_push_align(ndr, 4));
2394                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2395                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2396         }
2397         if (ndr_flags & NDR_BUFFERS) {
2398                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2399                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2400         }
2401         return NDR_ERR_SUCCESS;
2402 }
2403
2404 static enum ndr_err_code ndr_pull_samr_UserInfo10(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo10 *r)
2405 {
2406         if (ndr_flags & NDR_SCALARS) {
2407                 NDR_CHECK(ndr_pull_align(ndr, 4));
2408                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2409                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2410         }
2411         if (ndr_flags & NDR_BUFFERS) {
2412                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2413                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2414         }
2415         return NDR_ERR_SUCCESS;
2416 }
2417
2418 _PUBLIC_ void ndr_print_samr_UserInfo10(struct ndr_print *ndr, const char *name, const struct samr_UserInfo10 *r)
2419 {
2420         ndr_print_struct(ndr, name, "samr_UserInfo10");
2421         ndr->depth++;
2422         ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
2423         ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
2424         ndr->depth--;
2425 }
2426
2427 static enum ndr_err_code ndr_push_samr_UserInfo11(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo11 *r)
2428 {
2429         if (ndr_flags & NDR_SCALARS) {
2430                 NDR_CHECK(ndr_push_align(ndr, 4));
2431                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2432         }
2433         if (ndr_flags & NDR_BUFFERS) {
2434                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2435         }
2436         return NDR_ERR_SUCCESS;
2437 }
2438
2439 static enum ndr_err_code ndr_pull_samr_UserInfo11(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo11 *r)
2440 {
2441         if (ndr_flags & NDR_SCALARS) {
2442                 NDR_CHECK(ndr_pull_align(ndr, 4));
2443                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2444         }
2445         if (ndr_flags & NDR_BUFFERS) {
2446                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2447         }
2448         return NDR_ERR_SUCCESS;
2449 }
2450
2451 _PUBLIC_ void ndr_print_samr_UserInfo11(struct ndr_print *ndr, const char *name, const struct samr_UserInfo11 *r)
2452 {
2453         ndr_print_struct(ndr, name, "samr_UserInfo11");
2454         ndr->depth++;
2455         ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
2456         ndr->depth--;
2457 }
2458
2459 static enum ndr_err_code ndr_push_samr_UserInfo12(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo12 *r)
2460 {
2461         if (ndr_flags & NDR_SCALARS) {
2462                 NDR_CHECK(ndr_push_align(ndr, 4));
2463                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2464         }
2465         if (ndr_flags & NDR_BUFFERS) {
2466                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2467         }
2468         return NDR_ERR_SUCCESS;
2469 }
2470
2471 static enum ndr_err_code ndr_pull_samr_UserInfo12(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo12 *r)
2472 {
2473         if (ndr_flags & NDR_SCALARS) {
2474                 NDR_CHECK(ndr_pull_align(ndr, 4));
2475                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2476         }
2477         if (ndr_flags & NDR_BUFFERS) {
2478                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2479         }
2480         return NDR_ERR_SUCCESS;
2481 }
2482
2483 _PUBLIC_ void ndr_print_samr_UserInfo12(struct ndr_print *ndr, const char *name, const struct samr_UserInfo12 *r)
2484 {
2485         ndr_print_struct(ndr, name, "samr_UserInfo12");
2486         ndr->depth++;
2487         ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
2488         ndr->depth--;
2489 }
2490
2491 static enum ndr_err_code ndr_push_samr_UserInfo13(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo13 *r)
2492 {
2493         if (ndr_flags & NDR_SCALARS) {
2494                 NDR_CHECK(ndr_push_align(ndr, 4));
2495                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
2496         }
2497         if (ndr_flags & NDR_BUFFERS) {
2498                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
2499         }
2500         return NDR_ERR_SUCCESS;
2501 }
2502
2503 static enum ndr_err_code ndr_pull_samr_UserInfo13(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo13 *r)
2504 {
2505         if (ndr_flags & NDR_SCALARS) {
2506                 NDR_CHECK(ndr_pull_align(ndr, 4));
2507                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
2508         }
2509         if (ndr_flags & NDR_BUFFERS) {
2510                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
2511         }
2512         return NDR_ERR_SUCCESS;
2513 }
2514
2515 _PUBLIC_ void ndr_print_samr_UserInfo13(struct ndr_print *ndr, const char *name, const struct samr_UserInfo13 *r)
2516 {
2517         ndr_print_struct(ndr, name, "samr_UserInfo13");
2518         ndr->depth++;
2519         ndr_print_lsa_String(ndr, "description", &r->description);
2520         ndr->depth--;
2521 }
2522
2523 static enum ndr_err_code ndr_push_samr_UserInfo14(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo14 *r)
2524 {
2525         if (ndr_flags & NDR_SCALARS) {
2526                 NDR_CHECK(ndr_push_align(ndr, 4));
2527                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2528         }
2529         if (ndr_flags & NDR_BUFFERS) {
2530                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2531         }
2532         return NDR_ERR_SUCCESS;
2533 }
2534
2535 static enum ndr_err_code ndr_pull_samr_UserInfo14(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo14 *r)
2536 {
2537         if (ndr_flags & NDR_SCALARS) {
2538                 NDR_CHECK(ndr_pull_align(ndr, 4));
2539                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2540         }
2541         if (ndr_flags & NDR_BUFFERS) {
2542                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2543         }
2544         return NDR_ERR_SUCCESS;
2545 }
2546
2547 _PUBLIC_ void ndr_print_samr_UserInfo14(struct ndr_print *ndr, const char *name, const struct samr_UserInfo14 *r)
2548 {
2549         ndr_print_struct(ndr, name, "samr_UserInfo14");
2550         ndr->depth++;
2551         ndr_print_lsa_String(ndr, "workstations", &r->workstations);
2552         ndr->depth--;
2553 }
2554
2555 static enum ndr_err_code ndr_push_samr_UserInfo16(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo16 *r)
2556 {
2557         if (ndr_flags & NDR_SCALARS) {
2558                 NDR_CHECK(ndr_push_align(ndr, 4));
2559                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
2560         }
2561         if (ndr_flags & NDR_BUFFERS) {
2562         }
2563         return NDR_ERR_SUCCESS;
2564 }
2565
2566 static enum ndr_err_code ndr_pull_samr_UserInfo16(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo16 *r)
2567 {
2568         if (ndr_flags & NDR_SCALARS) {
2569                 NDR_CHECK(ndr_pull_align(ndr, 4));
2570                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
2571         }
2572         if (ndr_flags & NDR_BUFFERS) {
2573         }
2574         return NDR_ERR_SUCCESS;
2575 }
2576
2577 _PUBLIC_ void ndr_print_samr_UserInfo16(struct ndr_print *ndr, const char *name, const struct samr_UserInfo16 *r)
2578 {
2579         ndr_print_struct(ndr, name, "samr_UserInfo16");
2580         ndr->depth++;
2581         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
2582         ndr->depth--;
2583 }
2584
2585 static enum ndr_err_code ndr_push_samr_UserInfo17(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo17 *r)
2586 {
2587         if (ndr_flags & NDR_SCALARS) {
2588                 NDR_CHECK(ndr_push_align(ndr, 4));
2589                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
2590         }
2591         if (ndr_flags & NDR_BUFFERS) {
2592         }
2593         return NDR_ERR_SUCCESS;
2594 }
2595
2596 static enum ndr_err_code ndr_pull_samr_UserInfo17(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo17 *r)
2597 {
2598         if (ndr_flags & NDR_SCALARS) {
2599                 NDR_CHECK(ndr_pull_align(ndr, 4));
2600                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
2601         }
2602         if (ndr_flags & NDR_BUFFERS) {
2603         }
2604         return NDR_ERR_SUCCESS;
2605 }
2606
2607 _PUBLIC_ void ndr_print_samr_UserInfo17(struct ndr_print *ndr, const char *name, const struct samr_UserInfo17 *r)
2608 {
2609         ndr_print_struct(ndr, name, "samr_UserInfo17");
2610         ndr->depth++;
2611         ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);
2612         ndr->depth--;
2613 }
2614
2615 _PUBLIC_ enum ndr_err_code ndr_push_samr_Password(struct ndr_push *ndr, int ndr_flags, const struct samr_Password *r)
2616 {
2617         {
2618                 uint32_t _flags_save_STRUCT = ndr->flags;
2619                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2620                 if (ndr_flags & NDR_SCALARS) {
2621                         NDR_CHECK(ndr_push_align(ndr, 1));
2622                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
2623                 }
2624                 if (ndr_flags & NDR_BUFFERS) {
2625                 }
2626                 ndr->flags = _flags_save_STRUCT;
2627         }
2628         return NDR_ERR_SUCCESS;
2629 }
2630
2631 _PUBLIC_ enum ndr_err_code ndr_pull_samr_Password(struct ndr_pull *ndr, int ndr_flags, struct samr_Password *r)
2632 {
2633         uint32_t size_hash_0 = 0;
2634         {
2635                 uint32_t _flags_save_STRUCT = ndr->flags;
2636                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2637                 if (ndr_flags & NDR_SCALARS) {
2638                         NDR_CHECK(ndr_pull_align(ndr, 1));
2639                         size_hash_0 = 16;
2640                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->hash, size_hash_0));
2641                 }
2642                 if (ndr_flags & NDR_BUFFERS) {
2643                 }
2644                 ndr->flags = _flags_save_STRUCT;
2645         }
2646         return NDR_ERR_SUCCESS;
2647 }
2648
2649 _PUBLIC_ void ndr_print_samr_Password(struct ndr_print *ndr, const char *name, const struct samr_Password *r)
2650 {
2651         ndr_print_struct(ndr, name, "samr_Password");
2652         {
2653                 uint32_t _flags_save_STRUCT = ndr->flags;
2654                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2655                 ndr->depth++;
2656                 ndr_print_array_uint8(ndr, "hash", r->hash, 16);
2657                 ndr->depth--;
2658                 ndr->flags = _flags_save_STRUCT;
2659         }
2660 }
2661
2662 static enum ndr_err_code ndr_push_samr_UserInfo18(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo18 *r)
2663 {
2664         if (ndr_flags & NDR_SCALARS) {
2665                 NDR_CHECK(ndr_push_align(ndr, 1));
2666                 NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->nt_pwd));
2667                 NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->lm_pwd));
2668                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->nt_pwd_active));
2669                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->lm_pwd_active));
2670                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
2671         }
2672         if (ndr_flags & NDR_BUFFERS) {
2673         }
2674         return NDR_ERR_SUCCESS;
2675 }
2676
2677 static enum ndr_err_code ndr_pull_samr_UserInfo18(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo18 *r)
2678 {
2679         if (ndr_flags & NDR_SCALARS) {
2680                 NDR_CHECK(ndr_pull_align(ndr, 1));
2681                 NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->nt_pwd));
2682                 NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->lm_pwd));
2683                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->nt_pwd_active));
2684                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->lm_pwd_active));
2685                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
2686         }
2687         if (ndr_flags & NDR_BUFFERS) {
2688         }
2689         return NDR_ERR_SUCCESS;
2690 }
2691
2692 _PUBLIC_ void ndr_print_samr_UserInfo18(struct ndr_print *ndr, const char *name, const struct samr_UserInfo18 *r)
2693 {
2694         ndr_print_struct(ndr, name, "samr_UserInfo18");
2695         ndr->depth++;
2696         ndr_print_samr_Password(ndr, "nt_pwd", &r->nt_pwd);
2697         ndr_print_samr_Password(ndr, "lm_pwd", &r->lm_pwd);
2698         ndr_print_uint8(ndr, "nt_pwd_active", r->nt_pwd_active);
2699         ndr_print_uint8(ndr, "lm_pwd_active", r->lm_pwd_active);
2700         ndr_print_uint8(ndr, "password_expired", r->password_expired);
2701         ndr->depth--;
2702 }
2703
2704 static enum ndr_err_code ndr_push_samr_UserInfo20(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo20 *r)
2705 {
2706         if (ndr_flags & NDR_SCALARS) {
2707                 NDR_CHECK(ndr_push_align(ndr, 4));
2708                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
2709         }
2710         if (ndr_flags & NDR_BUFFERS) {
2711                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
2712         }
2713         return NDR_ERR_SUCCESS;
2714 }
2715
2716 static enum ndr_err_code ndr_pull_samr_UserInfo20(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo20 *r)
2717 {
2718         if (ndr_flags & NDR_SCALARS) {
2719                 NDR_CHECK(ndr_pull_align(ndr, 4));
2720                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
2721         }
2722         if (ndr_flags & NDR_BUFFERS) {
2723                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
2724         }
2725         return NDR_ERR_SUCCESS;
2726 }
2727
2728 _PUBLIC_ void ndr_print_samr_UserInfo20(struct ndr_print *ndr, const char *name, const struct samr_UserInfo20 *r)
2729 {
2730         ndr_print_struct(ndr, name, "samr_UserInfo20");
2731         ndr->depth++;
2732         ndr_print_lsa_BinaryString(ndr, "parameters", &r->parameters);
2733         ndr->depth--;
2734 }
2735
2736 static enum ndr_err_code ndr_push_samr_FieldsPresent(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2737 {
2738         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2739         return NDR_ERR_SUCCESS;
2740 }
2741
2742 static enum ndr_err_code ndr_pull_samr_FieldsPresent(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2743 {
2744         uint32_t v;
2745         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2746         *r = v;
2747         return NDR_ERR_SUCCESS;
2748 }
2749
2750 _PUBLIC_ void ndr_print_samr_FieldsPresent(struct ndr_print *ndr, const char *name, uint32_t r)
2751 {
2752         ndr_print_uint32(ndr, name, r);
2753         ndr->depth++;
2754         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCOUNT_NAME", SAMR_FIELD_ACCOUNT_NAME, r);
2755         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_FULL_NAME", SAMR_FIELD_FULL_NAME, r);
2756         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_RID", SAMR_FIELD_RID, r);
2757         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PRIMARY_GID", SAMR_FIELD_PRIMARY_GID, r);
2758         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_DESCRIPTION", SAMR_FIELD_DESCRIPTION, r);
2759         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_COMMENT", SAMR_FIELD_COMMENT, r);
2760         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_HOME_DIRECTORY", SAMR_FIELD_HOME_DIRECTORY, r);
2761         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_HOME_DRIVE", SAMR_FIELD_HOME_DRIVE, r);
2762         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LOGON_SCRIPT", SAMR_FIELD_LOGON_SCRIPT, r);
2763         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PROFILE_PATH", SAMR_FIELD_PROFILE_PATH, r);
2764         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_WORKSTATIONS", SAMR_FIELD_WORKSTATIONS, r);
2765         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_LOGON", SAMR_FIELD_LAST_LOGON, r);
2766         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_LOGOFF", SAMR_FIELD_LAST_LOGOFF, r);
2767         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LOGON_HOURS", SAMR_FIELD_LOGON_HOURS, r);
2768         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_BAD_PWD_COUNT", SAMR_FIELD_BAD_PWD_COUNT, r);
2769         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_NUM_LOGONS", SAMR_FIELD_NUM_LOGONS, r);
2770         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ALLOW_PWD_CHANGE", SAMR_FIELD_ALLOW_PWD_CHANGE, r);
2771         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_FORCE_PWD_CHANGE", SAMR_FIELD_FORCE_PWD_CHANGE, r);
2772         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_PWD_CHANGE", SAMR_FIELD_LAST_PWD_CHANGE, r);
2773         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCT_EXPIRY", SAMR_FIELD_ACCT_EXPIRY, r);
2774         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCT_FLAGS", SAMR_FIELD_ACCT_FLAGS, r);
2775         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PARAMETERS", SAMR_FIELD_PARAMETERS, r);
2776         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_COUNTRY_CODE", SAMR_FIELD_COUNTRY_CODE, r);
2777         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_CODE_PAGE", SAMR_FIELD_CODE_PAGE, r);
2778         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_NT_PASSWORD_PRESENT", SAMR_FIELD_NT_PASSWORD_PRESENT, r);
2779         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LM_PASSWORD_PRESENT", SAMR_FIELD_LM_PASSWORD_PRESENT, r);
2780         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PRIVATE_DATA", SAMR_FIELD_PRIVATE_DATA, r);
2781         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_EXPIRED_FLAG", SAMR_FIELD_EXPIRED_FLAG, r);
2782         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_SEC_DESC", SAMR_FIELD_SEC_DESC, r);
2783         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_OWF_PWD", SAMR_FIELD_OWF_PWD, r);
2784         ndr->depth--;
2785 }
2786
2787 static enum ndr_err_code ndr_push_samr_UserInfo21(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo21 *r)
2788 {
2789         if (ndr_flags & NDR_SCALARS) {
2790                 NDR_CHECK(ndr_push_align(ndr, 4));
2791                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));
2792                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));
2793                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));
2794                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
2795                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->allow_password_change));
2796                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_password_change));
2797                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2798                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2799                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2800                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2801                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2802                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2803                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
2804                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2805                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));
2806                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
2807                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->lm_owf_password));
2808                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->nt_owf_password));
2809                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->unknown3));
2810                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_count));
2811                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->buffer));
2812                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
2813                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
2814                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
2815                 NDR_CHECK(ndr_push_samr_FieldsPresent(ndr, NDR_SCALARS, r->fields_present));
2816                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2817                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));
2818                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
2819                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->country_code));
2820                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->code_page));
2821                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->lm_password_set));
2822                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->nt_password_set));
2823                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
2824                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->unknown4));
2825         }
2826         if (ndr_flags & NDR_BUFFERS) {
2827                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2828                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2829                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2830                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2831                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2832                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2833                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
2834                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2835                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));
2836                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
2837                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->lm_owf_password));
2838                 NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->nt_owf_password));
2839                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->unknown3));
2840                 if (r->buffer) {
2841                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_count));
2842                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->buffer, r->buf_count));
2843                 }
2844                 NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2845         }
2846         return NDR_ERR_SUCCESS;
2847 }
2848
2849 static enum ndr_err_code ndr_pull_samr_UserInfo21(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo21 *r)
2850 {
2851         uint32_t _ptr_buffer;
2852         uint32_t size_buffer_1 = 0;
2853         TALLOC_CTX *_mem_save_buffer_0;
2854         if (ndr_flags & NDR_SCALARS) {
2855                 NDR_CHECK(ndr_pull_align(ndr, 4));
2856                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));
2857                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));
2858                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));
2859                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
2860                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->allow_password_change));
2861                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_password_change));
2862                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
2863                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
2864                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
2865                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
2866                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
2867                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
2868                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
2869                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
2870                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));
2871                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
2872                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->lm_owf_password));
2873                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->nt_owf_password));
2874                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->unknown3));
2875                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_count));
2876                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
2877                 if (_ptr_buffer) {
2878                         NDR_PULL_ALLOC(ndr, r->buffer);
2879                 } else {
2880                         r->buffer = NULL;
2881                 }
2882                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
2883                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
2884                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
2885                 NDR_CHECK(ndr_pull_samr_FieldsPresent(ndr, NDR_SCALARS, &r->fields_present));
2886                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
2887                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));
2888                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
2889                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->country_code));
2890                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->code_page));
2891                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->lm_password_set));
2892                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->nt_password_set));
2893                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
2894                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->unknown4));
2895         }
2896         if (ndr_flags & NDR_BUFFERS) {
2897                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
2898                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
2899                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
2900                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
2901                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
2902                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
2903                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
2904                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
2905                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));
2906                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
2907                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->lm_owf_password));
2908                 NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->nt_owf_password));
2909                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->unknown3));
2910                 if (r->buffer) {
2911                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
2912                         NDR_PULL_SET_MEM_CTX(ndr, r->buffer, 0);
2913                         NDR_CHECK(ndr_pull_array_size(ndr, &r->buffer));
2914                         size_buffer_1 = ndr_get_array_size(ndr, &r->buffer);
2915                         NDR_PULL_ALLOC_N(ndr, r->buffer, size_buffer_1);
2916                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->buffer, size_buffer_1));
2917                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
2918                 }
2919                 NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
2920                 if (r->buffer) {
2921                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->buffer, r->buf_count));
2922                 }
2923         }
2924         return NDR_ERR_SUCCESS;
2925 }
2926
2927 _PUBLIC_ void ndr_print_samr_UserInfo21(struct ndr_print *ndr, const char *name, const struct samr_UserInfo21 *r)
2928 {
2929         ndr_print_struct(ndr, name, "samr_UserInfo21");
2930         ndr->depth++;
2931         ndr_print_NTTIME(ndr, "last_logon", r->last_logon);
2932         ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);
2933         ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);
2934         ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);
2935         ndr_print_NTTIME(ndr, "allow_password_change", r->allow_password_change);
2936         ndr_print_NTTIME(ndr, "force_password_change", r->force_password_change);
2937         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
2938         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
2939         ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
2940         ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
2941         ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
2942         ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
2943         ndr_print_lsa_String(ndr, "description", &r->description);
2944         ndr_print_lsa_String(ndr, "workstations", &r->workstations);
2945         ndr_print_lsa_String(ndr, "comment", &r->comment);
2946         ndr_print_lsa_BinaryString(ndr, "parameters", &r->parameters);
2947         ndr_print_lsa_BinaryString(ndr, "lm_owf_password", &r->lm_owf_password);
2948         ndr_print_lsa_BinaryString(ndr, "nt_owf_password", &r->nt_owf_password);
2949         ndr_print_lsa_String(ndr, "unknown3", &r->unknown3);
2950         ndr_print_uint32(ndr, "buf_count", r->buf_count);
2951         ndr_print_ptr(ndr, "buffer", r->buffer);
2952         ndr->depth++;
2953         if (r->buffer) {
2954                 ndr_print_array_uint8(ndr, "buffer", r->buffer, r->buf_count);
2955         }
2956         ndr->depth--;
2957         ndr_print_uint32(ndr, "rid", r->rid);
2958         ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
2959         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
2960         ndr_print_samr_FieldsPresent(ndr, "fields_present", r->fields_present);
2961         ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
2962         ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);
2963         ndr_print_uint16(ndr, "logon_count", r->logon_count);
2964         ndr_print_uint16(ndr, "country_code", r->country_code);
2965         ndr_print_uint16(ndr, "code_page", r->code_page);
2966         ndr_print_uint8(ndr, "lm_password_set", r->lm_password_set);
2967         ndr_print_uint8(ndr, "nt_password_set", r->nt_password_set);
2968         ndr_print_uint8(ndr, "password_expired", r->password_expired);
2969         ndr_print_uint8(ndr, "unknown4", r->unknown4);
2970         ndr->depth--;
2971 }
2972
2973 _PUBLIC_ enum ndr_err_code ndr_push_samr_CryptPassword(struct ndr_push *ndr, int ndr_flags, const 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_push_align(ndr, 1));
2980                         NDR_CHECK(ndr_push_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_ enum ndr_err_code ndr_pull_samr_CryptPassword(struct ndr_pull *ndr, int ndr_flags, struct samr_CryptPassword *r)
2990 {
2991         uint32_t size_data_0 = 0;
2992         {
2993                 uint32_t _flags_save_STRUCT = ndr->flags;
2994                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2995                 if (ndr_flags & NDR_SCALARS) {
2996                         NDR_CHECK(ndr_pull_align(ndr, 1));
2997                         size_data_0 = 516;
2998                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, size_data_0));
2999                 }
3000                 if (ndr_flags & NDR_BUFFERS) {
3001                 }
3002                 ndr->flags = _flags_save_STRUCT;
3003         }
3004         return NDR_ERR_SUCCESS;
3005 }
3006
3007 _PUBLIC_ void ndr_print_samr_CryptPassword(struct ndr_print *ndr, const char *name, const struct samr_CryptPassword *r)
3008 {
3009         ndr_print_struct(ndr, name, "samr_CryptPassword");
3010         {
3011                 uint32_t _flags_save_STRUCT = ndr->flags;
3012                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3013                 ndr->depth++;
3014                 ndr_print_array_uint8(ndr, "data", r->data, 516);
3015                 ndr->depth--;
3016                 ndr->flags = _flags_save_STRUCT;
3017         }
3018 }
3019
3020 static enum ndr_err_code ndr_push_samr_UserInfo23(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo23 *r)
3021 {
3022         if (ndr_flags & NDR_SCALARS) {
3023                 NDR_CHECK(ndr_push_align(ndr, 4));
3024                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
3025                 NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
3026         }
3027         if (ndr_flags & NDR_BUFFERS) {
3028                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
3029         }
3030         return NDR_ERR_SUCCESS;
3031 }
3032
3033 static enum ndr_err_code ndr_pull_samr_UserInfo23(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo23 *r)
3034 {
3035         if (ndr_flags & NDR_SCALARS) {
3036                 NDR_CHECK(ndr_pull_align(ndr, 4));
3037                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
3038                 NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
3039         }
3040         if (ndr_flags & NDR_BUFFERS) {
3041                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
3042         }
3043         return NDR_ERR_SUCCESS;
3044 }
3045
3046 _PUBLIC_ void ndr_print_samr_UserInfo23(struct ndr_print *ndr, const char *name, const struct samr_UserInfo23 *r)
3047 {
3048         ndr_print_struct(ndr, name, "samr_UserInfo23");
3049         ndr->depth++;
3050         ndr_print_samr_UserInfo21(ndr, "info", &r->info);
3051         ndr_print_samr_CryptPassword(ndr, "password", &r->password);
3052         ndr->depth--;
3053 }
3054
3055 static enum ndr_err_code ndr_push_samr_UserInfo24(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo24 *r)
3056 {
3057         if (ndr_flags & NDR_SCALARS) {
3058                 NDR_CHECK(ndr_push_align(ndr, 1));
3059                 NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
3060                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
3061         }
3062         if (ndr_flags & NDR_BUFFERS) {
3063         }
3064         return NDR_ERR_SUCCESS;
3065 }
3066
3067 static enum ndr_err_code ndr_pull_samr_UserInfo24(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo24 *r)
3068 {
3069         if (ndr_flags & NDR_SCALARS) {
3070                 NDR_CHECK(ndr_pull_align(ndr, 1));
3071                 NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
3072                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
3073         }
3074         if (ndr_flags & NDR_BUFFERS) {
3075         }
3076         return NDR_ERR_SUCCESS;
3077 }
3078
3079 _PUBLIC_ void ndr_print_samr_UserInfo24(struct ndr_print *ndr, const char *name, const struct samr_UserInfo24 *r)
3080 {
3081         ndr_print_struct(ndr, name, "samr_UserInfo24");
3082         ndr->depth++;
3083         ndr_print_samr_CryptPassword(ndr, "password", &r->password);
3084         ndr_print_uint8(ndr, "password_expired", r->password_expired);
3085         ndr->depth--;
3086 }
3087
3088 static enum ndr_err_code ndr_push_samr_CryptPasswordEx(struct ndr_push *ndr, int ndr_flags, const struct samr_CryptPasswordEx *r)
3089 {
3090         {
3091                 uint32_t _flags_save_STRUCT = ndr->flags;
3092                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3093                 if (ndr_flags & NDR_SCALARS) {
3094                         NDR_CHECK(ndr_push_align(ndr, 1));
3095                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 532));
3096                 }
3097                 if (ndr_flags & NDR_BUFFERS) {
3098                 }
3099                 ndr->flags = _flags_save_STRUCT;
3100         }
3101         return NDR_ERR_SUCCESS;
3102 }
3103
3104 static enum ndr_err_code ndr_pull_samr_CryptPasswordEx(struct ndr_pull *ndr, int ndr_flags, struct samr_CryptPasswordEx *r)
3105 {
3106         uint32_t size_data_0 = 0;
3107         {
3108                 uint32_t _flags_save_STRUCT = ndr->flags;
3109                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3110                 if (ndr_flags & NDR_SCALARS) {
3111                         NDR_CHECK(ndr_pull_align(ndr, 1));
3112                         size_data_0 = 532;
3113                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, size_data_0));
3114                 }
3115                 if (ndr_flags & NDR_BUFFERS) {
3116                 }
3117                 ndr->flags = _flags_save_STRUCT;
3118         }
3119         return NDR_ERR_SUCCESS;
3120 }
3121
3122 _PUBLIC_ void ndr_print_samr_CryptPasswordEx(struct ndr_print *ndr, const char *name, const struct samr_CryptPasswordEx *r)
3123 {
3124         ndr_print_struct(ndr, name, "samr_CryptPasswordEx");
3125         {
3126                 uint32_t _flags_save_STRUCT = ndr->flags;
3127                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3128                 ndr->depth++;
3129                 ndr_print_array_uint8(ndr, "data", r->data, 532);
3130                 ndr->depth--;
3131                 ndr->flags = _flags_save_STRUCT;
3132         }
3133 }
3134
3135 static enum ndr_err_code ndr_push_samr_UserInfo25(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo25 *r)
3136 {
3137         if (ndr_flags & NDR_SCALARS) {
3138                 NDR_CHECK(ndr_push_align(ndr, 4));
3139                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
3140                 NDR_CHECK(ndr_push_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
3141         }
3142         if (ndr_flags & NDR_BUFFERS) {
3143                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
3144         }
3145         return NDR_ERR_SUCCESS;
3146 }
3147
3148 static enum ndr_err_code ndr_pull_samr_UserInfo25(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo25 *r)
3149 {
3150         if (ndr_flags & NDR_SCALARS) {
3151                 NDR_CHECK(ndr_pull_align(ndr, 4));
3152                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
3153                 NDR_CHECK(ndr_pull_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
3154         }
3155         if (ndr_flags & NDR_BUFFERS) {
3156                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
3157         }
3158         return NDR_ERR_SUCCESS;
3159 }
3160
3161 _PUBLIC_ void ndr_print_samr_UserInfo25(struct ndr_print *ndr, const char *name, const struct samr_UserInfo25 *r)
3162 {
3163         ndr_print_struct(ndr, name, "samr_UserInfo25");
3164         ndr->depth++;
3165         ndr_print_samr_UserInfo21(ndr, "info", &r->info);
3166         ndr_print_samr_CryptPasswordEx(ndr, "password", &r->password);
3167         ndr->depth--;
3168 }
3169
3170 static enum ndr_err_code ndr_push_samr_UserInfo26(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo26 *r)
3171 {
3172         if (ndr_flags & NDR_SCALARS) {
3173                 NDR_CHECK(ndr_push_align(ndr, 1));
3174                 NDR_CHECK(ndr_push_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
3175                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
3176         }
3177         if (ndr_flags & NDR_BUFFERS) {
3178         }
3179         return NDR_ERR_SUCCESS;
3180 }
3181
3182 static enum ndr_err_code ndr_pull_samr_UserInfo26(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo26 *r)
3183 {
3184         if (ndr_flags & NDR_SCALARS) {
3185                 NDR_CHECK(ndr_pull_align(ndr, 1));
3186                 NDR_CHECK(ndr_pull_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
3187                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
3188         }
3189         if (ndr_flags & NDR_BUFFERS) {
3190         }
3191         return NDR_ERR_SUCCESS;
3192 }
3193
3194 _PUBLIC_ void ndr_print_samr_UserInfo26(struct ndr_print *ndr, const char *name, const struct samr_UserInfo26 *r)
3195 {
3196         ndr_print_struct(ndr, name, "samr_UserInfo26");
3197         ndr->depth++;
3198         ndr_print_samr_CryptPasswordEx(ndr, "password", &r->password);
3199         ndr_print_uint8(ndr, "password_expired", r->password_expired);
3200         ndr->depth--;
3201 }
3202
3203 static enum ndr_err_code ndr_push_samr_UserInfo(struct ndr_push *ndr, int ndr_flags, const union samr_UserInfo *r)
3204 {
3205         if (ndr_flags & NDR_SCALARS) {
3206                 int level = ndr_push_get_switch_value(ndr, r);
3207                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
3208                 switch (level) {
3209                         case 1: {
3210                                 NDR_CHECK(ndr_push_samr_UserInfo1(ndr, NDR_SCALARS, &r->info1));
3211                         break; }
3212
3213                         case 2: {
3214                                 NDR_CHECK(ndr_push_samr_UserInfo2(ndr, NDR_SCALARS, &r->info2));
3215                         break; }
3216
3217                         case 3: {
3218                                 NDR_CHECK(ndr_push_samr_UserInfo3(ndr, NDR_SCALARS, &r->info3));
3219                         break; }
3220
3221                         case 4: {
3222                                 NDR_CHECK(ndr_push_samr_UserInfo4(ndr, NDR_SCALARS, &r->info4));
3223                         break; }
3224
3225                         case 5: {
3226                                 NDR_CHECK(ndr_push_samr_UserInfo5(ndr, NDR_SCALARS, &r->info5));
3227                         break; }
3228
3229                         case 6: {
3230                                 NDR_CHECK(ndr_push_samr_UserInfo6(ndr, NDR_SCALARS, &r->info6));
3231                         break; }
3232
3233                         case 7: {
3234                                 NDR_CHECK(ndr_push_samr_UserInfo7(ndr, NDR_SCALARS, &r->info7));
3235                         break; }
3236
3237                         case 8: {
3238                                 NDR_CHECK(ndr_push_samr_UserInfo8(ndr, NDR_SCALARS, &r->info8));
3239                         break; }
3240
3241                         case 9: {
3242                                 NDR_CHECK(ndr_push_samr_UserInfo9(ndr, NDR_SCALARS, &r->info9));
3243                         break; }
3244
3245                         case 10: {
3246                                 NDR_CHECK(ndr_push_samr_UserInfo10(ndr, NDR_SCALARS, &r->info10));
3247                         break; }
3248
3249                         case 11: {
3250                                 NDR_CHECK(ndr_push_samr_UserInfo11(ndr, NDR_SCALARS, &r->info11));
3251                         break; }
3252
3253                         case 12: {
3254                                 NDR_CHECK(ndr_push_samr_UserInfo12(ndr, NDR_SCALARS, &r->info12));
3255                         break; }
3256
3257                         case 13: {
3258                                 NDR_CHECK(ndr_push_samr_UserInfo13(ndr, NDR_SCALARS, &r->info13));
3259                         break; }
3260
3261                         case 14: {
3262                                 NDR_CHECK(ndr_push_samr_UserInfo14(ndr, NDR_SCALARS, &r->info14));
3263                         break; }
3264
3265                         case 16: {
3266                                 NDR_CHECK(ndr_push_samr_UserInfo16(ndr, NDR_SCALARS, &r->info16));
3267                         break; }
3268
3269                         case 17: {
3270                                 NDR_CHECK(ndr_push_samr_UserInfo17(ndr, NDR_SCALARS, &r->info17));
3271                         break; }
3272
3273                         case 18: {
3274                                 NDR_CHECK(ndr_push_samr_UserInfo18(ndr, NDR_SCALARS, &r->info18));
3275                         break; }
3276
3277                         case 20: {
3278                                 NDR_CHECK(ndr_push_samr_UserInfo20(ndr, NDR_SCALARS, &r->info20));
3279                         break; }
3280
3281                         case 21: {
3282                                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info21));
3283                         break; }
3284
3285                         case 23: {
3286                                 NDR_CHECK(ndr_push_samr_UserInfo23(ndr, NDR_SCALARS, &r->info23));
3287                         break; }
3288
3289                         case 24: {
3290                                 NDR_CHECK(ndr_push_samr_UserInfo24(ndr, NDR_SCALARS, &r->info24));
3291                         break; }
3292
3293                         case 25: {
3294                                 NDR_CHECK(ndr_push_samr_UserInfo25(ndr, NDR_SCALARS, &r->info25));
3295                         break; }
3296
3297                         case 26: {
3298                                 NDR_CHECK(ndr_push_samr_UserInfo26(ndr, NDR_SCALARS, &r->info26));
3299                         break; }
3300
3301                         default:
3302                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3303                 }
3304         }
3305         if (ndr_flags & NDR_BUFFERS) {
3306                 int level = ndr_push_get_switch_value(ndr, r);
3307                 switch (level) {
3308                         case 1:
3309                                 NDR_CHECK(ndr_push_samr_UserInfo1(ndr, NDR_BUFFERS, &r->info1));
3310                         break;
3311
3312                         case 2:
3313                                 NDR_CHECK(ndr_push_samr_UserInfo2(ndr, NDR_BUFFERS, &r->info2));
3314                         break;
3315
3316                         case 3:
3317                                 NDR_CHECK(ndr_push_samr_UserInfo3(ndr, NDR_BUFFERS, &r->info3));
3318                         break;
3319
3320                         case 4:
3321                                 NDR_CHECK(ndr_push_samr_UserInfo4(ndr, NDR_BUFFERS, &r->info4));
3322                         break;
3323
3324                         case 5:
3325                                 NDR_CHECK(ndr_push_samr_UserInfo5(ndr, NDR_BUFFERS, &r->info5));
3326                         break;
3327
3328                         case 6:
3329                                 NDR_CHECK(ndr_push_samr_UserInfo6(ndr, NDR_BUFFERS, &r->info6));
3330                         break;
3331
3332                         case 7:
3333                                 NDR_CHECK(ndr_push_samr_UserInfo7(ndr, NDR_BUFFERS, &r->info7));
3334                         break;
3335
3336                         case 8:
3337                                 NDR_CHECK(ndr_push_samr_UserInfo8(ndr, NDR_BUFFERS, &r->info8));
3338                         break;
3339
3340                         case 9:
3341                         break;
3342
3343                         case 10:
3344                                 NDR_CHECK(ndr_push_samr_UserInfo10(ndr, NDR_BUFFERS, &r->info10));
3345                         break;
3346
3347                         case 11:
3348                                 NDR_CHECK(ndr_push_samr_UserInfo11(ndr, NDR_BUFFERS, &r->info11));
3349                         break;
3350
3351                         case 12:
3352                                 NDR_CHECK(ndr_push_samr_UserInfo12(ndr, NDR_BUFFERS, &r->info12));
3353                         break;
3354
3355                         case 13:
3356                                 NDR_CHECK(ndr_push_samr_UserInfo13(ndr, NDR_BUFFERS, &r->info13));
3357                         break;
3358
3359                         case 14:
3360                                 NDR_CHECK(ndr_push_samr_UserInfo14(ndr, NDR_BUFFERS, &r->info14));
3361                         break;
3362
3363                         case 16:
3364                         break;
3365
3366                         case 17:
3367                         break;
3368
3369                         case 18:
3370                         break;
3371
3372                         case 20:
3373                                 NDR_CHECK(ndr_push_samr_UserInfo20(ndr, NDR_BUFFERS, &r->info20));
3374                         break;
3375
3376                         case 21:
3377                                 NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info21));
3378                         break;
3379
3380                         case 23:
3381                                 NDR_CHECK(ndr_push_samr_UserInfo23(ndr, NDR_BUFFERS, &r->info23));
3382                         break;
3383
3384                         case 24:
3385                         break;
3386
3387                         case 25:
3388                                 NDR_CHECK(ndr_push_samr_UserInfo25(ndr, NDR_BUFFERS, &r->info25));
3389                         break;
3390
3391                         case 26:
3392                         break;
3393
3394                         default:
3395                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3396                 }
3397         }
3398         return NDR_ERR_SUCCESS;
3399 }
3400
3401 static enum ndr_err_code ndr_pull_samr_UserInfo(struct ndr_pull *ndr, int ndr_flags, union samr_UserInfo *r)
3402 {
3403         int level;
3404         uint16_t _level;
3405         level = ndr_pull_get_switch_value(ndr, r);
3406         if (ndr_flags & NDR_SCALARS) {
3407                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
3408                 if (_level != level) {
3409                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3410                 }
3411                 switch (level) {
3412                         case 1: {
3413                                 NDR_CHECK(ndr_pull_samr_UserInfo1(ndr, NDR_SCALARS, &r->info1));
3414                         break; }
3415
3416                         case 2: {
3417                                 NDR_CHECK(ndr_pull_samr_UserInfo2(ndr, NDR_SCALARS, &r->info2));
3418                         break; }
3419
3420                         case 3: {
3421                                 NDR_CHECK(ndr_pull_samr_UserInfo3(ndr, NDR_SCALARS, &r->info3));
3422                         break; }
3423
3424                         case 4: {
3425                                 NDR_CHECK(ndr_pull_samr_UserInfo4(ndr, NDR_SCALARS, &r->info4));
3426                         break; }
3427
3428                         case 5: {
3429                                 NDR_CHECK(ndr_pull_samr_UserInfo5(ndr, NDR_SCALARS, &r->info5));
3430                         break; }
3431
3432                         case 6: {
3433                                 NDR_CHECK(ndr_pull_samr_UserInfo6(ndr, NDR_SCALARS, &r->info6));
3434                         break; }
3435
3436                         case 7: {
3437                                 NDR_CHECK(ndr_pull_samr_UserInfo7(ndr, NDR_SCALARS, &r->info7));
3438                         break; }
3439
3440                         case 8: {
3441                                 NDR_CHECK(ndr_pull_samr_UserInfo8(ndr, NDR_SCALARS, &r->info8));
3442                         break; }
3443
3444                         case 9: {
3445                                 NDR_CHECK(ndr_pull_samr_UserInfo9(ndr, NDR_SCALARS, &r->info9));
3446                         break; }
3447
3448                         case 10: {
3449                                 NDR_CHECK(ndr_pull_samr_UserInfo10(ndr, NDR_SCALARS, &r->info10));
3450                         break; }
3451
3452                         case 11: {
3453                                 NDR_CHECK(ndr_pull_samr_UserInfo11(ndr, NDR_SCALARS, &r->info11));
3454                         break; }
3455
3456                         case 12: {
3457                                 NDR_CHECK(ndr_pull_samr_UserInfo12(ndr, NDR_SCALARS, &r->info12));
3458                         break; }
3459
3460                         case 13: {
3461                                 NDR_CHECK(ndr_pull_samr_UserInfo13(ndr, NDR_SCALARS, &r->info13));
3462                         break; }
3463
3464                         case 14: {
3465                                 NDR_CHECK(ndr_pull_samr_UserInfo14(ndr, NDR_SCALARS, &r->info14));
3466                         break; }
3467
3468                         case 16: {
3469                                 NDR_CHECK(ndr_pull_samr_UserInfo16(ndr, NDR_SCALARS, &r->info16));
3470                         break; }
3471
3472                         case 17: {
3473                                 NDR_CHECK(ndr_pull_samr_UserInfo17(ndr, NDR_SCALARS, &r->info17));
3474                         break; }
3475
3476                         case 18: {
3477                                 NDR_CHECK(ndr_pull_samr_UserInfo18(ndr, NDR_SCALARS, &r->info18));
3478                         break; }
3479
3480                         case 20: {
3481                                 NDR_CHECK(ndr_pull_samr_UserInfo20(ndr, NDR_SCALARS, &r->info20));
3482                         break; }
3483
3484                         case 21: {
3485                                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info21));
3486                         break; }
3487
3488                         case 23: {
3489                                 NDR_CHECK(ndr_pull_samr_UserInfo23(ndr, NDR_SCALARS, &r->info23));
3490                         break; }
3491
3492                         case 24: {
3493                                 NDR_CHECK(ndr_pull_samr_UserInfo24(ndr, NDR_SCALARS, &r->info24));
3494                         break; }
3495
3496                         case 25: {
3497                                 NDR_CHECK(ndr_pull_samr_UserInfo25(ndr, NDR_SCALARS, &r->info25));
3498                         break; }
3499
3500                         case 26: {
3501                                 NDR_CHECK(ndr_pull_samr_UserInfo26(ndr, NDR_SCALARS, &r->info26));
3502                         break; }
3503
3504                         default:
3505                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3506                 }
3507         }
3508         if (ndr_flags & NDR_BUFFERS) {
3509                 switch (level) {
3510                         case 1:
3511                                 NDR_CHECK(ndr_pull_samr_UserInfo1(ndr, NDR_BUFFERS, &r->info1));
3512                         break;
3513
3514                         case 2:
3515                                 NDR_CHECK(ndr_pull_samr_UserInfo2(ndr, NDR_BUFFERS, &r->info2));
3516                         break;
3517
3518                         case 3:
3519                                 NDR_CHECK(ndr_pull_samr_UserInfo3(ndr, NDR_BUFFERS, &r->info3));
3520                         break;
3521
3522                         case 4:
3523                                 NDR_CHECK(ndr_pull_samr_UserInfo4(ndr, NDR_BUFFERS, &r->info4));
3524                         break;
3525
3526                         case 5:
3527                                 NDR_CHECK(ndr_pull_samr_UserInfo5(ndr, NDR_BUFFERS, &r->info5));
3528                         break;
3529
3530                         case 6:
3531                                 NDR_CHECK(ndr_pull_samr_UserInfo6(ndr, NDR_BUFFERS, &r->info6));
3532                         break;
3533
3534                         case 7:
3535                                 NDR_CHECK(ndr_pull_samr_UserInfo7(ndr, NDR_BUFFERS, &r->info7));
3536                         break;
3537
3538                         case 8:
3539                                 NDR_CHECK(ndr_pull_samr_UserInfo8(ndr, NDR_BUFFERS, &r->info8));
3540                         break;
3541
3542                         case 9:
3543                         break;
3544
3545                         case 10:
3546                                 NDR_CHECK(ndr_pull_samr_UserInfo10(ndr, NDR_BUFFERS, &r->info10));
3547                         break;
3548
3549                         case 11:
3550                                 NDR_CHECK(ndr_pull_samr_UserInfo11(ndr, NDR_BUFFERS, &r->info11));
3551                         break;
3552
3553                         case 12:
3554                                 NDR_CHECK(ndr_pull_samr_UserInfo12(ndr, NDR_BUFFERS, &r->info12));
3555                         break;
3556
3557                         case 13:
3558                                 NDR_CHECK(ndr_pull_samr_UserInfo13(ndr, NDR_BUFFERS, &r->info13));
3559                         break;
3560
3561                         case 14:
3562                                 NDR_CHECK(ndr_pull_samr_UserInfo14(ndr, NDR_BUFFERS, &r->info14));
3563                         break;
3564
3565                         case 16:
3566                         break;
3567
3568                         case 17:
3569                         break;
3570
3571                         case 18:
3572                         break;
3573
3574                         case 20:
3575                                 NDR_CHECK(ndr_pull_samr_UserInfo20(ndr, NDR_BUFFERS, &r->info20));
3576                         break;
3577
3578                         case 21:
3579                                 NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info21));
3580                         break;
3581
3582                         case 23:
3583                                 NDR_CHECK(ndr_pull_samr_UserInfo23(ndr, NDR_BUFFERS, &r->info23));
3584                         break;
3585
3586                         case 24:
3587                         break;
3588
3589                         case 25:
3590                                 NDR_CHECK(ndr_pull_samr_UserInfo25(ndr, NDR_BUFFERS, &r->info25));
3591                         break;
3592
3593                         case 26:
3594                         break;
3595
3596                         default:
3597                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3598                 }
3599         }
3600         return NDR_ERR_SUCCESS;
3601 }
3602
3603 _PUBLIC_ void ndr_print_samr_UserInfo(struct ndr_print *ndr, const char *name, const union samr_UserInfo *r)
3604 {
3605         int level;
3606         level = ndr_print_get_switch_value(ndr, r);
3607         ndr_print_union(ndr, name, level, "samr_UserInfo");
3608         switch (level) {
3609                 case 1:
3610                         ndr_print_samr_UserInfo1(ndr, "info1", &r->info1);
3611                 break;
3612
3613                 case 2:
3614                         ndr_print_samr_UserInfo2(ndr, "info2", &r->info2);
3615                 break;
3616
3617                 case 3:
3618                         ndr_print_samr_UserInfo3(ndr, "info3", &r->info3);
3619                 break;
3620
3621                 case 4:
3622                         ndr_print_samr_UserInfo4(ndr, "info4", &r->info4);
3623                 break;
3624
3625                 case 5:
3626                         ndr_print_samr_UserInfo5(ndr, "info5", &r->info5);
3627                 break;
3628
3629                 case 6:
3630                         ndr_print_samr_UserInfo6(ndr, "info6", &r->info6);
3631                 break;
3632
3633                 case 7:
3634                         ndr_print_samr_UserInfo7(ndr, "info7", &r->info7);
3635                 break;
3636
3637                 case 8:
3638                         ndr_print_samr_UserInfo8(ndr, "info8", &r->info8);
3639                 break;
3640
3641                 case 9:
3642                         ndr_print_samr_UserInfo9(ndr, "info9", &r->info9);
3643                 break;
3644
3645                 case 10:
3646                         ndr_print_samr_UserInfo10(ndr, "info10", &r->info10);
3647                 break;
3648
3649                 case 11:
3650                         ndr_print_samr_UserInfo11(ndr, "info11", &r->info11);
3651                 break;
3652
3653                 case 12:
3654                         ndr_print_samr_UserInfo12(ndr, "info12", &r->info12);
3655                 break;
3656
3657                 case 13:
3658                         ndr_print_samr_UserInfo13(ndr, "info13", &r->info13);
3659                 break;
3660
3661                 case 14:
3662                         ndr_print_samr_UserInfo14(ndr, "info14", &r->info14);
3663                 break;
3664
3665                 case 16:
3666                         ndr_print_samr_UserInfo16(ndr, "info16", &r->info16);
3667                 break;
3668
3669                 case 17:
3670                         ndr_print_samr_UserInfo17(ndr, "info17", &r->info17);
3671                 break;
3672
3673                 case 18:
3674                         ndr_print_samr_UserInfo18(ndr, "info18", &r->info18);
3675                 break;
3676
3677                 case 20:
3678                         ndr_print_samr_UserInfo20(ndr, "info20", &r->info20);
3679                 break;
3680
3681                 case 21:
3682                         ndr_print_samr_UserInfo21(ndr, "info21", &r->info21);
3683                 break;
3684
3685                 case 23:
3686                         ndr_print_samr_UserInfo23(ndr, "info23", &r->info23);
3687                 break;
3688
3689                 case 24:
3690                         ndr_print_samr_UserInfo24(ndr, "info24", &r->info24);
3691                 break;
3692
3693                 case 25:
3694                         ndr_print_samr_UserInfo25(ndr, "info25", &r->info25);
3695                 break;
3696
3697                 case 26:
3698                         ndr_print_samr_UserInfo26(ndr, "info26", &r->info26);
3699                 break;
3700
3701                 default:
3702                         ndr_print_bad_level(ndr, name, level);
3703         }
3704 }
3705
3706 _PUBLIC_ enum ndr_err_code ndr_push_samr_RidWithAttribute(struct ndr_push *ndr, int ndr_flags, const struct samr_RidWithAttribute *r)
3707 {
3708         if (ndr_flags & NDR_SCALARS) {
3709                 NDR_CHECK(ndr_push_align(ndr, 4));
3710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
3711                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
3712         }
3713         if (ndr_flags & NDR_BUFFERS) {
3714         }
3715         return NDR_ERR_SUCCESS;
3716 }
3717
3718 _PUBLIC_ enum ndr_err_code ndr_pull_samr_RidWithAttribute(struct ndr_pull *ndr, int ndr_flags, struct samr_RidWithAttribute *r)
3719 {
3720         if (ndr_flags & NDR_SCALARS) {
3721                 NDR_CHECK(ndr_pull_align(ndr, 4));
3722                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
3723                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
3724         }
3725         if (ndr_flags & NDR_BUFFERS) {
3726         }
3727         return NDR_ERR_SUCCESS;
3728 }
3729
3730 _PUBLIC_ void ndr_print_samr_RidWithAttribute(struct ndr_print *ndr, const char *name, const struct samr_RidWithAttribute *r)
3731 {
3732         ndr_print_struct(ndr, name, "samr_RidWithAttribute");
3733         ndr->depth++;
3734         ndr_print_uint32(ndr, "rid", r->rid);
3735         ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);
3736         ndr->depth--;
3737 }
3738
3739 _PUBLIC_ enum ndr_err_code ndr_push_samr_RidWithAttributeArray(struct ndr_push *ndr, int ndr_flags, const struct samr_RidWithAttributeArray *r)
3740 {
3741         uint32_t cntr_rids_1;
3742         if (ndr_flags & NDR_SCALARS) {
3743                 NDR_CHECK(ndr_push_align(ndr, 4));
3744                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3745                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->rids));
3746         }
3747         if (ndr_flags & NDR_BUFFERS) {
3748                 if (r->rids) {
3749                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3750                         for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {
3751                                 NDR_CHECK(ndr_push_samr_RidWithAttribute(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));
3752                         }
3753                 }
3754         }
3755         return NDR_ERR_SUCCESS;
3756 }
3757
3758 _PUBLIC_ enum ndr_err_code ndr_pull_samr_RidWithAttributeArray(struct ndr_pull *ndr, int ndr_flags, struct samr_RidWithAttributeArray *r)
3759 {
3760         uint32_t _ptr_rids;
3761         uint32_t size_rids_1 = 0;
3762         uint32_t cntr_rids_1;
3763         TALLOC_CTX *_mem_save_rids_0;
3764         TALLOC_CTX *_mem_save_rids_1;
3765         if (ndr_flags & NDR_SCALARS) {
3766                 NDR_CHECK(ndr_pull_align(ndr, 4));
3767                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3768                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
3769                 if (_ptr_rids) {
3770                         NDR_PULL_ALLOC(ndr, r->rids);
3771                 } else {
3772                         r->rids = NULL;
3773                 }
3774         }
3775         if (ndr_flags & NDR_BUFFERS) {
3776                 if (r->rids) {
3777                         _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
3778                         NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
3779                         NDR_CHECK(ndr_pull_array_size(ndr, &r->rids));
3780                         size_rids_1 = ndr_get_array_size(ndr, &r->rids);
3781                         NDR_PULL_ALLOC_N(ndr, r->rids, size_rids_1);
3782                         _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
3783                         NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
3784                         for (cntr_rids_1 = 0; cntr_rids_1 < size_rids_1; cntr_rids_1++) {
3785                                 NDR_CHECK(ndr_pull_samr_RidWithAttribute(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));
3786                         }
3787                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
3788                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
3789                 }
3790                 if (r->rids) {
3791                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->rids, r->count));
3792                 }
3793         }
3794         return NDR_ERR_SUCCESS;
3795 }
3796
3797 _PUBLIC_ void ndr_print_samr_RidWithAttributeArray(struct ndr_print *ndr, const char *name, const struct samr_RidWithAttributeArray *r)
3798 {
3799         uint32_t cntr_rids_1;
3800         ndr_print_struct(ndr, name, "samr_RidWithAttributeArray");
3801         ndr->depth++;
3802         ndr_print_uint32(ndr, "count", r->count);
3803         ndr_print_ptr(ndr, "rids", r->rids);
3804         ndr->depth++;
3805         if (r->rids) {
3806                 ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->count);
3807                 ndr->depth++;
3808                 for (cntr_rids_1=0;cntr_rids_1<r->count;cntr_rids_1++) {
3809                         char *idx_1=NULL;
3810                         if (asprintf(&idx_1, "[%d]", cntr_rids_1) != -1) {
3811                                 ndr_print_samr_RidWithAttribute(ndr, "rids", &r->rids[cntr_rids_1]);
3812                                 free(idx_1);
3813                         }
3814                 }
3815                 ndr->depth--;
3816         }
3817         ndr->depth--;
3818         ndr->depth--;
3819 }
3820
3821 static enum ndr_err_code ndr_push_samr_DispEntryGeneral(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryGeneral *r)
3822 {
3823         if (ndr_flags & NDR_SCALARS) {
3824                 NDR_CHECK(ndr_push_align(ndr, 4));
3825                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
3826                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
3827                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
3828                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
3829                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
3830                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
3831         }
3832         if (ndr_flags & NDR_BUFFERS) {
3833                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
3834                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
3835                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
3836         }
3837         return NDR_ERR_SUCCESS;
3838 }
3839
3840 static enum ndr_err_code ndr_pull_samr_DispEntryGeneral(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryGeneral *r)
3841 {
3842         if (ndr_flags & NDR_SCALARS) {
3843                 NDR_CHECK(ndr_pull_align(ndr, 4));
3844                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
3845                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
3846                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
3847                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
3848                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
3849                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
3850         }
3851         if (ndr_flags & NDR_BUFFERS) {
3852                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
3853                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
3854                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
3855         }
3856         return NDR_ERR_SUCCESS;
3857 }
3858
3859 _PUBLIC_ void ndr_print_samr_DispEntryGeneral(struct ndr_print *ndr, const char *name, const struct samr_DispEntryGeneral *r)
3860 {
3861         ndr_print_struct(ndr, name, "samr_DispEntryGeneral");
3862         ndr->depth++;
3863         ndr_print_uint32(ndr, "idx", r->idx);
3864         ndr_print_uint32(ndr, "rid", r->rid);
3865         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
3866         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
3867         ndr_print_lsa_String(ndr, "description", &r->description);
3868         ndr_print_lsa_String(ndr, "full_name", &r->full_name);
3869         ndr->depth--;
3870 }
3871
3872 static enum ndr_err_code ndr_push_samr_DispInfoGeneral(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoGeneral *r)
3873 {
3874         uint32_t cntr_entries_1;
3875         if (ndr_flags & NDR_SCALARS) {
3876                 NDR_CHECK(ndr_push_align(ndr, 4));
3877                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3878                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
3879         }
3880         if (ndr_flags & NDR_BUFFERS) {
3881                 if (r->entries) {
3882                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3883                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
3884                                 NDR_CHECK(ndr_push_samr_DispEntryGeneral(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
3885                         }
3886                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
3887                                 NDR_CHECK(ndr_push_samr_DispEntryGeneral(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
3888                         }
3889                 }
3890         }
3891         return NDR_ERR_SUCCESS;
3892 }
3893
3894 static enum ndr_err_code ndr_pull_samr_DispInfoGeneral(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoGeneral *r)
3895 {
3896         uint32_t _ptr_entries;
3897         uint32_t size_entries_1 = 0;
3898         uint32_t cntr_entries_1;
3899         TALLOC_CTX *_mem_save_entries_0;
3900         TALLOC_CTX *_mem_save_entries_1;
3901         if (ndr_flags & NDR_SCALARS) {
3902                 NDR_CHECK(ndr_pull_align(ndr, 4));
3903                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3904                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
3905                 if (_ptr_entries) {
3906                         NDR_PULL_ALLOC(ndr, r->entries);
3907                 } else {
3908                         r->entries = NULL;
3909                 }
3910         }
3911         if (ndr_flags & NDR_BUFFERS) {
3912                 if (r->entries) {
3913                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
3914                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
3915                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
3916                         size_entries_1 = ndr_get_array_size(ndr, &r->entries);
3917                         NDR_PULL_ALLOC_N(ndr, r->entries, size_entries_1);
3918                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
3919                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
3920                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
3921                                 NDR_CHECK(ndr_pull_samr_DispEntryGeneral(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
3922                         }
3923                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
3924                                 NDR_CHECK(ndr_pull_samr_DispEntryGeneral(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
3925                         }
3926                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
3927                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
3928                 }
3929                 if (r->entries) {
3930                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
3931                 }
3932         }
3933         return NDR_ERR_SUCCESS;
3934 }
3935
3936 _PUBLIC_ void ndr_print_samr_DispInfoGeneral(struct ndr_print *ndr, const char *name, const struct samr_DispInfoGeneral *r)
3937 {
3938         uint32_t cntr_entries_1;
3939         ndr_print_struct(ndr, name, "samr_DispInfoGeneral");
3940         ndr->depth++;
3941         ndr_print_uint32(ndr, "count", r->count);
3942         ndr_print_ptr(ndr, "entries", r->entries);
3943         ndr->depth++;
3944         if (r->entries) {
3945                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
3946                 ndr->depth++;
3947                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
3948                         char *idx_1=NULL;
3949                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
3950                                 ndr_print_samr_DispEntryGeneral(ndr, "entries", &r->entries[cntr_entries_1]);
3951                                 free(idx_1);
3952                         }
3953                 }
3954                 ndr->depth--;
3955         }
3956         ndr->depth--;
3957         ndr->depth--;
3958 }
3959
3960 static enum ndr_err_code ndr_push_samr_DispEntryFull(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryFull *r)
3961 {
3962         if (ndr_flags & NDR_SCALARS) {
3963                 NDR_CHECK(ndr_push_align(ndr, 4));
3964                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
3965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
3966                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
3967                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
3968                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
3969         }
3970         if (ndr_flags & NDR_BUFFERS) {
3971                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
3972                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
3973         }
3974         return NDR_ERR_SUCCESS;
3975 }
3976
3977 static enum ndr_err_code ndr_pull_samr_DispEntryFull(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryFull *r)
3978 {
3979         if (ndr_flags & NDR_SCALARS) {
3980                 NDR_CHECK(ndr_pull_align(ndr, 4));
3981                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
3982                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
3983                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
3984                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
3985                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
3986         }
3987         if (ndr_flags & NDR_BUFFERS) {
3988                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
3989                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
3990         }
3991         return NDR_ERR_SUCCESS;
3992 }
3993
3994 _PUBLIC_ void ndr_print_samr_DispEntryFull(struct ndr_print *ndr, const char *name, const struct samr_DispEntryFull *r)
3995 {
3996         ndr_print_struct(ndr, name, "samr_DispEntryFull");
3997         ndr->depth++;
3998         ndr_print_uint32(ndr, "idx", r->idx);
3999         ndr_print_uint32(ndr, "rid", r->rid);
4000         ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
4001         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
4002         ndr_print_lsa_String(ndr, "description", &r->description);
4003         ndr->depth--;
4004 }
4005
4006 static enum ndr_err_code ndr_push_samr_DispInfoFull(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoFull *r)
4007 {
4008         uint32_t cntr_entries_1;
4009         if (ndr_flags & NDR_SCALARS) {
4010                 NDR_CHECK(ndr_push_align(ndr, 4));
4011                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4012                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
4013         }
4014         if (ndr_flags & NDR_BUFFERS) {
4015                 if (r->entries) {
4016                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4017                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4018                                 NDR_CHECK(ndr_push_samr_DispEntryFull(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4019                         }
4020                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4021                                 NDR_CHECK(ndr_push_samr_DispEntryFull(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4022                         }
4023                 }
4024         }
4025         return NDR_ERR_SUCCESS;
4026 }
4027
4028 static enum ndr_err_code ndr_pull_samr_DispInfoFull(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoFull *r)
4029 {
4030         uint32_t _ptr_entries;
4031         uint32_t size_entries_1 = 0;
4032         uint32_t cntr_entries_1;
4033         TALLOC_CTX *_mem_save_entries_0;
4034         TALLOC_CTX *_mem_save_entries_1;
4035         if (ndr_flags & NDR_SCALARS) {
4036                 NDR_CHECK(ndr_pull_align(ndr, 4));
4037                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4038                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
4039                 if (_ptr_entries) {
4040                         NDR_PULL_ALLOC(ndr, r->entries);
4041                 } else {
4042                         r->entries = NULL;
4043                 }
4044         }
4045         if (ndr_flags & NDR_BUFFERS) {
4046                 if (r->entries) {
4047                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
4048                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4049                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
4050                         size_entries_1 = ndr_get_array_size(ndr, &r->entries);
4051                         NDR_PULL_ALLOC_N(ndr, r->entries, size_entries_1);
4052                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
4053                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4054                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
4055                                 NDR_CHECK(ndr_pull_samr_DispEntryFull(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4056                         }
4057                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
4058                                 NDR_CHECK(ndr_pull_samr_DispEntryFull(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4059                         }
4060                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
4061                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
4062                 }
4063                 if (r->entries) {
4064                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
4065                 }
4066         }
4067         return NDR_ERR_SUCCESS;
4068 }
4069
4070 _PUBLIC_ void ndr_print_samr_DispInfoFull(struct ndr_print *ndr, const char *name, const struct samr_DispInfoFull *r)
4071 {
4072         uint32_t cntr_entries_1;
4073         ndr_print_struct(ndr, name, "samr_DispInfoFull");
4074         ndr->depth++;
4075         ndr_print_uint32(ndr, "count", r->count);
4076         ndr_print_ptr(ndr, "entries", r->entries);
4077         ndr->depth++;
4078         if (r->entries) {
4079                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
4080                 ndr->depth++;
4081                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
4082                         char *idx_1=NULL;
4083                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
4084                                 ndr_print_samr_DispEntryFull(ndr, "entries", &r->entries[cntr_entries_1]);
4085                                 free(idx_1);
4086                         }
4087                 }
4088                 ndr->depth--;
4089         }
4090         ndr->depth--;
4091         ndr->depth--;
4092 }
4093
4094 static enum ndr_err_code ndr_push_samr_DispEntryFullGroup(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryFullGroup *r)
4095 {
4096         if (ndr_flags & NDR_SCALARS) {
4097                 NDR_CHECK(ndr_push_align(ndr, 4));
4098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
4099                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
4100                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->acct_flags));
4101                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
4102                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
4103         }
4104         if (ndr_flags & NDR_BUFFERS) {
4105                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
4106                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
4107         }
4108         return NDR_ERR_SUCCESS;
4109 }
4110
4111 static enum ndr_err_code ndr_pull_samr_DispEntryFullGroup(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryFullGroup *r)
4112 {
4113         if (ndr_flags & NDR_SCALARS) {
4114                 NDR_CHECK(ndr_pull_align(ndr, 4));
4115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
4116                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
4117                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->acct_flags));
4118                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
4119                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
4120         }
4121         if (ndr_flags & NDR_BUFFERS) {
4122                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
4123                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
4124         }
4125         return NDR_ERR_SUCCESS;
4126 }
4127
4128 _PUBLIC_ void ndr_print_samr_DispEntryFullGroup(struct ndr_print *ndr, const char *name, const struct samr_DispEntryFullGroup *r)
4129 {
4130         ndr_print_struct(ndr, name, "samr_DispEntryFullGroup");
4131         ndr->depth++;
4132         ndr_print_uint32(ndr, "idx", r->idx);
4133         ndr_print_uint32(ndr, "rid", r->rid);
4134         ndr_print_samr_GroupAttrs(ndr, "acct_flags", r->acct_flags);
4135         ndr_print_lsa_String(ndr, "account_name", &r->account_name);
4136         ndr_print_lsa_String(ndr, "description", &r->description);
4137         ndr->depth--;
4138 }
4139
4140 static enum ndr_err_code ndr_push_samr_DispInfoFullGroups(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoFullGroups *r)
4141 {
4142         uint32_t cntr_entries_1;
4143         if (ndr_flags & NDR_SCALARS) {
4144                 NDR_CHECK(ndr_push_align(ndr, 4));
4145                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4146                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
4147         }
4148         if (ndr_flags & NDR_BUFFERS) {
4149                 if (r->entries) {
4150                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4151                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4152                                 NDR_CHECK(ndr_push_samr_DispEntryFullGroup(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4153                         }
4154                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4155                                 NDR_CHECK(ndr_push_samr_DispEntryFullGroup(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4156                         }
4157                 }
4158         }
4159         return NDR_ERR_SUCCESS;
4160 }
4161
4162 static enum ndr_err_code ndr_pull_samr_DispInfoFullGroups(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoFullGroups *r)
4163 {
4164         uint32_t _ptr_entries;
4165         uint32_t size_entries_1 = 0;
4166         uint32_t cntr_entries_1;
4167         TALLOC_CTX *_mem_save_entries_0;
4168         TALLOC_CTX *_mem_save_entries_1;
4169         if (ndr_flags & NDR_SCALARS) {
4170                 NDR_CHECK(ndr_pull_align(ndr, 4));
4171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4172                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
4173                 if (_ptr_entries) {
4174                         NDR_PULL_ALLOC(ndr, r->entries);
4175                 } else {
4176                         r->entries = NULL;
4177                 }
4178         }
4179         if (ndr_flags & NDR_BUFFERS) {
4180                 if (r->entries) {
4181                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
4182                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4183                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
4184                         size_entries_1 = ndr_get_array_size(ndr, &r->entries);
4185                         NDR_PULL_ALLOC_N(ndr, r->entries, size_entries_1);
4186                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
4187                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4188                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
4189                                 NDR_CHECK(ndr_pull_samr_DispEntryFullGroup(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4190                         }
4191                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
4192                                 NDR_CHECK(ndr_pull_samr_DispEntryFullGroup(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4193                         }
4194                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
4195                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
4196                 }
4197                 if (r->entries) {
4198                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
4199                 }
4200         }
4201         return NDR_ERR_SUCCESS;
4202 }
4203
4204 _PUBLIC_ void ndr_print_samr_DispInfoFullGroups(struct ndr_print *ndr, const char *name, const struct samr_DispInfoFullGroups *r)
4205 {
4206         uint32_t cntr_entries_1;
4207         ndr_print_struct(ndr, name, "samr_DispInfoFullGroups");
4208         ndr->depth++;
4209         ndr_print_uint32(ndr, "count", r->count);
4210         ndr_print_ptr(ndr, "entries", r->entries);
4211         ndr->depth++;
4212         if (r->entries) {
4213                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
4214                 ndr->depth++;
4215                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
4216                         char *idx_1=NULL;
4217                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
4218                                 ndr_print_samr_DispEntryFullGroup(ndr, "entries", &r->entries[cntr_entries_1]);
4219                                 free(idx_1);
4220                         }
4221                 }
4222                 ndr->depth--;
4223         }
4224         ndr->depth--;
4225         ndr->depth--;
4226 }
4227
4228 static enum ndr_err_code ndr_push_samr_DispEntryAscii(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryAscii *r)
4229 {
4230         if (ndr_flags & NDR_SCALARS) {
4231                 NDR_CHECK(ndr_push_align(ndr, 4));
4232                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
4233                 NDR_CHECK(ndr_push_lsa_AsciiStringLarge(ndr, NDR_SCALARS, &r->account_name));
4234         }
4235         if (ndr_flags & NDR_BUFFERS) {
4236                 NDR_CHECK(ndr_push_lsa_AsciiStringLarge(ndr, NDR_BUFFERS, &r->account_name));
4237         }
4238         return NDR_ERR_SUCCESS;
4239 }
4240
4241 static enum ndr_err_code ndr_pull_samr_DispEntryAscii(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryAscii *r)
4242 {
4243         if (ndr_flags & NDR_SCALARS) {
4244                 NDR_CHECK(ndr_pull_align(ndr, 4));
4245                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
4246                 NDR_CHECK(ndr_pull_lsa_AsciiStringLarge(ndr, NDR_SCALARS, &r->account_name));
4247         }
4248         if (ndr_flags & NDR_BUFFERS) {
4249                 NDR_CHECK(ndr_pull_lsa_AsciiStringLarge(ndr, NDR_BUFFERS, &r->account_name));
4250         }
4251         return NDR_ERR_SUCCESS;
4252 }
4253
4254 _PUBLIC_ void ndr_print_samr_DispEntryAscii(struct ndr_print *ndr, const char *name, const struct samr_DispEntryAscii *r)
4255 {
4256         ndr_print_struct(ndr, name, "samr_DispEntryAscii");
4257         ndr->depth++;
4258         ndr_print_uint32(ndr, "idx", r->idx);
4259         ndr_print_lsa_AsciiStringLarge(ndr, "account_name", &r->account_name);
4260         ndr->depth--;
4261 }
4262
4263 static enum ndr_err_code ndr_push_samr_DispInfoAscii(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoAscii *r)
4264 {
4265         uint32_t cntr_entries_1;
4266         if (ndr_flags & NDR_SCALARS) {
4267                 NDR_CHECK(ndr_push_align(ndr, 4));
4268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4269                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
4270         }
4271         if (ndr_flags & NDR_BUFFERS) {
4272                 if (r->entries) {
4273                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4274                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4275                                 NDR_CHECK(ndr_push_samr_DispEntryAscii(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4276                         }
4277                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4278                                 NDR_CHECK(ndr_push_samr_DispEntryAscii(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4279                         }
4280                 }
4281         }
4282         return NDR_ERR_SUCCESS;
4283 }
4284
4285 static enum ndr_err_code ndr_pull_samr_DispInfoAscii(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoAscii *r)
4286 {
4287         uint32_t _ptr_entries;
4288         uint32_t size_entries_1 = 0;
4289         uint32_t cntr_entries_1;
4290         TALLOC_CTX *_mem_save_entries_0;
4291         TALLOC_CTX *_mem_save_entries_1;
4292         if (ndr_flags & NDR_SCALARS) {
4293                 NDR_CHECK(ndr_pull_align(ndr, 4));
4294                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4295                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
4296                 if (_ptr_entries) {
4297                         NDR_PULL_ALLOC(ndr, r->entries);
4298                 } else {
4299                         r->entries = NULL;
4300                 }
4301         }
4302         if (ndr_flags & NDR_BUFFERS) {
4303                 if (r->entries) {
4304                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
4305                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4306                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
4307                         size_entries_1 = ndr_get_array_size(ndr, &r->entries);
4308                         NDR_PULL_ALLOC_N(ndr, r->entries, size_entries_1);
4309                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
4310                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4311                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
4312                                 NDR_CHECK(ndr_pull_samr_DispEntryAscii(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
4313                         }
4314                         for (cntr_entries_1 = 0; cntr_entries_1 < size_entries_1; cntr_entries_1++) {
4315                                 NDR_CHECK(ndr_pull_samr_DispEntryAscii(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
4316                         }
4317                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
4318                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
4319                 }
4320                 if (r->entries) {
4321                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
4322                 }
4323         }
4324         return NDR_ERR_SUCCESS;
4325 }
4326
4327 _PUBLIC_ void ndr_print_samr_DispInfoAscii(struct ndr_print *ndr, const char *name, const struct samr_DispInfoAscii *r)
4328 {
4329         uint32_t cntr_entries_1;
4330         ndr_print_struct(ndr, name, "samr_DispInfoAscii");
4331         ndr->depth++;
4332         ndr_print_uint32(ndr, "count", r->count);
4333         ndr_print_ptr(ndr, "entries", r->entries);
4334         ndr->depth++;
4335         if (r->entries) {
4336                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
4337                 ndr->depth++;
4338                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
4339                         char *idx_1=NULL;
4340                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
4341                                 ndr_print_samr_DispEntryAscii(ndr, "entries", &r->entries[cntr_entries_1]);
4342                                 free(idx_1);
4343                         }
4344                 }
4345                 ndr->depth--;
4346         }
4347         ndr->depth--;
4348         ndr->depth--;
4349 }
4350
4351 static enum ndr_err_code ndr_push_samr_DispInfo(struct ndr_push *ndr, int ndr_flags, const union samr_DispInfo *r)
4352 {
4353         if (ndr_flags & NDR_SCALARS) {
4354                 int level = ndr_push_get_switch_value(ndr, r);
4355                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
4356                 switch (level) {
4357                         case 1: {
4358                                 NDR_CHECK(ndr_push_samr_DispInfoGeneral(ndr, NDR_SCALARS, &r->info1));
4359                         break; }
4360
4361                         case 2: {
4362                                 NDR_CHECK(ndr_push_samr_DispInfoFull(ndr, NDR_SCALARS, &r->info2));
4363                         break; }
4364
4365                         case 3: {
4366                                 NDR_CHECK(ndr_push_samr_DispInfoFullGroups(ndr, NDR_SCALARS, &r->info3));
4367                         break; }
4368
4369                         case 4: {
4370                                 NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info4));
4371                         break; }
4372
4373                         case 5: {
4374                                 NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info5));
4375                         break; }
4376
4377                         default:
4378                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4379                 }
4380         }
4381         if (ndr_flags & NDR_BUFFERS) {
4382                 int level = ndr_push_get_switch_value(ndr, r);
4383                 switch (level) {
4384                         case 1:
4385                                 NDR_CHECK(ndr_push_samr_DispInfoGeneral(ndr, NDR_BUFFERS, &r->info1));
4386                         break;
4387
4388                         case 2:
4389                                 NDR_CHECK(ndr_push_samr_DispInfoFull(ndr, NDR_BUFFERS, &r->info2));
4390                         break;
4391
4392                         case 3:
4393                                 NDR_CHECK(ndr_push_samr_DispInfoFullGroups(ndr, NDR_BUFFERS, &r->info3));
4394                         break;
4395
4396                         case 4:
4397                                 NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info4));
4398                         break;
4399
4400                         case 5:
4401                                 NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info5));
4402                         break;
4403
4404                         default:
4405                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4406                 }
4407         }
4408         return NDR_ERR_SUCCESS;
4409 }
4410
4411 static enum ndr_err_code ndr_pull_samr_DispInfo(struct ndr_pull *ndr, int ndr_flags, union samr_DispInfo *r)
4412 {
4413         int level;
4414         uint16_t _level;
4415         level = ndr_pull_get_switch_value(ndr, r);
4416         if (ndr_flags & NDR_SCALARS) {
4417                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
4418                 if (_level != level) {
4419                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4420                 }
4421                 switch (level) {
4422                         case 1: {
4423                                 NDR_CHECK(ndr_pull_samr_DispInfoGeneral(ndr, NDR_SCALARS, &r->info1));
4424                         break; }
4425
4426                         case 2: {
4427                                 NDR_CHECK(ndr_pull_samr_DispInfoFull(ndr, NDR_SCALARS, &r->info2));
4428                         break; }
4429
4430                         case 3: {
4431                                 NDR_CHECK(ndr_pull_samr_DispInfoFullGroups(ndr, NDR_SCALARS, &r->info3));
4432                         break; }
4433
4434                         case 4: {
4435                                 NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info4));
4436                         break; }
4437
4438                         case 5: {
4439                                 NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info5));
4440                         break; }
4441
4442                         default:
4443                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4444                 }
4445         }
4446         if (ndr_flags & NDR_BUFFERS) {
4447                 switch (level) {
4448                         case 1:
4449                                 NDR_CHECK(ndr_pull_samr_DispInfoGeneral(ndr, NDR_BUFFERS, &r->info1));
4450                         break;
4451
4452                         case 2:
4453                                 NDR_CHECK(ndr_pull_samr_DispInfoFull(ndr, NDR_BUFFERS, &r->info2));
4454                         break;
4455
4456                         case 3:
4457                                 NDR_CHECK(ndr_pull_samr_DispInfoFullGroups(ndr, NDR_BUFFERS, &r->info3));
4458                         break;
4459
4460                         case 4:
4461                                 NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info4));
4462                         break;
4463
4464                         case 5:
4465                                 NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info5));
4466                         break;
4467
4468                         default:
4469                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4470                 }
4471         }
4472         return NDR_ERR_SUCCESS;
4473 }
4474
4475 _PUBLIC_ void ndr_print_samr_DispInfo(struct ndr_print *ndr, const char *name, const union samr_DispInfo *r)
4476 {
4477         int level;
4478         level = ndr_print_get_switch_value(ndr, r);
4479         ndr_print_union(ndr, name, level, "samr_DispInfo");
4480         switch (level) {
4481                 case 1:
4482                         ndr_print_samr_DispInfoGeneral(ndr, "info1", &r->info1);
4483                 break;
4484
4485                 case 2:
4486                         ndr_print_samr_DispInfoFull(ndr, "info2", &r->info2);
4487                 break;
4488
4489                 case 3:
4490                         ndr_print_samr_DispInfoFullGroups(ndr, "info3", &r->info3);
4491                 break;
4492
4493                 case 4:
4494                         ndr_print_samr_DispInfoAscii(ndr, "info4", &r->info4);
4495                 break;
4496
4497                 case 5:
4498                         ndr_print_samr_DispInfoAscii(ndr, "info5", &r->info5);
4499                 break;
4500
4501                 default:
4502                         ndr_print_bad_level(ndr, name, level);
4503         }
4504 }
4505
4506 static enum ndr_err_code ndr_push_samr_PwInfo(struct ndr_push *ndr, int ndr_flags, const struct samr_PwInfo *r)
4507 {
4508         if (ndr_flags & NDR_SCALARS) {
4509                 NDR_CHECK(ndr_push_align(ndr, 4));
4510                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->min_password_length));
4511                 NDR_CHECK(ndr_push_samr_PasswordProperties(ndr, NDR_SCALARS, r->password_properties));
4512         }
4513         if (ndr_flags & NDR_BUFFERS) {
4514         }
4515         return NDR_ERR_SUCCESS;
4516 }
4517
4518 static enum ndr_err_code ndr_pull_samr_PwInfo(struct ndr_pull *ndr, int ndr_flags, struct samr_PwInfo *r)
4519 {
4520         if (ndr_flags & NDR_SCALARS) {
4521                 NDR_CHECK(ndr_pull_align(ndr, 4));
4522                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->min_password_length));
4523                 NDR_CHECK(ndr_pull_samr_PasswordProperties(ndr, NDR_SCALARS, &r->password_properties));
4524         }
4525         if (ndr_flags & NDR_BUFFERS) {
4526         }
4527         return NDR_ERR_SUCCESS;
4528 }
4529
4530 _PUBLIC_ void ndr_print_samr_PwInfo(struct ndr_print *ndr, const char *name, const struct samr_PwInfo *r)
4531 {
4532         ndr_print_struct(ndr, name, "samr_PwInfo");
4533         ndr->depth++;
4534         ndr_print_uint16(ndr, "min_password_length", r->min_password_length);
4535         ndr_print_samr_PasswordProperties(ndr, "password_properties", r->password_properties);
4536         ndr->depth--;
4537 }
4538
4539 static enum ndr_err_code ndr_push_samr_ConnectVersion(struct ndr_push *ndr, int ndr_flags, enum samr_ConnectVersion r)
4540 {
4541         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4542         return NDR_ERR_SUCCESS;
4543 }
4544
4545 static enum ndr_err_code ndr_pull_samr_ConnectVersion(struct ndr_pull *ndr, int ndr_flags, enum samr_ConnectVersion *r)
4546 {
4547         uint32_t v;
4548         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4549         *r = v;
4550         return NDR_ERR_SUCCESS;
4551 }
4552
4553 _PUBLIC_ void ndr_print_samr_ConnectVersion(struct ndr_print *ndr, const char *name, enum samr_ConnectVersion r)
4554 {
4555         const char *val = NULL;
4556
4557         switch (r) {
4558                 case SAMR_CONNECT_PRE_W2K: val = "SAMR_CONNECT_PRE_W2K"; break;
4559                 case SAMR_CONNECT_W2K: val = "SAMR_CONNECT_W2K"; break;
4560                 case SAMR_CONNECT_AFTER_W2K: val = "SAMR_CONNECT_AFTER_W2K"; break;
4561         }
4562         ndr_print_enum(ndr, name, "ENUM", val, r);
4563 }
4564
4565 static enum ndr_err_code ndr_push_samr_ChangeReject(struct ndr_push *ndr, int ndr_flags, const struct samr_ChangeReject *r)
4566 {
4567         if (ndr_flags & NDR_SCALARS) {
4568                 NDR_CHECK(ndr_push_align(ndr, 4));
4569                 NDR_CHECK(ndr_push_samr_RejectReason(ndr, NDR_SCALARS, r->reason));
4570                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
4571                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
4572         }
4573         if (ndr_flags & NDR_BUFFERS) {
4574         }
4575         return NDR_ERR_SUCCESS;
4576 }
4577
4578 static enum ndr_err_code ndr_pull_samr_ChangeReject(struct ndr_pull *ndr, int ndr_flags, struct samr_ChangeReject *r)
4579 {
4580         if (ndr_flags & NDR_SCALARS) {
4581                 NDR_CHECK(ndr_pull_align(ndr, 4));
4582                 NDR_CHECK(ndr_pull_samr_RejectReason(ndr, NDR_SCALARS, &r->reason));
4583                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
4584                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
4585         }
4586         if (ndr_flags & NDR_BUFFERS) {
4587         }
4588         return NDR_ERR_SUCCESS;
4589 }
4590
4591 _PUBLIC_ void ndr_print_samr_ChangeReject(struct ndr_print *ndr, const char *name, const struct samr_ChangeReject *r)
4592 {
4593         ndr_print_struct(ndr, name, "samr_ChangeReject");
4594         ndr->depth++;
4595         ndr_print_samr_RejectReason(ndr, "reason", r->reason);
4596         ndr_print_uint32(ndr, "unknown1", r->unknown1);
4597         ndr_print_uint32(ndr, "unknown2", r->unknown2);
4598         ndr->depth--;
4599 }
4600
4601 static enum ndr_err_code ndr_push_samr_ConnectInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_ConnectInfo1 *r)
4602 {
4603         if (ndr_flags & NDR_SCALARS) {
4604                 NDR_CHECK(ndr_push_align(ndr, 4));
4605                 NDR_CHECK(ndr_push_samr_ConnectVersion(ndr, NDR_SCALARS, r->client_version));
4606                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
4607         }
4608         if (ndr_flags & NDR_BUFFERS) {
4609         }
4610         return NDR_ERR_SUCCESS;
4611 }
4612
4613 static enum ndr_err_code ndr_pull_samr_ConnectInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_ConnectInfo1 *r)
4614 {
4615         if (ndr_flags & NDR_SCALARS) {
4616                 NDR_CHECK(ndr_pull_align(ndr, 4));
4617                 NDR_CHECK(ndr_pull_samr_ConnectVersion(ndr, NDR_SCALARS, &r->client_version));
4618                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
4619         }
4620         if (ndr_flags & NDR_BUFFERS) {
4621         }
4622         return NDR_ERR_SUCCESS;
4623 }
4624
4625 _PUBLIC_ void ndr_print_samr_ConnectInfo1(struct ndr_print *ndr, const char *name, const struct samr_ConnectInfo1 *r)
4626 {
4627         ndr_print_struct(ndr, name, "samr_ConnectInfo1");
4628         ndr->depth++;
4629         ndr_print_samr_ConnectVersion(ndr, "client_version", r->client_version);
4630         ndr_print_uint32(ndr, "unknown2", r->unknown2);
4631         ndr->depth--;
4632 }
4633
4634 static enum ndr_err_code ndr_push_samr_ConnectInfo(struct ndr_push *ndr, int ndr_flags, const union samr_ConnectInfo *r)
4635 {
4636         if (ndr_flags & NDR_SCALARS) {
4637                 int level = ndr_push_get_switch_value(ndr, r);
4638                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4639                 switch (level) {
4640                         case 1: {
4641                                 NDR_CHECK(ndr_push_samr_ConnectInfo1(ndr, NDR_SCALARS, &r->info1));
4642                         break; }
4643
4644                         default:
4645                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4646                 }
4647         }
4648         if (ndr_flags & NDR_BUFFERS) {
4649                 int level = ndr_push_get_switch_value(ndr, r);
4650                 switch (level) {
4651                         case 1:
4652                         break;
4653
4654                         default:
4655                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4656                 }
4657         }
4658         return NDR_ERR_SUCCESS;
4659 }
4660
4661 static enum ndr_err_code ndr_pull_samr_ConnectInfo(struct ndr_pull *ndr, int ndr_flags, union samr_ConnectInfo *r)
4662 {
4663         int level;
4664         uint32_t _level;
4665         level = ndr_pull_get_switch_value(ndr, r);
4666         if (ndr_flags & NDR_SCALARS) {
4667                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4668                 if (_level != level) {
4669                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4670                 }
4671                 switch (level) {
4672                         case 1: {
4673                                 NDR_CHECK(ndr_pull_samr_ConnectInfo1(ndr, NDR_SCALARS, &r->info1));
4674                         break; }
4675
4676                         default:
4677                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4678                 }
4679         }
4680         if (ndr_flags & NDR_BUFFERS) {
4681                 switch (level) {
4682                         case 1:
4683                         break;
4684
4685                         default:
4686                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4687                 }
4688         }
4689         return NDR_ERR_SUCCESS;
4690 }
4691
4692 _PUBLIC_ void ndr_print_samr_ConnectInfo(struct ndr_print *ndr, const char *name, const union samr_ConnectInfo *r)
4693 {
4694         int level;
4695         level = ndr_print_get_switch_value(ndr, r);
4696         ndr_print_union(ndr, name, level, "samr_ConnectInfo");
4697         switch (level) {
4698                 case 1:
4699                         ndr_print_samr_ConnectInfo1(ndr, "info1", &r->info1);
4700                 break;
4701
4702                 default:
4703                         ndr_print_bad_level(ndr, name, level);
4704         }
4705 }
4706
4707 static enum ndr_err_code ndr_push_samr_ValidateFieldsPresent(struct ndr_push *ndr, int ndr_flags, uint32_t r)
4708 {
4709         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4710         return NDR_ERR_SUCCESS;
4711 }
4712
4713 static enum ndr_err_code ndr_pull_samr_ValidateFieldsPresent(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
4714 {
4715         uint32_t v;
4716         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4717         *r = v;
4718         return NDR_ERR_SUCCESS;
4719 }
4720
4721 _PUBLIC_ void ndr_print_samr_ValidateFieldsPresent(struct ndr_print *ndr, const char *name, uint32_t r)
4722 {
4723         ndr_print_uint32(ndr, name, r);
4724         ndr->depth++;
4725         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_LAST_SET", SAMR_VALIDATE_FIELD_PASSWORD_LAST_SET, r);
4726         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_BAD_PASSWORD_TIME", SAMR_VALIDATE_FIELD_BAD_PASSWORD_TIME, r);
4727         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_LOCKOUT_TIME", SAMR_VALIDATE_FIELD_LOCKOUT_TIME, r);
4728         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_BAD_PASSWORD_COUNT", SAMR_VALIDATE_FIELD_BAD_PASSWORD_COUNT, r);
4729         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_HISTORY_LENGTH", SAMR_VALIDATE_FIELD_PASSWORD_HISTORY_LENGTH, r);
4730         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_HISTORY", SAMR_VALIDATE_FIELD_PASSWORD_HISTORY, r);
4731         ndr->depth--;
4732 }
4733
4734 static enum ndr_err_code ndr_push_samr_ValidatePasswordLevel(struct ndr_push *ndr, int ndr_flags, enum samr_ValidatePasswordLevel r)
4735 {
4736         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
4737         return NDR_ERR_SUCCESS;
4738 }
4739
4740 static enum ndr_err_code ndr_pull_samr_ValidatePasswordLevel(struct ndr_pull *ndr, int ndr_flags, enum samr_ValidatePasswordLevel *r)
4741 {
4742         uint16_t v;
4743         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
4744         *r = v;
4745         return NDR_ERR_SUCCESS;
4746 }
4747
4748 _PUBLIC_ void ndr_print_samr_ValidatePasswordLevel(struct ndr_print *ndr, const char *name, enum samr_ValidatePasswordLevel r)
4749 {
4750         const char *val = NULL;
4751
4752         switch (r) {
4753                 case NetValidateAuthentication: val = "NetValidateAuthentication"; break;
4754                 case NetValidatePasswordChange: val = "NetValidatePasswordChange"; break;
4755                 case NetValidatePasswordReset: val = "NetValidatePasswordReset"; break;
4756         }
4757         ndr_print_enum(ndr, name, "ENUM", val, r);
4758 }
4759
4760 static enum ndr_err_code ndr_push_samr_ValidationStatus(struct ndr_push *ndr, int ndr_flags, enum samr_ValidationStatus r)
4761 {
4762         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
4763         return NDR_ERR_SUCCESS;
4764 }
4765
4766 static enum ndr_err_code ndr_pull_samr_ValidationStatus(struct ndr_pull *ndr, int ndr_flags, enum samr_ValidationStatus *r)
4767 {
4768         uint16_t v;
4769         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
4770         *r = v;
4771         return NDR_ERR_SUCCESS;
4772 }
4773
4774 _PUBLIC_ void ndr_print_samr_ValidationStatus(struct ndr_print *ndr, const char *name, enum samr_ValidationStatus r)
4775 {
4776         const char *val = NULL;
4777
4778         switch (r) {
4779                 case SAMR_VALIDATION_STATUS_SUCCESS: val = "SAMR_VALIDATION_STATUS_SUCCESS"; break;
4780                 case SAMR_VALIDATION_STATUS_PASSWORD_MUST_CHANGE: val = "SAMR_VALIDATION_STATUS_PASSWORD_MUST_CHANGE"; break;
4781                 case SAMR_VALIDATION_STATUS_ACCOUNT_LOCKED_OUT: val = "SAMR_VALIDATION_STATUS_ACCOUNT_LOCKED_OUT"; break;
4782                 case SAMR_VALIDATION_STATUS_BAD_PASSWORD: val = "SAMR_VALIDATION_STATUS_BAD_PASSWORD"; break;
4783                 case SAMR_VALIDATION_STATUS_PWD_HISTORY_CONFLICT: val = "SAMR_VALIDATION_STATUS_PWD_HISTORY_CONFLICT"; break;
4784                 case SAMR_VALIDATION_STATUS_PWD_TOO_SHORT: val = "SAMR_VALIDATION_STATUS_PWD_TOO_SHORT"; break;
4785                 case SAMR_VALIDATION_STATUS_PWD_TOO_LONG: val = "SAMR_VALIDATION_STATUS_PWD_TOO_LONG"; break;
4786                 case SAMR_VALIDATION_STATUS_NOT_COMPLEX_ENOUGH: val = "SAMR_VALIDATION_STATUS_NOT_COMPLEX_ENOUGH"; break;
4787                 case SAMR_VALIDATION_STATUS_PASSWORD_TOO_RECENT: val = "SAMR_VALIDATION_STATUS_PASSWORD_TOO_RECENT"; break;
4788         }
4789         ndr_print_enum(ndr, name, "ENUM", val, r);
4790 }
4791
4792 static enum ndr_err_code ndr_push_samr_ValidationBlob(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidationBlob *r)
4793 {
4794         if (ndr_flags & NDR_SCALARS) {
4795                 NDR_CHECK(ndr_push_align(ndr, 4));
4796                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
4797                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
4798         }
4799         if (ndr_flags & NDR_BUFFERS) {
4800                 if (r->data) {
4801                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
4802                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
4803                 }
4804         }
4805         return NDR_ERR_SUCCESS;
4806 }
4807
4808 static enum ndr_err_code ndr_pull_samr_ValidationBlob(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidationBlob *r)
4809 {
4810         uint32_t _ptr_data;
4811         uint32_t size_data_1 = 0;
4812         TALLOC_CTX *_mem_save_data_0;
4813         if (ndr_flags & NDR_SCALARS) {
4814                 NDR_CHECK(ndr_pull_align(ndr, 4));
4815                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
4816                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
4817                 if (_ptr_data) {
4818                         NDR_PULL_ALLOC(ndr, r->data);
4819                 } else {
4820                         r->data = NULL;
4821                 }
4822         }
4823         if (ndr_flags & NDR_BUFFERS) {
4824                 if (r->data) {
4825                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
4826                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
4827                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
4828                         size_data_1 = ndr_get_array_size(ndr, &r->data);
4829                         NDR_PULL_ALLOC_N(ndr, r->data, size_data_1);
4830                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, size_data_1));
4831                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
4832                 }
4833                 if (r->data) {
4834                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
4835                 }
4836         }
4837         return NDR_ERR_SUCCESS;
4838 }
4839
4840 _PUBLIC_ void ndr_print_samr_ValidationBlob(struct ndr_print *ndr, const char *name, const struct samr_ValidationBlob *r)
4841 {
4842         ndr_print_struct(ndr, name, "samr_ValidationBlob");
4843         ndr->depth++;
4844         ndr_print_uint32(ndr, "length", r->length);
4845         ndr_print_ptr(ndr, "data", r->data);
4846         ndr->depth++;
4847         if (r->data) {
4848                 ndr_print_array_uint8(ndr, "data", r->data, r->length);
4849         }
4850         ndr->depth--;
4851         ndr->depth--;
4852 }
4853
4854 static enum ndr_err_code ndr_push_samr_ValidatePasswordInfo(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordInfo *r)
4855 {
4856         uint32_t cntr_pwd_history_1;
4857         if (ndr_flags & NDR_SCALARS) {
4858                 NDR_CHECK(ndr_push_align(ndr, 8));
4859                 NDR_CHECK(ndr_push_samr_ValidateFieldsPresent(ndr, NDR_SCALARS, r->fields_present));
4860                 NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->last_password_change));
4861                 NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->bad_password_time));
4862                 NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->lockout_time));
4863                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bad_pwd_count));
4864                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pwd_history_len));
4865                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pwd_history));
4866         }
4867         if (ndr_flags & NDR_BUFFERS) {
4868                 if (r->pwd_history) {
4869                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pwd_history_len));
4870                         for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {
4871                                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->pwd_history[cntr_pwd_history_1]));
4872                         }
4873                         for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {
4874                                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->pwd_history[cntr_pwd_history_1]));
4875                         }
4876                 }
4877         }
4878         return NDR_ERR_SUCCESS;
4879 }
4880
4881 static enum ndr_err_code ndr_pull_samr_ValidatePasswordInfo(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordInfo *r)
4882 {
4883         uint32_t _ptr_pwd_history;
4884         uint32_t size_pwd_history_1 = 0;
4885         uint32_t cntr_pwd_history_1;
4886         TALLOC_CTX *_mem_save_pwd_history_0;
4887         TALLOC_CTX *_mem_save_pwd_history_1;
4888         if (ndr_flags & NDR_SCALARS) {
4889                 NDR_CHECK(ndr_pull_align(ndr, 8));
4890                 NDR_CHECK(ndr_pull_samr_ValidateFieldsPresent(ndr, NDR_SCALARS, &r->fields_present));
4891                 NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->last_password_change));
4892                 NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->bad_password_time));
4893                 NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->lockout_time));
4894                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bad_pwd_count));
4895                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pwd_history_len));
4896                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pwd_history));
4897                 if (_ptr_pwd_history) {
4898                         NDR_PULL_ALLOC(ndr, r->pwd_history);
4899                 } else {
4900                         r->pwd_history = NULL;
4901                 }
4902         }
4903         if (ndr_flags & NDR_BUFFERS) {
4904                 if (r->pwd_history) {
4905                         _mem_save_pwd_history_0 = NDR_PULL_GET_MEM_CTX(ndr);
4906                         NDR_PULL_SET_MEM_CTX(ndr, r->pwd_history, 0);
4907                         NDR_CHECK(ndr_pull_array_size(ndr, &r->pwd_history));
4908                         size_pwd_history_1 = ndr_get_array_size(ndr, &r->pwd_history);
4909                         NDR_PULL_ALLOC_N(ndr, r->pwd_history, size_pwd_history_1);
4910                         _mem_save_pwd_history_1 = NDR_PULL_GET_MEM_CTX(ndr);
4911                         NDR_PULL_SET_MEM_CTX(ndr, r->pwd_history, 0);
4912                         for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < size_pwd_history_1; cntr_pwd_history_1++) {
4913                                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->pwd_history[cntr_pwd_history_1]));
4914                         }
4915                         for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < size_pwd_history_1; cntr_pwd_history_1++) {
4916                                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->pwd_history[cntr_pwd_history_1]));
4917                         }
4918                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pwd_history_1, 0);
4919                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pwd_history_0, 0);
4920                 }
4921                 if (r->pwd_history) {
4922                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->pwd_history, r->pwd_history_len));
4923                 }
4924         }
4925         return NDR_ERR_SUCCESS;
4926 }
4927
4928 _PUBLIC_ void ndr_print_samr_ValidatePasswordInfo(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordInfo *r)
4929 {
4930         uint32_t cntr_pwd_history_1;
4931         ndr_print_struct(ndr, name, "samr_ValidatePasswordInfo");
4932         ndr->depth++;
4933         ndr_print_samr_ValidateFieldsPresent(ndr, "fields_present", r->fields_present);
4934         ndr_print_NTTIME_hyper(ndr, "last_password_change", r->last_password_change);
4935         ndr_print_NTTIME_hyper(ndr, "bad_password_time", r->bad_password_time);
4936         ndr_print_NTTIME_hyper(ndr, "lockout_time", r->lockout_time);
4937         ndr_print_uint32(ndr, "bad_pwd_count", r->bad_pwd_count);
4938         ndr_print_uint32(ndr, "pwd_history_len", r->pwd_history_len);
4939         ndr_print_ptr(ndr, "pwd_history", r->pwd_history);
4940         ndr->depth++;
4941         if (r->pwd_history) {
4942                 ndr->print(ndr, "%s: ARRAY(%d)", "pwd_history", (int)r->pwd_history_len);
4943                 ndr->depth++;
4944                 for (cntr_pwd_history_1=0;cntr_pwd_history_1<r->pwd_history_len;cntr_pwd_history_1++) {
4945                         char *idx_1=NULL;
4946                         if (asprintf(&idx_1, "[%d]", cntr_pwd_history_1) != -1) {
4947                                 ndr_print_samr_ValidationBlob(ndr, "pwd_history", &r->pwd_history[cntr_pwd_history_1]);
4948                                 free(idx_1);
4949                         }
4950                 }
4951                 ndr->depth--;
4952         }
4953         ndr->depth--;
4954         ndr->depth--;
4955 }
4956
4957 static enum ndr_err_code ndr_push_samr_ValidatePasswordRepCtr(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordRepCtr *r)
4958 {
4959         if (ndr_flags & NDR_SCALARS) {
4960                 NDR_CHECK(ndr_push_align(ndr, 8));
4961                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
4962                 NDR_CHECK(ndr_push_samr_ValidationStatus(ndr, NDR_SCALARS, r->status));
4963         }
4964         if (ndr_flags & NDR_BUFFERS) {
4965                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
4966         }
4967         return NDR_ERR_SUCCESS;
4968 }
4969
4970 static enum ndr_err_code ndr_pull_samr_ValidatePasswordRepCtr(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordRepCtr *r)
4971 {
4972         if (ndr_flags & NDR_SCALARS) {
4973                 NDR_CHECK(ndr_pull_align(ndr, 8));
4974                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
4975                 NDR_CHECK(ndr_pull_samr_ValidationStatus(ndr, NDR_SCALARS, &r->status));
4976         }
4977         if (ndr_flags & NDR_BUFFERS) {
4978                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
4979         }
4980         return NDR_ERR_SUCCESS;
4981 }
4982
4983 _PUBLIC_ void ndr_print_samr_ValidatePasswordRepCtr(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordRepCtr *r)
4984 {
4985         ndr_print_struct(ndr, name, "samr_ValidatePasswordRepCtr");
4986         ndr->depth++;
4987         ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
4988         ndr_print_samr_ValidationStatus(ndr, "status", r->status);
4989         ndr->depth--;
4990 }
4991
4992 static enum ndr_err_code ndr_push_samr_ValidatePasswordRep(struct ndr_push *ndr, int ndr_flags, const union samr_ValidatePasswordRep *r)
4993 {
4994         if (ndr_flags & NDR_SCALARS) {
4995                 int level = ndr_push_get_switch_value(ndr, r);
4996                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
4997                 switch (level) {
4998                         case 1: {
4999                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr1));
5000                         break; }
5001
5002                         case 2: {
5003                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr2));
5004                         break; }
5005
5006                         case 3: {
5007                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr3));
5008                         break; }
5009
5010                         default:
5011                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5012                 }
5013         }
5014         if (ndr_flags & NDR_BUFFERS) {
5015                 int level = ndr_push_get_switch_value(ndr, r);
5016                 switch (level) {
5017                         case 1:
5018                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr1));
5019                         break;
5020
5021                         case 2:
5022                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr2));
5023                         break;
5024
5025                         case 3:
5026                                 NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr3));
5027                         break;
5028
5029                         default:
5030                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5031                 }
5032         }
5033         return NDR_ERR_SUCCESS;
5034 }
5035
5036 static enum ndr_err_code ndr_pull_samr_ValidatePasswordRep(struct ndr_pull *ndr, int ndr_flags, union samr_ValidatePasswordRep *r)
5037 {
5038         int level;
5039         uint16_t _level;
5040         level = ndr_pull_get_switch_value(ndr, r);
5041         if (ndr_flags & NDR_SCALARS) {
5042                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
5043                 if (_level != level) {
5044                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5045                 }
5046                 switch (level) {
5047                         case 1: {
5048                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr1));
5049                         break; }
5050
5051                         case 2: {
5052                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr2));
5053                         break; }
5054
5055                         case 3: {
5056                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr3));
5057                         break; }
5058
5059                         default:
5060                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5061                 }
5062         }
5063         if (ndr_flags & NDR_BUFFERS) {
5064                 switch (level) {
5065                         case 1:
5066                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr1));
5067                         break;
5068
5069                         case 2:
5070                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr2));
5071                         break;
5072
5073                         case 3:
5074                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr3));
5075                         break;
5076
5077                         default:
5078                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5079                 }
5080         }
5081         return NDR_ERR_SUCCESS;
5082 }
5083
5084 _PUBLIC_ void ndr_print_samr_ValidatePasswordRep(struct ndr_print *ndr, const char *name, const union samr_ValidatePasswordRep *r)
5085 {
5086         int level;
5087         level = ndr_print_get_switch_value(ndr, r);
5088         ndr_print_union(ndr, name, level, "samr_ValidatePasswordRep");
5089         switch (level) {
5090                 case 1:
5091                         ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr1", &r->ctr1);
5092                 break;
5093
5094                 case 2:
5095                         ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr2", &r->ctr2);
5096                 break;
5097
5098                 case 3:
5099                         ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr3", &r->ctr3);
5100                 break;
5101
5102                 default:
5103                         ndr_print_bad_level(ndr, name, level);
5104         }
5105 }
5106
5107 static enum ndr_err_code ndr_push_samr_ValidatePasswordReq3(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq3 *r)
5108 {
5109         if (ndr_flags & NDR_SCALARS) {
5110                 NDR_CHECK(ndr_push_align(ndr, 8));
5111                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5112                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
5113                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
5114                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
5115                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->pwd_must_change_at_next_logon));
5116                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->clear_lockout));
5117         }
5118         if (ndr_flags & NDR_BUFFERS) {
5119                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5120                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
5121                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
5122                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
5123         }
5124         return NDR_ERR_SUCCESS;
5125 }
5126
5127 static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq3(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq3 *r)
5128 {
5129         if (ndr_flags & NDR_SCALARS) {
5130                 NDR_CHECK(ndr_pull_align(ndr, 8));
5131                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5132                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
5133                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
5134                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
5135                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->pwd_must_change_at_next_logon));
5136                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->clear_lockout));
5137         }
5138         if (ndr_flags & NDR_BUFFERS) {
5139                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5140                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
5141                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
5142                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
5143         }
5144         return NDR_ERR_SUCCESS;
5145 }
5146
5147 _PUBLIC_ void ndr_print_samr_ValidatePasswordReq3(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq3 *r)
5148 {
5149         ndr_print_struct(ndr, name, "samr_ValidatePasswordReq3");
5150         ndr->depth++;
5151         ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
5152         ndr_print_lsa_StringLarge(ndr, "password", &r->password);
5153         ndr_print_lsa_StringLarge(ndr, "account", &r->account);
5154         ndr_print_samr_ValidationBlob(ndr, "hash", &r->hash);
5155         ndr_print_uint8(ndr, "pwd_must_change_at_next_logon", r->pwd_must_change_at_next_logon);
5156         ndr_print_uint8(ndr, "clear_lockout", r->clear_lockout);
5157         ndr->depth--;
5158 }
5159
5160 static enum ndr_err_code ndr_push_samr_ValidatePasswordReq2(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq2 *r)
5161 {
5162         if (ndr_flags & NDR_SCALARS) {
5163                 NDR_CHECK(ndr_push_align(ndr, 8));
5164                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5165                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
5166                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
5167                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
5168                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_matched));
5169         }
5170         if (ndr_flags & NDR_BUFFERS) {
5171                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5172                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
5173                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
5174                 NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
5175         }
5176         return NDR_ERR_SUCCESS;
5177 }
5178
5179 static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq2(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq2 *r)
5180 {
5181         if (ndr_flags & NDR_SCALARS) {
5182                 NDR_CHECK(ndr_pull_align(ndr, 8));
5183                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5184                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
5185                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
5186                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
5187                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_matched));
5188         }
5189         if (ndr_flags & NDR_BUFFERS) {
5190                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5191                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
5192                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
5193                 NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
5194         }
5195         return NDR_ERR_SUCCESS;
5196 }
5197
5198 _PUBLIC_ void ndr_print_samr_ValidatePasswordReq2(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq2 *r)
5199 {
5200         ndr_print_struct(ndr, name, "samr_ValidatePasswordReq2");
5201         ndr->depth++;
5202         ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
5203         ndr_print_lsa_StringLarge(ndr, "password", &r->password);
5204         ndr_print_lsa_StringLarge(ndr, "account", &r->account);
5205         ndr_print_samr_ValidationBlob(ndr, "hash", &r->hash);
5206         ndr_print_uint8(ndr, "password_matched", r->password_matched);
5207         ndr->depth--;
5208 }
5209
5210 static enum ndr_err_code ndr_push_samr_ValidatePasswordReq1(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq1 *r)
5211 {
5212         if (ndr_flags & NDR_SCALARS) {
5213                 NDR_CHECK(ndr_push_align(ndr, 8));
5214                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5215                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_matched));
5216         }
5217         if (ndr_flags & NDR_BUFFERS) {
5218                 NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5219         }
5220         return NDR_ERR_SUCCESS;
5221 }
5222
5223 static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq1(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq1 *r)
5224 {
5225         if (ndr_flags & NDR_SCALARS) {
5226                 NDR_CHECK(ndr_pull_align(ndr, 8));
5227                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
5228                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_matched));
5229         }
5230         if (ndr_flags & NDR_BUFFERS) {
5231                 NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
5232         }
5233         return NDR_ERR_SUCCESS;
5234 }
5235
5236 _PUBLIC_ void ndr_print_samr_ValidatePasswordReq1(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq1 *r)
5237 {
5238         ndr_print_struct(ndr, name, "samr_ValidatePasswordReq1");
5239         ndr->depth++;
5240         ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
5241         ndr_print_uint8(ndr, "password_matched", r->password_matched);
5242         ndr->depth--;
5243 }
5244
5245 static enum ndr_err_code ndr_push_samr_ValidatePasswordReq(struct ndr_push *ndr, int ndr_flags, const union samr_ValidatePasswordReq *r)
5246 {
5247         if (ndr_flags & NDR_SCALARS) {
5248                 int level = ndr_push_get_switch_value(ndr, r);
5249                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
5250                 switch (level) {
5251                         case 1: {
5252                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq1(ndr, NDR_SCALARS, &r->req1));
5253                         break; }
5254
5255                         case 2: {
5256                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq2(ndr, NDR_SCALARS, &r->req2));
5257                         break; }
5258
5259                         case 3: {
5260                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq3(ndr, NDR_SCALARS, &r->req3));
5261                         break; }
5262
5263                         default:
5264                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5265                 }
5266         }
5267         if (ndr_flags & NDR_BUFFERS) {
5268                 int level = ndr_push_get_switch_value(ndr, r);
5269                 switch (level) {
5270                         case 1:
5271                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq1(ndr, NDR_BUFFERS, &r->req1));
5272                         break;
5273
5274                         case 2:
5275                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq2(ndr, NDR_BUFFERS, &r->req2));
5276                         break;
5277
5278                         case 3:
5279                                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq3(ndr, NDR_BUFFERS, &r->req3));
5280                         break;
5281
5282                         default:
5283                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5284                 }
5285         }
5286         return NDR_ERR_SUCCESS;
5287 }
5288
5289 static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq(struct ndr_pull *ndr, int ndr_flags, union samr_ValidatePasswordReq *r)
5290 {
5291         int level;
5292         uint16_t _level;
5293         level = ndr_pull_get_switch_value(ndr, r);
5294         if (ndr_flags & NDR_SCALARS) {
5295                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
5296                 if (_level != level) {
5297                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5298                 }
5299                 switch (level) {
5300                         case 1: {
5301                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq1(ndr, NDR_SCALARS, &r->req1));
5302                         break; }
5303
5304                         case 2: {
5305                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq2(ndr, NDR_SCALARS, &r->req2));
5306                         break; }
5307
5308                         case 3: {
5309                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq3(ndr, NDR_SCALARS, &r->req3));
5310                         break; }
5311
5312                         default:
5313                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5314                 }
5315         }
5316         if (ndr_flags & NDR_BUFFERS) {
5317                 switch (level) {
5318                         case 1:
5319                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq1(ndr, NDR_BUFFERS, &r->req1));
5320                         break;
5321
5322                         case 2:
5323                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq2(ndr, NDR_BUFFERS, &r->req2));
5324                         break;
5325
5326                         case 3:
5327                                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq3(ndr, NDR_BUFFERS, &r->req3));
5328                         break;
5329
5330                         default:
5331                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5332                 }
5333         }
5334         return NDR_ERR_SUCCESS;
5335 }
5336
5337 _PUBLIC_ void ndr_print_samr_ValidatePasswordReq(struct ndr_print *ndr, const char *name, const union samr_ValidatePasswordReq *r)
5338 {
5339         int level;
5340         level = ndr_print_get_switch_value(ndr, r);
5341         ndr_print_union(ndr, name, level, "samr_ValidatePasswordReq");
5342         switch (level) {
5343                 case 1:
5344                         ndr_print_samr_ValidatePasswordReq1(ndr, "req1", &r->req1);
5345                 break;
5346
5347                 case 2:
5348                         ndr_print_samr_ValidatePasswordReq2(ndr, "req2", &r->req2);
5349                 break;
5350
5351                 case 3:
5352                         ndr_print_samr_ValidatePasswordReq3(ndr, "req3", &r->req3);
5353                 break;
5354
5355                 default:
5356                         ndr_print_bad_level(ndr, name, level);
5357         }
5358 }
5359
5360 static enum ndr_err_code ndr_push_samr_Connect(struct ndr_push *ndr, int flags, const struct samr_Connect *r)
5361 {
5362         if (flags & NDR_IN) {
5363                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
5364                 if (r->in.system_name) {
5365                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
5366                 }
5367                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
5368         }
5369         if (flags & NDR_OUT) {
5370                 if (r->out.connect_handle == NULL) {
5371                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5372                 }
5373                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
5374                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5375         }
5376         return NDR_ERR_SUCCESS;
5377 }
5378
5379 static enum ndr_err_code ndr_pull_samr_Connect(struct ndr_pull *ndr, int flags, struct samr_Connect *r)
5380 {
5381         uint32_t _ptr_system_name;
5382         TALLOC_CTX *_mem_save_system_name_0;
5383         TALLOC_CTX *_mem_save_connect_handle_0;
5384         if (flags & NDR_IN) {
5385                 ZERO_STRUCT(r->out);
5386
5387                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
5388                 if (_ptr_system_name) {
5389                         NDR_PULL_ALLOC(ndr, r->in.system_name);
5390                 } else {
5391                         r->in.system_name = NULL;
5392                 }
5393                 if (r->in.system_name) {
5394                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5395                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
5396                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
5397                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
5398                 }
5399                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
5400                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
5401                 ZERO_STRUCTP(r->out.connect_handle);
5402         }
5403         if (flags & NDR_OUT) {
5404                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5405                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
5406                 }
5407                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5408                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
5409                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
5410                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
5411                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5412         }
5413         return NDR_ERR_SUCCESS;
5414 }
5415
5416 _PUBLIC_ void ndr_print_samr_Connect(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect *r)
5417 {
5418         ndr_print_struct(ndr, name, "samr_Connect");
5419         ndr->depth++;
5420         if (flags & NDR_SET_VALUES) {
5421                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5422         }
5423         if (flags & NDR_IN) {
5424                 ndr_print_struct(ndr, "in", "samr_Connect");
5425                 ndr->depth++;
5426                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
5427                 ndr->depth++;
5428                 if (r->in.system_name) {
5429                         ndr_print_uint16(ndr, "system_name", *r->in.system_name);
5430                 }
5431                 ndr->depth--;
5432                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
5433                 ndr->depth--;
5434         }
5435         if (flags & NDR_OUT) {
5436                 ndr_print_struct(ndr, "out", "samr_Connect");
5437                 ndr->depth++;
5438                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
5439                 ndr->depth++;
5440                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
5441                 ndr->depth--;
5442                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5443                 ndr->depth--;
5444         }
5445         ndr->depth--;
5446 }
5447
5448 _PUBLIC_ enum ndr_err_code ndr_push_samr_Close(struct ndr_push *ndr, int flags, const struct samr_Close *r)
5449 {
5450         if (flags & NDR_IN) {
5451                 if (r->in.handle == NULL) {
5452                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5453                 }
5454                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5455         }
5456         if (flags & NDR_OUT) {
5457                 if (r->out.handle == NULL) {
5458                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5459                 }
5460                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
5461                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5462         }
5463         return NDR_ERR_SUCCESS;
5464 }
5465
5466 _PUBLIC_ enum ndr_err_code ndr_pull_samr_Close(struct ndr_pull *ndr, int flags, struct samr_Close *r)
5467 {
5468         TALLOC_CTX *_mem_save_handle_0;
5469         if (flags & NDR_IN) {
5470                 ZERO_STRUCT(r->out);
5471
5472                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5473                         NDR_PULL_ALLOC(ndr, r->in.handle);
5474                 }
5475                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5476                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5477                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5478                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5479                 NDR_PULL_ALLOC(ndr, r->out.handle);
5480                 *r->out.handle = *r->in.handle;
5481         }
5482         if (flags & NDR_OUT) {
5483                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5484                         NDR_PULL_ALLOC(ndr, r->out.handle);
5485                 }
5486                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5487                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
5488                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
5489                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5490                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5491         }
5492         return NDR_ERR_SUCCESS;
5493 }
5494
5495 _PUBLIC_ void ndr_print_samr_Close(struct ndr_print *ndr, const char *name, int flags, const struct samr_Close *r)
5496 {
5497         ndr_print_struct(ndr, name, "samr_Close");
5498         ndr->depth++;
5499         if (flags & NDR_SET_VALUES) {
5500                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5501         }
5502         if (flags & NDR_IN) {
5503                 ndr_print_struct(ndr, "in", "samr_Close");
5504                 ndr->depth++;
5505                 ndr_print_ptr(ndr, "handle", r->in.handle);
5506                 ndr->depth++;
5507                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5508                 ndr->depth--;
5509                 ndr->depth--;
5510         }
5511         if (flags & NDR_OUT) {
5512                 ndr_print_struct(ndr, "out", "samr_Close");
5513                 ndr->depth++;
5514                 ndr_print_ptr(ndr, "handle", r->out.handle);
5515                 ndr->depth++;
5516                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
5517                 ndr->depth--;
5518                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5519                 ndr->depth--;
5520         }
5521         ndr->depth--;
5522 }
5523
5524 static enum ndr_err_code ndr_push_samr_SetSecurity(struct ndr_push *ndr, int flags, const struct samr_SetSecurity *r)
5525 {
5526         if (flags & NDR_IN) {
5527                 if (r->in.handle == NULL) {
5528                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5529                 }
5530                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5531                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
5532                 if (r->in.sdbuf == NULL) {
5533                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5534                 }
5535                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sdbuf));
5536         }
5537         if (flags & NDR_OUT) {
5538                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5539         }
5540         return NDR_ERR_SUCCESS;
5541 }
5542
5543 static enum ndr_err_code ndr_pull_samr_SetSecurity(struct ndr_pull *ndr, int flags, struct samr_SetSecurity *r)
5544 {
5545         TALLOC_CTX *_mem_save_handle_0;
5546         TALLOC_CTX *_mem_save_sdbuf_0;
5547         if (flags & NDR_IN) {
5548                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5549                         NDR_PULL_ALLOC(ndr, r->in.handle);
5550                 }
5551                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5552                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5553                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5554                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5555                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
5556                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5557                         NDR_PULL_ALLOC(ndr, r->in.sdbuf);
5558                 }
5559                 _mem_save_sdbuf_0 = NDR_PULL_GET_MEM_CTX(ndr);
5560                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sdbuf, LIBNDR_FLAG_REF_ALLOC);
5561                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sdbuf));
5562                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_0, LIBNDR_FLAG_REF_ALLOC);
5563         }
5564         if (flags & NDR_OUT) {
5565                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5566         }
5567         return NDR_ERR_SUCCESS;
5568 }
5569
5570 _PUBLIC_ void ndr_print_samr_SetSecurity(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetSecurity *r)
5571 {
5572         ndr_print_struct(ndr, name, "samr_SetSecurity");
5573         ndr->depth++;
5574         if (flags & NDR_SET_VALUES) {
5575                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5576         }
5577         if (flags & NDR_IN) {
5578                 ndr_print_struct(ndr, "in", "samr_SetSecurity");
5579                 ndr->depth++;
5580                 ndr_print_ptr(ndr, "handle", r->in.handle);
5581                 ndr->depth++;
5582                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5583                 ndr->depth--;
5584                 ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
5585                 ndr_print_ptr(ndr, "sdbuf", r->in.sdbuf);
5586                 ndr->depth++;
5587                 ndr_print_sec_desc_buf(ndr, "sdbuf", r->in.sdbuf);
5588                 ndr->depth--;
5589                 ndr->depth--;
5590         }
5591         if (flags & NDR_OUT) {
5592                 ndr_print_struct(ndr, "out", "samr_SetSecurity");
5593                 ndr->depth++;
5594                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5595                 ndr->depth--;
5596         }
5597         ndr->depth--;
5598 }
5599
5600 static enum ndr_err_code ndr_push_samr_QuerySecurity(struct ndr_push *ndr, int flags, const struct samr_QuerySecurity *r)
5601 {
5602         if (flags & NDR_IN) {
5603                 if (r->in.handle == NULL) {
5604                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5605                 }
5606                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5607                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
5608         }
5609         if (flags & NDR_OUT) {
5610                 if (r->out.sdbuf == NULL) {
5611                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5612                 }
5613                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sdbuf));
5614                 if (*r->out.sdbuf) {
5615                         NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sdbuf));
5616                 }
5617                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5618         }
5619         return NDR_ERR_SUCCESS;
5620 }
5621
5622 static enum ndr_err_code ndr_pull_samr_QuerySecurity(struct ndr_pull *ndr, int flags, struct samr_QuerySecurity *r)
5623 {
5624         uint32_t _ptr_sdbuf;
5625         TALLOC_CTX *_mem_save_handle_0;
5626         TALLOC_CTX *_mem_save_sdbuf_0;
5627         TALLOC_CTX *_mem_save_sdbuf_1;
5628         if (flags & NDR_IN) {
5629                 ZERO_STRUCT(r->out);
5630
5631                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5632                         NDR_PULL_ALLOC(ndr, r->in.handle);
5633                 }
5634                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5635                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5636                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5637                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5638                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
5639                 NDR_PULL_ALLOC(ndr, r->out.sdbuf);
5640                 ZERO_STRUCTP(r->out.sdbuf);
5641         }
5642         if (flags & NDR_OUT) {
5643                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5644                         NDR_PULL_ALLOC(ndr, r->out.sdbuf);
5645                 }
5646                 _mem_save_sdbuf_0 = NDR_PULL_GET_MEM_CTX(ndr);
5647                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sdbuf, LIBNDR_FLAG_REF_ALLOC);
5648                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sdbuf));
5649                 if (_ptr_sdbuf) {
5650                         NDR_PULL_ALLOC(ndr, *r->out.sdbuf);
5651                 } else {
5652                         *r->out.sdbuf = NULL;
5653                 }
5654                 if (*r->out.sdbuf) {
5655                         _mem_save_sdbuf_1 = NDR_PULL_GET_MEM_CTX(ndr);
5656                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sdbuf, 0);
5657                         NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sdbuf));
5658                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_1, 0);
5659                 }
5660                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_0, LIBNDR_FLAG_REF_ALLOC);
5661                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5662         }
5663         return NDR_ERR_SUCCESS;
5664 }
5665
5666 _PUBLIC_ void ndr_print_samr_QuerySecurity(struct ndr_print *ndr, const char *name, int flags, const struct samr_QuerySecurity *r)
5667 {
5668         ndr_print_struct(ndr, name, "samr_QuerySecurity");
5669         ndr->depth++;
5670         if (flags & NDR_SET_VALUES) {
5671                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5672         }
5673         if (flags & NDR_IN) {
5674                 ndr_print_struct(ndr, "in", "samr_QuerySecurity");
5675                 ndr->depth++;
5676                 ndr_print_ptr(ndr, "handle", r->in.handle);
5677                 ndr->depth++;
5678                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5679                 ndr->depth--;
5680                 ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
5681                 ndr->depth--;
5682         }
5683         if (flags & NDR_OUT) {
5684                 ndr_print_struct(ndr, "out", "samr_QuerySecurity");
5685                 ndr->depth++;
5686                 ndr_print_ptr(ndr, "sdbuf", r->out.sdbuf);
5687                 ndr->depth++;
5688                 ndr_print_ptr(ndr, "sdbuf", *r->out.sdbuf);
5689                 ndr->depth++;
5690                 if (*r->out.sdbuf) {
5691                         ndr_print_sec_desc_buf(ndr, "sdbuf", *r->out.sdbuf);
5692                 }
5693                 ndr->depth--;
5694                 ndr->depth--;
5695                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5696                 ndr->depth--;
5697         }
5698         ndr->depth--;
5699 }
5700
5701 static enum ndr_err_code ndr_push_samr_Shutdown(struct ndr_push *ndr, int flags, const struct samr_Shutdown *r)
5702 {
5703         if (flags & NDR_IN) {
5704                 if (r->in.connect_handle == NULL) {
5705                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5706                 }
5707                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5708         }
5709         if (flags & NDR_OUT) {
5710                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5711         }
5712         return NDR_ERR_SUCCESS;
5713 }
5714
5715 static enum ndr_err_code ndr_pull_samr_Shutdown(struct ndr_pull *ndr, int flags, struct samr_Shutdown *r)
5716 {
5717         TALLOC_CTX *_mem_save_connect_handle_0;
5718         if (flags & NDR_IN) {
5719                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5720                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
5721                 }
5722                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5723                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
5724                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5725                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
5726         }
5727         if (flags & NDR_OUT) {
5728                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5729         }
5730         return NDR_ERR_SUCCESS;
5731 }
5732
5733 _PUBLIC_ void ndr_print_samr_Shutdown(struct ndr_print *ndr, const char *name, int flags, const struct samr_Shutdown *r)
5734 {
5735         ndr_print_struct(ndr, name, "samr_Shutdown");
5736         ndr->depth++;
5737         if (flags & NDR_SET_VALUES) {
5738                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5739         }
5740         if (flags & NDR_IN) {
5741                 ndr_print_struct(ndr, "in", "samr_Shutdown");
5742                 ndr->depth++;
5743                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
5744                 ndr->depth++;
5745                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
5746                 ndr->depth--;
5747                 ndr->depth--;
5748         }
5749         if (flags & NDR_OUT) {
5750                 ndr_print_struct(ndr, "out", "samr_Shutdown");
5751                 ndr->depth++;
5752                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5753                 ndr->depth--;
5754         }
5755         ndr->depth--;
5756 }
5757
5758 static enum ndr_err_code ndr_push_samr_LookupDomain(struct ndr_push *ndr, int flags, const struct samr_LookupDomain *r)
5759 {
5760         if (flags & NDR_IN) {
5761                 if (r->in.connect_handle == NULL) {
5762                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5763                 }
5764                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5765                 if (r->in.domain_name == NULL) {
5766                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5767                 }
5768                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
5769         }
5770         if (flags & NDR_OUT) {
5771                 if (r->out.sid == NULL) {
5772                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5773                 }
5774                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sid));
5775                 if (*r->out.sid) {
5776                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
5777                 }
5778                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5779         }
5780         return NDR_ERR_SUCCESS;
5781 }
5782
5783 static enum ndr_err_code ndr_pull_samr_LookupDomain(struct ndr_pull *ndr, int flags, struct samr_LookupDomain *r)
5784 {
5785         uint32_t _ptr_sid;
5786         TALLOC_CTX *_mem_save_connect_handle_0;
5787         TALLOC_CTX *_mem_save_domain_name_0;
5788         TALLOC_CTX *_mem_save_sid_0;
5789         TALLOC_CTX *_mem_save_sid_1;
5790         if (flags & NDR_IN) {
5791                 ZERO_STRUCT(r->out);
5792
5793                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5794                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
5795                 }
5796                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5797                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
5798                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5799                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
5800                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5801                         NDR_PULL_ALLOC(ndr, r->in.domain_name);
5802                 }
5803                 _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5804                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_name, LIBNDR_FLAG_REF_ALLOC);
5805                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
5806                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, LIBNDR_FLAG_REF_ALLOC);
5807                 NDR_PULL_ALLOC(ndr, r->out.sid);
5808                 ZERO_STRUCTP(r->out.sid);
5809         }
5810         if (flags & NDR_OUT) {
5811                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5812                         NDR_PULL_ALLOC(ndr, r->out.sid);
5813                 }
5814                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
5815                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);
5816                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
5817                 if (_ptr_sid) {
5818                         NDR_PULL_ALLOC(ndr, *r->out.sid);
5819                 } else {
5820                         *r->out.sid = NULL;
5821                 }
5822                 if (*r->out.sid) {
5823                         _mem_save_sid_1 = NDR_PULL_GET_MEM_CTX(ndr);
5824                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sid, 0);
5825                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
5826                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_1, 0);
5827                 }
5828                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
5829                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5830         }
5831         return NDR_ERR_SUCCESS;
5832 }
5833
5834 _PUBLIC_ void ndr_print_samr_LookupDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupDomain *r)
5835 {
5836         ndr_print_struct(ndr, name, "samr_LookupDomain");
5837         ndr->depth++;
5838         if (flags & NDR_SET_VALUES) {
5839                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5840         }
5841         if (flags & NDR_IN) {
5842                 ndr_print_struct(ndr, "in", "samr_LookupDomain");
5843                 ndr->depth++;
5844                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
5845                 ndr->depth++;
5846                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
5847                 ndr->depth--;
5848                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
5849                 ndr->depth++;
5850                 ndr_print_lsa_String(ndr, "domain_name", r->in.domain_name);
5851                 ndr->depth--;
5852                 ndr->depth--;
5853         }
5854         if (flags & NDR_OUT) {
5855                 ndr_print_struct(ndr, "out", "samr_LookupDomain");
5856                 ndr->depth++;
5857                 ndr_print_ptr(ndr, "sid", r->out.sid);
5858                 ndr->depth++;
5859                 ndr_print_ptr(ndr, "sid", *r->out.sid);
5860                 ndr->depth++;
5861                 if (*r->out.sid) {
5862                         ndr_print_dom_sid2(ndr, "sid", *r->out.sid);
5863                 }
5864                 ndr->depth--;
5865                 ndr->depth--;
5866                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5867                 ndr->depth--;
5868         }
5869         ndr->depth--;
5870 }
5871
5872 static enum ndr_err_code ndr_push_samr_EnumDomains(struct ndr_push *ndr, int flags, const struct samr_EnumDomains *r)
5873 {
5874         if (flags & NDR_IN) {
5875                 if (r->in.connect_handle == NULL) {
5876                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5877                 }
5878                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5879                 if (r->in.resume_handle == NULL) {
5880                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5881                 }
5882                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
5883                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
5884         }
5885         if (flags & NDR_OUT) {
5886                 if (r->out.resume_handle == NULL) {
5887                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5888                 }
5889                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
5890                 if (r->out.sam == NULL) {
5891                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5892                 }
5893                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
5894                 if (*r->out.sam) {
5895                         NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
5896                 }
5897                 if (r->out.num_entries == NULL) {
5898                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5899                 }
5900                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
5901                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5902         }
5903         return NDR_ERR_SUCCESS;
5904 }
5905
5906 static enum ndr_err_code ndr_pull_samr_EnumDomains(struct ndr_pull *ndr, int flags, struct samr_EnumDomains *r)
5907 {
5908         uint32_t _ptr_sam;
5909         TALLOC_CTX *_mem_save_connect_handle_0;
5910         TALLOC_CTX *_mem_save_resume_handle_0;
5911         TALLOC_CTX *_mem_save_sam_0;
5912         TALLOC_CTX *_mem_save_sam_1;
5913         TALLOC_CTX *_mem_save_num_entries_0;
5914         if (flags & NDR_IN) {
5915                 ZERO_STRUCT(r->out);
5916
5917                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5918                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
5919                 }
5920                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5921                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
5922                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
5923                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
5924                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5925                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
5926                 }
5927                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5928                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
5929                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
5930                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
5931                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
5932                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
5933                 *r->out.resume_handle = *r->in.resume_handle;
5934                 NDR_PULL_ALLOC(ndr, r->out.sam);
5935                 ZERO_STRUCTP(r->out.sam);
5936                 NDR_PULL_ALLOC(ndr, r->out.num_entries);
5937                 ZERO_STRUCTP(r->out.num_entries);
5938         }
5939         if (flags & NDR_OUT) {
5940                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5941                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
5942                 }
5943                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5944                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
5945                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
5946                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
5947                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5948                         NDR_PULL_ALLOC(ndr, r->out.sam);
5949                 }
5950                 _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
5951                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
5952                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
5953                 if (_ptr_sam) {
5954                         NDR_PULL_ALLOC(ndr, *r->out.sam);
5955                 } else {
5956                         *r->out.sam = NULL;
5957                 }
5958                 if (*r->out.sam) {
5959                         _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
5960                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
5961                         NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
5962                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
5963                 }
5964                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
5965                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5966                         NDR_PULL_ALLOC(ndr, r->out.num_entries);
5967                 }
5968                 _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
5969                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
5970                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
5971                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
5972                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5973         }
5974         return NDR_ERR_SUCCESS;
5975 }
5976
5977 _PUBLIC_ void ndr_print_samr_EnumDomains(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomains *r)
5978 {
5979         ndr_print_struct(ndr, name, "samr_EnumDomains");
5980         ndr->depth++;
5981         if (flags & NDR_SET_VALUES) {
5982                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5983         }
5984         if (flags & NDR_IN) {
5985                 ndr_print_struct(ndr, "in", "samr_EnumDomains");
5986                 ndr->depth++;
5987                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
5988                 ndr->depth++;
5989                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
5990                 ndr->depth--;
5991                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
5992                 ndr->depth++;
5993                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
5994                 ndr->depth--;
5995                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
5996                 ndr->depth--;
5997         }
5998         if (flags & NDR_OUT) {
5999                 ndr_print_struct(ndr, "out", "samr_EnumDomains");
6000                 ndr->depth++;
6001                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6002                 ndr->depth++;
6003                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6004                 ndr->depth--;
6005                 ndr_print_ptr(ndr, "sam", r->out.sam);
6006                 ndr->depth++;
6007                 ndr_print_ptr(ndr, "sam", *r->out.sam);
6008                 ndr->depth++;
6009                 if (*r->out.sam) {
6010                         ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
6011                 }
6012                 ndr->depth--;
6013                 ndr->depth--;
6014                 ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
6015                 ndr->depth++;
6016                 ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
6017                 ndr->depth--;
6018                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6019                 ndr->depth--;
6020         }
6021         ndr->depth--;
6022 }
6023
6024 _PUBLIC_ enum ndr_err_code ndr_push_samr_OpenDomain(struct ndr_push *ndr, int flags, const struct samr_OpenDomain *r)
6025 {
6026         if (flags & NDR_IN) {
6027                 if (r->in.connect_handle == NULL) {
6028                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6029                 }
6030                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
6031                 NDR_CHECK(ndr_push_samr_DomainAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
6032                 if (r->in.sid == NULL) {
6033                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6034                 }
6035                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
6036         }
6037         if (flags & NDR_OUT) {
6038                 if (r->out.domain_handle == NULL) {
6039                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6040                 }
6041                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.domain_handle));
6042                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6043         }
6044         return NDR_ERR_SUCCESS;
6045 }
6046
6047 _PUBLIC_ enum ndr_err_code ndr_pull_samr_OpenDomain(struct ndr_pull *ndr, int flags, struct samr_OpenDomain *r)
6048 {
6049         TALLOC_CTX *_mem_save_connect_handle_0;
6050         TALLOC_CTX *_mem_save_sid_0;
6051         TALLOC_CTX *_mem_save_domain_handle_0;
6052         if (flags & NDR_IN) {
6053                 ZERO_STRUCT(r->out);
6054
6055                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6056                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
6057                 }
6058                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6059                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
6060                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
6061                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
6062                 NDR_CHECK(ndr_pull_samr_DomainAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
6063                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6064                         NDR_PULL_ALLOC(ndr, r->in.sid);
6065                 }
6066                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6067                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
6068                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
6069                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
6070                 NDR_PULL_ALLOC(ndr, r->out.domain_handle);
6071                 ZERO_STRUCTP(r->out.domain_handle);
6072         }
6073         if (flags & NDR_OUT) {
6074                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6075                         NDR_PULL_ALLOC(ndr, r->out.domain_handle);
6076                 }
6077                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6078                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6079                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.domain_handle));
6080                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6081                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6082         }
6083         return NDR_ERR_SUCCESS;
6084 }
6085
6086 _PUBLIC_ void ndr_print_samr_OpenDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenDomain *r)
6087 {
6088         ndr_print_struct(ndr, name, "samr_OpenDomain");
6089         ndr->depth++;
6090         if (flags & NDR_SET_VALUES) {
6091                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6092         }
6093         if (flags & NDR_IN) {
6094                 ndr_print_struct(ndr, "in", "samr_OpenDomain");
6095                 ndr->depth++;
6096                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
6097                 ndr->depth++;
6098                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
6099                 ndr->depth--;
6100                 ndr_print_samr_DomainAccessMask(ndr, "access_mask", r->in.access_mask);
6101                 ndr_print_ptr(ndr, "sid", r->in.sid);
6102                 ndr->depth++;
6103                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
6104                 ndr->depth--;
6105                 ndr->depth--;
6106         }
6107         if (flags & NDR_OUT) {
6108                 ndr_print_struct(ndr, "out", "samr_OpenDomain");
6109                 ndr->depth++;
6110                 ndr_print_ptr(ndr, "domain_handle", r->out.domain_handle);
6111                 ndr->depth++;
6112                 ndr_print_policy_handle(ndr, "domain_handle", r->out.domain_handle);
6113                 ndr->depth--;
6114                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6115                 ndr->depth--;
6116         }
6117         ndr->depth--;
6118 }
6119
6120 static enum ndr_err_code ndr_push_samr_QueryDomainInfo(struct ndr_push *ndr, int flags, const struct samr_QueryDomainInfo *r)
6121 {
6122         if (flags & NDR_IN) {
6123                 if (r->in.domain_handle == NULL) {
6124                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6125                 }
6126                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6127                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
6128         }
6129         if (flags & NDR_OUT) {
6130                 if (r->out.info == NULL) {
6131                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6132                 }
6133                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
6134                 if (*r->out.info) {
6135                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
6136                         NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
6137                 }
6138                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6139         }
6140         return NDR_ERR_SUCCESS;
6141 }
6142
6143 static enum ndr_err_code ndr_pull_samr_QueryDomainInfo(struct ndr_pull *ndr, int flags, struct samr_QueryDomainInfo *r)
6144 {
6145         uint32_t _ptr_info;
6146         TALLOC_CTX *_mem_save_domain_handle_0;
6147         TALLOC_CTX *_mem_save_info_0;
6148         TALLOC_CTX *_mem_save_info_1;
6149         if (flags & NDR_IN) {
6150                 ZERO_STRUCT(r->out);
6151
6152                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6153                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6154                 }
6155                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6156                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6157                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6158                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6159                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
6160                 NDR_PULL_ALLOC(ndr, r->out.info);
6161                 ZERO_STRUCTP(r->out.info);
6162         }
6163         if (flags & NDR_OUT) {
6164                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6165                         NDR_PULL_ALLOC(ndr, r->out.info);
6166                 }
6167                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6168                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
6169                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
6170                 if (_ptr_info) {
6171                         NDR_PULL_ALLOC(ndr, *r->out.info);
6172                 } else {
6173                         *r->out.info = NULL;
6174                 }
6175                 if (*r->out.info) {
6176                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
6177                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
6178                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
6179                         NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
6180                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
6181                 }
6182                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6183                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6184         }
6185         return NDR_ERR_SUCCESS;
6186 }
6187
6188 _PUBLIC_ void ndr_print_samr_QueryDomainInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDomainInfo *r)
6189 {
6190         ndr_print_struct(ndr, name, "samr_QueryDomainInfo");
6191         ndr->depth++;
6192         if (flags & NDR_SET_VALUES) {
6193                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6194         }
6195         if (flags & NDR_IN) {
6196                 ndr_print_struct(ndr, "in", "samr_QueryDomainInfo");
6197                 ndr->depth++;
6198                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6199                 ndr->depth++;
6200                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6201                 ndr->depth--;
6202                 ndr_print_uint16(ndr, "level", r->in.level);
6203                 ndr->depth--;
6204         }
6205         if (flags & NDR_OUT) {
6206                 ndr_print_struct(ndr, "out", "samr_QueryDomainInfo");
6207                 ndr->depth++;
6208                 ndr_print_ptr(ndr, "info", r->out.info);
6209                 ndr->depth++;
6210                 ndr_print_ptr(ndr, "info", *r->out.info);
6211                 ndr->depth++;
6212                 if (*r->out.info) {
6213                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
6214                         ndr_print_samr_DomainInfo(ndr, "info", *r->out.info);
6215                 }
6216                 ndr->depth--;
6217                 ndr->depth--;
6218                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6219                 ndr->depth--;
6220         }
6221         ndr->depth--;
6222 }
6223
6224 static enum ndr_err_code ndr_push_samr_SetDomainInfo(struct ndr_push *ndr, int flags, const struct samr_SetDomainInfo *r)
6225 {
6226         if (flags & NDR_IN) {
6227                 if (r->in.domain_handle == NULL) {
6228                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6229                 }
6230                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6231                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
6232                 if (r->in.info == NULL) {
6233                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6234                 }
6235                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
6236                 NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6237         }
6238         if (flags & NDR_OUT) {
6239                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6240         }
6241         return NDR_ERR_SUCCESS;
6242 }
6243
6244 static enum ndr_err_code ndr_pull_samr_SetDomainInfo(struct ndr_pull *ndr, int flags, struct samr_SetDomainInfo *r)
6245 {
6246         TALLOC_CTX *_mem_save_domain_handle_0;
6247         TALLOC_CTX *_mem_save_info_0;
6248         if (flags & NDR_IN) {
6249                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6250                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6251                 }
6252                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6253                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6254                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6255                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6256                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
6257                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6258                         NDR_PULL_ALLOC(ndr, r->in.info);
6259                 }
6260                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6261                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
6262                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
6263                 NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6264                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6265         }
6266         if (flags & NDR_OUT) {
6267                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6268         }
6269         return NDR_ERR_SUCCESS;
6270 }
6271
6272 _PUBLIC_ void ndr_print_samr_SetDomainInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetDomainInfo *r)
6273 {
6274         ndr_print_struct(ndr, name, "samr_SetDomainInfo");
6275         ndr->depth++;
6276         if (flags & NDR_SET_VALUES) {
6277                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6278         }
6279         if (flags & NDR_IN) {
6280                 ndr_print_struct(ndr, "in", "samr_SetDomainInfo");
6281                 ndr->depth++;
6282                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6283                 ndr->depth++;
6284                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6285                 ndr->depth--;
6286                 ndr_print_uint16(ndr, "level", r->in.level);
6287                 ndr_print_ptr(ndr, "info", r->in.info);
6288                 ndr->depth++;
6289                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
6290                 ndr_print_samr_DomainInfo(ndr, "info", r->in.info);
6291                 ndr->depth--;
6292                 ndr->depth--;
6293         }
6294         if (flags & NDR_OUT) {
6295                 ndr_print_struct(ndr, "out", "samr_SetDomainInfo");
6296                 ndr->depth++;
6297                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6298                 ndr->depth--;
6299         }
6300         ndr->depth--;
6301 }
6302
6303 static enum ndr_err_code ndr_push_samr_CreateDomainGroup(struct ndr_push *ndr, int flags, const struct samr_CreateDomainGroup *r)
6304 {
6305         if (flags & NDR_IN) {
6306                 if (r->in.domain_handle == NULL) {
6307                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6308                 }
6309                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6310                 if (r->in.name == NULL) {
6311                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6312                 }
6313                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
6314                 NDR_CHECK(ndr_push_samr_GroupAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
6315         }
6316         if (flags & NDR_OUT) {
6317                 if (r->out.group_handle == NULL) {
6318                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6319                 }
6320                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
6321                 if (r->out.rid == NULL) {
6322                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6323                 }
6324                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
6325                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6326         }
6327         return NDR_ERR_SUCCESS;
6328 }
6329
6330 static enum ndr_err_code ndr_pull_samr_CreateDomainGroup(struct ndr_pull *ndr, int flags, struct samr_CreateDomainGroup *r)
6331 {
6332         TALLOC_CTX *_mem_save_domain_handle_0;
6333         TALLOC_CTX *_mem_save_name_0;
6334         TALLOC_CTX *_mem_save_group_handle_0;
6335         TALLOC_CTX *_mem_save_rid_0;
6336         if (flags & NDR_IN) {
6337                 ZERO_STRUCT(r->out);
6338
6339                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6340                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6341                 }
6342                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6343                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6344                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6345                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6346                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6347                         NDR_PULL_ALLOC(ndr, r->in.name);
6348                 }
6349                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6350                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
6351                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
6352                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
6353                 NDR_CHECK(ndr_pull_samr_GroupAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
6354                 NDR_PULL_ALLOC(ndr, r->out.group_handle);
6355                 ZERO_STRUCTP(r->out.group_handle);
6356                 NDR_PULL_ALLOC(ndr, r->out.rid);
6357                 ZERO_STRUCTP(r->out.rid);
6358         }
6359         if (flags & NDR_OUT) {
6360                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6361                         NDR_PULL_ALLOC(ndr, r->out.group_handle);
6362                 }
6363                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6364                 NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);
6365                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
6366                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
6367                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6368                         NDR_PULL_ALLOC(ndr, r->out.rid);
6369                 }
6370                 _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6371                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
6372                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
6373                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
6374                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6375         }
6376         return NDR_ERR_SUCCESS;
6377 }
6378
6379 _PUBLIC_ void ndr_print_samr_CreateDomainGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateDomainGroup *r)
6380 {
6381         ndr_print_struct(ndr, name, "samr_CreateDomainGroup");
6382         ndr->depth++;
6383         if (flags & NDR_SET_VALUES) {
6384                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6385         }
6386         if (flags & NDR_IN) {
6387                 ndr_print_struct(ndr, "in", "samr_CreateDomainGroup");
6388                 ndr->depth++;
6389                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6390                 ndr->depth++;
6391                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6392                 ndr->depth--;
6393                 ndr_print_ptr(ndr, "name", r->in.name);
6394                 ndr->depth++;
6395                 ndr_print_lsa_String(ndr, "name", r->in.name);
6396                 ndr->depth--;
6397                 ndr_print_samr_GroupAccessMask(ndr, "access_mask", r->in.access_mask);
6398                 ndr->depth--;
6399         }
6400         if (flags & NDR_OUT) {
6401                 ndr_print_struct(ndr, "out", "samr_CreateDomainGroup");
6402                 ndr->depth++;
6403                 ndr_print_ptr(ndr, "group_handle", r->out.group_handle);
6404                 ndr->depth++;
6405                 ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);
6406                 ndr->depth--;
6407                 ndr_print_ptr(ndr, "rid", r->out.rid);
6408                 ndr->depth++;
6409                 ndr_print_uint32(ndr, "rid", *r->out.rid);
6410                 ndr->depth--;
6411                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6412                 ndr->depth--;
6413         }
6414         ndr->depth--;
6415 }
6416
6417 static enum ndr_err_code ndr_push_samr_EnumDomainGroups(struct ndr_push *ndr, int flags, const struct samr_EnumDomainGroups *r)
6418 {
6419         if (flags & NDR_IN) {
6420                 if (r->in.domain_handle == NULL) {
6421                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6422                 }
6423                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6424                 if (r->in.resume_handle == NULL) {
6425                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6426                 }
6427                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6428                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
6429         }
6430         if (flags & NDR_OUT) {
6431                 if (r->out.resume_handle == NULL) {
6432                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6433                 }
6434                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6435                 if (r->out.sam == NULL) {
6436                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6437                 }
6438                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
6439                 if (*r->out.sam) {
6440                         NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6441                 }
6442                 if (r->out.num_entries == NULL) {
6443                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6444                 }
6445                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
6446                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6447         }
6448         return NDR_ERR_SUCCESS;
6449 }
6450
6451 static enum ndr_err_code ndr_pull_samr_EnumDomainGroups(struct ndr_pull *ndr, int flags, struct samr_EnumDomainGroups *r)
6452 {
6453         uint32_t _ptr_sam;
6454         TALLOC_CTX *_mem_save_domain_handle_0;
6455         TALLOC_CTX *_mem_save_resume_handle_0;
6456         TALLOC_CTX *_mem_save_sam_0;
6457         TALLOC_CTX *_mem_save_sam_1;
6458         TALLOC_CTX *_mem_save_num_entries_0;
6459         if (flags & NDR_IN) {
6460                 ZERO_STRUCT(r->out);
6461
6462                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6463                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6464                 }
6465                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6466                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6467                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6468                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6469                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6470                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
6471                 }
6472                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6473                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6474                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6475                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6476                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
6477                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6478                 *r->out.resume_handle = *r->in.resume_handle;
6479                 NDR_PULL_ALLOC(ndr, r->out.sam);
6480                 ZERO_STRUCTP(r->out.sam);
6481                 NDR_PULL_ALLOC(ndr, r->out.num_entries);
6482                 ZERO_STRUCTP(r->out.num_entries);
6483         }
6484         if (flags & NDR_OUT) {
6485                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6486                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6487                 }
6488                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6489                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6491                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6492                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6493                         NDR_PULL_ALLOC(ndr, r->out.sam);
6494                 }
6495                 _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
6496                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
6497                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
6498                 if (_ptr_sam) {
6499                         NDR_PULL_ALLOC(ndr, *r->out.sam);
6500                 } else {
6501                         *r->out.sam = NULL;
6502                 }
6503                 if (*r->out.sam) {
6504                         _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
6505                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
6506                         NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6507                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
6508                 }
6509                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
6510                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6511                         NDR_PULL_ALLOC(ndr, r->out.num_entries);
6512                 }
6513                 _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
6514                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
6515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
6516                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
6517                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6518         }
6519         return NDR_ERR_SUCCESS;
6520 }
6521
6522 _PUBLIC_ void ndr_print_samr_EnumDomainGroups(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainGroups *r)
6523 {
6524         ndr_print_struct(ndr, name, "samr_EnumDomainGroups");
6525         ndr->depth++;
6526         if (flags & NDR_SET_VALUES) {
6527                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6528         }
6529         if (flags & NDR_IN) {
6530                 ndr_print_struct(ndr, "in", "samr_EnumDomainGroups");
6531                 ndr->depth++;
6532                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6533                 ndr->depth++;
6534                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6535                 ndr->depth--;
6536                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6537                 ndr->depth++;
6538                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6539                 ndr->depth--;
6540                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
6541                 ndr->depth--;
6542         }
6543         if (flags & NDR_OUT) {
6544                 ndr_print_struct(ndr, "out", "samr_EnumDomainGroups");
6545                 ndr->depth++;
6546                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6547                 ndr->depth++;
6548                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6549                 ndr->depth--;
6550                 ndr_print_ptr(ndr, "sam", r->out.sam);
6551                 ndr->depth++;
6552                 ndr_print_ptr(ndr, "sam", *r->out.sam);
6553                 ndr->depth++;
6554                 if (*r->out.sam) {
6555                         ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
6556                 }
6557                 ndr->depth--;
6558                 ndr->depth--;
6559                 ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
6560                 ndr->depth++;
6561                 ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
6562                 ndr->depth--;
6563                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6564                 ndr->depth--;
6565         }
6566         ndr->depth--;
6567 }
6568
6569 static enum ndr_err_code ndr_push_samr_CreateUser(struct ndr_push *ndr, int flags, const struct samr_CreateUser *r)
6570 {
6571         if (flags & NDR_IN) {
6572                 if (r->in.domain_handle == NULL) {
6573                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6574                 }
6575                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6576                 if (r->in.account_name == NULL) {
6577                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6578                 }
6579                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
6580                 NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
6581         }
6582         if (flags & NDR_OUT) {
6583                 if (r->out.user_handle == NULL) {
6584                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6585                 }
6586                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
6587                 if (r->out.rid == NULL) {
6588                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6589                 }
6590                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
6591                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6592         }
6593         return NDR_ERR_SUCCESS;
6594 }
6595
6596 static enum ndr_err_code ndr_pull_samr_CreateUser(struct ndr_pull *ndr, int flags, struct samr_CreateUser *r)
6597 {
6598         TALLOC_CTX *_mem_save_domain_handle_0;
6599         TALLOC_CTX *_mem_save_account_name_0;
6600         TALLOC_CTX *_mem_save_user_handle_0;
6601         TALLOC_CTX *_mem_save_rid_0;
6602         if (flags & NDR_IN) {
6603                 ZERO_STRUCT(r->out);
6604
6605                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6606                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6607                 }
6608                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6609                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6610                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6611                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6612                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6613                         NDR_PULL_ALLOC(ndr, r->in.account_name);
6614                 }
6615                 _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6616                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account_name, LIBNDR_FLAG_REF_ALLOC);
6617                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
6618                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, LIBNDR_FLAG_REF_ALLOC);
6619                 NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
6620                 NDR_PULL_ALLOC(ndr, r->out.user_handle);
6621                 ZERO_STRUCTP(r->out.user_handle);
6622                 NDR_PULL_ALLOC(ndr, r->out.rid);
6623                 ZERO_STRUCTP(r->out.rid);
6624         }
6625         if (flags & NDR_OUT) {
6626                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6627                         NDR_PULL_ALLOC(ndr, r->out.user_handle);
6628                 }
6629                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6630                 NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
6631                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
6632                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
6633                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6634                         NDR_PULL_ALLOC(ndr, r->out.rid);
6635                 }
6636                 _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6637                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
6638                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
6639                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
6640                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6641         }
6642         return NDR_ERR_SUCCESS;
6643 }
6644
6645 _PUBLIC_ void ndr_print_samr_CreateUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateUser *r)
6646 {
6647         ndr_print_struct(ndr, name, "samr_CreateUser");
6648         ndr->depth++;
6649         if (flags & NDR_SET_VALUES) {
6650                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6651         }
6652         if (flags & NDR_IN) {
6653                 ndr_print_struct(ndr, "in", "samr_CreateUser");
6654                 ndr->depth++;
6655                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6656                 ndr->depth++;
6657                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6658                 ndr->depth--;
6659                 ndr_print_ptr(ndr, "account_name", r->in.account_name);
6660                 ndr->depth++;
6661                 ndr_print_lsa_String(ndr, "account_name", r->in.account_name);
6662                 ndr->depth--;
6663                 ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);
6664                 ndr->depth--;
6665         }
6666         if (flags & NDR_OUT) {
6667                 ndr_print_struct(ndr, "out", "samr_CreateUser");
6668                 ndr->depth++;
6669                 ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
6670                 ndr->depth++;
6671                 ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
6672                 ndr->depth--;
6673                 ndr_print_ptr(ndr, "rid", r->out.rid);
6674                 ndr->depth++;
6675                 ndr_print_uint32(ndr, "rid", *r->out.rid);
6676                 ndr->depth--;
6677                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6678                 ndr->depth--;
6679         }
6680         ndr->depth--;
6681 }
6682
6683 static enum ndr_err_code ndr_push_samr_EnumDomainUsers(struct ndr_push *ndr, int flags, const struct samr_EnumDomainUsers *r)
6684 {
6685         if (flags & NDR_IN) {
6686                 if (r->in.domain_handle == NULL) {
6687                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6688                 }
6689                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6690                 if (r->in.resume_handle == NULL) {
6691                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6692                 }
6693                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6694                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->in.acct_flags));
6695                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
6696         }
6697         if (flags & NDR_OUT) {
6698                 if (r->out.resume_handle == NULL) {
6699                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6700                 }
6701                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6702                 if (r->out.sam == NULL) {
6703                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6704                 }
6705                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
6706                 if (*r->out.sam) {
6707                         NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6708                 }
6709                 if (r->out.num_entries == NULL) {
6710                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6711                 }
6712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
6713                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6714         }
6715         return NDR_ERR_SUCCESS;
6716 }
6717
6718 static enum ndr_err_code ndr_pull_samr_EnumDomainUsers(struct ndr_pull *ndr, int flags, struct samr_EnumDomainUsers *r)
6719 {
6720         uint32_t _ptr_sam;
6721         TALLOC_CTX *_mem_save_domain_handle_0;
6722         TALLOC_CTX *_mem_save_resume_handle_0;
6723         TALLOC_CTX *_mem_save_sam_0;
6724         TALLOC_CTX *_mem_save_sam_1;
6725         TALLOC_CTX *_mem_save_num_entries_0;
6726         if (flags & NDR_IN) {
6727                 ZERO_STRUCT(r->out);
6728
6729                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6730                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6731                 }
6732                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6733                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6734                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6735                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6736                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6737                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
6738                 }
6739                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6740                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6741                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6742                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6743                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->in.acct_flags));
6744                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
6745                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6746                 *r->out.resume_handle = *r->in.resume_handle;
6747                 NDR_PULL_ALLOC(ndr, r->out.sam);
6748                 ZERO_STRUCTP(r->out.sam);
6749                 NDR_PULL_ALLOC(ndr, r->out.num_entries);
6750                 ZERO_STRUCTP(r->out.num_entries);
6751         }
6752         if (flags & NDR_OUT) {
6753                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6754                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6755                 }
6756                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6757                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6758                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6759                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6760                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6761                         NDR_PULL_ALLOC(ndr, r->out.sam);
6762                 }
6763                 _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
6764                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
6765                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
6766                 if (_ptr_sam) {
6767                         NDR_PULL_ALLOC(ndr, *r->out.sam);
6768                 } else {
6769                         *r->out.sam = NULL;
6770                 }
6771                 if (*r->out.sam) {
6772                         _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
6773                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
6774                         NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6775                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
6776                 }
6777                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
6778                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6779                         NDR_PULL_ALLOC(ndr, r->out.num_entries);
6780                 }
6781                 _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
6782                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
6783                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
6784                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
6785                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6786         }
6787         return NDR_ERR_SUCCESS;
6788 }
6789
6790 _PUBLIC_ void ndr_print_samr_EnumDomainUsers(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainUsers *r)
6791 {
6792         ndr_print_struct(ndr, name, "samr_EnumDomainUsers");
6793         ndr->depth++;
6794         if (flags & NDR_SET_VALUES) {
6795                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6796         }
6797         if (flags & NDR_IN) {
6798                 ndr_print_struct(ndr, "in", "samr_EnumDomainUsers");
6799                 ndr->depth++;
6800                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6801                 ndr->depth++;
6802                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6803                 ndr->depth--;
6804                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6805                 ndr->depth++;
6806                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6807                 ndr->depth--;
6808                 ndr_print_samr_AcctFlags(ndr, "acct_flags", r->in.acct_flags);
6809                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
6810                 ndr->depth--;
6811         }
6812         if (flags & NDR_OUT) {
6813                 ndr_print_struct(ndr, "out", "samr_EnumDomainUsers");
6814                 ndr->depth++;
6815                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6816                 ndr->depth++;
6817                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6818                 ndr->depth--;
6819                 ndr_print_ptr(ndr, "sam", r->out.sam);
6820                 ndr->depth++;
6821                 ndr_print_ptr(ndr, "sam", *r->out.sam);
6822                 ndr->depth++;
6823                 if (*r->out.sam) {
6824                         ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
6825                 }
6826                 ndr->depth--;
6827                 ndr->depth--;
6828                 ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
6829                 ndr->depth++;
6830                 ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
6831                 ndr->depth--;
6832                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6833                 ndr->depth--;
6834         }
6835         ndr->depth--;
6836 }
6837
6838 static enum ndr_err_code ndr_push_samr_CreateDomAlias(struct ndr_push *ndr, int flags, const struct samr_CreateDomAlias *r)
6839 {
6840         if (flags & NDR_IN) {
6841                 if (r->in.domain_handle == NULL) {
6842                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6843                 }
6844                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6845                 if (r->in.alias_name == NULL) {
6846                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6847                 }
6848                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.alias_name));
6849                 NDR_CHECK(ndr_push_samr_AliasAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
6850         }
6851         if (flags & NDR_OUT) {
6852                 if (r->out.alias_handle == NULL) {
6853                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6854                 }
6855                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
6856                 if (r->out.rid == NULL) {
6857                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6858                 }
6859                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
6860                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6861         }
6862         return NDR_ERR_SUCCESS;
6863 }
6864
6865 static enum ndr_err_code ndr_pull_samr_CreateDomAlias(struct ndr_pull *ndr, int flags, struct samr_CreateDomAlias *r)
6866 {
6867         TALLOC_CTX *_mem_save_domain_handle_0;
6868         TALLOC_CTX *_mem_save_alias_name_0;
6869         TALLOC_CTX *_mem_save_alias_handle_0;
6870         TALLOC_CTX *_mem_save_rid_0;
6871         if (flags & NDR_IN) {
6872                 ZERO_STRUCT(r->out);
6873
6874                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6875                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6876                 }
6877                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6878                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
6879                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6880                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
6881                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6882                         NDR_PULL_ALLOC(ndr, r->in.alias_name);
6883                 }
6884                 _mem_save_alias_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6885                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_name, LIBNDR_FLAG_REF_ALLOC);
6886                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.alias_name));
6887                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_name_0, LIBNDR_FLAG_REF_ALLOC);
6888                 NDR_CHECK(ndr_pull_samr_AliasAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
6889                 NDR_PULL_ALLOC(ndr, r->out.alias_handle);
6890                 ZERO_STRUCTP(r->out.alias_handle);
6891                 NDR_PULL_ALLOC(ndr, r->out.rid);
6892                 ZERO_STRUCTP(r->out.rid);
6893         }
6894         if (flags & NDR_OUT) {
6895                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6896                         NDR_PULL_ALLOC(ndr, r->out.alias_handle);
6897                 }
6898                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6899                 NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);
6900                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
6901                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
6902                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6903                         NDR_PULL_ALLOC(ndr, r->out.rid);
6904                 }
6905                 _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6906                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
6907                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
6908                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
6909                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6910         }
6911         return NDR_ERR_SUCCESS;
6912 }
6913
6914 _PUBLIC_ void ndr_print_samr_CreateDomAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateDomAlias *r)
6915 {
6916         ndr_print_struct(ndr, name, "samr_CreateDomAlias");
6917         ndr->depth++;
6918         if (flags & NDR_SET_VALUES) {
6919                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6920         }
6921         if (flags & NDR_IN) {
6922                 ndr_print_struct(ndr, "in", "samr_CreateDomAlias");
6923                 ndr->depth++;
6924                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
6925                 ndr->depth++;
6926                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
6927                 ndr->depth--;
6928                 ndr_print_ptr(ndr, "alias_name", r->in.alias_name);
6929                 ndr->depth++;
6930                 ndr_print_lsa_String(ndr, "alias_name", r->in.alias_name);
6931                 ndr->depth--;
6932                 ndr_print_samr_AliasAccessMask(ndr, "access_mask", r->in.access_mask);
6933                 ndr->depth--;
6934         }
6935         if (flags & NDR_OUT) {
6936                 ndr_print_struct(ndr, "out", "samr_CreateDomAlias");
6937                 ndr->depth++;
6938                 ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);
6939                 ndr->depth++;
6940                 ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);
6941                 ndr->depth--;
6942                 ndr_print_ptr(ndr, "rid", r->out.rid);
6943                 ndr->depth++;
6944                 ndr_print_uint32(ndr, "rid", *r->out.rid);
6945                 ndr->depth--;
6946                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6947                 ndr->depth--;
6948         }
6949         ndr->depth--;
6950 }
6951
6952 static enum ndr_err_code ndr_push_samr_EnumDomainAliases(struct ndr_push *ndr, int flags, const struct samr_EnumDomainAliases *r)
6953 {
6954         if (flags & NDR_IN) {
6955                 if (r->in.domain_handle == NULL) {
6956                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6957                 }
6958                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
6959                 if (r->in.resume_handle == NULL) {
6960                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6961                 }
6962                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6963                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
6964         }
6965         if (flags & NDR_OUT) {
6966                 if (r->out.resume_handle == NULL) {
6967                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6968                 }
6969                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6970                 if (r->out.sam == NULL) {
6971                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6972                 }
6973                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
6974                 if (*r->out.sam) {
6975                         NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
6976                 }
6977                 if (r->out.num_entries == NULL) {
6978                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6979                 }
6980                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
6981                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6982         }
6983         return NDR_ERR_SUCCESS;
6984 }
6985
6986 static enum ndr_err_code ndr_pull_samr_EnumDomainAliases(struct ndr_pull *ndr, int flags, struct samr_EnumDomainAliases *r)
6987 {
6988         uint32_t _ptr_sam;
6989         TALLOC_CTX *_mem_save_domain_handle_0;
6990         TALLOC_CTX *_mem_save_resume_handle_0;
6991         TALLOC_CTX *_mem_save_sam_0;
6992         TALLOC_CTX *_mem_save_sam_1;
6993         TALLOC_CTX *_mem_save_num_entries_0;
6994         if (flags & NDR_IN) {
6995                 ZERO_STRUCT(r->out);
6996
6997                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6998                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
6999                 }
7000                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7001                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7002                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7003                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7004                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7005                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
7006                 }
7007                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7008                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
7009                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
7010                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
7011                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
7012                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
7013                 *r->out.resume_handle = *r->in.resume_handle;
7014                 NDR_PULL_ALLOC(ndr, r->out.sam);
7015                 ZERO_STRUCTP(r->out.sam);
7016                 NDR_PULL_ALLOC(ndr, r->out.num_entries);
7017                 ZERO_STRUCTP(r->out.num_entries);
7018         }
7019         if (flags & NDR_OUT) {
7020                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7021                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
7022                 }
7023                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7024                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
7025                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
7026                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
7027                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7028                         NDR_PULL_ALLOC(ndr, r->out.sam);
7029                 }
7030                 _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
7031                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
7032                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
7033                 if (_ptr_sam) {
7034                         NDR_PULL_ALLOC(ndr, *r->out.sam);
7035                 } else {
7036                         *r->out.sam = NULL;
7037                 }
7038                 if (*r->out.sam) {
7039                         _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
7040                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
7041                         NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
7042                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
7043                 }
7044                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
7045                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7046                         NDR_PULL_ALLOC(ndr, r->out.num_entries);
7047                 }
7048                 _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
7049                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
7050                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
7051                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
7052                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7053         }
7054         return NDR_ERR_SUCCESS;
7055 }
7056
7057 _PUBLIC_ void ndr_print_samr_EnumDomainAliases(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainAliases *r)
7058 {
7059         ndr_print_struct(ndr, name, "samr_EnumDomainAliases");
7060         ndr->depth++;
7061         if (flags & NDR_SET_VALUES) {
7062                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7063         }
7064         if (flags & NDR_IN) {
7065                 ndr_print_struct(ndr, "in", "samr_EnumDomainAliases");
7066                 ndr->depth++;
7067                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7068                 ndr->depth++;
7069                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7070                 ndr->depth--;
7071                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
7072                 ndr->depth++;
7073                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
7074                 ndr->depth--;
7075                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
7076                 ndr->depth--;
7077         }
7078         if (flags & NDR_OUT) {
7079                 ndr_print_struct(ndr, "out", "samr_EnumDomainAliases");
7080                 ndr->depth++;
7081                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
7082                 ndr->depth++;
7083                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
7084                 ndr->depth--;
7085                 ndr_print_ptr(ndr, "sam", r->out.sam);
7086                 ndr->depth++;
7087                 ndr_print_ptr(ndr, "sam", *r->out.sam);
7088                 ndr->depth++;
7089                 if (*r->out.sam) {
7090                         ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
7091                 }
7092                 ndr->depth--;
7093                 ndr->depth--;
7094                 ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
7095                 ndr->depth++;
7096                 ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
7097                 ndr->depth--;
7098                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7099                 ndr->depth--;
7100         }
7101         ndr->depth--;
7102 }
7103
7104 static enum ndr_err_code ndr_push_samr_GetAliasMembership(struct ndr_push *ndr, int flags, const struct samr_GetAliasMembership *r)
7105 {
7106         if (flags & NDR_IN) {
7107                 if (r->in.domain_handle == NULL) {
7108                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7109                 }
7110                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7111                 if (r->in.sids == NULL) {
7112                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7113                 }
7114                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
7115         }
7116         if (flags & NDR_OUT) {
7117                 if (r->out.rids == NULL) {
7118                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7119                 }
7120                 NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
7121                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7122         }
7123         return NDR_ERR_SUCCESS;
7124 }
7125
7126 static enum ndr_err_code ndr_pull_samr_GetAliasMembership(struct ndr_pull *ndr, int flags, struct samr_GetAliasMembership *r)
7127 {
7128         TALLOC_CTX *_mem_save_domain_handle_0;
7129         TALLOC_CTX *_mem_save_sids_0;
7130         TALLOC_CTX *_mem_save_rids_0;
7131         if (flags & NDR_IN) {
7132                 ZERO_STRUCT(r->out);
7133
7134                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7135                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7136                 }
7137                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7138                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7139                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7140                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7141                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7142                         NDR_PULL_ALLOC(ndr, r->in.sids);
7143                 }
7144                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7145                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
7146                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
7147                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
7148                 NDR_PULL_ALLOC(ndr, r->out.rids);
7149                 ZERO_STRUCTP(r->out.rids);
7150         }
7151         if (flags & NDR_OUT) {
7152                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7153                         NDR_PULL_ALLOC(ndr, r->out.rids);
7154                 }
7155                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7156                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
7157                 NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
7158                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
7159                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7160         }
7161         return NDR_ERR_SUCCESS;
7162 }
7163
7164 _PUBLIC_ void ndr_print_samr_GetAliasMembership(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetAliasMembership *r)
7165 {
7166         ndr_print_struct(ndr, name, "samr_GetAliasMembership");
7167         ndr->depth++;
7168         if (flags & NDR_SET_VALUES) {
7169                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7170         }
7171         if (flags & NDR_IN) {
7172                 ndr_print_struct(ndr, "in", "samr_GetAliasMembership");
7173                 ndr->depth++;
7174                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7175                 ndr->depth++;
7176                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7177                 ndr->depth--;
7178                 ndr_print_ptr(ndr, "sids", r->in.sids);
7179                 ndr->depth++;
7180                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
7181                 ndr->depth--;
7182                 ndr->depth--;
7183         }
7184         if (flags & NDR_OUT) {
7185                 ndr_print_struct(ndr, "out", "samr_GetAliasMembership");
7186                 ndr->depth++;
7187                 ndr_print_ptr(ndr, "rids", r->out.rids);
7188                 ndr->depth++;
7189                 ndr_print_samr_Ids(ndr, "rids", r->out.rids);
7190                 ndr->depth--;
7191                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7192                 ndr->depth--;
7193         }
7194         ndr->depth--;
7195 }
7196
7197 _PUBLIC_ enum ndr_err_code ndr_push_samr_LookupNames(struct ndr_push *ndr, int flags, const struct samr_LookupNames *r)
7198 {
7199         uint32_t cntr_names_0;
7200         if (flags & NDR_IN) {
7201                 if (r->in.domain_handle == NULL) {
7202                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7203                 }
7204                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7205                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
7206                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1000));
7207                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7208                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
7209                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
7210                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
7211                 }
7212                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
7213                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
7214                 }
7215         }
7216         if (flags & NDR_OUT) {
7217                 if (r->out.rids == NULL) {
7218                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7219                 }
7220                 NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
7221                 if (r->out.types == NULL) {
7222                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7223                 }
7224                 NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
7225                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7226         }
7227         return NDR_ERR_SUCCESS;
7228 }
7229
7230 _PUBLIC_ enum ndr_err_code ndr_pull_samr_LookupNames(struct ndr_pull *ndr, int flags, struct samr_LookupNames *r)
7231 {
7232         uint32_t size_names_0 = 0;
7233         uint32_t length_names_0 = 0;
7234         uint32_t cntr_names_0;
7235         TALLOC_CTX *_mem_save_domain_handle_0;
7236         TALLOC_CTX *_mem_save_names_0;
7237         TALLOC_CTX *_mem_save_rids_0;
7238         TALLOC_CTX *_mem_save_types_0;
7239         if (flags & NDR_IN) {
7240                 ZERO_STRUCT(r->out);
7241
7242                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7243                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7244                 }
7245                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7246                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7247                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7248                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7249                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
7250                 if (r->in.num_names > 1000) {
7251                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7252                 }
7253                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
7254                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.names));
7255                 size_names_0 = ndr_get_array_size(ndr, &r->in.names);
7256                 length_names_0 = ndr_get_array_length(ndr, &r->in.names);
7257                 if (length_names_0 > size_names_0) {
7258                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_names_0, length_names_0);
7259                 }
7260                 NDR_PULL_ALLOC_N(ndr, r->in.names, size_names_0);
7261                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
7262                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
7263                 for (cntr_names_0 = 0; cntr_names_0 < length_names_0; cntr_names_0++) {
7264                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
7265                 }
7266                 for (cntr_names_0 = 0; cntr_names_0 < length_names_0; cntr_names_0++) {
7267                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
7268                 }
7269                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
7270                 NDR_PULL_ALLOC(ndr, r->out.rids);
7271                 ZERO_STRUCTP(r->out.rids);
7272                 NDR_PULL_ALLOC(ndr, r->out.types);
7273                 ZERO_STRUCTP(r->out.types);
7274                 if (r->in.names) {
7275                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, 1000));
7276                 }
7277                 if (r->in.names) {
7278                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.names, r->in.num_names));
7279                 }
7280         }
7281         if (flags & NDR_OUT) {
7282                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7283                         NDR_PULL_ALLOC(ndr, r->out.rids);
7284                 }
7285                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7286                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
7287                 NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
7288                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
7289                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7290                         NDR_PULL_ALLOC(ndr, r->out.types);
7291                 }
7292                 _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
7293                 NDR_PULL_SET_MEM_CTX(ndr, r->out.types, LIBNDR_FLAG_REF_ALLOC);
7294                 NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
7295                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, LIBNDR_FLAG_REF_ALLOC);
7296                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7297         }
7298         return NDR_ERR_SUCCESS;
7299 }
7300
7301 _PUBLIC_ void ndr_print_samr_LookupNames(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupNames *r)
7302 {
7303         uint32_t cntr_names_0;
7304         ndr_print_struct(ndr, name, "samr_LookupNames");
7305         ndr->depth++;
7306         if (flags & NDR_SET_VALUES) {
7307                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7308         }
7309         if (flags & NDR_IN) {
7310                 ndr_print_struct(ndr, "in", "samr_LookupNames");
7311                 ndr->depth++;
7312                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7313                 ndr->depth++;
7314                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7315                 ndr->depth--;
7316                 ndr_print_uint32(ndr, "num_names", r->in.num_names);
7317                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->in.num_names);
7318                 ndr->depth++;
7319                 for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
7320                         char *idx_0=NULL;
7321                         if (asprintf(&idx_0, "[%d]", cntr_names_0) != -1) {
7322                                 ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
7323                                 free(idx_0);
7324                         }
7325                 }
7326                 ndr->depth--;
7327                 ndr->depth--;
7328         }
7329         if (flags & NDR_OUT) {
7330                 ndr_print_struct(ndr, "out", "samr_LookupNames");
7331                 ndr->depth++;
7332                 ndr_print_ptr(ndr, "rids", r->out.rids);
7333                 ndr->depth++;
7334                 ndr_print_samr_Ids(ndr, "rids", r->out.rids);
7335                 ndr->depth--;
7336                 ndr_print_ptr(ndr, "types", r->out.types);
7337                 ndr->depth++;
7338                 ndr_print_samr_Ids(ndr, "types", r->out.types);
7339                 ndr->depth--;
7340                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7341                 ndr->depth--;
7342         }
7343         ndr->depth--;
7344 }
7345
7346 static enum ndr_err_code ndr_push_samr_LookupRids(struct ndr_push *ndr, int flags, const struct samr_LookupRids *r)
7347 {
7348         uint32_t cntr_rids_0;
7349         if (flags & NDR_IN) {
7350                 if (r->in.domain_handle == NULL) {
7351                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7352                 }
7353                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7354                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_rids));
7355                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1000));
7356                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_rids));
7358                 for (cntr_rids_0 = 0; cntr_rids_0 < r->in.num_rids; cntr_rids_0++) {
7359                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rids[cntr_rids_0]));
7360                 }
7361         }
7362         if (flags & NDR_OUT) {
7363                 if (r->out.names == NULL) {
7364                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7365                 }
7366                 NDR_CHECK(ndr_push_lsa_Strings(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
7367                 if (r->out.types == NULL) {
7368                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7369                 }
7370                 NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
7371                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7372         }
7373         return NDR_ERR_SUCCESS;
7374 }
7375
7376 static enum ndr_err_code ndr_pull_samr_LookupRids(struct ndr_pull *ndr, int flags, struct samr_LookupRids *r)
7377 {
7378         uint32_t size_rids_0 = 0;
7379         uint32_t length_rids_0 = 0;
7380         uint32_t cntr_rids_0;
7381         TALLOC_CTX *_mem_save_domain_handle_0;
7382         TALLOC_CTX *_mem_save_rids_0;
7383         TALLOC_CTX *_mem_save_names_0;
7384         TALLOC_CTX *_mem_save_types_0;
7385         if (flags & NDR_IN) {
7386                 ZERO_STRUCT(r->out);
7387
7388                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7389                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7390                 }
7391                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7392                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7393                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7394                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7395                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_rids));
7396                 if (r->in.num_rids > 1000) {
7397                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7398                 }
7399                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.rids));
7400                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.rids));
7401                 size_rids_0 = ndr_get_array_size(ndr, &r->in.rids);
7402                 length_rids_0 = ndr_get_array_length(ndr, &r->in.rids);
7403                 if (length_rids_0 > size_rids_0) {
7404                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_rids_0, length_rids_0);
7405                 }
7406                 NDR_PULL_ALLOC_N(ndr, r->in.rids, size_rids_0);
7407                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7408                 NDR_PULL_SET_MEM_CTX(ndr, r->in.rids, 0);
7409                 for (cntr_rids_0 = 0; cntr_rids_0 < length_rids_0; cntr_rids_0++) {
7410                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rids[cntr_rids_0]));
7411                 }
7412                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
7413                 NDR_PULL_ALLOC(ndr, r->out.names);
7414                 ZERO_STRUCTP(r->out.names);
7415                 NDR_PULL_ALLOC(ndr, r->out.types);
7416                 ZERO_STRUCTP(r->out.types);
7417                 if (r->in.rids) {
7418                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.rids, 1000));
7419                 }
7420                 if (r->in.rids) {
7421                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.rids, r->in.num_rids));
7422                 }
7423         }
7424         if (flags & NDR_OUT) {
7425                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7426                         NDR_PULL_ALLOC(ndr, r->out.names);
7427                 }
7428                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
7429                 NDR_PULL_SET_MEM_CTX(ndr, r->out.names, LIBNDR_FLAG_REF_ALLOC);
7430                 NDR_CHECK(ndr_pull_lsa_Strings(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
7431                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
7432                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7433                         NDR_PULL_ALLOC(ndr, r->out.types);
7434                 }
7435                 _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
7436                 NDR_PULL_SET_MEM_CTX(ndr, r->out.types, LIBNDR_FLAG_REF_ALLOC);
7437                 NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
7438                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, LIBNDR_FLAG_REF_ALLOC);
7439                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7440         }
7441         return NDR_ERR_SUCCESS;
7442 }
7443
7444 _PUBLIC_ void ndr_print_samr_LookupRids(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupRids *r)
7445 {
7446         uint32_t cntr_rids_0;
7447         ndr_print_struct(ndr, name, "samr_LookupRids");
7448         ndr->depth++;
7449         if (flags & NDR_SET_VALUES) {
7450                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7451         }
7452         if (flags & NDR_IN) {
7453                 ndr_print_struct(ndr, "in", "samr_LookupRids");
7454                 ndr->depth++;
7455                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7456                 ndr->depth++;
7457                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7458                 ndr->depth--;
7459                 ndr_print_uint32(ndr, "num_rids", r->in.num_rids);
7460                 ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->in.num_rids);
7461                 ndr->depth++;
7462                 for (cntr_rids_0=0;cntr_rids_0<r->in.num_rids;cntr_rids_0++) {
7463                         char *idx_0=NULL;
7464                         if (asprintf(&idx_0, "[%d]", cntr_rids_0) != -1) {
7465                                 ndr_print_uint32(ndr, "rids", r->in.rids[cntr_rids_0]);
7466                                 free(idx_0);
7467                         }
7468                 }
7469                 ndr->depth--;
7470                 ndr->depth--;
7471         }
7472         if (flags & NDR_OUT) {
7473                 ndr_print_struct(ndr, "out", "samr_LookupRids");
7474                 ndr->depth++;
7475                 ndr_print_ptr(ndr, "names", r->out.names);
7476                 ndr->depth++;
7477                 ndr_print_lsa_Strings(ndr, "names", r->out.names);
7478                 ndr->depth--;
7479                 ndr_print_ptr(ndr, "types", r->out.types);
7480                 ndr->depth++;
7481                 ndr_print_samr_Ids(ndr, "types", r->out.types);
7482                 ndr->depth--;
7483                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7484                 ndr->depth--;
7485         }
7486         ndr->depth--;
7487 }
7488
7489 static enum ndr_err_code ndr_push_samr_OpenGroup(struct ndr_push *ndr, int flags, const struct samr_OpenGroup *r)
7490 {
7491         if (flags & NDR_IN) {
7492                 if (r->in.domain_handle == NULL) {
7493                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7494                 }
7495                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7496                 NDR_CHECK(ndr_push_samr_GroupAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
7497                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
7498         }
7499         if (flags & NDR_OUT) {
7500                 if (r->out.group_handle == NULL) {
7501                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7502                 }
7503                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
7504                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7505         }
7506         return NDR_ERR_SUCCESS;
7507 }
7508
7509 static enum ndr_err_code ndr_pull_samr_OpenGroup(struct ndr_pull *ndr, int flags, struct samr_OpenGroup *r)
7510 {
7511         TALLOC_CTX *_mem_save_domain_handle_0;
7512         TALLOC_CTX *_mem_save_group_handle_0;
7513         if (flags & NDR_IN) {
7514                 ZERO_STRUCT(r->out);
7515
7516                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7517                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
7518                 }
7519                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7520                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
7521                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
7522                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
7523                 NDR_CHECK(ndr_pull_samr_GroupAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
7524                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
7525                 NDR_PULL_ALLOC(ndr, r->out.group_handle);
7526                 ZERO_STRUCTP(r->out.group_handle);
7527         }
7528         if (flags & NDR_OUT) {
7529                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7530                         NDR_PULL_ALLOC(ndr, r->out.group_handle);
7531                 }
7532                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7533                 NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);
7534                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
7535                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7536                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7537         }
7538         return NDR_ERR_SUCCESS;
7539 }
7540
7541 _PUBLIC_ void ndr_print_samr_OpenGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenGroup *r)
7542 {
7543         ndr_print_struct(ndr, name, "samr_OpenGroup");
7544         ndr->depth++;
7545         if (flags & NDR_SET_VALUES) {
7546                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7547         }
7548         if (flags & NDR_IN) {
7549                 ndr_print_struct(ndr, "in", "samr_OpenGroup");
7550                 ndr->depth++;
7551                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
7552                 ndr->depth++;
7553                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
7554                 ndr->depth--;
7555                 ndr_print_samr_GroupAccessMask(ndr, "access_mask", r->in.access_mask);
7556                 ndr_print_uint32(ndr, "rid", r->in.rid);
7557                 ndr->depth--;
7558         }
7559         if (flags & NDR_OUT) {
7560                 ndr_print_struct(ndr, "out", "samr_OpenGroup");
7561                 ndr->depth++;
7562                 ndr_print_ptr(ndr, "group_handle", r->out.group_handle);
7563                 ndr->depth++;
7564                 ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);
7565                 ndr->depth--;
7566                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7567                 ndr->depth--;
7568         }
7569         ndr->depth--;
7570 }
7571
7572 static enum ndr_err_code ndr_push_samr_QueryGroupInfo(struct ndr_push *ndr, int flags, const struct samr_QueryGroupInfo *r)
7573 {
7574         if (flags & NDR_IN) {
7575                 if (r->in.group_handle == NULL) {
7576                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7577                 }
7578                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7579                 NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, r->in.level));
7580         }
7581         if (flags & NDR_OUT) {
7582                 if (r->out.info == NULL) {
7583                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7584                 }
7585                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
7586                 if (*r->out.info) {
7587                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
7588                         NDR_CHECK(ndr_push_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
7589                 }
7590                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7591         }
7592         return NDR_ERR_SUCCESS;
7593 }
7594
7595 static enum ndr_err_code ndr_pull_samr_QueryGroupInfo(struct ndr_pull *ndr, int flags, struct samr_QueryGroupInfo *r)
7596 {
7597         uint32_t _ptr_info;
7598         TALLOC_CTX *_mem_save_group_handle_0;
7599         TALLOC_CTX *_mem_save_info_0;
7600         TALLOC_CTX *_mem_save_info_1;
7601         if (flags & NDR_IN) {
7602                 ZERO_STRUCT(r->out);
7603
7604                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7605                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
7606                 }
7607                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7608                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
7609                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7610                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7611                 NDR_CHECK(ndr_pull_samr_GroupInfoEnum(ndr, NDR_SCALARS, &r->in.level));
7612                 NDR_PULL_ALLOC(ndr, r->out.info);
7613                 ZERO_STRUCTP(r->out.info);
7614         }
7615         if (flags & NDR_OUT) {
7616                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7617                         NDR_PULL_ALLOC(ndr, r->out.info);
7618                 }
7619                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7620                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
7621                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
7622                 if (_ptr_info) {
7623                         NDR_PULL_ALLOC(ndr, *r->out.info);
7624                 } else {
7625                         *r->out.info = NULL;
7626                 }
7627                 if (*r->out.info) {
7628                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
7629                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
7630                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
7631                         NDR_CHECK(ndr_pull_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
7632                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
7633                 }
7634                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7635                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7636         }
7637         return NDR_ERR_SUCCESS;
7638 }
7639
7640 _PUBLIC_ void ndr_print_samr_QueryGroupInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryGroupInfo *r)
7641 {
7642         ndr_print_struct(ndr, name, "samr_QueryGroupInfo");
7643         ndr->depth++;
7644         if (flags & NDR_SET_VALUES) {
7645                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7646         }
7647         if (flags & NDR_IN) {
7648                 ndr_print_struct(ndr, "in", "samr_QueryGroupInfo");
7649                 ndr->depth++;
7650                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
7651                 ndr->depth++;
7652                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
7653                 ndr->depth--;
7654                 ndr_print_samr_GroupInfoEnum(ndr, "level", r->in.level);
7655                 ndr->depth--;
7656         }
7657         if (flags & NDR_OUT) {
7658                 ndr_print_struct(ndr, "out", "samr_QueryGroupInfo");
7659                 ndr->depth++;
7660                 ndr_print_ptr(ndr, "info", r->out.info);
7661                 ndr->depth++;
7662                 ndr_print_ptr(ndr, "info", *r->out.info);
7663                 ndr->depth++;
7664                 if (*r->out.info) {
7665                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
7666                         ndr_print_samr_GroupInfo(ndr, "info", *r->out.info);
7667                 }
7668                 ndr->depth--;
7669                 ndr->depth--;
7670                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7671                 ndr->depth--;
7672         }
7673         ndr->depth--;
7674 }
7675
7676 static enum ndr_err_code ndr_push_samr_SetGroupInfo(struct ndr_push *ndr, int flags, const struct samr_SetGroupInfo *r)
7677 {
7678         if (flags & NDR_IN) {
7679                 if (r->in.group_handle == NULL) {
7680                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7681                 }
7682                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7683                 NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, r->in.level));
7684                 if (r->in.info == NULL) {
7685                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7686                 }
7687                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
7688                 NDR_CHECK(ndr_push_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
7689         }
7690         if (flags & NDR_OUT) {
7691                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7692         }
7693         return NDR_ERR_SUCCESS;
7694 }
7695
7696 static enum ndr_err_code ndr_pull_samr_SetGroupInfo(struct ndr_pull *ndr, int flags, struct samr_SetGroupInfo *r)
7697 {
7698         TALLOC_CTX *_mem_save_group_handle_0;
7699         TALLOC_CTX *_mem_save_info_0;
7700         if (flags & NDR_IN) {
7701                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7702                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
7703                 }
7704                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7705                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
7706                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7707                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7708                 NDR_CHECK(ndr_pull_samr_GroupInfoEnum(ndr, NDR_SCALARS, &r->in.level));
7709                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7710                         NDR_PULL_ALLOC(ndr, r->in.info);
7711                 }
7712                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7713                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
7714                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
7715                 NDR_CHECK(ndr_pull_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
7716                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7717         }
7718         if (flags & NDR_OUT) {
7719                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7720         }
7721         return NDR_ERR_SUCCESS;
7722 }
7723
7724 _PUBLIC_ void ndr_print_samr_SetGroupInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetGroupInfo *r)
7725 {
7726         ndr_print_struct(ndr, name, "samr_SetGroupInfo");
7727         ndr->depth++;
7728         if (flags & NDR_SET_VALUES) {
7729                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7730         }
7731         if (flags & NDR_IN) {
7732                 ndr_print_struct(ndr, "in", "samr_SetGroupInfo");
7733                 ndr->depth++;
7734                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
7735                 ndr->depth++;
7736                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
7737                 ndr->depth--;
7738                 ndr_print_samr_GroupInfoEnum(ndr, "level", r->in.level);
7739                 ndr_print_ptr(ndr, "info", r->in.info);
7740                 ndr->depth++;
7741                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
7742                 ndr_print_samr_GroupInfo(ndr, "info", r->in.info);
7743                 ndr->depth--;
7744                 ndr->depth--;
7745         }
7746         if (flags & NDR_OUT) {
7747                 ndr_print_struct(ndr, "out", "samr_SetGroupInfo");
7748                 ndr->depth++;
7749                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7750                 ndr->depth--;
7751         }
7752         ndr->depth--;
7753 }
7754
7755 static enum ndr_err_code ndr_push_samr_AddGroupMember(struct ndr_push *ndr, int flags, const struct samr_AddGroupMember *r)
7756 {
7757         if (flags & NDR_IN) {
7758                 if (r->in.group_handle == NULL) {
7759                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7760                 }
7761                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
7763                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
7764         }
7765         if (flags & NDR_OUT) {
7766                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7767         }
7768         return NDR_ERR_SUCCESS;
7769 }
7770
7771 static enum ndr_err_code ndr_pull_samr_AddGroupMember(struct ndr_pull *ndr, int flags, struct samr_AddGroupMember *r)
7772 {
7773         TALLOC_CTX *_mem_save_group_handle_0;
7774         if (flags & NDR_IN) {
7775                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7776                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
7777                 }
7778                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7779                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
7780                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7781                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7782                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
7783                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
7784         }
7785         if (flags & NDR_OUT) {
7786                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7787         }
7788         return NDR_ERR_SUCCESS;
7789 }
7790
7791 _PUBLIC_ void ndr_print_samr_AddGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddGroupMember *r)
7792 {
7793         ndr_print_struct(ndr, name, "samr_AddGroupMember");
7794         ndr->depth++;
7795         if (flags & NDR_SET_VALUES) {
7796                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7797         }
7798         if (flags & NDR_IN) {
7799                 ndr_print_struct(ndr, "in", "samr_AddGroupMember");
7800                 ndr->depth++;
7801                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
7802                 ndr->depth++;
7803                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
7804                 ndr->depth--;
7805                 ndr_print_uint32(ndr, "rid", r->in.rid);
7806                 ndr_print_uint32(ndr, "flags", r->in.flags);
7807                 ndr->depth--;
7808         }
7809         if (flags & NDR_OUT) {
7810                 ndr_print_struct(ndr, "out", "samr_AddGroupMember");
7811                 ndr->depth++;
7812                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7813                 ndr->depth--;
7814         }
7815         ndr->depth--;
7816 }
7817
7818 static enum ndr_err_code ndr_push_samr_DeleteDomainGroup(struct ndr_push *ndr, int flags, const struct samr_DeleteDomainGroup *r)
7819 {
7820         if (flags & NDR_IN) {
7821                 if (r->in.group_handle == NULL) {
7822                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7823                 }
7824                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7825         }
7826         if (flags & NDR_OUT) {
7827                 if (r->out.group_handle == NULL) {
7828                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7829                 }
7830                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
7831                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7832         }
7833         return NDR_ERR_SUCCESS;
7834 }
7835
7836 static enum ndr_err_code ndr_pull_samr_DeleteDomainGroup(struct ndr_pull *ndr, int flags, struct samr_DeleteDomainGroup *r)
7837 {
7838         TALLOC_CTX *_mem_save_group_handle_0;
7839         if (flags & NDR_IN) {
7840                 ZERO_STRUCT(r->out);
7841
7842                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7843                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
7844                 }
7845                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7846                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
7847                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7848                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7849                 NDR_PULL_ALLOC(ndr, r->out.group_handle);
7850                 *r->out.group_handle = *r->in.group_handle;
7851         }
7852         if (flags & NDR_OUT) {
7853                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7854                         NDR_PULL_ALLOC(ndr, r->out.group_handle);
7855                 }
7856                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7857                 NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);
7858                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
7859                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7860                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7861         }
7862         return NDR_ERR_SUCCESS;
7863 }
7864
7865 _PUBLIC_ void ndr_print_samr_DeleteDomainGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteDomainGroup *r)
7866 {
7867         ndr_print_struct(ndr, name, "samr_DeleteDomainGroup");
7868         ndr->depth++;
7869         if (flags & NDR_SET_VALUES) {
7870                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7871         }
7872         if (flags & NDR_IN) {
7873                 ndr_print_struct(ndr, "in", "samr_DeleteDomainGroup");
7874                 ndr->depth++;
7875                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
7876                 ndr->depth++;
7877                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
7878                 ndr->depth--;
7879                 ndr->depth--;
7880         }
7881         if (flags & NDR_OUT) {
7882                 ndr_print_struct(ndr, "out", "samr_DeleteDomainGroup");
7883                 ndr->depth++;
7884                 ndr_print_ptr(ndr, "group_handle", r->out.group_handle);
7885                 ndr->depth++;
7886                 ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);
7887                 ndr->depth--;
7888                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7889                 ndr->depth--;
7890         }
7891         ndr->depth--;
7892 }
7893
7894 static enum ndr_err_code ndr_push_samr_DeleteGroupMember(struct ndr_push *ndr, int flags, const struct samr_DeleteGroupMember *r)
7895 {
7896         if (flags & NDR_IN) {
7897                 if (r->in.group_handle == NULL) {
7898                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7899                 }
7900                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7901                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
7902         }
7903         if (flags & NDR_OUT) {
7904                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7905         }
7906         return NDR_ERR_SUCCESS;
7907 }
7908
7909 static enum ndr_err_code ndr_pull_samr_DeleteGroupMember(struct ndr_pull *ndr, int flags, struct samr_DeleteGroupMember *r)
7910 {
7911         TALLOC_CTX *_mem_save_group_handle_0;
7912         if (flags & NDR_IN) {
7913                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7914                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
7915                 }
7916                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7917                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
7918                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7919                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7920                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
7921         }
7922         if (flags & NDR_OUT) {
7923                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7924         }
7925         return NDR_ERR_SUCCESS;
7926 }
7927
7928 _PUBLIC_ void ndr_print_samr_DeleteGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteGroupMember *r)
7929 {
7930         ndr_print_struct(ndr, name, "samr_DeleteGroupMember");
7931         ndr->depth++;
7932         if (flags & NDR_SET_VALUES) {
7933                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7934         }
7935         if (flags & NDR_IN) {
7936                 ndr_print_struct(ndr, "in", "samr_DeleteGroupMember");
7937                 ndr->depth++;
7938                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
7939                 ndr->depth++;
7940                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
7941                 ndr->depth--;
7942                 ndr_print_uint32(ndr, "rid", r->in.rid);
7943                 ndr->depth--;
7944         }
7945         if (flags & NDR_OUT) {
7946                 ndr_print_struct(ndr, "out", "samr_DeleteGroupMember");
7947                 ndr->depth++;
7948                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7949                 ndr->depth--;
7950         }
7951         ndr->depth--;
7952 }
7953
7954 static enum ndr_err_code ndr_push_samr_QueryGroupMember(struct ndr_push *ndr, int flags, const struct samr_QueryGroupMember *r)
7955 {
7956         if (flags & NDR_IN) {
7957                 if (r->in.group_handle == NULL) {
7958                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7959                 }
7960                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7961         }
7962         if (flags & NDR_OUT) {
7963                 if (r->out.rids == NULL) {
7964                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7965                 }
7966                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rids));
7967                 if (*r->out.rids) {
7968                         NDR_CHECK(ndr_push_samr_RidTypeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
7969                 }
7970                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7971         }
7972         return NDR_ERR_SUCCESS;
7973 }
7974
7975 static enum ndr_err_code ndr_pull_samr_QueryGroupMember(struct ndr_pull *ndr, int flags, struct samr_QueryGroupMember *r)
7976 {
7977         uint32_t _ptr_rids;
7978         TALLOC_CTX *_mem_save_group_handle_0;
7979         TALLOC_CTX *_mem_save_rids_0;
7980         TALLOC_CTX *_mem_save_rids_1;
7981         if (flags & NDR_IN) {
7982                 ZERO_STRUCT(r->out);
7983
7984                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7985                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
7986                 }
7987                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7988                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
7989                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
7990                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
7991                 NDR_PULL_ALLOC(ndr, r->out.rids);
7992                 ZERO_STRUCTP(r->out.rids);
7993         }
7994         if (flags & NDR_OUT) {
7995                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7996                         NDR_PULL_ALLOC(ndr, r->out.rids);
7997                 }
7998                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7999                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
8000                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
8001                 if (_ptr_rids) {
8002                         NDR_PULL_ALLOC(ndr, *r->out.rids);
8003                 } else {
8004                         *r->out.rids = NULL;
8005                 }
8006                 if (*r->out.rids) {
8007                         _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
8008                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.rids, 0);
8009                         NDR_CHECK(ndr_pull_samr_RidTypeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
8010                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
8011                 }
8012                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
8013                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8014         }
8015         return NDR_ERR_SUCCESS;
8016 }
8017
8018 _PUBLIC_ void ndr_print_samr_QueryGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryGroupMember *r)
8019 {
8020         ndr_print_struct(ndr, name, "samr_QueryGroupMember");
8021         ndr->depth++;
8022         if (flags & NDR_SET_VALUES) {
8023                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8024         }
8025         if (flags & NDR_IN) {
8026                 ndr_print_struct(ndr, "in", "samr_QueryGroupMember");
8027                 ndr->depth++;
8028                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
8029                 ndr->depth++;
8030                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
8031                 ndr->depth--;
8032                 ndr->depth--;
8033         }
8034         if (flags & NDR_OUT) {
8035                 ndr_print_struct(ndr, "out", "samr_QueryGroupMember");
8036                 ndr->depth++;
8037                 ndr_print_ptr(ndr, "rids", r->out.rids);
8038                 ndr->depth++;
8039                 ndr_print_ptr(ndr, "rids", *r->out.rids);
8040                 ndr->depth++;
8041                 if (*r->out.rids) {
8042                         ndr_print_samr_RidTypeArray(ndr, "rids", *r->out.rids);
8043                 }
8044                 ndr->depth--;
8045                 ndr->depth--;
8046                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8047                 ndr->depth--;
8048         }
8049         ndr->depth--;
8050 }
8051
8052 static enum ndr_err_code ndr_push_samr_SetMemberAttributesOfGroup(struct ndr_push *ndr, int flags, const struct samr_SetMemberAttributesOfGroup *r)
8053 {
8054         if (flags & NDR_IN) {
8055                 if (r->in.group_handle == NULL) {
8056                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8057                 }
8058                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8059                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
8060                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
8061         }
8062         if (flags & NDR_OUT) {
8063                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8064         }
8065         return NDR_ERR_SUCCESS;
8066 }
8067
8068 static enum ndr_err_code ndr_pull_samr_SetMemberAttributesOfGroup(struct ndr_pull *ndr, int flags, struct samr_SetMemberAttributesOfGroup *r)
8069 {
8070         TALLOC_CTX *_mem_save_group_handle_0;
8071         if (flags & NDR_IN) {
8072                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8073                         NDR_PULL_ALLOC(ndr, r->in.group_handle);
8074                 }
8075                 _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8076                 NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
8077                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
8078                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
8079                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
8080                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
8081         }
8082         if (flags & NDR_OUT) {
8083                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8084         }
8085         return NDR_ERR_SUCCESS;
8086 }
8087
8088 _PUBLIC_ void ndr_print_samr_SetMemberAttributesOfGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetMemberAttributesOfGroup *r)
8089 {
8090         ndr_print_struct(ndr, name, "samr_SetMemberAttributesOfGroup");
8091         ndr->depth++;
8092         if (flags & NDR_SET_VALUES) {
8093                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8094         }
8095         if (flags & NDR_IN) {
8096                 ndr_print_struct(ndr, "in", "samr_SetMemberAttributesOfGroup");
8097                 ndr->depth++;
8098                 ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
8099                 ndr->depth++;
8100                 ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
8101                 ndr->depth--;
8102                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
8103                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
8104                 ndr->depth--;
8105         }
8106         if (flags & NDR_OUT) {
8107                 ndr_print_struct(ndr, "out", "samr_SetMemberAttributesOfGroup");
8108                 ndr->depth++;
8109                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8110                 ndr->depth--;
8111         }
8112         ndr->depth--;
8113 }
8114
8115 static enum ndr_err_code ndr_push_samr_OpenAlias(struct ndr_push *ndr, int flags, const struct samr_OpenAlias *r)
8116 {
8117         if (flags & NDR_IN) {
8118                 if (r->in.domain_handle == NULL) {
8119                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8120                 }
8121                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
8122                 NDR_CHECK(ndr_push_samr_AliasAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
8123                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
8124         }
8125         if (flags & NDR_OUT) {
8126                 if (r->out.alias_handle == NULL) {
8127                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8128                 }
8129                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
8130                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8131         }
8132         return NDR_ERR_SUCCESS;
8133 }
8134
8135 static enum ndr_err_code ndr_pull_samr_OpenAlias(struct ndr_pull *ndr, int flags, struct samr_OpenAlias *r)
8136 {
8137         TALLOC_CTX *_mem_save_domain_handle_0;
8138         TALLOC_CTX *_mem_save_alias_handle_0;
8139         if (flags & NDR_IN) {
8140                 ZERO_STRUCT(r->out);
8141
8142                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8143                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
8144                 }
8145                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8146                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
8147                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
8148                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
8149                 NDR_CHECK(ndr_pull_samr_AliasAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
8150                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
8151                 NDR_PULL_ALLOC(ndr, r->out.alias_handle);
8152                 ZERO_STRUCTP(r->out.alias_handle);
8153         }
8154         if (flags & NDR_OUT) {
8155                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8156                         NDR_PULL_ALLOC(ndr, r->out.alias_handle);
8157                 }
8158                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8159                 NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8160                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
8161                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8162                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8163         }
8164         return NDR_ERR_SUCCESS;
8165 }
8166
8167 _PUBLIC_ void ndr_print_samr_OpenAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenAlias *r)
8168 {
8169         ndr_print_struct(ndr, name, "samr_OpenAlias");
8170         ndr->depth++;
8171         if (flags & NDR_SET_VALUES) {
8172                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8173         }
8174         if (flags & NDR_IN) {
8175                 ndr_print_struct(ndr, "in", "samr_OpenAlias");
8176                 ndr->depth++;
8177                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
8178                 ndr->depth++;
8179                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
8180                 ndr->depth--;
8181                 ndr_print_samr_AliasAccessMask(ndr, "access_mask", r->in.access_mask);
8182                 ndr_print_uint32(ndr, "rid", r->in.rid);
8183                 ndr->depth--;
8184         }
8185         if (flags & NDR_OUT) {
8186                 ndr_print_struct(ndr, "out", "samr_OpenAlias");
8187                 ndr->depth++;
8188                 ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);
8189                 ndr->depth++;
8190                 ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);
8191                 ndr->depth--;
8192                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8193                 ndr->depth--;
8194         }
8195         ndr->depth--;
8196 }
8197
8198 static enum ndr_err_code ndr_push_samr_QueryAliasInfo(struct ndr_push *ndr, int flags, const struct samr_QueryAliasInfo *r)
8199 {
8200         if (flags & NDR_IN) {
8201                 if (r->in.alias_handle == NULL) {
8202                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8203                 }
8204                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8205                 NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, r->in.level));
8206         }
8207         if (flags & NDR_OUT) {
8208                 if (r->out.info == NULL) {
8209                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8210                 }
8211                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
8212                 if (*r->out.info) {
8213                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
8214                         NDR_CHECK(ndr_push_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8215                 }
8216                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8217         }
8218         return NDR_ERR_SUCCESS;
8219 }
8220
8221 static enum ndr_err_code ndr_pull_samr_QueryAliasInfo(struct ndr_pull *ndr, int flags, struct samr_QueryAliasInfo *r)
8222 {
8223         uint32_t _ptr_info;
8224         TALLOC_CTX *_mem_save_alias_handle_0;
8225         TALLOC_CTX *_mem_save_info_0;
8226         TALLOC_CTX *_mem_save_info_1;
8227         if (flags & NDR_IN) {
8228                 ZERO_STRUCT(r->out);
8229
8230                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8231                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8232                 }
8233                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8234                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8235                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8236                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8237                 NDR_CHECK(ndr_pull_samr_AliasInfoEnum(ndr, NDR_SCALARS, &r->in.level));
8238                 NDR_PULL_ALLOC(ndr, r->out.info);
8239                 ZERO_STRUCTP(r->out.info);
8240         }
8241         if (flags & NDR_OUT) {
8242                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8243                         NDR_PULL_ALLOC(ndr, r->out.info);
8244                 }
8245                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8246                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
8247                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8248                 if (_ptr_info) {
8249                         NDR_PULL_ALLOC(ndr, *r->out.info);
8250                 } else {
8251                         *r->out.info = NULL;
8252                 }
8253                 if (*r->out.info) {
8254                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
8255                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
8256                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
8257                         NDR_CHECK(ndr_pull_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8258                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
8259                 }
8260                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
8261                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8262         }
8263         return NDR_ERR_SUCCESS;
8264 }
8265
8266 _PUBLIC_ void ndr_print_samr_QueryAliasInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryAliasInfo *r)
8267 {
8268         ndr_print_struct(ndr, name, "samr_QueryAliasInfo");
8269         ndr->depth++;
8270         if (flags & NDR_SET_VALUES) {
8271                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8272         }
8273         if (flags & NDR_IN) {
8274                 ndr_print_struct(ndr, "in", "samr_QueryAliasInfo");
8275                 ndr->depth++;
8276                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8277                 ndr->depth++;
8278                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8279                 ndr->depth--;
8280                 ndr_print_samr_AliasInfoEnum(ndr, "level", r->in.level);
8281                 ndr->depth--;
8282         }
8283         if (flags & NDR_OUT) {
8284                 ndr_print_struct(ndr, "out", "samr_QueryAliasInfo");
8285                 ndr->depth++;
8286                 ndr_print_ptr(ndr, "info", r->out.info);
8287                 ndr->depth++;
8288                 ndr_print_ptr(ndr, "info", *r->out.info);
8289                 ndr->depth++;
8290                 if (*r->out.info) {
8291                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
8292                         ndr_print_samr_AliasInfo(ndr, "info", *r->out.info);
8293                 }
8294                 ndr->depth--;
8295                 ndr->depth--;
8296                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8297                 ndr->depth--;
8298         }
8299         ndr->depth--;
8300 }
8301
8302 static enum ndr_err_code ndr_push_samr_SetAliasInfo(struct ndr_push *ndr, int flags, const struct samr_SetAliasInfo *r)
8303 {
8304         if (flags & NDR_IN) {
8305                 if (r->in.alias_handle == NULL) {
8306                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8307                 }
8308                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8309                 NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, r->in.level));
8310                 if (r->in.info == NULL) {
8311                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8312                 }
8313                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
8314                 NDR_CHECK(ndr_push_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8315         }
8316         if (flags & NDR_OUT) {
8317                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8318         }
8319         return NDR_ERR_SUCCESS;
8320 }
8321
8322 static enum ndr_err_code ndr_pull_samr_SetAliasInfo(struct ndr_pull *ndr, int flags, struct samr_SetAliasInfo *r)
8323 {
8324         TALLOC_CTX *_mem_save_alias_handle_0;
8325         TALLOC_CTX *_mem_save_info_0;
8326         if (flags & NDR_IN) {
8327                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8328                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8329                 }
8330                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8331                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8332                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8333                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8334                 NDR_CHECK(ndr_pull_samr_AliasInfoEnum(ndr, NDR_SCALARS, &r->in.level));
8335                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8336                         NDR_PULL_ALLOC(ndr, r->in.info);
8337                 }
8338                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8339                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
8340                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
8341                 NDR_CHECK(ndr_pull_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8342                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
8343         }
8344         if (flags & NDR_OUT) {
8345                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8346         }
8347         return NDR_ERR_SUCCESS;
8348 }
8349
8350 _PUBLIC_ void ndr_print_samr_SetAliasInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetAliasInfo *r)
8351 {
8352         ndr_print_struct(ndr, name, "samr_SetAliasInfo");
8353         ndr->depth++;
8354         if (flags & NDR_SET_VALUES) {
8355                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8356         }
8357         if (flags & NDR_IN) {
8358                 ndr_print_struct(ndr, "in", "samr_SetAliasInfo");
8359                 ndr->depth++;
8360                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8361                 ndr->depth++;
8362                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8363                 ndr->depth--;
8364                 ndr_print_samr_AliasInfoEnum(ndr, "level", r->in.level);
8365                 ndr_print_ptr(ndr, "info", r->in.info);
8366                 ndr->depth++;
8367                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
8368                 ndr_print_samr_AliasInfo(ndr, "info", r->in.info);
8369                 ndr->depth--;
8370                 ndr->depth--;
8371         }
8372         if (flags & NDR_OUT) {
8373                 ndr_print_struct(ndr, "out", "samr_SetAliasInfo");
8374                 ndr->depth++;
8375                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8376                 ndr->depth--;
8377         }
8378         ndr->depth--;
8379 }
8380
8381 static enum ndr_err_code ndr_push_samr_DeleteDomAlias(struct ndr_push *ndr, int flags, const struct samr_DeleteDomAlias *r)
8382 {
8383         if (flags & NDR_IN) {
8384                 if (r->in.alias_handle == NULL) {
8385                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8386                 }
8387                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8388         }
8389         if (flags & NDR_OUT) {
8390                 if (r->out.alias_handle == NULL) {
8391                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8392                 }
8393                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
8394                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8395         }
8396         return NDR_ERR_SUCCESS;
8397 }
8398
8399 static enum ndr_err_code ndr_pull_samr_DeleteDomAlias(struct ndr_pull *ndr, int flags, struct samr_DeleteDomAlias *r)
8400 {
8401         TALLOC_CTX *_mem_save_alias_handle_0;
8402         if (flags & NDR_IN) {
8403                 ZERO_STRUCT(r->out);
8404
8405                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8406                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8407                 }
8408                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8409                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8410                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8411                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8412                 NDR_PULL_ALLOC(ndr, r->out.alias_handle);
8413                 *r->out.alias_handle = *r->in.alias_handle;
8414         }
8415         if (flags & NDR_OUT) {
8416                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8417                         NDR_PULL_ALLOC(ndr, r->out.alias_handle);
8418                 }
8419                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8420                 NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8421                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
8422                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8423                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8424         }
8425         return NDR_ERR_SUCCESS;
8426 }
8427
8428 _PUBLIC_ void ndr_print_samr_DeleteDomAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteDomAlias *r)
8429 {
8430         ndr_print_struct(ndr, name, "samr_DeleteDomAlias");
8431         ndr->depth++;
8432         if (flags & NDR_SET_VALUES) {
8433                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8434         }
8435         if (flags & NDR_IN) {
8436                 ndr_print_struct(ndr, "in", "samr_DeleteDomAlias");
8437                 ndr->depth++;
8438                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8439                 ndr->depth++;
8440                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8441                 ndr->depth--;
8442                 ndr->depth--;
8443         }
8444         if (flags & NDR_OUT) {
8445                 ndr_print_struct(ndr, "out", "samr_DeleteDomAlias");
8446                 ndr->depth++;
8447                 ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);
8448                 ndr->depth++;
8449                 ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);
8450                 ndr->depth--;
8451                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8452                 ndr->depth--;
8453         }
8454         ndr->depth--;
8455 }
8456
8457 static enum ndr_err_code ndr_push_samr_AddAliasMember(struct ndr_push *ndr, int flags, const struct samr_AddAliasMember *r)
8458 {
8459         if (flags & NDR_IN) {
8460                 if (r->in.alias_handle == NULL) {
8461                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8462                 }
8463                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8464                 if (r->in.sid == NULL) {
8465                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8466                 }
8467                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8468         }
8469         if (flags & NDR_OUT) {
8470                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8471         }
8472         return NDR_ERR_SUCCESS;
8473 }
8474
8475 static enum ndr_err_code ndr_pull_samr_AddAliasMember(struct ndr_pull *ndr, int flags, struct samr_AddAliasMember *r)
8476 {
8477         TALLOC_CTX *_mem_save_alias_handle_0;
8478         TALLOC_CTX *_mem_save_sid_0;
8479         if (flags & NDR_IN) {
8480                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8481                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8482                 }
8483                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8484                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8485                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8486                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8487                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8488                         NDR_PULL_ALLOC(ndr, r->in.sid);
8489                 }
8490                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
8491                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
8492                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8493                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
8494         }
8495         if (flags & NDR_OUT) {
8496                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8497         }
8498         return NDR_ERR_SUCCESS;
8499 }
8500
8501 _PUBLIC_ void ndr_print_samr_AddAliasMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddAliasMember *r)
8502 {
8503         ndr_print_struct(ndr, name, "samr_AddAliasMember");
8504         ndr->depth++;
8505         if (flags & NDR_SET_VALUES) {
8506                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8507         }
8508         if (flags & NDR_IN) {
8509                 ndr_print_struct(ndr, "in", "samr_AddAliasMember");
8510                 ndr->depth++;
8511                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8512                 ndr->depth++;
8513                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8514                 ndr->depth--;
8515                 ndr_print_ptr(ndr, "sid", r->in.sid);
8516                 ndr->depth++;
8517                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
8518                 ndr->depth--;
8519                 ndr->depth--;
8520         }
8521         if (flags & NDR_OUT) {
8522                 ndr_print_struct(ndr, "out", "samr_AddAliasMember");
8523                 ndr->depth++;
8524                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8525                 ndr->depth--;
8526         }
8527         ndr->depth--;
8528 }
8529
8530 static enum ndr_err_code ndr_push_samr_DeleteAliasMember(struct ndr_push *ndr, int flags, const struct samr_DeleteAliasMember *r)
8531 {
8532         if (flags & NDR_IN) {
8533                 if (r->in.alias_handle == NULL) {
8534                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8535                 }
8536                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8537                 if (r->in.sid == NULL) {
8538                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8539                 }
8540                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8541         }
8542         if (flags & NDR_OUT) {
8543                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8544         }
8545         return NDR_ERR_SUCCESS;
8546 }
8547
8548 static enum ndr_err_code ndr_pull_samr_DeleteAliasMember(struct ndr_pull *ndr, int flags, struct samr_DeleteAliasMember *r)
8549 {
8550         TALLOC_CTX *_mem_save_alias_handle_0;
8551         TALLOC_CTX *_mem_save_sid_0;
8552         if (flags & NDR_IN) {
8553                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8554                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8555                 }
8556                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8557                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8558                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8559                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8560                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8561                         NDR_PULL_ALLOC(ndr, r->in.sid);
8562                 }
8563                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
8564                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
8565                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8566                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
8567         }
8568         if (flags & NDR_OUT) {
8569                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8570         }
8571         return NDR_ERR_SUCCESS;
8572 }
8573
8574 _PUBLIC_ void ndr_print_samr_DeleteAliasMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteAliasMember *r)
8575 {
8576         ndr_print_struct(ndr, name, "samr_DeleteAliasMember");
8577         ndr->depth++;
8578         if (flags & NDR_SET_VALUES) {
8579                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8580         }
8581         if (flags & NDR_IN) {
8582                 ndr_print_struct(ndr, "in", "samr_DeleteAliasMember");
8583                 ndr->depth++;
8584                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8585                 ndr->depth++;
8586                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8587                 ndr->depth--;
8588                 ndr_print_ptr(ndr, "sid", r->in.sid);
8589                 ndr->depth++;
8590                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
8591                 ndr->depth--;
8592                 ndr->depth--;
8593         }
8594         if (flags & NDR_OUT) {
8595                 ndr_print_struct(ndr, "out", "samr_DeleteAliasMember");
8596                 ndr->depth++;
8597                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8598                 ndr->depth--;
8599         }
8600         ndr->depth--;
8601 }
8602
8603 static enum ndr_err_code ndr_push_samr_GetMembersInAlias(struct ndr_push *ndr, int flags, const struct samr_GetMembersInAlias *r)
8604 {
8605         if (flags & NDR_IN) {
8606                 if (r->in.alias_handle == NULL) {
8607                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8608                 }
8609                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8610         }
8611         if (flags & NDR_OUT) {
8612                 if (r->out.sids == NULL) {
8613                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8614                 }
8615                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
8616                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8617         }
8618         return NDR_ERR_SUCCESS;
8619 }
8620
8621 static enum ndr_err_code ndr_pull_samr_GetMembersInAlias(struct ndr_pull *ndr, int flags, struct samr_GetMembersInAlias *r)
8622 {
8623         TALLOC_CTX *_mem_save_alias_handle_0;
8624         TALLOC_CTX *_mem_save_sids_0;
8625         if (flags & NDR_IN) {
8626                 ZERO_STRUCT(r->out);
8627
8628                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8629                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
8630                 }
8631                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8632                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
8633                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
8634                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
8635                 NDR_PULL_ALLOC(ndr, r->out.sids);
8636                 ZERO_STRUCTP(r->out.sids);
8637         }
8638         if (flags & NDR_OUT) {
8639                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8640                         NDR_PULL_ALLOC(ndr, r->out.sids);
8641                 }
8642                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
8643                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
8644                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
8645                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
8646                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8647         }
8648         return NDR_ERR_SUCCESS;
8649 }
8650
8651 _PUBLIC_ void ndr_print_samr_GetMembersInAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetMembersInAlias *r)
8652 {
8653         ndr_print_struct(ndr, name, "samr_GetMembersInAlias");
8654         ndr->depth++;
8655         if (flags & NDR_SET_VALUES) {
8656                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8657         }
8658         if (flags & NDR_IN) {
8659                 ndr_print_struct(ndr, "in", "samr_GetMembersInAlias");
8660                 ndr->depth++;
8661                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
8662                 ndr->depth++;
8663                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
8664                 ndr->depth--;
8665                 ndr->depth--;
8666         }
8667         if (flags & NDR_OUT) {
8668                 ndr_print_struct(ndr, "out", "samr_GetMembersInAlias");
8669                 ndr->depth++;
8670                 ndr_print_ptr(ndr, "sids", r->out.sids);
8671                 ndr->depth++;
8672                 ndr_print_lsa_SidArray(ndr, "sids", r->out.sids);
8673                 ndr->depth--;
8674                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8675                 ndr->depth--;
8676         }
8677         ndr->depth--;
8678 }
8679
8680 _PUBLIC_ enum ndr_err_code ndr_push_samr_OpenUser(struct ndr_push *ndr, int flags, const struct samr_OpenUser *r)
8681 {
8682         if (flags & NDR_IN) {
8683                 if (r->in.domain_handle == NULL) {
8684                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8685                 }
8686                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
8687                 NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
8688                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
8689         }
8690         if (flags & NDR_OUT) {
8691                 if (r->out.user_handle == NULL) {
8692                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8693                 }
8694                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
8695                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8696         }
8697         return NDR_ERR_SUCCESS;
8698 }
8699
8700 _PUBLIC_ enum ndr_err_code ndr_pull_samr_OpenUser(struct ndr_pull *ndr, int flags, struct samr_OpenUser *r)
8701 {
8702         TALLOC_CTX *_mem_save_domain_handle_0;
8703         TALLOC_CTX *_mem_save_user_handle_0;
8704         if (flags & NDR_IN) {
8705                 ZERO_STRUCT(r->out);
8706
8707                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8708                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
8709                 }
8710                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8711                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
8712                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
8713                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
8714                 NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
8715                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
8716                 NDR_PULL_ALLOC(ndr, r->out.user_handle);
8717                 ZERO_STRUCTP(r->out.user_handle);
8718         }
8719         if (flags & NDR_OUT) {
8720                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8721                         NDR_PULL_ALLOC(ndr, r->out.user_handle);
8722                 }
8723                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8724                 NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
8725                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
8726                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
8727                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8728         }
8729         return NDR_ERR_SUCCESS;
8730 }
8731
8732 _PUBLIC_ void ndr_print_samr_OpenUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenUser *r)
8733 {
8734         ndr_print_struct(ndr, name, "samr_OpenUser");
8735         ndr->depth++;
8736         if (flags & NDR_SET_VALUES) {
8737                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8738         }
8739         if (flags & NDR_IN) {
8740                 ndr_print_struct(ndr, "in", "samr_OpenUser");
8741                 ndr->depth++;
8742                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
8743                 ndr->depth++;
8744                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
8745                 ndr->depth--;
8746                 ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);
8747                 ndr_print_uint32(ndr, "rid", r->in.rid);
8748                 ndr->depth--;
8749         }
8750         if (flags & NDR_OUT) {
8751                 ndr_print_struct(ndr, "out", "samr_OpenUser");
8752                 ndr->depth++;
8753                 ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
8754                 ndr->depth++;
8755                 ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
8756                 ndr->depth--;
8757                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8758                 ndr->depth--;
8759         }
8760         ndr->depth--;
8761 }
8762
8763 static enum ndr_err_code ndr_push_samr_DeleteUser(struct ndr_push *ndr, int flags, const struct samr_DeleteUser *r)
8764 {
8765         if (flags & NDR_IN) {
8766                 if (r->in.user_handle == NULL) {
8767                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8768                 }
8769                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
8770         }
8771         if (flags & NDR_OUT) {
8772                 if (r->out.user_handle == NULL) {
8773                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8774                 }
8775                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
8776                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8777         }
8778         return NDR_ERR_SUCCESS;
8779 }
8780
8781 static enum ndr_err_code ndr_pull_samr_DeleteUser(struct ndr_pull *ndr, int flags, struct samr_DeleteUser *r)
8782 {
8783         TALLOC_CTX *_mem_save_user_handle_0;
8784         if (flags & NDR_IN) {
8785                 ZERO_STRUCT(r->out);
8786
8787                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8788                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
8789                 }
8790                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8791                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
8792                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
8793                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
8794                 NDR_PULL_ALLOC(ndr, r->out.user_handle);
8795                 *r->out.user_handle = *r->in.user_handle;
8796         }
8797         if (flags & NDR_OUT) {
8798                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8799                         NDR_PULL_ALLOC(ndr, r->out.user_handle);
8800                 }
8801                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8802                 NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
8803                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
8804                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
8805                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8806         }
8807         return NDR_ERR_SUCCESS;
8808 }
8809
8810 _PUBLIC_ void ndr_print_samr_DeleteUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteUser *r)
8811 {
8812         ndr_print_struct(ndr, name, "samr_DeleteUser");
8813         ndr->depth++;
8814         if (flags & NDR_SET_VALUES) {
8815                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8816         }
8817         if (flags & NDR_IN) {
8818                 ndr_print_struct(ndr, "in", "samr_DeleteUser");
8819                 ndr->depth++;
8820                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
8821                 ndr->depth++;
8822                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
8823                 ndr->depth--;
8824                 ndr->depth--;
8825         }
8826         if (flags & NDR_OUT) {
8827                 ndr_print_struct(ndr, "out", "samr_DeleteUser");
8828                 ndr->depth++;
8829                 ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
8830                 ndr->depth++;
8831                 ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
8832                 ndr->depth--;
8833                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8834                 ndr->depth--;
8835         }
8836         ndr->depth--;
8837 }
8838
8839 _PUBLIC_ enum ndr_err_code ndr_push_samr_QueryUserInfo(struct ndr_push *ndr, int flags, const struct samr_QueryUserInfo *r)
8840 {
8841         if (flags & NDR_IN) {
8842                 if (r->in.user_handle == NULL) {
8843                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8844                 }
8845                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
8846                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
8847         }
8848         if (flags & NDR_OUT) {
8849                 if (r->out.info == NULL) {
8850                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8851                 }
8852                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
8853                 if (*r->out.info) {
8854                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
8855                         NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8856                 }
8857                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8858         }
8859         return NDR_ERR_SUCCESS;
8860 }
8861
8862 _PUBLIC_ enum ndr_err_code ndr_pull_samr_QueryUserInfo(struct ndr_pull *ndr, int flags, struct samr_QueryUserInfo *r)
8863 {
8864         uint32_t _ptr_info;
8865         TALLOC_CTX *_mem_save_user_handle_0;
8866         TALLOC_CTX *_mem_save_info_0;
8867         TALLOC_CTX *_mem_save_info_1;
8868         if (flags & NDR_IN) {
8869                 ZERO_STRUCT(r->out);
8870
8871                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8872                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
8873                 }
8874                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8875                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
8876                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
8877                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
8878                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
8879                 NDR_PULL_ALLOC(ndr, r->out.info);
8880                 ZERO_STRUCTP(r->out.info);
8881         }
8882         if (flags & NDR_OUT) {
8883                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8884                         NDR_PULL_ALLOC(ndr, r->out.info);
8885                 }
8886                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8887                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
8888                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8889                 if (_ptr_info) {
8890                         NDR_PULL_ALLOC(ndr, *r->out.info);
8891                 } else {
8892                         *r->out.info = NULL;
8893                 }
8894                 if (*r->out.info) {
8895                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
8896                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
8897                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
8898                         NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8899                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
8900                 }
8901                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
8902                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8903         }
8904         return NDR_ERR_SUCCESS;
8905 }
8906
8907 _PUBLIC_ void ndr_print_samr_QueryUserInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryUserInfo *r)
8908 {
8909         ndr_print_struct(ndr, name, "samr_QueryUserInfo");
8910         ndr->depth++;
8911         if (flags & NDR_SET_VALUES) {
8912                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8913         }
8914         if (flags & NDR_IN) {
8915                 ndr_print_struct(ndr, "in", "samr_QueryUserInfo");
8916                 ndr->depth++;
8917                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
8918                 ndr->depth++;
8919                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
8920                 ndr->depth--;
8921                 ndr_print_uint16(ndr, "level", r->in.level);
8922                 ndr->depth--;
8923         }
8924         if (flags & NDR_OUT) {
8925                 ndr_print_struct(ndr, "out", "samr_QueryUserInfo");
8926                 ndr->depth++;
8927                 ndr_print_ptr(ndr, "info", r->out.info);
8928                 ndr->depth++;
8929                 ndr_print_ptr(ndr, "info", *r->out.info);
8930                 ndr->depth++;
8931                 if (*r->out.info) {
8932                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
8933                         ndr_print_samr_UserInfo(ndr, "info", *r->out.info);
8934                 }
8935                 ndr->depth--;
8936                 ndr->depth--;
8937                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8938                 ndr->depth--;
8939         }
8940         ndr->depth--;
8941 }
8942
8943 _PUBLIC_ enum ndr_err_code ndr_push_samr_SetUserInfo(struct ndr_push *ndr, int flags, const struct samr_SetUserInfo *r)
8944 {
8945         if (flags & NDR_IN) {
8946                 if (r->in.user_handle == NULL) {
8947                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8948                 }
8949                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
8950                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
8951                 if (r->in.info == NULL) {
8952                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8953                 }
8954                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
8955                 NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8956         }
8957         if (flags & NDR_OUT) {
8958                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8959         }
8960         return NDR_ERR_SUCCESS;
8961 }
8962
8963 _PUBLIC_ enum ndr_err_code ndr_pull_samr_SetUserInfo(struct ndr_pull *ndr, int flags, struct samr_SetUserInfo *r)
8964 {
8965         TALLOC_CTX *_mem_save_user_handle_0;
8966         TALLOC_CTX *_mem_save_info_0;
8967         if (flags & NDR_IN) {
8968                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8969                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
8970                 }
8971                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8972                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
8973                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
8974                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
8975                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
8976                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8977                         NDR_PULL_ALLOC(ndr, r->in.info);
8978                 }
8979                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8980                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
8981                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
8982                 NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8983                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
8984         }
8985         if (flags & NDR_OUT) {
8986                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8987         }
8988         return NDR_ERR_SUCCESS;
8989 }
8990
8991 _PUBLIC_ void ndr_print_samr_SetUserInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetUserInfo *r)
8992 {
8993         ndr_print_struct(ndr, name, "samr_SetUserInfo");
8994         ndr->depth++;
8995         if (flags & NDR_SET_VALUES) {
8996                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8997         }
8998         if (flags & NDR_IN) {
8999                 ndr_print_struct(ndr, "in", "samr_SetUserInfo");
9000                 ndr->depth++;
9001                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9002                 ndr->depth++;
9003                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9004                 ndr->depth--;
9005                 ndr_print_uint16(ndr, "level", r->in.level);
9006                 ndr_print_ptr(ndr, "info", r->in.info);
9007                 ndr->depth++;
9008                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
9009                 ndr_print_samr_UserInfo(ndr, "info", r->in.info);
9010                 ndr->depth--;
9011                 ndr->depth--;
9012         }
9013         if (flags & NDR_OUT) {
9014                 ndr_print_struct(ndr, "out", "samr_SetUserInfo");
9015                 ndr->depth++;
9016                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9017                 ndr->depth--;
9018         }
9019         ndr->depth--;
9020 }
9021
9022 static enum ndr_err_code ndr_push_samr_ChangePasswordUser(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser *r)
9023 {
9024         if (flags & NDR_IN) {
9025                 if (r->in.user_handle == NULL) {
9026                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9027                 }
9028                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9029                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_present));
9030                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_lm_crypted));
9031                 if (r->in.old_lm_crypted) {
9032                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.old_lm_crypted));
9033                 }
9034                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_lm_crypted));
9035                 if (r->in.new_lm_crypted) {
9036                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.new_lm_crypted));
9037                 }
9038                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.nt_present));
9039                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_nt_crypted));
9040                 if (r->in.old_nt_crypted) {
9041                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.old_nt_crypted));
9042                 }
9043                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_nt_crypted));
9044                 if (r->in.new_nt_crypted) {
9045                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.new_nt_crypted));
9046                 }
9047                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.cross1_present));
9048                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_cross));
9049                 if (r->in.nt_cross) {
9050                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_cross));
9051                 }
9052                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.cross2_present));
9053                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_cross));
9054                 if (r->in.lm_cross) {
9055                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_cross));
9056                 }
9057         }
9058         if (flags & NDR_OUT) {
9059                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9060         }
9061         return NDR_ERR_SUCCESS;
9062 }
9063
9064 static enum ndr_err_code ndr_pull_samr_ChangePasswordUser(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser *r)
9065 {
9066         uint32_t _ptr_old_lm_crypted;
9067         uint32_t _ptr_new_lm_crypted;
9068         uint32_t _ptr_old_nt_crypted;
9069         uint32_t _ptr_new_nt_crypted;
9070         uint32_t _ptr_nt_cross;
9071         uint32_t _ptr_lm_cross;
9072         TALLOC_CTX *_mem_save_user_handle_0;
9073         TALLOC_CTX *_mem_save_old_lm_crypted_0;
9074         TALLOC_CTX *_mem_save_new_lm_crypted_0;
9075         TALLOC_CTX *_mem_save_old_nt_crypted_0;
9076         TALLOC_CTX *_mem_save_new_nt_crypted_0;
9077         TALLOC_CTX *_mem_save_nt_cross_0;
9078         TALLOC_CTX *_mem_save_lm_cross_0;
9079         if (flags & NDR_IN) {
9080                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9081                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9082                 }
9083                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9084                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9085                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9086                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9087                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_present));
9088                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_lm_crypted));
9089                 if (_ptr_old_lm_crypted) {
9090                         NDR_PULL_ALLOC(ndr, r->in.old_lm_crypted);
9091                 } else {
9092                         r->in.old_lm_crypted = NULL;
9093                 }
9094                 if (r->in.old_lm_crypted) {
9095                         _mem_save_old_lm_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
9096                         NDR_PULL_SET_MEM_CTX(ndr, r->in.old_lm_crypted, 0);
9097                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.old_lm_crypted));
9098                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_lm_crypted_0, 0);
9099                 }
9100                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_lm_crypted));
9101                 if (_ptr_new_lm_crypted) {
9102                         NDR_PULL_ALLOC(ndr, r->in.new_lm_crypted);
9103                 } else {
9104                         r->in.new_lm_crypted = NULL;
9105                 }
9106                 if (r->in.new_lm_crypted) {
9107                         _mem_save_new_lm_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
9108                         NDR_PULL_SET_MEM_CTX(ndr, r->in.new_lm_crypted, 0);
9109                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.new_lm_crypted));
9110                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_lm_crypted_0, 0);
9111                 }
9112                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.nt_present));
9113                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_nt_crypted));
9114                 if (_ptr_old_nt_crypted) {
9115                         NDR_PULL_ALLOC(ndr, r->in.old_nt_crypted);
9116                 } else {
9117                         r->in.old_nt_crypted = NULL;
9118                 }
9119                 if (r->in.old_nt_crypted) {
9120                         _mem_save_old_nt_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
9121                         NDR_PULL_SET_MEM_CTX(ndr, r->in.old_nt_crypted, 0);
9122                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.old_nt_crypted));
9123                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_nt_crypted_0, 0);
9124                 }
9125                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_nt_crypted));
9126                 if (_ptr_new_nt_crypted) {
9127                         NDR_PULL_ALLOC(ndr, r->in.new_nt_crypted);
9128                 } else {
9129                         r->in.new_nt_crypted = NULL;
9130                 }
9131                 if (r->in.new_nt_crypted) {
9132                         _mem_save_new_nt_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
9133                         NDR_PULL_SET_MEM_CTX(ndr, r->in.new_nt_crypted, 0);
9134                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.new_nt_crypted));
9135                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_nt_crypted_0, 0);
9136                 }
9137                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.cross1_present));
9138                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_cross));
9139                 if (_ptr_nt_cross) {
9140                         NDR_PULL_ALLOC(ndr, r->in.nt_cross);
9141                 } else {
9142                         r->in.nt_cross = NULL;
9143                 }
9144                 if (r->in.nt_cross) {
9145                         _mem_save_nt_cross_0 = NDR_PULL_GET_MEM_CTX(ndr);
9146                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_cross, 0);
9147                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_cross));
9148                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_cross_0, 0);
9149                 }
9150                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.cross2_present));
9151                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_cross));
9152                 if (_ptr_lm_cross) {
9153                         NDR_PULL_ALLOC(ndr, r->in.lm_cross);
9154                 } else {
9155                         r->in.lm_cross = NULL;
9156                 }
9157                 if (r->in.lm_cross) {
9158                         _mem_save_lm_cross_0 = NDR_PULL_GET_MEM_CTX(ndr);
9159                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_cross, 0);
9160                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_cross));
9161                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_cross_0, 0);
9162                 }
9163         }
9164         if (flags & NDR_OUT) {
9165                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9166         }
9167         return NDR_ERR_SUCCESS;
9168 }
9169
9170 _PUBLIC_ void ndr_print_samr_ChangePasswordUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser *r)
9171 {
9172         ndr_print_struct(ndr, name, "samr_ChangePasswordUser");
9173         ndr->depth++;
9174         if (flags & NDR_SET_VALUES) {
9175                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9176         }
9177         if (flags & NDR_IN) {
9178                 ndr_print_struct(ndr, "in", "samr_ChangePasswordUser");
9179                 ndr->depth++;
9180                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9181                 ndr->depth++;
9182                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9183                 ndr->depth--;
9184                 ndr_print_uint8(ndr, "lm_present", r->in.lm_present);
9185                 ndr_print_ptr(ndr, "old_lm_crypted", r->in.old_lm_crypted);
9186                 ndr->depth++;
9187                 if (r->in.old_lm_crypted) {
9188                         ndr_print_samr_Password(ndr, "old_lm_crypted", r->in.old_lm_crypted);
9189                 }
9190                 ndr->depth--;
9191                 ndr_print_ptr(ndr, "new_lm_crypted", r->in.new_lm_crypted);
9192                 ndr->depth++;
9193                 if (r->in.new_lm_crypted) {
9194                         ndr_print_samr_Password(ndr, "new_lm_crypted", r->in.new_lm_crypted);
9195                 }
9196                 ndr->depth--;
9197                 ndr_print_uint8(ndr, "nt_present", r->in.nt_present);
9198                 ndr_print_ptr(ndr, "old_nt_crypted", r->in.old_nt_crypted);
9199                 ndr->depth++;
9200                 if (r->in.old_nt_crypted) {
9201                         ndr_print_samr_Password(ndr, "old_nt_crypted", r->in.old_nt_crypted);
9202                 }
9203                 ndr->depth--;
9204                 ndr_print_ptr(ndr, "new_nt_crypted", r->in.new_nt_crypted);
9205                 ndr->depth++;
9206                 if (r->in.new_nt_crypted) {
9207                         ndr_print_samr_Password(ndr, "new_nt_crypted", r->in.new_nt_crypted);
9208                 }
9209                 ndr->depth--;
9210                 ndr_print_uint8(ndr, "cross1_present", r->in.cross1_present);
9211                 ndr_print_ptr(ndr, "nt_cross", r->in.nt_cross);
9212                 ndr->depth++;
9213                 if (r->in.nt_cross) {
9214                         ndr_print_samr_Password(ndr, "nt_cross", r->in.nt_cross);
9215                 }
9216                 ndr->depth--;
9217                 ndr_print_uint8(ndr, "cross2_present", r->in.cross2_present);
9218                 ndr_print_ptr(ndr, "lm_cross", r->in.lm_cross);
9219                 ndr->depth++;
9220                 if (r->in.lm_cross) {
9221                         ndr_print_samr_Password(ndr, "lm_cross", r->in.lm_cross);
9222                 }
9223                 ndr->depth--;
9224                 ndr->depth--;
9225         }
9226         if (flags & NDR_OUT) {
9227                 ndr_print_struct(ndr, "out", "samr_ChangePasswordUser");
9228                 ndr->depth++;
9229                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9230                 ndr->depth--;
9231         }
9232         ndr->depth--;
9233 }
9234
9235 static enum ndr_err_code ndr_push_samr_GetGroupsForUser(struct ndr_push *ndr, int flags, const struct samr_GetGroupsForUser *r)
9236 {
9237         if (flags & NDR_IN) {
9238                 if (r->in.user_handle == NULL) {
9239                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9240                 }
9241                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9242         }
9243         if (flags & NDR_OUT) {
9244                 if (r->out.rids == NULL) {
9245                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9246                 }
9247                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rids));
9248                 if (*r->out.rids) {
9249                         NDR_CHECK(ndr_push_samr_RidWithAttributeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
9250                 }
9251                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9252         }
9253         return NDR_ERR_SUCCESS;
9254 }
9255
9256 static enum ndr_err_code ndr_pull_samr_GetGroupsForUser(struct ndr_pull *ndr, int flags, struct samr_GetGroupsForUser *r)
9257 {
9258         uint32_t _ptr_rids;
9259         TALLOC_CTX *_mem_save_user_handle_0;
9260         TALLOC_CTX *_mem_save_rids_0;
9261         TALLOC_CTX *_mem_save_rids_1;
9262         if (flags & NDR_IN) {
9263                 ZERO_STRUCT(r->out);
9264
9265                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9266                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9267                 }
9268                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9269                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9270                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9271                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9272                 NDR_PULL_ALLOC(ndr, r->out.rids);
9273                 ZERO_STRUCTP(r->out.rids);
9274         }
9275         if (flags & NDR_OUT) {
9276                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9277                         NDR_PULL_ALLOC(ndr, r->out.rids);
9278                 }
9279                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
9280                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
9281                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
9282                 if (_ptr_rids) {
9283                         NDR_PULL_ALLOC(ndr, *r->out.rids);
9284                 } else {
9285                         *r->out.rids = NULL;
9286                 }
9287                 if (*r->out.rids) {
9288                         _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
9289                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.rids, 0);
9290                         NDR_CHECK(ndr_pull_samr_RidWithAttributeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
9291                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
9292                 }
9293                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
9294                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9295         }
9296         return NDR_ERR_SUCCESS;
9297 }
9298
9299 _PUBLIC_ void ndr_print_samr_GetGroupsForUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetGroupsForUser *r)
9300 {
9301         ndr_print_struct(ndr, name, "samr_GetGroupsForUser");
9302         ndr->depth++;
9303         if (flags & NDR_SET_VALUES) {
9304                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9305         }
9306         if (flags & NDR_IN) {
9307                 ndr_print_struct(ndr, "in", "samr_GetGroupsForUser");
9308                 ndr->depth++;
9309                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9310                 ndr->depth++;
9311                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9312                 ndr->depth--;
9313                 ndr->depth--;
9314         }
9315         if (flags & NDR_OUT) {
9316                 ndr_print_struct(ndr, "out", "samr_GetGroupsForUser");
9317                 ndr->depth++;
9318                 ndr_print_ptr(ndr, "rids", r->out.rids);
9319                 ndr->depth++;
9320                 ndr_print_ptr(ndr, "rids", *r->out.rids);
9321                 ndr->depth++;
9322                 if (*r->out.rids) {
9323                         ndr_print_samr_RidWithAttributeArray(ndr, "rids", *r->out.rids);
9324                 }
9325                 ndr->depth--;
9326                 ndr->depth--;
9327                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9328                 ndr->depth--;
9329         }
9330         ndr->depth--;
9331 }
9332
9333 static enum ndr_err_code ndr_push_samr_QueryDisplayInfo(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo *r)
9334 {
9335         if (flags & NDR_IN) {
9336                 if (r->in.domain_handle == NULL) {
9337                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9338                 }
9339                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9340                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));
9342                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));
9343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
9344         }
9345         if (flags & NDR_OUT) {
9346                 if (r->out.total_size == NULL) {
9347                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9348                 }
9349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));
9350                 if (r->out.returned_size == NULL) {
9351                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9352                 }
9353                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));
9354                 if (r->out.info == NULL) {
9355                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9356                 }
9357                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
9358                 NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
9359                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9360         }
9361         return NDR_ERR_SUCCESS;
9362 }
9363
9364 static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo *r)
9365 {
9366         TALLOC_CTX *_mem_save_domain_handle_0;
9367         TALLOC_CTX *_mem_save_total_size_0;
9368         TALLOC_CTX *_mem_save_returned_size_0;
9369         TALLOC_CTX *_mem_save_info_0;
9370         if (flags & NDR_IN) {
9371                 ZERO_STRUCT(r->out);
9372
9373                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9374                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
9375                 }
9376                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9377                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
9378                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9379                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
9380                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
9381                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));
9382                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));
9383                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
9384                 NDR_PULL_ALLOC(ndr, r->out.total_size);
9385                 ZERO_STRUCTP(r->out.total_size);
9386                 NDR_PULL_ALLOC(ndr, r->out.returned_size);
9387                 ZERO_STRUCTP(r->out.returned_size);
9388                 NDR_PULL_ALLOC(ndr, r->out.info);
9389                 ZERO_STRUCTP(r->out.info);
9390         }
9391         if (flags & NDR_OUT) {
9392                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9393                         NDR_PULL_ALLOC(ndr, r->out.total_size);
9394                 }
9395                 _mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
9396                 NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);
9397                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));
9398                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);
9399                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9400                         NDR_PULL_ALLOC(ndr, r->out.returned_size);
9401                 }
9402                 _mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
9403                 NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);
9404                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));
9405                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);
9406                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9407                         NDR_PULL_ALLOC(ndr, r->out.info);
9408                 }
9409                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9410                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9411                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
9412                 NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
9413                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9414                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9415         }
9416         return NDR_ERR_SUCCESS;
9417 }
9418
9419 _PUBLIC_ void ndr_print_samr_QueryDisplayInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo *r)
9420 {
9421         ndr_print_struct(ndr, name, "samr_QueryDisplayInfo");
9422         ndr->depth++;
9423         if (flags & NDR_SET_VALUES) {
9424                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9425         }
9426         if (flags & NDR_IN) {
9427                 ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo");
9428                 ndr->depth++;
9429                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
9430                 ndr->depth++;
9431                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
9432                 ndr->depth--;
9433                 ndr_print_uint16(ndr, "level", r->in.level);
9434                 ndr_print_uint32(ndr, "start_idx", r->in.start_idx);
9435                 ndr_print_uint32(ndr, "max_entries", r->in.max_entries);
9436                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
9437                 ndr->depth--;
9438         }
9439         if (flags & NDR_OUT) {
9440                 ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo");
9441                 ndr->depth++;
9442                 ndr_print_ptr(ndr, "total_size", r->out.total_size);
9443                 ndr->depth++;
9444                 ndr_print_uint32(ndr, "total_size", *r->out.total_size);
9445                 ndr->depth--;
9446                 ndr_print_ptr(ndr, "returned_size", r->out.returned_size);
9447                 ndr->depth++;
9448                 ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);
9449                 ndr->depth--;
9450                 ndr_print_ptr(ndr, "info", r->out.info);
9451                 ndr->depth++;
9452                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
9453                 ndr_print_samr_DispInfo(ndr, "info", r->out.info);
9454                 ndr->depth--;
9455                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9456                 ndr->depth--;
9457         }
9458         ndr->depth--;
9459 }
9460
9461 static enum ndr_err_code ndr_push_samr_GetDisplayEnumerationIndex(struct ndr_push *ndr, int flags, const struct samr_GetDisplayEnumerationIndex *r)
9462 {
9463         if (flags & NDR_IN) {
9464                 if (r->in.domain_handle == NULL) {
9465                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9466                 }
9467                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9468                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9469                 if (r->in.name == NULL) {
9470                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9471                 }
9472                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
9473         }
9474         if (flags & NDR_OUT) {
9475                 if (r->out.idx == NULL) {
9476                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9477                 }
9478                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.idx));
9479                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9480         }
9481         return NDR_ERR_SUCCESS;
9482 }
9483
9484 static enum ndr_err_code ndr_pull_samr_GetDisplayEnumerationIndex(struct ndr_pull *ndr, int flags, struct samr_GetDisplayEnumerationIndex *r)
9485 {
9486         TALLOC_CTX *_mem_save_domain_handle_0;
9487         TALLOC_CTX *_mem_save_name_0;
9488         TALLOC_CTX *_mem_save_idx_0;
9489         if (flags & NDR_IN) {
9490                 ZERO_STRUCT(r->out);
9491
9492                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9493                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
9494                 }
9495                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9496                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
9497                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9498                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
9499                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
9500                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9501                         NDR_PULL_ALLOC(ndr, r->in.name);
9502                 }
9503                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9504                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
9505                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
9506                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
9507                 NDR_PULL_ALLOC(ndr, r->out.idx);
9508                 ZERO_STRUCTP(r->out.idx);
9509         }
9510         if (flags & NDR_OUT) {
9511                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9512                         NDR_PULL_ALLOC(ndr, r->out.idx);
9513                 }
9514                 _mem_save_idx_0 = NDR_PULL_GET_MEM_CTX(ndr);
9515                 NDR_PULL_SET_MEM_CTX(ndr, r->out.idx, LIBNDR_FLAG_REF_ALLOC);
9516                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.idx));
9517                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_idx_0, LIBNDR_FLAG_REF_ALLOC);
9518                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9519         }
9520         return NDR_ERR_SUCCESS;
9521 }
9522
9523 _PUBLIC_ void ndr_print_samr_GetDisplayEnumerationIndex(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDisplayEnumerationIndex *r)
9524 {
9525         ndr_print_struct(ndr, name, "samr_GetDisplayEnumerationIndex");
9526         ndr->depth++;
9527         if (flags & NDR_SET_VALUES) {
9528                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9529         }
9530         if (flags & NDR_IN) {
9531                 ndr_print_struct(ndr, "in", "samr_GetDisplayEnumerationIndex");
9532                 ndr->depth++;
9533                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
9534                 ndr->depth++;
9535                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
9536                 ndr->depth--;
9537                 ndr_print_uint16(ndr, "level", r->in.level);
9538                 ndr_print_ptr(ndr, "name", r->in.name);
9539                 ndr->depth++;
9540                 ndr_print_lsa_String(ndr, "name", r->in.name);
9541                 ndr->depth--;
9542                 ndr->depth--;
9543         }
9544         if (flags & NDR_OUT) {
9545                 ndr_print_struct(ndr, "out", "samr_GetDisplayEnumerationIndex");
9546                 ndr->depth++;
9547                 ndr_print_ptr(ndr, "idx", r->out.idx);
9548                 ndr->depth++;
9549                 ndr_print_uint32(ndr, "idx", *r->out.idx);
9550                 ndr->depth--;
9551                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9552                 ndr->depth--;
9553         }
9554         ndr->depth--;
9555 }
9556
9557 static enum ndr_err_code ndr_push_samr_TestPrivateFunctionsDomain(struct ndr_push *ndr, int flags, const struct samr_TestPrivateFunctionsDomain *r)
9558 {
9559         if (flags & NDR_IN) {
9560                 if (r->in.domain_handle == NULL) {
9561                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9562                 }
9563                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9564         }
9565         if (flags & NDR_OUT) {
9566                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9567         }
9568         return NDR_ERR_SUCCESS;
9569 }
9570
9571 static enum ndr_err_code ndr_pull_samr_TestPrivateFunctionsDomain(struct ndr_pull *ndr, int flags, struct samr_TestPrivateFunctionsDomain *r)
9572 {
9573         TALLOC_CTX *_mem_save_domain_handle_0;
9574         if (flags & NDR_IN) {
9575                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9576                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
9577                 }
9578                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9579                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
9580                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9581                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
9582         }
9583         if (flags & NDR_OUT) {
9584                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9585         }
9586         return NDR_ERR_SUCCESS;
9587 }
9588
9589 _PUBLIC_ void ndr_print_samr_TestPrivateFunctionsDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_TestPrivateFunctionsDomain *r)
9590 {
9591         ndr_print_struct(ndr, name, "samr_TestPrivateFunctionsDomain");
9592         ndr->depth++;
9593         if (flags & NDR_SET_VALUES) {
9594                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9595         }
9596         if (flags & NDR_IN) {
9597                 ndr_print_struct(ndr, "in", "samr_TestPrivateFunctionsDomain");
9598                 ndr->depth++;
9599                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
9600                 ndr->depth++;
9601                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
9602                 ndr->depth--;
9603                 ndr->depth--;
9604         }
9605         if (flags & NDR_OUT) {
9606                 ndr_print_struct(ndr, "out", "samr_TestPrivateFunctionsDomain");
9607                 ndr->depth++;
9608                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9609                 ndr->depth--;
9610         }
9611         ndr->depth--;
9612 }
9613
9614 static enum ndr_err_code ndr_push_samr_TestPrivateFunctionsUser(struct ndr_push *ndr, int flags, const struct samr_TestPrivateFunctionsUser *r)
9615 {
9616         if (flags & NDR_IN) {
9617                 if (r->in.user_handle == NULL) {
9618                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9619                 }
9620                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9621         }
9622         if (flags & NDR_OUT) {
9623                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9624         }
9625         return NDR_ERR_SUCCESS;
9626 }
9627
9628 static enum ndr_err_code ndr_pull_samr_TestPrivateFunctionsUser(struct ndr_pull *ndr, int flags, struct samr_TestPrivateFunctionsUser *r)
9629 {
9630         TALLOC_CTX *_mem_save_user_handle_0;
9631         if (flags & NDR_IN) {
9632                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9633                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9634                 }
9635                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9636                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9637                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9638                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9639         }
9640         if (flags & NDR_OUT) {
9641                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9642         }
9643         return NDR_ERR_SUCCESS;
9644 }
9645
9646 _PUBLIC_ void ndr_print_samr_TestPrivateFunctionsUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_TestPrivateFunctionsUser *r)
9647 {
9648         ndr_print_struct(ndr, name, "samr_TestPrivateFunctionsUser");
9649         ndr->depth++;
9650         if (flags & NDR_SET_VALUES) {
9651                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9652         }
9653         if (flags & NDR_IN) {
9654                 ndr_print_struct(ndr, "in", "samr_TestPrivateFunctionsUser");
9655                 ndr->depth++;
9656                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9657                 ndr->depth++;
9658                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9659                 ndr->depth--;
9660                 ndr->depth--;
9661         }
9662         if (flags & NDR_OUT) {
9663                 ndr_print_struct(ndr, "out", "samr_TestPrivateFunctionsUser");
9664                 ndr->depth++;
9665                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9666                 ndr->depth--;
9667         }
9668         ndr->depth--;
9669 }
9670
9671 _PUBLIC_ enum ndr_err_code ndr_push_samr_GetUserPwInfo(struct ndr_push *ndr, int flags, const struct samr_GetUserPwInfo *r)
9672 {
9673         if (flags & NDR_IN) {
9674                 if (r->in.user_handle == NULL) {
9675                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9676                 }
9677                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9678         }
9679         if (flags & NDR_OUT) {
9680                 if (r->out.info == NULL) {
9681                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9682                 }
9683                 NDR_CHECK(ndr_push_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
9684                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9685         }
9686         return NDR_ERR_SUCCESS;
9687 }
9688
9689 _PUBLIC_ enum ndr_err_code ndr_pull_samr_GetUserPwInfo(struct ndr_pull *ndr, int flags, struct samr_GetUserPwInfo *r)
9690 {
9691         TALLOC_CTX *_mem_save_user_handle_0;
9692         TALLOC_CTX *_mem_save_info_0;
9693         if (flags & NDR_IN) {
9694                 ZERO_STRUCT(r->out);
9695
9696                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9697                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9698                 }
9699                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9700                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9701                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9702                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9703                 NDR_PULL_ALLOC(ndr, r->out.info);
9704                 ZERO_STRUCTP(r->out.info);
9705         }
9706         if (flags & NDR_OUT) {
9707                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9708                         NDR_PULL_ALLOC(ndr, r->out.info);
9709                 }
9710                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9711                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9712                 NDR_CHECK(ndr_pull_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
9713                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9714                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9715         }
9716         return NDR_ERR_SUCCESS;
9717 }
9718
9719 _PUBLIC_ void ndr_print_samr_GetUserPwInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetUserPwInfo *r)
9720 {
9721         ndr_print_struct(ndr, name, "samr_GetUserPwInfo");
9722         ndr->depth++;
9723         if (flags & NDR_SET_VALUES) {
9724                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9725         }
9726         if (flags & NDR_IN) {
9727                 ndr_print_struct(ndr, "in", "samr_GetUserPwInfo");
9728                 ndr->depth++;
9729                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
9730                 ndr->depth++;
9731                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
9732                 ndr->depth--;
9733                 ndr->depth--;
9734         }
9735         if (flags & NDR_OUT) {
9736                 ndr_print_struct(ndr, "out", "samr_GetUserPwInfo");
9737                 ndr->depth++;
9738                 ndr_print_ptr(ndr, "info", r->out.info);
9739                 ndr->depth++;
9740                 ndr_print_samr_PwInfo(ndr, "info", r->out.info);
9741                 ndr->depth--;
9742                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9743                 ndr->depth--;
9744         }
9745         ndr->depth--;
9746 }
9747
9748 static enum ndr_err_code ndr_push_samr_RemoveMemberFromForeignDomain(struct ndr_push *ndr, int flags, const struct samr_RemoveMemberFromForeignDomain *r)
9749 {
9750         if (flags & NDR_IN) {
9751                 if (r->in.domain_handle == NULL) {
9752                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9753                 }
9754                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9755                 if (r->in.sid == NULL) {
9756                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9757                 }
9758                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
9759         }
9760         if (flags & NDR_OUT) {
9761                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9762         }
9763         return NDR_ERR_SUCCESS;
9764 }
9765
9766 static enum ndr_err_code ndr_pull_samr_RemoveMemberFromForeignDomain(struct ndr_pull *ndr, int flags, struct samr_RemoveMemberFromForeignDomain *r)
9767 {
9768         TALLOC_CTX *_mem_save_domain_handle_0;
9769         TALLOC_CTX *_mem_save_sid_0;
9770         if (flags & NDR_IN) {
9771                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9772                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
9773                 }
9774                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9775                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
9776                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9777                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
9778                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9779                         NDR_PULL_ALLOC(ndr, r->in.sid);
9780                 }
9781                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
9782                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
9783                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
9784                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
9785         }
9786         if (flags & NDR_OUT) {
9787                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9788         }
9789         return NDR_ERR_SUCCESS;
9790 }
9791
9792 _PUBLIC_ void ndr_print_samr_RemoveMemberFromForeignDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_RemoveMemberFromForeignDomain *r)
9793 {
9794         ndr_print_struct(ndr, name, "samr_RemoveMemberFromForeignDomain");
9795         ndr->depth++;
9796         if (flags & NDR_SET_VALUES) {
9797                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9798         }
9799         if (flags & NDR_IN) {
9800                 ndr_print_struct(ndr, "in", "samr_RemoveMemberFromForeignDomain");
9801                 ndr->depth++;
9802                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
9803                 ndr->depth++;
9804                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
9805                 ndr->depth--;
9806                 ndr_print_ptr(ndr, "sid", r->in.sid);
9807                 ndr->depth++;
9808                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
9809                 ndr->depth--;
9810                 ndr->depth--;
9811         }
9812         if (flags & NDR_OUT) {
9813                 ndr_print_struct(ndr, "out", "samr_RemoveMemberFromForeignDomain");
9814                 ndr->depth++;
9815                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9816                 ndr->depth--;
9817         }
9818         ndr->depth--;
9819 }
9820
9821 static enum ndr_err_code ndr_push_samr_QueryDomainInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryDomainInfo2 *r)
9822 {
9823         if (flags & NDR_IN) {
9824                 if (r->in.domain_handle == NULL) {
9825                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9826                 }
9827                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9828                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9829         }
9830         if (flags & NDR_OUT) {
9831                 if (r->out.info == NULL) {
9832                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9833                 }
9834                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
9835                 if (*r->out.info) {
9836                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
9837                         NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9838                 }
9839                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9840         }
9841         return NDR_ERR_SUCCESS;
9842 }
9843
9844 static enum ndr_err_code ndr_pull_samr_QueryDomainInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryDomainInfo2 *r)
9845 {
9846         uint32_t _ptr_info;
9847         TALLOC_CTX *_mem_save_domain_handle_0;
9848         TALLOC_CTX *_mem_save_info_0;
9849         TALLOC_CTX *_mem_save_info_1;
9850         if (flags & NDR_IN) {
9851                 ZERO_STRUCT(r->out);
9852
9853                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9854                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
9855                 }
9856                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9857                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
9858                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
9859                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
9860                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
9861                 NDR_PULL_ALLOC(ndr, r->out.info);
9862                 ZERO_STRUCTP(r->out.info);
9863         }
9864         if (flags & NDR_OUT) {
9865                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9866                         NDR_PULL_ALLOC(ndr, r->out.info);
9867                 }
9868                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9869                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9870                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9871                 if (_ptr_info) {
9872                         NDR_PULL_ALLOC(ndr, *r->out.info);
9873                 } else {
9874                         *r->out.info = NULL;
9875                 }
9876                 if (*r->out.info) {
9877                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
9878                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
9879                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
9880                         NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9881                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
9882                 }
9883                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9884                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9885         }
9886         return NDR_ERR_SUCCESS;
9887 }
9888
9889 _PUBLIC_ void ndr_print_samr_QueryDomainInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDomainInfo2 *r)
9890 {
9891         ndr_print_struct(ndr, name, "samr_QueryDomainInfo2");
9892         ndr->depth++;
9893         if (flags & NDR_SET_VALUES) {
9894                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9895         }
9896         if (flags & NDR_IN) {
9897                 ndr_print_struct(ndr, "in", "samr_QueryDomainInfo2");
9898                 ndr->depth++;
9899                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
9900                 ndr->depth++;
9901                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
9902                 ndr->depth--;
9903                 ndr_print_uint16(ndr, "level", r->in.level);
9904                 ndr->depth--;
9905         }
9906         if (flags & NDR_OUT) {
9907                 ndr_print_struct(ndr, "out", "samr_QueryDomainInfo2");
9908                 ndr->depth++;
9909                 ndr_print_ptr(ndr, "info", r->out.info);
9910                 ndr->depth++;
9911                 ndr_print_ptr(ndr, "info", *r->out.info);
9912                 ndr->depth++;
9913                 if (*r->out.info) {
9914                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
9915                         ndr_print_samr_DomainInfo(ndr, "info", *r->out.info);
9916                 }
9917                 ndr->depth--;
9918                 ndr->depth--;
9919                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9920                 ndr->depth--;
9921         }
9922         ndr->depth--;
9923 }
9924
9925 static enum ndr_err_code ndr_push_samr_QueryUserInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryUserInfo2 *r)
9926 {
9927         if (flags & NDR_IN) {
9928                 if (r->in.user_handle == NULL) {
9929                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9930                 }
9931                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9932                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9933         }
9934         if (flags & NDR_OUT) {
9935                 if (r->out.info == NULL) {
9936                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9937                 }
9938                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
9939                 if (*r->out.info) {
9940                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
9941                         NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9942                 }
9943                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9944         }
9945         return NDR_ERR_SUCCESS;
9946 }
9947
9948 static enum ndr_err_code ndr_pull_samr_QueryUserInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryUserInfo2 *r)
9949 {
9950         uint32_t _ptr_info;
9951         TALLOC_CTX *_mem_save_user_handle_0;
9952         TALLOC_CTX *_mem_save_info_0;
9953         TALLOC_CTX *_mem_save_info_1;
9954         if (flags & NDR_IN) {
9955                 ZERO_STRUCT(r->out);
9956
9957                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9958                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
9959                 }
9960                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9961                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
9962                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
9963                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
9964                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
9965                 NDR_PULL_ALLOC(ndr, r->out.info);
9966                 ZERO_STRUCTP(r->out.info);
9967         }
9968         if (flags & NDR_OUT) {
9969                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9970                         NDR_PULL_ALLOC(ndr, r->out.info);
9971                 }
9972                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9973                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9974                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9975                 if (_ptr_info) {
9976                         NDR_PULL_ALLOC(ndr, *r->out.info);
9977                 } else {
9978                         *r->out.info = NULL;
9979                 }
9980                 if (*r->out.info) {
9981                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
9982                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
9983                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
9984                         NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9985                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
9986                 }
9987                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9988                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9989         }
9990         return NDR_ERR_SUCCESS;
9991 }
9992
9993 _PUBLIC_ void ndr_print_samr_QueryUserInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryUserInfo2 *r)
9994 {
9995         ndr_print_struct(ndr, name, "samr_QueryUserInfo2");
9996         ndr->depth++;
9997         if (flags & NDR_SET_VALUES) {
9998                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9999         }
10000         if (flags & NDR_IN) {
10001                 ndr_print_struct(ndr, "in", "samr_QueryUserInfo2");
10002                 ndr->depth++;
10003                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
10004                 ndr->depth++;
10005                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
10006                 ndr->depth--;
10007                 ndr_print_uint16(ndr, "level", r->in.level);
10008                 ndr->depth--;
10009         }
10010         if (flags & NDR_OUT) {
10011                 ndr_print_struct(ndr, "out", "samr_QueryUserInfo2");
10012                 ndr->depth++;
10013                 ndr_print_ptr(ndr, "info", r->out.info);
10014                 ndr->depth++;
10015                 ndr_print_ptr(ndr, "info", *r->out.info);
10016                 ndr->depth++;
10017                 if (*r->out.info) {
10018                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
10019                         ndr_print_samr_UserInfo(ndr, "info", *r->out.info);
10020                 }
10021                 ndr->depth--;
10022                 ndr->depth--;
10023                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10024                 ndr->depth--;
10025         }
10026         ndr->depth--;
10027 }
10028
10029 static enum ndr_err_code ndr_push_samr_QueryDisplayInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo2 *r)
10030 {
10031         if (flags & NDR_IN) {
10032                 if (r->in.domain_handle == NULL) {
10033                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10034                 }
10035                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10036                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
10037                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));
10038                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));
10039                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
10040         }
10041         if (flags & NDR_OUT) {
10042                 if (r->out.total_size == NULL) {
10043                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10044                 }
10045                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));
10046                 if (r->out.returned_size == NULL) {
10047                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10048                 }
10049                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));
10050                 if (r->out.info == NULL) {
10051                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10052                 }
10053                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
10054                 NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
10055                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10056         }
10057         return NDR_ERR_SUCCESS;
10058 }
10059
10060 static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo2 *r)
10061 {
10062         TALLOC_CTX *_mem_save_domain_handle_0;
10063         TALLOC_CTX *_mem_save_total_size_0;
10064         TALLOC_CTX *_mem_save_returned_size_0;
10065         TALLOC_CTX *_mem_save_info_0;
10066         if (flags & NDR_IN) {
10067                 ZERO_STRUCT(r->out);
10068
10069                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10070                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10071                 }
10072                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10073                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10074                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10075                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10076                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10077                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));
10078                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));
10079                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
10080                 NDR_PULL_ALLOC(ndr, r->out.total_size);
10081                 ZERO_STRUCTP(r->out.total_size);
10082                 NDR_PULL_ALLOC(ndr, r->out.returned_size);
10083                 ZERO_STRUCTP(r->out.returned_size);
10084                 NDR_PULL_ALLOC(ndr, r->out.info);
10085                 ZERO_STRUCTP(r->out.info);
10086         }
10087         if (flags & NDR_OUT) {
10088                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10089                         NDR_PULL_ALLOC(ndr, r->out.total_size);
10090                 }
10091                 _mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
10092                 NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);
10093                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));
10094                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);
10095                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10096                         NDR_PULL_ALLOC(ndr, r->out.returned_size);
10097                 }
10098                 _mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
10099                 NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);
10100                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));
10101                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);
10102                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10103                         NDR_PULL_ALLOC(ndr, r->out.info);
10104                 }
10105                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10106                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
10107                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
10108                 NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
10109                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
10110                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10111         }
10112         return NDR_ERR_SUCCESS;
10113 }
10114
10115 _PUBLIC_ void ndr_print_samr_QueryDisplayInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo2 *r)
10116 {
10117         ndr_print_struct(ndr, name, "samr_QueryDisplayInfo2");
10118         ndr->depth++;
10119         if (flags & NDR_SET_VALUES) {
10120                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10121         }
10122         if (flags & NDR_IN) {
10123                 ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo2");
10124                 ndr->depth++;
10125                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10126                 ndr->depth++;
10127                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10128                 ndr->depth--;
10129                 ndr_print_uint16(ndr, "level", r->in.level);
10130                 ndr_print_uint32(ndr, "start_idx", r->in.start_idx);
10131                 ndr_print_uint32(ndr, "max_entries", r->in.max_entries);
10132                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
10133                 ndr->depth--;
10134         }
10135         if (flags & NDR_OUT) {
10136                 ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo2");
10137                 ndr->depth++;
10138                 ndr_print_ptr(ndr, "total_size", r->out.total_size);
10139                 ndr->depth++;
10140                 ndr_print_uint32(ndr, "total_size", *r->out.total_size);
10141                 ndr->depth--;
10142                 ndr_print_ptr(ndr, "returned_size", r->out.returned_size);
10143                 ndr->depth++;
10144                 ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);
10145                 ndr->depth--;
10146                 ndr_print_ptr(ndr, "info", r->out.info);
10147                 ndr->depth++;
10148                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
10149                 ndr_print_samr_DispInfo(ndr, "info", r->out.info);
10150                 ndr->depth--;
10151                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10152                 ndr->depth--;
10153         }
10154         ndr->depth--;
10155 }
10156
10157 static enum ndr_err_code ndr_push_samr_GetDisplayEnumerationIndex2(struct ndr_push *ndr, int flags, const struct samr_GetDisplayEnumerationIndex2 *r)
10158 {
10159         if (flags & NDR_IN) {
10160                 if (r->in.domain_handle == NULL) {
10161                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10162                 }
10163                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10164                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
10165                 if (r->in.name == NULL) {
10166                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10167                 }
10168                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
10169         }
10170         if (flags & NDR_OUT) {
10171                 if (r->out.idx == NULL) {
10172                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10173                 }
10174                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.idx));
10175                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10176         }
10177         return NDR_ERR_SUCCESS;
10178 }
10179
10180 static enum ndr_err_code ndr_pull_samr_GetDisplayEnumerationIndex2(struct ndr_pull *ndr, int flags, struct samr_GetDisplayEnumerationIndex2 *r)
10181 {
10182         TALLOC_CTX *_mem_save_domain_handle_0;
10183         TALLOC_CTX *_mem_save_name_0;
10184         TALLOC_CTX *_mem_save_idx_0;
10185         if (flags & NDR_IN) {
10186                 ZERO_STRUCT(r->out);
10187
10188                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10189                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10190                 }
10191                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10192                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10193                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10194                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10195                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10196                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10197                         NDR_PULL_ALLOC(ndr, r->in.name);
10198                 }
10199                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10200                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
10201                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
10202                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
10203                 NDR_PULL_ALLOC(ndr, r->out.idx);
10204                 ZERO_STRUCTP(r->out.idx);
10205         }
10206         if (flags & NDR_OUT) {
10207                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10208                         NDR_PULL_ALLOC(ndr, r->out.idx);
10209                 }
10210                 _mem_save_idx_0 = NDR_PULL_GET_MEM_CTX(ndr);
10211                 NDR_PULL_SET_MEM_CTX(ndr, r->out.idx, LIBNDR_FLAG_REF_ALLOC);
10212                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.idx));
10213                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_idx_0, LIBNDR_FLAG_REF_ALLOC);
10214                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10215         }
10216         return NDR_ERR_SUCCESS;
10217 }
10218
10219 _PUBLIC_ void ndr_print_samr_GetDisplayEnumerationIndex2(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDisplayEnumerationIndex2 *r)
10220 {
10221         ndr_print_struct(ndr, name, "samr_GetDisplayEnumerationIndex2");
10222         ndr->depth++;
10223         if (flags & NDR_SET_VALUES) {
10224                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10225         }
10226         if (flags & NDR_IN) {
10227                 ndr_print_struct(ndr, "in", "samr_GetDisplayEnumerationIndex2");
10228                 ndr->depth++;
10229                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10230                 ndr->depth++;
10231                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10232                 ndr->depth--;
10233                 ndr_print_uint16(ndr, "level", r->in.level);
10234                 ndr_print_ptr(ndr, "name", r->in.name);
10235                 ndr->depth++;
10236                 ndr_print_lsa_String(ndr, "name", r->in.name);
10237                 ndr->depth--;
10238                 ndr->depth--;
10239         }
10240         if (flags & NDR_OUT) {
10241                 ndr_print_struct(ndr, "out", "samr_GetDisplayEnumerationIndex2");
10242                 ndr->depth++;
10243                 ndr_print_ptr(ndr, "idx", r->out.idx);
10244                 ndr->depth++;
10245                 ndr_print_uint32(ndr, "idx", *r->out.idx);
10246                 ndr->depth--;
10247                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10248                 ndr->depth--;
10249         }
10250         ndr->depth--;
10251 }
10252
10253 static enum ndr_err_code ndr_push_samr_CreateUser2(struct ndr_push *ndr, int flags, const struct samr_CreateUser2 *r)
10254 {
10255         if (flags & NDR_IN) {
10256                 if (r->in.domain_handle == NULL) {
10257                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10258                 }
10259                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10260                 if (r->in.account_name == NULL) {
10261                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10262                 }
10263                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
10264                 NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->in.acct_flags));
10265                 NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
10266         }
10267         if (flags & NDR_OUT) {
10268                 if (r->out.user_handle == NULL) {
10269                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10270                 }
10271                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
10272                 if (r->out.access_granted == NULL) {
10273                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10274                 }
10275                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.access_granted));
10276                 if (r->out.rid == NULL) {
10277                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10278                 }
10279                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
10280                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10281         }
10282         return NDR_ERR_SUCCESS;
10283 }
10284
10285 static enum ndr_err_code ndr_pull_samr_CreateUser2(struct ndr_pull *ndr, int flags, struct samr_CreateUser2 *r)
10286 {
10287         TALLOC_CTX *_mem_save_domain_handle_0;
10288         TALLOC_CTX *_mem_save_account_name_0;
10289         TALLOC_CTX *_mem_save_user_handle_0;
10290         TALLOC_CTX *_mem_save_access_granted_0;
10291         TALLOC_CTX *_mem_save_rid_0;
10292         if (flags & NDR_IN) {
10293                 ZERO_STRUCT(r->out);
10294
10295                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10296                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10297                 }
10298                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10299                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10300                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10301                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10302                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10303                         NDR_PULL_ALLOC(ndr, r->in.account_name);
10304                 }
10305                 _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10306                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account_name, LIBNDR_FLAG_REF_ALLOC);
10307                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
10308                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, LIBNDR_FLAG_REF_ALLOC);
10309                 NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->in.acct_flags));
10310                 NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
10311                 NDR_PULL_ALLOC(ndr, r->out.user_handle);
10312                 ZERO_STRUCTP(r->out.user_handle);
10313                 NDR_PULL_ALLOC(ndr, r->out.access_granted);
10314                 ZERO_STRUCTP(r->out.access_granted);
10315                 NDR_PULL_ALLOC(ndr, r->out.rid);
10316                 ZERO_STRUCTP(r->out.rid);
10317         }
10318         if (flags & NDR_OUT) {
10319                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10320                         NDR_PULL_ALLOC(ndr, r->out.user_handle);
10321                 }
10322                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10323                 NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
10324                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
10325                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
10326                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10327                         NDR_PULL_ALLOC(ndr, r->out.access_granted);
10328                 }
10329                 _mem_save_access_granted_0 = NDR_PULL_GET_MEM_CTX(ndr);
10330                 NDR_PULL_SET_MEM_CTX(ndr, r->out.access_granted, LIBNDR_FLAG_REF_ALLOC);
10331                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.access_granted));
10332                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_access_granted_0, LIBNDR_FLAG_REF_ALLOC);
10333                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10334                         NDR_PULL_ALLOC(ndr, r->out.rid);
10335                 }
10336                 _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
10337                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
10338                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
10339                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
10340                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10341         }
10342         return NDR_ERR_SUCCESS;
10343 }
10344
10345 _PUBLIC_ void ndr_print_samr_CreateUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateUser2 *r)
10346 {
10347         ndr_print_struct(ndr, name, "samr_CreateUser2");
10348         ndr->depth++;
10349         if (flags & NDR_SET_VALUES) {
10350                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10351         }
10352         if (flags & NDR_IN) {
10353                 ndr_print_struct(ndr, "in", "samr_CreateUser2");
10354                 ndr->depth++;
10355                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10356                 ndr->depth++;
10357                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10358                 ndr->depth--;
10359                 ndr_print_ptr(ndr, "account_name", r->in.account_name);
10360                 ndr->depth++;
10361                 ndr_print_lsa_String(ndr, "account_name", r->in.account_name);
10362                 ndr->depth--;
10363                 ndr_print_samr_AcctFlags(ndr, "acct_flags", r->in.acct_flags);
10364                 ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);
10365                 ndr->depth--;
10366         }
10367         if (flags & NDR_OUT) {
10368                 ndr_print_struct(ndr, "out", "samr_CreateUser2");
10369                 ndr->depth++;
10370                 ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
10371                 ndr->depth++;
10372                 ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
10373                 ndr->depth--;
10374                 ndr_print_ptr(ndr, "access_granted", r->out.access_granted);
10375                 ndr->depth++;
10376                 ndr_print_uint32(ndr, "access_granted", *r->out.access_granted);
10377                 ndr->depth--;
10378                 ndr_print_ptr(ndr, "rid", r->out.rid);
10379                 ndr->depth++;
10380                 ndr_print_uint32(ndr, "rid", *r->out.rid);
10381                 ndr->depth--;
10382                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10383                 ndr->depth--;
10384         }
10385         ndr->depth--;
10386 }
10387
10388 static enum ndr_err_code ndr_push_samr_QueryDisplayInfo3(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo3 *r)
10389 {
10390         if (flags & NDR_IN) {
10391                 if (r->in.domain_handle == NULL) {
10392                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10393                 }
10394                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10395                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
10396                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));
10397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));
10398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
10399         }
10400         if (flags & NDR_OUT) {
10401                 if (r->out.total_size == NULL) {
10402                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10403                 }
10404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));
10405                 if (r->out.returned_size == NULL) {
10406                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10407                 }
10408                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));
10409                 if (r->out.info == NULL) {
10410                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10411                 }
10412                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
10413                 NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
10414                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10415         }
10416         return NDR_ERR_SUCCESS;
10417 }
10418
10419 static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo3(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo3 *r)
10420 {
10421         TALLOC_CTX *_mem_save_domain_handle_0;
10422         TALLOC_CTX *_mem_save_total_size_0;
10423         TALLOC_CTX *_mem_save_returned_size_0;
10424         TALLOC_CTX *_mem_save_info_0;
10425         if (flags & NDR_IN) {
10426                 ZERO_STRUCT(r->out);
10427
10428                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10429                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
10430                 }
10431                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10432                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
10433                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
10434                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
10435                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10436                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));
10437                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));
10438                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
10439                 NDR_PULL_ALLOC(ndr, r->out.total_size);
10440                 ZERO_STRUCTP(r->out.total_size);
10441                 NDR_PULL_ALLOC(ndr, r->out.returned_size);
10442                 ZERO_STRUCTP(r->out.returned_size);
10443                 NDR_PULL_ALLOC(ndr, r->out.info);
10444                 ZERO_STRUCTP(r->out.info);
10445         }
10446         if (flags & NDR_OUT) {
10447                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10448                         NDR_PULL_ALLOC(ndr, r->out.total_size);
10449                 }
10450                 _mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
10451                 NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);
10452                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));
10453                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);
10454                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10455                         NDR_PULL_ALLOC(ndr, r->out.returned_size);
10456                 }
10457                 _mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
10458                 NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);
10459                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));
10460                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);
10461                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10462                         NDR_PULL_ALLOC(ndr, r->out.info);
10463                 }
10464                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10465                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
10466                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
10467                 NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
10468                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
10469                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10470         }
10471         return NDR_ERR_SUCCESS;
10472 }
10473
10474 _PUBLIC_ void ndr_print_samr_QueryDisplayInfo3(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo3 *r)
10475 {
10476         ndr_print_struct(ndr, name, "samr_QueryDisplayInfo3");
10477         ndr->depth++;
10478         if (flags & NDR_SET_VALUES) {
10479                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10480         }
10481         if (flags & NDR_IN) {
10482                 ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo3");
10483                 ndr->depth++;
10484                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
10485                 ndr->depth++;
10486                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
10487                 ndr->depth--;
10488                 ndr_print_uint16(ndr, "level", r->in.level);
10489                 ndr_print_uint32(ndr, "start_idx", r->in.start_idx);
10490                 ndr_print_uint32(ndr, "max_entries", r->in.max_entries);
10491                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
10492                 ndr->depth--;
10493         }
10494         if (flags & NDR_OUT) {
10495                 ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo3");
10496                 ndr->depth++;
10497                 ndr_print_ptr(ndr, "total_size", r->out.total_size);
10498                 ndr->depth++;
10499                 ndr_print_uint32(ndr, "total_size", *r->out.total_size);
10500                 ndr->depth--;
10501                 ndr_print_ptr(ndr, "returned_size", r->out.returned_size);
10502                 ndr->depth++;
10503                 ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);
10504                 ndr->depth--;
10505                 ndr_print_ptr(ndr, "info", r->out.info);
10506                 ndr->depth++;
10507                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
10508                 ndr_print_samr_DispInfo(ndr, "info", r->out.info);
10509                 ndr->depth--;
10510                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10511                 ndr->depth--;
10512         }
10513         ndr->depth--;
10514 }
10515
10516 static enum ndr_err_code ndr_push_samr_AddMultipleMembersToAlias(struct ndr_push *ndr, int flags, const struct samr_AddMultipleMembersToAlias *r)
10517 {
10518         if (flags & NDR_IN) {
10519                 if (r->in.alias_handle == NULL) {
10520                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10521                 }
10522                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
10523                 if (r->in.sids == NULL) {
10524                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10525                 }
10526                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10527         }
10528         if (flags & NDR_OUT) {
10529                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10530         }
10531         return NDR_ERR_SUCCESS;
10532 }
10533
10534 static enum ndr_err_code ndr_pull_samr_AddMultipleMembersToAlias(struct ndr_pull *ndr, int flags, struct samr_AddMultipleMembersToAlias *r)
10535 {
10536         TALLOC_CTX *_mem_save_alias_handle_0;
10537         TALLOC_CTX *_mem_save_sids_0;
10538         if (flags & NDR_IN) {
10539                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10540                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
10541                 }
10542                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10543                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
10544                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
10545                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
10546                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10547                         NDR_PULL_ALLOC(ndr, r->in.sids);
10548                 }
10549                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
10550                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
10551                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10552                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
10553         }
10554         if (flags & NDR_OUT) {
10555                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10556         }
10557         return NDR_ERR_SUCCESS;
10558 }
10559
10560 _PUBLIC_ void ndr_print_samr_AddMultipleMembersToAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddMultipleMembersToAlias *r)
10561 {
10562         ndr_print_struct(ndr, name, "samr_AddMultipleMembersToAlias");
10563         ndr->depth++;
10564         if (flags & NDR_SET_VALUES) {
10565                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10566         }
10567         if (flags & NDR_IN) {
10568                 ndr_print_struct(ndr, "in", "samr_AddMultipleMembersToAlias");
10569                 ndr->depth++;
10570                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
10571                 ndr->depth++;
10572                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
10573                 ndr->depth--;
10574                 ndr_print_ptr(ndr, "sids", r->in.sids);
10575                 ndr->depth++;
10576                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
10577                 ndr->depth--;
10578                 ndr->depth--;
10579         }
10580         if (flags & NDR_OUT) {
10581                 ndr_print_struct(ndr, "out", "samr_AddMultipleMembersToAlias");
10582                 ndr->depth++;
10583                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10584                 ndr->depth--;
10585         }
10586         ndr->depth--;
10587 }
10588
10589 static enum ndr_err_code ndr_push_samr_RemoveMultipleMembersFromAlias(struct ndr_push *ndr, int flags, const struct samr_RemoveMultipleMembersFromAlias *r)
10590 {
10591         if (flags & NDR_IN) {
10592                 if (r->in.alias_handle == NULL) {
10593                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10594                 }
10595                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
10596                 if (r->in.sids == NULL) {
10597                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10598                 }
10599                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10600         }
10601         if (flags & NDR_OUT) {
10602                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10603         }
10604         return NDR_ERR_SUCCESS;
10605 }
10606
10607 static enum ndr_err_code ndr_pull_samr_RemoveMultipleMembersFromAlias(struct ndr_pull *ndr, int flags, struct samr_RemoveMultipleMembersFromAlias *r)
10608 {
10609         TALLOC_CTX *_mem_save_alias_handle_0;
10610         TALLOC_CTX *_mem_save_sids_0;
10611         if (flags & NDR_IN) {
10612                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10613                         NDR_PULL_ALLOC(ndr, r->in.alias_handle);
10614                 }
10615                 _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10616                 NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
10617                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
10618                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
10619                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10620                         NDR_PULL_ALLOC(ndr, r->in.sids);
10621                 }
10622                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
10623                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
10624                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10625                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
10626         }
10627         if (flags & NDR_OUT) {
10628                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10629         }
10630         return NDR_ERR_SUCCESS;
10631 }
10632
10633 _PUBLIC_ void ndr_print_samr_RemoveMultipleMembersFromAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_RemoveMultipleMembersFromAlias *r)
10634 {
10635         ndr_print_struct(ndr, name, "samr_RemoveMultipleMembersFromAlias");
10636         ndr->depth++;
10637         if (flags & NDR_SET_VALUES) {
10638                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10639         }
10640         if (flags & NDR_IN) {
10641                 ndr_print_struct(ndr, "in", "samr_RemoveMultipleMembersFromAlias");
10642                 ndr->depth++;
10643                 ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
10644                 ndr->depth++;
10645                 ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
10646                 ndr->depth--;
10647                 ndr_print_ptr(ndr, "sids", r->in.sids);
10648                 ndr->depth++;
10649                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
10650                 ndr->depth--;
10651                 ndr->depth--;
10652         }
10653         if (flags & NDR_OUT) {
10654                 ndr_print_struct(ndr, "out", "samr_RemoveMultipleMembersFromAlias");
10655                 ndr->depth++;
10656                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10657                 ndr->depth--;
10658         }
10659         ndr->depth--;
10660 }
10661
10662 static enum ndr_err_code ndr_push_samr_OemChangePasswordUser2(struct ndr_push *ndr, int flags, const struct samr_OemChangePasswordUser2 *r)
10663 {
10664         if (flags & NDR_IN) {
10665                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
10666                 if (r->in.server) {
10667                         NDR_CHECK(ndr_push_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
10668                 }
10669                 if (r->in.account == NULL) {
10670                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10671                 }
10672                 NDR_CHECK(ndr_push_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
10673                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
10674                 if (r->in.password) {
10675                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password));
10676                 }
10677                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hash));
10678                 if (r->in.hash) {
10679                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.hash));
10680                 }
10681         }
10682         if (flags & NDR_OUT) {
10683                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10684         }
10685         return NDR_ERR_SUCCESS;
10686 }
10687
10688 static enum ndr_err_code ndr_pull_samr_OemChangePasswordUser2(struct ndr_pull *ndr, int flags, struct samr_OemChangePasswordUser2 *r)
10689 {
10690         uint32_t _ptr_server;
10691         uint32_t _ptr_password;
10692         uint32_t _ptr_hash;
10693         TALLOC_CTX *_mem_save_server_0;
10694         TALLOC_CTX *_mem_save_account_0;
10695         TALLOC_CTX *_mem_save_password_0;
10696         TALLOC_CTX *_mem_save_hash_0;
10697         if (flags & NDR_IN) {
10698                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
10699                 if (_ptr_server) {
10700                         NDR_PULL_ALLOC(ndr, r->in.server);
10701                 } else {
10702                         r->in.server = NULL;
10703                 }
10704                 if (r->in.server) {
10705                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
10706                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
10707                         NDR_CHECK(ndr_pull_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
10708                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
10709                 }
10710                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10711                         NDR_PULL_ALLOC(ndr, r->in.account);
10712                 }
10713                 _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
10714                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);
10715                 NDR_CHECK(ndr_pull_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
10716                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);
10717                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
10718                 if (_ptr_password) {
10719                         NDR_PULL_ALLOC(ndr, r->in.password);
10720                 } else {
10721                         r->in.password = NULL;
10722                 }
10723                 if (r->in.password) {
10724                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
10725                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
10726                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password));
10727                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
10728                 }
10729                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hash));
10730                 if (_ptr_hash) {
10731                         NDR_PULL_ALLOC(ndr, r->in.hash);
10732                 } else {
10733                         r->in.hash = NULL;
10734                 }
10735                 if (r->in.hash) {
10736                         _mem_save_hash_0 = NDR_PULL_GET_MEM_CTX(ndr);
10737                         NDR_PULL_SET_MEM_CTX(ndr, r->in.hash, 0);
10738                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.hash));
10739                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hash_0, 0);
10740                 }
10741         }
10742         if (flags & NDR_OUT) {
10743                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10744         }
10745         return NDR_ERR_SUCCESS;
10746 }
10747
10748 _PUBLIC_ void ndr_print_samr_OemChangePasswordUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_OemChangePasswordUser2 *r)
10749 {
10750         ndr_print_struct(ndr, name, "samr_OemChangePasswordUser2");
10751         ndr->depth++;
10752         if (flags & NDR_SET_VALUES) {
10753                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10754         }
10755         if (flags & NDR_IN) {
10756                 ndr_print_struct(ndr, "in", "samr_OemChangePasswordUser2");
10757                 ndr->depth++;
10758                 ndr_print_ptr(ndr, "server", r->in.server);
10759                 ndr->depth++;
10760                 if (r->in.server) {
10761                         ndr_print_lsa_AsciiString(ndr, "server", r->in.server);
10762                 }
10763                 ndr->depth--;
10764                 ndr_print_ptr(ndr, "account", r->in.account);
10765                 ndr->depth++;
10766                 ndr_print_lsa_AsciiString(ndr, "account", r->in.account);
10767                 ndr->depth--;
10768                 ndr_print_ptr(ndr, "password", r->in.password);
10769                 ndr->depth++;
10770                 if (r->in.password) {
10771                         ndr_print_samr_CryptPassword(ndr, "password", r->in.password);
10772                 }
10773                 ndr->depth--;
10774                 ndr_print_ptr(ndr, "hash", r->in.hash);
10775                 ndr->depth++;
10776                 if (r->in.hash) {
10777                         ndr_print_samr_Password(ndr, "hash", r->in.hash);
10778                 }
10779                 ndr->depth--;
10780                 ndr->depth--;
10781         }
10782         if (flags & NDR_OUT) {
10783                 ndr_print_struct(ndr, "out", "samr_OemChangePasswordUser2");
10784                 ndr->depth++;
10785                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10786                 ndr->depth--;
10787         }
10788         ndr->depth--;
10789 }
10790
10791 static enum ndr_err_code ndr_push_samr_ChangePasswordUser2(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser2 *r)
10792 {
10793         if (flags & NDR_IN) {
10794                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
10795                 if (r->in.server) {
10796                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
10797                 }
10798                 if (r->in.account == NULL) {
10799                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10800                 }
10801                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
10802                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_password));
10803                 if (r->in.nt_password) {
10804                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
10805                 }
10806                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_verifier));
10807                 if (r->in.nt_verifier) {
10808                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
10809                 }
10810                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_change));
10811                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_password));
10812                 if (r->in.lm_password) {
10813                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
10814                 }
10815                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_verifier));
10816                 if (r->in.lm_verifier) {
10817                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
10818                 }
10819         }
10820         if (flags & NDR_OUT) {
10821                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10822         }
10823         return NDR_ERR_SUCCESS;
10824 }
10825
10826 static enum ndr_err_code ndr_pull_samr_ChangePasswordUser2(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser2 *r)
10827 {
10828         uint32_t _ptr_server;
10829         uint32_t _ptr_nt_password;
10830         uint32_t _ptr_nt_verifier;
10831         uint32_t _ptr_lm_password;
10832         uint32_t _ptr_lm_verifier;
10833         TALLOC_CTX *_mem_save_server_0;
10834         TALLOC_CTX *_mem_save_account_0;
10835         TALLOC_CTX *_mem_save_nt_password_0;
10836         TALLOC_CTX *_mem_save_nt_verifier_0;
10837         TALLOC_CTX *_mem_save_lm_password_0;
10838         TALLOC_CTX *_mem_save_lm_verifier_0;
10839         if (flags & NDR_IN) {
10840                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
10841                 if (_ptr_server) {
10842                         NDR_PULL_ALLOC(ndr, r->in.server);
10843                 } else {
10844                         r->in.server = NULL;
10845                 }
10846                 if (r->in.server) {
10847                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
10848                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
10849                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
10850                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
10851                 }
10852                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10853                         NDR_PULL_ALLOC(ndr, r->in.account);
10854                 }
10855                 _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
10856                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);
10857                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
10858                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);
10859                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_password));
10860                 if (_ptr_nt_password) {
10861                         NDR_PULL_ALLOC(ndr, r->in.nt_password);
10862                 } else {
10863                         r->in.nt_password = NULL;
10864                 }
10865                 if (r->in.nt_password) {
10866                         _mem_save_nt_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
10867                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_password, 0);
10868                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
10869                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_password_0, 0);
10870                 }
10871                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_verifier));
10872                 if (_ptr_nt_verifier) {
10873                         NDR_PULL_ALLOC(ndr, r->in.nt_verifier);
10874                 } else {
10875                         r->in.nt_verifier = NULL;
10876                 }
10877                 if (r->in.nt_verifier) {
10878                         _mem_save_nt_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
10879                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_verifier, 0);
10880                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
10881                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_verifier_0, 0);
10882                 }
10883                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_change));
10884                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_password));
10885                 if (_ptr_lm_password) {
10886                         NDR_PULL_ALLOC(ndr, r->in.lm_password);
10887                 } else {
10888                         r->in.lm_password = NULL;
10889                 }
10890                 if (r->in.lm_password) {
10891                         _mem_save_lm_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
10892                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_password, 0);
10893                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
10894                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_password_0, 0);
10895                 }
10896                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_verifier));
10897                 if (_ptr_lm_verifier) {
10898                         NDR_PULL_ALLOC(ndr, r->in.lm_verifier);
10899                 } else {
10900                         r->in.lm_verifier = NULL;
10901                 }
10902                 if (r->in.lm_verifier) {
10903                         _mem_save_lm_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
10904                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_verifier, 0);
10905                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
10906                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_verifier_0, 0);
10907                 }
10908         }
10909         if (flags & NDR_OUT) {
10910                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10911         }
10912         return NDR_ERR_SUCCESS;
10913 }
10914
10915 _PUBLIC_ void ndr_print_samr_ChangePasswordUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser2 *r)
10916 {
10917         ndr_print_struct(ndr, name, "samr_ChangePasswordUser2");
10918         ndr->depth++;
10919         if (flags & NDR_SET_VALUES) {
10920                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10921         }
10922         if (flags & NDR_IN) {
10923                 ndr_print_struct(ndr, "in", "samr_ChangePasswordUser2");
10924                 ndr->depth++;
10925                 ndr_print_ptr(ndr, "server", r->in.server);
10926                 ndr->depth++;
10927                 if (r->in.server) {
10928                         ndr_print_lsa_String(ndr, "server", r->in.server);
10929                 }
10930                 ndr->depth--;
10931                 ndr_print_ptr(ndr, "account", r->in.account);
10932                 ndr->depth++;
10933                 ndr_print_lsa_String(ndr, "account", r->in.account);
10934                 ndr->depth--;
10935                 ndr_print_ptr(ndr, "nt_password", r->in.nt_password);
10936                 ndr->depth++;
10937                 if (r->in.nt_password) {
10938                         ndr_print_samr_CryptPassword(ndr, "nt_password", r->in.nt_password);
10939                 }
10940                 ndr->depth--;
10941                 ndr_print_ptr(ndr, "nt_verifier", r->in.nt_verifier);
10942                 ndr->depth++;
10943                 if (r->in.nt_verifier) {
10944                         ndr_print_samr_Password(ndr, "nt_verifier", r->in.nt_verifier);
10945                 }
10946                 ndr->depth--;
10947                 ndr_print_uint8(ndr, "lm_change", r->in.lm_change);
10948                 ndr_print_ptr(ndr, "lm_password", r->in.lm_password);
10949                 ndr->depth++;
10950                 if (r->in.lm_password) {
10951                         ndr_print_samr_CryptPassword(ndr, "lm_password", r->in.lm_password);
10952                 }
10953                 ndr->depth--;
10954                 ndr_print_ptr(ndr, "lm_verifier", r->in.lm_verifier);
10955                 ndr->depth++;
10956                 if (r->in.lm_verifier) {
10957                         ndr_print_samr_Password(ndr, "lm_verifier", r->in.lm_verifier);
10958                 }
10959                 ndr->depth--;
10960                 ndr->depth--;
10961         }
10962         if (flags & NDR_OUT) {
10963                 ndr_print_struct(ndr, "out", "samr_ChangePasswordUser2");
10964                 ndr->depth++;
10965                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10966                 ndr->depth--;
10967         }
10968         ndr->depth--;
10969 }
10970
10971 static enum ndr_err_code ndr_push_samr_GetDomPwInfo(struct ndr_push *ndr, int flags, const struct samr_GetDomPwInfo *r)
10972 {
10973         if (flags & NDR_IN) {
10974                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.domain_name));
10975                 if (r->in.domain_name) {
10976                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
10977                 }
10978         }
10979         if (flags & NDR_OUT) {
10980                 if (r->out.info == NULL) {
10981                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10982                 }
10983                 NDR_CHECK(ndr_push_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
10984                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10985         }
10986         return NDR_ERR_SUCCESS;
10987 }
10988
10989 static enum ndr_err_code ndr_pull_samr_GetDomPwInfo(struct ndr_pull *ndr, int flags, struct samr_GetDomPwInfo *r)
10990 {
10991         uint32_t _ptr_domain_name;
10992         TALLOC_CTX *_mem_save_domain_name_0;
10993         TALLOC_CTX *_mem_save_info_0;
10994         if (flags & NDR_IN) {
10995                 ZERO_STRUCT(r->out);
10996
10997                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
10998                 if (_ptr_domain_name) {
10999                         NDR_PULL_ALLOC(ndr, r->in.domain_name);
11000                 } else {
11001                         r->in.domain_name = NULL;
11002                 }
11003                 if (r->in.domain_name) {
11004                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11005                         NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_name, 0);
11006                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
11007                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
11008                 }
11009                 NDR_PULL_ALLOC(ndr, r->out.info);
11010                 ZERO_STRUCTP(r->out.info);
11011         }
11012         if (flags & NDR_OUT) {
11013                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11014                         NDR_PULL_ALLOC(ndr, r->out.info);
11015                 }
11016                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
11017                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
11018                 NDR_CHECK(ndr_pull_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
11019                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
11020                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11021         }
11022         return NDR_ERR_SUCCESS;
11023 }
11024
11025 _PUBLIC_ void ndr_print_samr_GetDomPwInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDomPwInfo *r)
11026 {
11027         ndr_print_struct(ndr, name, "samr_GetDomPwInfo");
11028         ndr->depth++;
11029         if (flags & NDR_SET_VALUES) {
11030                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11031         }
11032         if (flags & NDR_IN) {
11033                 ndr_print_struct(ndr, "in", "samr_GetDomPwInfo");
11034                 ndr->depth++;
11035                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
11036                 ndr->depth++;
11037                 if (r->in.domain_name) {
11038                         ndr_print_lsa_String(ndr, "domain_name", r->in.domain_name);
11039                 }
11040                 ndr->depth--;
11041                 ndr->depth--;
11042         }
11043         if (flags & NDR_OUT) {
11044                 ndr_print_struct(ndr, "out", "samr_GetDomPwInfo");
11045                 ndr->depth++;
11046                 ndr_print_ptr(ndr, "info", r->out.info);
11047                 ndr->depth++;
11048                 ndr_print_samr_PwInfo(ndr, "info", r->out.info);
11049                 ndr->depth--;
11050                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11051                 ndr->depth--;
11052         }
11053         ndr->depth--;
11054 }
11055
11056 static enum ndr_err_code ndr_push_samr_Connect2(struct ndr_push *ndr, int flags, const struct samr_Connect2 *r)
11057 {
11058         if (flags & NDR_IN) {
11059                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
11060                 if (r->in.system_name) {
11061                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11062                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11063                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11064                         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));
11065                 }
11066                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
11067         }
11068         if (flags & NDR_OUT) {
11069                 if (r->out.connect_handle == NULL) {
11070                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11071                 }
11072                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11073                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11074         }
11075         return NDR_ERR_SUCCESS;
11076 }
11077
11078 static enum ndr_err_code ndr_pull_samr_Connect2(struct ndr_pull *ndr, int flags, struct samr_Connect2 *r)
11079 {
11080         uint32_t _ptr_system_name;
11081         uint32_t size_system_name_1 = 0;
11082         uint32_t length_system_name_1 = 0;
11083         TALLOC_CTX *_mem_save_system_name_0;
11084         TALLOC_CTX *_mem_save_connect_handle_0;
11085         if (flags & NDR_IN) {
11086                 ZERO_STRUCT(r->out);
11087
11088                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
11089                 if (_ptr_system_name) {
11090                         NDR_PULL_ALLOC(ndr, r->in.system_name);
11091                 } else {
11092                         r->in.system_name = NULL;
11093                 }
11094                 if (r->in.system_name) {
11095                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11096                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
11097                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
11098                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
11099                         size_system_name_1 = ndr_get_array_size(ndr, &r->in.system_name);
11100                         length_system_name_1 = ndr_get_array_length(ndr, &r->in.system_name);
11101                         if (length_system_name_1 > size_system_name_1) {
11102                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_system_name_1, length_system_name_1);
11103                         }
11104                         NDR_CHECK(ndr_check_string_terminator(ndr, length_system_name_1, sizeof(uint16_t)));
11105                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, length_system_name_1, sizeof(uint16_t), CH_UTF16));
11106                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
11107                 }
11108                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
11109                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11110                 ZERO_STRUCTP(r->out.connect_handle);
11111         }
11112         if (flags & NDR_OUT) {
11113                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11114                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11115                 }
11116                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11117                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
11118                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11119                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
11120                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11121         }
11122         return NDR_ERR_SUCCESS;
11123 }
11124
11125 _PUBLIC_ void ndr_print_samr_Connect2(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect2 *r)
11126 {
11127         ndr_print_struct(ndr, name, "samr_Connect2");
11128         ndr->depth++;
11129         if (flags & NDR_SET_VALUES) {
11130                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11131         }
11132         if (flags & NDR_IN) {
11133                 ndr_print_struct(ndr, "in", "samr_Connect2");
11134                 ndr->depth++;
11135                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
11136                 ndr->depth++;
11137                 if (r->in.system_name) {
11138                         ndr_print_string(ndr, "system_name", r->in.system_name);
11139                 }
11140                 ndr->depth--;
11141                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
11142                 ndr->depth--;
11143         }
11144         if (flags & NDR_OUT) {
11145                 ndr_print_struct(ndr, "out", "samr_Connect2");
11146                 ndr->depth++;
11147                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
11148                 ndr->depth++;
11149                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
11150                 ndr->depth--;
11151                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11152                 ndr->depth--;
11153         }
11154         ndr->depth--;
11155 }
11156
11157 _PUBLIC_ enum ndr_err_code ndr_push_samr_SetUserInfo2(struct ndr_push *ndr, int flags, const struct samr_SetUserInfo2 *r)
11158 {
11159         if (flags & NDR_IN) {
11160                 if (r->in.user_handle == NULL) {
11161                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11162                 }
11163                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
11164                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
11165                 if (r->in.info == NULL) {
11166                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11167                 }
11168                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
11169                 NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
11170         }
11171         if (flags & NDR_OUT) {
11172                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11173         }
11174         return NDR_ERR_SUCCESS;
11175 }
11176
11177 _PUBLIC_ enum ndr_err_code ndr_pull_samr_SetUserInfo2(struct ndr_pull *ndr, int flags, struct samr_SetUserInfo2 *r)
11178 {
11179         TALLOC_CTX *_mem_save_user_handle_0;
11180         TALLOC_CTX *_mem_save_info_0;
11181         if (flags & NDR_IN) {
11182                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11183                         NDR_PULL_ALLOC(ndr, r->in.user_handle);
11184                 }
11185                 _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11186                 NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
11187                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
11188                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
11189                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
11190                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11191                         NDR_PULL_ALLOC(ndr, r->in.info);
11192                 }
11193                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
11194                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
11195                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
11196                 NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
11197                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
11198         }
11199         if (flags & NDR_OUT) {
11200                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11201         }
11202         return NDR_ERR_SUCCESS;
11203 }
11204
11205 _PUBLIC_ void ndr_print_samr_SetUserInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetUserInfo2 *r)
11206 {
11207         ndr_print_struct(ndr, name, "samr_SetUserInfo2");
11208         ndr->depth++;
11209         if (flags & NDR_SET_VALUES) {
11210                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11211         }
11212         if (flags & NDR_IN) {
11213                 ndr_print_struct(ndr, "in", "samr_SetUserInfo2");
11214                 ndr->depth++;
11215                 ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
11216                 ndr->depth++;
11217                 ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
11218                 ndr->depth--;
11219                 ndr_print_uint16(ndr, "level", r->in.level);
11220                 ndr_print_ptr(ndr, "info", r->in.info);
11221                 ndr->depth++;
11222                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
11223                 ndr_print_samr_UserInfo(ndr, "info", r->in.info);
11224                 ndr->depth--;
11225                 ndr->depth--;
11226         }
11227         if (flags & NDR_OUT) {
11228                 ndr_print_struct(ndr, "out", "samr_SetUserInfo2");
11229                 ndr->depth++;
11230                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11231                 ndr->depth--;
11232         }
11233         ndr->depth--;
11234 }
11235
11236 static enum ndr_err_code ndr_push_samr_SetBootKeyInformation(struct ndr_push *ndr, int flags, const struct samr_SetBootKeyInformation *r)
11237 {
11238         if (flags & NDR_IN) {
11239                 if (r->in.connect_handle == NULL) {
11240                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11241                 }
11242                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
11243                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
11244                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
11245                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown3));
11246         }
11247         if (flags & NDR_OUT) {
11248                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11249         }
11250         return NDR_ERR_SUCCESS;
11251 }
11252
11253 static enum ndr_err_code ndr_pull_samr_SetBootKeyInformation(struct ndr_pull *ndr, int flags, struct samr_SetBootKeyInformation *r)
11254 {
11255         TALLOC_CTX *_mem_save_connect_handle_0;
11256         if (flags & NDR_IN) {
11257                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11258                         NDR_PULL_ALLOC(ndr, r->in.connect_handle);
11259                 }
11260                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11261                 NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
11262                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
11263                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
11264                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
11265                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
11266                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown3));
11267         }
11268         if (flags & NDR_OUT) {
11269                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11270         }
11271         return NDR_ERR_SUCCESS;
11272 }
11273
11274 _PUBLIC_ void ndr_print_samr_SetBootKeyInformation(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetBootKeyInformation *r)
11275 {
11276         ndr_print_struct(ndr, name, "samr_SetBootKeyInformation");
11277         ndr->depth++;
11278         if (flags & NDR_SET_VALUES) {
11279                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11280         }
11281         if (flags & NDR_IN) {
11282                 ndr_print_struct(ndr, "in", "samr_SetBootKeyInformation");
11283                 ndr->depth++;
11284                 ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
11285                 ndr->depth++;
11286                 ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
11287                 ndr->depth--;
11288                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
11289                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
11290                 ndr_print_uint32(ndr, "unknown3", r->in.unknown3);
11291                 ndr->depth--;
11292         }
11293         if (flags & NDR_OUT) {
11294                 ndr_print_struct(ndr, "out", "samr_SetBootKeyInformation");
11295                 ndr->depth++;
11296                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11297                 ndr->depth--;
11298         }
11299         ndr->depth--;
11300 }
11301
11302 static enum ndr_err_code ndr_push_samr_GetBootKeyInformation(struct ndr_push *ndr, int flags, const struct samr_GetBootKeyInformation *r)
11303 {
11304         if (flags & NDR_IN) {
11305                 if (r->in.domain_handle == NULL) {
11306                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11307                 }
11308                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
11309         }
11310         if (flags & NDR_OUT) {
11311                 if (r->out.unknown == NULL) {
11312                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11313                 }
11314                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.unknown));
11315                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11316         }
11317         return NDR_ERR_SUCCESS;
11318 }
11319
11320 static enum ndr_err_code ndr_pull_samr_GetBootKeyInformation(struct ndr_pull *ndr, int flags, struct samr_GetBootKeyInformation *r)
11321 {
11322         TALLOC_CTX *_mem_save_domain_handle_0;
11323         TALLOC_CTX *_mem_save_unknown_0;
11324         if (flags & NDR_IN) {
11325                 ZERO_STRUCT(r->out);
11326
11327                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11328                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
11329                 }
11330                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11331                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
11332                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
11333                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
11334                 NDR_PULL_ALLOC(ndr, r->out.unknown);
11335                 ZERO_STRUCTP(r->out.unknown);
11336         }
11337         if (flags & NDR_OUT) {
11338                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11339                         NDR_PULL_ALLOC(ndr, r->out.unknown);
11340                 }
11341                 _mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);
11342                 NDR_PULL_SET_MEM_CTX(ndr, r->out.unknown, LIBNDR_FLAG_REF_ALLOC);
11343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.unknown));
11344                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, LIBNDR_FLAG_REF_ALLOC);
11345                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11346         }
11347         return NDR_ERR_SUCCESS;
11348 }
11349
11350 _PUBLIC_ void ndr_print_samr_GetBootKeyInformation(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetBootKeyInformation *r)
11351 {
11352         ndr_print_struct(ndr, name, "samr_GetBootKeyInformation");
11353         ndr->depth++;
11354         if (flags & NDR_SET_VALUES) {
11355                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11356         }
11357         if (flags & NDR_IN) {
11358                 ndr_print_struct(ndr, "in", "samr_GetBootKeyInformation");
11359                 ndr->depth++;
11360                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
11361                 ndr->depth++;
11362                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
11363                 ndr->depth--;
11364                 ndr->depth--;
11365         }
11366         if (flags & NDR_OUT) {
11367                 ndr_print_struct(ndr, "out", "samr_GetBootKeyInformation");
11368                 ndr->depth++;
11369                 ndr_print_ptr(ndr, "unknown", r->out.unknown);
11370                 ndr->depth++;
11371                 ndr_print_uint32(ndr, "unknown", *r->out.unknown);
11372                 ndr->depth--;
11373                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11374                 ndr->depth--;
11375         }
11376         ndr->depth--;
11377 }
11378
11379 static enum ndr_err_code ndr_push_samr_Connect3(struct ndr_push *ndr, int flags, const struct samr_Connect3 *r)
11380 {
11381         if (flags & NDR_IN) {
11382                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
11383                 if (r->in.system_name) {
11384                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11385                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11386                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11387                         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));
11388                 }
11389                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
11390                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
11391         }
11392         if (flags & NDR_OUT) {
11393                 if (r->out.connect_handle == NULL) {
11394                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11395                 }
11396                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11397                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11398         }
11399         return NDR_ERR_SUCCESS;
11400 }
11401
11402 static enum ndr_err_code ndr_pull_samr_Connect3(struct ndr_pull *ndr, int flags, struct samr_Connect3 *r)
11403 {
11404         uint32_t _ptr_system_name;
11405         uint32_t size_system_name_1 = 0;
11406         uint32_t length_system_name_1 = 0;
11407         TALLOC_CTX *_mem_save_system_name_0;
11408         TALLOC_CTX *_mem_save_connect_handle_0;
11409         if (flags & NDR_IN) {
11410                 ZERO_STRUCT(r->out);
11411
11412                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
11413                 if (_ptr_system_name) {
11414                         NDR_PULL_ALLOC(ndr, r->in.system_name);
11415                 } else {
11416                         r->in.system_name = NULL;
11417                 }
11418                 if (r->in.system_name) {
11419                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11420                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
11421                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
11422                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
11423                         size_system_name_1 = ndr_get_array_size(ndr, &r->in.system_name);
11424                         length_system_name_1 = ndr_get_array_length(ndr, &r->in.system_name);
11425                         if (length_system_name_1 > size_system_name_1) {
11426                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_system_name_1, length_system_name_1);
11427                         }
11428                         NDR_CHECK(ndr_check_string_terminator(ndr, length_system_name_1, sizeof(uint16_t)));
11429                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, length_system_name_1, sizeof(uint16_t), CH_UTF16));
11430                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
11431                 }
11432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
11433                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
11434                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11435                 ZERO_STRUCTP(r->out.connect_handle);
11436         }
11437         if (flags & NDR_OUT) {
11438                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11439                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11440                 }
11441                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11442                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
11443                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11444                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
11445                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11446         }
11447         return NDR_ERR_SUCCESS;
11448 }
11449
11450 _PUBLIC_ void ndr_print_samr_Connect3(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect3 *r)
11451 {
11452         ndr_print_struct(ndr, name, "samr_Connect3");
11453         ndr->depth++;
11454         if (flags & NDR_SET_VALUES) {
11455                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11456         }
11457         if (flags & NDR_IN) {
11458                 ndr_print_struct(ndr, "in", "samr_Connect3");
11459                 ndr->depth++;
11460                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
11461                 ndr->depth++;
11462                 if (r->in.system_name) {
11463                         ndr_print_string(ndr, "system_name", r->in.system_name);
11464                 }
11465                 ndr->depth--;
11466                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
11467                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
11468                 ndr->depth--;
11469         }
11470         if (flags & NDR_OUT) {
11471                 ndr_print_struct(ndr, "out", "samr_Connect3");
11472                 ndr->depth++;
11473                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
11474                 ndr->depth++;
11475                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
11476                 ndr->depth--;
11477                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11478                 ndr->depth--;
11479         }
11480         ndr->depth--;
11481 }
11482
11483 static enum ndr_err_code ndr_push_samr_Connect4(struct ndr_push *ndr, int flags, const struct samr_Connect4 *r)
11484 {
11485         if (flags & NDR_IN) {
11486                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
11487                 if (r->in.system_name) {
11488                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11489                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11490                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11491                         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));
11492                 }
11493                 NDR_CHECK(ndr_push_samr_ConnectVersion(ndr, NDR_SCALARS, r->in.client_version));
11494                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
11495         }
11496         if (flags & NDR_OUT) {
11497                 if (r->out.connect_handle == NULL) {
11498                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11499                 }
11500                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11501                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11502         }
11503         return NDR_ERR_SUCCESS;
11504 }
11505
11506 static enum ndr_err_code ndr_pull_samr_Connect4(struct ndr_pull *ndr, int flags, struct samr_Connect4 *r)
11507 {
11508         uint32_t _ptr_system_name;
11509         uint32_t size_system_name_1 = 0;
11510         uint32_t length_system_name_1 = 0;
11511         TALLOC_CTX *_mem_save_system_name_0;
11512         TALLOC_CTX *_mem_save_connect_handle_0;
11513         if (flags & NDR_IN) {
11514                 ZERO_STRUCT(r->out);
11515
11516                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
11517                 if (_ptr_system_name) {
11518                         NDR_PULL_ALLOC(ndr, r->in.system_name);
11519                 } else {
11520                         r->in.system_name = NULL;
11521                 }
11522                 if (r->in.system_name) {
11523                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11524                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
11525                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
11526                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
11527                         size_system_name_1 = ndr_get_array_size(ndr, &r->in.system_name);
11528                         length_system_name_1 = ndr_get_array_length(ndr, &r->in.system_name);
11529                         if (length_system_name_1 > size_system_name_1) {
11530                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_system_name_1, length_system_name_1);
11531                         }
11532                         NDR_CHECK(ndr_check_string_terminator(ndr, length_system_name_1, sizeof(uint16_t)));
11533                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, length_system_name_1, sizeof(uint16_t), CH_UTF16));
11534                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
11535                 }
11536                 NDR_CHECK(ndr_pull_samr_ConnectVersion(ndr, NDR_SCALARS, &r->in.client_version));
11537                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
11538                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11539                 ZERO_STRUCTP(r->out.connect_handle);
11540         }
11541         if (flags & NDR_OUT) {
11542                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11543                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11544                 }
11545                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11546                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
11547                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11548                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
11549                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11550         }
11551         return NDR_ERR_SUCCESS;
11552 }
11553
11554 _PUBLIC_ void ndr_print_samr_Connect4(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect4 *r)
11555 {
11556         ndr_print_struct(ndr, name, "samr_Connect4");
11557         ndr->depth++;
11558         if (flags & NDR_SET_VALUES) {
11559                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11560         }
11561         if (flags & NDR_IN) {
11562                 ndr_print_struct(ndr, "in", "samr_Connect4");
11563                 ndr->depth++;
11564                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
11565                 ndr->depth++;
11566                 if (r->in.system_name) {
11567                         ndr_print_string(ndr, "system_name", r->in.system_name);
11568                 }
11569                 ndr->depth--;
11570                 ndr_print_samr_ConnectVersion(ndr, "client_version", r->in.client_version);
11571                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
11572                 ndr->depth--;
11573         }
11574         if (flags & NDR_OUT) {
11575                 ndr_print_struct(ndr, "out", "samr_Connect4");
11576                 ndr->depth++;
11577                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
11578                 ndr->depth++;
11579                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
11580                 ndr->depth--;
11581                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11582                 ndr->depth--;
11583         }
11584         ndr->depth--;
11585 }
11586
11587 static enum ndr_err_code ndr_push_samr_ChangePasswordUser3(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser3 *r)
11588 {
11589         if (flags & NDR_IN) {
11590                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
11591                 if (r->in.server) {
11592                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
11593                 }
11594                 if (r->in.account == NULL) {
11595                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11596                 }
11597                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
11598                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_password));
11599                 if (r->in.nt_password) {
11600                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
11601                 }
11602                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_verifier));
11603                 if (r->in.nt_verifier) {
11604                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
11605                 }
11606                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_change));
11607                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_password));
11608                 if (r->in.lm_password) {
11609                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
11610                 }
11611                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_verifier));
11612                 if (r->in.lm_verifier) {
11613                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
11614                 }
11615                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password3));
11616                 if (r->in.password3) {
11617                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password3));
11618                 }
11619         }
11620         if (flags & NDR_OUT) {
11621                 if (r->out.dominfo == NULL) {
11622                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11623                 }
11624                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.dominfo));
11625                 if (*r->out.dominfo) {
11626                         NDR_CHECK(ndr_push_samr_DomInfo1(ndr, NDR_SCALARS, *r->out.dominfo));
11627                 }
11628                 if (r->out.reject == NULL) {
11629                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11630                 }
11631                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.reject));
11632                 if (*r->out.reject) {
11633                         NDR_CHECK(ndr_push_samr_ChangeReject(ndr, NDR_SCALARS, *r->out.reject));
11634                 }
11635                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11636         }
11637         return NDR_ERR_SUCCESS;
11638 }
11639
11640 static enum ndr_err_code ndr_pull_samr_ChangePasswordUser3(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser3 *r)
11641 {
11642         uint32_t _ptr_server;
11643         uint32_t _ptr_nt_password;
11644         uint32_t _ptr_nt_verifier;
11645         uint32_t _ptr_lm_password;
11646         uint32_t _ptr_lm_verifier;
11647         uint32_t _ptr_password3;
11648         uint32_t _ptr_dominfo;
11649         uint32_t _ptr_reject;
11650         TALLOC_CTX *_mem_save_server_0;
11651         TALLOC_CTX *_mem_save_account_0;
11652         TALLOC_CTX *_mem_save_nt_password_0;
11653         TALLOC_CTX *_mem_save_nt_verifier_0;
11654         TALLOC_CTX *_mem_save_lm_password_0;
11655         TALLOC_CTX *_mem_save_lm_verifier_0;
11656         TALLOC_CTX *_mem_save_password3_0;
11657         TALLOC_CTX *_mem_save_dominfo_0;
11658         TALLOC_CTX *_mem_save_dominfo_1;
11659         TALLOC_CTX *_mem_save_reject_0;
11660         TALLOC_CTX *_mem_save_reject_1;
11661         if (flags & NDR_IN) {
11662                 ZERO_STRUCT(r->out);
11663
11664                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
11665                 if (_ptr_server) {
11666                         NDR_PULL_ALLOC(ndr, r->in.server);
11667                 } else {
11668                         r->in.server = NULL;
11669                 }
11670                 if (r->in.server) {
11671                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
11672                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
11673                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
11674                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
11675                 }
11676                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11677                         NDR_PULL_ALLOC(ndr, r->in.account);
11678                 }
11679                 _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
11680                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);
11681                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
11682                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);
11683                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_password));
11684                 if (_ptr_nt_password) {
11685                         NDR_PULL_ALLOC(ndr, r->in.nt_password);
11686                 } else {
11687                         r->in.nt_password = NULL;
11688                 }
11689                 if (r->in.nt_password) {
11690                         _mem_save_nt_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
11691                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_password, 0);
11692                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
11693                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_password_0, 0);
11694                 }
11695                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_verifier));
11696                 if (_ptr_nt_verifier) {
11697                         NDR_PULL_ALLOC(ndr, r->in.nt_verifier);
11698                 } else {
11699                         r->in.nt_verifier = NULL;
11700                 }
11701                 if (r->in.nt_verifier) {
11702                         _mem_save_nt_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
11703                         NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_verifier, 0);
11704                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
11705                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_verifier_0, 0);
11706                 }
11707                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_change));
11708                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_password));
11709                 if (_ptr_lm_password) {
11710                         NDR_PULL_ALLOC(ndr, r->in.lm_password);
11711                 } else {
11712                         r->in.lm_password = NULL;
11713                 }
11714                 if (r->in.lm_password) {
11715                         _mem_save_lm_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
11716                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_password, 0);
11717                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
11718                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_password_0, 0);
11719                 }
11720                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_verifier));
11721                 if (_ptr_lm_verifier) {
11722                         NDR_PULL_ALLOC(ndr, r->in.lm_verifier);
11723                 } else {
11724                         r->in.lm_verifier = NULL;
11725                 }
11726                 if (r->in.lm_verifier) {
11727                         _mem_save_lm_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
11728                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_verifier, 0);
11729                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
11730                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_verifier_0, 0);
11731                 }
11732                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password3));
11733                 if (_ptr_password3) {
11734                         NDR_PULL_ALLOC(ndr, r->in.password3);
11735                 } else {
11736                         r->in.password3 = NULL;
11737                 }
11738                 if (r->in.password3) {
11739                         _mem_save_password3_0 = NDR_PULL_GET_MEM_CTX(ndr);
11740                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password3, 0);
11741                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password3));
11742                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password3_0, 0);
11743                 }
11744                 NDR_PULL_ALLOC(ndr, r->out.dominfo);
11745                 ZERO_STRUCTP(r->out.dominfo);
11746                 NDR_PULL_ALLOC(ndr, r->out.reject);
11747                 ZERO_STRUCTP(r->out.reject);
11748         }
11749         if (flags & NDR_OUT) {
11750                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11751                         NDR_PULL_ALLOC(ndr, r->out.dominfo);
11752                 }
11753                 _mem_save_dominfo_0 = NDR_PULL_GET_MEM_CTX(ndr);
11754                 NDR_PULL_SET_MEM_CTX(ndr, r->out.dominfo, LIBNDR_FLAG_REF_ALLOC);
11755                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dominfo));
11756                 if (_ptr_dominfo) {
11757                         NDR_PULL_ALLOC(ndr, *r->out.dominfo);
11758                 } else {
11759                         *r->out.dominfo = NULL;
11760                 }
11761                 if (*r->out.dominfo) {
11762                         _mem_save_dominfo_1 = NDR_PULL_GET_MEM_CTX(ndr);
11763                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.dominfo, 0);
11764                         NDR_CHECK(ndr_pull_samr_DomInfo1(ndr, NDR_SCALARS, *r->out.dominfo));
11765                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dominfo_1, 0);
11766                 }
11767                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dominfo_0, LIBNDR_FLAG_REF_ALLOC);
11768                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11769                         NDR_PULL_ALLOC(ndr, r->out.reject);
11770                 }
11771                 _mem_save_reject_0 = NDR_PULL_GET_MEM_CTX(ndr);
11772                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reject, LIBNDR_FLAG_REF_ALLOC);
11773                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_reject));
11774                 if (_ptr_reject) {
11775                         NDR_PULL_ALLOC(ndr, *r->out.reject);
11776                 } else {
11777                         *r->out.reject = NULL;
11778                 }
11779                 if (*r->out.reject) {
11780                         _mem_save_reject_1 = NDR_PULL_GET_MEM_CTX(ndr);
11781                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.reject, 0);
11782                         NDR_CHECK(ndr_pull_samr_ChangeReject(ndr, NDR_SCALARS, *r->out.reject));
11783                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reject_1, 0);
11784                 }
11785                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reject_0, LIBNDR_FLAG_REF_ALLOC);
11786                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11787         }
11788         return NDR_ERR_SUCCESS;
11789 }
11790
11791 _PUBLIC_ void ndr_print_samr_ChangePasswordUser3(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser3 *r)
11792 {
11793         ndr_print_struct(ndr, name, "samr_ChangePasswordUser3");
11794         ndr->depth++;
11795         if (flags & NDR_SET_VALUES) {
11796                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11797         }
11798         if (flags & NDR_IN) {
11799                 ndr_print_struct(ndr, "in", "samr_ChangePasswordUser3");
11800                 ndr->depth++;
11801                 ndr_print_ptr(ndr, "server", r->in.server);
11802                 ndr->depth++;
11803                 if (r->in.server) {
11804                         ndr_print_lsa_String(ndr, "server", r->in.server);
11805                 }
11806                 ndr->depth--;
11807                 ndr_print_ptr(ndr, "account", r->in.account);
11808                 ndr->depth++;
11809                 ndr_print_lsa_String(ndr, "account", r->in.account);
11810                 ndr->depth--;
11811                 ndr_print_ptr(ndr, "nt_password", r->in.nt_password);
11812                 ndr->depth++;
11813                 if (r->in.nt_password) {
11814                         ndr_print_samr_CryptPassword(ndr, "nt_password", r->in.nt_password);
11815                 }
11816                 ndr->depth--;
11817                 ndr_print_ptr(ndr, "nt_verifier", r->in.nt_verifier);
11818                 ndr->depth++;
11819                 if (r->in.nt_verifier) {
11820                         ndr_print_samr_Password(ndr, "nt_verifier", r->in.nt_verifier);
11821                 }
11822                 ndr->depth--;
11823                 ndr_print_uint8(ndr, "lm_change", r->in.lm_change);
11824                 ndr_print_ptr(ndr, "lm_password", r->in.lm_password);
11825                 ndr->depth++;
11826                 if (r->in.lm_password) {
11827                         ndr_print_samr_CryptPassword(ndr, "lm_password", r->in.lm_password);
11828                 }
11829                 ndr->depth--;
11830                 ndr_print_ptr(ndr, "lm_verifier", r->in.lm_verifier);
11831                 ndr->depth++;
11832                 if (r->in.lm_verifier) {
11833                         ndr_print_samr_Password(ndr, "lm_verifier", r->in.lm_verifier);
11834                 }
11835                 ndr->depth--;
11836                 ndr_print_ptr(ndr, "password3", r->in.password3);
11837                 ndr->depth++;
11838                 if (r->in.password3) {
11839                         ndr_print_samr_CryptPassword(ndr, "password3", r->in.password3);
11840                 }
11841                 ndr->depth--;
11842                 ndr->depth--;
11843         }
11844         if (flags & NDR_OUT) {
11845                 ndr_print_struct(ndr, "out", "samr_ChangePasswordUser3");
11846                 ndr->depth++;
11847                 ndr_print_ptr(ndr, "dominfo", r->out.dominfo);
11848                 ndr->depth++;
11849                 ndr_print_ptr(ndr, "dominfo", *r->out.dominfo);
11850                 ndr->depth++;
11851                 if (*r->out.dominfo) {
11852                         ndr_print_samr_DomInfo1(ndr, "dominfo", *r->out.dominfo);
11853                 }
11854                 ndr->depth--;
11855                 ndr->depth--;
11856                 ndr_print_ptr(ndr, "reject", r->out.reject);
11857                 ndr->depth++;
11858                 ndr_print_ptr(ndr, "reject", *r->out.reject);
11859                 ndr->depth++;
11860                 if (*r->out.reject) {
11861                         ndr_print_samr_ChangeReject(ndr, "reject", *r->out.reject);
11862                 }
11863                 ndr->depth--;
11864                 ndr->depth--;
11865                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11866                 ndr->depth--;
11867         }
11868         ndr->depth--;
11869 }
11870
11871 _PUBLIC_ enum ndr_err_code ndr_push_samr_Connect5(struct ndr_push *ndr, int flags, const struct samr_Connect5 *r)
11872 {
11873         if (flags & NDR_IN) {
11874                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
11875                 if (r->in.system_name) {
11876                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11877                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11878                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
11879                         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));
11880                 }
11881                 NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
11882                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level_in));
11883                 if (r->in.info_in == NULL) {
11884                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11885                 }
11886                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info_in, r->in.level_in));
11887                 NDR_CHECK(ndr_push_samr_ConnectInfo(ndr, NDR_SCALARS, r->in.info_in));
11888         }
11889         if (flags & NDR_OUT) {
11890                 if (r->out.level_out == NULL) {
11891                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11892                 }
11893                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
11894                 if (r->out.info_out == NULL) {
11895                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11896                 }
11897                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info_out, *r->out.level_out));
11898                 NDR_CHECK(ndr_push_samr_ConnectInfo(ndr, NDR_SCALARS, r->out.info_out));
11899                 if (r->out.connect_handle == NULL) {
11900                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11901                 }
11902                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11903                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11904         }
11905         return NDR_ERR_SUCCESS;
11906 }
11907
11908 _PUBLIC_ enum ndr_err_code ndr_pull_samr_Connect5(struct ndr_pull *ndr, int flags, struct samr_Connect5 *r)
11909 {
11910         uint32_t _ptr_system_name;
11911         uint32_t size_system_name_1 = 0;
11912         uint32_t length_system_name_1 = 0;
11913         TALLOC_CTX *_mem_save_system_name_0;
11914         TALLOC_CTX *_mem_save_info_in_0;
11915         TALLOC_CTX *_mem_save_level_out_0;
11916         TALLOC_CTX *_mem_save_info_out_0;
11917         TALLOC_CTX *_mem_save_connect_handle_0;
11918         if (flags & NDR_IN) {
11919                 ZERO_STRUCT(r->out);
11920
11921                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
11922                 if (_ptr_system_name) {
11923                         NDR_PULL_ALLOC(ndr, r->in.system_name);
11924                 } else {
11925                         r->in.system_name = NULL;
11926                 }
11927                 if (r->in.system_name) {
11928                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11929                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
11930                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
11931                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
11932                         size_system_name_1 = ndr_get_array_size(ndr, &r->in.system_name);
11933                         length_system_name_1 = ndr_get_array_length(ndr, &r->in.system_name);
11934                         if (length_system_name_1 > size_system_name_1) {
11935                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_system_name_1, length_system_name_1);
11936                         }
11937                         NDR_CHECK(ndr_check_string_terminator(ndr, length_system_name_1, sizeof(uint16_t)));
11938                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, length_system_name_1, sizeof(uint16_t), CH_UTF16));
11939                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
11940                 }
11941                 NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
11942                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level_in));
11943                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11944                         NDR_PULL_ALLOC(ndr, r->in.info_in);
11945                 }
11946                 _mem_save_info_in_0 = NDR_PULL_GET_MEM_CTX(ndr);
11947                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_in, LIBNDR_FLAG_REF_ALLOC);
11948                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info_in, r->in.level_in));
11949                 NDR_CHECK(ndr_pull_samr_ConnectInfo(ndr, NDR_SCALARS, r->in.info_in));
11950                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_in_0, LIBNDR_FLAG_REF_ALLOC);
11951                 NDR_PULL_ALLOC(ndr, r->out.level_out);
11952                 ZERO_STRUCTP(r->out.level_out);
11953                 NDR_PULL_ALLOC(ndr, r->out.info_out);
11954                 ZERO_STRUCTP(r->out.info_out);
11955                 NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11956                 ZERO_STRUCTP(r->out.connect_handle);
11957         }
11958         if (flags & NDR_OUT) {
11959                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11960                         NDR_PULL_ALLOC(ndr, r->out.level_out);
11961                 }
11962                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
11963                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
11964                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
11965                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
11966                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11967                         NDR_PULL_ALLOC(ndr, r->out.info_out);
11968                 }
11969                 _mem_save_info_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
11970                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_out, LIBNDR_FLAG_REF_ALLOC);
11971                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info_out, *r->out.level_out));
11972                 NDR_CHECK(ndr_pull_samr_ConnectInfo(ndr, NDR_SCALARS, r->out.info_out));
11973                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_out_0, LIBNDR_FLAG_REF_ALLOC);
11974                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11975                         NDR_PULL_ALLOC(ndr, r->out.connect_handle);
11976                 }
11977                 _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11978                 NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
11979                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
11980                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
11981                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11982         }
11983         return NDR_ERR_SUCCESS;
11984 }
11985
11986 _PUBLIC_ void ndr_print_samr_Connect5(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect5 *r)
11987 {
11988         ndr_print_struct(ndr, name, "samr_Connect5");
11989         ndr->depth++;
11990         if (flags & NDR_SET_VALUES) {
11991                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11992         }
11993         if (flags & NDR_IN) {
11994                 ndr_print_struct(ndr, "in", "samr_Connect5");
11995                 ndr->depth++;
11996                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
11997                 ndr->depth++;
11998                 if (r->in.system_name) {
11999                         ndr_print_string(ndr, "system_name", r->in.system_name);
12000                 }
12001                 ndr->depth--;
12002                 ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
12003                 ndr_print_uint32(ndr, "level_in", r->in.level_in);
12004                 ndr_print_ptr(ndr, "info_in", r->in.info_in);
12005                 ndr->depth++;
12006                 ndr_print_set_switch_value(ndr, r->in.info_in, r->in.level_in);
12007                 ndr_print_samr_ConnectInfo(ndr, "info_in", r->in.info_in);
12008                 ndr->depth--;
12009                 ndr->depth--;
12010         }
12011         if (flags & NDR_OUT) {
12012                 ndr_print_struct(ndr, "out", "samr_Connect5");
12013                 ndr->depth++;
12014                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
12015                 ndr->depth++;
12016                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
12017                 ndr->depth--;
12018                 ndr_print_ptr(ndr, "info_out", r->out.info_out);
12019                 ndr->depth++;
12020                 ndr_print_set_switch_value(ndr, r->out.info_out, *r->out.level_out);
12021                 ndr_print_samr_ConnectInfo(ndr, "info_out", r->out.info_out);
12022                 ndr->depth--;
12023                 ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
12024                 ndr->depth++;
12025                 ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
12026                 ndr->depth--;
12027                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12028                 ndr->depth--;
12029         }
12030         ndr->depth--;
12031 }
12032
12033 static enum ndr_err_code ndr_push_samr_RidToSid(struct ndr_push *ndr, int flags, const struct samr_RidToSid *r)
12034 {
12035         if (flags & NDR_IN) {
12036                 if (r->in.domain_handle == NULL) {
12037                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12038                 }
12039                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
12040                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
12041         }
12042         if (flags & NDR_OUT) {
12043                 if (r->out.sid == NULL) {
12044                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12045                 }
12046                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sid));
12047                 if (*r->out.sid) {
12048                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
12049                 }
12050                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12051         }
12052         return NDR_ERR_SUCCESS;
12053 }
12054
12055 static enum ndr_err_code ndr_pull_samr_RidToSid(struct ndr_pull *ndr, int flags, struct samr_RidToSid *r)
12056 {
12057         uint32_t _ptr_sid;
12058         TALLOC_CTX *_mem_save_domain_handle_0;
12059         TALLOC_CTX *_mem_save_sid_0;
12060         TALLOC_CTX *_mem_save_sid_1;
12061         if (flags & NDR_IN) {
12062                 ZERO_STRUCT(r->out);
12063
12064                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12065                         NDR_PULL_ALLOC(ndr, r->in.domain_handle);
12066                 }
12067                 _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12068                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
12069                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
12070                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
12071                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
12072                 NDR_PULL_ALLOC(ndr, r->out.sid);
12073                 ZERO_STRUCTP(r->out.sid);
12074         }
12075         if (flags & NDR_OUT) {
12076                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12077                         NDR_PULL_ALLOC(ndr, r->out.sid);
12078                 }
12079                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
12080                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);
12081                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
12082                 if (_ptr_sid) {
12083                         NDR_PULL_ALLOC(ndr, *r->out.sid);
12084                 } else {
12085                         *r->out.sid = NULL;
12086                 }
12087                 if (*r->out.sid) {
12088                         _mem_save_sid_1 = NDR_PULL_GET_MEM_CTX(ndr);
12089                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sid, 0);
12090                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
12091                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_1, 0);
12092                 }
12093                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
12094                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12095         }
12096         return NDR_ERR_SUCCESS;
12097 }
12098
12099 _PUBLIC_ void ndr_print_samr_RidToSid(struct ndr_print *ndr, const char *name, int flags, const struct samr_RidToSid *r)
12100 {
12101         ndr_print_struct(ndr, name, "samr_RidToSid");
12102         ndr->depth++;
12103         if (flags & NDR_SET_VALUES) {
12104                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12105         }
12106         if (flags & NDR_IN) {
12107                 ndr_print_struct(ndr, "in", "samr_RidToSid");
12108                 ndr->depth++;
12109                 ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
12110                 ndr->depth++;
12111                 ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
12112                 ndr->depth--;
12113                 ndr_print_uint32(ndr, "rid", r->in.rid);
12114                 ndr->depth--;
12115         }
12116         if (flags & NDR_OUT) {
12117                 ndr_print_struct(ndr, "out", "samr_RidToSid");
12118                 ndr->depth++;
12119                 ndr_print_ptr(ndr, "sid", r->out.sid);
12120                 ndr->depth++;
12121                 ndr_print_ptr(ndr, "sid", *r->out.sid);
12122                 ndr->depth++;
12123                 if (*r->out.sid) {
12124                         ndr_print_dom_sid2(ndr, "sid", *r->out.sid);
12125                 }
12126                 ndr->depth--;
12127                 ndr->depth--;
12128                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12129                 ndr->depth--;
12130         }
12131         ndr->depth--;
12132 }
12133
12134 static enum ndr_err_code ndr_push_samr_SetDsrmPassword(struct ndr_push *ndr, int flags, const struct samr_SetDsrmPassword *r)
12135 {
12136         if (flags & NDR_IN) {
12137                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.name));
12138                 if (r->in.name) {
12139                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
12140                 }
12141                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
12142                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hash));
12143                 if (r->in.hash) {
12144                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.hash));
12145                 }
12146         }
12147         if (flags & NDR_OUT) {
12148                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12149         }
12150         return NDR_ERR_SUCCESS;
12151 }
12152
12153 static enum ndr_err_code ndr_pull_samr_SetDsrmPassword(struct ndr_pull *ndr, int flags, struct samr_SetDsrmPassword *r)
12154 {
12155         uint32_t _ptr_name;
12156         uint32_t _ptr_hash;
12157         TALLOC_CTX *_mem_save_name_0;
12158         TALLOC_CTX *_mem_save_hash_0;
12159         if (flags & NDR_IN) {
12160                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
12161                 if (_ptr_name) {
12162                         NDR_PULL_ALLOC(ndr, r->in.name);
12163                 } else {
12164                         r->in.name = NULL;
12165                 }
12166                 if (r->in.name) {
12167                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12168                         NDR_PULL_SET_MEM_CTX(ndr, r->in.name, 0);
12169                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
12170                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
12171                 }
12172                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
12173                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hash));
12174                 if (_ptr_hash) {
12175                         NDR_PULL_ALLOC(ndr, r->in.hash);
12176                 } else {
12177                         r->in.hash = NULL;
12178                 }
12179                 if (r->in.hash) {
12180                         _mem_save_hash_0 = NDR_PULL_GET_MEM_CTX(ndr);
12181                         NDR_PULL_SET_MEM_CTX(ndr, r->in.hash, 0);
12182                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.hash));
12183                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hash_0, 0);
12184                 }
12185         }
12186         if (flags & NDR_OUT) {
12187                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12188         }
12189         return NDR_ERR_SUCCESS;
12190 }
12191
12192 _PUBLIC_ void ndr_print_samr_SetDsrmPassword(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetDsrmPassword *r)
12193 {
12194         ndr_print_struct(ndr, name, "samr_SetDsrmPassword");
12195         ndr->depth++;
12196         if (flags & NDR_SET_VALUES) {
12197                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12198         }
12199         if (flags & NDR_IN) {
12200                 ndr_print_struct(ndr, "in", "samr_SetDsrmPassword");
12201                 ndr->depth++;
12202                 ndr_print_ptr(ndr, "name", r->in.name);
12203                 ndr->depth++;
12204                 if (r->in.name) {
12205                         ndr_print_lsa_String(ndr, "name", r->in.name);
12206                 }
12207                 ndr->depth--;
12208                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
12209                 ndr_print_ptr(ndr, "hash", r->in.hash);
12210                 ndr->depth++;
12211                 if (r->in.hash) {
12212                         ndr_print_samr_Password(ndr, "hash", r->in.hash);
12213                 }
12214                 ndr->depth--;
12215                 ndr->depth--;
12216         }
12217         if (flags & NDR_OUT) {
12218                 ndr_print_struct(ndr, "out", "samr_SetDsrmPassword");
12219                 ndr->depth++;
12220                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12221                 ndr->depth--;
12222         }
12223         ndr->depth--;
12224 }
12225
12226 static enum ndr_err_code ndr_push_samr_ValidatePassword(struct ndr_push *ndr, int flags, const struct samr_ValidatePassword *r)
12227 {
12228         if (flags & NDR_IN) {
12229                 NDR_CHECK(ndr_push_samr_ValidatePasswordLevel(ndr, NDR_SCALARS, r->in.level));
12230                 if (r->in.req == NULL) {
12231                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12232                 }
12233                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
12234                 NDR_CHECK(ndr_push_samr_ValidatePasswordReq(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
12235         }
12236         if (flags & NDR_OUT) {
12237                 if (r->out.rep == NULL) {
12238                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12239                 }
12240                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rep));
12241                 if (*r->out.rep) {
12242                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.rep, r->in.level));
12243                         NDR_CHECK(ndr_push_samr_ValidatePasswordRep(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rep));
12244                 }
12245                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12246         }
12247         return NDR_ERR_SUCCESS;
12248 }
12249
12250 static enum ndr_err_code ndr_pull_samr_ValidatePassword(struct ndr_pull *ndr, int flags, struct samr_ValidatePassword *r)
12251 {
12252         uint32_t _ptr_rep;
12253         TALLOC_CTX *_mem_save_req_0;
12254         TALLOC_CTX *_mem_save_rep_0;
12255         TALLOC_CTX *_mem_save_rep_1;
12256         if (flags & NDR_IN) {
12257                 ZERO_STRUCT(r->out);
12258
12259                 NDR_CHECK(ndr_pull_samr_ValidatePasswordLevel(ndr, NDR_SCALARS, &r->in.level));
12260                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12261                         NDR_PULL_ALLOC(ndr, r->in.req);
12262                 }
12263                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
12264                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
12265                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
12266                 NDR_CHECK(ndr_pull_samr_ValidatePasswordReq(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
12267                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
12268                 NDR_PULL_ALLOC(ndr, r->out.rep);
12269                 ZERO_STRUCTP(r->out.rep);
12270         }
12271         if (flags & NDR_OUT) {
12272                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12273                         NDR_PULL_ALLOC(ndr, r->out.rep);
12274                 }
12275                 _mem_save_rep_0 = NDR_PULL_GET_MEM_CTX(ndr);
12276                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rep, LIBNDR_FLAG_REF_ALLOC);
12277                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rep));
12278                 if (_ptr_rep) {
12279                         NDR_PULL_ALLOC(ndr, *r->out.rep);
12280                 } else {
12281                         *r->out.rep = NULL;
12282                 }
12283                 if (*r->out.rep) {
12284                         _mem_save_rep_1 = NDR_PULL_GET_MEM_CTX(ndr);
12285                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.rep, 0);
12286                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.rep, r->in.level));
12287                         NDR_CHECK(ndr_pull_samr_ValidatePasswordRep(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rep));
12288                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rep_1, 0);
12289                 }
12290                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rep_0, LIBNDR_FLAG_REF_ALLOC);
12291                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12292         }
12293         return NDR_ERR_SUCCESS;
12294 }
12295
12296 _PUBLIC_ void ndr_print_samr_ValidatePassword(struct ndr_print *ndr, const char *name, int flags, const struct samr_ValidatePassword *r)
12297 {
12298         ndr_print_struct(ndr, name, "samr_ValidatePassword");
12299         ndr->depth++;
12300         if (flags & NDR_SET_VALUES) {
12301                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12302         }
12303         if (flags & NDR_IN) {
12304                 ndr_print_struct(ndr, "in", "samr_ValidatePassword");
12305                 ndr->depth++;
12306                 ndr_print_samr_ValidatePasswordLevel(ndr, "level", r->in.level);
12307                 ndr_print_ptr(ndr, "req", r->in.req);
12308                 ndr->depth++;
12309                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
12310                 ndr_print_samr_ValidatePasswordReq(ndr, "req", r->in.req);
12311                 ndr->depth--;
12312                 ndr->depth--;
12313         }
12314         if (flags & NDR_OUT) {
12315                 ndr_print_struct(ndr, "out", "samr_ValidatePassword");
12316                 ndr->depth++;
12317                 ndr_print_ptr(ndr, "rep", r->out.rep);
12318                 ndr->depth++;
12319                 ndr_print_ptr(ndr, "rep", *r->out.rep);
12320                 ndr->depth++;
12321                 if (*r->out.rep) {
12322                         ndr_print_set_switch_value(ndr, *r->out.rep, r->in.level);
12323                         ndr_print_samr_ValidatePasswordRep(ndr, "rep", *r->out.rep);
12324                 }
12325                 ndr->depth--;
12326                 ndr->depth--;
12327                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12328                 ndr->depth--;
12329         }
12330         ndr->depth--;
12331 }
12332
12333 static const struct ndr_interface_call samr_calls[] = {
12334         {
12335                 "samr_Connect",
12336                 sizeof(struct samr_Connect),
12337                 (ndr_push_flags_fn_t) ndr_push_samr_Connect,
12338                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect,
12339                 (ndr_print_function_t) ndr_print_samr_Connect,
12340                 false,
12341         },
12342         {
12343                 "samr_Close",
12344                 sizeof(struct samr_Close),
12345                 (ndr_push_flags_fn_t) ndr_push_samr_Close,
12346                 (ndr_pull_flags_fn_t) ndr_pull_samr_Close,
12347                 (ndr_print_function_t) ndr_print_samr_Close,
12348                 false,
12349         },
12350         {
12351                 "samr_SetSecurity",
12352                 sizeof(struct samr_SetSecurity),
12353                 (ndr_push_flags_fn_t) ndr_push_samr_SetSecurity,
12354                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetSecurity,
12355                 (ndr_print_function_t) ndr_print_samr_SetSecurity,
12356                 false,
12357         },
12358         {
12359                 "samr_QuerySecurity",
12360                 sizeof(struct samr_QuerySecurity),
12361                 (ndr_push_flags_fn_t) ndr_push_samr_QuerySecurity,
12362                 (ndr_pull_flags_fn_t) ndr_pull_samr_QuerySecurity,
12363                 (ndr_print_function_t) ndr_print_samr_QuerySecurity,
12364                 false,
12365         },
12366         {
12367                 "samr_Shutdown",
12368                 sizeof(struct samr_Shutdown),
12369                 (ndr_push_flags_fn_t) ndr_push_samr_Shutdown,
12370                 (ndr_pull_flags_fn_t) ndr_pull_samr_Shutdown,
12371                 (ndr_print_function_t) ndr_print_samr_Shutdown,
12372                 false,
12373         },
12374         {
12375                 "samr_LookupDomain",
12376                 sizeof(struct samr_LookupDomain),
12377                 (ndr_push_flags_fn_t) ndr_push_samr_LookupDomain,
12378                 (ndr_pull_flags_fn_t) ndr_pull_samr_LookupDomain,
12379                 (ndr_print_function_t) ndr_print_samr_LookupDomain,
12380                 false,
12381         },
12382         {
12383                 "samr_EnumDomains",
12384                 sizeof(struct samr_EnumDomains),
12385                 (ndr_push_flags_fn_t) ndr_push_samr_EnumDomains,
12386                 (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomains,
12387                 (ndr_print_function_t) ndr_print_samr_EnumDomains,
12388                 false,
12389         },
12390         {
12391                 "samr_OpenDomain",
12392                 sizeof(struct samr_OpenDomain),
12393                 (ndr_push_flags_fn_t) ndr_push_samr_OpenDomain,
12394                 (ndr_pull_flags_fn_t) ndr_pull_samr_OpenDomain,
12395                 (ndr_print_function_t) ndr_print_samr_OpenDomain,
12396                 false,
12397         },
12398         {
12399                 "samr_QueryDomainInfo",
12400                 sizeof(struct samr_QueryDomainInfo),
12401                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDomainInfo,
12402                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDomainInfo,
12403                 (ndr_print_function_t) ndr_print_samr_QueryDomainInfo,
12404                 false,
12405         },
12406         {
12407                 "samr_SetDomainInfo",
12408                 sizeof(struct samr_SetDomainInfo),
12409                 (ndr_push_flags_fn_t) ndr_push_samr_SetDomainInfo,
12410                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetDomainInfo,
12411                 (ndr_print_function_t) ndr_print_samr_SetDomainInfo,
12412                 false,
12413         },
12414         {
12415                 "samr_CreateDomainGroup",
12416                 sizeof(struct samr_CreateDomainGroup),
12417                 (ndr_push_flags_fn_t) ndr_push_samr_CreateDomainGroup,
12418                 (ndr_pull_flags_fn_t) ndr_pull_samr_CreateDomainGroup,
12419                 (ndr_print_function_t) ndr_print_samr_CreateDomainGroup,
12420                 false,
12421         },
12422         {
12423                 "samr_EnumDomainGroups",
12424                 sizeof(struct samr_EnumDomainGroups),
12425                 (ndr_push_flags_fn_t) ndr_push_samr_EnumDomainGroups,
12426                 (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainGroups,
12427                 (ndr_print_function_t) ndr_print_samr_EnumDomainGroups,
12428                 false,
12429         },
12430         {
12431                 "samr_CreateUser",
12432                 sizeof(struct samr_CreateUser),
12433                 (ndr_push_flags_fn_t) ndr_push_samr_CreateUser,
12434                 (ndr_pull_flags_fn_t) ndr_pull_samr_CreateUser,
12435                 (ndr_print_function_t) ndr_print_samr_CreateUser,
12436                 false,
12437         },
12438         {
12439                 "samr_EnumDomainUsers",
12440                 sizeof(struct samr_EnumDomainUsers),
12441                 (ndr_push_flags_fn_t) ndr_push_samr_EnumDomainUsers,
12442                 (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainUsers,
12443                 (ndr_print_function_t) ndr_print_samr_EnumDomainUsers,
12444                 false,
12445         },
12446         {
12447                 "samr_CreateDomAlias",
12448                 sizeof(struct samr_CreateDomAlias),
12449                 (ndr_push_flags_fn_t) ndr_push_samr_CreateDomAlias,
12450                 (ndr_pull_flags_fn_t) ndr_pull_samr_CreateDomAlias,
12451                 (ndr_print_function_t) ndr_print_samr_CreateDomAlias,
12452                 false,
12453         },
12454         {
12455                 "samr_EnumDomainAliases",
12456                 sizeof(struct samr_EnumDomainAliases),
12457                 (ndr_push_flags_fn_t) ndr_push_samr_EnumDomainAliases,
12458                 (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainAliases,
12459                 (ndr_print_function_t) ndr_print_samr_EnumDomainAliases,
12460                 false,
12461         },
12462         {
12463                 "samr_GetAliasMembership",
12464                 sizeof(struct samr_GetAliasMembership),
12465                 (ndr_push_flags_fn_t) ndr_push_samr_GetAliasMembership,
12466                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetAliasMembership,
12467                 (ndr_print_function_t) ndr_print_samr_GetAliasMembership,
12468                 false,
12469         },
12470         {
12471                 "samr_LookupNames",
12472                 sizeof(struct samr_LookupNames),
12473                 (ndr_push_flags_fn_t) ndr_push_samr_LookupNames,
12474                 (ndr_pull_flags_fn_t) ndr_pull_samr_LookupNames,
12475                 (ndr_print_function_t) ndr_print_samr_LookupNames,
12476                 false,
12477         },
12478         {
12479                 "samr_LookupRids",
12480                 sizeof(struct samr_LookupRids),
12481                 (ndr_push_flags_fn_t) ndr_push_samr_LookupRids,
12482                 (ndr_pull_flags_fn_t) ndr_pull_samr_LookupRids,
12483                 (ndr_print_function_t) ndr_print_samr_LookupRids,
12484                 false,
12485         },
12486         {
12487                 "samr_OpenGroup",
12488                 sizeof(struct samr_OpenGroup),
12489                 (ndr_push_flags_fn_t) ndr_push_samr_OpenGroup,
12490                 (ndr_pull_flags_fn_t) ndr_pull_samr_OpenGroup,
12491                 (ndr_print_function_t) ndr_print_samr_OpenGroup,
12492                 false,
12493         },
12494         {
12495                 "samr_QueryGroupInfo",
12496                 sizeof(struct samr_QueryGroupInfo),
12497                 (ndr_push_flags_fn_t) ndr_push_samr_QueryGroupInfo,
12498                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryGroupInfo,
12499                 (ndr_print_function_t) ndr_print_samr_QueryGroupInfo,
12500                 false,
12501         },
12502         {
12503                 "samr_SetGroupInfo",
12504                 sizeof(struct samr_SetGroupInfo),
12505                 (ndr_push_flags_fn_t) ndr_push_samr_SetGroupInfo,
12506                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetGroupInfo,
12507                 (ndr_print_function_t) ndr_print_samr_SetGroupInfo,
12508                 false,
12509         },
12510         {
12511                 "samr_AddGroupMember",
12512                 sizeof(struct samr_AddGroupMember),
12513                 (ndr_push_flags_fn_t) ndr_push_samr_AddGroupMember,
12514                 (ndr_pull_flags_fn_t) ndr_pull_samr_AddGroupMember,
12515                 (ndr_print_function_t) ndr_print_samr_AddGroupMember,
12516                 false,
12517         },
12518         {
12519                 "samr_DeleteDomainGroup",
12520                 sizeof(struct samr_DeleteDomainGroup),
12521                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteDomainGroup,
12522                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteDomainGroup,
12523                 (ndr_print_function_t) ndr_print_samr_DeleteDomainGroup,
12524                 false,
12525         },
12526         {
12527                 "samr_DeleteGroupMember",
12528                 sizeof(struct samr_DeleteGroupMember),
12529                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteGroupMember,
12530                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteGroupMember,
12531                 (ndr_print_function_t) ndr_print_samr_DeleteGroupMember,
12532                 false,
12533         },
12534         {
12535                 "samr_QueryGroupMember",
12536                 sizeof(struct samr_QueryGroupMember),
12537                 (ndr_push_flags_fn_t) ndr_push_samr_QueryGroupMember,
12538                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryGroupMember,
12539                 (ndr_print_function_t) ndr_print_samr_QueryGroupMember,
12540                 false,
12541         },
12542         {
12543                 "samr_SetMemberAttributesOfGroup",
12544                 sizeof(struct samr_SetMemberAttributesOfGroup),
12545                 (ndr_push_flags_fn_t) ndr_push_samr_SetMemberAttributesOfGroup,
12546                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetMemberAttributesOfGroup,
12547                 (ndr_print_function_t) ndr_print_samr_SetMemberAttributesOfGroup,
12548                 false,
12549         },
12550         {
12551                 "samr_OpenAlias",
12552                 sizeof(struct samr_OpenAlias),
12553                 (ndr_push_flags_fn_t) ndr_push_samr_OpenAlias,
12554                 (ndr_pull_flags_fn_t) ndr_pull_samr_OpenAlias,
12555                 (ndr_print_function_t) ndr_print_samr_OpenAlias,
12556                 false,
12557         },
12558         {
12559                 "samr_QueryAliasInfo",
12560                 sizeof(struct samr_QueryAliasInfo),
12561                 (ndr_push_flags_fn_t) ndr_push_samr_QueryAliasInfo,
12562                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryAliasInfo,
12563                 (ndr_print_function_t) ndr_print_samr_QueryAliasInfo,
12564                 false,
12565         },
12566         {
12567                 "samr_SetAliasInfo",
12568                 sizeof(struct samr_SetAliasInfo),
12569                 (ndr_push_flags_fn_t) ndr_push_samr_SetAliasInfo,
12570                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetAliasInfo,
12571                 (ndr_print_function_t) ndr_print_samr_SetAliasInfo,
12572                 false,
12573         },
12574         {
12575                 "samr_DeleteDomAlias",
12576                 sizeof(struct samr_DeleteDomAlias),
12577                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteDomAlias,
12578                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteDomAlias,
12579                 (ndr_print_function_t) ndr_print_samr_DeleteDomAlias,
12580                 false,
12581         },
12582         {
12583                 "samr_AddAliasMember",
12584                 sizeof(struct samr_AddAliasMember),
12585                 (ndr_push_flags_fn_t) ndr_push_samr_AddAliasMember,
12586                 (ndr_pull_flags_fn_t) ndr_pull_samr_AddAliasMember,
12587                 (ndr_print_function_t) ndr_print_samr_AddAliasMember,
12588                 false,
12589         },
12590         {
12591                 "samr_DeleteAliasMember",
12592                 sizeof(struct samr_DeleteAliasMember),
12593                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteAliasMember,
12594                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteAliasMember,
12595                 (ndr_print_function_t) ndr_print_samr_DeleteAliasMember,
12596                 false,
12597         },
12598         {
12599                 "samr_GetMembersInAlias",
12600                 sizeof(struct samr_GetMembersInAlias),
12601                 (ndr_push_flags_fn_t) ndr_push_samr_GetMembersInAlias,
12602                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetMembersInAlias,
12603                 (ndr_print_function_t) ndr_print_samr_GetMembersInAlias,
12604                 false,
12605         },
12606         {
12607                 "samr_OpenUser",
12608                 sizeof(struct samr_OpenUser),
12609                 (ndr_push_flags_fn_t) ndr_push_samr_OpenUser,
12610                 (ndr_pull_flags_fn_t) ndr_pull_samr_OpenUser,
12611                 (ndr_print_function_t) ndr_print_samr_OpenUser,
12612                 false,
12613         },
12614         {
12615                 "samr_DeleteUser",
12616                 sizeof(struct samr_DeleteUser),
12617                 (ndr_push_flags_fn_t) ndr_push_samr_DeleteUser,
12618                 (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteUser,
12619                 (ndr_print_function_t) ndr_print_samr_DeleteUser,
12620                 false,
12621         },
12622         {
12623                 "samr_QueryUserInfo",
12624                 sizeof(struct samr_QueryUserInfo),
12625                 (ndr_push_flags_fn_t) ndr_push_samr_QueryUserInfo,
12626                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryUserInfo,
12627                 (ndr_print_function_t) ndr_print_samr_QueryUserInfo,
12628                 false,
12629         },
12630         {
12631                 "samr_SetUserInfo",
12632                 sizeof(struct samr_SetUserInfo),
12633                 (ndr_push_flags_fn_t) ndr_push_samr_SetUserInfo,
12634                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetUserInfo,
12635                 (ndr_print_function_t) ndr_print_samr_SetUserInfo,
12636                 false,
12637         },
12638         {
12639                 "samr_ChangePasswordUser",
12640                 sizeof(struct samr_ChangePasswordUser),
12641                 (ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser,
12642                 (ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser,
12643                 (ndr_print_function_t) ndr_print_samr_ChangePasswordUser,
12644                 false,
12645         },
12646         {
12647                 "samr_GetGroupsForUser",
12648                 sizeof(struct samr_GetGroupsForUser),
12649                 (ndr_push_flags_fn_t) ndr_push_samr_GetGroupsForUser,
12650                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetGroupsForUser,
12651                 (ndr_print_function_t) ndr_print_samr_GetGroupsForUser,
12652                 false,
12653         },
12654         {
12655                 "samr_QueryDisplayInfo",
12656                 sizeof(struct samr_QueryDisplayInfo),
12657                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo,
12658                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo,
12659                 (ndr_print_function_t) ndr_print_samr_QueryDisplayInfo,
12660                 false,
12661         },
12662         {
12663                 "samr_GetDisplayEnumerationIndex",
12664                 sizeof(struct samr_GetDisplayEnumerationIndex),
12665                 (ndr_push_flags_fn_t) ndr_push_samr_GetDisplayEnumerationIndex,
12666                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetDisplayEnumerationIndex,
12667                 (ndr_print_function_t) ndr_print_samr_GetDisplayEnumerationIndex,
12668                 false,
12669         },
12670         {
12671                 "samr_TestPrivateFunctionsDomain",
12672                 sizeof(struct samr_TestPrivateFunctionsDomain),
12673                 (ndr_push_flags_fn_t) ndr_push_samr_TestPrivateFunctionsDomain,
12674                 (ndr_pull_flags_fn_t) ndr_pull_samr_TestPrivateFunctionsDomain,
12675                 (ndr_print_function_t) ndr_print_samr_TestPrivateFunctionsDomain,
12676                 false,
12677         },
12678         {
12679                 "samr_TestPrivateFunctionsUser",
12680                 sizeof(struct samr_TestPrivateFunctionsUser),
12681                 (ndr_push_flags_fn_t) ndr_push_samr_TestPrivateFunctionsUser,
12682                 (ndr_pull_flags_fn_t) ndr_pull_samr_TestPrivateFunctionsUser,
12683                 (ndr_print_function_t) ndr_print_samr_TestPrivateFunctionsUser,
12684                 false,
12685         },
12686         {
12687                 "samr_GetUserPwInfo",
12688                 sizeof(struct samr_GetUserPwInfo),
12689                 (ndr_push_flags_fn_t) ndr_push_samr_GetUserPwInfo,
12690                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetUserPwInfo,
12691                 (ndr_print_function_t) ndr_print_samr_GetUserPwInfo,
12692                 false,
12693         },
12694         {
12695                 "samr_RemoveMemberFromForeignDomain",
12696                 sizeof(struct samr_RemoveMemberFromForeignDomain),
12697                 (ndr_push_flags_fn_t) ndr_push_samr_RemoveMemberFromForeignDomain,
12698                 (ndr_pull_flags_fn_t) ndr_pull_samr_RemoveMemberFromForeignDomain,
12699                 (ndr_print_function_t) ndr_print_samr_RemoveMemberFromForeignDomain,
12700                 false,
12701         },
12702         {
12703                 "samr_QueryDomainInfo2",
12704                 sizeof(struct samr_QueryDomainInfo2),
12705                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDomainInfo2,
12706                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDomainInfo2,
12707                 (ndr_print_function_t) ndr_print_samr_QueryDomainInfo2,
12708                 false,
12709         },
12710         {
12711                 "samr_QueryUserInfo2",
12712                 sizeof(struct samr_QueryUserInfo2),
12713                 (ndr_push_flags_fn_t) ndr_push_samr_QueryUserInfo2,
12714                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryUserInfo2,
12715                 (ndr_print_function_t) ndr_print_samr_QueryUserInfo2,
12716                 false,
12717         },
12718         {
12719                 "samr_QueryDisplayInfo2",
12720                 sizeof(struct samr_QueryDisplayInfo2),
12721                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo2,
12722                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo2,
12723                 (ndr_print_function_t) ndr_print_samr_QueryDisplayInfo2,
12724                 false,
12725         },
12726         {
12727                 "samr_GetDisplayEnumerationIndex2",
12728                 sizeof(struct samr_GetDisplayEnumerationIndex2),
12729                 (ndr_push_flags_fn_t) ndr_push_samr_GetDisplayEnumerationIndex2,
12730                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetDisplayEnumerationIndex2,
12731                 (ndr_print_function_t) ndr_print_samr_GetDisplayEnumerationIndex2,
12732                 false,
12733         },
12734         {
12735                 "samr_CreateUser2",
12736                 sizeof(struct samr_CreateUser2),
12737                 (ndr_push_flags_fn_t) ndr_push_samr_CreateUser2,
12738                 (ndr_pull_flags_fn_t) ndr_pull_samr_CreateUser2,
12739                 (ndr_print_function_t) ndr_print_samr_CreateUser2,
12740                 false,
12741         },
12742         {
12743                 "samr_QueryDisplayInfo3",
12744                 sizeof(struct samr_QueryDisplayInfo3),
12745                 (ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo3,
12746                 (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo3,
12747                 (ndr_print_function_t) ndr_print_samr_QueryDisplayInfo3,
12748                 false,
12749         },
12750         {
12751                 "samr_AddMultipleMembersToAlias",
12752                 sizeof(struct samr_AddMultipleMembersToAlias),
12753                 (ndr_push_flags_fn_t) ndr_push_samr_AddMultipleMembersToAlias,
12754                 (ndr_pull_flags_fn_t) ndr_pull_samr_AddMultipleMembersToAlias,
12755                 (ndr_print_function_t) ndr_print_samr_AddMultipleMembersToAlias,
12756                 false,
12757         },
12758         {
12759                 "samr_RemoveMultipleMembersFromAlias",
12760                 sizeof(struct samr_RemoveMultipleMembersFromAlias),
12761                 (ndr_push_flags_fn_t) ndr_push_samr_RemoveMultipleMembersFromAlias,
12762                 (ndr_pull_flags_fn_t) ndr_pull_samr_RemoveMultipleMembersFromAlias,
12763                 (ndr_print_function_t) ndr_print_samr_RemoveMultipleMembersFromAlias,
12764                 false,
12765         },
12766         {
12767                 "samr_OemChangePasswordUser2",
12768                 sizeof(struct samr_OemChangePasswordUser2),
12769                 (ndr_push_flags_fn_t) ndr_push_samr_OemChangePasswordUser2,
12770                 (ndr_pull_flags_fn_t) ndr_pull_samr_OemChangePasswordUser2,
12771                 (ndr_print_function_t) ndr_print_samr_OemChangePasswordUser2,
12772                 false,
12773         },
12774         {
12775                 "samr_ChangePasswordUser2",
12776                 sizeof(struct samr_ChangePasswordUser2),
12777                 (ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser2,
12778                 (ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser2,
12779                 (ndr_print_function_t) ndr_print_samr_ChangePasswordUser2,
12780                 false,
12781         },
12782         {
12783                 "samr_GetDomPwInfo",
12784                 sizeof(struct samr_GetDomPwInfo),
12785                 (ndr_push_flags_fn_t) ndr_push_samr_GetDomPwInfo,
12786                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetDomPwInfo,
12787                 (ndr_print_function_t) ndr_print_samr_GetDomPwInfo,
12788                 false,
12789         },
12790         {
12791                 "samr_Connect2",
12792                 sizeof(struct samr_Connect2),
12793                 (ndr_push_flags_fn_t) ndr_push_samr_Connect2,
12794                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect2,
12795                 (ndr_print_function_t) ndr_print_samr_Connect2,
12796                 false,
12797         },
12798         {
12799                 "samr_SetUserInfo2",
12800                 sizeof(struct samr_SetUserInfo2),
12801                 (ndr_push_flags_fn_t) ndr_push_samr_SetUserInfo2,
12802                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetUserInfo2,
12803                 (ndr_print_function_t) ndr_print_samr_SetUserInfo2,
12804                 false,
12805         },
12806         {
12807                 "samr_SetBootKeyInformation",
12808                 sizeof(struct samr_SetBootKeyInformation),
12809                 (ndr_push_flags_fn_t) ndr_push_samr_SetBootKeyInformation,
12810                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetBootKeyInformation,
12811                 (ndr_print_function_t) ndr_print_samr_SetBootKeyInformation,
12812                 false,
12813         },
12814         {
12815                 "samr_GetBootKeyInformation",
12816                 sizeof(struct samr_GetBootKeyInformation),
12817                 (ndr_push_flags_fn_t) ndr_push_samr_GetBootKeyInformation,
12818                 (ndr_pull_flags_fn_t) ndr_pull_samr_GetBootKeyInformation,
12819                 (ndr_print_function_t) ndr_print_samr_GetBootKeyInformation,
12820                 false,
12821         },
12822         {
12823                 "samr_Connect3",
12824                 sizeof(struct samr_Connect3),
12825                 (ndr_push_flags_fn_t) ndr_push_samr_Connect3,
12826                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect3,
12827                 (ndr_print_function_t) ndr_print_samr_Connect3,
12828                 false,
12829         },
12830         {
12831                 "samr_Connect4",
12832                 sizeof(struct samr_Connect4),
12833                 (ndr_push_flags_fn_t) ndr_push_samr_Connect4,
12834                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect4,
12835                 (ndr_print_function_t) ndr_print_samr_Connect4,
12836                 false,
12837         },
12838         {
12839                 "samr_ChangePasswordUser3",
12840                 sizeof(struct samr_ChangePasswordUser3),
12841                 (ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser3,
12842                 (ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser3,
12843                 (ndr_print_function_t) ndr_print_samr_ChangePasswordUser3,
12844                 false,
12845         },
12846         {
12847                 "samr_Connect5",
12848                 sizeof(struct samr_Connect5),
12849                 (ndr_push_flags_fn_t) ndr_push_samr_Connect5,
12850                 (ndr_pull_flags_fn_t) ndr_pull_samr_Connect5,
12851                 (ndr_print_function_t) ndr_print_samr_Connect5,
12852                 false,
12853         },
12854         {
12855                 "samr_RidToSid",
12856                 sizeof(struct samr_RidToSid),
12857                 (ndr_push_flags_fn_t) ndr_push_samr_RidToSid,
12858                 (ndr_pull_flags_fn_t) ndr_pull_samr_RidToSid,
12859                 (ndr_print_function_t) ndr_print_samr_RidToSid,
12860                 false,
12861         },
12862         {
12863                 "samr_SetDsrmPassword",
12864                 sizeof(struct samr_SetDsrmPassword),
12865                 (ndr_push_flags_fn_t) ndr_push_samr_SetDsrmPassword,
12866                 (ndr_pull_flags_fn_t) ndr_pull_samr_SetDsrmPassword,
12867                 (ndr_print_function_t) ndr_print_samr_SetDsrmPassword,
12868                 false,
12869         },
12870         {
12871                 "samr_ValidatePassword",
12872                 sizeof(struct samr_ValidatePassword),
12873                 (ndr_push_flags_fn_t) ndr_push_samr_ValidatePassword,
12874                 (ndr_pull_flags_fn_t) ndr_pull_samr_ValidatePassword,
12875                 (ndr_print_function_t) ndr_print_samr_ValidatePassword,
12876                 false,
12877         },
12878         { NULL, 0, NULL, NULL, NULL, false }
12879 };
12880
12881 static const char * const samr_endpoint_strings[] = {
12882         "ncacn_np:[\\pipe\\samr]",
12883         "ncacn_ip_tcp:",
12884         "ncalrpc:",
12885 };
12886
12887 static const struct ndr_interface_string_array samr_endpoints = {
12888         .count  = 3,
12889         .names  = samr_endpoint_strings
12890 };
12891
12892 static const char * const samr_authservice_strings[] = {
12893         "host",
12894 };
12895
12896 static const struct ndr_interface_string_array samr_authservices = {
12897         .count  = 1,
12898         .names  = samr_authservice_strings
12899 };
12900
12901
12902 const struct ndr_interface_table ndr_table_samr = {
12903         .name           = "samr",
12904         .syntax_id      = {
12905                 {0x12345778,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xac}},
12906                 NDR_SAMR_VERSION
12907         },
12908         .helpstring     = NDR_SAMR_HELPSTRING,
12909         .num_calls      = 68,
12910         .calls          = samr_calls,
12911         .endpoints      = &samr_endpoints,
12912         .authservices   = &samr_authservices
12913 };
12914