source/librpc/gen_ndr/ndr_winbind_protocol.c

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