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