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 _PUBLIC_ enum ndr_err_code ndr_push_winbind_status(struct ndr_push *ndr, int ndr_flags, enum winbind_status r)
   9 {
  10         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  11         return NDR_ERR_SUCCESS;
  12 }
  13
  14 _PUBLIC_ enum ndr_err_code ndr_pull_winbind_status(struct ndr_pull *ndr, int ndr_flags, enum winbind_status *r)
  15 {
  16         uint32_t v;
  17         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  18         *r = v;
  19         return NDR_ERR_SUCCESS;
  20 }
  21
  22 _PUBLIC_ void ndr_print_winbind_status(struct ndr_print *ndr, const char *name, enum winbind_status r)
  23 {
  24         const char *val = NULL;
  25
  26         switch (r) {
  27                 case WINBIND_STATUS_OK: val = "WINBIND_STATUS_OK"; break;
  28                 case WINBIND_STATUS_UNKNOWN_ERROR: val = "WINBIND_STATUS_UNKNOWN_ERROR"; break;
  29                 case WINBIND_STATUS_NOT_IMPLEMENTED: val = "WINBIND_STATUS_NOT_IMPLEMENTED"; break;
  30                 case WINBIND_STATUS_NOT_SUPPORTED: val = "WINBIND_STATUS_NOT_SUPPORTED"; break;
  31                 case WINBIND_STATUS_NO_MEMORY: val = "WINBIND_STATUS_NO_MEMORY"; break;
  32                 case WINBIND_STATUS_INVALID_PARAMETER: val = "WINBIND_STATUS_INVALID_PARAMETER"; break;
  33                 case WINBIND_STATUS_INVALID_LEVEL: val = "WINBIND_STATUS_INVALID_LEVEL"; break;
  34                 case WINBIND_STATUS_UNKNOWN_LEVEL: val = "WINBIND_STATUS_UNKNOWN_LEVEL"; break;
  35                 case WINBIND_STATUS_DOMAIN_OFFLINE: val = "WINBIND_STATUS_DOMAIN_OFFLINE"; break;
  36         }
  37         ndr_print_enum(ndr, name, "ENUM", val, r);
  38 }
  39
  40 static enum ndr_err_code ndr_push_winbind_header_version(struct ndr_push *ndr, int ndr_flags, uint16_t r)
  41 {
  42         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
  43         return NDR_ERR_SUCCESS;
  44 }
  45
  46 static enum ndr_err_code ndr_pull_winbind_header_version(struct ndr_pull *ndr, int ndr_flags, uint16_t *r)
  47 {
  48         uint16_t v;
  49         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
  50         *r = v;
  51         return NDR_ERR_SUCCESS;
  52 }
  53
  54 _PUBLIC_ void ndr_print_winbind_header_version(struct ndr_print *ndr, const char *name, uint16_t r)
  55 {
  56         ndr_print_uint16(ndr, name, r);
  57         ndr->depth++;
  58         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "WINBIND_HEADER_VERSION", WINBIND_HEADER_VERSION, r);
  59         ndr->depth--;
  60 }
  61
  62 static enum ndr_err_code ndr_push_winbind_header_flags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  63 {
  64         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  65         return NDR_ERR_SUCCESS;
  66 }
  67
  68 static enum ndr_err_code ndr_pull_winbind_header_flags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  69 {
  70         uint32_t v;
  71         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  72         *r = v;
  73         return NDR_ERR_SUCCESS;
  74 }
  75
  76 _PUBLIC_ void ndr_print_winbind_header_flags(struct ndr_print *ndr, const char *name, uint32_t r)
  77 {
  78         ndr_print_uint32(ndr, name, r);
  79         ndr->depth++;
  80         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WINBIND_HEADER_FLAGS_RESPONSE", WINBIND_HEADER_FLAGS_RESPONSE, r);
  81         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WINBIND_HEADER_FLAGS_ERROR", WINBIND_HEADER_FLAGS_ERROR, r);
  82         ndr->depth--;
  83 }
  84
  85 _PUBLIC_ enum ndr_err_code ndr_push_STRUCT_winbind_header(struct ndr_push *ndr, int ndr_flags, const struct winbind_header *r)
  86 {
  87         if (ndr_flags & NDR_SCALARS) {
  88                 NDR_CHECK(ndr_push_align(ndr, 4));
  89                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
  90                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, "WBPT", 4, sizeof(uint8_t), CH_DOS));
  91                 NDR_CHECK(ndr_push_winbind_header_version(ndr, NDR_SCALARS, WINBIND_HEADER_VERSION));
  92                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->opnum));
  93                 NDR_CHECK(ndr_push_winbind_header_flags(ndr, NDR_SCALARS, r->flags));
  94         }
  95         if (ndr_flags & NDR_BUFFERS) {
  96         }
  97         return NDR_ERR_SUCCESS;
  98 }
  99
 100 _PUBLIC_ enum ndr_err_code ndr_pull_STRUCT_winbind_header(struct ndr_pull *ndr, int ndr_flags, struct winbind_header *r)
 101 {
 102         if (ndr_flags & NDR_SCALARS) {
 103                 NDR_CHECK(ndr_pull_align(ndr, 4));
 104                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
 105                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->magic, 4, sizeof(uint8_t), CH_DOS));
 106                 NDR_CHECK(ndr_pull_winbind_header_version(ndr, NDR_SCALARS, &r->version));
 107                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->opnum));
 108                 NDR_CHECK(ndr_pull_winbind_header_flags(ndr, NDR_SCALARS, &r->flags));
 109         }
 110         if (ndr_flags & NDR_BUFFERS) {
 111         }
 112         return NDR_ERR_SUCCESS;
 113 }
 114
 115 _PUBLIC_ void ndr_print_STRUCT_winbind_header(struct ndr_print *ndr, const char *name, const struct winbind_header *r)
 116 {
 117         ndr_print_struct(ndr, name, "winbind_header");
 118         ndr->depth++;
 119         ndr_print_uint32(ndr, "length", r->length);
 120         ndr_print_string(ndr, "magic", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?"WBPT":r->magic);
 121         ndr_print_winbind_header_version(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?WINBIND_HEADER_VERSION:r->version);
 122         ndr_print_uint16(ndr, "opnum", r->opnum);
 123         ndr_print_winbind_header_flags(ndr, "flags", r->flags);
 124         ndr->depth--;
 125 }
 126
 127 static enum ndr_err_code ndr_push_winbind_lookup_level(struct ndr_push *ndr, int ndr_flags, enum winbind_lookup_level r)
 128 {
 129         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 130         return NDR_ERR_SUCCESS;
 131 }
 132
 133 static enum ndr_err_code ndr_pull_winbind_lookup_level(struct ndr_pull *ndr, int ndr_flags, enum winbind_lookup_level *r)
 134 {
 135         uint32_t v;
 136         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 137         *r = v;
 138         return NDR_ERR_SUCCESS;
 139 }
 140
 141 _PUBLIC_ void ndr_print_winbind_lookup_level(struct ndr_print *ndr, const char *name, enum winbind_lookup_level r)
 142 {
 143         const char *val = NULL;
 144
 145         switch (r) {
 146                 case WINBIND_LOOKUP_LEVEL_SID2NAME: val = "WINBIND_LOOKUP_LEVEL_SID2NAME"; break;
 147                 case WINBIND_LOOKUP_LEVEL_NAME2SID: val = "WINBIND_LOOKUP_LEVEL_NAME2SID"; break;
 148                 case WINBIND_LOOKUP_LEVEL_RIDS2NAMES: val = "WINBIND_LOOKUP_LEVEL_RIDS2NAMES"; break;
 149         }
 150         ndr_print_enum(ndr, name, "ENUM", val, r);
 151 }
 152
 153 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)
 154 {
 155         uint32_t cntr_rids_0;
 156         if (ndr_flags & NDR_SCALARS) {
 157                 NDR_CHECK(ndr_push_align(ndr, 4));
 158                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_sid));
 159                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_rids));
 160                 for (cntr_rids_0 = 0; cntr_rids_0 < r->num_rids; cntr_rids_0++) {
 161                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rids[cntr_rids_0]));
 162                 }
 163         }
 164         if (ndr_flags & NDR_BUFFERS) {
 165                 if (r->domain_sid) {
 166                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain_sid));
 167                 }
 168         }
 169         return NDR_ERR_SUCCESS;
 170 }
 171
 172 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)
 173 {
 174         uint32_t _ptr_domain_sid;
 175         TALLOC_CTX *_mem_save_domain_sid_0;
 176         uint32_t cntr_rids_0;
 177         TALLOC_CTX *_mem_save_rids_0;
 178         if (ndr_flags & NDR_SCALARS) {
 179                 NDR_CHECK(ndr_pull_align(ndr, 4));
 180                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_sid));
 181                 if (_ptr_domain_sid) {
 182                         NDR_PULL_ALLOC(ndr, r->domain_sid);
 183                 } else {
 184                         r->domain_sid = NULL;
 185                 }
 186                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_rids));
 187                 NDR_PULL_ALLOC_N(ndr, r->rids, r->num_rids);
 188                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 189                 NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
 190                 for (cntr_rids_0 = 0; cntr_rids_0 < r->num_rids; cntr_rids_0++) {
 191                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rids[cntr_rids_0]));
 192                 }
 193                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
 194         }
 195         if (ndr_flags & NDR_BUFFERS) {
 196                 if (r->domain_sid) {
 197                         _mem_save_domain_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 198                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_sid, 0);
 199                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain_sid));
 200                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_sid_0, 0);
 201                 }
 202         }
 203         return NDR_ERR_SUCCESS;
 204 }
 205
 206 _PUBLIC_ void ndr_print_STRUCT_winbind_lookup_req_rids(struct ndr_print *ndr, const char *name, const struct winbind_lookup_req_rids *r)
 207 {
 208         uint32_t cntr_rids_0;
 209         ndr_print_struct(ndr, name, "winbind_lookup_req_rids");
 210         ndr->depth++;
 211         ndr_print_ptr(ndr, "domain_sid", r->domain_sid);
 212         ndr->depth++;
 213         if (r->domain_sid) {
 214                 ndr_print_dom_sid(ndr, "domain_sid", r->domain_sid);
 215         }
 216         ndr->depth--;
 217         ndr_print_uint32(ndr, "num_rids", r->num_rids);
 218         ndr->print(ndr, "%s: ARRAY(%d)", "rids", r->num_rids);
 219         ndr->depth++;
 220         for (cntr_rids_0=0;cntr_rids_0<r->num_rids;cntr_rids_0++) {
 221                 char *idx_0=NULL;
 222                 asprintf(&idx_0, "[%d]", cntr_rids_0);
 223                 if (idx_0) {
 224                         ndr_print_uint32(ndr, "rids", r->rids[cntr_rids_0]);
 225                         free(idx_0);
 226                 }
 227         }
 228         ndr->depth--;
 229         ndr->depth--;
 230 }
 231
 232 static enum ndr_err_code ndr_push_winbind_lookup_req(struct ndr_push *ndr, int ndr_flags, const union winbind_lookup_req *r)
 233 {
 234         if (ndr_flags & NDR_SCALARS) {
 235                 int level = ndr_push_get_switch_value(ndr, r);
 236                 NDR_CHECK(ndr_push_winbind_lookup_level(ndr, NDR_SCALARS, level));
 237                 switch (level) {
 238                         case WINBIND_LOOKUP_LEVEL_SID2NAME:
 239                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
 240                         break;
 241
 242                         case WINBIND_LOOKUP_LEVEL_NAME2SID:
 243                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF8)));
 244                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 245                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF8)));
 246                                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 247                         break;
 248
 249                         case WINBIND_LOOKUP_LEVEL_RIDS2NAMES:
 250                                 NDR_CHECK(ndr_push_STRUCT_winbind_lookup_req_rids(ndr, NDR_SCALARS, &r->rids));
 251                         break;
 252
 253                         default:
 254                         break;
 255
 256                 }
 257         }
 258         if (ndr_flags & NDR_BUFFERS) {
 259                 int level = ndr_push_get_switch_value(ndr, r);
 260                 switch (level) {
 261                         case WINBIND_LOOKUP_LEVEL_SID2NAME:
 262                                 if (r->sid) {
 263                                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
 264                                 }
 265                         break;
 266
 267                         case WINBIND_LOOKUP_LEVEL_NAME2SID:
 268                         break;
 269
 270                         case WINBIND_LOOKUP_LEVEL_RIDS2NAMES:
 271                                 NDR_CHECK(ndr_push_STRUCT_winbind_lookup_req_rids(ndr, NDR_BUFFERS, &r->rids));
 272                         break;
 273
 274                         default:
 275                         break;
 276
 277                 }
 278         }
 279         return NDR_ERR_SUCCESS;
 280 }
 281
 282 static enum ndr_err_code ndr_pull_winbind_lookup_req(struct ndr_pull *ndr, int ndr_flags, union winbind_lookup_req *r)
 283 {
 284         int level;
 285         uint32_t _level;
 286         TALLOC_CTX *_mem_save_sid_0;
 287         level = ndr_pull_get_switch_value(ndr, r);
 288         if (ndr_flags & NDR_SCALARS) {
 289                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
 290                 if (_level != level) {
 291                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
 292                 }
 293                 switch (level) {
 294                         case WINBIND_LOOKUP_LEVEL_SID2NAME: {
 295                                 uint32_t _ptr_sid;
 296                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
 297                                 if (_ptr_sid) {
 298                                         NDR_PULL_ALLOC(ndr, r->sid);
 299                                 } else {
 300                                         r->sid = NULL;
 301                                 }
 302                         break; }
 303
 304                         case WINBIND_LOOKUP_LEVEL_NAME2SID: {
 305                                 NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
 306                                 NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
 307                                 if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
 308                                         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));
 309                                 }
 310                                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint8_t)));
 311                                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint8_t), CH_UTF8));
 312                         break; }
 313
 314                         case WINBIND_LOOKUP_LEVEL_RIDS2NAMES: {
 315                                 NDR_CHECK(ndr_pull_STRUCT_winbind_lookup_req_rids(ndr, NDR_SCALARS, &r->rids));
 316                         break; }
 317
 318                         default: {
 319                         break; }
 320
 321                 }
 322         }
 323         if (ndr_flags & NDR_BUFFERS) {
 324                 switch (level) {
 325                         case WINBIND_LOOKUP_LEVEL_SID2NAME:
 326                                 if (r->sid) {
 327                                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 328                                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
 329                                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
 330                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
 331                                 }
 332                         break;
 333
 334                         case WINBIND_LOOKUP_LEVEL_NAME2SID:
 335                         break;
 336
 337                         case WINBIND_LOOKUP_LEVEL_RIDS2NAMES:
 338                                 NDR_CHECK(ndr_pull_STRUCT_winbind_lookup_req_rids(ndr, NDR_BUFFERS, &r->rids));
 339                         break;
 340
 341                         default:
 342                         break;
 343
 344                 }
 345         }
 346         return NDR_ERR_SUCCESS;
 347 }
 348
 349 _PUBLIC_ void ndr_print_winbind_lookup_req(struct ndr_print *ndr, const char *name, const union winbind_lookup_req *r)
 350 {
 351         int level;
 352         level = ndr_print_get_switch_value(ndr, r);
 353         ndr_print_union(ndr, name, level, "winbind_lookup_req");
 354         switch (level) {
 355                 case WINBIND_LOOKUP_LEVEL_SID2NAME:
 356                         ndr_print_ptr(ndr, "sid", r->sid);
 357                         ndr->depth++;
 358                         if (r->sid) {
 359                                 ndr_print_dom_sid(ndr, "sid", r->sid);
 360                         }
 361                         ndr->depth--;
 362                 break;
 363
 364                 case WINBIND_LOOKUP_LEVEL_NAME2SID:
 365                         ndr_print_string(ndr, "name", r->name);
 366                 break;
 367
 368                 case WINBIND_LOOKUP_LEVEL_RIDS2NAMES:
 369                         ndr_print_STRUCT_winbind_lookup_req_rids(ndr, "rids", &r->rids);
 370                 break;
 371
 372                 default:
 373                 break;
 374
 375         }
 376 }
 377
 378 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)
 379 {
 380         if (ndr_flags & NDR_SCALARS) {
 381                 NDR_CHECK(ndr_push_align(ndr, 4));
 382                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF8)));
 383                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 384                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF8)));
 385                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 386                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->account_name, CH_UTF8)));
 387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 388                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->account_name, CH_UTF8)));
 389                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->account_name, ndr_charset_length(r->account_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 390                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->type));
 391         }
 392         if (ndr_flags & NDR_BUFFERS) {
 393         }
 394         return NDR_ERR_SUCCESS;
 395 }
 396
 397 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)
 398 {
 399         if (ndr_flags & NDR_SCALARS) {
 400                 NDR_CHECK(ndr_pull_align(ndr, 4));
 401                 NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
 402                 NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
 403                 if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
 404                         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));
 405                 }
 406                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint8_t)));
 407                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint8_t), CH_UTF8));
 408                 NDR_CHECK(ndr_pull_array_size(ndr, &r->account_name));
 409                 NDR_CHECK(ndr_pull_array_length(ndr, &r->account_name));
 410                 if (ndr_get_array_length(ndr, &r->account_name) > ndr_get_array_size(ndr, &r->account_name)) {
 411                         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));
 412                 }
 413                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->account_name), sizeof(uint8_t)));
 414                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->account_name, ndr_get_array_length(ndr, &r->account_name), sizeof(uint8_t), CH_UTF8));
 415                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->type));
 416         }
 417         if (ndr_flags & NDR_BUFFERS) {
 418         }
 419         return NDR_ERR_SUCCESS;
 420 }
 421
 422 _PUBLIC_ void ndr_print_STRUCT_winbind_lookup_name_info(struct ndr_print *ndr, const char *name, const struct winbind_lookup_name_info *r)
 423 {
 424         ndr_print_struct(ndr, name, "winbind_lookup_name_info");
 425         ndr->depth++;
 426         ndr_print_string(ndr, "domain_name", r->domain_name);
 427         ndr_print_string(ndr, "account_name", r->account_name);
 428         ndr_print_lsa_SidType(ndr, "type", r->type);
 429         ndr->depth--;
 430 }
 431
 432 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)
 433 {
 434         if (ndr_flags & NDR_SCALARS) {
 435                 NDR_CHECK(ndr_push_align(ndr, 4));
 436                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
 437                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->type));
 438         }
 439         if (ndr_flags & NDR_BUFFERS) {
 440                 if (r->sid) {
 441                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
 442                 }
 443         }
 444         return NDR_ERR_SUCCESS;
 445 }
 446
 447 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)
 448 {
 449         uint32_t _ptr_sid;
 450         TALLOC_CTX *_mem_save_sid_0;
 451         if (ndr_flags & NDR_SCALARS) {
 452                 NDR_CHECK(ndr_pull_align(ndr, 4));
 453                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
 454                 if (_ptr_sid) {
 455                         NDR_PULL_ALLOC(ndr, r->sid);
 456                 } else {
 457                         r->sid = NULL;
 458                 }
 459                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->type));
 460         }
 461         if (ndr_flags & NDR_BUFFERS) {
 462                 if (r->sid) {
 463                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 464                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
 465                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
 466                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
 467                 }
 468         }
 469         return NDR_ERR_SUCCESS;
 470 }
 471
 472 _PUBLIC_ void ndr_print_STRUCT_winbind_lookup_sid_info(struct ndr_print *ndr, const char *name, const struct winbind_lookup_sid_info *r)
 473 {
 474         ndr_print_struct(ndr, name, "winbind_lookup_sid_info");
 475         ndr->depth++;
 476         ndr_print_ptr(ndr, "sid", r->sid);
 477         ndr->depth++;
 478         if (r->sid) {
 479                 ndr_print_dom_sid(ndr, "sid", r->sid);
 480         }
 481         ndr->depth--;
 482         ndr_print_lsa_SidType(ndr, "type", r->type);
 483         ndr->depth--;
 484 }
 485
 486 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)
 487 {
 488         uint32_t cntr_names_0;
 489         if (ndr_flags & NDR_SCALARS) {
 490                 NDR_CHECK(ndr_push_align(ndr, 4));
 491                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_names));
 492                 for (cntr_names_0 = 0; cntr_names_0 < r->num_names; cntr_names_0++) {
 493                         NDR_CHECK(ndr_push_STRUCT_winbind_lookup_name_info(ndr, NDR_SCALARS, &r->names[cntr_names_0]));
 494                 }
 495         }
 496         if (ndr_flags & NDR_BUFFERS) {
 497         }
 498         return NDR_ERR_SUCCESS;
 499 }
 500
 501 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)
 502 {
 503         uint32_t cntr_names_0;
 504         TALLOC_CTX *_mem_save_names_0;
 505         if (ndr_flags & NDR_SCALARS) {
 506                 NDR_CHECK(ndr_pull_align(ndr, 4));
 507                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_names));
 508                 NDR_PULL_ALLOC_N(ndr, r->names, r->num_names);
 509                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
 510                 NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
 511                 for (cntr_names_0 = 0; cntr_names_0 < r->num_names; cntr_names_0++) {
 512                         NDR_CHECK(ndr_pull_STRUCT_winbind_lookup_name_info(ndr, NDR_SCALARS, &r->names[cntr_names_0]));
 513                 }
 514                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
 515         }
 516         if (ndr_flags & NDR_BUFFERS) {
 517         }
 518         return NDR_ERR_SUCCESS;
 519 }
 520
 521 _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)
 522 {
 523         uint32_t cntr_names_0;
 524         ndr_print_struct(ndr, name, "winbind_lookup_name_info_array");
 525         ndr->depth++;
 526         ndr_print_uint32(ndr, "num_names", r->num_names);
 527         ndr->print(ndr, "%s: ARRAY(%d)", "names", r->num_names);
 528         ndr->depth++;
 529         for (cntr_names_0=0;cntr_names_0<r->num_names;cntr_names_0++) {
 530                 char *idx_0=NULL;
 531                 asprintf(&idx_0, "[%d]", cntr_names_0);
 532                 if (idx_0) {
 533                         ndr_print_STRUCT_winbind_lookup_name_info(ndr, "names", &r->names[cntr_names_0]);
 534                         free(idx_0);
 535                 }
 536         }
 537         ndr->depth--;
 538         ndr->depth--;
 539 }
 540
 541 static enum ndr_err_code ndr_push_winbind_lookup_rep(struct ndr_push *ndr, int ndr_flags, const union winbind_lookup_rep *r)
 542 {
 543         if (ndr_flags & NDR_SCALARS) {
 544                 int level = ndr_push_get_switch_value(ndr, r);
 545                 NDR_CHECK(ndr_push_winbind_lookup_level(ndr, NDR_SCALARS, level));
 546                 switch (level) {
 547                         case WINBIND_LOOKUP_LEVEL_SID2NAME:
 548                                 NDR_CHECK(ndr_push_STRUCT_winbind_lookup_name_info(ndr, NDR_SCALARS, &r->name_info));
 549                         break;
 550
 551                         case WINBIND_LOOKUP_LEVEL_NAME2SID:
 552                                 NDR_CHECK(ndr_push_STRUCT_winbind_lookup_sid_info(ndr, NDR_SCALARS, &r->sid_info));
 553                         break;
 554
 555                         case WINBIND_LOOKUP_LEVEL_RIDS2NAMES:
 556                                 NDR_CHECK(ndr_push_STRUCT_winbind_lookup_name_info_array(ndr, NDR_SCALARS, &r->name_array));
 557                         break;
 558
 559                         default:
 560                         break;
 561
 562                 }
 563         }
 564         if (ndr_flags & NDR_BUFFERS) {
 565                 int level = ndr_push_get_switch_value(ndr, r);
 566                 switch (level) {
 567                         case WINBIND_LOOKUP_LEVEL_SID2NAME:
 568                         break;
 569
 570                         case WINBIND_LOOKUP_LEVEL_NAME2SID:
 571                                 NDR_CHECK(ndr_push_STRUCT_winbind_lookup_sid_info(ndr, NDR_BUFFERS, &r->sid_info));
 572                         break;
 573
 574                         case WINBIND_LOOKUP_LEVEL_RIDS2NAMES:
 575                         break;
 576
 577                         default:
 578                         break;
 579
 580                 }
 581         }
 582         return NDR_ERR_SUCCESS;
 583 }
 584
 585 static enum ndr_err_code ndr_pull_winbind_lookup_rep(struct ndr_pull *ndr, int ndr_flags, union winbind_lookup_rep *r)
 586 {
 587         int level;
 588         uint32_t _level;
 589         level = ndr_pull_get_switch_value(ndr, r);
 590         if (ndr_flags & NDR_SCALARS) {
 591                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
 592                 if (_level != level) {
 593                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
 594                 }
 595                 switch (level) {
 596                         case WINBIND_LOOKUP_LEVEL_SID2NAME: {
 597                                 NDR_CHECK(ndr_pull_STRUCT_winbind_lookup_name_info(ndr, NDR_SCALARS, &r->name_info));
 598                         break; }
 599
 600                         case WINBIND_LOOKUP_LEVEL_NAME2SID: {
 601                                 NDR_CHECK(ndr_pull_STRUCT_winbind_lookup_sid_info(ndr, NDR_SCALARS, &r->sid_info));
 602                         break; }
 603
 604                         case WINBIND_LOOKUP_LEVEL_RIDS2NAMES: {
 605                                 NDR_CHECK(ndr_pull_STRUCT_winbind_lookup_name_info_array(ndr, NDR_SCALARS, &r->name_array));
 606                         break; }
 607
 608                         default: {
 609                         break; }
 610
 611                 }
 612         }
 613         if (ndr_flags & NDR_BUFFERS) {
 614                 switch (level) {
 615                         case WINBIND_LOOKUP_LEVEL_SID2NAME:
 616                         break;
 617
 618                         case WINBIND_LOOKUP_LEVEL_NAME2SID:
 619                                 NDR_CHECK(ndr_pull_STRUCT_winbind_lookup_sid_info(ndr, NDR_BUFFERS, &r->sid_info));
 620                         break;
 621
 622                         case WINBIND_LOOKUP_LEVEL_RIDS2NAMES:
 623                         break;
 624
 625                         default:
 626                         break;
 627
 628                 }
 629         }
 630         return NDR_ERR_SUCCESS;
 631 }
 632
 633 _PUBLIC_ void ndr_print_winbind_lookup_rep(struct ndr_print *ndr, const char *name, const union winbind_lookup_rep *r)
 634 {
 635         int level;
 636         level = ndr_print_get_switch_value(ndr, r);
 637         ndr_print_union(ndr, name, level, "winbind_lookup_rep");
 638         switch (level) {
 639                 case WINBIND_LOOKUP_LEVEL_SID2NAME:
 640                         ndr_print_STRUCT_winbind_lookup_name_info(ndr, "name_info", &r->name_info);
 641                 break;
 642
 643                 case WINBIND_LOOKUP_LEVEL_NAME2SID:
 644                         ndr_print_STRUCT_winbind_lookup_sid_info(ndr, "sid_info", &r->sid_info);
 645                 break;
 646
 647                 case WINBIND_LOOKUP_LEVEL_RIDS2NAMES:
 648                         ndr_print_STRUCT_winbind_lookup_name_info_array(ndr, "name_array", &r->name_array);
 649                 break;
 650
 651                 default:
 652                 break;
 653
 654         }
 655 }
 656
 657 static enum ndr_err_code ndr_push_winbind_get_idmap_level(struct ndr_push *ndr, int ndr_flags, enum winbind_get_idmap_level r)
 658 {
 659         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 660         return NDR_ERR_SUCCESS;
 661 }
 662
 663 static enum ndr_err_code ndr_pull_winbind_get_idmap_level(struct ndr_pull *ndr, int ndr_flags, enum winbind_get_idmap_level *r)
 664 {
 665         uint32_t v;
 666         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 667         *r = v;
 668         return NDR_ERR_SUCCESS;
 669 }
 670
 671 _PUBLIC_ void ndr_print_winbind_get_idmap_level(struct ndr_print *ndr, const char *name, enum winbind_get_idmap_level r)
 672 {
 673         const char *val = NULL;
 674
 675         switch (r) {
 676                 case WINBIND_IDMAP_LEVEL_SID_TO_UID: val = "WINBIND_IDMAP_LEVEL_SID_TO_UID"; break;
 677                 case WINBIND_IDMAP_LEVEL_SID_TO_GID: val = "WINBIND_IDMAP_LEVEL_SID_TO_GID"; break;
 678                 case WINBIND_IDMAP_LEVEL_UID_TO_SID: val = "WINBIND_IDMAP_LEVEL_UID_TO_SID"; break;
 679                 case WINBIND_IDMAP_LEVEL_GID_TO_SID: val = "WINBIND_IDMAP_LEVEL_GID_TO_SID"; break;
 680         }
 681         ndr_print_enum(ndr, name, "ENUM", val, r);
 682 }
 683
 684 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)
 685 {
 686         if (ndr_flags & NDR_SCALARS) {
 687                 int level = ndr_push_get_switch_value(ndr, r);
 688                 NDR_CHECK(ndr_push_winbind_get_idmap_level(ndr, NDR_SCALARS, level));
 689                 switch (level) {
 690                         case WINBIND_IDMAP_LEVEL_SID_TO_UID:
 691                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
 692                         break;
 693
 694                         case WINBIND_IDMAP_LEVEL_SID_TO_GID:
 695                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
 696                         break;
 697
 698                         case WINBIND_IDMAP_LEVEL_UID_TO_SID:
 699                                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->uid));
 700                         break;
 701
 702                         case WINBIND_IDMAP_LEVEL_GID_TO_SID:
 703                                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->gid));
 704                         break;
 705
 706                         default:
 707                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 708                 }
 709         }
 710         if (ndr_flags & NDR_BUFFERS) {
 711                 int level = ndr_push_get_switch_value(ndr, r);
 712                 switch (level) {
 713                         case WINBIND_IDMAP_LEVEL_SID_TO_UID:
 714                                 if (r->sid) {
 715                                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
 716                                 }
 717                         break;
 718
 719                         case WINBIND_IDMAP_LEVEL_SID_TO_GID:
 720                                 if (r->sid) {
 721                                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
 722                                 }
 723                         break;
 724
 725                         case WINBIND_IDMAP_LEVEL_UID_TO_SID:
 726                         break;
 727
 728                         case WINBIND_IDMAP_LEVEL_GID_TO_SID:
 729                         break;
 730
 731                         default:
 732                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 733                 }
 734         }
 735         return NDR_ERR_SUCCESS;
 736 }
 737
 738 static enum ndr_err_code ndr_pull_winbind_get_idmap_req(struct ndr_pull *ndr, int ndr_flags, union winbind_get_idmap_req *r)
 739 {
 740         int level;
 741         uint32_t _level;
 742         TALLOC_CTX *_mem_save_sid_0;
 743         level = ndr_pull_get_switch_value(ndr, r);
 744         if (ndr_flags & NDR_SCALARS) {
 745                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
 746                 if (_level != level) {
 747                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
 748                 }
 749                 switch (level) {
 750                         case WINBIND_IDMAP_LEVEL_SID_TO_UID: {
 751                                 uint32_t _ptr_sid;
 752                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
 753                                 if (_ptr_sid) {
 754                                         NDR_PULL_ALLOC(ndr, r->sid);
 755                                 } else {
 756                                         r->sid = NULL;
 757                                 }
 758                         break; }
 759
 760                         case WINBIND_IDMAP_LEVEL_SID_TO_GID: {
 761                                 uint32_t _ptr_sid;
 762                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
 763                                 if (_ptr_sid) {
 764                                         NDR_PULL_ALLOC(ndr, r->sid);
 765                                 } else {
 766                                         r->sid = NULL;
 767                                 }
 768                         break; }
 769
 770                         case WINBIND_IDMAP_LEVEL_UID_TO_SID: {
 771                                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->uid));
 772                         break; }
 773
 774                         case WINBIND_IDMAP_LEVEL_GID_TO_SID: {
 775                                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->gid));
 776                         break; }
 777
 778                         default:
 779                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 780                 }
 781         }
 782         if (ndr_flags & NDR_BUFFERS) {
 783                 switch (level) {
 784                         case WINBIND_IDMAP_LEVEL_SID_TO_UID:
 785                                 if (r->sid) {
 786                                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 787                                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
 788                                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
 789                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
 790                                 }
 791                         break;
 792
 793                         case WINBIND_IDMAP_LEVEL_SID_TO_GID:
 794                                 if (r->sid) {
 795                                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 796                                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
 797                                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
 798                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
 799                                 }
 800                         break;
 801
 802                         case WINBIND_IDMAP_LEVEL_UID_TO_SID:
 803                         break;
 804
 805                         case WINBIND_IDMAP_LEVEL_GID_TO_SID:
 806                         break;
 807
 808                         default:
 809                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 810                 }
 811         }
 812         return NDR_ERR_SUCCESS;
 813 }
 814
 815 _PUBLIC_ void ndr_print_winbind_get_idmap_req(struct ndr_print *ndr, const char *name, const union winbind_get_idmap_req *r)
 816 {
 817         int level;
 818         level = ndr_print_get_switch_value(ndr, r);
 819         ndr_print_union(ndr, name, level, "winbind_get_idmap_req");
 820         switch (level) {
 821                 case WINBIND_IDMAP_LEVEL_SID_TO_UID:
 822                         ndr_print_ptr(ndr, "sid", r->sid);
 823                         ndr->depth++;
 824                         if (r->sid) {
 825                                 ndr_print_dom_sid(ndr, "sid", r->sid);
 826                         }
 827                         ndr->depth--;
 828                 break;
 829
 830                 case WINBIND_IDMAP_LEVEL_SID_TO_GID:
 831                         ndr_print_ptr(ndr, "sid", r->sid);
 832                         ndr->depth++;
 833                         if (r->sid) {
 834                                 ndr_print_dom_sid(ndr, "sid", r->sid);
 835                         }
 836                         ndr->depth--;
 837                 break;
 838
 839                 case WINBIND_IDMAP_LEVEL_UID_TO_SID:
 840                         ndr_print_hyper(ndr, "uid", r->uid);
 841                 break;
 842
 843                 case WINBIND_IDMAP_LEVEL_GID_TO_SID:
 844                         ndr_print_hyper(ndr, "gid", r->gid);
 845                 break;
 846
 847                 default:
 848                         ndr_print_bad_level(ndr, name, level);
 849         }
 850 }
 851
 852 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)
 853 {
 854         if (ndr_flags & NDR_SCALARS) {
 855                 int level = ndr_push_get_switch_value(ndr, r);
 856                 NDR_CHECK(ndr_push_winbind_get_idmap_level(ndr, NDR_SCALARS, level));
 857                 switch (level) {
 858                         case WINBIND_IDMAP_LEVEL_SID_TO_UID:
 859                                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->uid));
 860                         break;
 861
 862                         case WINBIND_IDMAP_LEVEL_SID_TO_GID:
 863                                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->gid));
 864                         break;
 865
 866                         case WINBIND_IDMAP_LEVEL_UID_TO_SID:
 867                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
 868                         break;
 869
 870                         case WINBIND_IDMAP_LEVEL_GID_TO_SID:
 871                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
 872                         break;
 873
 874                         default:
 875                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 876                 }
 877         }
 878         if (ndr_flags & NDR_BUFFERS) {
 879                 int level = ndr_push_get_switch_value(ndr, r);
 880                 switch (level) {
 881                         case WINBIND_IDMAP_LEVEL_SID_TO_UID:
 882                         break;
 883
 884                         case WINBIND_IDMAP_LEVEL_SID_TO_GID:
 885                         break;
 886
 887                         case WINBIND_IDMAP_LEVEL_UID_TO_SID:
 888                                 if (r->sid) {
 889                                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
 890                                 }
 891                         break;
 892
 893                         case WINBIND_IDMAP_LEVEL_GID_TO_SID:
 894                                 if (r->sid) {
 895                                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
 896                                 }
 897                         break;
 898
 899                         default:
 900                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 901                 }
 902         }
 903         return NDR_ERR_SUCCESS;
 904 }
 905
 906 static enum ndr_err_code ndr_pull_winbind_get_idmap_rep(struct ndr_pull *ndr, int ndr_flags, union winbind_get_idmap_rep *r)
 907 {
 908         int level;
 909         uint32_t _level;
 910         TALLOC_CTX *_mem_save_sid_0;
 911         level = ndr_pull_get_switch_value(ndr, r);
 912         if (ndr_flags & NDR_SCALARS) {
 913                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
 914                 if (_level != level) {
 915                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
 916                 }
 917                 switch (level) {
 918                         case WINBIND_IDMAP_LEVEL_SID_TO_UID: {
 919                                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->uid));
 920                         break; }
 921
 922                         case WINBIND_IDMAP_LEVEL_SID_TO_GID: {
 923                                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->gid));
 924                         break; }
 925
 926                         case WINBIND_IDMAP_LEVEL_UID_TO_SID: {
 927                                 uint32_t _ptr_sid;
 928                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
 929                                 if (_ptr_sid) {
 930                                         NDR_PULL_ALLOC(ndr, r->sid);
 931                                 } else {
 932                                         r->sid = NULL;
 933                                 }
 934                         break; }
 935
 936                         case WINBIND_IDMAP_LEVEL_GID_TO_SID: {
 937                                 uint32_t _ptr_sid;
 938                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
 939                                 if (_ptr_sid) {
 940                                         NDR_PULL_ALLOC(ndr, r->sid);
 941                                 } else {
 942                                         r->sid = NULL;
 943                                 }
 944                         break; }
 945
 946                         default:
 947                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 948                 }
 949         }
 950         if (ndr_flags & NDR_BUFFERS) {
 951                 switch (level) {
 952                         case WINBIND_IDMAP_LEVEL_SID_TO_UID:
 953                         break;
 954
 955                         case WINBIND_IDMAP_LEVEL_SID_TO_GID:
 956                         break;
 957
 958                         case WINBIND_IDMAP_LEVEL_UID_TO_SID:
 959                                 if (r->sid) {
 960                                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 961                                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
 962                                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
 963                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
 964                                 }
 965                         break;
 966
 967                         case WINBIND_IDMAP_LEVEL_GID_TO_SID:
 968                                 if (r->sid) {
 969                                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 970                                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
 971                                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
 972                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
 973                                 }
 974                         break;
 975
 976                         default:
 977                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 978                 }
 979         }
 980         return NDR_ERR_SUCCESS;
 981 }
 982
 983 _PUBLIC_ void ndr_print_winbind_get_idmap_rep(struct ndr_print *ndr, const char *name, const union winbind_get_idmap_rep *r)
 984 {
 985         int level;
 986         level = ndr_print_get_switch_value(ndr, r);
 987         ndr_print_union(ndr, name, level, "winbind_get_idmap_rep");
 988         switch (level) {
 989                 case WINBIND_IDMAP_LEVEL_SID_TO_UID:
 990                         ndr_print_hyper(ndr, "uid", r->uid);
 991                 break;
 992
 993                 case WINBIND_IDMAP_LEVEL_SID_TO_GID:
 994                         ndr_print_hyper(ndr, "gid", r->gid);
 995                 break;
 996
 997                 case WINBIND_IDMAP_LEVEL_UID_TO_SID:
 998                         ndr_print_ptr(ndr, "sid", r->sid);
 999                         ndr->depth++;
1000                         if (r->sid) {
1001                                 ndr_print_dom_sid(ndr, "sid", r->sid);
1002                         }
1003                         ndr->depth--;
1004                 break;
1005
1006                 case WINBIND_IDMAP_LEVEL_GID_TO_SID:
1007                         ndr_print_ptr(ndr, "sid", r->sid);
1008                         ndr->depth++;
1009                         if (r->sid) {
1010                                 ndr_print_dom_sid(ndr, "sid", r->sid);
1011                         }
1012                         ndr->depth--;
1013                 break;
1014
1015                 default:
1016                         ndr_print_bad_level(ndr, name, level);
1017         }
1018 }
1019
1020 static enum ndr_err_code ndr_push_winbind_set_idmap_level(struct ndr_push *ndr, int ndr_flags, enum winbind_set_idmap_level r)
1021 {
1022         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1023         return NDR_ERR_SUCCESS;
1024 }
1025
1026 static enum ndr_err_code ndr_pull_winbind_set_idmap_level(struct ndr_pull *ndr, int ndr_flags, enum winbind_set_idmap_level *r)
1027 {
1028         uint32_t v;
1029         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1030         *r = v;
1031         return NDR_ERR_SUCCESS;
1032 }
1033
1034 _PUBLIC_ void ndr_print_winbind_set_idmap_level(struct ndr_print *ndr, const char *name, enum winbind_set_idmap_level r)
1035 {
1036         const char *val = NULL;
1037
1038         switch (r) {
1039                 case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_UID: val = "WINBIND_SET_IDMAP_LEVEL_ALLOCATE_UID"; break;
1040                 case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_GID: val = "WINBIND_SET_IDMAP_LEVEL_ALLOCATE_GID"; break;
1041                 case WINBIND_SET_IDMAP_LEVEL_SET_MAPPING: val = "WINBIND_SET_IDMAP_LEVEL_SET_MAPPING"; break;
1042                 case WINBIND_SET_IDMAP_LEVEL_SET_HWM: val = "WINBIND_SET_IDMAP_LEVEL_SET_HWM"; break;
1043         }
1044         ndr_print_enum(ndr, name, "ENUM", val, r);
1045 }
1046
1047 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)
1048 {
1049         if (ndr_flags & NDR_SCALARS) {
1050                 int level = ndr_push_get_switch_value(ndr, r);
1051                 NDR_CHECK(ndr_push_winbind_set_idmap_level(ndr, NDR_SCALARS, level));
1052                 switch (level) {
1053                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_UID:
1054                         break;
1055
1056                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_GID:
1057                         break;
1058
1059                         case WINBIND_SET_IDMAP_LEVEL_SET_MAPPING:
1060                                 NDR_CHECK(ndr_push_id_map(ndr, NDR_SCALARS, &r->mapping));
1061                         break;
1062
1063                         case WINBIND_SET_IDMAP_LEVEL_SET_HWM:
1064                                 NDR_CHECK(ndr_push_unixid(ndr, NDR_SCALARS, &r->hwm));
1065                         break;
1066
1067                         default:
1068                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1069                 }
1070         }
1071         if (ndr_flags & NDR_BUFFERS) {
1072                 int level = ndr_push_get_switch_value(ndr, r);
1073                 switch (level) {
1074                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_UID:
1075                         break;
1076
1077                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_GID:
1078                         break;
1079
1080                         case WINBIND_SET_IDMAP_LEVEL_SET_MAPPING:
1081                                 NDR_CHECK(ndr_push_id_map(ndr, NDR_BUFFERS, &r->mapping));
1082                         break;
1083
1084                         case WINBIND_SET_IDMAP_LEVEL_SET_HWM:
1085                                 NDR_CHECK(ndr_push_unixid(ndr, NDR_BUFFERS, &r->hwm));
1086                         break;
1087
1088                         default:
1089                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1090                 }
1091         }
1092         return NDR_ERR_SUCCESS;
1093 }
1094
1095 static enum ndr_err_code ndr_pull_winbind_set_idmap_req(struct ndr_pull *ndr, int ndr_flags, union winbind_set_idmap_req *r)
1096 {
1097         int level;
1098         uint32_t _level;
1099         level = ndr_pull_get_switch_value(ndr, r);
1100         if (ndr_flags & NDR_SCALARS) {
1101                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
1102                 if (_level != level) {
1103                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1104                 }
1105                 switch (level) {
1106                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_UID: {
1107                         break; }
1108
1109                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_GID: {
1110                         break; }
1111
1112                         case WINBIND_SET_IDMAP_LEVEL_SET_MAPPING: {
1113                                 NDR_CHECK(ndr_pull_id_map(ndr, NDR_SCALARS, &r->mapping));
1114                         break; }
1115
1116                         case WINBIND_SET_IDMAP_LEVEL_SET_HWM: {
1117                                 NDR_CHECK(ndr_pull_unixid(ndr, NDR_SCALARS, &r->hwm));
1118                         break; }
1119
1120                         default:
1121                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1122                 }
1123         }
1124         if (ndr_flags & NDR_BUFFERS) {
1125                 switch (level) {
1126                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_UID:
1127                         break;
1128
1129                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_GID:
1130                         break;
1131
1132                         case WINBIND_SET_IDMAP_LEVEL_SET_MAPPING:
1133                                 NDR_CHECK(ndr_pull_id_map(ndr, NDR_BUFFERS, &r->mapping));
1134                         break;
1135
1136                         case WINBIND_SET_IDMAP_LEVEL_SET_HWM:
1137                                 NDR_CHECK(ndr_pull_unixid(ndr, NDR_BUFFERS, &r->hwm));
1138                         break;
1139
1140                         default:
1141                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1142                 }
1143         }
1144         return NDR_ERR_SUCCESS;
1145 }
1146
1147 _PUBLIC_ void ndr_print_winbind_set_idmap_req(struct ndr_print *ndr, const char *name, const union winbind_set_idmap_req *r)
1148 {
1149         int level;
1150         level = ndr_print_get_switch_value(ndr, r);
1151         ndr_print_union(ndr, name, level, "winbind_set_idmap_req");
1152         switch (level) {
1153                 case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_UID:
1154                 break;
1155
1156                 case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_GID:
1157                 break;
1158
1159                 case WINBIND_SET_IDMAP_LEVEL_SET_MAPPING:
1160                         ndr_print_id_map(ndr, "mapping", &r->mapping);
1161                 break;
1162
1163                 case WINBIND_SET_IDMAP_LEVEL_SET_HWM:
1164                         ndr_print_unixid(ndr, "hwm", &r->hwm);
1165                 break;
1166
1167                 default:
1168                         ndr_print_bad_level(ndr, name, level);
1169         }
1170 }
1171
1172 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)
1173 {
1174         if (ndr_flags & NDR_SCALARS) {
1175                 int level = ndr_push_get_switch_value(ndr, r);
1176                 NDR_CHECK(ndr_push_winbind_set_idmap_level(ndr, NDR_SCALARS, level));
1177                 switch (level) {
1178                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_UID:
1179                                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->uid));
1180                         break;
1181
1182                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_GID:
1183                                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->gid));
1184                         break;
1185
1186                         case WINBIND_SET_IDMAP_LEVEL_SET_MAPPING:
1187                         break;
1188
1189                         case WINBIND_SET_IDMAP_LEVEL_SET_HWM:
1190                         break;
1191
1192                         default:
1193                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1194                 }
1195         }
1196         if (ndr_flags & NDR_BUFFERS) {
1197                 int level = ndr_push_get_switch_value(ndr, r);
1198                 switch (level) {
1199                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_UID:
1200                         break;
1201
1202                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_GID:
1203                         break;
1204
1205                         case WINBIND_SET_IDMAP_LEVEL_SET_MAPPING:
1206                         break;
1207
1208                         case WINBIND_SET_IDMAP_LEVEL_SET_HWM:
1209                         break;
1210
1211                         default:
1212                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1213                 }
1214         }
1215         return NDR_ERR_SUCCESS;
1216 }
1217
1218 static enum ndr_err_code ndr_pull_winbind_set_idmap_rep(struct ndr_pull *ndr, int ndr_flags, union winbind_set_idmap_rep *r)
1219 {
1220         int level;
1221         uint32_t _level;
1222         level = ndr_pull_get_switch_value(ndr, r);
1223         if (ndr_flags & NDR_SCALARS) {
1224                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
1225                 if (_level != level) {
1226                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1227                 }
1228                 switch (level) {
1229                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_UID: {
1230                                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->uid));
1231                         break; }
1232
1233                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_GID: {
1234                                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->gid));
1235                         break; }
1236
1237                         case WINBIND_SET_IDMAP_LEVEL_SET_MAPPING: {
1238                         break; }
1239
1240                         case WINBIND_SET_IDMAP_LEVEL_SET_HWM: {
1241                         break; }
1242
1243                         default:
1244                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1245                 }
1246         }
1247         if (ndr_flags & NDR_BUFFERS) {
1248                 switch (level) {
1249                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_UID:
1250                         break;
1251
1252                         case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_GID:
1253                         break;
1254
1255                         case WINBIND_SET_IDMAP_LEVEL_SET_MAPPING:
1256                         break;
1257
1258                         case WINBIND_SET_IDMAP_LEVEL_SET_HWM:
1259                         break;
1260
1261                         default:
1262                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1263                 }
1264         }
1265         return NDR_ERR_SUCCESS;
1266 }
1267
1268 _PUBLIC_ void ndr_print_winbind_set_idmap_rep(struct ndr_print *ndr, const char *name, const union winbind_set_idmap_rep *r)
1269 {
1270         int level;
1271         level = ndr_print_get_switch_value(ndr, r);
1272         ndr_print_union(ndr, name, level, "winbind_set_idmap_rep");
1273         switch (level) {
1274                 case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_UID:
1275                         ndr_print_hyper(ndr, "uid", r->uid);
1276                 break;
1277
1278                 case WINBIND_SET_IDMAP_LEVEL_ALLOCATE_GID:
1279                         ndr_print_hyper(ndr, "gid", r->gid);
1280                 break;
1281
1282                 case WINBIND_SET_IDMAP_LEVEL_SET_MAPPING:
1283                 break;
1284
1285                 case WINBIND_SET_IDMAP_LEVEL_SET_HWM:
1286                 break;
1287
1288                 default:
1289                         ndr_print_bad_level(ndr, name, level);
1290         }
1291 }
1292
1293 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)
1294 {
1295         if (ndr_flags & NDR_SCALARS) {
1296                 NDR_CHECK(ndr_push_align(ndr, 4));
1297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF8)));
1298                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF8)));
1300                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
1301                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
1302                 if (r->sid == NULL) {
1303                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1304                 }
1305                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1306                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_native_mode));
1307                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_active_directory));
1308                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_primary));
1309         }
1310         if (ndr_flags & NDR_BUFFERS) {
1311                 if (r->dns_name) {
1312                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF8)));
1313                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1314                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF8)));
1315                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
1316                 }
1317                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1318         }
1319         return NDR_ERR_SUCCESS;
1320 }
1321
1322 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)
1323 {
1324         uint32_t _ptr_dns_name;
1325         TALLOC_CTX *_mem_save_dns_name_0;
1326         uint32_t _ptr_sid;
1327         TALLOC_CTX *_mem_save_sid_0;
1328         if (ndr_flags & NDR_SCALARS) {
1329                 NDR_CHECK(ndr_pull_align(ndr, 4));
1330                 NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
1331                 NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
1332                 if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
1333                         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));
1334                 }
1335                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint8_t)));
1336                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint8_t), CH_UTF8));
1337                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
1338                 if (_ptr_dns_name) {
1339                         NDR_PULL_ALLOC(ndr, r->dns_name);
1340                 } else {
1341                         r->dns_name = NULL;
1342                 }
1343                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_sid));
1344                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1345                         NDR_PULL_ALLOC(ndr, r->sid);
1346                 }
1347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_native_mode));
1348                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_active_directory));
1349                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_primary));
1350         }
1351         if (ndr_flags & NDR_BUFFERS) {
1352                 if (r->dns_name) {
1353                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1354                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
1355                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
1356                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
1357                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
1358                                 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));
1359                         }
1360                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint8_t)));
1361                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint8_t), CH_UTF8));
1362                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
1363                 }
1364                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1365                 NDR_PULL_SET_MEM_CTX(ndr, r->sid, LIBNDR_FLAG_REF_ALLOC);
1366                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1367                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
1368         }
1369         return NDR_ERR_SUCCESS;
1370 }
1371
1372 _PUBLIC_ void ndr_print_STRUCT_winbind_domain_info_compat(struct ndr_print *ndr, const char *name, const struct winbind_domain_info_compat *r)
1373 {
1374         ndr_print_struct(ndr, name, "winbind_domain_info_compat");
1375         ndr->depth++;
1376         ndr_print_string(ndr, "netbios_name", r->netbios_name);
1377         ndr_print_ptr(ndr, "dns_name", r->dns_name);
1378         ndr->depth++;
1379         if (r->dns_name) {
1380                 ndr_print_string(ndr, "dns_name", r->dns_name);
1381         }
1382         ndr->depth--;
1383         ndr_print_ptr(ndr, "sid", r->sid);
1384         ndr->depth++;
1385         ndr_print_dom_sid(ndr, "sid", r->sid);
1386         ndr->depth--;
1387         ndr_print_uint32(ndr, "is_native_mode", r->is_native_mode);
1388         ndr_print_uint32(ndr, "is_active_directory", r->is_active_directory);
1389         ndr_print_uint32(ndr, "is_primary", r->is_primary);
1390         ndr->depth--;
1391 }
1392
1393 static enum ndr_err_code ndr_push_winbind_domain_info_level(struct ndr_push *ndr, int ndr_flags, enum winbind_domain_info_level r)
1394 {
1395         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1396         return NDR_ERR_SUCCESS;
1397 }
1398
1399 static enum ndr_err_code ndr_pull_winbind_domain_info_level(struct ndr_pull *ndr, int ndr_flags, enum winbind_domain_info_level *r)
1400 {
1401         uint32_t v;
1402         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1403         *r = v;
1404         return NDR_ERR_SUCCESS;
1405 }
1406
1407 _PUBLIC_ void ndr_print_winbind_domain_info_level(struct ndr_print *ndr, const char *name, enum winbind_domain_info_level r)
1408 {
1409         const char *val = NULL;
1410
1411         switch (r) {
1412                 case WINBIND_DOMAIN_INFO_LEVEL_COMPAT: val = "WINBIND_DOMAIN_INFO_LEVEL_COMPAT"; break;
1413                 case WINBIND_DOMAIN_INFO_LEVEL_SEQNUM: val = "WINBIND_DOMAIN_INFO_LEVEL_SEQNUM"; break;
1414         }
1415         ndr_print_enum(ndr, name, "ENUM", val, r);
1416 }
1417
1418 static enum ndr_err_code ndr_push_winbind_domain_info(struct ndr_push *ndr, int ndr_flags, const union winbind_domain_info *r)
1419 {
1420         if (ndr_flags & NDR_SCALARS) {
1421                 int level = ndr_push_get_switch_value(ndr, r);
1422                 NDR_CHECK(ndr_push_winbind_domain_info_level(ndr, NDR_SCALARS, level));
1423                 switch (level) {
1424                         case WINBIND_DOMAIN_INFO_LEVEL_COMPAT:
1425                                 NDR_CHECK(ndr_push_STRUCT_winbind_domain_info_compat(ndr, NDR_SCALARS, &r->compat));
1426                         break;
1427
1428                         case WINBIND_DOMAIN_INFO_LEVEL_SEQNUM:
1429                                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->seqnum));
1430                         break;
1431
1432                         default:
1433                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1434                 }
1435         }
1436         if (ndr_flags & NDR_BUFFERS) {
1437                 int level = ndr_push_get_switch_value(ndr, r);
1438                 switch (level) {
1439                         case WINBIND_DOMAIN_INFO_LEVEL_COMPAT:
1440                                 NDR_CHECK(ndr_push_STRUCT_winbind_domain_info_compat(ndr, NDR_BUFFERS, &r->compat));
1441                         break;
1442
1443                         case WINBIND_DOMAIN_INFO_LEVEL_SEQNUM:
1444                         break;
1445
1446                         default:
1447                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1448                 }
1449         }
1450         return NDR_ERR_SUCCESS;
1451 }
1452
1453 static enum ndr_err_code ndr_pull_winbind_domain_info(struct ndr_pull *ndr, int ndr_flags, union winbind_domain_info *r)
1454 {
1455         int level;
1456         uint32_t _level;
1457         level = ndr_pull_get_switch_value(ndr, r);
1458         if (ndr_flags & NDR_SCALARS) {
1459                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
1460                 if (_level != level) {
1461                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1462                 }
1463                 switch (level) {
1464                         case WINBIND_DOMAIN_INFO_LEVEL_COMPAT: {
1465                                 NDR_CHECK(ndr_pull_STRUCT_winbind_domain_info_compat(ndr, NDR_SCALARS, &r->compat));
1466                         break; }
1467
1468                         case WINBIND_DOMAIN_INFO_LEVEL_SEQNUM: {
1469                                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->seqnum));
1470                         break; }
1471
1472                         default:
1473                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1474                 }
1475         }
1476         if (ndr_flags & NDR_BUFFERS) {
1477                 switch (level) {
1478                         case WINBIND_DOMAIN_INFO_LEVEL_COMPAT:
1479                                 NDR_CHECK(ndr_pull_STRUCT_winbind_domain_info_compat(ndr, NDR_BUFFERS, &r->compat));
1480                         break;
1481
1482                         case WINBIND_DOMAIN_INFO_LEVEL_SEQNUM:
1483                         break;
1484
1485                         default:
1486                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1487                 }
1488         }
1489         return NDR_ERR_SUCCESS;
1490 }
1491
1492 _PUBLIC_ void ndr_print_winbind_domain_info(struct ndr_print *ndr, const char *name, const union winbind_domain_info *r)
1493 {
1494         int level;
1495         level = ndr_print_get_switch_value(ndr, r);
1496         ndr_print_union(ndr, name, level, "winbind_domain_info");
1497         switch (level) {
1498                 case WINBIND_DOMAIN_INFO_LEVEL_COMPAT:
1499                         ndr_print_STRUCT_winbind_domain_info_compat(ndr, "compat", &r->compat);
1500                 break;
1501
1502                 case WINBIND_DOMAIN_INFO_LEVEL_SEQNUM:
1503                         ndr_print_hyper(ndr, "seqnum", r->seqnum);
1504                 break;
1505
1506                 default:
1507                         ndr_print_bad_level(ndr, name, level);
1508         }
1509 }
1510
1511 static enum ndr_err_code ndr_push_winbind_dc_info_level(struct ndr_push *ndr, int ndr_flags, enum winbind_dc_info_level r)
1512 {
1513         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1514         return NDR_ERR_SUCCESS;
1515 }
1516
1517 static enum ndr_err_code ndr_pull_winbind_dc_info_level(struct ndr_pull *ndr, int ndr_flags, enum winbind_dc_info_level *r)
1518 {
1519         uint32_t v;
1520         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1521         *r = v;
1522         return NDR_ERR_SUCCESS;
1523 }
1524
1525 _PUBLIC_ void ndr_print_winbind_dc_info_level(struct ndr_print *ndr, const char *name, enum winbind_dc_info_level r)
1526 {
1527         const char *val = NULL;
1528
1529         switch (r) {
1530                 case WINBIND_DC_INFO_LEVEL_COMPAT_NT4: val = "WINBIND_DC_INFO_LEVEL_COMPAT_NT4"; break;
1531                 case WINBIND_DC_INFO_LEVEL_COMPAT_DS: val = "WINBIND_DC_INFO_LEVEL_COMPAT_DS"; break;
1532         }
1533         ndr_print_enum(ndr, name, "ENUM", val, r);
1534 }
1535
1536 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)
1537 {
1538         if (ndr_flags & NDR_SCALARS) {
1539                 int level = ndr_push_get_switch_value(ndr, r);
1540                 NDR_CHECK(ndr_push_winbind_dc_info_level(ndr, NDR_SCALARS, level));
1541                 switch (level) {
1542                         case WINBIND_DC_INFO_LEVEL_COMPAT_NT4:
1543                         break;
1544
1545                         case WINBIND_DC_INFO_LEVEL_COMPAT_DS:
1546                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
1547                         break;
1548
1549                         default:
1550                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1551                 }
1552         }
1553         if (ndr_flags & NDR_BUFFERS) {
1554                 int level = ndr_push_get_switch_value(ndr, r);
1555                 switch (level) {
1556                         case WINBIND_DC_INFO_LEVEL_COMPAT_NT4:
1557                         break;
1558
1559                         case WINBIND_DC_INFO_LEVEL_COMPAT_DS:
1560                         break;
1561
1562                         default:
1563                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1564                 }
1565         }
1566         return NDR_ERR_SUCCESS;
1567 }
1568
1569 static enum ndr_err_code ndr_pull_winbind_dc_info_params(struct ndr_pull *ndr, int ndr_flags, union winbind_dc_info_params *r)
1570 {
1571         int level;
1572         uint32_t _level;
1573         level = ndr_pull_get_switch_value(ndr, r);
1574         if (ndr_flags & NDR_SCALARS) {
1575                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
1576                 if (_level != level) {
1577                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1578                 }
1579                 switch (level) {
1580                         case WINBIND_DC_INFO_LEVEL_COMPAT_NT4: {
1581                         break; }
1582
1583                         case WINBIND_DC_INFO_LEVEL_COMPAT_DS: {
1584                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
1585                         break; }
1586
1587                         default:
1588                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1589                 }
1590         }
1591         if (ndr_flags & NDR_BUFFERS) {
1592                 switch (level) {
1593                         case WINBIND_DC_INFO_LEVEL_COMPAT_NT4:
1594                         break;
1595
1596                         case WINBIND_DC_INFO_LEVEL_COMPAT_DS:
1597                         break;
1598
1599                         default:
1600                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1601                 }
1602         }
1603         return NDR_ERR_SUCCESS;
1604 }
1605
1606 _PUBLIC_ void ndr_print_winbind_dc_info_params(struct ndr_print *ndr, const char *name, const union winbind_dc_info_params *r)
1607 {
1608         int level;
1609         level = ndr_print_get_switch_value(ndr, r);
1610         ndr_print_union(ndr, name, level, "winbind_dc_info_params");
1611         switch (level) {
1612                 case WINBIND_DC_INFO_LEVEL_COMPAT_NT4:
1613                 break;
1614
1615                 case WINBIND_DC_INFO_LEVEL_COMPAT_DS:
1616                         ndr_print_uint32(ndr, "flags", r->flags);
1617                 break;
1618
1619                 default:
1620                         ndr_print_bad_level(ndr, name, level);
1621         }
1622 }
1623
1624 static enum ndr_err_code ndr_push_winbind_dc_info(struct ndr_push *ndr, int ndr_flags, const union winbind_dc_info *r)
1625 {
1626         if (ndr_flags & NDR_SCALARS) {
1627                 int level = ndr_push_get_switch_value(ndr, r);
1628                 NDR_CHECK(ndr_push_winbind_dc_info_level(ndr, NDR_SCALARS, level));
1629                 switch (level) {
1630                         case WINBIND_DC_INFO_LEVEL_COMPAT_NT4:
1631                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
1632                         break;
1633
1634                         case WINBIND_DC_INFO_LEVEL_COMPAT_DS:
1635                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
1636                         break;
1637
1638                         default:
1639                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1640                 }
1641         }
1642         if (ndr_flags & NDR_BUFFERS) {
1643                 int level = ndr_push_get_switch_value(ndr, r);
1644                 switch (level) {
1645                         case WINBIND_DC_INFO_LEVEL_COMPAT_NT4:
1646                                 if (r->name) {
1647                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF8)));
1648                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1649                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF8)));
1650                                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
1651                                 }
1652                         break;
1653
1654                         case WINBIND_DC_INFO_LEVEL_COMPAT_DS:
1655                                 if (r->name) {
1656                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF8)));
1657                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1658                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF8)));
1659                                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
1660                                 }
1661                         break;
1662
1663                         default:
1664                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1665                 }
1666         }
1667         return NDR_ERR_SUCCESS;
1668 }
1669
1670 static enum ndr_err_code ndr_pull_winbind_dc_info(struct ndr_pull *ndr, int ndr_flags, union winbind_dc_info *r)
1671 {
1672         int level;
1673         uint32_t _level;
1674         TALLOC_CTX *_mem_save_name_0;
1675         level = ndr_pull_get_switch_value(ndr, r);
1676         if (ndr_flags & NDR_SCALARS) {
1677                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
1678                 if (_level != level) {
1679                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1680                 }
1681                 switch (level) {
1682                         case WINBIND_DC_INFO_LEVEL_COMPAT_NT4: {
1683                                 uint32_t _ptr_name;
1684                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
1685                                 if (_ptr_name) {
1686                                         NDR_PULL_ALLOC(ndr, r->name);
1687                                 } else {
1688                                         r->name = NULL;
1689                                 }
1690                         break; }
1691
1692                         case WINBIND_DC_INFO_LEVEL_COMPAT_DS: {
1693                                 uint32_t _ptr_name;
1694                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
1695                                 if (_ptr_name) {
1696                                         NDR_PULL_ALLOC(ndr, r->name);
1697                                 } else {
1698                                         r->name = NULL;
1699                                 }
1700                         break; }
1701
1702                         default:
1703                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1704                 }
1705         }
1706         if (ndr_flags & NDR_BUFFERS) {
1707                 switch (level) {
1708                         case WINBIND_DC_INFO_LEVEL_COMPAT_NT4:
1709                                 if (r->name) {
1710                                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1711                                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
1712                                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
1713                                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
1714                                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
1715                                                 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));
1716                                         }
1717                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint8_t)));
1718                                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint8_t), CH_UTF8));
1719                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
1720                                 }
1721                         break;
1722
1723                         case WINBIND_DC_INFO_LEVEL_COMPAT_DS:
1724                                 if (r->name) {
1725                                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1726                                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
1727                                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
1728                                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
1729                                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
1730                                                 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));
1731                                         }
1732                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint8_t)));
1733                                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint8_t), CH_UTF8));
1734                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
1735                                 }
1736                         break;
1737
1738                         default:
1739                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1740                 }
1741         }
1742         return NDR_ERR_SUCCESS;
1743 }
1744
1745 _PUBLIC_ void ndr_print_winbind_dc_info(struct ndr_print *ndr, const char *name, const union winbind_dc_info *r)
1746 {
1747         int level;
1748         level = ndr_print_get_switch_value(ndr, r);
1749         ndr_print_union(ndr, name, level, "winbind_dc_info");
1750         switch (level) {
1751                 case WINBIND_DC_INFO_LEVEL_COMPAT_NT4:
1752                         ndr_print_ptr(ndr, "name", r->name);
1753                         ndr->depth++;
1754                         if (r->name) {
1755                                 ndr_print_string(ndr, "name", r->name);
1756                         }
1757                         ndr->depth--;
1758                 break;
1759
1760                 case WINBIND_DC_INFO_LEVEL_COMPAT_DS:
1761                         ndr_print_ptr(ndr, "name", r->name);
1762                         ndr->depth++;
1763                         if (r->name) {
1764                                 ndr_print_string(ndr, "name", r->name);
1765                         }
1766                         ndr->depth--;
1767                 break;
1768
1769                 default:
1770                         ndr_print_bad_level(ndr, name, level);
1771         }
1772 }
1773
1774 static enum ndr_err_code ndr_push_winbind_ping(struct ndr_push *ndr, int flags, const struct winbind_ping *r)
1775 {
1776         if (flags & NDR_IN) {
1777         }
1778         if (flags & NDR_OUT) {
1779                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
1780         }
1781         return NDR_ERR_SUCCESS;
1782 }
1783
1784 static enum ndr_err_code ndr_pull_winbind_ping(struct ndr_pull *ndr, int flags, struct winbind_ping *r)
1785 {
1786         if (flags & NDR_IN) {
1787         }
1788         if (flags & NDR_OUT) {
1789                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
1790         }
1791         return NDR_ERR_SUCCESS;
1792 }
1793
1794 _PUBLIC_ void ndr_print_winbind_ping(struct ndr_print *ndr, const char *name, int flags, const struct winbind_ping *r)
1795 {
1796         ndr_print_struct(ndr, name, "winbind_ping");
1797         ndr->depth++;
1798         if (flags & NDR_SET_VALUES) {
1799                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1800         }
1801         if (flags & NDR_IN) {
1802                 ndr_print_struct(ndr, "in", "winbind_ping");
1803                 ndr->depth++;
1804                 ndr->depth--;
1805         }
1806         if (flags & NDR_OUT) {
1807                 ndr_print_struct(ndr, "out", "winbind_ping");
1808                 ndr->depth++;
1809                 ndr_print_winbind_status(ndr, "result", r->out.result);
1810                 ndr->depth--;
1811         }
1812         ndr->depth--;
1813 }
1814
1815 static enum ndr_err_code ndr_push_winbind_interface_details(struct ndr_push *ndr, int flags, const struct winbind_interface_details *r)
1816 {
1817         if (flags & NDR_IN) {
1818         }
1819         if (flags & NDR_OUT) {
1820                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
1821         }
1822         return NDR_ERR_SUCCESS;
1823 }
1824
1825 static enum ndr_err_code ndr_pull_winbind_interface_details(struct ndr_pull *ndr, int flags, struct winbind_interface_details *r)
1826 {
1827         if (flags & NDR_IN) {
1828         }
1829         if (flags & NDR_OUT) {
1830                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
1831         }
1832         return NDR_ERR_SUCCESS;
1833 }
1834
1835 _PUBLIC_ void ndr_print_winbind_interface_details(struct ndr_print *ndr, const char *name, int flags, const struct winbind_interface_details *r)
1836 {
1837         ndr_print_struct(ndr, name, "winbind_interface_details");
1838         ndr->depth++;
1839         if (flags & NDR_SET_VALUES) {
1840                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1841         }
1842         if (flags & NDR_IN) {
1843                 ndr_print_struct(ndr, "in", "winbind_interface_details");
1844                 ndr->depth++;
1845                 ndr->depth--;
1846         }
1847         if (flags & NDR_OUT) {
1848                 ndr_print_struct(ndr, "out", "winbind_interface_details");
1849                 ndr->depth++;
1850                 ndr_print_winbind_status(ndr, "result", r->out.result);
1851                 ndr->depth--;
1852         }
1853         ndr->depth--;
1854 }
1855
1856 static enum ndr_err_code ndr_push_winbind_getpwnam(struct ndr_push *ndr, int flags, const struct winbind_getpwnam *r)
1857 {
1858         if (flags & NDR_IN) {
1859         }
1860         if (flags & NDR_OUT) {
1861                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
1862         }
1863         return NDR_ERR_SUCCESS;
1864 }
1865
1866 static enum ndr_err_code ndr_pull_winbind_getpwnam(struct ndr_pull *ndr, int flags, struct winbind_getpwnam *r)
1867 {
1868         if (flags & NDR_IN) {
1869         }
1870         if (flags & NDR_OUT) {
1871                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
1872         }
1873         return NDR_ERR_SUCCESS;
1874 }
1875
1876 _PUBLIC_ void ndr_print_winbind_getpwnam(struct ndr_print *ndr, const char *name, int flags, const struct winbind_getpwnam *r)
1877 {
1878         ndr_print_struct(ndr, name, "winbind_getpwnam");
1879         ndr->depth++;
1880         if (flags & NDR_SET_VALUES) {
1881                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1882         }
1883         if (flags & NDR_IN) {
1884                 ndr_print_struct(ndr, "in", "winbind_getpwnam");
1885                 ndr->depth++;
1886                 ndr->depth--;
1887         }
1888         if (flags & NDR_OUT) {
1889                 ndr_print_struct(ndr, "out", "winbind_getpwnam");
1890                 ndr->depth++;
1891                 ndr_print_winbind_status(ndr, "result", r->out.result);
1892                 ndr->depth--;
1893         }
1894         ndr->depth--;
1895 }
1896
1897 static enum ndr_err_code ndr_push_winbind_getpwuid(struct ndr_push *ndr, int flags, const struct winbind_getpwuid *r)
1898 {
1899         if (flags & NDR_IN) {
1900         }
1901         if (flags & NDR_OUT) {
1902                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
1903         }
1904         return NDR_ERR_SUCCESS;
1905 }
1906
1907 static enum ndr_err_code ndr_pull_winbind_getpwuid(struct ndr_pull *ndr, int flags, struct winbind_getpwuid *r)
1908 {
1909         if (flags & NDR_IN) {
1910         }
1911         if (flags & NDR_OUT) {
1912                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
1913         }
1914         return NDR_ERR_SUCCESS;
1915 }
1916
1917 _PUBLIC_ void ndr_print_winbind_getpwuid(struct ndr_print *ndr, const char *name, int flags, const struct winbind_getpwuid *r)
1918 {
1919         ndr_print_struct(ndr, name, "winbind_getpwuid");
1920         ndr->depth++;
1921         if (flags & NDR_SET_VALUES) {
1922                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1923         }
1924         if (flags & NDR_IN) {
1925                 ndr_print_struct(ndr, "in", "winbind_getpwuid");
1926                 ndr->depth++;
1927                 ndr->depth--;
1928         }
1929         if (flags & NDR_OUT) {
1930                 ndr_print_struct(ndr, "out", "winbind_getpwuid");
1931                 ndr->depth++;
1932                 ndr_print_winbind_status(ndr, "result", r->out.result);
1933                 ndr->depth--;
1934         }
1935         ndr->depth--;
1936 }
1937
1938 static enum ndr_err_code ndr_push_winbind_getgrnam(struct ndr_push *ndr, int flags, const struct winbind_getgrnam *r)
1939 {
1940         if (flags & NDR_IN) {
1941         }
1942         if (flags & NDR_OUT) {
1943                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
1944         }
1945         return NDR_ERR_SUCCESS;
1946 }
1947
1948 static enum ndr_err_code ndr_pull_winbind_getgrnam(struct ndr_pull *ndr, int flags, struct winbind_getgrnam *r)
1949 {
1950         if (flags & NDR_IN) {
1951         }
1952         if (flags & NDR_OUT) {
1953                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
1954         }
1955         return NDR_ERR_SUCCESS;
1956 }
1957
1958 _PUBLIC_ void ndr_print_winbind_getgrnam(struct ndr_print *ndr, const char *name, int flags, const struct winbind_getgrnam *r)
1959 {
1960         ndr_print_struct(ndr, name, "winbind_getgrnam");
1961         ndr->depth++;
1962         if (flags & NDR_SET_VALUES) {
1963                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1964         }
1965         if (flags & NDR_IN) {
1966                 ndr_print_struct(ndr, "in", "winbind_getgrnam");
1967                 ndr->depth++;
1968                 ndr->depth--;
1969         }
1970         if (flags & NDR_OUT) {
1971                 ndr_print_struct(ndr, "out", "winbind_getgrnam");
1972                 ndr->depth++;
1973                 ndr_print_winbind_status(ndr, "result", r->out.result);
1974                 ndr->depth--;
1975         }
1976         ndr->depth--;
1977 }
1978
1979 static enum ndr_err_code ndr_push_winbind_getgrgid(struct ndr_push *ndr, int flags, const struct winbind_getgrgid *r)
1980 {
1981         if (flags & NDR_IN) {
1982         }
1983         if (flags & NDR_OUT) {
1984                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
1985         }
1986         return NDR_ERR_SUCCESS;
1987 }
1988
1989 static enum ndr_err_code ndr_pull_winbind_getgrgid(struct ndr_pull *ndr, int flags, struct winbind_getgrgid *r)
1990 {
1991         if (flags & NDR_IN) {
1992         }
1993         if (flags & NDR_OUT) {
1994                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
1995         }
1996         return NDR_ERR_SUCCESS;
1997 }
1998
1999 _PUBLIC_ void ndr_print_winbind_getgrgid(struct ndr_print *ndr, const char *name, int flags, const struct winbind_getgrgid *r)
2000 {
2001         ndr_print_struct(ndr, name, "winbind_getgrgid");
2002         ndr->depth++;
2003         if (flags & NDR_SET_VALUES) {
2004                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2005         }
2006         if (flags & NDR_IN) {
2007                 ndr_print_struct(ndr, "in", "winbind_getgrgid");
2008                 ndr->depth++;
2009                 ndr->depth--;
2010         }
2011         if (flags & NDR_OUT) {
2012                 ndr_print_struct(ndr, "out", "winbind_getgrgid");
2013                 ndr->depth++;
2014                 ndr_print_winbind_status(ndr, "result", r->out.result);
2015                 ndr->depth--;
2016         }
2017         ndr->depth--;
2018 }
2019
2020 static enum ndr_err_code ndr_push_winbind_getgroups(struct ndr_push *ndr, int flags, const struct winbind_getgroups *r)
2021 {
2022         if (flags & NDR_IN) {
2023         }
2024         if (flags & NDR_OUT) {
2025                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
2026         }
2027         return NDR_ERR_SUCCESS;
2028 }
2029
2030 static enum ndr_err_code ndr_pull_winbind_getgroups(struct ndr_pull *ndr, int flags, struct winbind_getgroups *r)
2031 {
2032         if (flags & NDR_IN) {
2033         }
2034         if (flags & NDR_OUT) {
2035                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
2036         }
2037         return NDR_ERR_SUCCESS;
2038 }
2039
2040 _PUBLIC_ void ndr_print_winbind_getgroups(struct ndr_print *ndr, const char *name, int flags, const struct winbind_getgroups *r)
2041 {
2042         ndr_print_struct(ndr, name, "winbind_getgroups");
2043         ndr->depth++;
2044         if (flags & NDR_SET_VALUES) {
2045                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2046         }
2047         if (flags & NDR_IN) {
2048                 ndr_print_struct(ndr, "in", "winbind_getgroups");
2049                 ndr->depth++;
2050                 ndr->depth--;
2051         }
2052         if (flags & NDR_OUT) {
2053                 ndr_print_struct(ndr, "out", "winbind_getgroups");
2054                 ndr->depth++;
2055                 ndr_print_winbind_status(ndr, "result", r->out.result);
2056                 ndr->depth--;
2057         }
2058         ndr->depth--;
2059 }
2060
2061 static enum ndr_err_code ndr_push_winbind_setpwent(struct ndr_push *ndr, int flags, const struct winbind_setpwent *r)
2062 {
2063         if (flags & NDR_IN) {
2064         }
2065         if (flags & NDR_OUT) {
2066                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
2067         }
2068         return NDR_ERR_SUCCESS;
2069 }
2070
2071 static enum ndr_err_code ndr_pull_winbind_setpwent(struct ndr_pull *ndr, int flags, struct winbind_setpwent *r)
2072 {
2073         if (flags & NDR_IN) {
2074         }
2075         if (flags & NDR_OUT) {
2076                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
2077         }
2078         return NDR_ERR_SUCCESS;
2079 }
2080
2081 _PUBLIC_ void ndr_print_winbind_setpwent(struct ndr_print *ndr, const char *name, int flags, const struct winbind_setpwent *r)
2082 {
2083         ndr_print_struct(ndr, name, "winbind_setpwent");
2084         ndr->depth++;
2085         if (flags & NDR_SET_VALUES) {
2086                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2087         }
2088         if (flags & NDR_IN) {
2089                 ndr_print_struct(ndr, "in", "winbind_setpwent");
2090                 ndr->depth++;
2091                 ndr->depth--;
2092         }
2093         if (flags & NDR_OUT) {
2094                 ndr_print_struct(ndr, "out", "winbind_setpwent");
2095                 ndr->depth++;
2096                 ndr_print_winbind_status(ndr, "result", r->out.result);
2097                 ndr->depth--;
2098         }
2099         ndr->depth--;
2100 }
2101
2102 static enum ndr_err_code ndr_push_winbind_endpwent(struct ndr_push *ndr, int flags, const struct winbind_endpwent *r)
2103 {
2104         if (flags & NDR_IN) {
2105         }
2106         if (flags & NDR_OUT) {
2107                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
2108         }
2109         return NDR_ERR_SUCCESS;
2110 }
2111
2112 static enum ndr_err_code ndr_pull_winbind_endpwent(struct ndr_pull *ndr, int flags, struct winbind_endpwent *r)
2113 {
2114         if (flags & NDR_IN) {
2115         }
2116         if (flags & NDR_OUT) {
2117                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
2118         }
2119         return NDR_ERR_SUCCESS;
2120 }
2121
2122 _PUBLIC_ void ndr_print_winbind_endpwent(struct ndr_print *ndr, const char *name, int flags, const struct winbind_endpwent *r)
2123 {
2124         ndr_print_struct(ndr, name, "winbind_endpwent");
2125         ndr->depth++;
2126         if (flags & NDR_SET_VALUES) {
2127                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2128         }
2129         if (flags & NDR_IN) {
2130                 ndr_print_struct(ndr, "in", "winbind_endpwent");
2131                 ndr->depth++;
2132                 ndr->depth--;
2133         }
2134         if (flags & NDR_OUT) {
2135                 ndr_print_struct(ndr, "out", "winbind_endpwent");
2136                 ndr->depth++;
2137                 ndr_print_winbind_status(ndr, "result", r->out.result);
2138                 ndr->depth--;
2139         }
2140         ndr->depth--;
2141 }
2142
2143 static enum ndr_err_code ndr_push_winbind_getpwent(struct ndr_push *ndr, int flags, const struct winbind_getpwent *r)
2144 {
2145         if (flags & NDR_IN) {
2146         }
2147         if (flags & NDR_OUT) {
2148                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
2149         }
2150         return NDR_ERR_SUCCESS;
2151 }
2152
2153 static enum ndr_err_code ndr_pull_winbind_getpwent(struct ndr_pull *ndr, int flags, struct winbind_getpwent *r)
2154 {
2155         if (flags & NDR_IN) {
2156         }
2157         if (flags & NDR_OUT) {
2158                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
2159         }
2160         return NDR_ERR_SUCCESS;
2161 }
2162
2163 _PUBLIC_ void ndr_print_winbind_getpwent(struct ndr_print *ndr, const char *name, int flags, const struct winbind_getpwent *r)
2164 {
2165         ndr_print_struct(ndr, name, "winbind_getpwent");
2166         ndr->depth++;
2167         if (flags & NDR_SET_VALUES) {
2168                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2169         }
2170         if (flags & NDR_IN) {
2171                 ndr_print_struct(ndr, "in", "winbind_getpwent");
2172                 ndr->depth++;
2173                 ndr->depth--;
2174         }
2175         if (flags & NDR_OUT) {
2176                 ndr_print_struct(ndr, "out", "winbind_getpwent");
2177                 ndr->depth++;
2178                 ndr_print_winbind_status(ndr, "result", r->out.result);
2179                 ndr->depth--;
2180         }
2181         ndr->depth--;
2182 }
2183
2184 static enum ndr_err_code ndr_push_winbind_setgrent(struct ndr_push *ndr, int flags, const struct winbind_setgrent *r)
2185 {
2186         if (flags & NDR_IN) {
2187         }
2188         if (flags & NDR_OUT) {
2189                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
2190         }
2191         return NDR_ERR_SUCCESS;
2192 }
2193
2194 static enum ndr_err_code ndr_pull_winbind_setgrent(struct ndr_pull *ndr, int flags, struct winbind_setgrent *r)
2195 {
2196         if (flags & NDR_IN) {
2197         }
2198         if (flags & NDR_OUT) {
2199                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
2200         }
2201         return NDR_ERR_SUCCESS;
2202 }
2203
2204 _PUBLIC_ void ndr_print_winbind_setgrent(struct ndr_print *ndr, const char *name, int flags, const struct winbind_setgrent *r)
2205 {
2206         ndr_print_struct(ndr, name, "winbind_setgrent");
2207         ndr->depth++;
2208         if (flags & NDR_SET_VALUES) {
2209                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2210         }
2211         if (flags & NDR_IN) {
2212                 ndr_print_struct(ndr, "in", "winbind_setgrent");
2213                 ndr->depth++;
2214                 ndr->depth--;
2215         }
2216         if (flags & NDR_OUT) {
2217                 ndr_print_struct(ndr, "out", "winbind_setgrent");
2218                 ndr->depth++;
2219                 ndr_print_winbind_status(ndr, "result", r->out.result);
2220                 ndr->depth--;
2221         }
2222         ndr->depth--;
2223 }
2224
2225 static enum ndr_err_code ndr_push_winbind_endgrent(struct ndr_push *ndr, int flags, const struct winbind_endgrent *r)
2226 {
2227         if (flags & NDR_IN) {
2228         }
2229         if (flags & NDR_OUT) {
2230                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
2231         }
2232         return NDR_ERR_SUCCESS;
2233 }
2234
2235 static enum ndr_err_code ndr_pull_winbind_endgrent(struct ndr_pull *ndr, int flags, struct winbind_endgrent *r)
2236 {
2237         if (flags & NDR_IN) {
2238         }
2239         if (flags & NDR_OUT) {
2240                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
2241         }
2242         return NDR_ERR_SUCCESS;
2243 }
2244
2245 _PUBLIC_ void ndr_print_winbind_endgrent(struct ndr_print *ndr, const char *name, int flags, const struct winbind_endgrent *r)
2246 {
2247         ndr_print_struct(ndr, name, "winbind_endgrent");
2248         ndr->depth++;
2249         if (flags & NDR_SET_VALUES) {
2250                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2251         }
2252         if (flags & NDR_IN) {
2253                 ndr_print_struct(ndr, "in", "winbind_endgrent");
2254                 ndr->depth++;
2255                 ndr->depth--;
2256         }
2257         if (flags & NDR_OUT) {
2258                 ndr_print_struct(ndr, "out", "winbind_endgrent");
2259                 ndr->depth++;
2260                 ndr_print_winbind_status(ndr, "result", r->out.result);
2261                 ndr->depth--;
2262         }
2263         ndr->depth--;
2264 }
2265
2266 static enum ndr_err_code ndr_push_winbind_getgrent(struct ndr_push *ndr, int flags, const struct winbind_getgrent *r)
2267 {
2268         if (flags & NDR_IN) {
2269         }
2270         if (flags & NDR_OUT) {
2271                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
2272         }
2273         return NDR_ERR_SUCCESS;
2274 }
2275
2276 static enum ndr_err_code ndr_pull_winbind_getgrent(struct ndr_pull *ndr, int flags, struct winbind_getgrent *r)
2277 {
2278         if (flags & NDR_IN) {
2279         }
2280         if (flags & NDR_OUT) {
2281                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
2282         }
2283         return NDR_ERR_SUCCESS;
2284 }
2285
2286 _PUBLIC_ void ndr_print_winbind_getgrent(struct ndr_print *ndr, const char *name, int flags, const struct winbind_getgrent *r)
2287 {
2288         ndr_print_struct(ndr, name, "winbind_getgrent");
2289         ndr->depth++;
2290         if (flags & NDR_SET_VALUES) {
2291                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2292         }
2293         if (flags & NDR_IN) {
2294                 ndr_print_struct(ndr, "in", "winbind_getgrent");
2295                 ndr->depth++;
2296                 ndr->depth--;
2297         }
2298         if (flags & NDR_OUT) {
2299                 ndr_print_struct(ndr, "out", "winbind_getgrent");
2300                 ndr->depth++;
2301                 ndr_print_winbind_status(ndr, "result", r->out.result);
2302                 ndr->depth--;
2303         }
2304         ndr->depth--;
2305 }
2306
2307 static enum ndr_err_code ndr_push_winbind_pam_auth(struct ndr_push *ndr, int flags, const struct winbind_pam_auth *r)
2308 {
2309         if (flags & NDR_IN) {
2310         }
2311         if (flags & NDR_OUT) {
2312                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
2313         }
2314         return NDR_ERR_SUCCESS;
2315 }
2316
2317 static enum ndr_err_code ndr_pull_winbind_pam_auth(struct ndr_pull *ndr, int flags, struct winbind_pam_auth *r)
2318 {
2319         if (flags & NDR_IN) {
2320         }
2321         if (flags & NDR_OUT) {
2322                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
2323         }
2324         return NDR_ERR_SUCCESS;
2325 }
2326
2327 _PUBLIC_ void ndr_print_winbind_pam_auth(struct ndr_print *ndr, const char *name, int flags, const struct winbind_pam_auth *r)
2328 {
2329         ndr_print_struct(ndr, name, "winbind_pam_auth");
2330         ndr->depth++;
2331         if (flags & NDR_SET_VALUES) {
2332                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2333         }
2334         if (flags & NDR_IN) {
2335                 ndr_print_struct(ndr, "in", "winbind_pam_auth");
2336                 ndr->depth++;
2337                 ndr->depth--;
2338         }
2339         if (flags & NDR_OUT) {
2340                 ndr_print_struct(ndr, "out", "winbind_pam_auth");
2341                 ndr->depth++;
2342                 ndr_print_winbind_status(ndr, "result", r->out.result);
2343                 ndr->depth--;
2344         }
2345         ndr->depth--;
2346 }
2347
2348 static enum ndr_err_code ndr_push_winbind_pam_auth_crap(struct ndr_push *ndr, int flags, const struct winbind_pam_auth_crap *r)
2349 {
2350         if (flags & NDR_IN) {
2351         }
2352         if (flags & NDR_OUT) {
2353                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
2354         }
2355         return NDR_ERR_SUCCESS;
2356 }
2357
2358 static enum ndr_err_code ndr_pull_winbind_pam_auth_crap(struct ndr_pull *ndr, int flags, struct winbind_pam_auth_crap *r)
2359 {
2360         if (flags & NDR_IN) {
2361         }
2362         if (flags & NDR_OUT) {
2363                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
2364         }
2365         return NDR_ERR_SUCCESS;
2366 }
2367
2368 _PUBLIC_ void ndr_print_winbind_pam_auth_crap(struct ndr_print *ndr, const char *name, int flags, const struct winbind_pam_auth_crap *r)
2369 {
2370         ndr_print_struct(ndr, name, "winbind_pam_auth_crap");
2371         ndr->depth++;
2372         if (flags & NDR_SET_VALUES) {
2373                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2374         }
2375         if (flags & NDR_IN) {
2376                 ndr_print_struct(ndr, "in", "winbind_pam_auth_crap");
2377                 ndr->depth++;
2378                 ndr->depth--;
2379         }
2380         if (flags & NDR_OUT) {
2381                 ndr_print_struct(ndr, "out", "winbind_pam_auth_crap");
2382                 ndr->depth++;
2383                 ndr_print_winbind_status(ndr, "result", r->out.result);
2384                 ndr->depth--;
2385         }
2386         ndr->depth--;
2387 }
2388
2389 static enum ndr_err_code ndr_push_winbind_pam_chauthtok(struct ndr_push *ndr, int flags, const struct winbind_pam_chauthtok *r)
2390 {
2391         if (flags & NDR_IN) {
2392         }
2393         if (flags & NDR_OUT) {
2394                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
2395         }
2396         return NDR_ERR_SUCCESS;
2397 }
2398
2399 static enum ndr_err_code ndr_pull_winbind_pam_chauthtok(struct ndr_pull *ndr, int flags, struct winbind_pam_chauthtok *r)
2400 {
2401         if (flags & NDR_IN) {
2402         }
2403         if (flags & NDR_OUT) {
2404                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
2405         }
2406         return NDR_ERR_SUCCESS;
2407 }
2408
2409 _PUBLIC_ void ndr_print_winbind_pam_chauthtok(struct ndr_print *ndr, const char *name, int flags, const struct winbind_pam_chauthtok *r)
2410 {
2411         ndr_print_struct(ndr, name, "winbind_pam_chauthtok");
2412         ndr->depth++;
2413         if (flags & NDR_SET_VALUES) {
2414                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2415         }
2416         if (flags & NDR_IN) {
2417                 ndr_print_struct(ndr, "in", "winbind_pam_chauthtok");
2418                 ndr->depth++;
2419                 ndr->depth--;
2420         }
2421         if (flags & NDR_OUT) {
2422                 ndr_print_struct(ndr, "out", "winbind_pam_chauthtok");
2423                 ndr->depth++;
2424                 ndr_print_winbind_status(ndr, "result", r->out.result);
2425                 ndr->depth--;
2426         }
2427         ndr->depth--;
2428 }
2429
2430 static enum ndr_err_code ndr_push_winbind_pam_logoff(struct ndr_push *ndr, int flags, const struct winbind_pam_logoff *r)
2431 {
2432         if (flags & NDR_IN) {
2433         }
2434         if (flags & NDR_OUT) {
2435                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
2436         }
2437         return NDR_ERR_SUCCESS;
2438 }
2439
2440 static enum ndr_err_code ndr_pull_winbind_pam_logoff(struct ndr_pull *ndr, int flags, struct winbind_pam_logoff *r)
2441 {
2442         if (flags & NDR_IN) {
2443         }
2444         if (flags & NDR_OUT) {
2445                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
2446         }
2447         return NDR_ERR_SUCCESS;
2448 }
2449
2450 _PUBLIC_ void ndr_print_winbind_pam_logoff(struct ndr_print *ndr, const char *name, int flags, const struct winbind_pam_logoff *r)
2451 {
2452         ndr_print_struct(ndr, name, "winbind_pam_logoff");
2453         ndr->depth++;
2454         if (flags & NDR_SET_VALUES) {
2455                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2456         }
2457         if (flags & NDR_IN) {
2458                 ndr_print_struct(ndr, "in", "winbind_pam_logoff");
2459                 ndr->depth++;
2460                 ndr->depth--;
2461         }
2462         if (flags & NDR_OUT) {
2463                 ndr_print_struct(ndr, "out", "winbind_pam_logoff");
2464                 ndr->depth++;
2465                 ndr_print_winbind_status(ndr, "result", r->out.result);
2466                 ndr->depth--;
2467         }
2468         ndr->depth--;
2469 }
2470
2471 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)
2472 {
2473         if (flags & NDR_IN) {
2474         }
2475         if (flags & NDR_OUT) {
2476                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
2477         }
2478         return NDR_ERR_SUCCESS;
2479 }
2480
2481 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)
2482 {
2483         if (flags & NDR_IN) {
2484         }
2485         if (flags & NDR_OUT) {
2486                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
2487         }
2488         return NDR_ERR_SUCCESS;
2489 }
2490
2491 _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)
2492 {
2493         ndr_print_struct(ndr, name, "winbind_pam_chng_paswd_auth_crap");
2494         ndr->depth++;
2495         if (flags & NDR_SET_VALUES) {
2496                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2497         }
2498         if (flags & NDR_IN) {
2499                 ndr_print_struct(ndr, "in", "winbind_pam_chng_paswd_auth_crap");
2500                 ndr->depth++;
2501                 ndr->depth--;
2502         }
2503         if (flags & NDR_OUT) {
2504                 ndr_print_struct(ndr, "out", "winbind_pam_chng_paswd_auth_crap");
2505                 ndr->depth++;
2506                 ndr_print_winbind_status(ndr, "result", r->out.result);
2507                 ndr->depth--;
2508         }
2509         ndr->depth--;
2510 }
2511
2512 static enum ndr_err_code ndr_push_winbind_list_users(struct ndr_push *ndr, int flags, const struct winbind_list_users *r)
2513 {
2514         if (flags & NDR_IN) {
2515         }
2516         if (flags & NDR_OUT) {
2517                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
2518         }
2519         return NDR_ERR_SUCCESS;
2520 }
2521
2522 static enum ndr_err_code ndr_pull_winbind_list_users(struct ndr_pull *ndr, int flags, struct winbind_list_users *r)
2523 {
2524         if (flags & NDR_IN) {
2525         }
2526         if (flags & NDR_OUT) {
2527                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
2528         }
2529         return NDR_ERR_SUCCESS;
2530 }
2531
2532 _PUBLIC_ void ndr_print_winbind_list_users(struct ndr_print *ndr, const char *name, int flags, const struct winbind_list_users *r)
2533 {
2534         ndr_print_struct(ndr, name, "winbind_list_users");
2535         ndr->depth++;
2536         if (flags & NDR_SET_VALUES) {
2537                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2538         }
2539         if (flags & NDR_IN) {
2540                 ndr_print_struct(ndr, "in", "winbind_list_users");
2541                 ndr->depth++;
2542                 ndr->depth--;
2543         }
2544         if (flags & NDR_OUT) {
2545                 ndr_print_struct(ndr, "out", "winbind_list_users");
2546                 ndr->depth++;
2547                 ndr_print_winbind_status(ndr, "result", r->out.result);
2548                 ndr->depth--;
2549         }
2550         ndr->depth--;
2551 }
2552
2553 static enum ndr_err_code ndr_push_winbind_list_groups(struct ndr_push *ndr, int flags, const struct winbind_list_groups *r)
2554 {
2555         if (flags & NDR_IN) {
2556         }
2557         if (flags & NDR_OUT) {
2558                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
2559         }
2560         return NDR_ERR_SUCCESS;
2561 }
2562
2563 static enum ndr_err_code ndr_pull_winbind_list_groups(struct ndr_pull *ndr, int flags, struct winbind_list_groups *r)
2564 {
2565         if (flags & NDR_IN) {
2566         }
2567         if (flags & NDR_OUT) {
2568                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
2569         }
2570         return NDR_ERR_SUCCESS;
2571 }
2572
2573 _PUBLIC_ void ndr_print_winbind_list_groups(struct ndr_print *ndr, const char *name, int flags, const struct winbind_list_groups *r)
2574 {
2575         ndr_print_struct(ndr, name, "winbind_list_groups");
2576         ndr->depth++;
2577         if (flags & NDR_SET_VALUES) {
2578                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2579         }
2580         if (flags & NDR_IN) {
2581                 ndr_print_struct(ndr, "in", "winbind_list_groups");
2582                 ndr->depth++;
2583                 ndr->depth--;
2584         }
2585         if (flags & NDR_OUT) {
2586                 ndr_print_struct(ndr, "out", "winbind_list_groups");
2587                 ndr->depth++;
2588                 ndr_print_winbind_status(ndr, "result", r->out.result);
2589                 ndr->depth--;
2590         }
2591         ndr->depth--;
2592 }
2593
2594 static enum ndr_err_code ndr_push_winbind_list_trustdom(struct ndr_push *ndr, int flags, const struct winbind_list_trustdom *r)
2595 {
2596         if (flags & NDR_IN) {
2597         }
2598         if (flags & NDR_OUT) {
2599                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
2600         }
2601         return NDR_ERR_SUCCESS;
2602 }
2603
2604 static enum ndr_err_code ndr_pull_winbind_list_trustdom(struct ndr_pull *ndr, int flags, struct winbind_list_trustdom *r)
2605 {
2606         if (flags & NDR_IN) {
2607         }
2608         if (flags & NDR_OUT) {
2609                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
2610         }
2611         return NDR_ERR_SUCCESS;
2612 }
2613
2614 _PUBLIC_ void ndr_print_winbind_list_trustdom(struct ndr_print *ndr, const char *name, int flags, const struct winbind_list_trustdom *r)
2615 {
2616         ndr_print_struct(ndr, name, "winbind_list_trustdom");
2617         ndr->depth++;
2618         if (flags & NDR_SET_VALUES) {
2619                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2620         }
2621         if (flags & NDR_IN) {
2622                 ndr_print_struct(ndr, "in", "winbind_list_trustdom");
2623                 ndr->depth++;
2624                 ndr->depth--;
2625         }
2626         if (flags & NDR_OUT) {
2627                 ndr_print_struct(ndr, "out", "winbind_list_trustdom");
2628                 ndr->depth++;
2629                 ndr_print_winbind_status(ndr, "result", r->out.result);
2630                 ndr->depth--;
2631         }
2632         ndr->depth--;
2633 }
2634
2635 static enum ndr_err_code ndr_push_winbind_lookup(struct ndr_push *ndr, int flags, const struct winbind_lookup *r)
2636 {
2637         if (flags & NDR_IN) {
2638                 if (r->in.level == NULL) {
2639                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2640                 }
2641                 NDR_CHECK(ndr_push_winbind_lookup_level(ndr, NDR_SCALARS, *r->in.level));
2642                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, *r->in.level));
2643                 NDR_CHECK(ndr_push_winbind_lookup_req(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
2644         }
2645         if (flags & NDR_OUT) {
2646                 if (r->out.rep == NULL) {
2647                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2648                 }
2649                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.rep, *r->in.level));
2650                 NDR_CHECK(ndr_push_winbind_lookup_rep(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rep));
2651                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
2652         }
2653         return NDR_ERR_SUCCESS;
2654 }
2655
2656 static enum ndr_err_code ndr_pull_winbind_lookup(struct ndr_pull *ndr, int flags, struct winbind_lookup *r)
2657 {
2658         TALLOC_CTX *_mem_save_level_0;
2659         TALLOC_CTX *_mem_save_rep_0;
2660         if (flags & NDR_IN) {
2661                 ZERO_STRUCT(r->out);
2662
2663                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2664                         NDR_PULL_ALLOC(ndr, r->in.level);
2665                 }
2666                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
2667                 NDR_PULL_SET_MEM_CTX(ndr, r->in.level, LIBNDR_FLAG_REF_ALLOC);
2668                 NDR_CHECK(ndr_pull_winbind_lookup_level(ndr, NDR_SCALARS, r->in.level));
2669                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
2670                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, *r->in.level));
2671                 NDR_CHECK(ndr_pull_winbind_lookup_req(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
2672                 NDR_PULL_ALLOC(ndr, r->out.rep);
2673                 ZERO_STRUCTP(r->out.rep);
2674         }
2675         if (flags & NDR_OUT) {
2676                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2677                         NDR_PULL_ALLOC(ndr, r->out.rep);
2678                 }
2679                 _mem_save_rep_0 = NDR_PULL_GET_MEM_CTX(ndr);
2680                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rep, LIBNDR_FLAG_REF_ALLOC);
2681                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.rep, *r->in.level));
2682                 NDR_CHECK(ndr_pull_winbind_lookup_rep(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rep));
2683                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rep_0, LIBNDR_FLAG_REF_ALLOC);
2684                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
2685         }
2686         return NDR_ERR_SUCCESS;
2687 }
2688
2689 _PUBLIC_ void ndr_print_winbind_lookup(struct ndr_print *ndr, const char *name, int flags, const struct winbind_lookup *r)
2690 {
2691         ndr_print_struct(ndr, name, "winbind_lookup");
2692         ndr->depth++;
2693         if (flags & NDR_SET_VALUES) {
2694                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2695         }
2696         if (flags & NDR_IN) {
2697                 ndr_print_struct(ndr, "in", "winbind_lookup");
2698                 ndr->depth++;
2699                 ndr_print_ptr(ndr, "level", r->in.level);
2700                 ndr->depth++;
2701                 ndr_print_winbind_lookup_level(ndr, "level", *r->in.level);
2702                 ndr->depth--;
2703                 ndr_print_set_switch_value(ndr, &r->in.req, *r->in.level);
2704                 ndr_print_winbind_lookup_req(ndr, "req", &r->in.req);
2705                 ndr->depth--;
2706         }
2707         if (flags & NDR_OUT) {
2708                 ndr_print_struct(ndr, "out", "winbind_lookup");
2709                 ndr->depth++;
2710                 ndr_print_ptr(ndr, "rep", r->out.rep);
2711                 ndr->depth++;
2712                 ndr_print_set_switch_value(ndr, r->out.rep, *r->in.level);
2713                 ndr_print_winbind_lookup_rep(ndr, "rep", r->out.rep);
2714                 ndr->depth--;
2715                 ndr_print_winbind_status(ndr, "result", r->out.result);
2716                 ndr->depth--;
2717         }
2718         ndr->depth--;
2719 }
2720
2721 static enum ndr_err_code ndr_push_winbind_get_idmap(struct ndr_push *ndr, int flags, const struct winbind_get_idmap *r)
2722 {
2723         if (flags & NDR_IN) {
2724                 if (r->in.level == NULL) {
2725                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2726                 }
2727                 NDR_CHECK(ndr_push_winbind_get_idmap_level(ndr, NDR_SCALARS, *r->in.level));
2728                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, *r->in.level));
2729                 NDR_CHECK(ndr_push_winbind_get_idmap_req(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
2730         }
2731         if (flags & NDR_OUT) {
2732                 if (r->out.level == NULL) {
2733                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2734                 }
2735                 NDR_CHECK(ndr_push_winbind_get_idmap_level(ndr, NDR_SCALARS, *r->out.level));
2736                 if (r->out.rep == NULL) {
2737                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2738                 }
2739                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.rep, *r->out.level));
2740                 NDR_CHECK(ndr_push_winbind_get_idmap_rep(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rep));
2741                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
2742         }
2743         return NDR_ERR_SUCCESS;
2744 }
2745
2746 static enum ndr_err_code ndr_pull_winbind_get_idmap(struct ndr_pull *ndr, int flags, struct winbind_get_idmap *r)
2747 {
2748         TALLOC_CTX *_mem_save_level_0;
2749         TALLOC_CTX *_mem_save_rep_0;
2750         if (flags & NDR_IN) {
2751                 ZERO_STRUCT(r->out);
2752
2753                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2754                         NDR_PULL_ALLOC(ndr, r->in.level);
2755                 }
2756                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
2757                 NDR_PULL_SET_MEM_CTX(ndr, r->in.level, LIBNDR_FLAG_REF_ALLOC);
2758                 NDR_CHECK(ndr_pull_winbind_get_idmap_level(ndr, NDR_SCALARS, r->in.level));
2759                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
2760                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, *r->in.level));
2761                 NDR_CHECK(ndr_pull_winbind_get_idmap_req(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
2762                 NDR_PULL_ALLOC(ndr, r->out.level);
2763                 *r->out.level = *r->in.level;
2764                 NDR_PULL_ALLOC(ndr, r->out.rep);
2765                 ZERO_STRUCTP(r->out.rep);
2766         }
2767         if (flags & NDR_OUT) {
2768                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2769                         NDR_PULL_ALLOC(ndr, r->out.level);
2770                 }
2771                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
2772                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level, LIBNDR_FLAG_REF_ALLOC);
2773                 NDR_CHECK(ndr_pull_winbind_get_idmap_level(ndr, NDR_SCALARS, r->out.level));
2774                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
2775                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2776                         NDR_PULL_ALLOC(ndr, r->out.rep);
2777                 }
2778                 _mem_save_rep_0 = NDR_PULL_GET_MEM_CTX(ndr);
2779                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rep, LIBNDR_FLAG_REF_ALLOC);
2780                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.rep, *r->out.level));
2781                 NDR_CHECK(ndr_pull_winbind_get_idmap_rep(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rep));
2782                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rep_0, LIBNDR_FLAG_REF_ALLOC);
2783                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
2784         }
2785         return NDR_ERR_SUCCESS;
2786 }
2787
2788 _PUBLIC_ void ndr_print_winbind_get_idmap(struct ndr_print *ndr, const char *name, int flags, const struct winbind_get_idmap *r)
2789 {
2790         ndr_print_struct(ndr, name, "winbind_get_idmap");
2791         ndr->depth++;
2792         if (flags & NDR_SET_VALUES) {
2793                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2794         }
2795         if (flags & NDR_IN) {
2796                 ndr_print_struct(ndr, "in", "winbind_get_idmap");
2797                 ndr->depth++;
2798                 ndr_print_ptr(ndr, "level", r->in.level);
2799                 ndr->depth++;
2800                 ndr_print_winbind_get_idmap_level(ndr, "level", *r->in.level);
2801                 ndr->depth--;
2802                 ndr_print_set_switch_value(ndr, &r->in.req, *r->in.level);
2803                 ndr_print_winbind_get_idmap_req(ndr, "req", &r->in.req);
2804                 ndr->depth--;
2805         }
2806         if (flags & NDR_OUT) {
2807                 ndr_print_struct(ndr, "out", "winbind_get_idmap");
2808                 ndr->depth++;
2809                 ndr_print_ptr(ndr, "level", r->out.level);
2810                 ndr->depth++;
2811                 ndr_print_winbind_get_idmap_level(ndr, "level", *r->out.level);
2812                 ndr->depth--;
2813                 ndr_print_ptr(ndr, "rep", r->out.rep);
2814                 ndr->depth++;
2815                 ndr_print_set_switch_value(ndr, r->out.rep, *r->out.level);
2816                 ndr_print_winbind_get_idmap_rep(ndr, "rep", r->out.rep);
2817                 ndr->depth--;
2818                 ndr_print_winbind_status(ndr, "result", r->out.result);
2819                 ndr->depth--;
2820         }
2821         ndr->depth--;
2822 }
2823
2824 static enum ndr_err_code ndr_push_winbind_set_idmap(struct ndr_push *ndr, int flags, const struct winbind_set_idmap *r)
2825 {
2826         if (flags & NDR_IN) {
2827                 if (r->in.level == NULL) {
2828                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2829                 }
2830                 NDR_CHECK(ndr_push_winbind_set_idmap_level(ndr, NDR_SCALARS, *r->in.level));
2831                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, *r->in.level));
2832                 NDR_CHECK(ndr_push_winbind_set_idmap_req(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
2833         }
2834         if (flags & NDR_OUT) {
2835                 if (r->out.level == NULL) {
2836                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2837                 }
2838                 NDR_CHECK(ndr_push_winbind_set_idmap_level(ndr, NDR_SCALARS, *r->out.level));
2839                 if (r->out.rep == NULL) {
2840                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2841                 }
2842                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.rep, *r->out.level));
2843                 NDR_CHECK(ndr_push_winbind_set_idmap_rep(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rep));
2844                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
2845         }
2846         return NDR_ERR_SUCCESS;
2847 }
2848
2849 static enum ndr_err_code ndr_pull_winbind_set_idmap(struct ndr_pull *ndr, int flags, struct winbind_set_idmap *r)
2850 {
2851         TALLOC_CTX *_mem_save_level_0;
2852         TALLOC_CTX *_mem_save_rep_0;
2853         if (flags & NDR_IN) {
2854                 ZERO_STRUCT(r->out);
2855
2856                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2857                         NDR_PULL_ALLOC(ndr, r->in.level);
2858                 }
2859                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
2860                 NDR_PULL_SET_MEM_CTX(ndr, r->in.level, LIBNDR_FLAG_REF_ALLOC);
2861                 NDR_CHECK(ndr_pull_winbind_set_idmap_level(ndr, NDR_SCALARS, r->in.level));
2862                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
2863                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, *r->in.level));
2864                 NDR_CHECK(ndr_pull_winbind_set_idmap_req(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
2865                 NDR_PULL_ALLOC(ndr, r->out.level);
2866                 *r->out.level = *r->in.level;
2867                 NDR_PULL_ALLOC(ndr, r->out.rep);
2868                 ZERO_STRUCTP(r->out.rep);
2869         }
2870         if (flags & NDR_OUT) {
2871                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2872                         NDR_PULL_ALLOC(ndr, r->out.level);
2873                 }
2874                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
2875                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level, LIBNDR_FLAG_REF_ALLOC);
2876                 NDR_CHECK(ndr_pull_winbind_set_idmap_level(ndr, NDR_SCALARS, r->out.level));
2877                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
2878                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2879                         NDR_PULL_ALLOC(ndr, r->out.rep);
2880                 }
2881                 _mem_save_rep_0 = NDR_PULL_GET_MEM_CTX(ndr);
2882                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rep, LIBNDR_FLAG_REF_ALLOC);
2883                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.rep, *r->out.level));
2884                 NDR_CHECK(ndr_pull_winbind_set_idmap_rep(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rep));
2885                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rep_0, LIBNDR_FLAG_REF_ALLOC);
2886                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
2887         }
2888         return NDR_ERR_SUCCESS;
2889 }
2890
2891 _PUBLIC_ void ndr_print_winbind_set_idmap(struct ndr_print *ndr, const char *name, int flags, const struct winbind_set_idmap *r)
2892 {
2893         ndr_print_struct(ndr, name, "winbind_set_idmap");
2894         ndr->depth++;
2895         if (flags & NDR_SET_VALUES) {
2896                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2897         }
2898         if (flags & NDR_IN) {
2899                 ndr_print_struct(ndr, "in", "winbind_set_idmap");
2900                 ndr->depth++;
2901                 ndr_print_ptr(ndr, "level", r->in.level);
2902                 ndr->depth++;
2903                 ndr_print_winbind_set_idmap_level(ndr, "level", *r->in.level);
2904                 ndr->depth--;
2905                 ndr_print_set_switch_value(ndr, &r->in.req, *r->in.level);
2906                 ndr_print_winbind_set_idmap_req(ndr, "req", &r->in.req);
2907                 ndr->depth--;
2908         }
2909         if (flags & NDR_OUT) {
2910                 ndr_print_struct(ndr, "out", "winbind_set_idmap");
2911                 ndr->depth++;
2912                 ndr_print_ptr(ndr, "level", r->out.level);
2913                 ndr->depth++;
2914                 ndr_print_winbind_set_idmap_level(ndr, "level", *r->out.level);
2915                 ndr->depth--;
2916                 ndr_print_ptr(ndr, "rep", r->out.rep);
2917                 ndr->depth++;
2918                 ndr_print_set_switch_value(ndr, r->out.rep, *r->out.level);
2919                 ndr_print_winbind_set_idmap_rep(ndr, "rep", r->out.rep);
2920                 ndr->depth--;
2921                 ndr_print_winbind_status(ndr, "result", r->out.result);
2922                 ndr->depth--;
2923         }
2924         ndr->depth--;
2925 }
2926
2927 static enum ndr_err_code ndr_push_winbind_check_machcc(struct ndr_push *ndr, int flags, const struct winbind_check_machcc *r)
2928 {
2929         if (flags & NDR_IN) {
2930         }
2931         if (flags & NDR_OUT) {
2932                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
2933         }
2934         return NDR_ERR_SUCCESS;
2935 }
2936
2937 static enum ndr_err_code ndr_pull_winbind_check_machcc(struct ndr_pull *ndr, int flags, struct winbind_check_machcc *r)
2938 {
2939         if (flags & NDR_IN) {
2940         }
2941         if (flags & NDR_OUT) {
2942                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
2943         }
2944         return NDR_ERR_SUCCESS;
2945 }
2946
2947 _PUBLIC_ void ndr_print_winbind_check_machcc(struct ndr_print *ndr, const char *name, int flags, const struct winbind_check_machcc *r)
2948 {
2949         ndr_print_struct(ndr, name, "winbind_check_machcc");
2950         ndr->depth++;
2951         if (flags & NDR_SET_VALUES) {
2952                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2953         }
2954         if (flags & NDR_IN) {
2955                 ndr_print_struct(ndr, "in", "winbind_check_machcc");
2956                 ndr->depth++;
2957                 ndr->depth--;
2958         }
2959         if (flags & NDR_OUT) {
2960                 ndr_print_struct(ndr, "out", "winbind_check_machcc");
2961                 ndr->depth++;
2962                 ndr_print_winbind_status(ndr, "result", r->out.result);
2963                 ndr->depth--;
2964         }
2965         ndr->depth--;
2966 }
2967
2968 static enum ndr_err_code ndr_push_winbind_info_fixname(struct ndr_push *ndr, int flags, const struct winbind_info_fixname *r)
2969 {
2970         if (flags & NDR_IN) {
2971         }
2972         if (flags & NDR_OUT) {
2973                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
2974         }
2975         return NDR_ERR_SUCCESS;
2976 }
2977
2978 static enum ndr_err_code ndr_pull_winbind_info_fixname(struct ndr_pull *ndr, int flags, struct winbind_info_fixname *r)
2979 {
2980         if (flags & NDR_IN) {
2981         }
2982         if (flags & NDR_OUT) {
2983                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
2984         }
2985         return NDR_ERR_SUCCESS;
2986 }
2987
2988 _PUBLIC_ void ndr_print_winbind_info_fixname(struct ndr_print *ndr, const char *name, int flags, const struct winbind_info_fixname *r)
2989 {
2990         ndr_print_struct(ndr, name, "winbind_info_fixname");
2991         ndr->depth++;
2992         if (flags & NDR_SET_VALUES) {
2993                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2994         }
2995         if (flags & NDR_IN) {
2996                 ndr_print_struct(ndr, "in", "winbind_info_fixname");
2997                 ndr->depth++;
2998                 ndr->depth--;
2999         }
3000         if (flags & NDR_OUT) {
3001                 ndr_print_struct(ndr, "out", "winbind_info_fixname");
3002                 ndr->depth++;
3003                 ndr_print_winbind_status(ndr, "result", r->out.result);
3004                 ndr->depth--;
3005         }
3006         ndr->depth--;
3007 }
3008
3009 static enum ndr_err_code ndr_push_winbind_domain_name(struct ndr_push *ndr, int flags, const struct winbind_domain_name *r)
3010 {
3011         if (flags & NDR_IN) {
3012         }
3013         if (flags & NDR_OUT) {
3014                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
3015         }
3016         return NDR_ERR_SUCCESS;
3017 }
3018
3019 static enum ndr_err_code ndr_pull_winbind_domain_name(struct ndr_pull *ndr, int flags, struct winbind_domain_name *r)
3020 {
3021         if (flags & NDR_IN) {
3022         }
3023         if (flags & NDR_OUT) {
3024                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
3025         }
3026         return NDR_ERR_SUCCESS;
3027 }
3028
3029 _PUBLIC_ void ndr_print_winbind_domain_name(struct ndr_print *ndr, const char *name, int flags, const struct winbind_domain_name *r)
3030 {
3031         ndr_print_struct(ndr, name, "winbind_domain_name");
3032         ndr->depth++;
3033         if (flags & NDR_SET_VALUES) {
3034                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3035         }
3036         if (flags & NDR_IN) {
3037                 ndr_print_struct(ndr, "in", "winbind_domain_name");
3038                 ndr->depth++;
3039                 ndr->depth--;
3040         }
3041         if (flags & NDR_OUT) {
3042                 ndr_print_struct(ndr, "out", "winbind_domain_name");
3043                 ndr->depth++;
3044                 ndr_print_winbind_status(ndr, "result", r->out.result);
3045                 ndr->depth--;
3046         }
3047         ndr->depth--;
3048 }
3049
3050 static enum ndr_err_code ndr_push_winbind_get_domain_info(struct ndr_push *ndr, int flags, const struct winbind_get_domain_info *r)
3051 {
3052         if (flags & NDR_IN) {
3053                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF8)));
3054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3055                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF8)));
3056                 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));
3057                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dc_name));
3058                 if (r->in.dc_name) {
3059                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dc_name, CH_UTF8)));
3060                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3061                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dc_name, CH_UTF8)));
3062                         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));
3063                 }
3064                 if (r->in.level == NULL) {
3065                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3066                 }
3067                 NDR_CHECK(ndr_push_winbind_domain_info_level(ndr, NDR_SCALARS, *r->in.level));
3068         }
3069         if (flags & NDR_OUT) {
3070                 if (r->out.level == NULL) {
3071                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3072                 }
3073                 NDR_CHECK(ndr_push_winbind_domain_info_level(ndr, NDR_SCALARS, *r->out.level));
3074                 if (r->out.domain_info == NULL) {
3075                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3076                 }
3077                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.domain_info, *r->out.level));
3078                 NDR_CHECK(ndr_push_winbind_domain_info(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domain_info));
3079                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
3080         }
3081         return NDR_ERR_SUCCESS;
3082 }
3083
3084 static enum ndr_err_code ndr_pull_winbind_get_domain_info(struct ndr_pull *ndr, int flags, struct winbind_get_domain_info *r)
3085 {
3086         uint32_t _ptr_dc_name;
3087         TALLOC_CTX *_mem_save_dc_name_0;
3088         TALLOC_CTX *_mem_save_level_0;
3089         TALLOC_CTX *_mem_save_domain_info_0;
3090         if (flags & NDR_IN) {
3091                 ZERO_STRUCT(r->out);
3092
3093                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
3094                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
3095                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
3096                         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));
3097                 }
3098                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint8_t)));
3099                 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));
3100                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dc_name));
3101                 if (_ptr_dc_name) {
3102                         NDR_PULL_ALLOC(ndr, r->in.dc_name);
3103                 } else {
3104                         r->in.dc_name = NULL;
3105                 }
3106                 if (r->in.dc_name) {
3107                         _mem_save_dc_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3108                         NDR_PULL_SET_MEM_CTX(ndr, r->in.dc_name, 0);
3109                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dc_name));
3110                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dc_name));
3111                         if (ndr_get_array_length(ndr, &r->in.dc_name) > ndr_get_array_size(ndr, &r->in.dc_name)) {
3112                                 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));
3113                         }
3114                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dc_name), sizeof(uint8_t)));
3115                         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));
3116                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dc_name_0, 0);
3117                 }
3118                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3119                         NDR_PULL_ALLOC(ndr, r->in.level);
3120                 }
3121                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
3122                 NDR_PULL_SET_MEM_CTX(ndr, r->in.level, LIBNDR_FLAG_REF_ALLOC);
3123                 NDR_CHECK(ndr_pull_winbind_domain_info_level(ndr, NDR_SCALARS, r->in.level));
3124                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
3125                 NDR_PULL_ALLOC(ndr, r->out.level);
3126                 *r->out.level = *r->in.level;
3127                 NDR_PULL_ALLOC(ndr, r->out.domain_info);
3128                 ZERO_STRUCTP(r->out.domain_info);
3129         }
3130         if (flags & NDR_OUT) {
3131                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3132                         NDR_PULL_ALLOC(ndr, r->out.level);
3133                 }
3134                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
3135                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level, LIBNDR_FLAG_REF_ALLOC);
3136                 NDR_CHECK(ndr_pull_winbind_domain_info_level(ndr, NDR_SCALARS, r->out.level));
3137                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
3138                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3139                         NDR_PULL_ALLOC(ndr, r->out.domain_info);
3140                 }
3141                 _mem_save_domain_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
3142                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domain_info, LIBNDR_FLAG_REF_ALLOC);
3143                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.domain_info, *r->out.level));
3144                 NDR_CHECK(ndr_pull_winbind_domain_info(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domain_info));
3145                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_info_0, LIBNDR_FLAG_REF_ALLOC);
3146                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
3147         }
3148         return NDR_ERR_SUCCESS;
3149 }
3150
3151 _PUBLIC_ void ndr_print_winbind_get_domain_info(struct ndr_print *ndr, const char *name, int flags, const struct winbind_get_domain_info *r)
3152 {
3153         ndr_print_struct(ndr, name, "winbind_get_domain_info");
3154         ndr->depth++;
3155         if (flags & NDR_SET_VALUES) {
3156                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3157         }
3158         if (flags & NDR_IN) {
3159                 ndr_print_struct(ndr, "in", "winbind_get_domain_info");
3160                 ndr->depth++;
3161                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
3162                 ndr_print_ptr(ndr, "dc_name", r->in.dc_name);
3163                 ndr->depth++;
3164                 if (r->in.dc_name) {
3165                         ndr_print_string(ndr, "dc_name", r->in.dc_name);
3166                 }
3167                 ndr->depth--;
3168                 ndr_print_ptr(ndr, "level", r->in.level);
3169                 ndr->depth++;
3170                 ndr_print_winbind_domain_info_level(ndr, "level", *r->in.level);
3171                 ndr->depth--;
3172                 ndr->depth--;
3173         }
3174         if (flags & NDR_OUT) {
3175                 ndr_print_struct(ndr, "out", "winbind_get_domain_info");
3176                 ndr->depth++;
3177                 ndr_print_ptr(ndr, "level", r->out.level);
3178                 ndr->depth++;
3179                 ndr_print_winbind_domain_info_level(ndr, "level", *r->out.level);
3180                 ndr->depth--;
3181                 ndr_print_ptr(ndr, "domain_info", r->out.domain_info);
3182                 ndr->depth++;
3183                 ndr_print_set_switch_value(ndr, r->out.domain_info, *r->out.level);
3184                 ndr_print_winbind_domain_info(ndr, "domain_info", r->out.domain_info);
3185                 ndr->depth--;
3186                 ndr_print_winbind_status(ndr, "result", r->out.result);
3187                 ndr->depth--;
3188         }
3189         ndr->depth--;
3190 }
3191
3192 static enum ndr_err_code ndr_push_winbind_get_dc_info(struct ndr_push *ndr, int flags, const struct winbind_get_dc_info *r)
3193 {
3194         if (flags & NDR_IN) {
3195                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF8)));
3196                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3197                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF8)));
3198                 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));
3199                 if (r->in.level == NULL) {
3200                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3201                 }
3202                 NDR_CHECK(ndr_push_winbind_dc_info_level(ndr, NDR_SCALARS, *r->in.level));
3203                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.params, *r->in.level));
3204                 NDR_CHECK(ndr_push_winbind_dc_info_params(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.params));
3205         }
3206         if (flags & NDR_OUT) {
3207                 if (r->out.level == NULL) {
3208                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3209                 }
3210                 NDR_CHECK(ndr_push_winbind_dc_info_level(ndr, NDR_SCALARS, *r->out.level));
3211                 if (r->out.dc_info == NULL) {
3212                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3213                 }
3214                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.dc_info, *r->out.level));
3215                 NDR_CHECK(ndr_push_winbind_dc_info(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.dc_info));
3216                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
3217         }
3218         return NDR_ERR_SUCCESS;
3219 }
3220
3221 static enum ndr_err_code ndr_pull_winbind_get_dc_info(struct ndr_pull *ndr, int flags, struct winbind_get_dc_info *r)
3222 {
3223         TALLOC_CTX *_mem_save_level_0;
3224         TALLOC_CTX *_mem_save_dc_info_0;
3225         if (flags & NDR_IN) {
3226                 ZERO_STRUCT(r->out);
3227
3228                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
3229                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
3230                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
3231                         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));
3232                 }
3233                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint8_t)));
3234                 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));
3235                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3236                         NDR_PULL_ALLOC(ndr, r->in.level);
3237                 }
3238                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
3239                 NDR_PULL_SET_MEM_CTX(ndr, r->in.level, LIBNDR_FLAG_REF_ALLOC);
3240                 NDR_CHECK(ndr_pull_winbind_dc_info_level(ndr, NDR_SCALARS, r->in.level));
3241                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
3242                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.params, *r->in.level));
3243                 NDR_CHECK(ndr_pull_winbind_dc_info_params(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.params));
3244                 NDR_PULL_ALLOC(ndr, r->out.level);
3245                 *r->out.level = *r->in.level;
3246                 NDR_PULL_ALLOC(ndr, r->out.dc_info);
3247                 ZERO_STRUCTP(r->out.dc_info);
3248         }
3249         if (flags & NDR_OUT) {
3250                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3251                         NDR_PULL_ALLOC(ndr, r->out.level);
3252                 }
3253                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
3254                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level, LIBNDR_FLAG_REF_ALLOC);
3255                 NDR_CHECK(ndr_pull_winbind_dc_info_level(ndr, NDR_SCALARS, r->out.level));
3256                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
3257                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3258                         NDR_PULL_ALLOC(ndr, r->out.dc_info);
3259                 }
3260                 _mem_save_dc_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
3261                 NDR_PULL_SET_MEM_CTX(ndr, r->out.dc_info, LIBNDR_FLAG_REF_ALLOC);
3262                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.dc_info, *r->out.level));
3263                 NDR_CHECK(ndr_pull_winbind_dc_info(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.dc_info));
3264                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dc_info_0, LIBNDR_FLAG_REF_ALLOC);
3265                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
3266         }
3267         return NDR_ERR_SUCCESS;
3268 }
3269
3270 _PUBLIC_ void ndr_print_winbind_get_dc_info(struct ndr_print *ndr, const char *name, int flags, const struct winbind_get_dc_info *r)
3271 {
3272         ndr_print_struct(ndr, name, "winbind_get_dc_info");
3273         ndr->depth++;
3274         if (flags & NDR_SET_VALUES) {
3275                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3276         }
3277         if (flags & NDR_IN) {
3278                 ndr_print_struct(ndr, "in", "winbind_get_dc_info");
3279                 ndr->depth++;
3280                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
3281                 ndr_print_ptr(ndr, "level", r->in.level);
3282                 ndr->depth++;
3283                 ndr_print_winbind_dc_info_level(ndr, "level", *r->in.level);
3284                 ndr->depth--;
3285                 ndr_print_set_switch_value(ndr, &r->in.params, *r->in.level);
3286                 ndr_print_winbind_dc_info_params(ndr, "params", &r->in.params);
3287                 ndr->depth--;
3288         }
3289         if (flags & NDR_OUT) {
3290                 ndr_print_struct(ndr, "out", "winbind_get_dc_info");
3291                 ndr->depth++;
3292                 ndr_print_ptr(ndr, "level", r->out.level);
3293                 ndr->depth++;
3294                 ndr_print_winbind_dc_info_level(ndr, "level", *r->out.level);
3295                 ndr->depth--;
3296                 ndr_print_ptr(ndr, "dc_info", r->out.dc_info);
3297                 ndr->depth++;
3298                 ndr_print_set_switch_value(ndr, r->out.dc_info, *r->out.level);
3299                 ndr_print_winbind_dc_info(ndr, "dc_info", r->out.dc_info);
3300                 ndr->depth--;
3301                 ndr_print_winbind_status(ndr, "result", r->out.result);
3302                 ndr->depth--;
3303         }
3304         ndr->depth--;
3305 }
3306
3307 static enum ndr_err_code ndr_push_winbind_wins_byip(struct ndr_push *ndr, int flags, const struct winbind_wins_byip *r)
3308 {
3309         if (flags & NDR_IN) {
3310         }
3311         if (flags & NDR_OUT) {
3312                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
3313         }
3314         return NDR_ERR_SUCCESS;
3315 }
3316
3317 static enum ndr_err_code ndr_pull_winbind_wins_byip(struct ndr_pull *ndr, int flags, struct winbind_wins_byip *r)
3318 {
3319         if (flags & NDR_IN) {
3320         }
3321         if (flags & NDR_OUT) {
3322                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
3323         }
3324         return NDR_ERR_SUCCESS;
3325 }
3326
3327 _PUBLIC_ void ndr_print_winbind_wins_byip(struct ndr_print *ndr, const char *name, int flags, const struct winbind_wins_byip *r)
3328 {
3329         ndr_print_struct(ndr, name, "winbind_wins_byip");
3330         ndr->depth++;
3331         if (flags & NDR_SET_VALUES) {
3332                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3333         }
3334         if (flags & NDR_IN) {
3335                 ndr_print_struct(ndr, "in", "winbind_wins_byip");
3336                 ndr->depth++;
3337                 ndr->depth--;
3338         }
3339         if (flags & NDR_OUT) {
3340                 ndr_print_struct(ndr, "out", "winbind_wins_byip");
3341                 ndr->depth++;
3342                 ndr_print_winbind_status(ndr, "result", r->out.result);
3343                 ndr->depth--;
3344         }
3345         ndr->depth--;
3346 }
3347
3348 static enum ndr_err_code ndr_push_winbind_wins_byname(struct ndr_push *ndr, int flags, const struct winbind_wins_byname *r)
3349 {
3350         if (flags & NDR_IN) {
3351         }
3352         if (flags & NDR_OUT) {
3353                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
3354         }
3355         return NDR_ERR_SUCCESS;
3356 }
3357
3358 static enum ndr_err_code ndr_pull_winbind_wins_byname(struct ndr_pull *ndr, int flags, struct winbind_wins_byname *r)
3359 {
3360         if (flags & NDR_IN) {
3361         }
3362         if (flags & NDR_OUT) {
3363                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
3364         }
3365         return NDR_ERR_SUCCESS;
3366 }
3367
3368 _PUBLIC_ void ndr_print_winbind_wins_byname(struct ndr_print *ndr, const char *name, int flags, const struct winbind_wins_byname *r)
3369 {
3370         ndr_print_struct(ndr, name, "winbind_wins_byname");
3371         ndr->depth++;
3372         if (flags & NDR_SET_VALUES) {
3373                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3374         }
3375         if (flags & NDR_IN) {
3376                 ndr_print_struct(ndr, "in", "winbind_wins_byname");
3377                 ndr->depth++;
3378                 ndr->depth--;
3379         }
3380         if (flags & NDR_OUT) {
3381                 ndr_print_struct(ndr, "out", "winbind_wins_byname");
3382                 ndr->depth++;
3383                 ndr_print_winbind_status(ndr, "result", r->out.result);
3384                 ndr->depth--;
3385         }
3386         ndr->depth--;
3387 }
3388
3389 static enum ndr_err_code ndr_push_winbind_getgrlist(struct ndr_push *ndr, int flags, const struct winbind_getgrlist *r)
3390 {
3391         if (flags & NDR_IN) {
3392         }
3393         if (flags & NDR_OUT) {
3394                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
3395         }
3396         return NDR_ERR_SUCCESS;
3397 }
3398
3399 static enum ndr_err_code ndr_pull_winbind_getgrlist(struct ndr_pull *ndr, int flags, struct winbind_getgrlist *r)
3400 {
3401         if (flags & NDR_IN) {
3402         }
3403         if (flags & NDR_OUT) {
3404                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
3405         }
3406         return NDR_ERR_SUCCESS;
3407 }
3408
3409 _PUBLIC_ void ndr_print_winbind_getgrlist(struct ndr_print *ndr, const char *name, int flags, const struct winbind_getgrlist *r)
3410 {
3411         ndr_print_struct(ndr, name, "winbind_getgrlist");
3412         ndr->depth++;
3413         if (flags & NDR_SET_VALUES) {
3414                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3415         }
3416         if (flags & NDR_IN) {
3417                 ndr_print_struct(ndr, "in", "winbind_getgrlist");
3418                 ndr->depth++;
3419                 ndr->depth--;
3420         }
3421         if (flags & NDR_OUT) {
3422                 ndr_print_struct(ndr, "out", "winbind_getgrlist");
3423                 ndr->depth++;
3424                 ndr_print_winbind_status(ndr, "result", r->out.result);
3425                 ndr->depth--;
3426         }
3427         ndr->depth--;
3428 }
3429
3430 static enum ndr_err_code ndr_push_winbind_netbios_name(struct ndr_push *ndr, int flags, const struct winbind_netbios_name *r)
3431 {
3432         if (flags & NDR_IN) {
3433         }
3434         if (flags & NDR_OUT) {
3435                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
3436         }
3437         return NDR_ERR_SUCCESS;
3438 }
3439
3440 static enum ndr_err_code ndr_pull_winbind_netbios_name(struct ndr_pull *ndr, int flags, struct winbind_netbios_name *r)
3441 {
3442         if (flags & NDR_IN) {
3443         }
3444         if (flags & NDR_OUT) {
3445                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
3446         }
3447         return NDR_ERR_SUCCESS;
3448 }
3449
3450 _PUBLIC_ void ndr_print_winbind_netbios_name(struct ndr_print *ndr, const char *name, int flags, const struct winbind_netbios_name *r)
3451 {
3452         ndr_print_struct(ndr, name, "winbind_netbios_name");
3453         ndr->depth++;
3454         if (flags & NDR_SET_VALUES) {
3455                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3456         }
3457         if (flags & NDR_IN) {
3458                 ndr_print_struct(ndr, "in", "winbind_netbios_name");
3459                 ndr->depth++;
3460                 ndr->depth--;
3461         }
3462         if (flags & NDR_OUT) {
3463                 ndr_print_struct(ndr, "out", "winbind_netbios_name");
3464                 ndr->depth++;
3465                 ndr_print_winbind_status(ndr, "result", r->out.result);
3466                 ndr->depth--;
3467         }
3468         ndr->depth--;
3469 }
3470
3471 static enum ndr_err_code ndr_push_winbind_getusersids(struct ndr_push *ndr, int flags, const struct winbind_getusersids *r)
3472 {
3473         if (flags & NDR_IN) {
3474         }
3475         if (flags & NDR_OUT) {
3476                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
3477         }
3478         return NDR_ERR_SUCCESS;
3479 }
3480
3481 static enum ndr_err_code ndr_pull_winbind_getusersids(struct ndr_pull *ndr, int flags, struct winbind_getusersids *r)
3482 {
3483         if (flags & NDR_IN) {
3484         }
3485         if (flags & NDR_OUT) {
3486                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
3487         }
3488         return NDR_ERR_SUCCESS;
3489 }
3490
3491 _PUBLIC_ void ndr_print_winbind_getusersids(struct ndr_print *ndr, const char *name, int flags, const struct winbind_getusersids *r)
3492 {
3493         ndr_print_struct(ndr, name, "winbind_getusersids");
3494         ndr->depth++;
3495         if (flags & NDR_SET_VALUES) {
3496                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3497         }
3498         if (flags & NDR_IN) {
3499                 ndr_print_struct(ndr, "in", "winbind_getusersids");
3500                 ndr->depth++;
3501                 ndr->depth--;
3502         }
3503         if (flags & NDR_OUT) {
3504                 ndr_print_struct(ndr, "out", "winbind_getusersids");
3505                 ndr->depth++;
3506                 ndr_print_winbind_status(ndr, "result", r->out.result);
3507                 ndr->depth--;
3508         }
3509         ndr->depth--;
3510 }
3511
3512 static enum ndr_err_code ndr_push_winbind_getuserdomgroups(struct ndr_push *ndr, int flags, const struct winbind_getuserdomgroups *r)
3513 {
3514         if (flags & NDR_IN) {
3515         }
3516         if (flags & NDR_OUT) {
3517                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
3518         }
3519         return NDR_ERR_SUCCESS;
3520 }
3521
3522 static enum ndr_err_code ndr_pull_winbind_getuserdomgroups(struct ndr_pull *ndr, int flags, struct winbind_getuserdomgroups *r)
3523 {
3524         if (flags & NDR_IN) {
3525         }
3526         if (flags & NDR_OUT) {
3527                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
3528         }
3529         return NDR_ERR_SUCCESS;
3530 }
3531
3532 _PUBLIC_ void ndr_print_winbind_getuserdomgroups(struct ndr_print *ndr, const char *name, int flags, const struct winbind_getuserdomgroups *r)
3533 {
3534         ndr_print_struct(ndr, name, "winbind_getuserdomgroups");
3535         ndr->depth++;
3536         if (flags & NDR_SET_VALUES) {
3537                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3538         }
3539         if (flags & NDR_IN) {
3540                 ndr_print_struct(ndr, "in", "winbind_getuserdomgroups");
3541                 ndr->depth++;
3542                 ndr->depth--;
3543         }
3544         if (flags & NDR_OUT) {
3545                 ndr_print_struct(ndr, "out", "winbind_getuserdomgroups");
3546                 ndr->depth++;
3547                 ndr_print_winbind_status(ndr, "result", r->out.result);
3548                 ndr->depth--;
3549         }
3550         ndr->depth--;
3551 }
3552
3553 static enum ndr_err_code ndr_push_winbind_dual_userinfo(struct ndr_push *ndr, int flags, const struct winbind_dual_userinfo *r)
3554 {
3555         if (flags & NDR_IN) {
3556         }
3557         if (flags & NDR_OUT) {
3558                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
3559         }
3560         return NDR_ERR_SUCCESS;
3561 }
3562
3563 static enum ndr_err_code ndr_pull_winbind_dual_userinfo(struct ndr_pull *ndr, int flags, struct winbind_dual_userinfo *r)
3564 {
3565         if (flags & NDR_IN) {
3566         }
3567         if (flags & NDR_OUT) {
3568                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
3569         }
3570         return NDR_ERR_SUCCESS;
3571 }
3572
3573 _PUBLIC_ void ndr_print_winbind_dual_userinfo(struct ndr_print *ndr, const char *name, int flags, const struct winbind_dual_userinfo *r)
3574 {
3575         ndr_print_struct(ndr, name, "winbind_dual_userinfo");
3576         ndr->depth++;
3577         if (flags & NDR_SET_VALUES) {
3578                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3579         }
3580         if (flags & NDR_IN) {
3581                 ndr_print_struct(ndr, "in", "winbind_dual_userinfo");
3582                 ndr->depth++;
3583                 ndr->depth--;
3584         }
3585         if (flags & NDR_OUT) {
3586                 ndr_print_struct(ndr, "out", "winbind_dual_userinfo");
3587                 ndr->depth++;
3588                 ndr_print_winbind_status(ndr, "result", r->out.result);
3589                 ndr->depth--;
3590         }
3591         ndr->depth--;
3592 }
3593
3594 static enum ndr_err_code ndr_push_winbind_dual_getsidaliases(struct ndr_push *ndr, int flags, const struct winbind_dual_getsidaliases *r)
3595 {
3596         if (flags & NDR_IN) {
3597         }
3598         if (flags & NDR_OUT) {
3599                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
3600         }
3601         return NDR_ERR_SUCCESS;
3602 }
3603
3604 static enum ndr_err_code ndr_pull_winbind_dual_getsidaliases(struct ndr_pull *ndr, int flags, struct winbind_dual_getsidaliases *r)
3605 {
3606         if (flags & NDR_IN) {
3607         }
3608         if (flags & NDR_OUT) {
3609                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
3610         }
3611         return NDR_ERR_SUCCESS;
3612 }
3613
3614 _PUBLIC_ void ndr_print_winbind_dual_getsidaliases(struct ndr_print *ndr, const char *name, int flags, const struct winbind_dual_getsidaliases *r)
3615 {
3616         ndr_print_struct(ndr, name, "winbind_dual_getsidaliases");
3617         ndr->depth++;
3618         if (flags & NDR_SET_VALUES) {
3619                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3620         }
3621         if (flags & NDR_IN) {
3622                 ndr_print_struct(ndr, "in", "winbind_dual_getsidaliases");
3623                 ndr->depth++;
3624                 ndr->depth--;
3625         }
3626         if (flags & NDR_OUT) {
3627                 ndr_print_struct(ndr, "out", "winbind_dual_getsidaliases");
3628                 ndr->depth++;
3629                 ndr_print_winbind_status(ndr, "result", r->out.result);
3630                 ndr->depth--;
3631         }
3632         ndr->depth--;
3633 }
3634
3635 static enum ndr_err_code ndr_push_winbind_ccache_ntlmauth(struct ndr_push *ndr, int flags, const struct winbind_ccache_ntlmauth *r)
3636 {
3637         if (flags & NDR_IN) {
3638         }
3639         if (flags & NDR_OUT) {
3640                 NDR_CHECK(ndr_push_winbind_status(ndr, NDR_SCALARS, r->out.result));
3641         }
3642         return NDR_ERR_SUCCESS;
3643 }
3644
3645 static enum ndr_err_code ndr_pull_winbind_ccache_ntlmauth(struct ndr_pull *ndr, int flags, struct winbind_ccache_ntlmauth *r)
3646 {
3647         if (flags & NDR_IN) {
3648         }
3649         if (flags & NDR_OUT) {
3650                 NDR_CHECK(ndr_pull_winbind_status(ndr, NDR_SCALARS, &r->out.result));
3651         }
3652         return NDR_ERR_SUCCESS;
3653 }
3654
3655 _PUBLIC_ void ndr_print_winbind_ccache_ntlmauth(struct ndr_print *ndr, const char *name, int flags, const struct winbind_ccache_ntlmauth *r)
3656 {
3657         ndr_print_struct(ndr, name, "winbind_ccache_ntlmauth");
3658         ndr->depth++;
3659         if (flags & NDR_SET_VALUES) {
3660                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3661         }
3662         if (flags & NDR_IN) {
3663                 ndr_print_struct(ndr, "in", "winbind_ccache_ntlmauth");
3664                 ndr->depth++;
3665                 ndr->depth--;
3666         }
3667         if (flags & NDR_OUT) {
3668                 ndr_print_struct(ndr, "out", "winbind_ccache_ntlmauth");
3669                 ndr->depth++;
3670                 ndr_print_winbind_status(ndr, "result", r->out.result);
3671                 ndr->depth--;
3672         }
3673         ndr->depth--;
3674 }
3675
3676 static const struct ndr_interface_call winbind_protocol_calls[] = {
3677         {
3678                 "winbind_ping",
3679                 sizeof(struct winbind_ping),
3680                 (ndr_push_flags_fn_t) ndr_push_winbind_ping,
3681                 (ndr_pull_flags_fn_t) ndr_pull_winbind_ping,
3682                 (ndr_print_function_t) ndr_print_winbind_ping,
3683                 false,
3684         },
3685         {
3686                 "winbind_interface_details",
3687                 sizeof(struct winbind_interface_details),
3688                 (ndr_push_flags_fn_t) ndr_push_winbind_interface_details,
3689                 (ndr_pull_flags_fn_t) ndr_pull_winbind_interface_details,
3690                 (ndr_print_function_t) ndr_print_winbind_interface_details,
3691                 false,
3692         },
3693         {
3694                 "winbind_getpwnam",
3695                 sizeof(struct winbind_getpwnam),
3696                 (ndr_push_flags_fn_t) ndr_push_winbind_getpwnam,
3697                 (ndr_pull_flags_fn_t) ndr_pull_winbind_getpwnam,
3698                 (ndr_print_function_t) ndr_print_winbind_getpwnam,
3699                 false,
3700         },
3701         {
3702                 "winbind_getpwuid",
3703                 sizeof(struct winbind_getpwuid),
3704                 (ndr_push_flags_fn_t) ndr_push_winbind_getpwuid,
3705                 (ndr_pull_flags_fn_t) ndr_pull_winbind_getpwuid,
3706                 (ndr_print_function_t) ndr_print_winbind_getpwuid,
3707                 false,
3708         },
3709         {
3710                 "winbind_getgrnam",
3711                 sizeof(struct winbind_getgrnam),
3712                 (ndr_push_flags_fn_t) ndr_push_winbind_getgrnam,
3713                 (ndr_pull_flags_fn_t) ndr_pull_winbind_getgrnam,
3714                 (ndr_print_function_t) ndr_print_winbind_getgrnam,
3715                 false,
3716         },
3717         {
3718                 "winbind_getgrgid",
3719                 sizeof(struct winbind_getgrgid),
3720                 (ndr_push_flags_fn_t) ndr_push_winbind_getgrgid,
3721                 (ndr_pull_flags_fn_t) ndr_pull_winbind_getgrgid,
3722                 (ndr_print_function_t) ndr_print_winbind_getgrgid,
3723                 false,
3724         },
3725         {
3726                 "winbind_getgroups",
3727                 sizeof(struct winbind_getgroups),
3728                 (ndr_push_flags_fn_t) ndr_push_winbind_getgroups,
3729                 (ndr_pull_flags_fn_t) ndr_pull_winbind_getgroups,
3730                 (ndr_print_function_t) ndr_print_winbind_getgroups,
3731                 false,
3732         },
3733         {
3734                 "winbind_setpwent",
3735                 sizeof(struct winbind_setpwent),
3736                 (ndr_push_flags_fn_t) ndr_push_winbind_setpwent,
3737                 (ndr_pull_flags_fn_t) ndr_pull_winbind_setpwent,
3738                 (ndr_print_function_t) ndr_print_winbind_setpwent,
3739                 false,
3740         },
3741         {
3742                 "winbind_endpwent",
3743                 sizeof(struct winbind_endpwent),
3744                 (ndr_push_flags_fn_t) ndr_push_winbind_endpwent,
3745                 (ndr_pull_flags_fn_t) ndr_pull_winbind_endpwent,
3746                 (ndr_print_function_t) ndr_print_winbind_endpwent,
3747                 false,
3748         },
3749         {
3750                 "winbind_getpwent",
3751                 sizeof(struct winbind_getpwent),
3752                 (ndr_push_flags_fn_t) ndr_push_winbind_getpwent,
3753                 (ndr_pull_flags_fn_t) ndr_pull_winbind_getpwent,
3754                 (ndr_print_function_t) ndr_print_winbind_getpwent,
3755                 false,
3756         },
3757         {
3758                 "winbind_setgrent",
3759                 sizeof(struct winbind_setgrent),
3760                 (ndr_push_flags_fn_t) ndr_push_winbind_setgrent,
3761                 (ndr_pull_flags_fn_t) ndr_pull_winbind_setgrent,
3762                 (ndr_print_function_t) ndr_print_winbind_setgrent,
3763                 false,
3764         },
3765         {
3766                 "winbind_endgrent",
3767                 sizeof(struct winbind_endgrent),
3768                 (ndr_push_flags_fn_t) ndr_push_winbind_endgrent,
3769                 (ndr_pull_flags_fn_t) ndr_pull_winbind_endgrent,
3770                 (ndr_print_function_t) ndr_print_winbind_endgrent,
3771                 false,
3772         },
3773         {
3774                 "winbind_getgrent",
3775                 sizeof(struct winbind_getgrent),
3776                 (ndr_push_flags_fn_t) ndr_push_winbind_getgrent,
3777                 (ndr_pull_flags_fn_t) ndr_pull_winbind_getgrent,
3778                 (ndr_print_function_t) ndr_print_winbind_getgrent,
3779                 false,
3780         },
3781         {
3782                 "winbind_pam_auth",
3783                 sizeof(struct winbind_pam_auth),
3784                 (ndr_push_flags_fn_t) ndr_push_winbind_pam_auth,
3785                 (ndr_pull_flags_fn_t) ndr_pull_winbind_pam_auth,
3786                 (ndr_print_function_t) ndr_print_winbind_pam_auth,
3787                 false,
3788         },
3789         {
3790                 "winbind_pam_auth_crap",
3791                 sizeof(struct winbind_pam_auth_crap),
3792                 (ndr_push_flags_fn_t) ndr_push_winbind_pam_auth_crap,
3793                 (ndr_pull_flags_fn_t) ndr_pull_winbind_pam_auth_crap,
3794                 (ndr_print_function_t) ndr_print_winbind_pam_auth_crap,
3795                 false,
3796         },
3797         {
3798                 "winbind_pam_chauthtok",
3799                 sizeof(struct winbind_pam_chauthtok),
3800                 (ndr_push_flags_fn_t) ndr_push_winbind_pam_chauthtok,
3801                 (ndr_pull_flags_fn_t) ndr_pull_winbind_pam_chauthtok,
3802                 (ndr_print_function_t) ndr_print_winbind_pam_chauthtok,
3803                 false,
3804         },
3805         {
3806                 "winbind_pam_logoff",
3807                 sizeof(struct winbind_pam_logoff),
3808                 (ndr_push_flags_fn_t) ndr_push_winbind_pam_logoff,
3809                 (ndr_pull_flags_fn_t) ndr_pull_winbind_pam_logoff,
3810                 (ndr_print_function_t) ndr_print_winbind_pam_logoff,
3811                 false,
3812         },
3813         {
3814                 "winbind_pam_chng_paswd_auth_crap",
3815                 sizeof(struct winbind_pam_chng_paswd_auth_crap),
3816                 (ndr_push_flags_fn_t) ndr_push_winbind_pam_chng_paswd_auth_crap,
3817                 (ndr_pull_flags_fn_t) ndr_pull_winbind_pam_chng_paswd_auth_crap,
3818                 (ndr_print_function_t) ndr_print_winbind_pam_chng_paswd_auth_crap,
3819                 false,
3820         },
3821         {
3822                 "winbind_list_users",
3823                 sizeof(struct winbind_list_users),
3824                 (ndr_push_flags_fn_t) ndr_push_winbind_list_users,
3825                 (ndr_pull_flags_fn_t) ndr_pull_winbind_list_users,
3826                 (ndr_print_function_t) ndr_print_winbind_list_users,
3827                 false,
3828         },
3829         {
3830                 "winbind_list_groups",
3831                 sizeof(struct winbind_list_groups),
3832                 (ndr_push_flags_fn_t) ndr_push_winbind_list_groups,
3833                 (ndr_pull_flags_fn_t) ndr_pull_winbind_list_groups,
3834                 (ndr_print_function_t) ndr_print_winbind_list_groups,
3835                 false,
3836         },
3837         {
3838                 "winbind_list_trustdom",
3839                 sizeof(struct winbind_list_trustdom),
3840                 (ndr_push_flags_fn_t) ndr_push_winbind_list_trustdom,
3841                 (ndr_pull_flags_fn_t) ndr_pull_winbind_list_trustdom,
3842                 (ndr_print_function_t) ndr_print_winbind_list_trustdom,
3843                 false,
3844         },
3845         {
3846                 "winbind_lookup",
3847                 sizeof(struct winbind_lookup),
3848                 (ndr_push_flags_fn_t) ndr_push_winbind_lookup,
3849                 (ndr_pull_flags_fn_t) ndr_pull_winbind_lookup,
3850                 (ndr_print_function_t) ndr_print_winbind_lookup,
3851                 false,
3852         },
3853         {
3854                 "winbind_get_idmap",
3855                 sizeof(struct winbind_get_idmap),
3856                 (ndr_push_flags_fn_t) ndr_push_winbind_get_idmap,
3857                 (ndr_pull_flags_fn_t) ndr_pull_winbind_get_idmap,
3858                 (ndr_print_function_t) ndr_print_winbind_get_idmap,
3859                 false,
3860         },
3861         {
3862                 "winbind_set_idmap",
3863                 sizeof(struct winbind_set_idmap),
3864                 (ndr_push_flags_fn_t) ndr_push_winbind_set_idmap,
3865                 (ndr_pull_flags_fn_t) ndr_pull_winbind_set_idmap,
3866                 (ndr_print_function_t) ndr_print_winbind_set_idmap,
3867                 false,
3868         },
3869         {
3870                 "winbind_check_machcc",
3871                 sizeof(struct winbind_check_machcc),
3872                 (ndr_push_flags_fn_t) ndr_push_winbind_check_machcc,
3873                 (ndr_pull_flags_fn_t) ndr_pull_winbind_check_machcc,
3874                 (ndr_print_function_t) ndr_print_winbind_check_machcc,
3875                 false,
3876         },
3877         {
3878                 "winbind_info_fixname",
3879                 sizeof(struct winbind_info_fixname),
3880                 (ndr_push_flags_fn_t) ndr_push_winbind_info_fixname,
3881                 (ndr_pull_flags_fn_t) ndr_pull_winbind_info_fixname,
3882                 (ndr_print_function_t) ndr_print_winbind_info_fixname,
3883                 false,
3884         },
3885         {
3886                 "winbind_domain_name",
3887                 sizeof(struct winbind_domain_name),
3888                 (ndr_push_flags_fn_t) ndr_push_winbind_domain_name,
3889                 (ndr_pull_flags_fn_t) ndr_pull_winbind_domain_name,
3890                 (ndr_print_function_t) ndr_print_winbind_domain_name,
3891                 false,
3892         },
3893         {
3894                 "winbind_get_domain_info",
3895                 sizeof(struct winbind_get_domain_info),
3896                 (ndr_push_flags_fn_t) ndr_push_winbind_get_domain_info,
3897                 (ndr_pull_flags_fn_t) ndr_pull_winbind_get_domain_info,
3898                 (ndr_print_function_t) ndr_print_winbind_get_domain_info,
3899                 false,
3900         },
3901         {
3902                 "winbind_get_dc_info",
3903                 sizeof(struct winbind_get_dc_info),
3904                 (ndr_push_flags_fn_t) ndr_push_winbind_get_dc_info,
3905                 (ndr_pull_flags_fn_t) ndr_pull_winbind_get_dc_info,
3906                 (ndr_print_function_t) ndr_print_winbind_get_dc_info,
3907                 false,
3908         },
3909         {
3910                 "winbind_wins_byip",
3911                 sizeof(struct winbind_wins_byip),
3912                 (ndr_push_flags_fn_t) ndr_push_winbind_wins_byip,
3913                 (ndr_pull_flags_fn_t) ndr_pull_winbind_wins_byip,
3914                 (ndr_print_function_t) ndr_print_winbind_wins_byip,
3915                 false,
3916         },
3917         {
3918                 "winbind_wins_byname",
3919                 sizeof(struct winbind_wins_byname),
3920                 (ndr_push_flags_fn_t) ndr_push_winbind_wins_byname,
3921                 (ndr_pull_flags_fn_t) ndr_pull_winbind_wins_byname,
3922                 (ndr_print_function_t) ndr_print_winbind_wins_byname,
3923                 false,
3924         },
3925         {
3926                 "winbind_getgrlist",
3927                 sizeof(struct winbind_getgrlist),
3928                 (ndr_push_flags_fn_t) ndr_push_winbind_getgrlist,
3929                 (ndr_pull_flags_fn_t) ndr_pull_winbind_getgrlist,
3930                 (ndr_print_function_t) ndr_print_winbind_getgrlist,
3931                 false,
3932         },
3933         {
3934                 "winbind_netbios_name",
3935                 sizeof(struct winbind_netbios_name),
3936                 (ndr_push_flags_fn_t) ndr_push_winbind_netbios_name,
3937                 (ndr_pull_flags_fn_t) ndr_pull_winbind_netbios_name,
3938                 (ndr_print_function_t) ndr_print_winbind_netbios_name,
3939                 false,
3940         },
3941         {
3942                 "winbind_getusersids",
3943                 sizeof(struct winbind_getusersids),
3944                 (ndr_push_flags_fn_t) ndr_push_winbind_getusersids,
3945                 (ndr_pull_flags_fn_t) ndr_pull_winbind_getusersids,
3946                 (ndr_print_function_t) ndr_print_winbind_getusersids,
3947                 false,
3948         },
3949         {
3950                 "winbind_getuserdomgroups",
3951                 sizeof(struct winbind_getuserdomgroups),
3952                 (ndr_push_flags_fn_t) ndr_push_winbind_getuserdomgroups,
3953                 (ndr_pull_flags_fn_t) ndr_pull_winbind_getuserdomgroups,
3954                 (ndr_print_function_t) ndr_print_winbind_getuserdomgroups,
3955                 false,
3956         },
3957         {
3958                 "winbind_dual_userinfo",
3959                 sizeof(struct winbind_dual_userinfo),
3960                 (ndr_push_flags_fn_t) ndr_push_winbind_dual_userinfo,
3961                 (ndr_pull_flags_fn_t) ndr_pull_winbind_dual_userinfo,
3962                 (ndr_print_function_t) ndr_print_winbind_dual_userinfo,
3963                 false,
3964         },
3965         {
3966                 "winbind_dual_getsidaliases",
3967                 sizeof(struct winbind_dual_getsidaliases),
3968                 (ndr_push_flags_fn_t) ndr_push_winbind_dual_getsidaliases,
3969                 (ndr_pull_flags_fn_t) ndr_pull_winbind_dual_getsidaliases,
3970                 (ndr_print_function_t) ndr_print_winbind_dual_getsidaliases,
3971                 false,
3972         },
3973         {
3974                 "winbind_ccache_ntlmauth",
3975                 sizeof(struct winbind_ccache_ntlmauth),
3976                 (ndr_push_flags_fn_t) ndr_push_winbind_ccache_ntlmauth,
3977                 (ndr_pull_flags_fn_t) ndr_pull_winbind_ccache_ntlmauth,
3978                 (ndr_print_function_t) ndr_print_winbind_ccache_ntlmauth,
3979                 false,
3980         },
3981         { NULL, 0, NULL, NULL, NULL, false }
3982 };
3983
3984 static const char * const winbind_protocol_endpoint_strings[] = {
3985         "ncacn_np:[\\pipe\\winbind_protocol]",
3986 };
3987
3988 static const struct ndr_interface_string_array winbind_protocol_endpoints = {
3989         .count  = 1,
3990         .names  = winbind_protocol_endpoint_strings
3991 };
3992
3993 static const char * const winbind_protocol_authservice_strings[] = {
3994         "host",
3995 };
3996
3997 static const struct ndr_interface_string_array winbind_protocol_authservices = {
3998         .count  = 1,
3999         .names  = winbind_protocol_authservice_strings
4000 };
4001
4002
4003 const struct ndr_interface_table ndr_table_winbind_protocol = {
4004         .name           = "winbind_protocol",
4005         .syntax_id      = {
4006                 {0xb6608c99,0x0407,0x401b,{0x96,0xd3},{0x7b,0xcd,0xa6,0x72,0x32,0xaf}},
4007                 NDR_WINBIND_PROTOCOL_VERSION
4008         },
4009         .helpstring     = NDR_WINBIND_PROTOCOL_HELPSTRING,
4010         .num_calls      = 38,
4011         .calls          = winbind_protocol_calls,
4012         .endpoints      = &winbind_protocol_endpoints,
4013         .authservices   = &winbind_protocol_authservices
4014 };
4015