source/librpc/gen_ndr/ndr_winbind_protocol.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "librpc/gen_ndr/ndr_winbind_protocol.h"
   5
   6 #include "librpc/gen_ndr/ndr_security.h"
   7 #include "librpc/gen_ndr/ndr_lsa.h"
   8 #include "librpc/gen_ndr/ndr_samr.h"
   9 #include "librpc/gen_ndr/ndr_netlogon.h"
  10 _PUBLIC_ enum ndr_err_code ndr_push_winbind_status(struct ndr_push *ndr, int ndr_flags, enum winbind_status r)
  11 {
  12         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  13         return NDR_ERR_SUCCESS;
  14 }
  15
  16 _PUBLIC_ enum ndr_err_code ndr_pull_winbind_status(struct ndr_pull *ndr, int ndr_flags, enum winbind_status *r)
  17 {
  18         uint32_t v;
  19         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  20         *r = v;
  21         return NDR_ERR_SUCCESS;
  22 }
  23
  24 _PUBLIC_ void ndr_print_winbind_status(struct ndr_print *ndr, const char *name, enum winbind_status r)
  25 {
  26         const char *val = NULL;
  27
  28         switch (r) {
  29                 case WINBIND_STATUS_OK: val = "WINBIND_STATUS_OK"; break;
  30                 case WINBIND_STATUS_UNKNOWN_ERROR: val = "WINBIND_STATUS_UNKNOWN_ERROR"; break;
  31                 case WINBIND_STATUS_NOT_IMPLEMENTED: val = "WINBIND_STATUS_NOT_IMPLEMENTED"; break;
  32                 case WINBIND_STATUS_NOT_SUPPORTED: val = "WINBIND_STATUS_NOT_SUPPORTED"; break;
  33                 case WINBIND_STATUS_NO_MEMORY: val = "WINBIND_STATUS_NO_MEMORY"; break;
  34                 case WINBIND_STATUS_INVALID_PARAMETER: val = "WINBIND_STATUS_INVALID_PARAMETER"; break;
  35                 case WINBIND_STATUS_INVALID_LEVEL: val = "WINBIND_STATUS_INVALID_LEVEL"; break;
  36                 case WINBIND_STATUS_UNKNOWN_LEVEL: val = "WINBIND_STATUS_UNKNOWN_LEVEL"; break;
  37                 case WINBIND_STATUS_DOMAIN_OFFLINE: val = "WINBIND_STATUS_DOMAIN_OFFLINE"; break;
  38         }
  39         ndr_print_enum(ndr, name, "ENUM", val, r);
  40 }
  41
  42 static enum ndr_err_code ndr_push_winbind_header_version(struct ndr_push *ndr, int ndr_flags, uint16_t r)
  43 {
  44         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
  45         return NDR_ERR_SUCCESS;
  46 }
  47
  48 static enum ndr_err_code ndr_pull_winbind_header_version(struct ndr_pull *ndr, int ndr_flags, uint16_t *r)
  49 {
  50         uint16_t v;
  51         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
  52         *r = v;
  53         return NDR_ERR_SUCCESS;
  54 }
  55
  56 _PUBLIC_ void ndr_print_winbind_header_version(struct ndr_print *ndr, const char *name, uint16_t r)
  57 {
  58         ndr_print_uint16(ndr, name, r);
  59         ndr->depth++;
  60         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "WINBIND_HEADER_VERSION", WINBIND_HEADER_VERSION, r);
  61         ndr->depth--;
  62 }
  63
  64 static enum ndr_err_code ndr_push_winbind_header_flags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  65 {
  66         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  67         return NDR_ERR_SUCCESS;
  68 }
  69
  70 static enum ndr_err_code ndr_pull_winbind_header_flags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  71 {
  72         uint32_t v;
  73         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  74         *r = v;
  75         return NDR_ERR_SUCCESS;
  76 }
  77
  78 _PUBLIC_ void ndr_print_winbind_header_flags(struct ndr_print *ndr, const char *name, uint32_t r)
  79 {
  80         ndr_print_uint32(ndr, name, r);
  81         ndr->depth++;
  82         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WINBIND_HEADER_FLAGS_RESPONSE", WINBIND_HEADER_FLAGS_RESPONSE, r);
  83         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WINBIND_HEADER_FLAGS_ERROR", WINBIND_HEADER_FLAGS_ERROR, r);
  84         ndr->depth--;
  85 }
  86
  87 _PUBLIC_ enum ndr_err_code ndr_push_STRUCT_winbind_header(struct ndr_push *ndr, int ndr_flags, const struct winbind_header *r)
  88 {
  89         if (ndr_flags & NDR_SCALARS) {
  90                 NDR_CHECK(ndr_push_align(ndr, 4));
  91                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
  92                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, "WBPT", 4, sizeof(uint8_t), CH_DOS));
  93                 NDR_CHECK(ndr_push_winbind_header_version(ndr, NDR_SCALARS, WINBIND_HEADER_VERSION));
  94                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->opnum));
  95                 NDR_CHECK(ndr_push_winbind_header_flags(ndr, NDR_SCALARS, r->flags));
  96         }
  97         if (ndr_flags & NDR_BUFFERS) {
  98         }
  99         return NDR_ERR_SUCCESS;
 100 }
 101
 102 _PUBLIC_ enum ndr_err_code ndr_pull_STRUCT_winbind_header(struct ndr_pull *ndr, int ndr_flags, struct winbind_header *r)
 103 {
 104         if (ndr_flags & NDR_SCALARS) {
 105                 NDR_CHECK(ndr_pull_align(ndr, 4));
 106                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
 107                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->magic, 4, sizeof(uint8_t), CH_DOS));
 108                 NDR_CHECK(ndr_pull_winbind_header_version(ndr, NDR_SCALARS, &r->version));
 109                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->opnum));
 110                 NDR_CHECK(ndr_pull_winbind_header_flags(ndr, NDR_SCALARS, &r->flags));
 111         }
 112         if (ndr_flags & NDR_BUFFERS) {
 113         }
 114         return NDR_ERR_SUCCESS;
 115 }
 116
 117 _PUBLIC_ void ndr_print_STRUCT_winbind_header(struct ndr_print *ndr, const char *name, const struct winbind_header *r)
 118 {
 119         ndr_print_struct(ndr, name, "winbind_header");
 120         ndr->depth++;
 121         ndr_print_uint32(ndr, "length", r->length);
 122         ndr_print_string(ndr, "magic", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?"WBPT":r->magic);
 123         ndr_print_winbind_header_version(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?WINBIND_HEADER_VERSION:r->version);
 124         ndr_print_uint16(ndr, "opnum", r->opnum);
 125         ndr_print_winbind_header_flags(ndr, "flags", r->flags);
 126         ndr->depth--;
 127 }
 128
 129 static enum ndr_err_code ndr_push_winbind_auth_level(struct ndr_push *ndr, int ndr_flags, enum winbind_auth_level 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_winbind_auth_level(struct ndr_pull *ndr, int ndr_flags, enum winbind_auth_level *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_winbind_auth_level(struct ndr_print *ndr, const char *name, enum winbind_auth_level r)
 144 {
 145         const char *val = NULL;
 146
 147         switch (r) {
 148                 case WINBIND_AUTH_LEVEL_COMPAT_AUTH_PLAIN: val = "WINBIND_AUTH_LEVEL_COMPAT_AUTH_PLAIN"; break;
 149                 case WINBIND_AUTH_LEVEL_COMPAT_AUTH_RESPONSE: val = "WINBIND_AUTH_LEVEL_COMPAT_AUTH_RESPONSE"; break;
 150                 case WINBIND_AUTH_LEVEL_COMPAT_LOGOFF: val = "WINBIND_AUTH_LEVEL_COMPAT_LOGOFF"; break;
 151                 case WINBIND_AUTH_LEVEL_CHANGE_PASSWORD_PLAIN: val = "WINBIND_AUTH_LEVEL_CHANGE_PASSWORD_PLAIN"; break;
 152                 case WINBIND_AUTH_LEVEL_CHANGE_PASSWORD_CRYPT: val = "WINBIND_AUTH_LEVEL_CHANGE_PASSWORD_CRYPT"; break;
 153         }
 154         ndr_print_enum(ndr, name, "ENUM", val, r);
 155 }
 156
 157 static enum ndr_err_code ndr_push_STRUCT_winbind_auth_compat_auth_plain_req(struct ndr_push *ndr, int ndr_flags, const struct winbind_auth_compat_auth_plain_req *r)
 158 {
 159         uint32_t cntr_require_membership_of_sids_1;
 160         if (ndr_flags & NDR_SCALARS) {
 161                 NDR_CHECK(ndr_push_align(ndr, 4));
 162                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
 163                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->account_name, CH_UTF8)));
 164                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 165                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->account_name, CH_UTF8)));
 166                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->account_name, ndr_charset_length(r->account_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 167                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
 168                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF8)));
 169                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 170                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF8)));
 171                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->password, ndr_charset_length(r->password, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 172                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_require_membership_of_sids));
 173                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->require_membership_of_sids));
 174                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->krb5_cc_type));
 175                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uid));
 176         }
 177         if (ndr_flags & NDR_BUFFERS) {
 178                 if (r->domain_name) {
 179                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF8)));
 180                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 181                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF8)));
 182                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 183                 }
 184                 if (r->require_membership_of_sids) {
 185                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_require_membership_of_sids));
 186                         for (cntr_require_membership_of_sids_1 = 0; cntr_require_membership_of_sids_1 < r->num_require_membership_of_sids; cntr_require_membership_of_sids_1++) {
 187                                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->require_membership_of_sids[cntr_require_membership_of_sids_1]));
 188                         }
 189                         for (cntr_require_membership_of_sids_1 = 0; cntr_require_membership_of_sids_1 < r->num_require_membership_of_sids; cntr_require_membership_of_sids_1++) {
 190                                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_BUFFERS, &r->require_membership_of_sids[cntr_require_membership_of_sids_1]));
 191                         }
 192                 }
 193                 if (r->krb5_cc_type) {
 194                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->krb5_cc_type, CH_UTF8)));
 195                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 196                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->krb5_cc_type, CH_UTF8)));
 197                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->krb5_cc_type, ndr_charset_length(r->krb5_cc_type, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 198                 }
 199                 if (r->uid) {
 200                         NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, *r->uid));
 201                 }
 202         }
 203         return NDR_ERR_SUCCESS;
 204 }
 205
 206 static enum ndr_err_code ndr_pull_STRUCT_winbind_auth_compat_auth_plain_req(struct ndr_pull *ndr, int ndr_flags, struct winbind_auth_compat_auth_plain_req *r)
 207 {
 208         uint32_t _ptr_domain_name;
 209         TALLOC_CTX *_mem_save_domain_name_0;
 210         uint32_t _ptr_require_membership_of_sids;
 211         uint32_t cntr_require_membership_of_sids_1;
 212         TALLOC_CTX *_mem_save_require_membership_of_sids_0;
 213         TALLOC_CTX *_mem_save_require_membership_of_sids_1;
 214         uint32_t _ptr_krb5_cc_type;
 215         TALLOC_CTX *_mem_save_krb5_cc_type_0;
 216         uint32_t _ptr_uid;
 217         TALLOC_CTX *_mem_save_uid_0;
 218         if (ndr_flags & NDR_SCALARS) {
 219                 NDR_CHECK(ndr_pull_align(ndr, 4));
 220                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
 221                 NDR_CHECK(ndr_pull_array_size(ndr, &r->account_name));
 222                 NDR_CHECK(ndr_pull_array_length(ndr, &r->account_name));
 223                 if (ndr_get_array_length(ndr, &r->account_name) > ndr_get_array_size(ndr, &r->account_name)) {
 224                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->account_name), ndr_get_array_length(ndr, &r->account_name));
 225                 }
 226                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->account_name), sizeof(uint8_t)));
 227                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->account_name, ndr_get_array_length(ndr, &r->account_name), sizeof(uint8_t), CH_UTF8));
 228                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
 229                 if (_ptr_domain_name) {
 230                         NDR_PULL_ALLOC(ndr, r->domain_name);
 231                 } else {
 232                         r->domain_name = NULL;
 233                 }
 234                 NDR_CHECK(ndr_pull_array_size(ndr, &r->password));
 235                 NDR_CHECK(ndr_pull_array_length(ndr, &r->password));
 236                 if (ndr_get_array_length(ndr, &r->password) > ndr_get_array_size(ndr, &r->password)) {
 237                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->password), ndr_get_array_length(ndr, &r->password));
 238                 }
 239                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->password), sizeof(uint8_t)));
 240                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->password, ndr_get_array_length(ndr, &r->password), sizeof(uint8_t), CH_UTF8));
 241                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_require_membership_of_sids));
 242                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_require_membership_of_sids));
 243                 if (_ptr_require_membership_of_sids) {
 244                         NDR_PULL_ALLOC(ndr, r->require_membership_of_sids);
 245                 } else {
 246                         r->require_membership_of_sids = NULL;
 247                 }
 248                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_krb5_cc_type));
 249                 if (_ptr_krb5_cc_type) {
 250                         NDR_PULL_ALLOC(ndr, r->krb5_cc_type);
 251                 } else {
 252                         r->krb5_cc_type = NULL;
 253                 }
 254                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uid));
 255                 if (_ptr_uid) {
 256                         NDR_PULL_ALLOC(ndr, r->uid);
 257                 } else {
 258                         r->uid = NULL;
 259                 }
 260         }
 261         if (ndr_flags & NDR_BUFFERS) {
 262                 if (r->domain_name) {
 263                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 264                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
 265                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
 266                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
 267                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
 268                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain_name), ndr_get_array_length(ndr, &r->domain_name));
 269                         }
 270                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint8_t)));
 271                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint8_t), CH_UTF8));
 272                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
 273                 }
 274                 if (r->require_membership_of_sids) {
 275                         _mem_save_require_membership_of_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 276                         NDR_PULL_SET_MEM_CTX(ndr, r->require_membership_of_sids, 0);
 277                         NDR_CHECK(ndr_pull_array_size(ndr, &r->require_membership_of_sids));
 278                         NDR_PULL_ALLOC_N(ndr, r->require_membership_of_sids, ndr_get_array_size(ndr, &r->require_membership_of_sids));
 279                         _mem_save_require_membership_of_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
 280                         NDR_PULL_SET_MEM_CTX(ndr, r->require_membership_of_sids, 0);
 281                         for (cntr_require_membership_of_sids_1 = 0; cntr_require_membership_of_sids_1 < r->num_require_membership_of_sids; cntr_require_membership_of_sids_1++) {
 282                                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, &r->require_membership_of_sids[cntr_require_membership_of_sids_1]));
 283                         }
 284                         for (cntr_require_membership_of_sids_1 = 0; cntr_require_membership_of_sids_1 < r->num_require_membership_of_sids; cntr_require_membership_of_sids_1++) {
 285                                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_BUFFERS, &r->require_membership_of_sids[cntr_require_membership_of_sids_1]));
 286                         }
 287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_require_membership_of_sids_1, 0);
 288                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_require_membership_of_sids_0, 0);
 289                 }
 290                 if (r->krb5_cc_type) {
 291                         _mem_save_krb5_cc_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
 292                         NDR_PULL_SET_MEM_CTX(ndr, r->krb5_cc_type, 0);
 293                         NDR_CHECK(ndr_pull_array_size(ndr, &r->krb5_cc_type));
 294                         NDR_CHECK(ndr_pull_array_length(ndr, &r->krb5_cc_type));
 295                         if (ndr_get_array_length(ndr, &r->krb5_cc_type) > ndr_get_array_size(ndr, &r->krb5_cc_type)) {
 296                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->krb5_cc_type), ndr_get_array_length(ndr, &r->krb5_cc_type));
 297                         }
 298                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->krb5_cc_type), sizeof(uint8_t)));
 299                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->krb5_cc_type, ndr_get_array_length(ndr, &r->krb5_cc_type), sizeof(uint8_t), CH_UTF8));
 300                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_krb5_cc_type_0, 0);
 301                 }
 302                 if (r->uid) {
 303                         _mem_save_uid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 304                         NDR_PULL_SET_MEM_CTX(ndr, r->uid, 0);
 305                         NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, r->uid));
 306                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uid_0, 0);
 307                 }
 308                 if (r->require_membership_of_sids) {
 309                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->require_membership_of_sids, r->num_require_membership_of_sids));
 310                 }
 311         }
 312         return NDR_ERR_SUCCESS;
 313 }
 314
 315 _PUBLIC_ void ndr_print_STRUCT_winbind_auth_compat_auth_plain_req(struct ndr_print *ndr, const char *name, const struct winbind_auth_compat_auth_plain_req *r)
 316 {
 317         uint32_t cntr_require_membership_of_sids_1;
 318         ndr_print_struct(ndr, name, "winbind_auth_compat_auth_plain_req");
 319         ndr->depth++;
 320         ndr_print_uint32(ndr, "flags", r->flags);
 321         ndr_print_string(ndr, "account_name", r->account_name);
 322         ndr_print_ptr(ndr, "domain_name", r->domain_name);
 323         ndr->depth++;
 324         if (r->domain_name) {
 325                 ndr_print_string(ndr, "domain_name", r->domain_name);
 326         }
 327         ndr->depth--;
 328         ndr_print_string(ndr, "password", r->password);
 329         ndr_print_uint32(ndr, "num_require_membership_of_sids", r->num_require_membership_of_sids);
 330         ndr_print_ptr(ndr, "require_membership_of_sids", r->require_membership_of_sids);
 331         ndr->depth++;
 332         if (r->require_membership_of_sids) {
 333                 ndr->print(ndr, "%s: ARRAY(%d)", "require_membership_of_sids", r->num_require_membership_of_sids);
 334                 ndr->depth++;
 335                 for (cntr_require_membership_of_sids_1=0;cntr_require_membership_of_sids_1<r->num_require_membership_of_sids;cntr_require_membership_of_sids_1++) {
 336                         char *idx_1=NULL;
 337                         if (asprintf(&idx_1, "[%d]", cntr_require_membership_of_sids_1) != -1) {
 338                                 ndr_print_dom_sid(ndr, "require_membership_of_sids", &r->require_membership_of_sids[cntr_require_membership_of_sids_1]);
 339                                 free(idx_1);
 340                         }
 341                 }
 342                 ndr->depth--;
 343         }
 344         ndr->depth--;
 345         ndr_print_ptr(ndr, "krb5_cc_type", r->krb5_cc_type);
 346         ndr->depth++;
 347         if (r->krb5_cc_type) {
 348                 ndr_print_string(ndr, "krb5_cc_type", r->krb5_cc_type);
 349         }
 350         ndr->depth--;
 351         ndr_print_ptr(ndr, "uid", r->uid);
 352         ndr->depth++;
 353         if (r->uid) {
 354                 ndr_print_hyper(ndr, "uid", *r->uid);
 355         }
 356         ndr->depth--;
 357         ndr->depth--;
 358 }
 359
 360 static enum ndr_err_code ndr_push_STRUCT_winbind_auth_compat_auth_rep(struct ndr_push *ndr, int ndr_flags, const struct winbind_auth_compat_auth_rep *r)
 361 {
 362         if (ndr_flags & NDR_SCALARS) {
 363                 NDR_CHECK(ndr_push_align(ndr, 4));
 364                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->unix_username));
 365                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->krb5_cc_name));
 366                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
 367                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->password_policy));
 368                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->afs_token));
 369         }
 370         if (ndr_flags & NDR_BUFFERS) {
 371                 if (r->unix_username) {
 372                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->unix_username, CH_UTF8)));
 373                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 374                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->unix_username, CH_UTF8)));
 375                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->unix_username, ndr_charset_length(r->unix_username, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 376                 }
 377                 if (r->krb5_cc_name) {
 378                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->krb5_cc_name, CH_UTF8)));
 379                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 380                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->krb5_cc_name, CH_UTF8)));
 381                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->krb5_cc_name, ndr_charset_length(r->krb5_cc_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 382                 }
 383                 if (r->info3) {
 384                         NDR_CHECK(ndr_push_netr_SamInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
 385                 }
 386                 if (r->password_policy) {
 387                         NDR_CHECK(ndr_push_samr_DomInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->password_policy));
 388                 }
 389                 if (r->afs_token) {
 390                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->afs_token));
 391                 }
 392         }
 393         return NDR_ERR_SUCCESS;
 394 }
 395
 396 static enum ndr_err_code ndr_pull_STRUCT_winbind_auth_compat_auth_rep(struct ndr_pull *ndr, int ndr_flags, struct winbind_auth_compat_auth_rep *r)
 397 {
 398         uint32_t _ptr_unix_username;
 399         TALLOC_CTX *_mem_save_unix_username_0;
 400         uint32_t _ptr_krb5_cc_name;
 401         TALLOC_CTX *_mem_save_krb5_cc_name_0;
 402         uint32_t _ptr_info3;
 403         TALLOC_CTX *_mem_save_info3_0;
 404         uint32_t _ptr_password_policy;
 405         TALLOC_CTX *_mem_save_password_policy_0;
 406         uint32_t _ptr_afs_token;
 407         TALLOC_CTX *_mem_save_afs_token_0;
 408         if (ndr_flags & NDR_SCALARS) {
 409                 NDR_CHECK(ndr_pull_align(ndr, 4));
 410                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unix_username));
 411                 if (_ptr_unix_username) {
 412                         NDR_PULL_ALLOC(ndr, r->unix_username);
 413                 } else {
 414                         r->unix_username = NULL;
 415                 }
 416                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_krb5_cc_name));
 417                 if (_ptr_krb5_cc_name) {
 418                         NDR_PULL_ALLOC(ndr, r->krb5_cc_name);
 419                 } else {
 420                         r->krb5_cc_name = NULL;
 421                 }
 422                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
 423                 if (_ptr_info3) {
 424                         NDR_PULL_ALLOC(ndr, r->info3);
 425                 } else {
 426                         r->info3 = NULL;
 427                 }
 428                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password_policy));
 429                 if (_ptr_password_policy) {
 430                         NDR_PULL_ALLOC(ndr, r->password_policy);
 431                 } else {
 432                         r->password_policy = NULL;
 433                 }
 434                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_afs_token));
 435                 if (_ptr_afs_token) {
 436                         NDR_PULL_ALLOC(ndr, r->afs_token);
 437                 } else {
 438                         r->afs_token = NULL;
 439                 }
 440         }
 441         if (ndr_flags & NDR_BUFFERS) {
 442                 if (r->unix_username) {
 443                         _mem_save_unix_username_0 = NDR_PULL_GET_MEM_CTX(ndr);
 444                         NDR_PULL_SET_MEM_CTX(ndr, r->unix_username, 0);
 445                         NDR_CHECK(ndr_pull_array_size(ndr, &r->unix_username));
 446                         NDR_CHECK(ndr_pull_array_length(ndr, &r->unix_username));
 447                         if (ndr_get_array_length(ndr, &r->unix_username) > ndr_get_array_size(ndr, &r->unix_username)) {
 448                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->unix_username), ndr_get_array_length(ndr, &r->unix_username));
 449                         }
 450                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->unix_username), sizeof(uint8_t)));
 451                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->unix_username, ndr_get_array_length(ndr, &r->unix_username), sizeof(uint8_t), CH_UTF8));
 452                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unix_username_0, 0);
 453                 }
 454                 if (r->krb5_cc_name) {
 455                         _mem_save_krb5_cc_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 456                         NDR_PULL_SET_MEM_CTX(ndr, r->krb5_cc_name, 0);
 457                         NDR_CHECK(ndr_pull_array_size(ndr, &r->krb5_cc_name));
 458                         NDR_CHECK(ndr_pull_array_length(ndr, &r->krb5_cc_name));
 459                         if (ndr_get_array_length(ndr, &r->krb5_cc_name) > ndr_get_array_size(ndr, &r->krb5_cc_name)) {
 460                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->krb5_cc_name), ndr_get_array_length(ndr, &r->krb5_cc_name));
 461                         }
 462                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->krb5_cc_name), sizeof(uint8_t)));
 463                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->krb5_cc_name, ndr_get_array_length(ndr, &r->krb5_cc_name), sizeof(uint8_t), CH_UTF8));
 464                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_krb5_cc_name_0, 0);
 465                 }
 466                 if (r->info3) {
 467                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
 468                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
 469                         NDR_CHECK(ndr_pull_netr_SamInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
 470                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
 471                 }
 472                 if (r->password_policy) {
 473                         _mem_save_password_policy_0 = NDR_PULL_GET_MEM_CTX(ndr);
 474                         NDR_PULL_SET_MEM_CTX(ndr, r->password_policy, 0);
 475                         NDR_CHECK(ndr_pull_samr_DomInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->password_policy));
 476                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_policy_0, 0);
 477                 }
 478                 if (r->afs_token) {
 479                         _mem_save_afs_token_0 = NDR_PULL_GET_MEM_CTX(ndr);
 480                         NDR_PULL_SET_MEM_CTX(ndr, r->afs_token, 0);
 481                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->afs_token));
 482                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_afs_token_0, 0);
 483                 }
 484         }
 485         return NDR_ERR_SUCCESS;
 486 }
 487
 488 _PUBLIC_ void ndr_print_STRUCT_winbind_auth_compat_auth_rep(struct ndr_print *ndr, const char *name, const struct winbind_auth_compat_auth_rep *r)
 489 {
 490         ndr_print_struct(ndr, name, "winbind_auth_compat_auth_rep");
 491         ndr->depth++;
 492         ndr_print_ptr(ndr, "unix_username", r->unix_username);
 493         ndr->depth++;
 494         if (r->unix_username) {
 495                 ndr_print_string(ndr, "unix_username", r->unix_username);
 496         }
 497         ndr->depth--;
 498         ndr_print_ptr(ndr, "krb5_cc_name", r->krb5_cc_name);
 499         ndr->depth++;
 500         if (r->krb5_cc_name) {
 501                 ndr_print_string(ndr, "krb5_cc_name", r->krb5_cc_name);
 502         }
 503         ndr->depth--;
 504         ndr_print_ptr(ndr, "info3", r->info3);
 505         ndr->depth++;
 506         if (r->info3) {
 507                 ndr_print_netr_SamInfo3(ndr, "info3", r->info3);
 508         }
 509         ndr->depth--;
 510         ndr_print_ptr(ndr, "password_policy", r->password_policy);
 511         ndr->depth++;
 512         if (r->password_policy) {
 513                 ndr_print_samr_DomInfo1(ndr, "password_policy", r->password_policy);
 514         }
 515         ndr->depth--;
 516         ndr_print_ptr(ndr, "afs_token", r->afs_token);
 517         ndr->depth++;
 518         if (r->afs_token) {
 519                 ndr_print_DATA_BLOB(ndr, "afs_token", *r->afs_token);
 520         }
 521         ndr->depth--;
 522         ndr->depth--;
 523 }
 524
 525 static enum ndr_err_code ndr_push_STRUCT_winbind_auth_compat_auth_response_req(struct ndr_push *ndr, int ndr_flags, const struct winbind_auth_compat_auth_response_req *r)
 526 {
 527         uint32_t cntr_require_membership_of_sids_1;
 528         if (ndr_flags & NDR_SCALARS) {
 529                 NDR_CHECK(ndr_push_align(ndr, 4));
 530                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
 531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->account_name, CH_UTF8)));
 532                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 533                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->account_name, CH_UTF8)));
 534                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->account_name, ndr_charset_length(r->account_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 535                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
 536                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->workstation_name));
 537                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_require_membership_of_sids));
 538                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->require_membership_of_sids));
 539                 NDR_CHECK(ndr_push_netr_LogonParameterControl(ndr, NDR_SCALARS, r->logon_parameters));
 540                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->challenge, 8));
 541                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->lm_response));
 542                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->nt_response));
 543         }
 544         if (ndr_flags & NDR_BUFFERS) {
 545                 if (r->domain_name) {
 546                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF8)));
 547                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 548                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF8)));
 549                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 550                 }
 551                 if (r->workstation_name) {
 552                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->workstation_name, CH_UTF8)));
 553                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 554                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->workstation_name, CH_UTF8)));
 555                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->workstation_name, ndr_charset_length(r->workstation_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 556                 }
 557                 if (r->require_membership_of_sids) {
 558                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_require_membership_of_sids));
 559                         for (cntr_require_membership_of_sids_1 = 0; cntr_require_membership_of_sids_1 < r->num_require_membership_of_sids; cntr_require_membership_of_sids_1++) {
 560                                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->require_membership_of_sids[cntr_require_membership_of_sids_1]));
 561                         }
 562                         for (cntr_require_membership_of_sids_1 = 0; cntr_require_membership_of_sids_1 < r->num_require_membership_of_sids; cntr_require_membership_of_sids_1++) {
 563                                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_BUFFERS, &r->require_membership_of_sids[cntr_require_membership_of_sids_1]));
 564                         }
 565                 }
 566         }
 567         return NDR_ERR_SUCCESS;
 568 }
 569
 570 static enum ndr_err_code ndr_pull_STRUCT_winbind_auth_compat_auth_response_req(struct ndr_pull *ndr, int ndr_flags, struct winbind_auth_compat_auth_response_req *r)
 571 {
 572         uint32_t _ptr_domain_name;
 573         TALLOC_CTX *_mem_save_domain_name_0;
 574         uint32_t _ptr_workstation_name;
 575         TALLOC_CTX *_mem_save_workstation_name_0;
 576         uint32_t _ptr_require_membership_of_sids;
 577         uint32_t cntr_require_membership_of_sids_1;
 578         TALLOC_CTX *_mem_save_require_membership_of_sids_0;
 579         TALLOC_CTX *_mem_save_require_membership_of_sids_1;
 580         if (ndr_flags & NDR_SCALARS) {
 581                 NDR_CHECK(ndr_pull_align(ndr, 4));
 582                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
 583                 NDR_CHECK(ndr_pull_array_size(ndr, &r->account_name));
 584                 NDR_CHECK(ndr_pull_array_length(ndr, &r->account_name));
 585                 if (ndr_get_array_length(ndr, &r->account_name) > ndr_get_array_size(ndr, &r->account_name)) {
 586                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->account_name), ndr_get_array_length(ndr, &r->account_name));
 587                 }
 588                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->account_name), sizeof(uint8_t)));
 589                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->account_name, ndr_get_array_length(ndr, &r->account_name), sizeof(uint8_t), CH_UTF8));
 590                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
 591                 if (_ptr_domain_name) {
 592                         NDR_PULL_ALLOC(ndr, r->domain_name);
 593                 } else {
 594                         r->domain_name = NULL;
 595                 }
 596                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_workstation_name));
 597                 if (_ptr_workstation_name) {
 598                         NDR_PULL_ALLOC(ndr, r->workstation_name);
 599                 } else {
 600                         r->workstation_name = NULL;
 601                 }
 602                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_require_membership_of_sids));
 603                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_require_membership_of_sids));
 604                 if (_ptr_require_membership_of_sids) {
 605                         NDR_PULL_ALLOC(ndr, r->require_membership_of_sids);
 606                 } else {
 607                         r->require_membership_of_sids = NULL;
 608                 }
 609                 NDR_CHECK(ndr_pull_netr_LogonParameterControl(ndr, NDR_SCALARS, &r->logon_parameters));
 610                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->challenge, 8));
 611                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->lm_response));
 612                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->nt_response));
 613         }
 614         if (ndr_flags & NDR_BUFFERS) {
 615                 if (r->domain_name) {
 616                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 617                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
 618                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
 619                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
 620                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
 621                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain_name), ndr_get_array_length(ndr, &r->domain_name));
 622                         }
 623                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint8_t)));
 624                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint8_t), CH_UTF8));
 625                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
 626                 }
 627                 if (r->workstation_name) {
 628                         _mem_save_workstation_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 629                         NDR_PULL_SET_MEM_CTX(ndr, r->workstation_name, 0);
 630                         NDR_CHECK(ndr_pull_array_size(ndr, &r->workstation_name));
 631                         NDR_CHECK(ndr_pull_array_length(ndr, &r->workstation_name));
 632                         if (ndr_get_array_length(ndr, &r->workstation_name) > ndr_get_array_size(ndr, &r->workstation_name)) {
 633                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->workstation_name), ndr_get_array_length(ndr, &r->workstation_name));
 634                         }
 635                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->workstation_name), sizeof(uint8_t)));
 636                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->workstation_name, ndr_get_array_length(ndr, &r->workstation_name), sizeof(uint8_t), CH_UTF8));
 637                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_workstation_name_0, 0);
 638                 }
 639                 if (r->require_membership_of_sids) {
 640                         _mem_save_require_membership_of_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 641                         NDR_PULL_SET_MEM_CTX(ndr, r->require_membership_of_sids, 0);
 642                         NDR_CHECK(ndr_pull_array_size(ndr, &r->require_membership_of_sids));
 643                         NDR_PULL_ALLOC_N(ndr, r->require_membership_of_sids, ndr_get_array_size(ndr, &r->require_membership_of_sids));
 644                         _mem_save_require_membership_of_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
 645                         NDR_PULL_SET_MEM_CTX(ndr, r->require_membership_of_sids, 0);
 646                         for (cntr_require_membership_of_sids_1 = 0; cntr_require_membership_of_sids_1 < r->num_require_membership_of_sids; cntr_require_membership_of_sids_1++) {
 647                                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, &r->require_membership_of_sids[cntr_require_membership_of_sids_1]));
 648                         }
 649                         for (cntr_require_membership_of_sids_1 = 0; cntr_require_membership_of_sids_1 < r->num_require_membership_of_sids; cntr_require_membership_of_sids_1++) {
 650                                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_BUFFERS, &r->require_membership_of_sids[cntr_require_membership_of_sids_1]));
 651                         }
 652                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_require_membership_of_sids_1, 0);
 653                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_require_membership_of_sids_0, 0);
 654                 }
 655                 if (r->require_membership_of_sids) {
 656                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->require_membership_of_sids, r->num_require_membership_of_sids));
 657                 }
 658         }
 659         return NDR_ERR_SUCCESS;
 660 }
 661
 662 _PUBLIC_ void ndr_print_STRUCT_winbind_auth_compat_auth_response_req(struct ndr_print *ndr, const char *name, const struct winbind_auth_compat_auth_response_req *r)
 663 {
 664         uint32_t cntr_require_membership_of_sids_1;
 665         ndr_print_struct(ndr, name, "winbind_auth_compat_auth_response_req");
 666         ndr->depth++;
 667         ndr_print_uint32(ndr, "flags", r->flags);
 668         ndr_print_string(ndr, "account_name", r->account_name);
 669         ndr_print_ptr(ndr, "domain_name", r->domain_name);
 670         ndr->depth++;
 671         if (r->domain_name) {
 672                 ndr_print_string(ndr, "domain_name", r->domain_name);
 673         }
 674         ndr->depth--;
 675         ndr_print_ptr(ndr, "workstation_name", r->workstation_name);
 676         ndr->depth++;
 677         if (r->workstation_name) {
 678                 ndr_print_string(ndr, "workstation_name", r->workstation_name);
 679         }
 680         ndr->depth--;
 681         ndr_print_uint32(ndr, "num_require_membership_of_sids", r->num_require_membership_of_sids);
 682         ndr_print_ptr(ndr, "require_membership_of_sids", r->require_membership_of_sids);
 683         ndr->depth++;
 684         if (r->require_membership_of_sids) {
 685                 ndr->print(ndr, "%s: ARRAY(%d)", "require_membership_of_sids", r->num_require_membership_of_sids);
 686                 ndr->depth++;
 687                 for (cntr_require_membership_of_sids_1=0;cntr_require_membership_of_sids_1<r->num_require_membership_of_sids;cntr_require_membership_of_sids_1++) {
 688                         char *idx_1=NULL;
 689                         if (asprintf(&idx_1, "[%d]", cntr_require_membership_of_sids_1) != -1) {
 690                                 ndr_print_dom_sid(ndr, "require_membership_of_sids", &r->require_membership_of_sids[cntr_require_membership_of_sids_1]);
 691                                 free(idx_1);
 692                         }
 693                 }
 694                 ndr->depth--;
 695         }
 696         ndr->depth--;
 697         ndr_print_netr_LogonParameterControl(ndr, "logon_parameters", r->logon_parameters);
 698         ndr_print_array_uint8(ndr, "challenge", r->challenge, 8);
 699         ndr_print_DATA_BLOB(ndr, "lm_response", r->lm_response);
 700         ndr_print_DATA_BLOB(ndr, "nt_response", r->nt_response);
 701         ndr->depth--;
 702 }
 703
 704 static enum ndr_err_code ndr_push_STRUCT_winbind_auth_compat_logoff_req(struct ndr_push *ndr, int ndr_flags, const struct winbind_auth_compat_logoff_req *r)
 705 {
 706         if (ndr_flags & NDR_SCALARS) {
 707                 NDR_CHECK(ndr_push_align(ndr, 4));
 708                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
 709                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->account_name, CH_UTF8)));
 710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 711                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->account_name, CH_UTF8)));
 712                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->account_name, ndr_charset_length(r->account_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 713                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
 714                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->krb5_cc_name));
 715                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uid));
 716         }
 717         if (ndr_flags & NDR_BUFFERS) {
 718                 if (r->domain_name) {
 719                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF8)));
 720                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 721                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF8)));
 722                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 723                 }
 724                 if (r->krb5_cc_name) {
 725                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->krb5_cc_name, CH_UTF8)));
 726                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 727                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->krb5_cc_name, CH_UTF8)));
 728                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->krb5_cc_name, ndr_charset_length(r->krb5_cc_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 729                 }
 730                 if (r->uid) {
 731                         NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, *r->uid));
 732                 }
 733         }
 734         return NDR_ERR_SUCCESS;
 735 }
 736
 737 static enum ndr_err_code ndr_pull_STRUCT_winbind_auth_compat_logoff_req(struct ndr_pull *ndr, int ndr_flags, struct winbind_auth_compat_logoff_req *r)
 738 {
 739         uint32_t _ptr_domain_name;
 740         TALLOC_CTX *_mem_save_domain_name_0;
 741         uint32_t _ptr_krb5_cc_name;
 742         TALLOC_CTX *_mem_save_krb5_cc_name_0;
 743         uint32_t _ptr_uid;
 744         TALLOC_CTX *_mem_save_uid_0;
 745         if (ndr_flags & NDR_SCALARS) {
 746                 NDR_CHECK(ndr_pull_align(ndr, 4));
 747                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
 748                 NDR_CHECK(ndr_pull_array_size(ndr, &r->account_name));
 749                 NDR_CHECK(ndr_pull_array_length(ndr, &r->account_name));
 750                 if (ndr_get_array_length(ndr, &r->account_name) > ndr_get_array_size(ndr, &r->account_name)) {
 751                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->account_name), ndr_get_array_length(ndr, &r->account_name));
 752                 }
 753                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->account_name), sizeof(uint8_t)));
 754                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->account_name, ndr_get_array_length(ndr, &r->account_name), sizeof(uint8_t), CH_UTF8));
 755                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
 756                 if (_ptr_domain_name) {
 757                         NDR_PULL_ALLOC(ndr, r->domain_name);
 758                 } else {
 759                         r->domain_name = NULL;
 760                 }
 761                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_krb5_cc_name));
 762                 if (_ptr_krb5_cc_name) {
 763                         NDR_PULL_ALLOC(ndr, r->krb5_cc_name);
 764                 } else {
 765                         r->krb5_cc_name = NULL;
 766                 }
 767                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uid));
 768                 if (_ptr_uid) {
 769                         NDR_PULL_ALLOC(ndr, r->uid);
 770                 } else {
 771                         r->uid = NULL;
 772                 }
 773         }
 774         if (ndr_flags & NDR_BUFFERS) {
 775                 if (r->domain_name) {
 776                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 777                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
 778                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
 779                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
 780                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
 781                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain_name), ndr_get_array_length(ndr, &r->domain_name));
 782                         }
 783                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint8_t)));
 784                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint8_t), CH_UTF8));
 785                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
 786                 }
 787                 if (r->krb5_cc_name) {
 788                         _mem_save_krb5_cc_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 789                         NDR_PULL_SET_MEM_CTX(ndr, r->krb5_cc_name, 0);
 790                         NDR_CHECK(ndr_pull_array_size(ndr, &r->krb5_cc_name));
 791                         NDR_CHECK(ndr_pull_array_length(ndr, &r->krb5_cc_name));
 792                         if (ndr_get_array_length(ndr, &r->krb5_cc_name) > ndr_get_array_size(ndr, &r->krb5_cc_name)) {
 793                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->krb5_cc_name), ndr_get_array_length(ndr, &r->krb5_cc_name));
 794                         }
 795                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->krb5_cc_name), sizeof(uint8_t)));
 796                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->krb5_cc_name, ndr_get_array_length(ndr, &r->krb5_cc_name), sizeof(uint8_t), CH_UTF8));
 797                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_krb5_cc_name_0, 0);
 798                 }
 799                 if (r->uid) {
 800                         _mem_save_uid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 801                         NDR_PULL_SET_MEM_CTX(ndr, r->uid, 0);
 802                         NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, r->uid));
 803                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uid_0, 0);
 804                 }
 805         }
 806         return NDR_ERR_SUCCESS;
 807 }
 808
 809 _PUBLIC_ void ndr_print_STRUCT_winbind_auth_compat_logoff_req(struct ndr_print *ndr, const char *name, const struct winbind_auth_compat_logoff_req *r)
 810 {
 811         ndr_print_struct(ndr, name, "winbind_auth_compat_logoff_req");
 812         ndr->depth++;
 813         ndr_print_uint32(ndr, "flags", r->flags);
 814         ndr_print_string(ndr, "account_name", r->account_name);
 815         ndr_print_ptr(ndr, "domain_name", r->domain_name);
 816         ndr->depth++;
 817         if (r->domain_name) {
 818                 ndr_print_string(ndr, "domain_name", r->domain_name);
 819         }
 820         ndr->depth--;
 821         ndr_print_ptr(ndr, "krb5_cc_name", r->krb5_cc_name);
 822         ndr->depth++;
 823         if (r->krb5_cc_name) {
 824                 ndr_print_string(ndr, "krb5_cc_name", r->krb5_cc_name);
 825         }
 826         ndr->depth--;
 827         ndr_print_ptr(ndr, "uid", r->uid);
 828         ndr->depth++;
 829         if (r->uid) {
 830                 ndr_print_hyper(ndr, "uid", *r->uid);
 831         }
 832         ndr->depth--;
 833         ndr->depth--;
 834 }
 835
 836 static enum ndr_err_code ndr_push_STRUCT_winbind_auth_change_password_plain_req(struct ndr_push *ndr, int ndr_flags, const struct winbind_auth_change_password_plain_req *r)
 837 {
 838         if (ndr_flags & NDR_SCALARS) {
 839                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->new_password, CH_UTF8)));
 840                 NDR_CHECK(ndr_push_align(ndr, 4));
 841                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->account_name, CH_UTF8)));
 842                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 843                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->account_name, CH_UTF8)));
 844                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->account_name, ndr_charset_length(r->account_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 845                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
 846                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->old_password, CH_UTF8)));
 847                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 848                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->old_password, CH_UTF8)));
 849                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->old_password, ndr_charset_length(r->old_password, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 850                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 851                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->new_password, CH_UTF8)));
 852                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->new_password, ndr_charset_length(r->new_password, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 853         }
 854         if (ndr_flags & NDR_BUFFERS) {
 855                 if (r->domain_name) {
 856                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF8)));
 857                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 858                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF8)));
 859                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 860                 }
 861         }
 862         return NDR_ERR_SUCCESS;
 863 }
 864
 865 static enum ndr_err_code ndr_pull_STRUCT_winbind_auth_change_password_plain_req(struct ndr_pull *ndr, int ndr_flags, struct winbind_auth_change_password_plain_req *r)
 866 {
 867         uint32_t _ptr_domain_name;
 868         TALLOC_CTX *_mem_save_domain_name_0;
 869         if (ndr_flags & NDR_SCALARS) {
 870                 NDR_CHECK(ndr_pull_array_size(ndr, &r->new_password));
 871                 NDR_CHECK(ndr_pull_align(ndr, 4));
 872                 NDR_CHECK(ndr_pull_array_size(ndr, &r->account_name));
 873                 NDR_CHECK(ndr_pull_array_length(ndr, &r->account_name));
 874                 if (ndr_get_array_length(ndr, &r->account_name) > ndr_get_array_size(ndr, &r->account_name)) {
 875                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->account_name), ndr_get_array_length(ndr, &r->account_name));
 876                 }
 877                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->account_name), sizeof(uint8_t)));
 878                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->account_name, ndr_get_array_length(ndr, &r->account_name), sizeof(uint8_t), CH_UTF8));
 879                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
 880                 if (_ptr_domain_name) {
 881                         NDR_PULL_ALLOC(ndr, r->domain_name);
 882                 } else {
 883                         r->domain_name = NULL;
 884                 }
 885                 NDR_CHECK(ndr_pull_array_size(ndr, &r->old_password));
 886                 NDR_CHECK(ndr_pull_array_length(ndr, &r->old_password));
 887                 if (ndr_get_array_length(ndr, &r->old_password) > ndr_get_array_size(ndr, &r->old_password)) {
 888                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->old_password), ndr_get_array_length(ndr, &r->old_password));
 889                 }
 890                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->old_password), sizeof(uint8_t)));
 891                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->old_password, ndr_get_array_length(ndr, &r->old_password), sizeof(uint8_t), CH_UTF8));
 892                 NDR_CHECK(ndr_pull_array_length(ndr, &r->new_password));
 893                 if (ndr_get_array_length(ndr, &r->new_password) > ndr_get_array_size(ndr, &r->new_password)) {
 894                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->new_password), ndr_get_array_length(ndr, &r->new_password));
 895                 }
 896                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->new_password), sizeof(uint8_t)));
 897                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->new_password, ndr_get_array_length(ndr, &r->new_password), sizeof(uint8_t), CH_UTF8));
 898         }
 899         if (ndr_flags & NDR_BUFFERS) {
 900                 if (r->domain_name) {
 901                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 902                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
 903                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
 904                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
 905                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
 906                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain_name), ndr_get_array_length(ndr, &r->domain_name));
 907                         }
 908                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint8_t)));
 909                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint8_t), CH_UTF8));
 910                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
 911                 }
 912         }
 913         return NDR_ERR_SUCCESS;
 914 }
 915
 916 _PUBLIC_ void ndr_print_STRUCT_winbind_auth_change_password_plain_req(struct ndr_print *ndr, const char *name, const struct winbind_auth_change_password_plain_req *r)
 917 {
 918         ndr_print_struct(ndr, name, "winbind_auth_change_password_plain_req");
 919         ndr->depth++;
 920         ndr_print_string(ndr, "account_name", r->account_name);
 921         ndr_print_ptr(ndr, "domain_name", r->domain_name);
 922         ndr->depth++;
 923         if (r->domain_name) {
 924                 ndr_print_string(ndr, "domain_name", r->domain_name);
 925         }
 926         ndr->depth--;
 927         ndr_print_string(ndr, "old_password", r->old_password);
 928         ndr_print_string(ndr, "new_password", r->new_password);
 929         ndr->depth--;
 930 }
 931
 932 static enum ndr_err_code ndr_push_STRUCT_winbind_auth_change_password_crypt_req(struct ndr_push *ndr, int ndr_flags, const struct winbind_auth_change_password_crypt_req *r)
 933 {
 934         if (ndr_flags & NDR_SCALARS) {
 935                 NDR_CHECK(ndr_push_align(ndr, 4));
 936                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->account_name, CH_UTF8)));
 937                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 938                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->account_name, CH_UTF8)));
 939                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->account_name, ndr_charset_length(r->account_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 940                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
 941                 NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, &r->nt_password));
 942                 NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->nt_verifier));
 943                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->lm_password));
 944                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->lm_verifier));
 945         }
 946         if (ndr_flags & NDR_BUFFERS) {
 947                 if (r->domain_name) {
 948                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF8)));
 949                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 950                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF8)));
 951                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 952                 }
 953                 if (r->lm_password) {
 954                         NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->lm_password));
 955                 }
 956                 if (r->lm_verifier) {
 957                         NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->lm_verifier));
 958                 }
 959         }
 960         return NDR_ERR_SUCCESS;
 961 }
 962
 963 static enum ndr_err_code ndr_pull_STRUCT_winbind_auth_change_password_crypt_req(struct ndr_pull *ndr, int ndr_flags, struct winbind_auth_change_password_crypt_req *r)
 964 {
 965         uint32_t _ptr_domain_name;
 966         TALLOC_CTX *_mem_save_domain_name_0;
 967         uint32_t _ptr_lm_password;
 968         TALLOC_CTX *_mem_save_lm_password_0;
 969         uint32_t _ptr_lm_verifier;
 970         TALLOC_CTX *_mem_save_lm_verifier_0;
 971         if (ndr_flags & NDR_SCALARS) {
 972                 NDR_CHECK(ndr_pull_align(ndr, 4));
 973                 NDR_CHECK(ndr_pull_array_size(ndr, &r->account_name));
 974                 NDR_CHECK(ndr_pull_array_length(ndr, &r->account_name));
 975                 if (ndr_get_array_length(ndr, &r->account_name) > ndr_get_array_size(ndr, &r->account_name)) {
 976                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->account_name), ndr_get_array_length(ndr, &r->account_name));
 977                 }
 978                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->account_name), sizeof(uint8_t)));
 979                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->account_name, ndr_get_array_length(ndr, &r->account_name), sizeof(uint8_t), CH_UTF8));
 980                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
 981                 if (_ptr_domain_name) {
 982                         NDR_PULL_ALLOC(ndr, r->domain_name);
 983                 } else {
 984                         r->domain_name = NULL;
 985                 }
 986                 NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, &r->nt_password));
 987                 NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->nt_verifier));
 988                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_password));
 989                 if (_ptr_lm_password) {
 990                         NDR_PULL_ALLOC(ndr, r->lm_password);
 991                 } else {
 992                         r->lm_password = NULL;
 993                 }
 994                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_verifier));
 995                 if (_ptr_lm_verifier) {
 996                         NDR_PULL_ALLOC(ndr, r->lm_verifier);
 997                 } else {
 998                         r->lm_verifier = NULL;
 999                 }
1000         }
1001         if (ndr_flags & NDR_BUFFERS) {
1002                 if (r->domain_name) {
1003                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1004                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
1005                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
1006                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
1007                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
1008                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain_name), ndr_get_array_length(ndr, &r->domain_name));
1009                         }
1010                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint8_t)));
1011                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint8_t), CH_UTF8));
1012                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
1013                 }
1014                 if (r->lm_password) {
1015                         _mem_save_lm_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
1016                         NDR_PULL_SET_MEM_CTX(ndr, r->lm_password, 0);
1017                         NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->lm_password));
1018                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_password_0, 0);
1019                 }
1020                 if (r->lm_verifier) {
1021                         _mem_save_lm_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
1022                         NDR_PULL_SET_MEM_CTX(ndr, r->lm_verifier, 0);
1023                         NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->lm_verifier));
1024                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_verifier_0, 0);
1025                 }
1026         }
1027         return NDR_ERR_SUCCESS;
1028 }
1029
1030 _PUBLIC_ void ndr_print_STRUCT_winbind_auth_change_password_crypt_req(struct ndr_print *ndr, const char *name, const struct winbind_auth_change_password_crypt_req *r)
1031 {
1032         ndr_print_struct(ndr, name, "winbind_auth_change_password_crypt_req");
1033         ndr->depth++;
1034         ndr_print_string(ndr, "account_name", r->account_name);
1035         ndr_print_ptr(ndr, "domain_name", r->domain_name);
1036         ndr->depth++;
1037         if (r->domain_name) {
1038                 ndr_print_string(ndr, "domain_name", r->domain_name);
1039         }
1040         ndr->depth--;
1041         ndr_print_samr_CryptPassword(ndr, "nt_password", &r->nt_password);
1042         ndr_print_samr_Password(ndr, "nt_verifier", &r->nt_verifier);
1043         ndr_print_ptr(ndr, "lm_password", r->lm_password);
1044         ndr->depth++;
1045         if (r->lm_password) {
1046                 ndr_print_samr_CryptPassword(ndr, "lm_password", r->lm_password);
1047         }
1048         ndr->depth--;
1049         ndr_print_ptr(ndr, "lm_verifier", r->lm_verifier);
1050         ndr->depth++;
1051         if (r->lm_verifier) {
1052                 ndr_print_samr_Password(ndr, "lm_verifier", r->lm_verifier);
1053         }
1054         ndr->depth--;
1055         ndr->depth--;
1056 }
1057
1058 static enum ndr_err_code ndr_push_winbind_auth_req(struct ndr_push *ndr, int ndr_flags, const union winbind_auth_req *r)
1059 {
1060         if (ndr_flags & NDR_SCALARS) {
1061                 int level = ndr_push_get_switch_value(ndr, r);
1062                 NDR_CHECK(ndr_push_winbind_auth_level(ndr, NDR_SCALARS, level));
1063                 switch (level) {
1064                         case WINBIND_AUTH_LEVEL_COMPAT_AUTH_PLAIN: {
1065                                 NDR_CHECK(ndr_push_STRUCT_winbind_auth_compat_auth_plain_req(ndr, NDR_SCALARS, &r->compat_auth_plain));
1066                         break; }
1067
1068                         case WINBIND_AUTH_LEVEL_COMPAT_AUTH_RESPONSE: {
1069                                 NDR_CHECK(ndr_push_STRUCT_winbind_auth_compat_auth_response_req(ndr, NDR_SCALARS, &r->compat_auth_response));
1070                         break; }
1071
1072                         case WINBIND_AUTH_LEVEL_COMPAT_LOGOFF: {
1073                                 NDR_CHECK(ndr_push_STRUCT_winbind_auth_compat_logoff_req(ndr, NDR_SCALARS, &r->compat_logoff));
1074                         break; }
1075
1076                         case WINBIND_AUTH_LEVEL_CHANGE_PASSWORD_PLAIN: {
1077                                 NDR_CHECK(ndr_push_STRUCT_winbind_auth_change_password_plain_req(ndr, NDR_SCALARS, &r->change_password_plain));
1078                         break; }
1079
1080                         case WINBIND_AUTH_LEVEL_CHANGE_PASSWORD_CRYPT: {
1081                                 NDR_CHECK(ndr_push_STRUCT_winbind_auth_change_password_crypt_req(ndr, NDR_SCALARS, &r->change_password_crypt));
1082                         break; }
1083
1084                         default: {
1085                         break; }
1086
1087                 }
1088         }
1089         if (ndr_flags & NDR_BUFFERS) {
1090                 int level = ndr_push_get_switch_value(ndr, r);
1091                 switch (level) {
1092                         case WINBIND_AUTH_LEVEL_COMPAT_AUTH_PLAIN:
1093                                 NDR_CHECK(ndr_push_STRUCT_winbind_auth_compat_auth_plain_req(ndr, NDR_BUFFERS, &r->compat_auth_plain));
1094                         break;
1095
1096                         case WINBIND_AUTH_LEVEL_COMPAT_AUTH_RESPONSE:
1097                                 NDR_CHECK(ndr_push_STRUCT_winbind_auth_compat_auth_response_req(ndr, NDR_BUFFERS, &r->compat_auth_response));
1098                         break;
1099
1100                         case WINBIND_AUTH_LEVEL_COMPAT_LOGOFF:
1101                                 NDR_CHECK(ndr_push_STRUCT_winbind_auth_compat_logoff_req(ndr, NDR_BUFFERS, &r->compat_logoff));
1102                         break;
1103
1104                         case WINBIND_AUTH_LEVEL_CHANGE_PASSWORD_PLAIN:
1105                                 NDR_CHECK(ndr_push_STRUCT_winbind_auth_change_password_plain_req(ndr, NDR_BUFFERS, &r->change_password_plain));
1106                         break;
1107
1108                         case WINBIND_AUTH_LEVEL_CHANGE_PASSWORD_CRYPT:
1109                                 NDR_CHECK(ndr_push_STRUCT_winbind_auth_change_password_crypt_req(ndr, NDR_BUFFERS, &r->change_password_crypt));
1110                         break;
1111
1112                         default:
1113                         break;
1114
1115                 }
1116         }
1117         return NDR_ERR_SUCCESS;
1118 }
1119
1120 static enum ndr_err_code ndr_pull_winbind_auth_req(struct ndr_pull *ndr, int ndr_flags, union winbind_auth_req *r)
1121 {
1122         int level;
1123         uint32_t _level;
1124         level = ndr_pull_get_switch_value(ndr, r);
1125         if (ndr_flags & NDR_SCALARS) {
1126                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
1127                 if (_level != level) {
1128                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1129                 }
1130                 switch (level) {
1131                         case WINBIND_AUTH_LEVEL_COMPAT_AUTH_PLAIN: {
1132                                 NDR_CHECK(ndr_pull_STRUCT_winbind_auth_compat_auth_plain_req(ndr, NDR_SCALARS, &r->compat_auth_plain));
1133                         break; }
1134
1135                         case WINBIND_AUTH_LEVEL_COMPAT_AUTH_RESPONSE: {
1136                                 NDR_CHECK(ndr_pull_STRUCT_winbind_auth_compat_auth_response_req(ndr, NDR_SCALARS, &r->compat_auth_response));
1137                         break; }
1138
1139                         case WINBIND_AUTH_LEVEL_COMPAT_LOGOFF: {
1140                                 NDR_CHECK(ndr_pull_STRUCT_winbind_auth_compat_logoff_req(ndr, NDR_SCALARS, &r->compat_logoff));
1141                         break; }
1142
1143                         case WINBIND_AUTH_LEVEL_CHANGE_PASSWORD_PLAIN: {
1144                                 NDR_CHECK(ndr_pull_STRUCT_winbind_auth_change_password_plain_req(ndr, NDR_SCALARS, &r->change_password_plain));
1145                         break; }
1146
1147                         case WINBIND_AUTH_LEVEL_CHANGE_PASSWORD_CRYPT: {
1148                                 NDR_CHECK(ndr_pull_STRUCT_winbind_auth_change_password_crypt_req(ndr, NDR_SCALARS, &r->change_password_crypt));
1149                         break; }
1150
1151                         default: {
1152                         break; }
1153
1154                 }
1155         }
1156         if (ndr_flags & NDR_BUFFERS) {
1157                 switch (level) {
1158                         case WINBIND_AUTH_LEVEL_COMPAT_AUTH_PLAIN:
1159                                 NDR_CHECK(ndr_pull_STRUCT_winbind_auth_compat_auth_plain_req(ndr, NDR_BUFFERS, &r->compat_auth_plain));
1160                         break;
1161
1162                         case WINBIND_AUTH_LEVEL_COMPAT_AUTH_RESPONSE:
1163                                 NDR_CHECK(ndr_pull_STRUCT_winbind_auth_compat_auth_response_req(ndr, NDR_BUFFERS, &r->compat_auth_response));
1164                         break;
1165
1166                         case WINBIND_AUTH_LEVEL_COMPAT_LOGOFF:
1167                                 NDR_CHECK(ndr_pull_STRUCT_winbind_auth_compat_logoff_req(ndr, NDR_BUFFERS, &r->compat_logoff));
1168                         break;
1169
1170                         case WINBIND_AUTH_LEVEL_CHANGE_PASSWORD_PLAIN:
1171                                 NDR_CHECK(ndr_pull_STRUCT_winbind_auth_change_password_plain_req(ndr, NDR_BUFFERS, &r->change_password_plain));
1172                         break;
1173
1174                         case WINBIND_AUTH_LEVEL_CHANGE_PASSWORD_CRYPT:
1175                                 NDR_CHECK(ndr_pull_STRUCT_winbind_auth_change_password_crypt_req(ndr, NDR_BUFFERS, &r->change_password_crypt));
1176                         break;
1177
1178                         default:
1179                         break;
1180
1181                 }
1182         }
1183         return NDR_ERR_SUCCESS;
1184 }
1185
1186 _PUBLIC_ void ndr_print_winbind_auth_req(struct ndr_print *ndr, const char *name, const union winbind_auth_req *r)
1187 {
1188         int level;
1189         level = ndr_print_get_switch_value(ndr, r);
1190         ndr_print_union(ndr, name, level, "winbind_auth_req");
1191         switch (level) {
1192                 case WINBIND_AUTH_LEVEL_COMPAT_AUTH_PLAIN:
1193                         ndr_print_STRUCT_winbind_auth_compat_auth_plain_req(ndr, "compat_auth_plain", &r->compat_auth_plain);
1194                 break;
1195
1196                 case WINBIND_AUTH_LEVEL_COMPAT_AUTH_RESPONSE:
1197                         ndr_print_STRUCT_winbind_auth_compat_auth_response_req(ndr, "compat_auth_response", &r->compat_auth_response);
1198                 break;
1199
1200                 case WINBIND_AUTH_LEVEL_COMPAT_LOGOFF:
1201                         ndr_print_STRUCT_winbind_auth_compat_logoff_req(ndr, "compat_logoff", &r->compat_logoff);
1202                 break;
1203
1204                 case WINBIND_AUTH_LEVEL_CHANGE_PASSWORD_PLAIN:
1205                         ndr_print_STRUCT_winbind_auth_change_password_plain_req(ndr, "change_password_plain", &r->change_password_plain);
1206                 break;
1207
1208                 case WINBIND_AUTH_LEVEL_CHANGE_PASSWORD_CRYPT:
1209                         ndr_print_STRUCT_winbind_auth_change_password_crypt_req(ndr, "change_password_crypt", &r->change_password_crypt);
1210                 break;
1211
1212                 default:
1213                 break;
1214
1215         }
1216 }
1217
1218 static enum ndr_err_code ndr_push_winbind_auth_rep(struct ndr_push *ndr, int ndr_flags, const union winbind_auth_rep *r)
1219 {
1220         if (ndr_flags & NDR_SCALARS) {
1221                 int level = ndr_push_get_switch_value(ndr, r);
1222                 NDR_CHECK(ndr_push_winbind_auth_level(ndr, NDR_SCALARS, level));
1223                 switch (level) {
1224                         case WINBIND_AUTH_LEVEL_COMPAT_AUTH_PLAIN: {
1225                                 NDR_CHECK(ndr_push_STRUCT_winbind_auth_compat_auth_rep(ndr, NDR_SCALARS, &r->compat_auth));
1226                         break; }
1227
1228                         case WINBIND_AUTH_LEVEL_COMPAT_AUTH_RESPONSE: {
1229                                 NDR_CHECK(ndr_push_STRUCT_winbind_auth_compat_auth_rep(ndr, NDR_SCALARS, &r->compat_auth));
1230                         break; }
1231
1232                         case WINBIND_AUTH_LEVEL_COMPAT_LOGOFF: {
1233                         break; }
1234
1235                         case WINBIND_AUTH_LEVEL_CHANGE_PASSWORD_PLAIN: {
1236                         break; }
1237
1238                         case WINBIND_AUTH_LEVEL_CHANGE_PASSWORD_CRYPT: {
1239                         break; }
1240
1241                         default: {
1242                         break; }
1243
1244                 }
1245         }
1246         if (ndr_flags & NDR_BUFFERS) {
1247                 int level = ndr_push_get_switch_value(ndr, r);
1248                 switch (level) {
1249                         case WINBIND_AUTH_LEVEL_COMPAT_AUTH_PLAIN:
1250                                 NDR_CHECK(ndr_push_STRUCT_winbind_auth_compat_auth_rep(ndr, NDR_BUFFERS, &r->compat_auth));
1251                         break;
1252
1253                         case WINBIND_AUTH_LEVEL_COMPAT_AUTH_RESPONSE:
1254                                 NDR_CHECK(ndr_push_STRUCT_winbind_auth_compat_auth_rep(ndr, NDR_BUFFERS, &r->compat_auth));
1255                         break;
1256
1257                         case WINBIND_AUTH_LEVEL_COMPAT_LOGOFF:
1258                         break;
1259
1260                         case WINBIND_AUTH_LEVEL_CHANGE_PASSWORD_PLAIN:
1261                         break;
1262
1263                         case WINBIND_AUTH_LEVEL_CHANGE_PASSWORD_CRYPT:
1264                         break;
1265
1266                         default:
1267                         break;
1268
1269                 }
1270         }
1271         return NDR_ERR_SUCCESS;
1272 }
1273
1274 static enum ndr_err_code ndr_pull_winbind_auth_rep(struct ndr_pull *ndr, int ndr_flags, union winbind_auth_rep *r)
1275 {
1276         int level;
1277         uint32_t _level;
1278         level = ndr_pull_get_switch_value(ndr, r);
1279         if (ndr_flags & NDR_SCALARS) {
1280                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
1281                 if (_level != level) {
1282                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1283                 }
1284                 switch (level) {
1285                         case WINBIND_AUTH_LEVEL_COMPAT_AUTH_PLAIN: {
1286                                 NDR_CHECK(ndr_pull_STRUCT_winbind_auth_compat_auth_rep(ndr, NDR_SCALARS, &r->compat_auth));
1287                         break; }
1288
1289                         case WINBIND_AUTH_LEVEL_COMPAT_AUTH_RESPONSE: {
1290                                 NDR_CHECK(ndr_pull_STRUCT_winbind_auth_compat_auth_rep(ndr, NDR_SCALARS, &r->compat_auth));
1291                         break; }
1292
1293                         case WINBIND_AUTH_LEVEL_COMPAT_LOGOFF: {
1294                         break; }
1295
1296                         case WINBIND_AUTH_LEVEL_CHANGE_PASSWORD_PLAIN: {
1297                         break; }
1298
1299                         case WINBIND_AUTH_LEVEL_CHANGE_PASSWORD_CRYPT: {
1300                         break; }
1301
1302                         default: {
1303                         break; }
1304
1305                 }
1306         }
1307         if (ndr_flags & NDR_BUFFERS) {
1308                 switch (level) {
1309                         case WINBIND_AUTH_LEVEL_COMPAT_AUTH_PLAIN:
1310                                 NDR_CHECK(ndr_pull_STRUCT_winbind_auth_compat_auth_rep(ndr, NDR_BUFFERS, &r->compat_auth));
1311                         break;
1312
1313                         case WINBIND_AUTH_LEVEL_COMPAT_AUTH_RESPONSE:
1314                                 NDR_CHECK(ndr_pull_STRUCT_winbind_auth_compat_auth_rep(ndr, NDR_BUFFERS, &r->compat_auth));
1315                         break;
1316
1317                         case WINBIND_AUTH_LEVEL_COMPAT_LOGOFF:
1318                         break;
1319
1320                         case WINBIND_AUTH_LEVEL_CHANGE_PASSWORD_PLAIN:
1321                         break;
1322
1323                         case WINBIND_AUTH_LEVEL_CHANGE_PASSWORD_CRYPT:
1324                         break;
1325
1326                         default:
1327                         break;
1328
1329                 }
1330         }
1331         return NDR_ERR_SUCCESS;
1332 }
1333
1334 _PUBLIC_ void ndr_print_winbind_auth_rep(struct ndr_print *ndr, const char *name, const union winbind_auth_rep *r)
1335 {
1336         int level;
1337         level = ndr_print_get_switch_value(ndr, r);
1338         ndr_print_union(ndr, name, level, "winbind_auth_rep");
1339         switch (level) {
1340                 case WINBIND_AUTH_LEVEL_COMPAT_AUTH_PLAIN:
1341                         ndr_print_STRUCT_winbind_auth_compat_auth_rep(ndr, "compat_auth", &r->compat_auth);
1342                 break;
1343
1344                 case WINBIND_AUTH_LEVEL_COMPAT_AUTH_RESPONSE:
1345                         ndr_print_STRUCT_winbind_auth_compat_auth_rep(ndr, "compat_auth", &r->compat_auth);
1346                 break;
1347
1348                 case WINBIND_AUTH_LEVEL_COMPAT_LOGOFF:
1349                 break;
1350
1351                 case WINBIND_AUTH_LEVEL_CHANGE_PASSWORD_PLAIN:
1352                 break;
1353
1354                 case WINBIND_AUTH_LEVEL_CHANGE_PASSWORD_CRYPT:
1355                 break;
1356
1357                 default:
1358                 break;
1359
1360         }
1361 }
1362
1363 static enum ndr_err_code ndr_push_winbind_trust_level(struct ndr_push *ndr, int ndr_flags, enum winbind_trust_level r)
1364 {
1365         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1366         return NDR_ERR_SUCCESS;
1367 }
1368
1369 static enum ndr_err_code ndr_pull_winbind_trust_level(struct ndr_pull *ndr, int ndr_flags, enum winbind_trust_level *r)
1370 {
1371         uint32_t v;
1372         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1373         *r = v;
1374         return NDR_ERR_SUCCESS;
1375 }
1376
1377 _PUBLIC_ void ndr_print_winbind_trust_level(struct ndr_print *ndr, const char *name, enum winbind_trust_level r)
1378 {
1379         const char *val = NULL;
1380
1381         switch (r) {
1382                 case WINBIND_TRUST_LEVEL_COMPAT_LIST: val = "WINBIND_TRUST_LEVEL_COMPAT_LIST"; break;
1383                 case WINBIND_TRUST_LEVEL_COMPAT_CHECK_MACHCC: val = "WINBIND_TRUST_LEVEL_COMPAT_CHECK_MACHCC"; break;
1384         }
1385         ndr_print_enum(ndr, name, "ENUM", val, r);
1386 }
1387
1388 static enum ndr_err_code ndr_push_STRUCT_winbind_domain_info_compat(struct ndr_push *ndr, int ndr_flags, const struct winbind_domain_info_compat *r)
1389 {
1390         if (ndr_flags & NDR_SCALARS) {
1391                 NDR_CHECK(ndr_push_align(ndr, 4));
1392                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF8)));
1393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1394                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF8)));
1395                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
1396                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
1397                 if (r->sid == NULL) {
1398                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1399                 }
1400                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1401                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_native_mode));
1402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_active_directory));
1403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_primary));
1404         }
1405         if (ndr_flags & NDR_BUFFERS) {
1406                 if (r->dns_name) {
1407                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF8)));
1408                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1409                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF8)));
1410                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
1411                 }
1412                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1413         }
1414         return NDR_ERR_SUCCESS;
1415 }
1416
1417 static enum ndr_err_code ndr_pull_STRUCT_winbind_domain_info_compat(struct ndr_pull *ndr, int ndr_flags, struct winbind_domain_info_compat *r)
1418 {
1419         uint32_t _ptr_dns_name;
1420         TALLOC_CTX *_mem_save_dns_name_0;
1421         uint32_t _ptr_sid;
1422         TALLOC_CTX *_mem_save_sid_0;
1423         if (ndr_flags & NDR_SCALARS) {
1424                 NDR_CHECK(ndr_pull_align(ndr, 4));
1425                 NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
1426                 NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
1427                 if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
1428                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->netbios_name), ndr_get_array_length(ndr, &r->netbios_name));
1429                 }
1430                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint8_t)));
1431                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint8_t), CH_UTF8));
1432                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
1433                 if (_ptr_dns_name) {
1434                         NDR_PULL_ALLOC(ndr, r->dns_name);
1435                 } else {
1436                         r->dns_name = NULL;
1437                 }
1438                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_sid));
1439                 if (_ptr_sid) {
1440                         NDR_PULL_ALLOC(ndr, r->sid);
1441                 } else {
1442                         r->sid = NULL;
1443                 }
1444                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_native_mode));
1445                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_active_directory));
1446                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_primary));
1447         }
1448         if (ndr_flags & NDR_BUFFERS) {
1449                 if (r->dns_name) {
1450                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1451                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
1452                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
1453                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
1454                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
1455                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->dns_name), ndr_get_array_length(ndr, &r->dns_name));
1456                         }
1457                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint8_t)));
1458                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint8_t), CH_UTF8));
1459                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
1460                 }
1461                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1462                 NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
1463                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1464                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
1465         }
1466         return NDR_ERR_SUCCESS;
1467 }
1468
1469 _PUBLIC_ void ndr_print_STRUCT_winbind_domain_info_compat(struct ndr_print *ndr, const char *name, const struct winbind_domain_info_compat *r)
1470 {
1471         ndr_print_struct(ndr, name, "winbind_domain_info_compat");
1472         ndr->depth++;
1473         ndr_print_string(ndr, "netbios_name", r->netbios_name);
1474         ndr_print_ptr(ndr, "dns_name", r->dns_name);
1475         ndr->depth++;
1476         if (r->dns_name) {
1477                 ndr_print_string(ndr, "dns_name", r->dns_name);
1478         }
1479         ndr->depth--;
1480         ndr_print_ptr(ndr, "sid", r->sid);
1481         ndr->depth++;
1482         ndr_print_dom_sid(ndr, "sid", r->sid);
1483         ndr->depth--;
1484         ndr_print_uint32(ndr, "is_native_mode", r->is_native_mode);
1485         ndr_print_uint32(ndr, "is_active_directory", r->is_active_directory);
1486         ndr_print_uint32(ndr, "is_primary", r->is_primary);
1487         ndr->depth--;
1488 }
1489
1490 static enum ndr_err_code ndr_push_STRUCT_winbind_domain_info_compat_array(struct ndr_push *ndr, int ndr_flags, const struct winbind_domain_info_compat_array *r)
1491 {
1492         uint32_t cntr_domains_0;
1493         if (ndr_flags & NDR_SCALARS) {
1494                 NDR_CHECK(ndr_push_align(ndr, 4));
1495                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_domains));
1496                 for (cntr_domains_0 = 0; cntr_domains_0 < r->num_domains; cntr_domains_0++) {
1497                         NDR_CHECK(ndr_push_STRUCT_winbind_domain_info_compat(ndr, NDR_SCALARS, &r->domains[cntr_domains_0]));
1498                 }
1499         }
1500         if (ndr_flags & NDR_BUFFERS) {
1501                 for (cntr_domains_0 = 0; cntr_domains_0 < r->num_domains; cntr_domains_0++) {
1502                         NDR_CHECK(ndr_push_STRUCT_winbind_domain_info_compat(ndr, NDR_BUFFERS, &r->domains[cntr_domains_0]));
1503                 }
1504         }
1505         return NDR_ERR_SUCCESS;
1506 }
1507
1508 static enum ndr_err_code ndr_pull_STRUCT_winbind_domain_info_compat_array(struct ndr_pull *ndr, int ndr_flags, struct winbind_domain_info_compat_array *r)
1509 {
1510         uint32_t cntr_domains_0;
1511         TALLOC_CTX *_mem_save_domains_0;
1512         if (ndr_flags & NDR_SCALARS) {
1513                 NDR_CHECK(ndr_pull_align(ndr, 4));
1514                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_domains));
1515                 NDR_PULL_ALLOC_N(ndr, r->domains, r->num_domains);
1516                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
1517                 NDR_PULL_SET_MEM_CTX(ndr, r->domains, 0);
1518                 for (cntr_domains_0 = 0; cntr_domains_0 < r->num_domains; cntr_domains_0++) {
1519                         NDR_CHECK(ndr_pull_STRUCT_winbind_domain_info_compat(ndr, NDR_SCALARS, &r->domains[cntr_domains_0]));
1520                 }
1521                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, 0);
1522         }
1523         if (ndr_flags & NDR_BUFFERS) {
1524                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
1525                 NDR_PULL_SET_MEM_CTX(ndr, r->domains, 0);
1526                 for (cntr_domains_0 = 0; cntr_domains_0 < r->num_domains; cntr_domains_0++) {
1527                         NDR_CHECK(ndr_pull_STRUCT_winbind_domain_info_compat(ndr, NDR_BUFFERS, &r->domains[cntr_domains_0]));
1528                 }
1529                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, 0);
1530         }
1531         return NDR_ERR_SUCCESS;
1532 }
1533
1534 _PUBLIC_ void ndr_print_STRUCT_winbind_domain_info_compat_array(struct ndr_print *ndr, const char *name, const struct winbind_domain_info_compat_array *r)
1535 {
1536         uint32_t cntr_domains_0;
1537         ndr_print_struct(ndr, name, "winbind_domain_info_compat_array");
1538         ndr->depth++;
1539         ndr_print_uint32(ndr, "num_domains", r->num_domains);
1540         ndr->print(ndr, "%s: ARRAY(%d)", "domains", r->num_domains);
1541         ndr->depth++;
1542         for (cntr_domains_0=0;cntr_domains_0<r->num_domains;cntr_domains_0++) {
1543                 char *idx_0=NULL;
1544                 if (asprintf(&idx_0, "[%d]", cntr_domains_0) != -1) {
1545                         ndr_print_STRUCT_winbind_domain_info_compat(ndr, "domains", &r->domains[cntr_domains_0]);
1546                         free(idx_0);
1547                 }
1548         }
1549         ndr->depth--;
1550         ndr->depth--;
1551 }
1552
1553 static enum ndr_err_code ndr_push_winbind_trust_req(struct ndr_push *ndr, int ndr_flags, const union winbind_trust_req *r)
1554 {
1555         if (ndr_flags & NDR_SCALARS) {
1556                 int level = ndr_push_get_switch_value(ndr, r);
1557                 NDR_CHECK(ndr_push_winbind_trust_level(ndr, NDR_SCALARS, level));
1558                 switch (level) {
1559                         case WINBIND_TRUST_LEVEL_COMPAT_LIST: {
1560                         break; }
1561
1562                         case WINBIND_TRUST_LEVEL_COMPAT_CHECK_MACHCC: {
1563                         break; }
1564
1565                         default: {
1566                         break; }
1567
1568                 }
1569         }
1570         if (ndr_flags & NDR_BUFFERS) {
1571                 int level = ndr_push_get_switch_value(ndr, r);
1572                 switch (level) {
1573                         case WINBIND_TRUST_LEVEL_COMPAT_LIST:
1574                         break;
1575
1576                         case WINBIND_TRUST_LEVEL_COMPAT_CHECK_MACHCC:
1577                         break;
1578
1579                         default:
1580                         break;
1581
1582                 }
1583         }
1584         return NDR_ERR_SUCCESS;
1585 }
1586
1587 static enum ndr_err_code ndr_pull_winbind_trust_req(struct ndr_pull *ndr, int ndr_flags, union winbind_trust_req *r)
1588 {
1589         int level;
1590         uint32_t _level;
1591         level = ndr_pull_get_switch_value(ndr, r);
1592         if (ndr_flags & NDR_SCALARS) {
1593                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
1594                 if (_level != level) {
1595                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1596                 }
1597                 switch (level) {
1598                         case WINBIND_TRUST_LEVEL_COMPAT_LIST: {
1599                         break; }
1600
1601                         case WINBIND_TRUST_LEVEL_COMPAT_CHECK_MACHCC: {
1602                         break; }
1603
1604                         default: {
1605                         break; }
1606
1607                 }
1608         }
1609         if (ndr_flags & NDR_BUFFERS) {
1610                 switch (level) {
1611                         case WINBIND_TRUST_LEVEL_COMPAT_LIST:
1612                         break;
1613
1614                         case WINBIND_TRUST_LEVEL_COMPAT_CHECK_MACHCC:
1615                         break;
1616
1617                         default:
1618                         break;
1619
1620                 }
1621         }
1622         return NDR_ERR_SUCCESS;
1623 }
1624
1625 _PUBLIC_ void ndr_print_winbind_trust_req(struct ndr_print *ndr, const char *name, const union winbind_trust_req *r)
1626 {
1627         int level;
1628         level = ndr_print_get_switch_value(ndr, r);
1629         ndr_print_union(ndr, name, level, "winbind_trust_req");
1630         switch (level) {
1631                 case WINBIND_TRUST_LEVEL_COMPAT_LIST:
1632                 break;
1633
1634                 case WINBIND_TRUST_LEVEL_COMPAT_CHECK_MACHCC:
1635                 break;
1636
1637                 default:
1638                 break;
1639
1640         }
1641 }
1642
1643 static enum ndr_err_code ndr_push_winbind_trust_rep(struct ndr_push *ndr, int ndr_flags, const union winbind_trust_rep *r)
1644 {
1645         if (ndr_flags & NDR_SCALARS) {
1646                 int level = ndr_push_get_switch_value(ndr, r);
1647                 NDR_CHECK(ndr_push_winbind_trust_level(ndr, NDR_SCALARS, level));
1648                 switch (level) {
1649                         case WINBIND_TRUST_LEVEL_COMPAT_LIST: {
1650                                 NDR_CHECK(ndr_push_STRUCT_winbind_domain_info_compat_array(ndr, NDR_SCALARS, &r->compat_trusts));
1651                         break; }
1652
1653                         case WINBIND_TRUST_LEVEL_COMPAT_CHECK_MACHCC: {
1654                         break; }
1655
1656                         default: {
1657                         break; }
1658
1659                 }
1660         }
1661         if (ndr_flags & NDR_BUFFERS) {
1662                 int level = ndr_push_get_switch_value(ndr, r);
1663                 switch (level) {
1664                         case WINBIND_TRUST_LEVEL_COMPAT_LIST:
1665                                 NDR_CHECK(ndr_push_STRUCT_winbind_domain_info_compat_array(ndr, NDR_BUFFERS, &r->compat_trusts));
1666                         break;
1667
1668                         case WINBIND_TRUST_LEVEL_COMPAT_CHECK_MACHCC:
1669                         break;
1670
1671                         default:
1672                         break;
1673
1674                 }
1675         }
1676         return NDR_ERR_SUCCESS;
1677 }
1678
1679 static enum ndr_err_code ndr_pull_winbind_trust_rep(struct ndr_pull *ndr, int ndr_flags, union winbind_trust_rep *r)
1680 {
1681         int level;
1682         uint32_t _level;
1683         level = ndr_pull_get_switch_value(ndr, r);
1684         if (ndr_flags & NDR_SCALARS) {
1685                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
1686                 if (_level != level) {
1687                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1688                 }
1689                 switch (level) {
1690                         case WINBIND_TRUST_LEVEL_COMPAT_LIST: {
1691                                 NDR_CHECK(ndr_pull_STRUCT_winbind_domain_info_compat_array(ndr, NDR_SCALARS, &r->compat_trusts));
1692                         break; }
1693
1694                         case WINBIND_TRUST_LEVEL_COMPAT_CHECK_MACHCC: {
1695                         break; }
1696
1697                         default: {
1698                         break; }
1699
1700                 }
1701         }
1702         if (ndr_flags & NDR_BUFFERS) {
1703                 switch (level) {
1704                         case WINBIND_TRUST_LEVEL_COMPAT_LIST:
1705                                 NDR_CHECK(ndr_pull_STRUCT_winbind_domain_info_compat_array(ndr, NDR_BUFFERS, &r->compat_trusts));
1706                         break;
1707
1708                         case WINBIND_TRUST_LEVEL_COMPAT_CHECK_MACHCC:
1709                         break;
1710
1711                         default:
1712                         break;
1713
1714                 }
1715         }
1716         return NDR_ERR_SUCCESS;
1717 }
1718
1719 _PUBLIC_ void ndr_print_winbind_trust_rep(struct ndr_print *ndr, const char *name, const union winbind_trust_rep *r)
1720 {
1721         int level;
1722         level = ndr_print_get_switch_value(ndr, r);
1723         ndr_print_union(ndr, name, level, "winbind_trust_rep");
1724         switch (level) {
1725                 case WINBIND_TRUST_LEVEL_COMPAT_LIST:
1726                         ndr_print_STRUCT_winbind_domain_info_compat_array(ndr, "compat_trusts", &r->compat_trusts);
1727                 break;
1728
1729                 case WINBIND_TRUST_LEVEL_COMPAT_CHECK_MACHCC:
1730                 break;
1731
1732                 default:
1733                 break;
1734
1735         }
1736 }
1737
1738 static enum ndr_err_code ndr_push_winbind_lookup_level(struct ndr_push *ndr, int ndr_flags, enum winbind_lookup_level r)
1739 {
1740         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1741         return NDR_ERR_SUCCESS;
1742 }
1743
1744 static enum ndr_err_code ndr_pull_winbind_lookup_level(struct ndr_pull *ndr, int ndr_flags, enum winbind_lookup_level *r)
1745 {
1746         uint32_t v;
1747         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1748         *r = v;
1749         return NDR_ERR_SUCCESS;
1750 }
1751
1752 _PUBLIC_ void ndr_print_winbind_lookup_level(struct ndr_print *ndr, const char *name, enum winbind_lookup_level r)
1753 {
1754         const char *val = NULL;
1755
1756         switch (r) {
1757                 case WINBIND_LOOKUP_LEVEL_SID2NAME: val = "WINBIND_LOOKUP_LEVEL_SID2NAME"; break;
1758                 case WINBIND_LOOKUP_LEVEL_NAME2SID: val = "WINBIND_LOOKUP_LEVEL_NAME2SID"; break;
1759                 case WINBIND_LOOKUP_LEVEL_RIDS2NAMES: val = "WINBIND_LOOKUP_LEVEL_RIDS2NAMES"; break;
1760                 case WINBIND_LOOKUP_LEVEL_SID2USERINFO: val = "WINBIND_LOOKUP_LEVEL_SID2USERINFO"; break;
1761                 case WINBIND_LOOKUP_LEVEL_SID2DOMGROUPS: val = "WINBIND_LOOKUP_LEVEL_SID2DOMGROUPS"; break;
1762                 case WINBIND_LOOKUP_LEVEL_EXPANDALIASES: val = "WINBIND_LOOKUP_LEVEL_EXPANDALIASES"; break;
1763         }
1764         ndr_print_enum(ndr, name, "ENUM", val, r);
1765 }
1766
1767 static enum ndr_err_code ndr_push_STRUCT_winbind_lookup_req_rids(struct ndr_push *ndr, int ndr_flags, const struct winbind_lookup_req_rids *r)
1768 {
1769         uint32_t cntr_rids_0;
1770         if (ndr_flags & NDR_SCALARS) {
1771                 NDR_CHECK(ndr_push_align(ndr, 4));
1772                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_sid));
1773                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_rids));
1774                 for (cntr_rids_0 = 0; cntr_rids_0 < r->num_rids; cntr_rids_0++) {
1775                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rids[cntr_rids_0]));
1776                 }
1777         }
1778         if (ndr_flags & NDR_BUFFERS) {
1779                 if (r->domain_sid) {
1780                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain_sid));
1781                 }
1782         }
1783         return NDR_ERR_SUCCESS;
1784 }
1785
1786 static enum ndr_err_code ndr_pull_STRUCT_winbind_lookup_req_rids(struct ndr_pull *ndr, int ndr_flags, struct winbind_lookup_req_rids *r)
1787 {
1788         uint32_t _ptr_domain_sid;
1789         TALLOC_CTX *_mem_save_domain_sid_0;
1790         uint32_t cntr_rids_0;
1791         TALLOC_CTX *_mem_save_rids_0;
1792         if (ndr_flags & NDR_SCALARS) {
1793                 NDR_CHECK(ndr_pull_align(ndr, 4));
1794                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_sid));
1795                 if (_ptr_domain_sid) {
1796                         NDR_PULL_ALLOC(ndr, r->domain_sid);
1797                 } else {
1798                         r->domain_sid = NULL;
1799                 }
1800                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_rids));
1801                 NDR_PULL_ALLOC_N(ndr, r->rids, r->num_rids);
1802                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1803                 NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
1804                 for (cntr_rids_0 = 0; cntr_rids_0 < r->num_rids; cntr_rids_0++) {
1805                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rids[cntr_rids_0]));
1806                 }
1807                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
1808         }
1809         if (ndr_flags & NDR_BUFFERS) {
1810                 if (r->domain_sid) {
1811                         _mem_save_domain_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1812                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_sid, 0);
1813                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain_sid));
1814                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_sid_0, 0);
1815                 }
1816         }
1817         return NDR_ERR_SUCCESS;
1818 }
1819
1820 _PUBLIC_ void ndr_print_STRUCT_winbind_lookup_req_rids(struct ndr_print *ndr, const char *name, const struct winbind_lookup_req_rids *r)
1821 {
1822         uint32_t cntr_rids_0;
1823         ndr_print_struct(ndr, name, "winbind_lookup_req_rids");
1824         ndr->depth++;
1825         ndr_print_ptr(ndr, "domain_sid", r->domain_sid);
1826         ndr->depth++;
1827         if (r->domain_sid) {
1828                 ndr_print_dom_sid(ndr, "domain_sid", r->domain_sid);
1829         }
1830         ndr->depth--;
1831         ndr_print_uint32(ndr, "num_rids", r->num_rids);
1832         ndr->print(ndr, "%s: ARRAY(%d)", "rids", r->num_rids);
1833         ndr->depth++;
1834         for (cntr_rids_0=0;cntr_rids_0<r->num_rids;cntr_rids_0++) {
1835                 char *idx_0=NULL;
1836                 if (asprintf(&idx_0, "[%d]", cntr_rids_0) != -1) {
1837                         ndr_print_uint32(ndr, "rids", r->rids[cntr_rids_0]);
1838                         free(idx_0);
1839                 }
1840         }
1841         ndr->depth--;
1842         ndr->depth--;
1843 }
1844
1845 static enum ndr_err_code ndr_push_STRUCT_winbind_lookup_name_info(struct ndr_push *ndr, int ndr_flags, const struct winbind_lookup_name_info *r)
1846 {
1847         if (ndr_flags & NDR_SCALARS) {
1848                 NDR_CHECK(ndr_push_align(ndr, 4));
1849                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF8)));
1850                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1851                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF8)));
1852                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
1853                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->account_name, CH_UTF8)));
1854                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1855                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->account_name, CH_UTF8)));
1856                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->account_name, ndr_charset_length(r->account_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
1857                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->type));
1858         }
1859         if (ndr_flags & NDR_BUFFERS) {
1860         }
1861         return NDR_ERR_SUCCESS;
1862 }
1863
1864 static enum ndr_err_code ndr_pull_STRUCT_winbind_lookup_name_info(struct ndr_pull *ndr, int ndr_flags, struct winbind_lookup_name_info *r)
1865 {
1866         if (ndr_flags & NDR_SCALARS) {
1867                 NDR_CHECK(ndr_pull_align(ndr, 4));
1868                 NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
1869                 NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
1870                 if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
1871                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain_name), ndr_get_array_length(ndr, &r->domain_name));
1872                 }
1873                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint8_t)));
1874                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint8_t), CH_UTF8));
1875                 NDR_CHECK(ndr_pull_array_size(ndr, &r->account_name));
1876                 NDR_CHECK(ndr_pull_array_length(ndr, &r->account_name));
1877                 if (ndr_get_array_length(ndr, &r->account_name) > ndr_get_array_size(ndr, &r->account_name)) {
1878                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->account_name), ndr_get_array_length(ndr, &r->account_name));
1879                 }
1880                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->account_name), sizeof(uint8_t)));
1881                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->account_name, ndr_get_array_length(ndr, &r->account_name), sizeof(uint8_t), CH_UTF8));
1882                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->type));
1883         }
1884         if (ndr_flags & NDR_BUFFERS) {
1885         }
1886         return NDR_ERR_SUCCESS;
1887 }
1888
1889 _PUBLIC_ void ndr_print_STRUCT_winbind_lookup_name_info(struct ndr_print *ndr, const char *name, const struct winbind_lookup_name_info *r)
1890 {
1891         ndr_print_struct(ndr, name, "winbind_lookup_name_info");
1892         ndr->depth++;
1893         ndr_print_string(ndr, "domain_name", r->domain_name);
1894         ndr_print_string(ndr, "account_name", r->account_name);
1895         ndr_print_lsa_SidType(ndr, "type", r->type);
1896         ndr->depth--;
1897 }
1898
1899 static enum ndr_err_code ndr_push_STRUCT_winbind_lookup_sid_info(struct ndr_push *ndr, int ndr_flags, const struct winbind_lookup_sid_info *r)
1900 {
1901         if (ndr_flags & NDR_SCALARS) {
1902                 NDR_CHECK(ndr_push_align(ndr, 4));
1903                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
1904                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->type));
1905         }
1906         if (ndr_flags & NDR_BUFFERS) {
1907                 if (r->sid) {
1908                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1909                 }
1910         }
1911         return NDR_ERR_SUCCESS;
1912 }
1913
1914 static enum ndr_err_code ndr_pull_STRUCT_winbind_lookup_sid_info(struct ndr_pull *ndr, int ndr_flags, struct winbind_lookup_sid_info *r)
1915 {
1916         uint32_t _ptr_sid;
1917         TALLOC_CTX *_mem_save_sid_0;
1918         if (ndr_flags & NDR_SCALARS) {
1919                 NDR_CHECK(ndr_pull_align(ndr, 4));
1920                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
1921                 if (_ptr_sid) {
1922                         NDR_PULL_ALLOC(ndr, r->sid);
1923                 } else {
1924                         r->sid = NULL;
1925                 }
1926                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->type));
1927         }
1928         if (ndr_flags & NDR_BUFFERS) {
1929                 if (r->sid) {
1930                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1931                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
1932                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1933                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
1934                 }
1935         }
1936         return NDR_ERR_SUCCESS;
1937 }
1938
1939 _PUBLIC_ void ndr_print_STRUCT_winbind_lookup_sid_info(struct ndr_print *ndr, const char *name, const struct winbind_lookup_sid_info *r)
1940 {
1941         ndr_print_struct(ndr, name, "winbind_lookup_sid_info");
1942         ndr->depth++;
1943         ndr_print_ptr(ndr, "sid", r->sid);
1944         ndr->depth++;
1945         if (r->sid) {
1946                 ndr_print_dom_sid(ndr, "sid", r->sid);
1947         }
1948         ndr->depth--;
1949         ndr_print_lsa_SidType(ndr, "type", r->type);
1950         ndr->depth--;
1951 }
1952
1953 static enum ndr_err_code ndr_push_STRUCT_winbind_lookup_name_info_array(struct ndr_push *ndr, int ndr_flags, const struct winbind_lookup_name_info_array *r)
1954 {
1955         uint32_t cntr_names_0;
1956         if (ndr_flags & NDR_SCALARS) {
1957                 NDR_CHECK(ndr_push_align(ndr, 4));
1958                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_names));
1959                 for (cntr_names_0 = 0; cntr_names_0 < r->num_names; cntr_names_0++) {
1960                         NDR_CHECK(ndr_push_STRUCT_winbind_lookup_name_info(ndr, NDR_SCALARS, &r->names[cntr_names_0]));
1961                 }
1962         }
1963         if (ndr_flags & NDR_BUFFERS) {
1964         }
1965         return NDR_ERR_SUCCESS;
1966 }
1967
1968 static enum ndr_err_code ndr_pull_STRUCT_winbind_lookup_name_info_array(struct ndr_pull *ndr, int ndr_flags, struct winbind_lookup_name_info_array *r)
1969 {
1970         uint32_t cntr_names_0;
1971         TALLOC_CTX *_mem_save_names_0;
1972         if (ndr_flags & NDR_SCALARS) {
1973                 NDR_CHECK(ndr_pull_align(ndr, 4));
1974                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_names));
1975                 NDR_PULL_ALLOC_N(ndr, r->names, r->num_names);
1976                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
1977                 NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
1978                 for (cntr_names_0 = 0; cntr_names_0 < r->num_names; cntr_names_0++) {
1979                         NDR_CHECK(ndr_pull_STRUCT_winbind_lookup_name_info(ndr, NDR_SCALARS, &r->names[cntr_names_0]));
1980                 }
1981                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
1982         }
1983         if (ndr_flags & NDR_BUFFERS) {
1984         }
1985         return NDR_ERR_SUCCESS;
1986 }
1987
1988 _PUBLIC_ void ndr_print_STRUCT_winbind_lookup_name_info_array(struct ndr_print *ndr, const char *name, const struct winbind_lookup_name_info_array *r)
1989 {
1990         uint32_t cntr_names_0;
1991         ndr_print_struct(ndr, name, "winbind_lookup_name_info_array");
1992         ndr->depth++;
1993         ndr_print_uint32(ndr, "num_names", r->num_names);
1994         ndr->print(ndr, "%s: ARRAY(%d)", "names", r->num_names);
1995         ndr->depth++;
1996         for (cntr_names_0=0;cntr_names_0<r->num_names;cntr_names_0++) {
1997                 char *idx_0=NULL;
1998                 if (asprintf(&idx_0, "[%d]", cntr_names_0) != -1) {
1999                         ndr_print_STRUCT_winbind_lookup_name_info(ndr, "names", &r->names[cntr_names_0]);
2000                         free(idx_0);
2001                 }
2002         }
2003         ndr->depth--;
2004         ndr->depth--;
2005 }
2006
2007 static enum ndr_err_code ndr_push_STRUCT_winbind_lookup_user_info(struct ndr_push *ndr, int ndr_flags, const struct winbind_lookup_user_info *r)
2008 {
2009         if (ndr_flags & NDR_SCALARS) {
2010                 NDR_CHECK(ndr_push_align(ndr, 8));
2011                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->account, CH_UTF8)));
2012                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2013                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->account, CH_UTF8)));
2014                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->account, ndr_charset_length(r->account, CH_UTF8), sizeof(uint8_t), CH_UTF8));
2015                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->gecos, CH_UTF8)));
2016                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2017                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->gecos, CH_UTF8)));
2018                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->gecos, ndr_charset_length(r->gecos, CH_UTF8), sizeof(uint8_t), CH_UTF8));
2019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->homedir, CH_UTF8)));
2020                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2021                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->homedir, CH_UTF8)));
2022                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->homedir, ndr_charset_length(r->homedir, CH_UTF8), sizeof(uint8_t), CH_UTF8));
2023                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->shell, CH_UTF8)));
2024                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2025                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->shell, CH_UTF8)));
2026                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->shell, ndr_charset_length(r->shell, CH_UTF8), sizeof(uint8_t), CH_UTF8));
2027                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->primary_gid));
2028                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_rid));
2029         }
2030         if (ndr_flags & NDR_BUFFERS) {
2031         }
2032         return NDR_ERR_SUCCESS;
2033 }
2034
2035 static enum ndr_err_code ndr_pull_STRUCT_winbind_lookup_user_info(struct ndr_pull *ndr, int ndr_flags, struct winbind_lookup_user_info *r)
2036 {
2037         if (ndr_flags & NDR_SCALARS) {
2038                 NDR_CHECK(ndr_pull_align(ndr, 8));
2039                 NDR_CHECK(ndr_pull_array_size(ndr, &r->account));
2040                 NDR_CHECK(ndr_pull_array_length(ndr, &r->account));
2041                 if (ndr_get_array_length(ndr, &r->account) > ndr_get_array_size(ndr, &r->account)) {
2042                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->account), ndr_get_array_length(ndr, &r->account));
2043                 }
2044                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->account), sizeof(uint8_t)));
2045                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->account, ndr_get_array_length(ndr, &r->account), sizeof(uint8_t), CH_UTF8));
2046                 NDR_CHECK(ndr_pull_array_size(ndr, &r->gecos));
2047                 NDR_CHECK(ndr_pull_array_length(ndr, &r->gecos));
2048                 if (ndr_get_array_length(ndr, &r->gecos) > ndr_get_array_size(ndr, &r->gecos)) {
2049                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->gecos), ndr_get_array_length(ndr, &r->gecos));
2050                 }
2051                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->gecos), sizeof(uint8_t)));
2052                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->gecos, ndr_get_array_length(ndr, &r->gecos), sizeof(uint8_t), CH_UTF8));
2053                 NDR_CHECK(ndr_pull_array_size(ndr, &r->homedir));
2054                 NDR_CHECK(ndr_pull_array_length(ndr, &r->homedir));
2055                 if (ndr_get_array_length(ndr, &r->homedir) > ndr_get_array_size(ndr, &r->homedir)) {
2056                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->homedir), ndr_get_array_length(ndr, &r->homedir));
2057                 }
2058                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->homedir), sizeof(uint8_t)));
2059                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->homedir, ndr_get_array_length(ndr, &r->homedir), sizeof(uint8_t), CH_UTF8));
2060                 NDR_CHECK(ndr_pull_array_size(ndr, &r->shell));
2061                 NDR_CHECK(ndr_pull_array_length(ndr, &r->shell));
2062                 if (ndr_get_array_length(ndr, &r->shell) > ndr_get_array_size(ndr, &r->shell)) {
2063                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->shell), ndr_get_array_length(ndr, &r->shell));
2064                 }
2065                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->shell), sizeof(uint8_t)));
2066                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->shell, ndr_get_array_length(ndr, &r->shell), sizeof(uint8_t), CH_UTF8));
2067                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->primary_gid));
2068                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_rid));
2069         }
2070         if (ndr_flags & NDR_BUFFERS) {
2071         }
2072         return NDR_ERR_SUCCESS;
2073 }
2074
2075 _PUBLIC_ void ndr_print_STRUCT_winbind_lookup_user_info(struct ndr_print *ndr, const char *name, const struct winbind_lookup_user_info *r)
2076 {
2077         ndr_print_struct(ndr, name, "winbind_lookup_user_info");
2078         ndr->depth++;
2079         ndr_print_string(ndr, "account", r->account);
2080         ndr_print_string(ndr, "gecos", r->gecos);
2081         ndr_print_string(ndr, "homedir", r->homedir);
2082         ndr_print_string(ndr, "shell", r->shell);
2083         ndr_print_hyper(ndr, "primary_gid", r->primary_gid);
2084         ndr_print_uint32(ndr, "primary_rid", r->primary_rid);
2085         ndr->depth--;
2086 }
2087
2088 static enum ndr_err_code ndr_push_STRUCT_winbind_lookup_sid_info_array(struct ndr_push *ndr, int ndr_flags, const struct winbind_lookup_sid_info_array *r)
2089 {
2090         uint32_t cntr_sids_0;
2091         if (ndr_flags & NDR_SCALARS) {
2092                 NDR_CHECK(ndr_push_align(ndr, 4));
2093                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
2094                 for (cntr_sids_0 = 0; cntr_sids_0 < r->num_sids; cntr_sids_0++) {
2095                         NDR_CHECK(ndr_push_STRUCT_winbind_lookup_sid_info(ndr, NDR_SCALARS, &r->sids[cntr_sids_0]));
2096                 }
2097         }
2098         if (ndr_flags & NDR_BUFFERS) {
2099                 for (cntr_sids_0 = 0; cntr_sids_0 < r->num_sids; cntr_sids_0++) {
2100                         NDR_CHECK(ndr_push_STRUCT_winbind_lookup_sid_info(ndr, NDR_BUFFERS, &r->sids[cntr_sids_0]));
2101                 }
2102         }
2103         return NDR_ERR_SUCCESS;
2104 }
2105
2106 static enum ndr_err_code ndr_pull_STRUCT_winbind_lookup_sid_info_array(struct ndr_pull *ndr, int ndr_flags, struct winbind_lookup_sid_info_array *r)
2107 {
2108         uint32_t cntr_sids_0;
2109         TALLOC_CTX *_mem_save_sids_0;
2110         if (ndr_flags & NDR_SCALARS) {
2111                 NDR_CHECK(ndr_pull_align(ndr, 4));
2112                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sids));
2113                 NDR_PULL_ALLOC_N(ndr, r->sids, r->num_sids);
2114                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
2115                 NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
2116                 for (cntr_sids_0 = 0; cntr_sids_0 < r->num_sids; cntr_sids_0++) {
2117                         NDR_CHECK(ndr_pull_STRUCT_winbind_lookup_sid_info(ndr, NDR_SCALARS, &r->sids[cntr_sids_0]));
2118                 }
2119                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
2120         }
2121         if (ndr_flags & NDR_BUFFERS) {
2122                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
2123                 NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
2124                 for (cntr_sids_0 = 0; cntr_sids_0 < r->num_sids; cntr_sids_0++) {
2125                         NDR_CHECK(ndr_pull_STRUCT_winbind_lookup_sid_info(ndr, NDR_BUFFERS, &r->sids[cntr_sids_0]));
2126                 }
2127                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
2128         }
2129         return NDR_ERR_SUCCESS;
2130 }
2131
2132 _PUBLIC_ void ndr_print_STRUCT_winbind_lookup_sid_info_array(struct ndr_print *ndr, const char *name, const struct winbind_lookup_sid_info_array *r)
2133 {
2134         uint32_t cntr_sids_0;
2135         ndr_print_struct(ndr, name, "winbind_lookup_sid_info_array");
2136         ndr->depth++;
2137         ndr_print_uint32(ndr, "num_sids", r->num_sids);
2138         ndr->print(ndr, "%s: ARRAY(%d)", "sids", r->num_sids);
2139         ndr->depth++;
2140         for (cntr_sids_0=0;cntr_sids_0<r->num_sids;cntr_sids_0++) {
2141                 char *idx_0=NULL;
2142                 if (asprintf(&idx_0, "[%d]", cntr_sids_0) != -1) {
2143                         ndr_print_STRUCT_winbind_lookup_sid_info(ndr, "sids", &r->sids[cntr_sids_0]);
2144                         free(idx_0);
2145                 }
2146         }
2147         ndr->depth--;
2148         ndr->depth--;
2149 }
2150
2151 static enum ndr_err_code ndr_push_winbind_lookup_req(struct ndr_push *ndr, int ndr_flags, const union winbind_lookup_req *r)
2152 {
2153         if (ndr_flags & NDR_SCALARS) {
2154                 int level = ndr_push_get_switch_value(ndr, r);
2155                 NDR_CHECK(ndr_push_winbind_lookup_level(ndr, NDR_SCALARS, level));
2156                 switch (level) {
2157                         case WINBIND_LOOKUP_LEVEL_SID2NAME: {
2158                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
2159                         break; }
2160
2161                         case WINBIND_LOOKUP_LEVEL_NAME2SID: {
2162                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF8)));
2163                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2164                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF8)));
2165                                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
2166                         break; }
2167
2168                         case WINBIND_LOOKUP_LEVEL_RIDS2NAMES: {
2169                                 NDR_CHECK(ndr_push_STRUCT_winbind_lookup_req_rids(ndr, NDR_SCALARS, &r->rids));
2170                         break; }
2171
2172                         case WINBIND_LOOKUP_LEVEL_SID2USERINFO: {
2173                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
2174                         break; }
2175
2176                         case WINBIND_LOOKUP_LEVEL_SID2DOMGROUPS: {
2177                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
2178                         break; }
2179
2180                         case WINBIND_LOOKUP_LEVEL_EXPANDALIASES: {
2181                                 NDR_CHECK(ndr_push_STRUCT_winbind_lookup_sid_info_array(ndr, NDR_SCALARS, &r->sid_array));
2182                         break; }
2183
2184                         default: {
2185                         break; }
2186
2187                 }
2188         }
2189         if (ndr_flags & NDR_BUFFERS) {
2190                 int level = ndr_push_get_switch_value(ndr, r);
2191                 switch (level) {
2192                         case WINBIND_LOOKUP_LEVEL_SID2NAME:
2193                                 if (r->sid) {
2194                                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
2195                                 }
2196                         break;
2197
2198                         case WINBIND_LOOKUP_LEVEL_NAME2SID:
2199                         break;
2200
2201                         case WINBIND_LOOKUP_LEVEL_RIDS2NAMES:
2202                                 NDR_CHECK(ndr_push_STRUCT_winbind_lookup_req_rids(ndr, NDR_BUFFERS, &r->rids));
2203                         break;
2204
2205                         case WINBIND_LOOKUP_LEVEL_SID2USERINFO:
2206                                 if (r->sid) {
2207                                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
2208                                 }
2209                         break;
2210
2211                         case WINBIND_LOOKUP_LEVEL_SID2DOMGROUPS:
2212                                 if (r->sid) {
2213                                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
2214                                 }
2215                         break;
2216
2217                         case WINBIND_LOOKUP_LEVEL_EXPANDALIASES:
2218                                 NDR_CHECK(ndr_push_STRUCT_winbind_lookup_sid_info_array(ndr, NDR_BUFFERS, &r->sid_array));
2219                         break;
2220
2221                         default:
2222                         break;
2223
2224                 }
2225         }
2226         return NDR_ERR_SUCCESS;
2227 }
2228
2229 static enum ndr_err_code ndr_pull_winbind_lookup_req(struct ndr_pull *ndr, int ndr_flags, union winbind_lookup_req *r)
2230 {
2231         int level;
2232         uint32_t _level;
2233         TALLOC_CTX *_mem_save_sid_0;
2234         level = ndr_pull_get_switch_value(ndr, r);
2235         if (ndr_flags & NDR_SCALARS) {
2236                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
2237                 if (_level != level) {
2238                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
2239                 }
2240                 switch (level) {
2241                         case WINBIND_LOOKUP_LEVEL_SID2NAME: {
2242                                 uint32_t _ptr_sid;
2243                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
2244                                 if (_ptr_sid) {
2245                                         NDR_PULL_ALLOC(ndr, r->sid);
2246                                 } else {
2247                                         r->sid = NULL;
2248                                 }
2249                         break; }
2250
2251                         case WINBIND_LOOKUP_LEVEL_NAME2SID: {
2252                                 NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
2253                                 NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
2254                                 if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
2255                                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
2256                                 }
2257                                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint8_t)));
2258                                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint8_t), CH_UTF8));
2259                         break; }
2260
2261                         case WINBIND_LOOKUP_LEVEL_RIDS2NAMES: {
2262                                 NDR_CHECK(ndr_pull_STRUCT_winbind_lookup_req_rids(ndr, NDR_SCALARS, &r->rids));
2263                         break; }
2264
2265                         case WINBIND_LOOKUP_LEVEL_SID2USERINFO: {
2266                                 uint32_t _ptr_sid;
2267                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
2268                                 if (_ptr_sid) {
2269                                         NDR_PULL_ALLOC(ndr, r->sid);
2270                                 } else {
2271                                         r->sid = NULL;
2272                                 }
2273                         break; }
2274
2275                         case WINBIND_LOOKUP_LEVEL_SID2DOMGROUPS: {
2276                                 uint32_t _ptr_sid;
2277                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
2278                                 if (_ptr_sid) {
2279                                         NDR_PULL_ALLOC(ndr, r->sid);
2280                                 } else {
2281                                         r->sid = NULL;
2282                                 }
2283                         break; }
2284
2285                         case WINBIND_LOOKUP_LEVEL_EXPANDALIASES: {
2286                                 NDR_CHECK(ndr_pull_STRUCT_winbind_lookup_sid_info_array(ndr, NDR_SCALARS, &r->sid_array));
2287                         break; }
2288
2289                         default: {
2290                         break; }
2291
2292                 }
2293         }
2294         if (ndr_flags & NDR_BUFFERS) {
2295                 switch (level) {
2296                         case WINBIND_LOOKUP_LEVEL_SID2NAME:
2297                                 if (r->sid) {
2298                                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2299                                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
2300                                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
2301                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
2302                                 }
2303                         break;
2304
2305                         case WINBIND_LOOKUP_LEVEL_NAME2SID:
2306                         break;
2307
2308                         case WINBIND_LOOKUP_LEVEL_RIDS2NAMES:
2309                                 NDR_CHECK(ndr_pull_STRUCT_winbind_lookup_req_rids(ndr, NDR_BUFFERS, &r->rids));
2310                         break;
2311
2312                         case WINBIND_LOOKUP_LEVEL_SID2USERINFO:
2313                                 if (r->sid) {
2314                                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2315                                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
2316                                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
2317                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
2318                                 }
2319                         break;
2320
2321                         case WINBIND_LOOKUP_LEVEL_SID2DOMGROUPS:
2322                                 if (r->sid) {
2323                                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2324                                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
2325                                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
2326                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
2327                                 }
2328                         break;
2329
2330                         case WINBIND_LOOKUP_LEVEL_EXPANDALIASES:
2331                                 NDR_CHECK(ndr_pull_STRUCT_winbind_lookup_sid_info_array(ndr, NDR_BUFFERS, &r->sid_array));
2332                         break;
2333
2334                         default:
2335                         break;
2336
2337                 }
2338         }
2339         return NDR_ERR_SUCCESS;
2340 }
2341
2342 _PUBLIC_ void ndr_print_winbind_lookup_req(struct ndr_print *ndr, const char *name, const union winbind_lookup_req *r)
2343 {
2344         int level;
2345         level = ndr_print_get_switch_value(ndr, r);
2346         ndr_print_union(ndr, name, level, "winbind_lookup_req");
2347         switch (level) {
2348                 case WINBIND_LOOKUP_LEVEL_SID2NAME:
2349                         ndr_print_ptr(ndr, "sid", r->sid);
2350                         ndr->depth++;
2351                         if (r->sid) {
2352                                 ndr_print_dom_sid(ndr, "sid", r->sid);
2353                         }
2354                         ndr->depth--;
2355                 break;
2356
2357                 case WINBIND_LOOKUP_LEVEL_NAME2SID:
2358                         ndr_print_string(ndr, "name", r->name);
2359                 break;
2360
2361                 case WINBIND_LOOKUP_LEVEL_RIDS2NAMES:
2362                         ndr_print_STRUCT_winbind_lookup_req_rids(ndr, "rids", &r->rids);
2363                 break;
2364
2365                 case WINBIND_LOOKUP_LEVEL_SID2USERINFO:
2366                         ndr_print_ptr(ndr, "sid", r->sid);
2367                         ndr->depth++;
2368                         if (r->sid) {
2369                                 ndr_print_dom_sid(ndr, "sid", r->sid);
2370                         }
2371                         ndr->depth--;
2372                 break;
2373
2374                 case WINBIND_LOOKUP_LEVEL_SID2DOMGROUPS:
2375                         ndr_print_ptr(ndr, "sid", r->sid);
2376                         ndr->depth++;
2377                         if (r->sid) {
2378                                 ndr_print_dom_sid(ndr, "sid", r->sid);
2379                         }
2380                         ndr->depth--;
2381                 break;
2382
2383                 case WINBIND_LOOKUP_LEVEL_EXPANDALIASES:
2384                         ndr_print_STRUCT_winbind_lookup_sid_info_array(ndr, "sid_array", &r->sid_array);
2385                 break;
2386
2387                 default:
2388                 break;
2389
2390         }
2391 }
2392
2393 static enum ndr_err_code ndr_push_winbind_lookup_rep(struct ndr_push *ndr, int ndr_flags, const union winbind_lookup_rep *r)
2394 {
2395         if (ndr_flags & NDR_SCALARS) {
2396                 int level = ndr_push_get_switch_value(ndr, r);
2397                 NDR_CHECK(ndr_push_winbind_lookup_level(ndr, NDR_SCALARS, level));
2398                 switch (level) {
2399                         case WINBIND_LOOKUP_LEVEL_SID2NAME: {
2400                                 NDR_CHECK(ndr_push_STRUCT_winbind_lookup_name_info(ndr, NDR_SCALARS, &r->name_info));
2401                         break; }
2402
2403                         case WINBIND_LOOKUP_LEVEL_NAME2SID: {
2404                                 NDR_CHECK(ndr_push_STRUCT_winbind_lookup_sid_info(ndr, NDR_SCALARS, &r->sid_info));
2405                         break; }
2406
2407                         case WINBIND_LOOKUP_LEVEL_RIDS2NAMES: {
2408                                 NDR_CHECK(ndr_push_STRUCT_winbind_lookup_name_info_array(ndr, NDR_SCALARS, &r->name_array));
2409                         break; }
2410
2411                         case WINBIND_LOOKUP_LEVEL_SID2USERINFO: {
2412                                 NDR_CHECK(ndr_push_STRUCT_winbind_lookup_user_info(ndr, NDR_SCALARS, &r->user_info));
2413                         break; }
2414
2415                         case WINBIND_LOOKUP_LEVEL_SID2DOMGROUPS: {
2416                                 NDR_CHECK(ndr_push_STRUCT_winbind_lookup_sid_info_array(ndr, NDR_SCALARS, &r->sid_array));
2417                         break; }
2418
2419                         case WINBIND_LOOKUP_LEVEL_EXPANDALIASES: {
2420                                 NDR_CHECK(ndr_push_STRUCT_winbind_lookup_sid_info_array(ndr, NDR_SCALARS, &r->sid_array));
2421                         break; }
2422
2423                         default: {
2424                         break; }
2425
2426                 }
2427         }
2428         if (ndr_flags & NDR_BUFFERS) {
2429                 int level = ndr_push_get_switch_value(ndr, r);
2430                 switch (level) {
2431                         case WINBIND_LOOKUP_LEVEL_SID2NAME:
2432                         break;
2433
2434                         case WINBIND_LOOKUP_LEVEL_NAME2SID:
2435                                 NDR_CHECK(ndr_push_STRUCT_winbind_lookup_sid_info(ndr, NDR_BUFFERS, &r->sid_info));
2436                         break;
2437
2438                         case WINBIND_LOOKUP_LEVEL_RIDS2NAMES:
2439                         break;
2440
2441                         case WINBIND_LOOKUP_LEVEL_SID2USERINFO:
2442                         break;
2443
2444                         case WINBIND_LOOKUP_LEVEL_SID2DOMGROUPS:
2445                                 NDR_CHECK(ndr_push_STRUCT_winbind_lookup_sid_info_array(ndr, NDR_BUFFERS, &r->sid_array));
2446                         break;
2447
2448                         case WINBIND_LOOKUP_LEVEL_EXPANDALIASES:
2449                                 NDR_CHECK(ndr_push_STRUCT_winbind_lookup_sid_info_array(ndr, NDR_BUFFERS, &r->sid_array));
2450                         break;
2451
2452                         default:
2453                         break;
2454
2455                 }
2456         }
2457         return NDR_ERR_SUCCESS;
2458 }
2459
2460 static enum ndr_err_code ndr_pull_winbind_lookup_rep(struct ndr_pull *ndr, int ndr_flags, union winbind_lookup_rep *r)
2461 {
2462         int level;
2463         uint32_t _level;
2464         level = ndr_pull_get_switch_value(ndr, r);
2465         if (ndr_flags & NDR_SCALARS) {
2466                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
2467                 if (_level != level) {
2468                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
2469                 }
2470                 switch (level) {
2471                         case WINBIND_LOOKUP_LEVEL_SID2NAME: {
2472                                 NDR_CHECK(ndr_pull_STRUCT_winbind_lookup_name_info(ndr, NDR_SCALARS, &r->name_info));
2473                         break; }
2474
2475                         case WINBIND_LOOKUP_LEVEL_NAME2SID: {
2476                                 NDR_CHECK(ndr_pull_STRUCT_winbind_lookup_sid_info(ndr, NDR_SCALARS, &r->sid_info));
2477                         break; }
2478
2479                         case WINBIND_LOOKUP_LEVEL_RIDS2NAMES: {
2480                                 NDR_CHECK(ndr_pull_STRUCT_winbind_lookup_name_info_array(ndr, NDR_SCALARS, &r->name_array));
2481                         break; }
2482
2483                         case WINBIND_LOOKUP_LEVEL_SID2USERINFO: {
2484                                 NDR_CHECK(ndr_pull_STRUCT_winbind_lookup_user_info(ndr, NDR_SCALARS, &r->user_info));
2485                         break; }
2486
2487                         case WINBIND_LOOKUP_LEVEL_SID2DOMGROUPS: {
2488                                 NDR_CHECK(ndr_pull_STRUCT_winbind_lookup_sid_info_array(ndr, NDR_SCALARS, &r->sid_array));
2489                         break; }
2490
2491                         case WINBIND_LOOKUP_LEVEL_EXPANDALIASES: {
2492                                 NDR_CHECK(ndr_pull_STRUCT_winbind_lookup_sid_info_array(ndr, NDR_SCALARS, &r->sid_array));
2493                         break; }
2494
2495                         default: {
2496                         break; }
2497
2498                 }
2499         }
2500         if (ndr_flags & NDR_BUFFERS) {
2501                 switch (level) {
2502                         case WINBIND_LOOKUP_LEVEL_SID2NAME:
2503                         break;
2504
2505                         case WINBIND_LOOKUP_LEVEL_NAME2SID:
2506                                 NDR_CHECK(ndr_pull_STRUCT_winbind_lookup_sid_info(ndr, NDR_BUFFERS, &r->sid_info));
2507                         break;
2508
2509                         case WINBIND_LOOKUP_LEVEL_RIDS2NAMES:
2510                         break;
2511
2512                         case WINBIND_LOOKUP_LEVEL_SID2USERINFO:
2513                         break;
2514
2515                         case WINBIND_LOOKUP_LEVEL_SID2DOMGROUPS:
2516                                 NDR_CHECK(ndr_pull_STRUCT_winbind_lookup_sid_info_array(ndr, NDR_BUFFERS, &r->sid_array));
2517                         break;
2518
2519                         case WINBIND_LOOKUP_LEVEL_EXPANDALIASES:
2520                                 NDR_CHECK(ndr_pull_STRUCT_winbind_lookup_sid_info_array(ndr, NDR_BUFFERS, &r->sid_array));
2521                         break;
2522
2523                         default:
2524                         break;
2525
2526                 }
2527         }
2528         return NDR_ERR_SUCCESS;
2529 }
2530
2531 _PUBLIC_ void ndr_print_winbind_lookup_rep(struct ndr_print *ndr, const char *name, const union winbind_lookup_rep *r)
2532 {
2533         int level;
2534         level = ndr_print_get_switch_value(ndr, r);
2535         ndr_print_union(ndr, name, level, "winbind_lookup_rep");
2536         switch (level) {
2537                 case WINBIND_LOOKUP_LEVEL_SID2NAME:
2538                         ndr_print_STRUCT_winbind_lookup_name_info(ndr, "name_info", &r->name_info);
2539                 break;
2540
2541                 case WINBIND_LOOKUP_LEVEL_NAME2SID:
2542                         ndr_print_STRUCT_winbind_lookup_sid_info(ndr, "sid_info", &r->sid_info);
2543                 break;
2544
2545                 case WINBIND_LOOKUP_LEVEL_RIDS2NAMES:
2546                         ndr_print_STRUCT_winbind_lookup_name_info_array(ndr, "name_array", &r->name_array);
2547                 break;
2548
2549                 case WINBIND_LOOKUP_LEVEL_SID2USERINFO:
2550                         ndr_print_STRUCT_winbind_lookup_user_info(ndr, "user_info", &r->user_info);
2551                 break;
2552
2553                 case WINBIND_LOOKUP_LEVEL_SID2DOMGROUPS:
2554                         ndr_print_STRUCT_winbind_lookup_sid_info_array(ndr, "sid_array", &r->sid_array);
2555                 break;
2556
2557                 case WINBIND_LOOKUP_LEVEL_EXPANDALIASES:
2558                         ndr_print_STRUCT_winbind_lookup_sid_info_array(ndr, "sid_array", &r->sid_array);
2559                 break;
2560
2561                 default:
2562                 break;
2563
2564         }
2565 }
2566
2567 static enum ndr_err_code ndr_push_winbind_get_idmap_level(struct ndr_push *ndr, int ndr_flags, enum winbind_get_idmap_level r)
2568 {
2569         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2570         return NDR_ERR_SUCCESS;
2571 }
2572
2573 static enum ndr_err_code ndr_pull_winbind_get_idmap_level(struct ndr_pull *ndr, int ndr_flags, enum winbind_get_idmap_level *r)
2574 {
2575         uint32_t v;
2576         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2577         *r = v;
2578         return NDR_ERR_SUCCESS;
2579 }
2580
2581 _PUBLIC_ void ndr_print_winbind_get_idmap_level(struct ndr_print *ndr, const char *name, enum winbind_get_idmap_level r)
2582 {
2583         const char *val = NULL;
2584
2585         switch (r) {
2586                 case WINBIND_IDMAP_LEVEL_SID_TO_UID: val = "WINBIND_IDMAP_LEVEL_SID_TO_UID"; break;
2587                 case WINBIND_IDMAP_LEVEL_SID_TO_GID: val = "WINBIND_IDMAP_LEVEL_SID_TO_GID"; break;
2588                 case WINBIND_IDMAP_LEVEL_UID_TO_SID: val = "WINBIND_IDMAP_LEVEL_UID_TO_SID"; break;
2589                 case WINBIND_IDMAP_LEVEL_GID_TO_SID: val = "WINBIND_IDMAP_LEVEL_GID_TO_SID"; break;
2590         }
2591         ndr_print_enum(ndr, name, "ENUM", val, r);
2592 }
2593
2594 static enum ndr_err_code ndr_push_winbind_get_idmap_req(struct ndr_push *ndr, int ndr_flags, const union winbind_get_idmap_req *r)
2595 {
2596         if (ndr_flags & NDR_SCALARS) {
2597                 int level = ndr_push_get_switch_value(ndr, r);
2598                 NDR_CHECK(ndr_push_winbind_get_idmap_level(ndr, NDR_SCALARS, level));
2599                 switch (level) {
2600                         case WINBIND_IDMAP_LEVEL_SID_TO_UID: {
2601                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
2602                         break; }
2603
2604                         case WINBIND_IDMAP_LEVEL_SID_TO_GID: {
2605                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
2606                         break; }
2607
2608                         case WINBIND_IDMAP_LEVEL_UID_TO_SID: {
2609                                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->uid));
2610                         break; }
2611
2612                         case WINBIND_IDMAP_LEVEL_GID_TO_SID: {
2613                                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->gid));
2614                         break; }
2615
2616                         default:
2617                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
2618                 }
2619         }
2620         if (ndr_flags & NDR_BUFFERS) {
2621                 int level = ndr_push_get_switch_value(ndr, r);
2622                 switch (level) {
2623                         case WINBIND_IDMAP_LEVEL_SID_TO_UID:
2624                                 if (r->sid) {
2625                                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
2626                                 }
2627                         break;
2628
2629                         case WINBIND_IDMAP_LEVEL_SID_TO_GID:
2630                                 if (r->sid) {
2631                                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
2632                                 }
2633                         break;
2634
2635                         case WINBIND_IDMAP_LEVEL_UID_TO_SID:
2636                         break;
2637
2638                         case WINBIND_IDMAP_LEVEL_GID_TO_SID:
2639                         break;
2640
2641                         default:
2642                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
2643                 }
2644         }
2645         return NDR_ERR_SUCCESS;
2646 }
2647
2648 static enum ndr_err_code ndr_pull_winbind_get_idmap_req(struct ndr_pull *ndr, int ndr_flags, union winbind_get_idmap_req *r)
2649 {
2650         int level;
2651         uint32_t _level;
2652         TALLOC_CTX *_mem_save_sid_0;
2653         level = ndr_pull_get_switch_value(ndr, r);
2654         if (ndr_flags & NDR_SCALARS) {
2655                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
2656                 if (_level != level) {
2657                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
2658                 }
2659                 switch (level) {
2660                         case WINBIND_IDMAP_LEVEL_SID_TO_UID: {
2661                                 uint32_t _ptr_sid;
2662                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
2663                                 if (_ptr_sid) {
2664                                         NDR_PULL_ALLOC(ndr, r->sid);
2665                                 } else {
2666                                         r->sid = NULL;
2667                                 }
2668                         break; }
2669
2670                         case WINBIND_IDMAP_LEVEL_SID_TO_GID: {
2671                                 uint32_t _ptr_sid;
2672                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
2673                                 if (_ptr_sid) {
2674                                         NDR_PULL_ALLOC(ndr, r->sid);
2675                                 } else {
2676                                         r->sid = NULL;
2677                                 }
2678                         break; }
2679
2680                         case WINBIND_IDMAP_LEVEL_UID_TO_SID: {
2681                                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->uid));
2682                         break; }
2683
2684                         case WINBIND_IDMAP_LEVEL_GID_TO_SID: {
2685                                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->gid));
2686                         break; }
2687
2688                         default:
2689                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
2690                 }
2691         }
2692         if (ndr_flags & NDR_BUFFERS) {
2693                 switch (level) {
2694                         case WINBIND_IDMAP_LEVEL_SID_TO_UID:
2695                                 if (r->sid) {
2696                                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2697                                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
2698                                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
2699                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
2700                                 }
2701                         break;
2702
2703                         case WINBIND_IDMAP_LEVEL_SID_TO_GID:
2704                                 if (r->sid) {
2705                                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2706                                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
2707                                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
2708                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
2709                                 }
2710                         break;
2711
2712                         case WINBIND_IDMAP_LEVEL_UID_TO_SID:
2713                         break;
2714
2715                         case WINBIND_IDMAP_LEVEL_GID_TO_SID:
2716                         break;
2717
2718                         default:
2719                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
2720                 }
2721         }
2722         return NDR_ERR_SUCCESS;
2723 }
2724
2725 _PUBLIC_ void ndr_print_winbind_get_idmap_req(struct ndr_print *ndr, const char *name, const union winbind_get_idmap_req *r)
2726 {
2727         int level;
2728         level = ndr_print_get_switch_value(ndr, r);
2729         ndr_print_union(ndr, name, level, "winbind_get_idmap_req");
2730         switch (level) {
2731                 case WINBIND_IDMAP_LEVEL_SID_TO_UID:
2732                         ndr_print_ptr(ndr, "sid", r->sid);
2733                         ndr->depth++;
2734                         if (r->sid) {
2735                                 ndr_print_dom_sid(ndr, "sid", r->sid);
2736                         }
2737                         ndr->depth--;
2738                 break;
2739
2740                 case WINBIND_IDMAP_LEVEL_SID_TO_GID:
2741                         ndr_print_ptr(ndr, "sid", r->sid);
2742                         ndr->depth++;
2743                         if (r->sid) {
2744                                 ndr_print_dom_sid(ndr, "sid", r->sid);
2745                         }
2746                         ndr->depth--;
2747                 break;
2748
2749                 case WINBIND_IDMAP_LEVEL_UID_TO_SID:
2750                         ndr_print_hyper(ndr, "uid", r->uid);
2751                 break;
2752
2753                 case WINBIND_IDMAP_LEVEL_GID_TO_SID:
2754                         ndr_print_hyper(ndr, "gid", r->gid);
2755                 break;
2756
2757                 default:
2758                         ndr_print_bad_level(ndr, name, level);
2759         }
2760 }
2761
2762 static enum ndr_err_code ndr_push_winbind_get_idmap_rep(struct ndr_push *ndr, int ndr_flags, const union winbind_get_idmap_rep *r)
2763 {
2764         if (ndr_flags & NDR_SCALARS) {
2765                 int level = ndr_push_get_switch_value(ndr, r);
2766                 NDR_CHECK(ndr_push_winbind_get_idmap_level(ndr, NDR_SCALARS, level));
2767                 switch (level) {
2768                         case WINBIND_IDMAP_LEVEL_SID_TO_UID: {
2769                                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->uid));
2770                         break; }
2771
2772                         case WINBIND_IDMAP_LEVEL_SID_TO_GID: {
2773                                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->gid));
2774                         break; }
2775
2776                         case WINBIND_IDMAP_LEVEL_UID_TO_SID: {
2777                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
2778                         break; }
2779
2780                         case WINBIND_IDMAP_LEVEL_GID_TO_SID: {
2781                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
2782                         break; }
2783
2784                         default:
2785                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
2786                 }
2787         }
2788         if (ndr_flags & NDR_BUFFERS) {
2789                 int level = ndr_push_get_switch_value(ndr, r);
2790                 switch (level) {
2791                         case WINBIND_IDMAP_LEVEL_SID_TO_UID:
2792                         break;
2793
2794                         case WINBIND_IDMAP_LEVEL_SID_TO_GID:
2795                         break;
2796
2797                         case WINBIND_IDMAP_LEVEL_UID_TO_SID:
2798                                 if (r->sid) {
2799                                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
2800                                 }
2801                         break;
2802
2803                         case WINBIND_IDMAP_LEVEL_GID_TO_SID:
2804                                 if (r->sid) {
2805                                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
2806                                 }
2807                         break;
2808
2809                         default:
2810                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
2811                 }
2812         }
2813         return NDR_ERR_SUCCESS;
2814 }
2815
2816 static enum ndr_err_code ndr_pull_winbind_get_idmap_rep(struct ndr_pull *ndr, int ndr_flags, union winbind_get_idmap_rep *r)
2817 {
2818         int level;
2819         uint32_t _level;
2820         TALLOC_CTX *_mem_save_sid_0;
2821         level = ndr_pull_get_switch_value(ndr, r);
2822         if (ndr_flags & NDR_SCALARS) {
2823                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
2824                 if (_level != level) {
2825                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
2826                 }
2827                 switch (level) {
2828                         case WINBIND_IDMAP_LEVEL_SID_TO_UID: {
2829                                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->uid));
2830                         break; }
2831
2832                         case WINBIND_IDMAP_LEVEL_SID_TO_GID: {
2833                                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->gid));
2834                         break; }
2835
2836                         case WINBIND_IDMAP_LEVEL_UID_TO_SID: {
2837                                 uint32_t _ptr_sid;
2838                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
2839                                 if (_ptr_sid) {
2840                                         NDR_PULL_ALLOC(ndr, r->sid);
2841                                 } else {
2842                                         r->sid = NULL;
2843                                 }
2844                         break; }
2845
2846                         case WINBIND_IDMAP_LEVEL_GID_TO_SID: {
2847                                 uint32_t _ptr_sid;
2848                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
2849                                 if (_ptr_sid) {
2850                                         NDR_PULL_ALLOC(ndr, r->sid);
2851                                 } else {
2852                                         r->sid = NULL;
2853                                 }
2854                         break; }
2855
2856                         default:
2857                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
2858                 }
2859         }
2860         if (ndr_flags & NDR_BUFFERS) {
2861                 switch (level) {
2862                         case WINBIND_IDMAP_LEVEL_SID_TO_UID:
2863                         break;
2864
2865                         case WINBIND_IDMAP_LEVEL_SID_TO_GID:
2866                         break;
2867
2868                         case WINBIND_IDMAP_LEVEL_UID_TO_SID:
2869                                 if (r->sid) {
2870                                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2871                                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
2872                                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
2873                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
2874                                 }
2875                         break;
2876
2877                         case WINBIND_IDMAP_LEVEL_GID_TO_SID:
2878                                 if (r->sid) {
2879                                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2880                                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
2881                                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
2882                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
2883                                 }
2884                         break;
2885
2886                         default:
2887                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
2888                 }
2889         }
2890         return NDR_ERR_SUCCESS;
2891 }
2892
2893 _PUBLIC_ void ndr_print_winbind_get_idmap_rep(struct ndr_print *ndr, const char *name, const union winbind_get_idmap_rep *r)
2894 {
2895         int level;
2896         level = ndr_print_get_switch_value(ndr, r);
2897         ndr_print_union(ndr, name, level, "winbind_get_idmap_rep");
2898         switch (level) {
2899                 case WINBIND_IDMAP_LEVEL_SID_TO_UID:
2900                         ndr_print_hyper(ndr, "uid", r->uid);
2901                 break;
2902
2903                 case WINBIND_IDMAP_LEVEL_SID_TO_GID:
2904                         ndr_print_hyper(ndr, "gid", r->gid);
2905                 break;
2906
2907                 case WINBIND_IDMAP_LEVEL_UID_TO_SID:
2908                         ndr_print_ptr(ndr, "sid", r->sid);
2909                         ndr->depth++;
2910                         if (r->sid) {
2911                                 ndr_print_dom_sid(ndr, "sid", r->sid);
2912                         }
2913                         ndr->depth--;
2914                 break;
2915
2916                 case WINBIND_IDMAP_LEVEL_GID_TO_SID:
2917                         ndr_print_ptr(ndr, "sid", r->sid);
2918                         ndr->depth++;
2919                         if (r->sid) {
2920                                 ndr_print_dom_sid(ndr, "sid", r->sid);
2921                         }
2922                         ndr->depth--;
2923                 break;
2924
2925                 default:
2926                         ndr_print_bad_level(ndr, name, level);
2927         }
2928 }
2929
2930 static enum ndr_err_code ndr_push_winbind_set_idmap_level(struct ndr_push *ndr, int ndr_flags, enum winbind_set_idmap_level r)
2931 {
2932         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2933         return NDR_ERR_SUCCESS;
2934 }
2935
2936 static enum ndr_err_code ndr_pull_winbind_set_idmap_level(struct ndr_pull *ndr, int ndr_flags, enum winbind_set_idmap_level *r)
2937 {
2938         uint32_t v;
2939         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2940         *r = v;
2941         return NDR_ERR_SUCCESS;
2942 }
2943
2944 _PUBLIC_ void ndr_print_winbind_set_idmap_level(struct ndr_print *ndr, const char *name, enum winbind_set_idmap_level r)
2945 {
2946         const char *val = NULL;
2947
2948         switch (r) {
2949                 case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_UID: val = "WINBIND_SET_IDMAP_LEVEL_ALLOCATE_UID"; break;
2950                 case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_GID: val = "WINBIND_SET_IDMAP_LEVEL_ALLOCATE_GID"; break;
2951                 case WINBIND_SET_IDMAP_LEVEL_SET_MAPPING: val = "WINBIND_SET_IDMAP_LEVEL_SET_MAPPING"; break;
2952                 case WINBIND_SET_IDMAP_LEVEL_SET_HWM: val = "WINBIND_SET_IDMAP_LEVEL_SET_HWM"; break;
2953         }
2954         ndr_print_enum(ndr, name, "ENUM", val, r);
2955 }
2956
2957 static enum ndr_err_code ndr_push_winbind_set_idmap_req(struct ndr_push *ndr, int ndr_flags, const union winbind_set_idmap_req *r)
2958 {
2959         if (ndr_flags & NDR_SCALARS) {
2960                 int level = ndr_push_get_switch_value(ndr, r);
2961                 NDR_CHECK(ndr_push_winbind_set_idmap_level(ndr, NDR_SCALARS, level));
2962                 switch (level) {
2963                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_UID: {
2964                         break; }
2965
2966                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_GID: {
2967                         break; }
2968
2969                         case WINBIND_SET_IDMAP_LEVEL_SET_MAPPING: {
2970                                 NDR_CHECK(ndr_push_id_map(ndr, NDR_SCALARS, &r->mapping));
2971                         break; }
2972
2973                         case WINBIND_SET_IDMAP_LEVEL_SET_HWM: {
2974                                 NDR_CHECK(ndr_push_unixid(ndr, NDR_SCALARS, &r->hwm));
2975                         break; }
2976
2977                         default:
2978                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
2979                 }
2980         }
2981         if (ndr_flags & NDR_BUFFERS) {
2982                 int level = ndr_push_get_switch_value(ndr, r);
2983                 switch (level) {
2984                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_UID:
2985                         break;
2986
2987                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_GID:
2988                         break;
2989
2990                         case WINBIND_SET_IDMAP_LEVEL_SET_MAPPING:
2991                                 NDR_CHECK(ndr_push_id_map(ndr, NDR_BUFFERS, &r->mapping));
2992                         break;
2993
2994                         case WINBIND_SET_IDMAP_LEVEL_SET_HWM:
2995                                 NDR_CHECK(ndr_push_unixid(ndr, NDR_BUFFERS, &r->hwm));
2996                         break;
2997
2998                         default:
2999                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3000                 }
3001         }
3002         return NDR_ERR_SUCCESS;
3003 }
3004
3005 static enum ndr_err_code ndr_pull_winbind_set_idmap_req(struct ndr_pull *ndr, int ndr_flags, union winbind_set_idmap_req *r)
3006 {
3007         int level;
3008         uint32_t _level;
3009         level = ndr_pull_get_switch_value(ndr, r);
3010         if (ndr_flags & NDR_SCALARS) {
3011                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
3012                 if (_level != level) {
3013                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3014                 }
3015                 switch (level) {
3016                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_UID: {
3017                         break; }
3018
3019                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_GID: {
3020                         break; }
3021
3022                         case WINBIND_SET_IDMAP_LEVEL_SET_MAPPING: {
3023                                 NDR_CHECK(ndr_pull_id_map(ndr, NDR_SCALARS, &r->mapping));
3024                         break; }
3025
3026                         case WINBIND_SET_IDMAP_LEVEL_SET_HWM: {
3027                                 NDR_CHECK(ndr_pull_unixid(ndr, NDR_SCALARS, &r->hwm));
3028                         break; }
3029
3030                         default:
3031                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3032                 }
3033         }
3034         if (ndr_flags & NDR_BUFFERS) {
3035                 switch (level) {
3036                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_UID:
3037                         break;
3038
3039                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_GID:
3040                         break;
3041
3042                         case WINBIND_SET_IDMAP_LEVEL_SET_MAPPING:
3043                                 NDR_CHECK(ndr_pull_id_map(ndr, NDR_BUFFERS, &r->mapping));
3044                         break;
3045
3046                         case WINBIND_SET_IDMAP_LEVEL_SET_HWM:
3047                                 NDR_CHECK(ndr_pull_unixid(ndr, NDR_BUFFERS, &r->hwm));
3048                         break;
3049
3050                         default:
3051                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3052                 }
3053         }
3054         return NDR_ERR_SUCCESS;
3055 }
3056
3057 _PUBLIC_ void ndr_print_winbind_set_idmap_req(struct ndr_print *ndr, const char *name, const union winbind_set_idmap_req *r)
3058 {
3059         int level;
3060         level = ndr_print_get_switch_value(ndr, r);
3061         ndr_print_union(ndr, name, level, "winbind_set_idmap_req");
3062         switch (level) {
3063                 case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_UID:
3064                 break;
3065
3066                 case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_GID:
3067                 break;
3068
3069                 case WINBIND_SET_IDMAP_LEVEL_SET_MAPPING:
3070                         ndr_print_id_map(ndr, "mapping", &r->mapping);
3071                 break;
3072
3073                 case WINBIND_SET_IDMAP_LEVEL_SET_HWM:
3074                         ndr_print_unixid(ndr, "hwm", &r->hwm);
3075                 break;
3076
3077                 default:
3078                         ndr_print_bad_level(ndr, name, level);
3079         }
3080 }
3081
3082 static enum ndr_err_code ndr_push_winbind_set_idmap_rep(struct ndr_push *ndr, int ndr_flags, const union winbind_set_idmap_rep *r)
3083 {
3084         if (ndr_flags & NDR_SCALARS) {
3085                 int level = ndr_push_get_switch_value(ndr, r);
3086                 NDR_CHECK(ndr_push_winbind_set_idmap_level(ndr, NDR_SCALARS, level));
3087                 switch (level) {
3088                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_UID: {
3089                                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->uid));
3090                         break; }
3091
3092                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_GID: {
3093                                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->gid));
3094                         break; }
3095
3096                         case WINBIND_SET_IDMAP_LEVEL_SET_MAPPING: {
3097                         break; }
3098
3099                         case WINBIND_SET_IDMAP_LEVEL_SET_HWM: {
3100                         break; }
3101
3102                         default:
3103                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3104                 }
3105         }
3106         if (ndr_flags & NDR_BUFFERS) {
3107                 int level = ndr_push_get_switch_value(ndr, r);
3108                 switch (level) {
3109                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_UID:
3110                         break;
3111
3112                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_GID:
3113                         break;
3114
3115                         case WINBIND_SET_IDMAP_LEVEL_SET_MAPPING:
3116                         break;
3117
3118                         case WINBIND_SET_IDMAP_LEVEL_SET_HWM:
3119                         break;
3120
3121                         default:
3122                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3123                 }
3124         }
3125         return NDR_ERR_SUCCESS;
3126 }
3127
3128 static enum ndr_err_code ndr_pull_winbind_set_idmap_rep(struct ndr_pull *ndr, int ndr_flags, union winbind_set_idmap_rep *r)
3129 {
3130         int level;
3131         uint32_t _level;
3132         level = ndr_pull_get_switch_value(ndr, r);
3133         if (ndr_flags & NDR_SCALARS) {
3134                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
3135                 if (_level != level) {
3136                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3137                 }
3138                 switch (level) {
3139                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_UID: {
3140                                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->uid));
3141                         break; }
3142
3143                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_GID: {
3144                                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->gid));
3145                         break; }
3146
3147                         case WINBIND_SET_IDMAP_LEVEL_SET_MAPPING: {
3148                         break; }
3149
3150                         case WINBIND_SET_IDMAP_LEVEL_SET_HWM: {
3151                         break; }
3152
3153                         default:
3154                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3155                 }
3156         }
3157         if (ndr_flags & NDR_BUFFERS) {
3158                 switch (level) {
3159                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_UID:
3160                         break;
3161
3162                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_GID:
3163                         break;
3164
3165                         case WINBIND_SET_IDMAP_LEVEL_SET_MAPPING:
3166                         break;
3167
3168                         case WINBIND_SET_IDMAP_LEVEL_SET_HWM:
3169                         break;
3170
3171                         default:
3172                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3173                 }
3174         }
3175         return NDR_ERR_SUCCESS;
3176 }
3177
3178 _PUBLIC_ void ndr_print_winbind_set_idmap_rep(struct ndr_print *ndr, const char *name, const union winbind_set_idmap_rep *r)
3179 {
3180         int level;
3181         level = ndr_print_get_switch_value(ndr, r);
3182         ndr_print_union(ndr, name, level, "winbind_set_idmap_rep");
3183         switch (level) {
3184                 case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_UID:
3185                         ndr_print_hyper(ndr, "uid", r->uid);
3186                 break;
3187
3188                 case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_GID:
3189                         ndr_print_hyper(ndr, "gid", r->gid);
3190                 break;
3191
3192                 case WINBIND_SET_IDMAP_LEVEL_SET_MAPPING:
3193                 break;
3194
3195                 case WINBIND_SET_IDMAP_LEVEL_SET_HWM:
3196                 break;
3197
3198                 default:
3199                         ndr_print_bad_level(ndr, name, level);
3200         }
3201 }
3202
3203 static enum ndr_err_code ndr_push_winbind_domain_info_level(struct ndr_push *ndr, int ndr_flags, enum winbind_domain_info_level r)
3204 {
3205         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3206         return NDR_ERR_SUCCESS;
3207 }
3208
3209 static enum ndr_err_code ndr_pull_winbind_domain_info_level(struct ndr_pull *ndr, int ndr_flags, enum winbind_domain_info_level *r)
3210 {
3211         uint32_t v;
3212         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3213         *r = v;
3214         return NDR_ERR_SUCCESS;
3215 }
3216
3217 _PUBLIC_ void ndr_print_winbind_domain_info_level(struct ndr_print *ndr, const char *name, enum winbind_domain_info_level r)
3218 {
3219         const char *val = NULL;
3220
3221         switch (r) {
3222                 case WINBIND_DOMAIN_INFO_LEVEL_COMPAT: val = "WINBIND_DOMAIN_INFO_LEVEL_COMPAT"; break;
3223                 case WINBIND_DOMAIN_INFO_LEVEL_SEQNUM: val = "WINBIND_DOMAIN_INFO_LEVEL_SEQNUM"; break;
3224         }
3225         ndr_print_enum(ndr, name, "ENUM", val, r);
3226 }
3227
3228 static enum ndr_err_code ndr_push_winbind_domain_info(struct ndr_push *ndr, int ndr_flags, const union winbind_domain_info *r)
3229 {
3230         if (ndr_flags & NDR_SCALARS) {
3231                 int level = ndr_push_get_switch_value(ndr, r);
3232                 NDR_CHECK(ndr_push_winbind_domain_info_level(ndr, NDR_SCALARS, level));
3233                 switch (level) {
3234                         case WINBIND_DOMAIN_INFO_LEVEL_COMPAT: {
3235                                 NDR_CHECK(ndr_push_STRUCT_winbind_domain_info_compat(ndr, NDR_SCALARS, &r->compat));
3236                         break; }
3237
3238                         case WINBIND_DOMAIN_INFO_LEVEL_SEQNUM: {
3239                                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->seqnum));
3240                         break; }
3241
3242                         default:
3243                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3244                 }
3245         }
3246         if (ndr_flags & NDR_BUFFERS) {
3247                 int level = ndr_push_get_switch_value(ndr, r);
3248                 switch (level) {
3249                         case WINBIND_DOMAIN_INFO_LEVEL_COMPAT:
3250                                 NDR_CHECK(ndr_push_STRUCT_winbind_domain_info_compat(ndr, NDR_BUFFERS, &r->compat));
3251                         break;
3252
3253                         case WINBIND_DOMAIN_INFO_LEVEL_SEQNUM:
3254                         break;
3255
3256                         default:
3257                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3258                 }
3259         }
3260         return NDR_ERR_SUCCESS;
3261 }
3262
3263 static enum ndr_err_code ndr_pull_winbind_domain_info(struct ndr_pull *ndr, int ndr_flags, union winbind_domain_info *r)
3264 {
3265         int level;
3266         uint32_t _level;
3267         level = ndr_pull_get_switch_value(ndr, r);
3268         if (ndr_flags & NDR_SCALARS) {
3269                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
3270                 if (_level != level) {
3271                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3272                 }
3273                 switch (level) {
3274                         case WINBIND_DOMAIN_INFO_LEVEL_COMPAT: {
3275                                 NDR_CHECK(ndr_pull_STRUCT_winbind_domain_info_compat(ndr, NDR_SCALARS, &r->compat));
3276                         break; }
3277
3278                         case WINBIND_DOMAIN_INFO_LEVEL_SEQNUM: {
3279                                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->seqnum));
3280                         break; }
3281
3282                         default:
3283                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3284                 }
3285         }
3286         if (ndr_flags & NDR_BUFFERS) {
3287                 switch (level) {
3288                         case WINBIND_DOMAIN_INFO_LEVEL_COMPAT:
3289                                 NDR_CHECK(ndr_pull_STRUCT_winbind_domain_info_compat(ndr, NDR_BUFFERS, &r->compat));
3290                         break;
3291
3292                         case WINBIND_DOMAIN_INFO_LEVEL_SEQNUM:
3293                         break;
3294
3295                         default:
3296                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3297                 }
3298         }
3299         return NDR_ERR_SUCCESS;
3300 }
3301
3302 _PUBLIC_ void ndr_print_winbind_domain_info(struct ndr_print *ndr, const char *name, const union winbind_domain_info *r)
3303 {
3304         int level;
3305         level = ndr_print_get_switch_value(ndr, r);
3306         ndr_print_union(ndr, name, level, "winbind_domain_info");
3307         switch (level) {
3308                 case WINBIND_DOMAIN_INFO_LEVEL_COMPAT:
3309                         ndr_print_STRUCT_winbind_domain_info_compat(ndr, "compat", &r->compat);
3310                 break;
3311
3312                 case WINBIND_DOMAIN_INFO_LEVEL_SEQNUM:
3313                         ndr_print_hyper(ndr, "seqnum", r->seqnum);
3314                 break;
3315
3316                 default:
3317                         ndr_print_bad_level(ndr, name, level);
3318         }
3319 }
3320
3321 static enum ndr_err_code ndr_push_winbind_dc_info_level(struct ndr_push *ndr, int ndr_flags, enum winbind_dc_info_level r)
3322 {
3323         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3324         return NDR_ERR_SUCCESS;
3325 }
3326
3327 static enum ndr_err_code ndr_pull_winbind_dc_info_level(struct ndr_pull *ndr, int ndr_flags, enum winbind_dc_info_level *r)
3328 {
3329         uint32_t v;
3330         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3331         *r = v;
3332         return NDR_ERR_SUCCESS;
3333 }
3334
3335 _PUBLIC_ void ndr_print_winbind_dc_info_level(struct ndr_print *ndr, const char *name, enum winbind_dc_info_level r)
3336 {
3337         const char *val = NULL;
3338
3339         switch (r) {
3340                 case WINBIND_DC_INFO_LEVEL_COMPAT_NT4: val = "WINBIND_DC_INFO_LEVEL_COMPAT_NT4"; break;
3341                 case WINBIND_DC_INFO_LEVEL_COMPAT_DS: val = "WINBIND_DC_INFO_LEVEL_COMPAT_DS"; break;
3342         }
3343         ndr_print_enum(ndr, name, "ENUM", val, r);
3344 }
3345
3346 static enum ndr_err_code ndr_push_winbind_dc_info_params(struct ndr_push *ndr, int ndr_flags, const union winbind_dc_info_params *r)
3347 {
3348         if (ndr_flags & NDR_SCALARS) {
3349                 int level = ndr_push_get_switch_value(ndr, r);
3350                 NDR_CHECK(ndr_push_winbind_dc_info_level(ndr, NDR_SCALARS, level));
3351                 switch (level) {
3352                         case WINBIND_DC_INFO_LEVEL_COMPAT_NT4: {
3353                         break; }
3354
3355                         case WINBIND_DC_INFO_LEVEL_COMPAT_DS: {
3356                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
3357                         break; }
3358
3359                         default:
3360                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3361                 }
3362         }
3363         if (ndr_flags & NDR_BUFFERS) {
3364                 int level = ndr_push_get_switch_value(ndr, r);
3365                 switch (level) {
3366                         case WINBIND_DC_INFO_LEVEL_COMPAT_NT4:
3367                         break;
3368
3369                         case WINBIND_DC_INFO_LEVEL_COMPAT_DS:
3370                         break;
3371
3372                         default:
3373                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3374                 }
3375         }
3376         return NDR_ERR_SUCCESS;
3377 }
3378
3379 static enum ndr_err_code ndr_pull_winbind_dc_info_params(struct ndr_pull *ndr, int ndr_flags, union winbind_dc_info_params *r)
3380 {
3381         int level;
3382         uint32_t _level;
3383         level = ndr_pull_get_switch_value(ndr, r);
3384         if (ndr_flags & NDR_SCALARS) {
3385                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
3386                 if (_level != level) {
3387                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3388                 }
3389                 switch (level) {
3390                         case WINBIND_DC_INFO_LEVEL_COMPAT_NT4: {
3391                         break; }
3392
3393                         case WINBIND_DC_INFO_LEVEL_COMPAT_DS: {
3394                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
3395                         break; }
3396
3397                         default:
3398                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3399                 }
3400         }
3401         if (ndr_flags & NDR_BUFFERS) {
3402                 switch (level) {
3403                         case WINBIND_DC_INFO_LEVEL_COMPAT_NT4:
3404                         break;
3405
3406                         case WINBIND_DC_INFO_LEVEL_COMPAT_DS:
3407                         break;
3408
3409                         default:
3410                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3411                 }
3412         }
3413         return NDR_ERR_SUCCESS;
3414 }
3415
3416 _PUBLIC_ void ndr_print_winbind_dc_info_params(struct ndr_print *ndr, const char *name, const union winbind_dc_info_params *r)
3417 {
3418         int level;
3419         level = ndr_print_get_switch_value(ndr, r);
3420         ndr_print_union(ndr, name, level, "winbind_dc_info_params");
3421         switch (level) {
3422                 case WINBIND_DC_INFO_LEVEL_COMPAT_NT4:
3423                 break;
3424
3425                 case WINBIND_DC_INFO_LEVEL_COMPAT_DS:
3426                         ndr_print_uint32(ndr, "flags", r->flags);
3427                 break;
3428
3429                 default:
3430                         ndr_print_bad_level(ndr, name, level);
3431         }
3432 }
3433
3434 static enum ndr_err_code ndr_push_winbind_dc_info(struct ndr_push *ndr, int ndr_flags, const union winbind_dc_info *r)
3435 {
3436         if (ndr_flags & NDR_SCALARS) {
3437                 int level = ndr_push_get_switch_value(ndr, r);
3438                 NDR_CHECK(ndr_push_winbind_dc_info_level(ndr, NDR_SCALARS, level));
3439                 switch (level) {
3440                         case WINBIND_DC_INFO_LEVEL_COMPAT_NT4: {
3441                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
3442                         break; }
3443
3444                         case WINBIND_DC_INFO_LEVEL_COMPAT_DS: {
3445                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
3446                         break; }
3447
3448                         default:
3449                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3450                 }
3451         }
3452         if (ndr_flags & NDR_BUFFERS) {
3453                 int level = ndr_push_get_switch_value(ndr, r);
3454                 switch (level) {
3455                         case WINBIND_DC_INFO_LEVEL_COMPAT_NT4:
3456                                 if (r->name) {
3457                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF8)));
3458                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3459                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF8)));
3460                                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
3461                                 }
3462                         break;
3463
3464                         case WINBIND_DC_INFO_LEVEL_COMPAT_DS:
3465                                 if (r->name) {
3466                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF8)));
3467                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3468                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF8)));
3469                                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
3470                                 }
3471                         break;
3472
3473                         default:
3474                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3475                 }
3476         }
3477         return NDR_ERR_SUCCESS;
3478 }
3479
3480 static enum ndr_err_code ndr_pull_winbind_dc_info(struct ndr_pull *ndr, int ndr_flags, union winbind_dc_info *r)
3481 {
3482         int level;
3483         uint32_t _level;
3484         TALLOC_CTX *_mem_save_name_0;
3485         level = ndr_pull_get_switch_value(ndr, r);
3486         if (ndr_flags & NDR_SCALARS) {
3487                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
3488                 if (_level != level) {
3489                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3490                 }
3491                 switch (level) {
3492                         case WINBIND_DC_INFO_LEVEL_COMPAT_NT4: {
3493                                 uint32_t _ptr_name;
3494                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
3495                                 if (_ptr_name) {
3496                                         NDR_PULL_ALLOC(ndr, r->name);
3497                                 } else {
3498                                         r->name = NULL;
3499                                 }
3500                         break; }
3501
3502                         case WINBIND_DC_INFO_LEVEL_COMPAT_DS: {
3503                                 uint32_t _ptr_name;
3504                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
3505                                 if (_ptr_name) {
3506                                         NDR_PULL_ALLOC(ndr, r->name);
3507                                 } else {
3508                                         r->name = NULL;
3509                                 }
3510                         break; }
3511
3512                         default:
3513                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3514                 }
3515         }
3516         if (ndr_flags & NDR_BUFFERS) {
3517                 switch (level) {
3518                         case WINBIND_DC_INFO_LEVEL_COMPAT_NT4:
3519                                 if (r->name) {
3520                                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3521                                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
3522                                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
3523                                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
3524                                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
3525                                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
3526                                         }
3527                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint8_t)));
3528                                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint8_t), CH_UTF8));
3529                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
3530                                 }
3531                         break;
3532
3533                         case WINBIND_DC_INFO_LEVEL_COMPAT_DS:
3534                                 if (r->name) {
3535                                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3536                                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
3537                                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
3538                                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
3539                                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
3540                                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
3541                                         }
3542                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint8_t)));
3543                                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint8_t), CH_UTF8));
3544                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
3545                                 }
3546                         break;
3547
3548                         default:
3549                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3550                 }
3551         }
3552         return NDR_ERR_SUCCESS;
3553 }
3554
3555 _PUBLIC_ void ndr_print_winbind_dc_info(struct ndr_print *ndr, const char *name, const union winbind_dc_info *r)
3556 {
3557         int level;
3558         level = ndr_print_get_switch_value(ndr, r);
3559         ndr_print_union(ndr, name, level, "winbind_dc_info");
3560         switch (level) {
3561                 case WINBIND_DC_INFO_LEVEL_COMPAT_NT4:
3562                         ndr_print_ptr(ndr, "name", r->name);
3563                         ndr->depth++;
3564                         if (r->name) {
3565                                 ndr_print_string(ndr, "name", r->name);
3566                         }
3567                         ndr->depth--;
3568                 break;
3569
3570                 case WINBIND_DC_INFO_LEVEL_COMPAT_DS:
3571                         ndr_print_ptr(ndr, "name", r->name);
3572                         ndr->depth++;
3573                         if (r->name) {
3574                                 ndr_print_string(ndr, "name", r->name);
3575                         }
3576                         ndr->depth--;
3577                 break;
3578
3579                 default:
3580                         ndr_print_bad_level(ndr, name, level);
3581         }
3582 }
3583
3584 static enum ndr_err_code ndr_push_winbind_ping(struct ndr_push *ndr, int flags, const struct winbind_ping *r)
3585 {
3586         if (flags & NDR_IN) {
3587         }
3588         if (flags & NDR_OUT) {
3589                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
3590         }
3591         return NDR_ERR_SUCCESS;
3592 }
3593
3594 static enum ndr_err_code ndr_pull_winbind_ping(struct ndr_pull *ndr, int flags, struct winbind_ping *r)
3595 {
3596         if (flags & NDR_IN) {
3597         }
3598         if (flags & NDR_OUT) {
3599                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
3600         }
3601         return NDR_ERR_SUCCESS;
3602 }
3603
3604 _PUBLIC_ void ndr_print_winbind_ping(struct ndr_print *ndr, const char *name, int flags, const struct winbind_ping *r)
3605 {
3606         ndr_print_struct(ndr, name, "winbind_ping");
3607         ndr->depth++;
3608         if (flags & NDR_SET_VALUES) {
3609                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3610         }
3611         if (flags & NDR_IN) {
3612                 ndr_print_struct(ndr, "in", "winbind_ping");
3613                 ndr->depth++;
3614                 ndr->depth--;
3615         }
3616         if (flags & NDR_OUT) {
3617                 ndr_print_struct(ndr, "out", "winbind_ping");
3618                 ndr->depth++;
3619                 ndr_print_winbind_status(ndr, "result", r->out.result);
3620                 ndr->depth--;
3621         }
3622         ndr->depth--;
3623 }
3624
3625 static enum ndr_err_code ndr_push_winbind_interface_details(struct ndr_push *ndr, int flags, const struct winbind_interface_details *r)
3626 {
3627         if (flags & NDR_IN) {
3628         }
3629         if (flags & NDR_OUT) {
3630                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
3631         }
3632         return NDR_ERR_SUCCESS;
3633 }
3634
3635 static enum ndr_err_code ndr_pull_winbind_interface_details(struct ndr_pull *ndr, int flags, struct winbind_interface_details *r)
3636 {
3637         if (flags & NDR_IN) {
3638         }
3639         if (flags & NDR_OUT) {
3640                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
3641         }
3642         return NDR_ERR_SUCCESS;
3643 }
3644
3645 _PUBLIC_ void ndr_print_winbind_interface_details(struct ndr_print *ndr, const char *name, int flags, const struct winbind_interface_details *r)
3646 {
3647         ndr_print_struct(ndr, name, "winbind_interface_details");
3648         ndr->depth++;
3649         if (flags & NDR_SET_VALUES) {
3650                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3651         }
3652         if (flags & NDR_IN) {
3653                 ndr_print_struct(ndr, "in", "winbind_interface_details");
3654                 ndr->depth++;
3655                 ndr->depth--;
3656         }
3657         if (flags & NDR_OUT) {
3658                 ndr_print_struct(ndr, "out", "winbind_interface_details");
3659                 ndr->depth++;
3660                 ndr_print_winbind_status(ndr, "result", r->out.result);
3661                 ndr->depth--;
3662         }
3663         ndr->depth--;
3664 }
3665
3666 static enum ndr_err_code ndr_push_winbind_getpwnam(struct ndr_push *ndr, int flags, const struct winbind_getpwnam *r)
3667 {
3668         if (flags & NDR_IN) {
3669         }
3670         if (flags & NDR_OUT) {
3671                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
3672         }
3673         return NDR_ERR_SUCCESS;
3674 }
3675
3676 static enum ndr_err_code ndr_pull_winbind_getpwnam(struct ndr_pull *ndr, int flags, struct winbind_getpwnam *r)
3677 {
3678         if (flags & NDR_IN) {
3679         }
3680         if (flags & NDR_OUT) {
3681                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
3682         }
3683         return NDR_ERR_SUCCESS;
3684 }
3685
3686 _PUBLIC_ void ndr_print_winbind_getpwnam(struct ndr_print *ndr, const char *name, int flags, const struct winbind_getpwnam *r)
3687 {
3688         ndr_print_struct(ndr, name, "winbind_getpwnam");
3689         ndr->depth++;
3690         if (flags & NDR_SET_VALUES) {
3691                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3692         }
3693         if (flags & NDR_IN) {
3694                 ndr_print_struct(ndr, "in", "winbind_getpwnam");
3695                 ndr->depth++;
3696                 ndr->depth--;
3697         }
3698         if (flags & NDR_OUT) {
3699                 ndr_print_struct(ndr, "out", "winbind_getpwnam");
3700                 ndr->depth++;
3701                 ndr_print_winbind_status(ndr, "result", r->out.result);
3702                 ndr->depth--;
3703         }
3704         ndr->depth--;
3705 }
3706
3707 static enum ndr_err_code ndr_push_winbind_getpwuid(struct ndr_push *ndr, int flags, const struct winbind_getpwuid *r)
3708 {
3709         if (flags & NDR_IN) {
3710         }
3711         if (flags & NDR_OUT) {
3712                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
3713         }
3714         return NDR_ERR_SUCCESS;
3715 }
3716
3717 static enum ndr_err_code ndr_pull_winbind_getpwuid(struct ndr_pull *ndr, int flags, struct winbind_getpwuid *r)
3718 {
3719         if (flags & NDR_IN) {
3720         }
3721         if (flags & NDR_OUT) {
3722                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
3723         }
3724         return NDR_ERR_SUCCESS;
3725 }
3726
3727 _PUBLIC_ void ndr_print_winbind_getpwuid(struct ndr_print *ndr, const char *name, int flags, const struct winbind_getpwuid *r)
3728 {
3729         ndr_print_struct(ndr, name, "winbind_getpwuid");
3730         ndr->depth++;
3731         if (flags & NDR_SET_VALUES) {
3732                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3733         }
3734         if (flags & NDR_IN) {
3735                 ndr_print_struct(ndr, "in", "winbind_getpwuid");
3736                 ndr->depth++;
3737                 ndr->depth--;
3738         }
3739         if (flags & NDR_OUT) {
3740                 ndr_print_struct(ndr, "out", "winbind_getpwuid");
3741                 ndr->depth++;
3742                 ndr_print_winbind_status(ndr, "result", r->out.result);
3743                 ndr->depth--;
3744         }
3745         ndr->depth--;
3746 }
3747
3748 static enum ndr_err_code ndr_push_winbind_getgrnam(struct ndr_push *ndr, int flags, const struct winbind_getgrnam *r)
3749 {
3750         if (flags & NDR_IN) {
3751         }
3752         if (flags & NDR_OUT) {
3753                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
3754         }
3755         return NDR_ERR_SUCCESS;
3756 }
3757
3758 static enum ndr_err_code ndr_pull_winbind_getgrnam(struct ndr_pull *ndr, int flags, struct winbind_getgrnam *r)
3759 {
3760         if (flags & NDR_IN) {
3761         }
3762         if (flags & NDR_OUT) {
3763                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
3764         }
3765         return NDR_ERR_SUCCESS;
3766 }
3767
3768 _PUBLIC_ void ndr_print_winbind_getgrnam(struct ndr_print *ndr, const char *name, int flags, const struct winbind_getgrnam *r)
3769 {
3770         ndr_print_struct(ndr, name, "winbind_getgrnam");
3771         ndr->depth++;
3772         if (flags & NDR_SET_VALUES) {
3773                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3774         }
3775         if (flags & NDR_IN) {
3776                 ndr_print_struct(ndr, "in", "winbind_getgrnam");
3777                 ndr->depth++;
3778                 ndr->depth--;
3779         }
3780         if (flags & NDR_OUT) {
3781                 ndr_print_struct(ndr, "out", "winbind_getgrnam");
3782                 ndr->depth++;
3783                 ndr_print_winbind_status(ndr, "result", r->out.result);
3784                 ndr->depth--;
3785         }
3786         ndr->depth--;
3787 }
3788
3789 static enum ndr_err_code ndr_push_winbind_getgrgid(struct ndr_push *ndr, int flags, const struct winbind_getgrgid *r)
3790 {
3791         if (flags & NDR_IN) {
3792         }
3793         if (flags & NDR_OUT) {
3794                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
3795         }
3796         return NDR_ERR_SUCCESS;
3797 }
3798
3799 static enum ndr_err_code ndr_pull_winbind_getgrgid(struct ndr_pull *ndr, int flags, struct winbind_getgrgid *r)
3800 {
3801         if (flags & NDR_IN) {
3802         }
3803         if (flags & NDR_OUT) {
3804                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
3805         }
3806         return NDR_ERR_SUCCESS;
3807 }
3808
3809 _PUBLIC_ void ndr_print_winbind_getgrgid(struct ndr_print *ndr, const char *name, int flags, const struct winbind_getgrgid *r)
3810 {
3811         ndr_print_struct(ndr, name, "winbind_getgrgid");
3812         ndr->depth++;
3813         if (flags & NDR_SET_VALUES) {
3814                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3815         }
3816         if (flags & NDR_IN) {
3817                 ndr_print_struct(ndr, "in", "winbind_getgrgid");
3818                 ndr->depth++;
3819                 ndr->depth--;
3820         }
3821         if (flags & NDR_OUT) {
3822                 ndr_print_struct(ndr, "out", "winbind_getgrgid");
3823                 ndr->depth++;
3824                 ndr_print_winbind_status(ndr, "result", r->out.result);
3825                 ndr->depth--;
3826         }
3827         ndr->depth--;
3828 }
3829
3830 static enum ndr_err_code ndr_push_winbind_getgroups(struct ndr_push *ndr, int flags, const struct winbind_getgroups *r)
3831 {
3832         if (flags & NDR_IN) {
3833         }
3834         if (flags & NDR_OUT) {
3835                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
3836         }
3837         return NDR_ERR_SUCCESS;
3838 }
3839
3840 static enum ndr_err_code ndr_pull_winbind_getgroups(struct ndr_pull *ndr, int flags, struct winbind_getgroups *r)
3841 {
3842         if (flags & NDR_IN) {
3843         }
3844         if (flags & NDR_OUT) {
3845                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
3846         }
3847         return NDR_ERR_SUCCESS;
3848 }
3849
3850 _PUBLIC_ void ndr_print_winbind_getgroups(struct ndr_print *ndr, const char *name, int flags, const struct winbind_getgroups *r)
3851 {
3852         ndr_print_struct(ndr, name, "winbind_getgroups");
3853         ndr->depth++;
3854         if (flags & NDR_SET_VALUES) {
3855                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3856         }
3857         if (flags & NDR_IN) {
3858                 ndr_print_struct(ndr, "in", "winbind_getgroups");
3859                 ndr->depth++;
3860                 ndr->depth--;
3861         }
3862         if (flags & NDR_OUT) {
3863                 ndr_print_struct(ndr, "out", "winbind_getgroups");
3864                 ndr->depth++;
3865                 ndr_print_winbind_status(ndr, "result", r->out.result);
3866                 ndr->depth--;
3867         }
3868         ndr->depth--;
3869 }
3870
3871 static enum ndr_err_code ndr_push_winbind_setpwent(struct ndr_push *ndr, int flags, const struct winbind_setpwent *r)
3872 {
3873         if (flags & NDR_IN) {
3874         }
3875         if (flags & NDR_OUT) {
3876                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
3877         }
3878         return NDR_ERR_SUCCESS;
3879 }
3880
3881 static enum ndr_err_code ndr_pull_winbind_setpwent(struct ndr_pull *ndr, int flags, struct winbind_setpwent *r)
3882 {
3883         if (flags & NDR_IN) {
3884         }
3885         if (flags & NDR_OUT) {
3886                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
3887         }
3888         return NDR_ERR_SUCCESS;
3889 }
3890
3891 _PUBLIC_ void ndr_print_winbind_setpwent(struct ndr_print *ndr, const char *name, int flags, const struct winbind_setpwent *r)
3892 {
3893         ndr_print_struct(ndr, name, "winbind_setpwent");
3894         ndr->depth++;
3895         if (flags & NDR_SET_VALUES) {
3896                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3897         }
3898         if (flags & NDR_IN) {
3899                 ndr_print_struct(ndr, "in", "winbind_setpwent");
3900                 ndr->depth++;
3901                 ndr->depth--;
3902         }
3903         if (flags & NDR_OUT) {
3904                 ndr_print_struct(ndr, "out", "winbind_setpwent");
3905                 ndr->depth++;
3906                 ndr_print_winbind_status(ndr, "result", r->out.result);
3907                 ndr->depth--;
3908         }
3909         ndr->depth--;
3910 }
3911
3912 static enum ndr_err_code ndr_push_winbind_endpwent(struct ndr_push *ndr, int flags, const struct winbind_endpwent *r)
3913 {
3914         if (flags & NDR_IN) {
3915         }
3916         if (flags & NDR_OUT) {
3917                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
3918         }
3919         return NDR_ERR_SUCCESS;
3920 }
3921
3922 static enum ndr_err_code ndr_pull_winbind_endpwent(struct ndr_pull *ndr, int flags, struct winbind_endpwent *r)
3923 {
3924         if (flags & NDR_IN) {
3925         }
3926         if (flags & NDR_OUT) {
3927                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
3928         }
3929         return NDR_ERR_SUCCESS;
3930 }
3931
3932 _PUBLIC_ void ndr_print_winbind_endpwent(struct ndr_print *ndr, const char *name, int flags, const struct winbind_endpwent *r)
3933 {
3934         ndr_print_struct(ndr, name, "winbind_endpwent");
3935         ndr->depth++;
3936         if (flags & NDR_SET_VALUES) {
3937                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3938         }
3939         if (flags & NDR_IN) {
3940                 ndr_print_struct(ndr, "in", "winbind_endpwent");
3941                 ndr->depth++;
3942                 ndr->depth--;
3943         }
3944         if (flags & NDR_OUT) {
3945                 ndr_print_struct(ndr, "out", "winbind_endpwent");
3946                 ndr->depth++;
3947                 ndr_print_winbind_status(ndr, "result", r->out.result);
3948                 ndr->depth--;
3949         }
3950         ndr->depth--;
3951 }
3952
3953 static enum ndr_err_code ndr_push_winbind_getpwent(struct ndr_push *ndr, int flags, const struct winbind_getpwent *r)
3954 {
3955         if (flags & NDR_IN) {
3956         }
3957         if (flags & NDR_OUT) {
3958                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
3959         }
3960         return NDR_ERR_SUCCESS;
3961 }
3962
3963 static enum ndr_err_code ndr_pull_winbind_getpwent(struct ndr_pull *ndr, int flags, struct winbind_getpwent *r)
3964 {
3965         if (flags & NDR_IN) {
3966         }
3967         if (flags & NDR_OUT) {
3968                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
3969         }
3970         return NDR_ERR_SUCCESS;
3971 }
3972
3973 _PUBLIC_ void ndr_print_winbind_getpwent(struct ndr_print *ndr, const char *name, int flags, const struct winbind_getpwent *r)
3974 {
3975         ndr_print_struct(ndr, name, "winbind_getpwent");
3976         ndr->depth++;
3977         if (flags & NDR_SET_VALUES) {
3978                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3979         }
3980         if (flags & NDR_IN) {
3981                 ndr_print_struct(ndr, "in", "winbind_getpwent");
3982                 ndr->depth++;
3983                 ndr->depth--;
3984         }
3985         if (flags & NDR_OUT) {
3986                 ndr_print_struct(ndr, "out", "winbind_getpwent");
3987                 ndr->depth++;
3988                 ndr_print_winbind_status(ndr, "result", r->out.result);
3989                 ndr->depth--;
3990         }
3991         ndr->depth--;
3992 }
3993
3994 static enum ndr_err_code ndr_push_winbind_setgrent(struct ndr_push *ndr, int flags, const struct winbind_setgrent *r)
3995 {
3996         if (flags & NDR_IN) {
3997         }
3998         if (flags & NDR_OUT) {
3999                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
4000         }
4001         return NDR_ERR_SUCCESS;
4002 }
4003
4004 static enum ndr_err_code ndr_pull_winbind_setgrent(struct ndr_pull *ndr, int flags, struct winbind_setgrent *r)
4005 {
4006         if (flags & NDR_IN) {
4007         }
4008         if (flags & NDR_OUT) {
4009                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
4010         }
4011         return NDR_ERR_SUCCESS;
4012 }
4013
4014 _PUBLIC_ void ndr_print_winbind_setgrent(struct ndr_print *ndr, const char *name, int flags, const struct winbind_setgrent *r)
4015 {
4016         ndr_print_struct(ndr, name, "winbind_setgrent");
4017         ndr->depth++;
4018         if (flags & NDR_SET_VALUES) {
4019                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4020         }
4021         if (flags & NDR_IN) {
4022                 ndr_print_struct(ndr, "in", "winbind_setgrent");
4023                 ndr->depth++;
4024                 ndr->depth--;
4025         }
4026         if (flags & NDR_OUT) {
4027                 ndr_print_struct(ndr, "out", "winbind_setgrent");
4028                 ndr->depth++;
4029                 ndr_print_winbind_status(ndr, "result", r->out.result);
4030                 ndr->depth--;
4031         }
4032         ndr->depth--;
4033 }
4034
4035 static enum ndr_err_code ndr_push_winbind_endgrent(struct ndr_push *ndr, int flags, const struct winbind_endgrent *r)
4036 {
4037         if (flags & NDR_IN) {
4038         }
4039         if (flags & NDR_OUT) {
4040                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
4041         }
4042         return NDR_ERR_SUCCESS;
4043 }
4044
4045 static enum ndr_err_code ndr_pull_winbind_endgrent(struct ndr_pull *ndr, int flags, struct winbind_endgrent *r)
4046 {
4047         if (flags & NDR_IN) {
4048         }
4049         if (flags & NDR_OUT) {
4050                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
4051         }
4052         return NDR_ERR_SUCCESS;
4053 }
4054
4055 _PUBLIC_ void ndr_print_winbind_endgrent(struct ndr_print *ndr, const char *name, int flags, const struct winbind_endgrent *r)
4056 {
4057         ndr_print_struct(ndr, name, "winbind_endgrent");
4058         ndr->depth++;
4059         if (flags & NDR_SET_VALUES) {
4060                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4061         }
4062         if (flags & NDR_IN) {
4063                 ndr_print_struct(ndr, "in", "winbind_endgrent");
4064                 ndr->depth++;
4065                 ndr->depth--;
4066         }
4067         if (flags & NDR_OUT) {
4068                 ndr_print_struct(ndr, "out", "winbind_endgrent");
4069                 ndr->depth++;
4070                 ndr_print_winbind_status(ndr, "result", r->out.result);
4071                 ndr->depth--;
4072         }
4073         ndr->depth--;
4074 }
4075
4076 static enum ndr_err_code ndr_push_winbind_getgrent(struct ndr_push *ndr, int flags, const struct winbind_getgrent *r)
4077 {
4078         if (flags & NDR_IN) {
4079         }
4080         if (flags & NDR_OUT) {
4081                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
4082         }
4083         return NDR_ERR_SUCCESS;
4084 }
4085
4086 static enum ndr_err_code ndr_pull_winbind_getgrent(struct ndr_pull *ndr, int flags, struct winbind_getgrent *r)
4087 {
4088         if (flags & NDR_IN) {
4089         }
4090         if (flags & NDR_OUT) {
4091                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
4092         }
4093         return NDR_ERR_SUCCESS;
4094 }
4095
4096 _PUBLIC_ void ndr_print_winbind_getgrent(struct ndr_print *ndr, const char *name, int flags, const struct winbind_getgrent *r)
4097 {
4098         ndr_print_struct(ndr, name, "winbind_getgrent");
4099         ndr->depth++;
4100         if (flags & NDR_SET_VALUES) {
4101                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4102         }
4103         if (flags & NDR_IN) {
4104                 ndr_print_struct(ndr, "in", "winbind_getgrent");
4105                 ndr->depth++;
4106                 ndr->depth--;
4107         }
4108         if (flags & NDR_OUT) {
4109                 ndr_print_struct(ndr, "out", "winbind_getgrent");
4110                 ndr->depth++;
4111                 ndr_print_winbind_status(ndr, "result", r->out.result);
4112                 ndr->depth--;
4113         }
4114         ndr->depth--;
4115 }
4116
4117 static enum ndr_err_code ndr_push_winbind_auth(struct ndr_push *ndr, int flags, const struct winbind_auth *r)
4118 {
4119         if (flags & NDR_IN) {
4120                 if (r->in.level == NULL) {
4121                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4122                 }
4123                 NDR_CHECK(ndr_push_winbind_auth_level(ndr, NDR_SCALARS, *r->in.level));
4124                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, *r->in.level));
4125                 NDR_CHECK(ndr_push_winbind_auth_req(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
4126         }
4127         if (flags & NDR_OUT) {
4128                 if (r->out.rep == NULL) {
4129                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4130                 }
4131                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.rep, *r->in.level));
4132                 NDR_CHECK(ndr_push_winbind_auth_rep(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rep));
4133                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
4134         }
4135         return NDR_ERR_SUCCESS;
4136 }
4137
4138 static enum ndr_err_code ndr_pull_winbind_auth(struct ndr_pull *ndr, int flags, struct winbind_auth *r)
4139 {
4140         TALLOC_CTX *_mem_save_level_0;
4141         TALLOC_CTX *_mem_save_rep_0;
4142         if (flags & NDR_IN) {
4143                 ZERO_STRUCT(r->out);
4144
4145                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4146                         NDR_PULL_ALLOC(ndr, r->in.level);
4147                 }
4148                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
4149                 NDR_PULL_SET_MEM_CTX(ndr, r->in.level, LIBNDR_FLAG_REF_ALLOC);
4150                 NDR_CHECK(ndr_pull_winbind_auth_level(ndr, NDR_SCALARS, r->in.level));
4151                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
4152                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, *r->in.level));
4153                 NDR_CHECK(ndr_pull_winbind_auth_req(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
4154                 NDR_PULL_ALLOC(ndr, r->out.rep);
4155                 ZERO_STRUCTP(r->out.rep);
4156         }
4157         if (flags & NDR_OUT) {
4158                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4159                         NDR_PULL_ALLOC(ndr, r->out.rep);
4160                 }
4161                 _mem_save_rep_0 = NDR_PULL_GET_MEM_CTX(ndr);
4162                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rep, LIBNDR_FLAG_REF_ALLOC);
4163                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.rep, *r->in.level));
4164                 NDR_CHECK(ndr_pull_winbind_auth_rep(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rep));
4165                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rep_0, LIBNDR_FLAG_REF_ALLOC);
4166                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
4167         }
4168         return NDR_ERR_SUCCESS;
4169 }
4170
4171 _PUBLIC_ void ndr_print_winbind_auth(struct ndr_print *ndr, const char *name, int flags, const struct winbind_auth *r)
4172 {
4173         ndr_print_struct(ndr, name, "winbind_auth");
4174         ndr->depth++;
4175         if (flags & NDR_SET_VALUES) {
4176                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4177         }
4178         if (flags & NDR_IN) {
4179                 ndr_print_struct(ndr, "in", "winbind_auth");
4180                 ndr->depth++;
4181                 ndr_print_ptr(ndr, "level", r->in.level);
4182                 ndr->depth++;
4183                 ndr_print_winbind_auth_level(ndr, "level", *r->in.level);
4184                 ndr->depth--;
4185                 ndr_print_set_switch_value(ndr, &r->in.req, *r->in.level);
4186                 ndr_print_winbind_auth_req(ndr, "req", &r->in.req);
4187                 ndr->depth--;
4188         }
4189         if (flags & NDR_OUT) {
4190                 ndr_print_struct(ndr, "out", "winbind_auth");
4191                 ndr->depth++;
4192                 ndr_print_ptr(ndr, "rep", r->out.rep);
4193                 ndr->depth++;
4194                 ndr_print_set_switch_value(ndr, r->out.rep, *r->in.level);
4195                 ndr_print_winbind_auth_rep(ndr, "rep", r->out.rep);
4196                 ndr->depth--;
4197                 ndr_print_winbind_status(ndr, "result", r->out.result);
4198                 ndr->depth--;
4199         }
4200         ndr->depth--;
4201 }
4202
4203 static enum ndr_err_code ndr_push_winbind_list_users(struct ndr_push *ndr, int flags, const struct winbind_list_users *r)
4204 {
4205         if (flags & NDR_IN) {
4206         }
4207         if (flags & NDR_OUT) {
4208                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
4209         }
4210         return NDR_ERR_SUCCESS;
4211 }
4212
4213 static enum ndr_err_code ndr_pull_winbind_list_users(struct ndr_pull *ndr, int flags, struct winbind_list_users *r)
4214 {
4215         if (flags & NDR_IN) {
4216         }
4217         if (flags & NDR_OUT) {
4218                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
4219         }
4220         return NDR_ERR_SUCCESS;
4221 }
4222
4223 _PUBLIC_ void ndr_print_winbind_list_users(struct ndr_print *ndr, const char *name, int flags, const struct winbind_list_users *r)
4224 {
4225         ndr_print_struct(ndr, name, "winbind_list_users");
4226         ndr->depth++;
4227         if (flags & NDR_SET_VALUES) {
4228                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4229         }
4230         if (flags & NDR_IN) {
4231                 ndr_print_struct(ndr, "in", "winbind_list_users");
4232                 ndr->depth++;
4233                 ndr->depth--;
4234         }
4235         if (flags & NDR_OUT) {
4236                 ndr_print_struct(ndr, "out", "winbind_list_users");
4237                 ndr->depth++;
4238                 ndr_print_winbind_status(ndr, "result", r->out.result);
4239                 ndr->depth--;
4240         }
4241         ndr->depth--;
4242 }
4243
4244 static enum ndr_err_code ndr_push_winbind_list_groups(struct ndr_push *ndr, int flags, const struct winbind_list_groups *r)
4245 {
4246         if (flags & NDR_IN) {
4247         }
4248         if (flags & NDR_OUT) {
4249                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
4250         }
4251         return NDR_ERR_SUCCESS;
4252 }
4253
4254 static enum ndr_err_code ndr_pull_winbind_list_groups(struct ndr_pull *ndr, int flags, struct winbind_list_groups *r)
4255 {
4256         if (flags & NDR_IN) {
4257         }
4258         if (flags & NDR_OUT) {
4259                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
4260         }
4261         return NDR_ERR_SUCCESS;
4262 }
4263
4264 _PUBLIC_ void ndr_print_winbind_list_groups(struct ndr_print *ndr, const char *name, int flags, const struct winbind_list_groups *r)
4265 {
4266         ndr_print_struct(ndr, name, "winbind_list_groups");
4267         ndr->depth++;
4268         if (flags & NDR_SET_VALUES) {
4269                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4270         }
4271         if (flags & NDR_IN) {
4272                 ndr_print_struct(ndr, "in", "winbind_list_groups");
4273                 ndr->depth++;
4274                 ndr->depth--;
4275         }
4276         if (flags & NDR_OUT) {
4277                 ndr_print_struct(ndr, "out", "winbind_list_groups");
4278                 ndr->depth++;
4279                 ndr_print_winbind_status(ndr, "result", r->out.result);
4280                 ndr->depth--;
4281         }
4282         ndr->depth--;
4283 }
4284
4285 static enum ndr_err_code ndr_push_winbind_trust(struct ndr_push *ndr, int flags, const struct winbind_trust *r)
4286 {
4287         if (flags & NDR_IN) {
4288                 if (r->in.level == NULL) {
4289                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4290                 }
4291                 NDR_CHECK(ndr_push_winbind_trust_level(ndr, NDR_SCALARS, *r->in.level));
4292                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, *r->in.level));
4293                 NDR_CHECK(ndr_push_winbind_trust_req(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
4294         }
4295         if (flags & NDR_OUT) {
4296                 if (r->out.rep == NULL) {
4297                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4298                 }
4299                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.rep, *r->in.level));
4300                 NDR_CHECK(ndr_push_winbind_trust_rep(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rep));
4301                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
4302         }
4303         return NDR_ERR_SUCCESS;
4304 }
4305
4306 static enum ndr_err_code ndr_pull_winbind_trust(struct ndr_pull *ndr, int flags, struct winbind_trust *r)
4307 {
4308         TALLOC_CTX *_mem_save_level_0;
4309         TALLOC_CTX *_mem_save_rep_0;
4310         if (flags & NDR_IN) {
4311                 ZERO_STRUCT(r->out);
4312
4313                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4314                         NDR_PULL_ALLOC(ndr, r->in.level);
4315                 }
4316                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
4317                 NDR_PULL_SET_MEM_CTX(ndr, r->in.level, LIBNDR_FLAG_REF_ALLOC);
4318                 NDR_CHECK(ndr_pull_winbind_trust_level(ndr, NDR_SCALARS, r->in.level));
4319                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
4320                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, *r->in.level));
4321                 NDR_CHECK(ndr_pull_winbind_trust_req(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
4322                 NDR_PULL_ALLOC(ndr, r->out.rep);
4323                 ZERO_STRUCTP(r->out.rep);
4324         }
4325         if (flags & NDR_OUT) {
4326                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4327                         NDR_PULL_ALLOC(ndr, r->out.rep);
4328                 }
4329                 _mem_save_rep_0 = NDR_PULL_GET_MEM_CTX(ndr);
4330                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rep, LIBNDR_FLAG_REF_ALLOC);
4331                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.rep, *r->in.level));
4332                 NDR_CHECK(ndr_pull_winbind_trust_rep(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rep));
4333                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rep_0, LIBNDR_FLAG_REF_ALLOC);
4334                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
4335         }
4336         return NDR_ERR_SUCCESS;
4337 }
4338
4339 _PUBLIC_ void ndr_print_winbind_trust(struct ndr_print *ndr, const char *name, int flags, const struct winbind_trust *r)
4340 {
4341         ndr_print_struct(ndr, name, "winbind_trust");
4342         ndr->depth++;
4343         if (flags & NDR_SET_VALUES) {
4344                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4345         }
4346         if (flags & NDR_IN) {
4347                 ndr_print_struct(ndr, "in", "winbind_trust");
4348                 ndr->depth++;
4349                 ndr_print_ptr(ndr, "level", r->in.level);
4350                 ndr->depth++;
4351                 ndr_print_winbind_trust_level(ndr, "level", *r->in.level);
4352                 ndr->depth--;
4353                 ndr_print_set_switch_value(ndr, &r->in.req, *r->in.level);
4354                 ndr_print_winbind_trust_req(ndr, "req", &r->in.req);
4355                 ndr->depth--;
4356         }
4357         if (flags & NDR_OUT) {
4358                 ndr_print_struct(ndr, "out", "winbind_trust");
4359                 ndr->depth++;
4360                 ndr_print_ptr(ndr, "rep", r->out.rep);
4361                 ndr->depth++;
4362                 ndr_print_set_switch_value(ndr, r->out.rep, *r->in.level);
4363                 ndr_print_winbind_trust_rep(ndr, "rep", r->out.rep);
4364                 ndr->depth--;
4365                 ndr_print_winbind_status(ndr, "result", r->out.result);
4366                 ndr->depth--;
4367         }
4368         ndr->depth--;
4369 }
4370
4371 static enum ndr_err_code ndr_push_winbind_lookup(struct ndr_push *ndr, int flags, const struct winbind_lookup *r)
4372 {
4373         if (flags & NDR_IN) {
4374                 if (r->in.level == NULL) {
4375                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4376                 }
4377                 NDR_CHECK(ndr_push_winbind_lookup_level(ndr, NDR_SCALARS, *r->in.level));
4378                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, *r->in.level));
4379                 NDR_CHECK(ndr_push_winbind_lookup_req(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
4380         }
4381         if (flags & NDR_OUT) {
4382                 if (r->out.rep == NULL) {
4383                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4384                 }
4385                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.rep, *r->in.level));
4386                 NDR_CHECK(ndr_push_winbind_lookup_rep(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rep));
4387                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
4388         }
4389         return NDR_ERR_SUCCESS;
4390 }
4391
4392 static enum ndr_err_code ndr_pull_winbind_lookup(struct ndr_pull *ndr, int flags, struct winbind_lookup *r)
4393 {
4394         TALLOC_CTX *_mem_save_level_0;
4395         TALLOC_CTX *_mem_save_rep_0;
4396         if (flags & NDR_IN) {
4397                 ZERO_STRUCT(r->out);
4398
4399                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4400                         NDR_PULL_ALLOC(ndr, r->in.level);
4401                 }
4402                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
4403                 NDR_PULL_SET_MEM_CTX(ndr, r->in.level, LIBNDR_FLAG_REF_ALLOC);
4404                 NDR_CHECK(ndr_pull_winbind_lookup_level(ndr, NDR_SCALARS, r->in.level));
4405                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
4406                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, *r->in.level));
4407                 NDR_CHECK(ndr_pull_winbind_lookup_req(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
4408                 NDR_PULL_ALLOC(ndr, r->out.rep);
4409                 ZERO_STRUCTP(r->out.rep);
4410         }
4411         if (flags & NDR_OUT) {
4412                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4413                         NDR_PULL_ALLOC(ndr, r->out.rep);
4414                 }
4415                 _mem_save_rep_0 = NDR_PULL_GET_MEM_CTX(ndr);
4416                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rep, LIBNDR_FLAG_REF_ALLOC);
4417                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.rep, *r->in.level));
4418                 NDR_CHECK(ndr_pull_winbind_lookup_rep(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rep));
4419                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rep_0, LIBNDR_FLAG_REF_ALLOC);
4420                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
4421         }
4422         return NDR_ERR_SUCCESS;
4423 }
4424
4425 _PUBLIC_ void ndr_print_winbind_lookup(struct ndr_print *ndr, const char *name, int flags, const struct winbind_lookup *r)
4426 {
4427         ndr_print_struct(ndr, name, "winbind_lookup");
4428         ndr->depth++;
4429         if (flags & NDR_SET_VALUES) {
4430                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4431         }
4432         if (flags & NDR_IN) {
4433                 ndr_print_struct(ndr, "in", "winbind_lookup");
4434                 ndr->depth++;
4435                 ndr_print_ptr(ndr, "level", r->in.level);
4436                 ndr->depth++;
4437                 ndr_print_winbind_lookup_level(ndr, "level", *r->in.level);
4438                 ndr->depth--;
4439                 ndr_print_set_switch_value(ndr, &r->in.req, *r->in.level);
4440                 ndr_print_winbind_lookup_req(ndr, "req", &r->in.req);
4441                 ndr->depth--;
4442         }
4443         if (flags & NDR_OUT) {
4444                 ndr_print_struct(ndr, "out", "winbind_lookup");
4445                 ndr->depth++;
4446                 ndr_print_ptr(ndr, "rep", r->out.rep);
4447                 ndr->depth++;
4448                 ndr_print_set_switch_value(ndr, r->out.rep, *r->in.level);
4449                 ndr_print_winbind_lookup_rep(ndr, "rep", r->out.rep);
4450                 ndr->depth--;
4451                 ndr_print_winbind_status(ndr, "result", r->out.result);
4452                 ndr->depth--;
4453         }
4454         ndr->depth--;
4455 }
4456
4457 static enum ndr_err_code ndr_push_winbind_get_idmap(struct ndr_push *ndr, int flags, const struct winbind_get_idmap *r)
4458 {
4459         if (flags & NDR_IN) {
4460                 if (r->in.level == NULL) {
4461                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4462                 }
4463                 NDR_CHECK(ndr_push_winbind_get_idmap_level(ndr, NDR_SCALARS, *r->in.level));
4464                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, *r->in.level));
4465                 NDR_CHECK(ndr_push_winbind_get_idmap_req(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
4466         }
4467         if (flags & NDR_OUT) {
4468                 if (r->out.level == NULL) {
4469                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4470                 }
4471                 NDR_CHECK(ndr_push_winbind_get_idmap_level(ndr, NDR_SCALARS, *r->out.level));
4472                 if (r->out.rep == NULL) {
4473                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4474                 }
4475                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.rep, *r->out.level));
4476                 NDR_CHECK(ndr_push_winbind_get_idmap_rep(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rep));
4477                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
4478         }
4479         return NDR_ERR_SUCCESS;
4480 }
4481
4482 static enum ndr_err_code ndr_pull_winbind_get_idmap(struct ndr_pull *ndr, int flags, struct winbind_get_idmap *r)
4483 {
4484         TALLOC_CTX *_mem_save_level_0;
4485         TALLOC_CTX *_mem_save_rep_0;
4486         if (flags & NDR_IN) {
4487                 ZERO_STRUCT(r->out);
4488
4489                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4490                         NDR_PULL_ALLOC(ndr, r->in.level);
4491                 }
4492                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
4493                 NDR_PULL_SET_MEM_CTX(ndr, r->in.level, LIBNDR_FLAG_REF_ALLOC);
4494                 NDR_CHECK(ndr_pull_winbind_get_idmap_level(ndr, NDR_SCALARS, r->in.level));
4495                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
4496                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, *r->in.level));
4497                 NDR_CHECK(ndr_pull_winbind_get_idmap_req(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
4498                 NDR_PULL_ALLOC(ndr, r->out.level);
4499                 *r->out.level = *r->in.level;
4500                 NDR_PULL_ALLOC(ndr, r->out.rep);
4501                 ZERO_STRUCTP(r->out.rep);
4502         }
4503         if (flags & NDR_OUT) {
4504                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4505                         NDR_PULL_ALLOC(ndr, r->out.level);
4506                 }
4507                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
4508                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level, LIBNDR_FLAG_REF_ALLOC);
4509                 NDR_CHECK(ndr_pull_winbind_get_idmap_level(ndr, NDR_SCALARS, r->out.level));
4510                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
4511                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4512                         NDR_PULL_ALLOC(ndr, r->out.rep);
4513                 }
4514                 _mem_save_rep_0 = NDR_PULL_GET_MEM_CTX(ndr);
4515                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rep, LIBNDR_FLAG_REF_ALLOC);
4516                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.rep, *r->out.level));
4517                 NDR_CHECK(ndr_pull_winbind_get_idmap_rep(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rep));
4518                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rep_0, LIBNDR_FLAG_REF_ALLOC);
4519                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
4520         }
4521         return NDR_ERR_SUCCESS;
4522 }
4523
4524 _PUBLIC_ void ndr_print_winbind_get_idmap(struct ndr_print *ndr, const char *name, int flags, const struct winbind_get_idmap *r)
4525 {
4526         ndr_print_struct(ndr, name, "winbind_get_idmap");
4527         ndr->depth++;
4528         if (flags & NDR_SET_VALUES) {
4529                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4530         }
4531         if (flags & NDR_IN) {
4532                 ndr_print_struct(ndr, "in", "winbind_get_idmap");
4533                 ndr->depth++;
4534                 ndr_print_ptr(ndr, "level", r->in.level);
4535                 ndr->depth++;
4536                 ndr_print_winbind_get_idmap_level(ndr, "level", *r->in.level);
4537                 ndr->depth--;
4538                 ndr_print_set_switch_value(ndr, &r->in.req, *r->in.level);
4539                 ndr_print_winbind_get_idmap_req(ndr, "req", &r->in.req);
4540                 ndr->depth--;
4541         }
4542         if (flags & NDR_OUT) {
4543                 ndr_print_struct(ndr, "out", "winbind_get_idmap");
4544                 ndr->depth++;
4545                 ndr_print_ptr(ndr, "level", r->out.level);
4546                 ndr->depth++;
4547                 ndr_print_winbind_get_idmap_level(ndr, "level", *r->out.level);
4548                 ndr->depth--;
4549                 ndr_print_ptr(ndr, "rep", r->out.rep);
4550                 ndr->depth++;
4551                 ndr_print_set_switch_value(ndr, r->out.rep, *r->out.level);
4552                 ndr_print_winbind_get_idmap_rep(ndr, "rep", r->out.rep);
4553                 ndr->depth--;
4554                 ndr_print_winbind_status(ndr, "result", r->out.result);
4555                 ndr->depth--;
4556         }
4557         ndr->depth--;
4558 }
4559
4560 static enum ndr_err_code ndr_push_winbind_set_idmap(struct ndr_push *ndr, int flags, const struct winbind_set_idmap *r)
4561 {
4562         if (flags & NDR_IN) {
4563                 if (r->in.level == NULL) {
4564                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4565                 }
4566                 NDR_CHECK(ndr_push_winbind_set_idmap_level(ndr, NDR_SCALARS, *r->in.level));
4567                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, *r->in.level));
4568                 NDR_CHECK(ndr_push_winbind_set_idmap_req(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
4569         }
4570         if (flags & NDR_OUT) {
4571                 if (r->out.level == NULL) {
4572                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4573                 }
4574                 NDR_CHECK(ndr_push_winbind_set_idmap_level(ndr, NDR_SCALARS, *r->out.level));
4575                 if (r->out.rep == NULL) {
4576                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4577                 }
4578                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.rep, *r->out.level));
4579                 NDR_CHECK(ndr_push_winbind_set_idmap_rep(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rep));
4580                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
4581         }
4582         return NDR_ERR_SUCCESS;
4583 }
4584
4585 static enum ndr_err_code ndr_pull_winbind_set_idmap(struct ndr_pull *ndr, int flags, struct winbind_set_idmap *r)
4586 {
4587         TALLOC_CTX *_mem_save_level_0;
4588         TALLOC_CTX *_mem_save_rep_0;
4589         if (flags & NDR_IN) {
4590                 ZERO_STRUCT(r->out);
4591
4592                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4593                         NDR_PULL_ALLOC(ndr, r->in.level);
4594                 }
4595                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
4596                 NDR_PULL_SET_MEM_CTX(ndr, r->in.level, LIBNDR_FLAG_REF_ALLOC);
4597                 NDR_CHECK(ndr_pull_winbind_set_idmap_level(ndr, NDR_SCALARS, r->in.level));
4598                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
4599                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, *r->in.level));
4600                 NDR_CHECK(ndr_pull_winbind_set_idmap_req(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
4601                 NDR_PULL_ALLOC(ndr, r->out.level);
4602                 *r->out.level = *r->in.level;
4603                 NDR_PULL_ALLOC(ndr, r->out.rep);
4604                 ZERO_STRUCTP(r->out.rep);
4605         }
4606         if (flags & NDR_OUT) {
4607                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4608                         NDR_PULL_ALLOC(ndr, r->out.level);
4609                 }
4610                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
4611                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level, LIBNDR_FLAG_REF_ALLOC);
4612                 NDR_CHECK(ndr_pull_winbind_set_idmap_level(ndr, NDR_SCALARS, r->out.level));
4613                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
4614                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4615                         NDR_PULL_ALLOC(ndr, r->out.rep);
4616                 }
4617                 _mem_save_rep_0 = NDR_PULL_GET_MEM_CTX(ndr);
4618                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rep, LIBNDR_FLAG_REF_ALLOC);
4619                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.rep, *r->out.level));
4620                 NDR_CHECK(ndr_pull_winbind_set_idmap_rep(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rep));
4621                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rep_0, LIBNDR_FLAG_REF_ALLOC);
4622                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
4623         }
4624         return NDR_ERR_SUCCESS;
4625 }
4626
4627 _PUBLIC_ void ndr_print_winbind_set_idmap(struct ndr_print *ndr, const char *name, int flags, const struct winbind_set_idmap *r)
4628 {
4629         ndr_print_struct(ndr, name, "winbind_set_idmap");
4630         ndr->depth++;
4631         if (flags & NDR_SET_VALUES) {
4632                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4633         }
4634         if (flags & NDR_IN) {
4635                 ndr_print_struct(ndr, "in", "winbind_set_idmap");
4636                 ndr->depth++;
4637                 ndr_print_ptr(ndr, "level", r->in.level);
4638                 ndr->depth++;
4639                 ndr_print_winbind_set_idmap_level(ndr, "level", *r->in.level);
4640                 ndr->depth--;
4641                 ndr_print_set_switch_value(ndr, &r->in.req, *r->in.level);
4642                 ndr_print_winbind_set_idmap_req(ndr, "req", &r->in.req);
4643                 ndr->depth--;
4644         }
4645         if (flags & NDR_OUT) {
4646                 ndr_print_struct(ndr, "out", "winbind_set_idmap");
4647                 ndr->depth++;
4648                 ndr_print_ptr(ndr, "level", r->out.level);
4649                 ndr->depth++;
4650                 ndr_print_winbind_set_idmap_level(ndr, "level", *r->out.level);
4651                 ndr->depth--;
4652                 ndr_print_ptr(ndr, "rep", r->out.rep);
4653                 ndr->depth++;
4654                 ndr_print_set_switch_value(ndr, r->out.rep, *r->out.level);
4655                 ndr_print_winbind_set_idmap_rep(ndr, "rep", r->out.rep);
4656                 ndr->depth--;
4657                 ndr_print_winbind_status(ndr, "result", r->out.result);
4658                 ndr->depth--;
4659         }
4660         ndr->depth--;
4661 }
4662
4663 static enum ndr_err_code ndr_push_winbind_info_fixname(struct ndr_push *ndr, int flags, const struct winbind_info_fixname *r)
4664 {
4665         if (flags & NDR_IN) {
4666         }
4667         if (flags & NDR_OUT) {
4668                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
4669         }
4670         return NDR_ERR_SUCCESS;
4671 }
4672
4673 static enum ndr_err_code ndr_pull_winbind_info_fixname(struct ndr_pull *ndr, int flags, struct winbind_info_fixname *r)
4674 {
4675         if (flags & NDR_IN) {
4676         }
4677         if (flags & NDR_OUT) {
4678                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
4679         }
4680         return NDR_ERR_SUCCESS;
4681 }
4682
4683 _PUBLIC_ void ndr_print_winbind_info_fixname(struct ndr_print *ndr, const char *name, int flags, const struct winbind_info_fixname *r)
4684 {
4685         ndr_print_struct(ndr, name, "winbind_info_fixname");
4686         ndr->depth++;
4687         if (flags & NDR_SET_VALUES) {
4688                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4689         }
4690         if (flags & NDR_IN) {
4691                 ndr_print_struct(ndr, "in", "winbind_info_fixname");
4692                 ndr->depth++;
4693                 ndr->depth--;
4694         }
4695         if (flags & NDR_OUT) {
4696                 ndr_print_struct(ndr, "out", "winbind_info_fixname");
4697                 ndr->depth++;
4698                 ndr_print_winbind_status(ndr, "result", r->out.result);
4699                 ndr->depth--;
4700         }
4701         ndr->depth--;
4702 }
4703
4704 static enum ndr_err_code ndr_push_winbind_domain_name(struct ndr_push *ndr, int flags, const struct winbind_domain_name *r)
4705 {
4706         if (flags & NDR_IN) {
4707         }
4708         if (flags & NDR_OUT) {
4709                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
4710         }
4711         return NDR_ERR_SUCCESS;
4712 }
4713
4714 static enum ndr_err_code ndr_pull_winbind_domain_name(struct ndr_pull *ndr, int flags, struct winbind_domain_name *r)
4715 {
4716         if (flags & NDR_IN) {
4717         }
4718         if (flags & NDR_OUT) {
4719                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
4720         }
4721         return NDR_ERR_SUCCESS;
4722 }
4723
4724 _PUBLIC_ void ndr_print_winbind_domain_name(struct ndr_print *ndr, const char *name, int flags, const struct winbind_domain_name *r)
4725 {
4726         ndr_print_struct(ndr, name, "winbind_domain_name");
4727         ndr->depth++;
4728         if (flags & NDR_SET_VALUES) {
4729                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4730         }
4731         if (flags & NDR_IN) {
4732                 ndr_print_struct(ndr, "in", "winbind_domain_name");
4733                 ndr->depth++;
4734                 ndr->depth--;
4735         }
4736         if (flags & NDR_OUT) {
4737                 ndr_print_struct(ndr, "out", "winbind_domain_name");
4738                 ndr->depth++;
4739                 ndr_print_winbind_status(ndr, "result", r->out.result);
4740                 ndr->depth--;
4741         }
4742         ndr->depth--;
4743 }
4744
4745 static enum ndr_err_code ndr_push_winbind_get_domain_info(struct ndr_push *ndr, int flags, const struct winbind_get_domain_info *r)
4746 {
4747         if (flags & NDR_IN) {
4748                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF8)));
4749                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF8)));
4751                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.domain_name, ndr_charset_length(r->in.domain_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
4752                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dc_name));
4753                 if (r->in.dc_name) {
4754                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dc_name, CH_UTF8)));
4755                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4756                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dc_name, CH_UTF8)));
4757                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dc_name, ndr_charset_length(r->in.dc_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
4758                 }
4759                 if (r->in.level == NULL) {
4760                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4761                 }
4762                 NDR_CHECK(ndr_push_winbind_domain_info_level(ndr, NDR_SCALARS, *r->in.level));
4763         }
4764         if (flags & NDR_OUT) {
4765                 if (r->out.level == NULL) {
4766                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4767                 }
4768                 NDR_CHECK(ndr_push_winbind_domain_info_level(ndr, NDR_SCALARS, *r->out.level));
4769                 if (r->out.domain_info == NULL) {
4770                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4771                 }
4772                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.domain_info, *r->out.level));
4773                 NDR_CHECK(ndr_push_winbind_domain_info(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domain_info));
4774                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
4775         }
4776         return NDR_ERR_SUCCESS;
4777 }
4778
4779 static enum ndr_err_code ndr_pull_winbind_get_domain_info(struct ndr_pull *ndr, int flags, struct winbind_get_domain_info *r)
4780 {
4781         uint32_t _ptr_dc_name;
4782         TALLOC_CTX *_mem_save_dc_name_0;
4783         TALLOC_CTX *_mem_save_level_0;
4784         TALLOC_CTX *_mem_save_domain_info_0;
4785         if (flags & NDR_IN) {
4786                 ZERO_STRUCT(r->out);
4787
4788                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
4789                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
4790                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
4791                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.domain_name), ndr_get_array_length(ndr, &r->in.domain_name));
4792                 }
4793                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint8_t)));
4794                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.domain_name, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint8_t), CH_UTF8));
4795                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dc_name));
4796                 if (_ptr_dc_name) {
4797                         NDR_PULL_ALLOC(ndr, r->in.dc_name);
4798                 } else {
4799                         r->in.dc_name = NULL;
4800                 }
4801                 if (r->in.dc_name) {
4802                         _mem_save_dc_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4803                         NDR_PULL_SET_MEM_CTX(ndr, r->in.dc_name, 0);
4804                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dc_name));
4805                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dc_name));
4806                         if (ndr_get_array_length(ndr, &r->in.dc_name) > ndr_get_array_size(ndr, &r->in.dc_name)) {
4807                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.dc_name), ndr_get_array_length(ndr, &r->in.dc_name));
4808                         }
4809                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dc_name), sizeof(uint8_t)));
4810                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dc_name, ndr_get_array_length(ndr, &r->in.dc_name), sizeof(uint8_t), CH_UTF8));
4811                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dc_name_0, 0);
4812                 }
4813                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4814                         NDR_PULL_ALLOC(ndr, r->in.level);
4815                 }
4816                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
4817                 NDR_PULL_SET_MEM_CTX(ndr, r->in.level, LIBNDR_FLAG_REF_ALLOC);
4818                 NDR_CHECK(ndr_pull_winbind_domain_info_level(ndr, NDR_SCALARS, r->in.level));
4819                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
4820                 NDR_PULL_ALLOC(ndr, r->out.level);
4821                 *r->out.level = *r->in.level;
4822                 NDR_PULL_ALLOC(ndr, r->out.domain_info);
4823                 ZERO_STRUCTP(r->out.domain_info);
4824         }
4825         if (flags & NDR_OUT) {
4826                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4827                         NDR_PULL_ALLOC(ndr, r->out.level);
4828                 }
4829                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
4830                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level, LIBNDR_FLAG_REF_ALLOC);
4831                 NDR_CHECK(ndr_pull_winbind_domain_info_level(ndr, NDR_SCALARS, r->out.level));
4832                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
4833                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4834                         NDR_PULL_ALLOC(ndr, r->out.domain_info);
4835                 }
4836                 _mem_save_domain_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
4837                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domain_info, LIBNDR_FLAG_REF_ALLOC);
4838                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.domain_info, *r->out.level));
4839                 NDR_CHECK(ndr_pull_winbind_domain_info(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domain_info));
4840                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_info_0, LIBNDR_FLAG_REF_ALLOC);
4841                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
4842         }
4843         return NDR_ERR_SUCCESS;
4844 }
4845
4846 _PUBLIC_ void ndr_print_winbind_get_domain_info(struct ndr_print *ndr, const char *name, int flags, const struct winbind_get_domain_info *r)
4847 {
4848         ndr_print_struct(ndr, name, "winbind_get_domain_info");
4849         ndr->depth++;
4850         if (flags & NDR_SET_VALUES) {
4851                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4852         }
4853         if (flags & NDR_IN) {
4854                 ndr_print_struct(ndr, "in", "winbind_get_domain_info");
4855                 ndr->depth++;
4856                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
4857                 ndr_print_ptr(ndr, "dc_name", r->in.dc_name);
4858                 ndr->depth++;
4859                 if (r->in.dc_name) {
4860                         ndr_print_string(ndr, "dc_name", r->in.dc_name);
4861                 }
4862                 ndr->depth--;
4863                 ndr_print_ptr(ndr, "level", r->in.level);
4864                 ndr->depth++;
4865                 ndr_print_winbind_domain_info_level(ndr, "level", *r->in.level);
4866                 ndr->depth--;
4867                 ndr->depth--;
4868         }
4869         if (flags & NDR_OUT) {
4870                 ndr_print_struct(ndr, "out", "winbind_get_domain_info");
4871                 ndr->depth++;
4872                 ndr_print_ptr(ndr, "level", r->out.level);
4873                 ndr->depth++;
4874                 ndr_print_winbind_domain_info_level(ndr, "level", *r->out.level);
4875                 ndr->depth--;
4876                 ndr_print_ptr(ndr, "domain_info", r->out.domain_info);
4877                 ndr->depth++;
4878                 ndr_print_set_switch_value(ndr, r->out.domain_info, *r->out.level);
4879                 ndr_print_winbind_domain_info(ndr, "domain_info", r->out.domain_info);
4880                 ndr->depth--;
4881                 ndr_print_winbind_status(ndr, "result", r->out.result);
4882                 ndr->depth--;
4883         }
4884         ndr->depth--;
4885 }
4886
4887 static enum ndr_err_code ndr_push_winbind_get_dc_info(struct ndr_push *ndr, int flags, const struct winbind_get_dc_info *r)
4888 {
4889         if (flags & NDR_IN) {
4890                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF8)));
4891                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4892                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF8)));
4893                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.domain_name, ndr_charset_length(r->in.domain_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
4894                 if (r->in.level == NULL) {
4895                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4896                 }
4897                 NDR_CHECK(ndr_push_winbind_dc_info_level(ndr, NDR_SCALARS, *r->in.level));
4898                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.params, *r->in.level));
4899                 NDR_CHECK(ndr_push_winbind_dc_info_params(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.params));
4900         }
4901         if (flags & NDR_OUT) {
4902                 if (r->out.level == NULL) {
4903                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4904                 }
4905                 NDR_CHECK(ndr_push_winbind_dc_info_level(ndr, NDR_SCALARS, *r->out.level));
4906                 if (r->out.dc_info == NULL) {
4907                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4908                 }
4909                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.dc_info, *r->out.level));
4910                 NDR_CHECK(ndr_push_winbind_dc_info(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.dc_info));
4911                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
4912         }
4913         return NDR_ERR_SUCCESS;
4914 }
4915
4916 static enum ndr_err_code ndr_pull_winbind_get_dc_info(struct ndr_pull *ndr, int flags, struct winbind_get_dc_info *r)
4917 {
4918         TALLOC_CTX *_mem_save_level_0;
4919         TALLOC_CTX *_mem_save_dc_info_0;
4920         if (flags & NDR_IN) {
4921                 ZERO_STRUCT(r->out);
4922
4923                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
4924                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
4925                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
4926                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.domain_name), ndr_get_array_length(ndr, &r->in.domain_name));
4927                 }
4928                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint8_t)));
4929                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.domain_name, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint8_t), CH_UTF8));
4930                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4931                         NDR_PULL_ALLOC(ndr, r->in.level);
4932                 }
4933                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
4934                 NDR_PULL_SET_MEM_CTX(ndr, r->in.level, LIBNDR_FLAG_REF_ALLOC);
4935                 NDR_CHECK(ndr_pull_winbind_dc_info_level(ndr, NDR_SCALARS, r->in.level));
4936                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
4937                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.params, *r->in.level));
4938                 NDR_CHECK(ndr_pull_winbind_dc_info_params(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.params));
4939                 NDR_PULL_ALLOC(ndr, r->out.level);
4940                 *r->out.level = *r->in.level;
4941                 NDR_PULL_ALLOC(ndr, r->out.dc_info);
4942                 ZERO_STRUCTP(r->out.dc_info);
4943         }
4944         if (flags & NDR_OUT) {
4945                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4946                         NDR_PULL_ALLOC(ndr, r->out.level);
4947                 }
4948                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
4949                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level, LIBNDR_FLAG_REF_ALLOC);
4950                 NDR_CHECK(ndr_pull_winbind_dc_info_level(ndr, NDR_SCALARS, r->out.level));
4951                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
4952                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4953                         NDR_PULL_ALLOC(ndr, r->out.dc_info);
4954                 }
4955                 _mem_save_dc_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
4956                 NDR_PULL_SET_MEM_CTX(ndr, r->out.dc_info, LIBNDR_FLAG_REF_ALLOC);
4957                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.dc_info, *r->out.level));
4958                 NDR_CHECK(ndr_pull_winbind_dc_info(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.dc_info));
4959                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dc_info_0, LIBNDR_FLAG_REF_ALLOC);
4960                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
4961         }
4962         return NDR_ERR_SUCCESS;
4963 }
4964
4965 _PUBLIC_ void ndr_print_winbind_get_dc_info(struct ndr_print *ndr, const char *name, int flags, const struct winbind_get_dc_info *r)
4966 {
4967         ndr_print_struct(ndr, name, "winbind_get_dc_info");
4968         ndr->depth++;
4969         if (flags & NDR_SET_VALUES) {
4970                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4971         }
4972         if (flags & NDR_IN) {
4973                 ndr_print_struct(ndr, "in", "winbind_get_dc_info");
4974                 ndr->depth++;
4975                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
4976                 ndr_print_ptr(ndr, "level", r->in.level);
4977                 ndr->depth++;
4978                 ndr_print_winbind_dc_info_level(ndr, "level", *r->in.level);
4979                 ndr->depth--;
4980                 ndr_print_set_switch_value(ndr, &r->in.params, *r->in.level);
4981                 ndr_print_winbind_dc_info_params(ndr, "params", &r->in.params);
4982                 ndr->depth--;
4983         }
4984         if (flags & NDR_OUT) {
4985                 ndr_print_struct(ndr, "out", "winbind_get_dc_info");
4986                 ndr->depth++;
4987                 ndr_print_ptr(ndr, "level", r->out.level);
4988                 ndr->depth++;
4989                 ndr_print_winbind_dc_info_level(ndr, "level", *r->out.level);
4990                 ndr->depth--;
4991                 ndr_print_ptr(ndr, "dc_info", r->out.dc_info);
4992                 ndr->depth++;
4993                 ndr_print_set_switch_value(ndr, r->out.dc_info, *r->out.level);
4994                 ndr_print_winbind_dc_info(ndr, "dc_info", r->out.dc_info);
4995                 ndr->depth--;
4996                 ndr_print_winbind_status(ndr, "result", r->out.result);
4997                 ndr->depth--;
4998         }
4999         ndr->depth--;
5000 }
5001
5002 static enum ndr_err_code ndr_push_winbind_wins_byip(struct ndr_push *ndr, int flags, const struct winbind_wins_byip *r)
5003 {
5004         if (flags & NDR_IN) {
5005         }
5006         if (flags & NDR_OUT) {
5007                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
5008         }
5009         return NDR_ERR_SUCCESS;
5010 }
5011
5012 static enum ndr_err_code ndr_pull_winbind_wins_byip(struct ndr_pull *ndr, int flags, struct winbind_wins_byip *r)
5013 {
5014         if (flags & NDR_IN) {
5015         }
5016         if (flags & NDR_OUT) {
5017                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
5018         }
5019         return NDR_ERR_SUCCESS;
5020 }
5021
5022 _PUBLIC_ void ndr_print_winbind_wins_byip(struct ndr_print *ndr, const char *name, int flags, const struct winbind_wins_byip *r)
5023 {
5024         ndr_print_struct(ndr, name, "winbind_wins_byip");
5025         ndr->depth++;
5026         if (flags & NDR_SET_VALUES) {
5027                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5028         }
5029         if (flags & NDR_IN) {
5030                 ndr_print_struct(ndr, "in", "winbind_wins_byip");
5031                 ndr->depth++;
5032                 ndr->depth--;
5033         }
5034         if (flags & NDR_OUT) {
5035                 ndr_print_struct(ndr, "out", "winbind_wins_byip");
5036                 ndr->depth++;
5037                 ndr_print_winbind_status(ndr, "result", r->out.result);
5038                 ndr->depth--;
5039         }
5040         ndr->depth--;
5041 }
5042
5043 static enum ndr_err_code ndr_push_winbind_wins_byname(struct ndr_push *ndr, int flags, const struct winbind_wins_byname *r)
5044 {
5045         if (flags & NDR_IN) {
5046         }
5047         if (flags & NDR_OUT) {
5048                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
5049         }
5050         return NDR_ERR_SUCCESS;
5051 }
5052
5053 static enum ndr_err_code ndr_pull_winbind_wins_byname(struct ndr_pull *ndr, int flags, struct winbind_wins_byname *r)
5054 {
5055         if (flags & NDR_IN) {
5056         }
5057         if (flags & NDR_OUT) {
5058                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
5059         }
5060         return NDR_ERR_SUCCESS;
5061 }
5062
5063 _PUBLIC_ void ndr_print_winbind_wins_byname(struct ndr_print *ndr, const char *name, int flags, const struct winbind_wins_byname *r)
5064 {
5065         ndr_print_struct(ndr, name, "winbind_wins_byname");
5066         ndr->depth++;
5067         if (flags & NDR_SET_VALUES) {
5068                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5069         }
5070         if (flags & NDR_IN) {
5071                 ndr_print_struct(ndr, "in", "winbind_wins_byname");
5072                 ndr->depth++;
5073                 ndr->depth--;
5074         }
5075         if (flags & NDR_OUT) {
5076                 ndr_print_struct(ndr, "out", "winbind_wins_byname");
5077                 ndr->depth++;
5078                 ndr_print_winbind_status(ndr, "result", r->out.result);
5079                 ndr->depth--;
5080         }
5081         ndr->depth--;
5082 }
5083
5084 static enum ndr_err_code ndr_push_winbind_getgrlist(struct ndr_push *ndr, int flags, const struct winbind_getgrlist *r)
5085 {
5086         if (flags & NDR_IN) {
5087         }
5088         if (flags & NDR_OUT) {
5089                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
5090         }
5091         return NDR_ERR_SUCCESS;
5092 }
5093
5094 static enum ndr_err_code ndr_pull_winbind_getgrlist(struct ndr_pull *ndr, int flags, struct winbind_getgrlist *r)
5095 {
5096         if (flags & NDR_IN) {
5097         }
5098         if (flags & NDR_OUT) {
5099                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
5100         }
5101         return NDR_ERR_SUCCESS;
5102 }
5103
5104 _PUBLIC_ void ndr_print_winbind_getgrlist(struct ndr_print *ndr, const char *name, int flags, const struct winbind_getgrlist *r)
5105 {
5106         ndr_print_struct(ndr, name, "winbind_getgrlist");
5107         ndr->depth++;
5108         if (flags & NDR_SET_VALUES) {
5109                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5110         }
5111         if (flags & NDR_IN) {
5112                 ndr_print_struct(ndr, "in", "winbind_getgrlist");
5113                 ndr->depth++;
5114                 ndr->depth--;
5115         }
5116         if (flags & NDR_OUT) {
5117                 ndr_print_struct(ndr, "out", "winbind_getgrlist");
5118                 ndr->depth++;
5119                 ndr_print_winbind_status(ndr, "result", r->out.result);
5120                 ndr->depth--;
5121         }
5122         ndr->depth--;
5123 }
5124
5125 static enum ndr_err_code ndr_push_winbind_netbios_name(struct ndr_push *ndr, int flags, const struct winbind_netbios_name *r)
5126 {
5127         if (flags & NDR_IN) {
5128         }
5129         if (flags & NDR_OUT) {
5130                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
5131         }
5132         return NDR_ERR_SUCCESS;
5133 }
5134
5135 static enum ndr_err_code ndr_pull_winbind_netbios_name(struct ndr_pull *ndr, int flags, struct winbind_netbios_name *r)
5136 {
5137         if (flags & NDR_IN) {
5138         }
5139         if (flags & NDR_OUT) {
5140                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
5141         }
5142         return NDR_ERR_SUCCESS;
5143 }
5144
5145 _PUBLIC_ void ndr_print_winbind_netbios_name(struct ndr_print *ndr, const char *name, int flags, const struct winbind_netbios_name *r)
5146 {
5147         ndr_print_struct(ndr, name, "winbind_netbios_name");
5148         ndr->depth++;
5149         if (flags & NDR_SET_VALUES) {
5150                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5151         }
5152         if (flags & NDR_IN) {
5153                 ndr_print_struct(ndr, "in", "winbind_netbios_name");
5154                 ndr->depth++;
5155                 ndr->depth--;
5156         }
5157         if (flags & NDR_OUT) {
5158                 ndr_print_struct(ndr, "out", "winbind_netbios_name");
5159                 ndr->depth++;
5160                 ndr_print_winbind_status(ndr, "result", r->out.result);
5161                 ndr->depth--;
5162         }
5163         ndr->depth--;
5164 }
5165
5166 static enum ndr_err_code ndr_push_winbind_getusersids(struct ndr_push *ndr, int flags, const struct winbind_getusersids *r)
5167 {
5168         if (flags & NDR_IN) {
5169         }
5170         if (flags & NDR_OUT) {
5171                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
5172         }
5173         return NDR_ERR_SUCCESS;
5174 }
5175
5176 static enum ndr_err_code ndr_pull_winbind_getusersids(struct ndr_pull *ndr, int flags, struct winbind_getusersids *r)
5177 {
5178         if (flags & NDR_IN) {
5179         }
5180         if (flags & NDR_OUT) {
5181                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
5182         }
5183         return NDR_ERR_SUCCESS;
5184 }
5185
5186 _PUBLIC_ void ndr_print_winbind_getusersids(struct ndr_print *ndr, const char *name, int flags, const struct winbind_getusersids *r)
5187 {
5188         ndr_print_struct(ndr, name, "winbind_getusersids");
5189         ndr->depth++;
5190         if (flags & NDR_SET_VALUES) {
5191                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5192         }
5193         if (flags & NDR_IN) {
5194                 ndr_print_struct(ndr, "in", "winbind_getusersids");
5195                 ndr->depth++;
5196                 ndr->depth--;
5197         }
5198         if (flags & NDR_OUT) {
5199                 ndr_print_struct(ndr, "out", "winbind_getusersids");
5200                 ndr->depth++;
5201                 ndr_print_winbind_status(ndr, "result", r->out.result);
5202                 ndr->depth--;
5203         }
5204         ndr->depth--;
5205 }
5206
5207 static enum ndr_err_code ndr_push_winbind_getuserdomgroups(struct ndr_push *ndr, int flags, const struct winbind_getuserdomgroups *r)
5208 {
5209         if (flags & NDR_IN) {
5210         }
5211         if (flags & NDR_OUT) {
5212                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
5213         }
5214         return NDR_ERR_SUCCESS;
5215 }
5216
5217 static enum ndr_err_code ndr_pull_winbind_getuserdomgroups(struct ndr_pull *ndr, int flags, struct winbind_getuserdomgroups *r)
5218 {
5219         if (flags & NDR_IN) {
5220         }
5221         if (flags & NDR_OUT) {
5222                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
5223         }
5224         return NDR_ERR_SUCCESS;
5225 }
5226
5227 _PUBLIC_ void ndr_print_winbind_getuserdomgroups(struct ndr_print *ndr, const char *name, int flags, const struct winbind_getuserdomgroups *r)
5228 {
5229         ndr_print_struct(ndr, name, "winbind_getuserdomgroups");
5230         ndr->depth++;
5231         if (flags & NDR_SET_VALUES) {
5232                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5233         }
5234         if (flags & NDR_IN) {
5235                 ndr_print_struct(ndr, "in", "winbind_getuserdomgroups");
5236                 ndr->depth++;
5237                 ndr->depth--;
5238         }
5239         if (flags & NDR_OUT) {
5240                 ndr_print_struct(ndr, "out", "winbind_getuserdomgroups");
5241                 ndr->depth++;
5242                 ndr_print_winbind_status(ndr, "result", r->out.result);
5243                 ndr->depth--;
5244         }
5245         ndr->depth--;
5246 }
5247
5248 static enum ndr_err_code ndr_push_winbind_dual_userinfo(struct ndr_push *ndr, int flags, const struct winbind_dual_userinfo *r)
5249 {
5250         if (flags & NDR_IN) {
5251         }
5252         if (flags & NDR_OUT) {
5253                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
5254         }
5255         return NDR_ERR_SUCCESS;
5256 }
5257
5258 static enum ndr_err_code ndr_pull_winbind_dual_userinfo(struct ndr_pull *ndr, int flags, struct winbind_dual_userinfo *r)
5259 {
5260         if (flags & NDR_IN) {
5261         }
5262         if (flags & NDR_OUT) {
5263                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
5264         }
5265         return NDR_ERR_SUCCESS;
5266 }
5267
5268 _PUBLIC_ void ndr_print_winbind_dual_userinfo(struct ndr_print *ndr, const char *name, int flags, const struct winbind_dual_userinfo *r)
5269 {
5270         ndr_print_struct(ndr, name, "winbind_dual_userinfo");
5271         ndr->depth++;
5272         if (flags & NDR_SET_VALUES) {
5273                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5274         }
5275         if (flags & NDR_IN) {
5276                 ndr_print_struct(ndr, "in", "winbind_dual_userinfo");
5277                 ndr->depth++;
5278                 ndr->depth--;
5279         }
5280         if (flags & NDR_OUT) {
5281                 ndr_print_struct(ndr, "out", "winbind_dual_userinfo");
5282                 ndr->depth++;
5283                 ndr_print_winbind_status(ndr, "result", r->out.result);
5284                 ndr->depth--;
5285         }
5286         ndr->depth--;
5287 }
5288
5289 static enum ndr_err_code ndr_push_winbind_dual_getsidaliases(struct ndr_push *ndr, int flags, const struct winbind_dual_getsidaliases *r)
5290 {
5291         if (flags & NDR_IN) {
5292         }
5293         if (flags & NDR_OUT) {
5294                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
5295         }
5296         return NDR_ERR_SUCCESS;
5297 }
5298
5299 static enum ndr_err_code ndr_pull_winbind_dual_getsidaliases(struct ndr_pull *ndr, int flags, struct winbind_dual_getsidaliases *r)
5300 {
5301         if (flags & NDR_IN) {
5302         }
5303         if (flags & NDR_OUT) {
5304                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
5305         }
5306         return NDR_ERR_SUCCESS;
5307 }
5308
5309 _PUBLIC_ void ndr_print_winbind_dual_getsidaliases(struct ndr_print *ndr, const char *name, int flags, const struct winbind_dual_getsidaliases *r)
5310 {
5311         ndr_print_struct(ndr, name, "winbind_dual_getsidaliases");
5312         ndr->depth++;
5313         if (flags & NDR_SET_VALUES) {
5314                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5315         }
5316         if (flags & NDR_IN) {
5317                 ndr_print_struct(ndr, "in", "winbind_dual_getsidaliases");
5318                 ndr->depth++;
5319                 ndr->depth--;
5320         }
5321         if (flags & NDR_OUT) {
5322                 ndr_print_struct(ndr, "out", "winbind_dual_getsidaliases");
5323                 ndr->depth++;
5324                 ndr_print_winbind_status(ndr, "result", r->out.result);
5325                 ndr->depth--;
5326         }
5327         ndr->depth--;
5328 }
5329
5330 static enum ndr_err_code ndr_push_winbind_ccache_ntlmauth(struct ndr_push *ndr, int flags, const struct winbind_ccache_ntlmauth *r)
5331 {
5332         if (flags & NDR_IN) {
5333         }
5334         if (flags & NDR_OUT) {
5335                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
5336         }
5337         return NDR_ERR_SUCCESS;
5338 }
5339
5340 static enum ndr_err_code ndr_pull_winbind_ccache_ntlmauth(struct ndr_pull *ndr, int flags, struct winbind_ccache_ntlmauth *r)
5341 {
5342         if (flags & NDR_IN) {
5343         }
5344         if (flags & NDR_OUT) {
5345                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
5346         }
5347         return NDR_ERR_SUCCESS;
5348 }
5349
5350 _PUBLIC_ void ndr_print_winbind_ccache_ntlmauth(struct ndr_print *ndr, const char *name, int flags, const struct winbind_ccache_ntlmauth *r)
5351 {
5352         ndr_print_struct(ndr, name, "winbind_ccache_ntlmauth");
5353         ndr->depth++;
5354         if (flags & NDR_SET_VALUES) {
5355                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5356         }
5357         if (flags & NDR_IN) {
5358                 ndr_print_struct(ndr, "in", "winbind_ccache_ntlmauth");
5359                 ndr->depth++;
5360                 ndr->depth--;
5361         }
5362         if (flags & NDR_OUT) {
5363                 ndr_print_struct(ndr, "out", "winbind_ccache_ntlmauth");
5364                 ndr->depth++;
5365                 ndr_print_winbind_status(ndr, "result", r->out.result);
5366                 ndr->depth--;
5367         }
5368         ndr->depth--;
5369 }
5370
5371 static const struct ndr_interface_call winbind_protocol_calls[] = {
5372         {
5373                 "winbind_ping",
5374                 sizeof(struct winbind_ping),
5375                 (ndr_push_flags_fn_t) ndr_push_winbind_ping,
5376                 (ndr_pull_flags_fn_t) ndr_pull_winbind_ping,
5377                 (ndr_print_function_t) ndr_print_winbind_ping,
5378                 false,
5379         },
5380         {
5381                 "winbind_interface_details",
5382                 sizeof(struct winbind_interface_details),
5383                 (ndr_push_flags_fn_t) ndr_push_winbind_interface_details,
5384                 (ndr_pull_flags_fn_t) ndr_pull_winbind_interface_details,
5385                 (ndr_print_function_t) ndr_print_winbind_interface_details,
5386                 false,
5387         },
5388         {
5389                 "winbind_getpwnam",
5390                 sizeof(struct winbind_getpwnam),
5391                 (ndr_push_flags_fn_t) ndr_push_winbind_getpwnam,
5392                 (ndr_pull_flags_fn_t) ndr_pull_winbind_getpwnam,
5393                 (ndr_print_function_t) ndr_print_winbind_getpwnam,
5394                 false,
5395         },
5396         {
5397                 "winbind_getpwuid",
5398                 sizeof(struct winbind_getpwuid),
5399                 (ndr_push_flags_fn_t) ndr_push_winbind_getpwuid,
5400                 (ndr_pull_flags_fn_t) ndr_pull_winbind_getpwuid,
5401                 (ndr_print_function_t) ndr_print_winbind_getpwuid,
5402                 false,
5403         },
5404         {
5405                 "winbind_getgrnam",
5406                 sizeof(struct winbind_getgrnam),
5407                 (ndr_push_flags_fn_t) ndr_push_winbind_getgrnam,
5408                 (ndr_pull_flags_fn_t) ndr_pull_winbind_getgrnam,
5409                 (ndr_print_function_t) ndr_print_winbind_getgrnam,
5410                 false,
5411         },
5412         {
5413                 "winbind_getgrgid",
5414                 sizeof(struct winbind_getgrgid),
5415                 (ndr_push_flags_fn_t) ndr_push_winbind_getgrgid,
5416                 (ndr_pull_flags_fn_t) ndr_pull_winbind_getgrgid,
5417                 (ndr_print_function_t) ndr_print_winbind_getgrgid,
5418                 false,
5419         },
5420         {
5421                 "winbind_getgroups",
5422                 sizeof(struct winbind_getgroups),
5423                 (ndr_push_flags_fn_t) ndr_push_winbind_getgroups,
5424                 (ndr_pull_flags_fn_t) ndr_pull_winbind_getgroups,
5425                 (ndr_print_function_t) ndr_print_winbind_getgroups,
5426                 false,
5427         },
5428         {
5429                 "winbind_setpwent",
5430                 sizeof(struct winbind_setpwent),
5431                 (ndr_push_flags_fn_t) ndr_push_winbind_setpwent,
5432                 (ndr_pull_flags_fn_t) ndr_pull_winbind_setpwent,
5433                 (ndr_print_function_t) ndr_print_winbind_setpwent,
5434                 false,
5435         },
5436         {
5437                 "winbind_endpwent",
5438                 sizeof(struct winbind_endpwent),
5439                 (ndr_push_flags_fn_t) ndr_push_winbind_endpwent,
5440                 (ndr_pull_flags_fn_t) ndr_pull_winbind_endpwent,
5441                 (ndr_print_function_t) ndr_print_winbind_endpwent,
5442                 false,
5443         },
5444         {
5445                 "winbind_getpwent",
5446                 sizeof(struct winbind_getpwent),
5447                 (ndr_push_flags_fn_t) ndr_push_winbind_getpwent,
5448                 (ndr_pull_flags_fn_t) ndr_pull_winbind_getpwent,
5449                 (ndr_print_function_t) ndr_print_winbind_getpwent,
5450                 false,
5451         },
5452         {
5453                 "winbind_setgrent",
5454                 sizeof(struct winbind_setgrent),
5455                 (ndr_push_flags_fn_t) ndr_push_winbind_setgrent,
5456                 (ndr_pull_flags_fn_t) ndr_pull_winbind_setgrent,
5457                 (ndr_print_function_t) ndr_print_winbind_setgrent,
5458                 false,
5459         },
5460         {
5461                 "winbind_endgrent",
5462                 sizeof(struct winbind_endgrent),
5463                 (ndr_push_flags_fn_t) ndr_push_winbind_endgrent,
5464                 (ndr_pull_flags_fn_t) ndr_pull_winbind_endgrent,
5465                 (ndr_print_function_t) ndr_print_winbind_endgrent,
5466                 false,
5467         },
5468         {
5469                 "winbind_getgrent",
5470                 sizeof(struct winbind_getgrent),
5471                 (ndr_push_flags_fn_t) ndr_push_winbind_getgrent,
5472                 (ndr_pull_flags_fn_t) ndr_pull_winbind_getgrent,
5473                 (ndr_print_function_t) ndr_print_winbind_getgrent,
5474                 false,
5475         },
5476         {
5477                 "winbind_auth",
5478                 sizeof(struct winbind_auth),
5479                 (ndr_push_flags_fn_t) ndr_push_winbind_auth,
5480                 (ndr_pull_flags_fn_t) ndr_pull_winbind_auth,
5481                 (ndr_print_function_t) ndr_print_winbind_auth,
5482                 false,
5483         },
5484         {
5485                 "winbind_list_users",
5486                 sizeof(struct winbind_list_users),
5487                 (ndr_push_flags_fn_t) ndr_push_winbind_list_users,
5488                 (ndr_pull_flags_fn_t) ndr_pull_winbind_list_users,
5489                 (ndr_print_function_t) ndr_print_winbind_list_users,
5490                 false,
5491         },
5492         {
5493                 "winbind_list_groups",
5494                 sizeof(struct winbind_list_groups),
5495                 (ndr_push_flags_fn_t) ndr_push_winbind_list_groups,
5496                 (ndr_pull_flags_fn_t) ndr_pull_winbind_list_groups,
5497                 (ndr_print_function_t) ndr_print_winbind_list_groups,
5498                 false,
5499         },
5500         {
5501                 "winbind_trust",
5502                 sizeof(struct winbind_trust),
5503                 (ndr_push_flags_fn_t) ndr_push_winbind_trust,
5504                 (ndr_pull_flags_fn_t) ndr_pull_winbind_trust,
5505                 (ndr_print_function_t) ndr_print_winbind_trust,
5506                 false,
5507         },
5508         {
5509                 "winbind_lookup",
5510                 sizeof(struct winbind_lookup),
5511                 (ndr_push_flags_fn_t) ndr_push_winbind_lookup,
5512                 (ndr_pull_flags_fn_t) ndr_pull_winbind_lookup,
5513                 (ndr_print_function_t) ndr_print_winbind_lookup,
5514                 false,
5515         },
5516         {
5517                 "winbind_get_idmap",
5518                 sizeof(struct winbind_get_idmap),
5519                 (ndr_push_flags_fn_t) ndr_push_winbind_get_idmap,
5520                 (ndr_pull_flags_fn_t) ndr_pull_winbind_get_idmap,
5521                 (ndr_print_function_t) ndr_print_winbind_get_idmap,
5522                 false,
5523         },
5524         {
5525                 "winbind_set_idmap",
5526                 sizeof(struct winbind_set_idmap),
5527                 (ndr_push_flags_fn_t) ndr_push_winbind_set_idmap,
5528                 (ndr_pull_flags_fn_t) ndr_pull_winbind_set_idmap,
5529                 (ndr_print_function_t) ndr_print_winbind_set_idmap,
5530                 false,
5531         },
5532         {
5533                 "winbind_info_fixname",
5534                 sizeof(struct winbind_info_fixname),
5535                 (ndr_push_flags_fn_t) ndr_push_winbind_info_fixname,
5536                 (ndr_pull_flags_fn_t) ndr_pull_winbind_info_fixname,
5537                 (ndr_print_function_t) ndr_print_winbind_info_fixname,
5538                 false,
5539         },
5540         {
5541                 "winbind_domain_name",
5542                 sizeof(struct winbind_domain_name),
5543                 (ndr_push_flags_fn_t) ndr_push_winbind_domain_name,
5544                 (ndr_pull_flags_fn_t) ndr_pull_winbind_domain_name,
5545                 (ndr_print_function_t) ndr_print_winbind_domain_name,
5546                 false,
5547         },
5548         {
5549                 "winbind_get_domain_info",
5550                 sizeof(struct winbind_get_domain_info),
5551                 (ndr_push_flags_fn_t) ndr_push_winbind_get_domain_info,
5552                 (ndr_pull_flags_fn_t) ndr_pull_winbind_get_domain_info,
5553                 (ndr_print_function_t) ndr_print_winbind_get_domain_info,
5554                 false,
5555         },
5556         {
5557                 "winbind_get_dc_info",
5558                 sizeof(struct winbind_get_dc_info),
5559                 (ndr_push_flags_fn_t) ndr_push_winbind_get_dc_info,
5560                 (ndr_pull_flags_fn_t) ndr_pull_winbind_get_dc_info,
5561                 (ndr_print_function_t) ndr_print_winbind_get_dc_info,
5562                 false,
5563         },
5564         {
5565                 "winbind_wins_byip",
5566                 sizeof(struct winbind_wins_byip),
5567                 (ndr_push_flags_fn_t) ndr_push_winbind_wins_byip,
5568                 (ndr_pull_flags_fn_t) ndr_pull_winbind_wins_byip,
5569                 (ndr_print_function_t) ndr_print_winbind_wins_byip,
5570                 false,
5571         },
5572         {
5573                 "winbind_wins_byname",
5574                 sizeof(struct winbind_wins_byname),
5575                 (ndr_push_flags_fn_t) ndr_push_winbind_wins_byname,
5576                 (ndr_pull_flags_fn_t) ndr_pull_winbind_wins_byname,
5577                 (ndr_print_function_t) ndr_print_winbind_wins_byname,
5578                 false,
5579         },
5580         {
5581                 "winbind_getgrlist",
5582                 sizeof(struct winbind_getgrlist),
5583                 (ndr_push_flags_fn_t) ndr_push_winbind_getgrlist,
5584                 (ndr_pull_flags_fn_t) ndr_pull_winbind_getgrlist,
5585                 (ndr_print_function_t) ndr_print_winbind_getgrlist,
5586                 false,
5587         },
5588         {
5589                 "winbind_netbios_name",
5590                 sizeof(struct winbind_netbios_name),
5591                 (ndr_push_flags_fn_t) ndr_push_winbind_netbios_name,
5592                 (ndr_pull_flags_fn_t) ndr_pull_winbind_netbios_name,
5593                 (ndr_print_function_t) ndr_print_winbind_netbios_name,
5594                 false,
5595         },
5596         {
5597                 "winbind_getusersids",
5598                 sizeof(struct winbind_getusersids),
5599                 (ndr_push_flags_fn_t) ndr_push_winbind_getusersids,
5600                 (ndr_pull_flags_fn_t) ndr_pull_winbind_getusersids,
5601                 (ndr_print_function_t) ndr_print_winbind_getusersids,
5602                 false,
5603         },
5604         {
5605                 "winbind_getuserdomgroups",
5606                 sizeof(struct winbind_getuserdomgroups),
5607                 (ndr_push_flags_fn_t) ndr_push_winbind_getuserdomgroups,
5608                 (ndr_pull_flags_fn_t) ndr_pull_winbind_getuserdomgroups,
5609                 (ndr_print_function_t) ndr_print_winbind_getuserdomgroups,
5610                 false,
5611         },
5612         {
5613                 "winbind_dual_userinfo",
5614                 sizeof(struct winbind_dual_userinfo),
5615                 (ndr_push_flags_fn_t) ndr_push_winbind_dual_userinfo,
5616                 (ndr_pull_flags_fn_t) ndr_pull_winbind_dual_userinfo,
5617                 (ndr_print_function_t) ndr_print_winbind_dual_userinfo,
5618                 false,
5619         },
5620         {
5621                 "winbind_dual_getsidaliases",
5622                 sizeof(struct winbind_dual_getsidaliases),
5623                 (ndr_push_flags_fn_t) ndr_push_winbind_dual_getsidaliases,
5624                 (ndr_pull_flags_fn_t) ndr_pull_winbind_dual_getsidaliases,
5625                 (ndr_print_function_t) ndr_print_winbind_dual_getsidaliases,
5626                 false,
5627         },
5628         {
5629                 "winbind_ccache_ntlmauth",
5630                 sizeof(struct winbind_ccache_ntlmauth),
5631                 (ndr_push_flags_fn_t) ndr_push_winbind_ccache_ntlmauth,
5632                 (ndr_pull_flags_fn_t) ndr_pull_winbind_ccache_ntlmauth,
5633                 (ndr_print_function_t) ndr_print_winbind_ccache_ntlmauth,
5634                 false,
5635         },
5636         { NULL, 0, NULL, NULL, NULL, false }
5637 };
5638
5639 static const char * const winbind_protocol_endpoint_strings[] = {
5640         "ncacn_np:[\\pipe\\winbind_protocol]",
5641 };
5642
5643 static const struct ndr_interface_string_array winbind_protocol_endpoints = {
5644         .count  = 1,
5645         .names  = winbind_protocol_endpoint_strings
5646 };
5647
5648 static const char * const winbind_protocol_authservice_strings[] = {
5649         "host",
5650 };
5651
5652 static const struct ndr_interface_string_array winbind_protocol_authservices = {
5653         .count  = 1,
5654         .names  = winbind_protocol_authservice_strings
5655 };
5656
5657
5658 const struct ndr_interface_table ndr_table_winbind_protocol = {
5659         .name           = "winbind_protocol",
5660         .syntax_id      = {
5661                 {0xb6608c99,0x0407,0x401b,{0x96,0xd3},{0x7b,0xcd,0xa6,0x72,0x32,0xaf}},
5662                 NDR_WINBIND_PROTOCOL_VERSION
5663         },
5664         .helpstring     = NDR_WINBIND_PROTOCOL_HELPSTRING,
5665         .num_calls      = 33,
5666         .calls          = winbind_protocol_calls,
5667         .endpoints      = &winbind_protocol_endpoints,
5668         .authservices   = &winbind_protocol_authservices
5669 };
5670