source3/librpc/gen_ndr/ndr_wbint.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "librpc/gen_ndr/ndr_wbint.h"
   5
   6 #include "librpc/gen_ndr/ndr_lsa.h"
   7 _PUBLIC_ enum ndr_err_code ndr_push_wbint_userinfo(struct ndr_push *ndr, int ndr_flags, const struct wbint_userinfo *r)
   8 {
   9         if (ndr_flags & NDR_SCALARS) {
  10                 NDR_CHECK(ndr_push_align(ndr, 8));
  11                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->acct_name));
  12                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->full_name));
  13                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->homedir));
  14                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->shell));
  15                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->primary_gid));
  16                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->user_sid));
  17                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->group_sid));
  18         }
  19         if (ndr_flags & NDR_BUFFERS) {
  20                 if (r->acct_name) {
  21                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->acct_name, CH_UTF8)));
  22                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  23                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->acct_name, CH_UTF8)));
  24                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->acct_name, ndr_charset_length(r->acct_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
  25                 }
  26                 if (r->full_name) {
  27                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->full_name, CH_UTF8)));
  28                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  29                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->full_name, CH_UTF8)));
  30                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->full_name, ndr_charset_length(r->full_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
  31                 }
  32                 if (r->homedir) {
  33                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->homedir, CH_UTF8)));
  34                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  35                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->homedir, CH_UTF8)));
  36                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->homedir, ndr_charset_length(r->homedir, CH_UTF8), sizeof(uint8_t), CH_UTF8));
  37                 }
  38                 if (r->shell) {
  39                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->shell, CH_UTF8)));
  40                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  41                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->shell, CH_UTF8)));
  42                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->shell, ndr_charset_length(r->shell, CH_UTF8), sizeof(uint8_t), CH_UTF8));
  43                 }
  44         }
  45         return NDR_ERR_SUCCESS;
  46 }
  47
  48 _PUBLIC_ enum ndr_err_code ndr_pull_wbint_userinfo(struct ndr_pull *ndr, int ndr_flags, struct wbint_userinfo *r)
  49 {
  50         uint32_t _ptr_acct_name;
  51         TALLOC_CTX *_mem_save_acct_name_0;
  52         uint32_t _ptr_full_name;
  53         TALLOC_CTX *_mem_save_full_name_0;
  54         uint32_t _ptr_homedir;
  55         TALLOC_CTX *_mem_save_homedir_0;
  56         uint32_t _ptr_shell;
  57         TALLOC_CTX *_mem_save_shell_0;
  58         if (ndr_flags & NDR_SCALARS) {
  59                 NDR_CHECK(ndr_pull_align(ndr, 8));
  60                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_acct_name));
  61                 if (_ptr_acct_name) {
  62                         NDR_PULL_ALLOC(ndr, r->acct_name);
  63                 } else {
  64                         r->acct_name = NULL;
  65                 }
  66                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_full_name));
  67                 if (_ptr_full_name) {
  68                         NDR_PULL_ALLOC(ndr, r->full_name);
  69                 } else {
  70                         r->full_name = NULL;
  71                 }
  72                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_homedir));
  73                 if (_ptr_homedir) {
  74                         NDR_PULL_ALLOC(ndr, r->homedir);
  75                 } else {
  76                         r->homedir = NULL;
  77                 }
  78                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_shell));
  79                 if (_ptr_shell) {
  80                         NDR_PULL_ALLOC(ndr, r->shell);
  81                 } else {
  82                         r->shell = NULL;
  83                 }
  84                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->primary_gid));
  85                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, &r->user_sid));
  86                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, &r->group_sid));
  87         }
  88         if (ndr_flags & NDR_BUFFERS) {
  89                 if (r->acct_name) {
  90                         _mem_save_acct_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
  91                         NDR_PULL_SET_MEM_CTX(ndr, r->acct_name, 0);
  92                         NDR_CHECK(ndr_pull_array_size(ndr, &r->acct_name));
  93                         NDR_CHECK(ndr_pull_array_length(ndr, &r->acct_name));
  94                         if (ndr_get_array_length(ndr, &r->acct_name) > ndr_get_array_size(ndr, &r->acct_name)) {
  95                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->acct_name), ndr_get_array_length(ndr, &r->acct_name));
  96                         }
  97                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->acct_name), sizeof(uint8_t)));
  98                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->acct_name, ndr_get_array_length(ndr, &r->acct_name), sizeof(uint8_t), CH_UTF8));
  99                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_acct_name_0, 0);
 100                 }
 101                 if (r->full_name) {
 102                         _mem_save_full_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 103                         NDR_PULL_SET_MEM_CTX(ndr, r->full_name, 0);
 104                         NDR_CHECK(ndr_pull_array_size(ndr, &r->full_name));
 105                         NDR_CHECK(ndr_pull_array_length(ndr, &r->full_name));
 106                         if (ndr_get_array_length(ndr, &r->full_name) > ndr_get_array_size(ndr, &r->full_name)) {
 107                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->full_name), ndr_get_array_length(ndr, &r->full_name));
 108                         }
 109                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->full_name), sizeof(uint8_t)));
 110                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->full_name, ndr_get_array_length(ndr, &r->full_name), sizeof(uint8_t), CH_UTF8));
 111                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_full_name_0, 0);
 112                 }
 113                 if (r->homedir) {
 114                         _mem_save_homedir_0 = NDR_PULL_GET_MEM_CTX(ndr);
 115                         NDR_PULL_SET_MEM_CTX(ndr, r->homedir, 0);
 116                         NDR_CHECK(ndr_pull_array_size(ndr, &r->homedir));
 117                         NDR_CHECK(ndr_pull_array_length(ndr, &r->homedir));
 118                         if (ndr_get_array_length(ndr, &r->homedir) > ndr_get_array_size(ndr, &r->homedir)) {
 119                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->homedir), ndr_get_array_length(ndr, &r->homedir));
 120                         }
 121                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->homedir), sizeof(uint8_t)));
 122                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->homedir, ndr_get_array_length(ndr, &r->homedir), sizeof(uint8_t), CH_UTF8));
 123                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_homedir_0, 0);
 124                 }
 125                 if (r->shell) {
 126                         _mem_save_shell_0 = NDR_PULL_GET_MEM_CTX(ndr);
 127                         NDR_PULL_SET_MEM_CTX(ndr, r->shell, 0);
 128                         NDR_CHECK(ndr_pull_array_size(ndr, &r->shell));
 129                         NDR_CHECK(ndr_pull_array_length(ndr, &r->shell));
 130                         if (ndr_get_array_length(ndr, &r->shell) > ndr_get_array_size(ndr, &r->shell)) {
 131                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->shell), ndr_get_array_length(ndr, &r->shell));
 132                         }
 133                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->shell), sizeof(uint8_t)));
 134                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->shell, ndr_get_array_length(ndr, &r->shell), sizeof(uint8_t), CH_UTF8));
 135                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_shell_0, 0);
 136                 }
 137         }
 138         return NDR_ERR_SUCCESS;
 139 }
 140
 141 _PUBLIC_ void ndr_print_wbint_userinfo(struct ndr_print *ndr, const char *name, const struct wbint_userinfo *r)
 142 {
 143         ndr_print_struct(ndr, name, "wbint_userinfo");
 144         ndr->depth++;
 145         ndr_print_ptr(ndr, "acct_name", r->acct_name);
 146         ndr->depth++;
 147         if (r->acct_name) {
 148                 ndr_print_string(ndr, "acct_name", r->acct_name);
 149         }
 150         ndr->depth--;
 151         ndr_print_ptr(ndr, "full_name", r->full_name);
 152         ndr->depth++;
 153         if (r->full_name) {
 154                 ndr_print_string(ndr, "full_name", r->full_name);
 155         }
 156         ndr->depth--;
 157         ndr_print_ptr(ndr, "homedir", r->homedir);
 158         ndr->depth++;
 159         if (r->homedir) {
 160                 ndr_print_string(ndr, "homedir", r->homedir);
 161         }
 162         ndr->depth--;
 163         ndr_print_ptr(ndr, "shell", r->shell);
 164         ndr->depth++;
 165         if (r->shell) {
 166                 ndr_print_string(ndr, "shell", r->shell);
 167         }
 168         ndr->depth--;
 169         ndr_print_hyper(ndr, "primary_gid", r->primary_gid);
 170         ndr_print_dom_sid(ndr, "user_sid", &r->user_sid);
 171         ndr_print_dom_sid(ndr, "group_sid", &r->group_sid);
 172         ndr->depth--;
 173 }
 174
 175 _PUBLIC_ enum ndr_err_code ndr_push_wbint_SidArray(struct ndr_push *ndr, int ndr_flags, const struct wbint_SidArray *r)
 176 {
 177         uint32_t cntr_sids_0;
 178         if (ndr_flags & NDR_SCALARS) {
 179                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
 180                 NDR_CHECK(ndr_push_align(ndr, 4));
 181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
 182                 for (cntr_sids_0 = 0; cntr_sids_0 < r->num_sids; cntr_sids_0++) {
 183                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->sids[cntr_sids_0]));
 184                 }
 185         }
 186         if (ndr_flags & NDR_BUFFERS) {
 187         }
 188         return NDR_ERR_SUCCESS;
 189 }
 190
 191 _PUBLIC_ enum ndr_err_code ndr_pull_wbint_SidArray(struct ndr_pull *ndr, int ndr_flags, struct wbint_SidArray *r)
 192 {
 193         uint32_t cntr_sids_0;
 194         TALLOC_CTX *_mem_save_sids_0;
 195         if (ndr_flags & NDR_SCALARS) {
 196                 NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
 197                 NDR_CHECK(ndr_pull_align(ndr, 4));
 198                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sids));
 199                 NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
 200                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 201                 NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
 202                 for (cntr_sids_0 = 0; cntr_sids_0 < r->num_sids; cntr_sids_0++) {
 203                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, &r->sids[cntr_sids_0]));
 204                 }
 205                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
 206                 if (r->sids) {
 207                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->num_sids));
 208                 }
 209         }
 210         if (ndr_flags & NDR_BUFFERS) {
 211         }
 212         return NDR_ERR_SUCCESS;
 213 }
 214
 215 _PUBLIC_ void ndr_print_wbint_SidArray(struct ndr_print *ndr, const char *name, const struct wbint_SidArray *r)
 216 {
 217         uint32_t cntr_sids_0;
 218         ndr_print_struct(ndr, name, "wbint_SidArray");
 219         ndr->depth++;
 220         ndr_print_uint32(ndr, "num_sids", r->num_sids);
 221         ndr->print(ndr, "%s: ARRAY(%d)", "sids", (int)r->num_sids);
 222         ndr->depth++;
 223         for (cntr_sids_0=0;cntr_sids_0<r->num_sids;cntr_sids_0++) {
 224                 char *idx_0=NULL;
 225                 if (asprintf(&idx_0, "[%d]", cntr_sids_0) != -1) {
 226                         ndr_print_dom_sid(ndr, "sids", &r->sids[cntr_sids_0]);
 227                         free(idx_0);
 228                 }
 229         }
 230         ndr->depth--;
 231         ndr->depth--;
 232 }
 233
 234 _PUBLIC_ enum ndr_err_code ndr_push_wbint_RidArray(struct ndr_push *ndr, int ndr_flags, const struct wbint_RidArray *r)
 235 {
 236         uint32_t cntr_rids_0;
 237         if (ndr_flags & NDR_SCALARS) {
 238                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_rids));
 239                 NDR_CHECK(ndr_push_align(ndr, 4));
 240                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_rids));
 241                 for (cntr_rids_0 = 0; cntr_rids_0 < r->num_rids; cntr_rids_0++) {
 242                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rids[cntr_rids_0]));
 243                 }
 244         }
 245         if (ndr_flags & NDR_BUFFERS) {
 246         }
 247         return NDR_ERR_SUCCESS;
 248 }
 249
 250 _PUBLIC_ enum ndr_err_code ndr_pull_wbint_RidArray(struct ndr_pull *ndr, int ndr_flags, struct wbint_RidArray *r)
 251 {
 252         uint32_t cntr_rids_0;
 253         TALLOC_CTX *_mem_save_rids_0;
 254         if (ndr_flags & NDR_SCALARS) {
 255                 NDR_CHECK(ndr_pull_array_size(ndr, &r->rids));
 256                 NDR_CHECK(ndr_pull_align(ndr, 4));
 257                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_rids));
 258                 NDR_PULL_ALLOC_N(ndr, r->rids, ndr_get_array_size(ndr, &r->rids));
 259                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 260                 NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
 261                 for (cntr_rids_0 = 0; cntr_rids_0 < r->num_rids; cntr_rids_0++) {
 262                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rids[cntr_rids_0]));
 263                 }
 264                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
 265                 if (r->rids) {
 266                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->rids, r->num_rids));
 267                 }
 268         }
 269         if (ndr_flags & NDR_BUFFERS) {
 270         }
 271         return NDR_ERR_SUCCESS;
 272 }
 273
 274 _PUBLIC_ void ndr_print_wbint_RidArray(struct ndr_print *ndr, const char *name, const struct wbint_RidArray *r)
 275 {
 276         uint32_t cntr_rids_0;
 277         ndr_print_struct(ndr, name, "wbint_RidArray");
 278         ndr->depth++;
 279         ndr_print_uint32(ndr, "num_rids", r->num_rids);
 280         ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->num_rids);
 281         ndr->depth++;
 282         for (cntr_rids_0=0;cntr_rids_0<r->num_rids;cntr_rids_0++) {
 283                 char *idx_0=NULL;
 284                 if (asprintf(&idx_0, "[%d]", cntr_rids_0) != -1) {
 285                         ndr_print_uint32(ndr, "rids", r->rids[cntr_rids_0]);
 286                         free(idx_0);
 287                 }
 288         }
 289         ndr->depth--;
 290         ndr->depth--;
 291 }
 292
 293 _PUBLIC_ enum ndr_err_code ndr_push_wbint_Principal(struct ndr_push *ndr, int ndr_flags, const struct wbint_Principal *r)
 294 {
 295         if (ndr_flags & NDR_SCALARS) {
 296                 NDR_CHECK(ndr_push_align(ndr, 4));
 297                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->sid));
 298                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->type));
 299                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
 300         }
 301         if (ndr_flags & NDR_BUFFERS) {
 302                 if (r->name) {
 303                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF8)));
 304                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 305                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF8)));
 306                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 307                 }
 308         }
 309         return NDR_ERR_SUCCESS;
 310 }
 311
 312 _PUBLIC_ enum ndr_err_code ndr_pull_wbint_Principal(struct ndr_pull *ndr, int ndr_flags, struct wbint_Principal *r)
 313 {
 314         uint32_t _ptr_name;
 315         TALLOC_CTX *_mem_save_name_0;
 316         if (ndr_flags & NDR_SCALARS) {
 317                 NDR_CHECK(ndr_pull_align(ndr, 4));
 318                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, &r->sid));
 319                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->type));
 320                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
 321                 if (_ptr_name) {
 322                         NDR_PULL_ALLOC(ndr, r->name);
 323                 } else {
 324                         r->name = NULL;
 325                 }
 326         }
 327         if (ndr_flags & NDR_BUFFERS) {
 328                 if (r->name) {
 329                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 330                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
 331                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
 332                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
 333                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
 334                                 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));
 335                         }
 336                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint8_t)));
 337                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint8_t), CH_UTF8));
 338                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
 339                 }
 340         }
 341         return NDR_ERR_SUCCESS;
 342 }
 343
 344 _PUBLIC_ void ndr_print_wbint_Principal(struct ndr_print *ndr, const char *name, const struct wbint_Principal *r)
 345 {
 346         ndr_print_struct(ndr, name, "wbint_Principal");
 347         ndr->depth++;
 348         ndr_print_dom_sid(ndr, "sid", &r->sid);
 349         ndr_print_lsa_SidType(ndr, "type", r->type);
 350         ndr_print_ptr(ndr, "name", r->name);
 351         ndr->depth++;
 352         if (r->name) {
 353                 ndr_print_string(ndr, "name", r->name);
 354         }
 355         ndr->depth--;
 356         ndr->depth--;
 357 }
 358
 359 _PUBLIC_ enum ndr_err_code ndr_push_wbint_Principals(struct ndr_push *ndr, int ndr_flags, const struct wbint_Principals *r)
 360 {
 361         uint32_t cntr_principals_0;
 362         if (ndr_flags & NDR_SCALARS) {
 363                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_principals));
 364                 NDR_CHECK(ndr_push_align(ndr, 4));
 365                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->num_principals));
 366                 for (cntr_principals_0 = 0; cntr_principals_0 < r->num_principals; cntr_principals_0++) {
 367                         NDR_CHECK(ndr_push_wbint_Principal(ndr, NDR_SCALARS, &r->principals[cntr_principals_0]));
 368                 }
 369         }
 370         if (ndr_flags & NDR_BUFFERS) {
 371                 for (cntr_principals_0 = 0; cntr_principals_0 < r->num_principals; cntr_principals_0++) {
 372                         NDR_CHECK(ndr_push_wbint_Principal(ndr, NDR_BUFFERS, &r->principals[cntr_principals_0]));
 373                 }
 374         }
 375         return NDR_ERR_SUCCESS;
 376 }
 377
 378 _PUBLIC_ enum ndr_err_code ndr_pull_wbint_Principals(struct ndr_pull *ndr, int ndr_flags, struct wbint_Principals *r)
 379 {
 380         uint32_t cntr_principals_0;
 381         TALLOC_CTX *_mem_save_principals_0;
 382         if (ndr_flags & NDR_SCALARS) {
 383                 NDR_CHECK(ndr_pull_array_size(ndr, &r->principals));
 384                 NDR_CHECK(ndr_pull_align(ndr, 4));
 385                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->num_principals));
 386                 NDR_PULL_ALLOC_N(ndr, r->principals, ndr_get_array_size(ndr, &r->principals));
 387                 _mem_save_principals_0 = NDR_PULL_GET_MEM_CTX(ndr);
 388                 NDR_PULL_SET_MEM_CTX(ndr, r->principals, 0);
 389                 for (cntr_principals_0 = 0; cntr_principals_0 < r->num_principals; cntr_principals_0++) {
 390                         NDR_CHECK(ndr_pull_wbint_Principal(ndr, NDR_SCALARS, &r->principals[cntr_principals_0]));
 391                 }
 392                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_principals_0, 0);
 393                 if (r->principals) {
 394                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->principals, r->num_principals));
 395                 }
 396         }
 397         if (ndr_flags & NDR_BUFFERS) {
 398                 _mem_save_principals_0 = NDR_PULL_GET_MEM_CTX(ndr);
 399                 NDR_PULL_SET_MEM_CTX(ndr, r->principals, 0);
 400                 for (cntr_principals_0 = 0; cntr_principals_0 < r->num_principals; cntr_principals_0++) {
 401                         NDR_CHECK(ndr_pull_wbint_Principal(ndr, NDR_BUFFERS, &r->principals[cntr_principals_0]));
 402                 }
 403                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_principals_0, 0);
 404         }
 405         return NDR_ERR_SUCCESS;
 406 }
 407
 408 _PUBLIC_ void ndr_print_wbint_Principals(struct ndr_print *ndr, const char *name, const struct wbint_Principals *r)
 409 {
 410         uint32_t cntr_principals_0;
 411         ndr_print_struct(ndr, name, "wbint_Principals");
 412         ndr->depth++;
 413         ndr_print_int32(ndr, "num_principals", r->num_principals);
 414         ndr->print(ndr, "%s: ARRAY(%d)", "principals", (int)r->num_principals);
 415         ndr->depth++;
 416         for (cntr_principals_0=0;cntr_principals_0<r->num_principals;cntr_principals_0++) {
 417                 char *idx_0=NULL;
 418                 if (asprintf(&idx_0, "[%d]", cntr_principals_0) != -1) {
 419                         ndr_print_wbint_Principal(ndr, "principals", &r->principals[cntr_principals_0]);
 420                         free(idx_0);
 421                 }
 422         }
 423         ndr->depth--;
 424         ndr->depth--;
 425 }
 426
 427 _PUBLIC_ enum ndr_err_code ndr_push_wbint_userinfos(struct ndr_push *ndr, int ndr_flags, const struct wbint_userinfos *r)
 428 {
 429         uint32_t cntr_userinfos_0;
 430         if (ndr_flags & NDR_SCALARS) {
 431                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_userinfos));
 432                 NDR_CHECK(ndr_push_align(ndr, 8));
 433                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_userinfos));
 434                 for (cntr_userinfos_0 = 0; cntr_userinfos_0 < r->num_userinfos; cntr_userinfos_0++) {
 435                         NDR_CHECK(ndr_push_wbint_userinfo(ndr, NDR_SCALARS, &r->userinfos[cntr_userinfos_0]));
 436                 }
 437         }
 438         if (ndr_flags & NDR_BUFFERS) {
 439                 for (cntr_userinfos_0 = 0; cntr_userinfos_0 < r->num_userinfos; cntr_userinfos_0++) {
 440                         NDR_CHECK(ndr_push_wbint_userinfo(ndr, NDR_BUFFERS, &r->userinfos[cntr_userinfos_0]));
 441                 }
 442         }
 443         return NDR_ERR_SUCCESS;
 444 }
 445
 446 _PUBLIC_ enum ndr_err_code ndr_pull_wbint_userinfos(struct ndr_pull *ndr, int ndr_flags, struct wbint_userinfos *r)
 447 {
 448         uint32_t cntr_userinfos_0;
 449         TALLOC_CTX *_mem_save_userinfos_0;
 450         if (ndr_flags & NDR_SCALARS) {
 451                 NDR_CHECK(ndr_pull_array_size(ndr, &r->userinfos));
 452                 NDR_CHECK(ndr_pull_align(ndr, 8));
 453                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_userinfos));
 454                 NDR_PULL_ALLOC_N(ndr, r->userinfos, ndr_get_array_size(ndr, &r->userinfos));
 455                 _mem_save_userinfos_0 = NDR_PULL_GET_MEM_CTX(ndr);
 456                 NDR_PULL_SET_MEM_CTX(ndr, r->userinfos, 0);
 457                 for (cntr_userinfos_0 = 0; cntr_userinfos_0 < r->num_userinfos; cntr_userinfos_0++) {
 458                         NDR_CHECK(ndr_pull_wbint_userinfo(ndr, NDR_SCALARS, &r->userinfos[cntr_userinfos_0]));
 459                 }
 460                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userinfos_0, 0);
 461                 if (r->userinfos) {
 462                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->userinfos, r->num_userinfos));
 463                 }
 464         }
 465         if (ndr_flags & NDR_BUFFERS) {
 466                 _mem_save_userinfos_0 = NDR_PULL_GET_MEM_CTX(ndr);
 467                 NDR_PULL_SET_MEM_CTX(ndr, r->userinfos, 0);
 468                 for (cntr_userinfos_0 = 0; cntr_userinfos_0 < r->num_userinfos; cntr_userinfos_0++) {
 469                         NDR_CHECK(ndr_pull_wbint_userinfo(ndr, NDR_BUFFERS, &r->userinfos[cntr_userinfos_0]));
 470                 }
 471                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userinfos_0, 0);
 472         }
 473         return NDR_ERR_SUCCESS;
 474 }
 475
 476 _PUBLIC_ void ndr_print_wbint_userinfos(struct ndr_print *ndr, const char *name, const struct wbint_userinfos *r)
 477 {
 478         uint32_t cntr_userinfos_0;
 479         ndr_print_struct(ndr, name, "wbint_userinfos");
 480         ndr->depth++;
 481         ndr_print_uint32(ndr, "num_userinfos", r->num_userinfos);
 482         ndr->print(ndr, "%s: ARRAY(%d)", "userinfos", (int)r->num_userinfos);
 483         ndr->depth++;
 484         for (cntr_userinfos_0=0;cntr_userinfos_0<r->num_userinfos;cntr_userinfos_0++) {
 485                 char *idx_0=NULL;
 486                 if (asprintf(&idx_0, "[%d]", cntr_userinfos_0) != -1) {
 487                         ndr_print_wbint_userinfo(ndr, "userinfos", &r->userinfos[cntr_userinfos_0]);
 488                         free(idx_0);
 489                 }
 490         }
 491         ndr->depth--;
 492         ndr->depth--;
 493 }
 494
 495 static enum ndr_err_code ndr_push_wbint_Ping(struct ndr_push *ndr, int flags, const struct wbint_Ping *r)
 496 {
 497         if (flags & NDR_IN) {
 498                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data));
 499         }
 500         if (flags & NDR_OUT) {
 501                 if (r->out.out_data == NULL) {
 502                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 503                 }
 504                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.out_data));
 505         }
 506         return NDR_ERR_SUCCESS;
 507 }
 508
 509 static enum ndr_err_code ndr_pull_wbint_Ping(struct ndr_pull *ndr, int flags, struct wbint_Ping *r)
 510 {
 511         TALLOC_CTX *_mem_save_out_data_0;
 512         if (flags & NDR_IN) {
 513                 ZERO_STRUCT(r->out);
 514
 515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.in_data));
 516                 NDR_PULL_ALLOC(ndr, r->out.out_data);
 517                 ZERO_STRUCTP(r->out.out_data);
 518         }
 519         if (flags & NDR_OUT) {
 520                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 521                         NDR_PULL_ALLOC(ndr, r->out.out_data);
 522                 }
 523                 _mem_save_out_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
 524                 NDR_PULL_SET_MEM_CTX(ndr, r->out.out_data, LIBNDR_FLAG_REF_ALLOC);
 525                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.out_data));
 526                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_out_data_0, LIBNDR_FLAG_REF_ALLOC);
 527         }
 528         return NDR_ERR_SUCCESS;
 529 }
 530
 531 _PUBLIC_ void ndr_print_wbint_Ping(struct ndr_print *ndr, const char *name, int flags, const struct wbint_Ping *r)
 532 {
 533         ndr_print_struct(ndr, name, "wbint_Ping");
 534         ndr->depth++;
 535         if (flags & NDR_SET_VALUES) {
 536                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 537         }
 538         if (flags & NDR_IN) {
 539                 ndr_print_struct(ndr, "in", "wbint_Ping");
 540                 ndr->depth++;
 541                 ndr_print_uint32(ndr, "in_data", r->in.in_data);
 542                 ndr->depth--;
 543         }
 544         if (flags & NDR_OUT) {
 545                 ndr_print_struct(ndr, "out", "wbint_Ping");
 546                 ndr->depth++;
 547                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
 548                 ndr->depth++;
 549                 ndr_print_uint32(ndr, "out_data", *r->out.out_data);
 550                 ndr->depth--;
 551                 ndr->depth--;
 552         }
 553         ndr->depth--;
 554 }
 555
 556 static enum ndr_err_code ndr_push_wbint_LookupSid(struct ndr_push *ndr, int flags, const struct wbint_LookupSid *r)
 557 {
 558         if (flags & NDR_IN) {
 559                 if (r->in.sid == NULL) {
 560                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 561                 }
 562                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.sid));
 563         }
 564         if (flags & NDR_OUT) {
 565                 if (r->out.type == NULL) {
 566                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 567                 }
 568                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, *r->out.type));
 569                 if (r->out.domain == NULL) {
 570                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 571                 }
 572                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domain));
 573                 if (*r->out.domain) {
 574                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.domain, CH_UTF8)));
 575                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 576                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.domain, CH_UTF8)));
 577                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.domain, ndr_charset_length(*r->out.domain, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 578                 }
 579                 if (r->out.name == NULL) {
 580                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 581                 }
 582                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.name));
 583                 if (*r->out.name) {
 584                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.name, CH_UTF8)));
 585                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 586                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.name, CH_UTF8)));
 587                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.name, ndr_charset_length(*r->out.name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 588                 }
 589                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 590         }
 591         return NDR_ERR_SUCCESS;
 592 }
 593
 594 static enum ndr_err_code ndr_pull_wbint_LookupSid(struct ndr_pull *ndr, int flags, struct wbint_LookupSid *r)
 595 {
 596         uint32_t _ptr_domain;
 597         uint32_t _ptr_name;
 598         TALLOC_CTX *_mem_save_sid_0;
 599         TALLOC_CTX *_mem_save_type_0;
 600         TALLOC_CTX *_mem_save_domain_0;
 601         TALLOC_CTX *_mem_save_domain_1;
 602         TALLOC_CTX *_mem_save_name_0;
 603         TALLOC_CTX *_mem_save_name_1;
 604         if (flags & NDR_IN) {
 605                 ZERO_STRUCT(r->out);
 606
 607                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 608                         NDR_PULL_ALLOC(ndr, r->in.sid);
 609                 }
 610                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 611                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
 612                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.sid));
 613                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
 614                 NDR_PULL_ALLOC(ndr, r->out.type);
 615                 ZERO_STRUCTP(r->out.type);
 616                 NDR_PULL_ALLOC(ndr, r->out.domain);
 617                 ZERO_STRUCTP(r->out.domain);
 618                 NDR_PULL_ALLOC(ndr, r->out.name);
 619                 ZERO_STRUCTP(r->out.name);
 620         }
 621         if (flags & NDR_OUT) {
 622                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 623                         NDR_PULL_ALLOC(ndr, r->out.type);
 624                 }
 625                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
 626                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
 627                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, r->out.type));
 628                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
 629                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 630                         NDR_PULL_ALLOC(ndr, r->out.domain);
 631                 }
 632                 _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
 633                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domain, LIBNDR_FLAG_REF_ALLOC);
 634                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
 635                 if (_ptr_domain) {
 636                         NDR_PULL_ALLOC(ndr, *r->out.domain);
 637                 } else {
 638                         *r->out.domain = NULL;
 639                 }
 640                 if (*r->out.domain) {
 641                         _mem_save_domain_1 = NDR_PULL_GET_MEM_CTX(ndr);
 642                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domain, 0);
 643                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.domain));
 644                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.domain));
 645                         if (ndr_get_array_length(ndr, r->out.domain) > ndr_get_array_size(ndr, r->out.domain)) {
 646                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, r->out.domain), ndr_get_array_length(ndr, r->out.domain));
 647                         }
 648                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.domain), sizeof(uint8_t)));
 649                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.domain, ndr_get_array_length(ndr, r->out.domain), sizeof(uint8_t), CH_UTF8));
 650                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_1, 0);
 651                 }
 652                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, LIBNDR_FLAG_REF_ALLOC);
 653                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 654                         NDR_PULL_ALLOC(ndr, r->out.name);
 655                 }
 656                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 657                 NDR_PULL_SET_MEM_CTX(ndr, r->out.name, LIBNDR_FLAG_REF_ALLOC);
 658                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
 659                 if (_ptr_name) {
 660                         NDR_PULL_ALLOC(ndr, *r->out.name);
 661                 } else {
 662                         *r->out.name = NULL;
 663                 }
 664                 if (*r->out.name) {
 665                         _mem_save_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
 666                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.name, 0);
 667                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.name));
 668                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.name));
 669                         if (ndr_get_array_length(ndr, r->out.name) > ndr_get_array_size(ndr, r->out.name)) {
 670                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, r->out.name), ndr_get_array_length(ndr, r->out.name));
 671                         }
 672                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.name), sizeof(uint8_t)));
 673                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.name, ndr_get_array_length(ndr, r->out.name), sizeof(uint8_t), CH_UTF8));
 674                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_1, 0);
 675                 }
 676                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
 677                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 678         }
 679         return NDR_ERR_SUCCESS;
 680 }
 681
 682 _PUBLIC_ void ndr_print_wbint_LookupSid(struct ndr_print *ndr, const char *name, int flags, const struct wbint_LookupSid *r)
 683 {
 684         ndr_print_struct(ndr, name, "wbint_LookupSid");
 685         ndr->depth++;
 686         if (flags & NDR_SET_VALUES) {
 687                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 688         }
 689         if (flags & NDR_IN) {
 690                 ndr_print_struct(ndr, "in", "wbint_LookupSid");
 691                 ndr->depth++;
 692                 ndr_print_ptr(ndr, "sid", r->in.sid);
 693                 ndr->depth++;
 694                 ndr_print_dom_sid(ndr, "sid", r->in.sid);
 695                 ndr->depth--;
 696                 ndr->depth--;
 697         }
 698         if (flags & NDR_OUT) {
 699                 ndr_print_struct(ndr, "out", "wbint_LookupSid");
 700                 ndr->depth++;
 701                 ndr_print_ptr(ndr, "type", r->out.type);
 702                 ndr->depth++;
 703                 ndr_print_lsa_SidType(ndr, "type", *r->out.type);
 704                 ndr->depth--;
 705                 ndr_print_ptr(ndr, "domain", r->out.domain);
 706                 ndr->depth++;
 707                 ndr_print_ptr(ndr, "domain", *r->out.domain);
 708                 ndr->depth++;
 709                 if (*r->out.domain) {
 710                         ndr_print_string(ndr, "domain", *r->out.domain);
 711                 }
 712                 ndr->depth--;
 713                 ndr->depth--;
 714                 ndr_print_ptr(ndr, "name", r->out.name);
 715                 ndr->depth++;
 716                 ndr_print_ptr(ndr, "name", *r->out.name);
 717                 ndr->depth++;
 718                 if (*r->out.name) {
 719                         ndr_print_string(ndr, "name", *r->out.name);
 720                 }
 721                 ndr->depth--;
 722                 ndr->depth--;
 723                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
 724                 ndr->depth--;
 725         }
 726         ndr->depth--;
 727 }
 728
 729 static enum ndr_err_code ndr_push_wbint_LookupName(struct ndr_push *ndr, int flags, const struct wbint_LookupName *r)
 730 {
 731         if (flags & NDR_IN) {
 732                 if (r->in.domain == NULL) {
 733                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 734                 }
 735                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain, CH_UTF8)));
 736                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 737                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain, CH_UTF8)));
 738                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.domain, ndr_charset_length(r->in.domain, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 739                 if (r->in.name == NULL) {
 740                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 741                 }
 742                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF8)));
 743                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 744                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF8)));
 745                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name, ndr_charset_length(r->in.name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 746                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
 747         }
 748         if (flags & NDR_OUT) {
 749                 if (r->out.type == NULL) {
 750                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 751                 }
 752                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, *r->out.type));
 753                 if (r->out.sid == NULL) {
 754                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 755                 }
 756                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->out.sid));
 757                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 758         }
 759         return NDR_ERR_SUCCESS;
 760 }
 761
 762 static enum ndr_err_code ndr_pull_wbint_LookupName(struct ndr_pull *ndr, int flags, struct wbint_LookupName *r)
 763 {
 764         TALLOC_CTX *_mem_save_type_0;
 765         TALLOC_CTX *_mem_save_sid_0;
 766         if (flags & NDR_IN) {
 767                 ZERO_STRUCT(r->out);
 768
 769                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain));
 770                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain));
 771                 if (ndr_get_array_length(ndr, &r->in.domain) > ndr_get_array_size(ndr, &r->in.domain)) {
 772                         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), ndr_get_array_length(ndr, &r->in.domain));
 773                 }
 774                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain), sizeof(uint8_t)));
 775                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.domain, ndr_get_array_length(ndr, &r->in.domain), sizeof(uint8_t), CH_UTF8));
 776                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name));
 777                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name));
 778                 if (ndr_get_array_length(ndr, &r->in.name) > ndr_get_array_size(ndr, &r->in.name)) {
 779                         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.name), ndr_get_array_length(ndr, &r->in.name));
 780                 }
 781                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.name), sizeof(uint8_t)));
 782                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name, ndr_get_array_length(ndr, &r->in.name), sizeof(uint8_t), CH_UTF8));
 783                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
 784                 NDR_PULL_ALLOC(ndr, r->out.type);
 785                 ZERO_STRUCTP(r->out.type);
 786                 NDR_PULL_ALLOC(ndr, r->out.sid);
 787                 ZERO_STRUCTP(r->out.sid);
 788         }
 789         if (flags & NDR_OUT) {
 790                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 791                         NDR_PULL_ALLOC(ndr, r->out.type);
 792                 }
 793                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
 794                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
 795                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, r->out.type));
 796                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
 797                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 798                         NDR_PULL_ALLOC(ndr, r->out.sid);
 799                 }
 800                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 801                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);
 802                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->out.sid));
 803                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
 804                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 805         }
 806         return NDR_ERR_SUCCESS;
 807 }
 808
 809 _PUBLIC_ void ndr_print_wbint_LookupName(struct ndr_print *ndr, const char *name, int flags, const struct wbint_LookupName *r)
 810 {
 811         ndr_print_struct(ndr, name, "wbint_LookupName");
 812         ndr->depth++;
 813         if (flags & NDR_SET_VALUES) {
 814                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 815         }
 816         if (flags & NDR_IN) {
 817                 ndr_print_struct(ndr, "in", "wbint_LookupName");
 818                 ndr->depth++;
 819                 ndr_print_ptr(ndr, "domain", r->in.domain);
 820                 ndr->depth++;
 821                 ndr_print_string(ndr, "domain", r->in.domain);
 822                 ndr->depth--;
 823                 ndr_print_ptr(ndr, "name", r->in.name);
 824                 ndr->depth++;
 825                 ndr_print_string(ndr, "name", r->in.name);
 826                 ndr->depth--;
 827                 ndr_print_uint32(ndr, "flags", r->in.flags);
 828                 ndr->depth--;
 829         }
 830         if (flags & NDR_OUT) {
 831                 ndr_print_struct(ndr, "out", "wbint_LookupName");
 832                 ndr->depth++;
 833                 ndr_print_ptr(ndr, "type", r->out.type);
 834                 ndr->depth++;
 835                 ndr_print_lsa_SidType(ndr, "type", *r->out.type);
 836                 ndr->depth--;
 837                 ndr_print_ptr(ndr, "sid", r->out.sid);
 838                 ndr->depth++;
 839                 ndr_print_dom_sid(ndr, "sid", r->out.sid);
 840                 ndr->depth--;
 841                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
 842                 ndr->depth--;
 843         }
 844         ndr->depth--;
 845 }
 846
 847 static enum ndr_err_code ndr_push_wbint_Sid2Uid(struct ndr_push *ndr, int flags, const struct wbint_Sid2Uid *r)
 848 {
 849         if (flags & NDR_IN) {
 850                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dom_name));
 851                 if (r->in.dom_name) {
 852                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
 853                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 854                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
 855                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dom_name, ndr_charset_length(r->in.dom_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 856                 }
 857                 if (r->in.sid == NULL) {
 858                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 859                 }
 860                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.sid));
 861         }
 862         if (flags & NDR_OUT) {
 863                 if (r->out.uid == NULL) {
 864                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 865                 }
 866                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, *r->out.uid));
 867                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 868         }
 869         return NDR_ERR_SUCCESS;
 870 }
 871
 872 static enum ndr_err_code ndr_pull_wbint_Sid2Uid(struct ndr_pull *ndr, int flags, struct wbint_Sid2Uid *r)
 873 {
 874         uint32_t _ptr_dom_name;
 875         TALLOC_CTX *_mem_save_dom_name_0;
 876         TALLOC_CTX *_mem_save_sid_0;
 877         TALLOC_CTX *_mem_save_uid_0;
 878         if (flags & NDR_IN) {
 879                 ZERO_STRUCT(r->out);
 880
 881                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dom_name));
 882                 if (_ptr_dom_name) {
 883                         NDR_PULL_ALLOC(ndr, r->in.dom_name);
 884                 } else {
 885                         r->in.dom_name = NULL;
 886                 }
 887                 if (r->in.dom_name) {
 888                         _mem_save_dom_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 889                         NDR_PULL_SET_MEM_CTX(ndr, r->in.dom_name, 0);
 890                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dom_name));
 891                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dom_name));
 892                         if (ndr_get_array_length(ndr, &r->in.dom_name) > ndr_get_array_size(ndr, &r->in.dom_name)) {
 893                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.dom_name), ndr_get_array_length(ndr, &r->in.dom_name));
 894                         }
 895                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dom_name), sizeof(uint8_t)));
 896                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dom_name, ndr_get_array_length(ndr, &r->in.dom_name), sizeof(uint8_t), CH_UTF8));
 897                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dom_name_0, 0);
 898                 }
 899                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 900                         NDR_PULL_ALLOC(ndr, r->in.sid);
 901                 }
 902                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 903                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
 904                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.sid));
 905                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
 906                 NDR_PULL_ALLOC(ndr, r->out.uid);
 907                 ZERO_STRUCTP(r->out.uid);
 908         }
 909         if (flags & NDR_OUT) {
 910                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 911                         NDR_PULL_ALLOC(ndr, r->out.uid);
 912                 }
 913                 _mem_save_uid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 914                 NDR_PULL_SET_MEM_CTX(ndr, r->out.uid, LIBNDR_FLAG_REF_ALLOC);
 915                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, r->out.uid));
 916                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uid_0, LIBNDR_FLAG_REF_ALLOC);
 917                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 918         }
 919         return NDR_ERR_SUCCESS;
 920 }
 921
 922 _PUBLIC_ void ndr_print_wbint_Sid2Uid(struct ndr_print *ndr, const char *name, int flags, const struct wbint_Sid2Uid *r)
 923 {
 924         ndr_print_struct(ndr, name, "wbint_Sid2Uid");
 925         ndr->depth++;
 926         if (flags & NDR_SET_VALUES) {
 927                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 928         }
 929         if (flags & NDR_IN) {
 930                 ndr_print_struct(ndr, "in", "wbint_Sid2Uid");
 931                 ndr->depth++;
 932                 ndr_print_ptr(ndr, "dom_name", r->in.dom_name);
 933                 ndr->depth++;
 934                 if (r->in.dom_name) {
 935                         ndr_print_string(ndr, "dom_name", r->in.dom_name);
 936                 }
 937                 ndr->depth--;
 938                 ndr_print_ptr(ndr, "sid", r->in.sid);
 939                 ndr->depth++;
 940                 ndr_print_dom_sid(ndr, "sid", r->in.sid);
 941                 ndr->depth--;
 942                 ndr->depth--;
 943         }
 944         if (flags & NDR_OUT) {
 945                 ndr_print_struct(ndr, "out", "wbint_Sid2Uid");
 946                 ndr->depth++;
 947                 ndr_print_ptr(ndr, "uid", r->out.uid);
 948                 ndr->depth++;
 949                 ndr_print_hyper(ndr, "uid", *r->out.uid);
 950                 ndr->depth--;
 951                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
 952                 ndr->depth--;
 953         }
 954         ndr->depth--;
 955 }
 956
 957 static enum ndr_err_code ndr_push_wbint_Sid2Gid(struct ndr_push *ndr, int flags, const struct wbint_Sid2Gid *r)
 958 {
 959         if (flags & NDR_IN) {
 960                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dom_name));
 961                 if (r->in.dom_name) {
 962                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
 963                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 964                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
 965                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dom_name, ndr_charset_length(r->in.dom_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 966                 }
 967                 if (r->in.sid == NULL) {
 968                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 969                 }
 970                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.sid));
 971         }
 972         if (flags & NDR_OUT) {
 973                 if (r->out.gid == NULL) {
 974                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 975                 }
 976                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, *r->out.gid));
 977                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 978         }
 979         return NDR_ERR_SUCCESS;
 980 }
 981
 982 static enum ndr_err_code ndr_pull_wbint_Sid2Gid(struct ndr_pull *ndr, int flags, struct wbint_Sid2Gid *r)
 983 {
 984         uint32_t _ptr_dom_name;
 985         TALLOC_CTX *_mem_save_dom_name_0;
 986         TALLOC_CTX *_mem_save_sid_0;
 987         TALLOC_CTX *_mem_save_gid_0;
 988         if (flags & NDR_IN) {
 989                 ZERO_STRUCT(r->out);
 990
 991                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dom_name));
 992                 if (_ptr_dom_name) {
 993                         NDR_PULL_ALLOC(ndr, r->in.dom_name);
 994                 } else {
 995                         r->in.dom_name = NULL;
 996                 }
 997                 if (r->in.dom_name) {
 998                         _mem_save_dom_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 999                         NDR_PULL_SET_MEM_CTX(ndr, r->in.dom_name, 0);
1000                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dom_name));
1001                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dom_name));
1002                         if (ndr_get_array_length(ndr, &r->in.dom_name) > ndr_get_array_size(ndr, &r->in.dom_name)) {
1003                                 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.dom_name), ndr_get_array_length(ndr, &r->in.dom_name));
1004                         }
1005                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dom_name), sizeof(uint8_t)));
1006                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dom_name, ndr_get_array_length(ndr, &r->in.dom_name), sizeof(uint8_t), CH_UTF8));
1007                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dom_name_0, 0);
1008                 }
1009                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1010                         NDR_PULL_ALLOC(ndr, r->in.sid);
1011                 }
1012                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1013                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
1014                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.sid));
1015                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
1016                 NDR_PULL_ALLOC(ndr, r->out.gid);
1017                 ZERO_STRUCTP(r->out.gid);
1018         }
1019         if (flags & NDR_OUT) {
1020                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1021                         NDR_PULL_ALLOC(ndr, r->out.gid);
1022                 }
1023                 _mem_save_gid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1024                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gid, LIBNDR_FLAG_REF_ALLOC);
1025                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, r->out.gid));
1026                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gid_0, LIBNDR_FLAG_REF_ALLOC);
1027                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1028         }
1029         return NDR_ERR_SUCCESS;
1030 }
1031
1032 _PUBLIC_ void ndr_print_wbint_Sid2Gid(struct ndr_print *ndr, const char *name, int flags, const struct wbint_Sid2Gid *r)
1033 {
1034         ndr_print_struct(ndr, name, "wbint_Sid2Gid");
1035         ndr->depth++;
1036         if (flags & NDR_SET_VALUES) {
1037                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1038         }
1039         if (flags & NDR_IN) {
1040                 ndr_print_struct(ndr, "in", "wbint_Sid2Gid");
1041                 ndr->depth++;
1042                 ndr_print_ptr(ndr, "dom_name", r->in.dom_name);
1043                 ndr->depth++;
1044                 if (r->in.dom_name) {
1045                         ndr_print_string(ndr, "dom_name", r->in.dom_name);
1046                 }
1047                 ndr->depth--;
1048                 ndr_print_ptr(ndr, "sid", r->in.sid);
1049                 ndr->depth++;
1050                 ndr_print_dom_sid(ndr, "sid", r->in.sid);
1051                 ndr->depth--;
1052                 ndr->depth--;
1053         }
1054         if (flags & NDR_OUT) {
1055                 ndr_print_struct(ndr, "out", "wbint_Sid2Gid");
1056                 ndr->depth++;
1057                 ndr_print_ptr(ndr, "gid", r->out.gid);
1058                 ndr->depth++;
1059                 ndr_print_hyper(ndr, "gid", *r->out.gid);
1060                 ndr->depth--;
1061                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1062                 ndr->depth--;
1063         }
1064         ndr->depth--;
1065 }
1066
1067 static enum ndr_err_code ndr_push_wbint_Uid2Sid(struct ndr_push *ndr, int flags, const struct wbint_Uid2Sid *r)
1068 {
1069         if (flags & NDR_IN) {
1070                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dom_name));
1071                 if (r->in.dom_name) {
1072                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
1073                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1074                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
1075                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dom_name, ndr_charset_length(r->in.dom_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
1076                 }
1077                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->in.uid));
1078         }
1079         if (flags & NDR_OUT) {
1080                 if (r->out.sid == NULL) {
1081                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1082                 }
1083                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->out.sid));
1084                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1085         }
1086         return NDR_ERR_SUCCESS;
1087 }
1088
1089 static enum ndr_err_code ndr_pull_wbint_Uid2Sid(struct ndr_pull *ndr, int flags, struct wbint_Uid2Sid *r)
1090 {
1091         uint32_t _ptr_dom_name;
1092         TALLOC_CTX *_mem_save_dom_name_0;
1093         TALLOC_CTX *_mem_save_sid_0;
1094         if (flags & NDR_IN) {
1095                 ZERO_STRUCT(r->out);
1096
1097                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dom_name));
1098                 if (_ptr_dom_name) {
1099                         NDR_PULL_ALLOC(ndr, r->in.dom_name);
1100                 } else {
1101                         r->in.dom_name = NULL;
1102                 }
1103                 if (r->in.dom_name) {
1104                         _mem_save_dom_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1105                         NDR_PULL_SET_MEM_CTX(ndr, r->in.dom_name, 0);
1106                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dom_name));
1107                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dom_name));
1108                         if (ndr_get_array_length(ndr, &r->in.dom_name) > ndr_get_array_size(ndr, &r->in.dom_name)) {
1109                                 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.dom_name), ndr_get_array_length(ndr, &r->in.dom_name));
1110                         }
1111                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dom_name), sizeof(uint8_t)));
1112                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dom_name, ndr_get_array_length(ndr, &r->in.dom_name), sizeof(uint8_t), CH_UTF8));
1113                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dom_name_0, 0);
1114                 }
1115                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->in.uid));
1116                 NDR_PULL_ALLOC(ndr, r->out.sid);
1117                 ZERO_STRUCTP(r->out.sid);
1118         }
1119         if (flags & NDR_OUT) {
1120                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1121                         NDR_PULL_ALLOC(ndr, r->out.sid);
1122                 }
1123                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1124                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);
1125                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->out.sid));
1126                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
1127                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1128         }
1129         return NDR_ERR_SUCCESS;
1130 }
1131
1132 _PUBLIC_ void ndr_print_wbint_Uid2Sid(struct ndr_print *ndr, const char *name, int flags, const struct wbint_Uid2Sid *r)
1133 {
1134         ndr_print_struct(ndr, name, "wbint_Uid2Sid");
1135         ndr->depth++;
1136         if (flags & NDR_SET_VALUES) {
1137                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1138         }
1139         if (flags & NDR_IN) {
1140                 ndr_print_struct(ndr, "in", "wbint_Uid2Sid");
1141                 ndr->depth++;
1142                 ndr_print_ptr(ndr, "dom_name", r->in.dom_name);
1143                 ndr->depth++;
1144                 if (r->in.dom_name) {
1145                         ndr_print_string(ndr, "dom_name", r->in.dom_name);
1146                 }
1147                 ndr->depth--;
1148                 ndr_print_hyper(ndr, "uid", r->in.uid);
1149                 ndr->depth--;
1150         }
1151         if (flags & NDR_OUT) {
1152                 ndr_print_struct(ndr, "out", "wbint_Uid2Sid");
1153                 ndr->depth++;
1154                 ndr_print_ptr(ndr, "sid", r->out.sid);
1155                 ndr->depth++;
1156                 ndr_print_dom_sid(ndr, "sid", r->out.sid);
1157                 ndr->depth--;
1158                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1159                 ndr->depth--;
1160         }
1161         ndr->depth--;
1162 }
1163
1164 static enum ndr_err_code ndr_push_wbint_Gid2Sid(struct ndr_push *ndr, int flags, const struct wbint_Gid2Sid *r)
1165 {
1166         if (flags & NDR_IN) {
1167                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dom_name));
1168                 if (r->in.dom_name) {
1169                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
1170                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1171                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
1172                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dom_name, ndr_charset_length(r->in.dom_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
1173                 }
1174                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->in.gid));
1175         }
1176         if (flags & NDR_OUT) {
1177                 if (r->out.sid == NULL) {
1178                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1179                 }
1180                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->out.sid));
1181                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1182         }
1183         return NDR_ERR_SUCCESS;
1184 }
1185
1186 static enum ndr_err_code ndr_pull_wbint_Gid2Sid(struct ndr_pull *ndr, int flags, struct wbint_Gid2Sid *r)
1187 {
1188         uint32_t _ptr_dom_name;
1189         TALLOC_CTX *_mem_save_dom_name_0;
1190         TALLOC_CTX *_mem_save_sid_0;
1191         if (flags & NDR_IN) {
1192                 ZERO_STRUCT(r->out);
1193
1194                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dom_name));
1195                 if (_ptr_dom_name) {
1196                         NDR_PULL_ALLOC(ndr, r->in.dom_name);
1197                 } else {
1198                         r->in.dom_name = NULL;
1199                 }
1200                 if (r->in.dom_name) {
1201                         _mem_save_dom_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1202                         NDR_PULL_SET_MEM_CTX(ndr, r->in.dom_name, 0);
1203                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dom_name));
1204                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dom_name));
1205                         if (ndr_get_array_length(ndr, &r->in.dom_name) > ndr_get_array_size(ndr, &r->in.dom_name)) {
1206                                 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.dom_name), ndr_get_array_length(ndr, &r->in.dom_name));
1207                         }
1208                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dom_name), sizeof(uint8_t)));
1209                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dom_name, ndr_get_array_length(ndr, &r->in.dom_name), sizeof(uint8_t), CH_UTF8));
1210                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dom_name_0, 0);
1211                 }
1212                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->in.gid));
1213                 NDR_PULL_ALLOC(ndr, r->out.sid);
1214                 ZERO_STRUCTP(r->out.sid);
1215         }
1216         if (flags & NDR_OUT) {
1217                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1218                         NDR_PULL_ALLOC(ndr, r->out.sid);
1219                 }
1220                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1221                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);
1222                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->out.sid));
1223                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
1224                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1225         }
1226         return NDR_ERR_SUCCESS;
1227 }
1228
1229 _PUBLIC_ void ndr_print_wbint_Gid2Sid(struct ndr_print *ndr, const char *name, int flags, const struct wbint_Gid2Sid *r)
1230 {
1231         ndr_print_struct(ndr, name, "wbint_Gid2Sid");
1232         ndr->depth++;
1233         if (flags & NDR_SET_VALUES) {
1234                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1235         }
1236         if (flags & NDR_IN) {
1237                 ndr_print_struct(ndr, "in", "wbint_Gid2Sid");
1238                 ndr->depth++;
1239                 ndr_print_ptr(ndr, "dom_name", r->in.dom_name);
1240                 ndr->depth++;
1241                 if (r->in.dom_name) {
1242                         ndr_print_string(ndr, "dom_name", r->in.dom_name);
1243                 }
1244                 ndr->depth--;
1245                 ndr_print_hyper(ndr, "gid", r->in.gid);
1246                 ndr->depth--;
1247         }
1248         if (flags & NDR_OUT) {
1249                 ndr_print_struct(ndr, "out", "wbint_Gid2Sid");
1250                 ndr->depth++;
1251                 ndr_print_ptr(ndr, "sid", r->out.sid);
1252                 ndr->depth++;
1253                 ndr_print_dom_sid(ndr, "sid", r->out.sid);
1254                 ndr->depth--;
1255                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1256                 ndr->depth--;
1257         }
1258         ndr->depth--;
1259 }
1260
1261 static enum ndr_err_code ndr_push_wbint_AllocateUid(struct ndr_push *ndr, int flags, const struct wbint_AllocateUid *r)
1262 {
1263         if (flags & NDR_IN) {
1264         }
1265         if (flags & NDR_OUT) {
1266                 if (r->out.uid == NULL) {
1267                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1268                 }
1269                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, *r->out.uid));
1270                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1271         }
1272         return NDR_ERR_SUCCESS;
1273 }
1274
1275 static enum ndr_err_code ndr_pull_wbint_AllocateUid(struct ndr_pull *ndr, int flags, struct wbint_AllocateUid *r)
1276 {
1277         TALLOC_CTX *_mem_save_uid_0;
1278         if (flags & NDR_IN) {
1279                 ZERO_STRUCT(r->out);
1280
1281                 NDR_PULL_ALLOC(ndr, r->out.uid);
1282                 ZERO_STRUCTP(r->out.uid);
1283         }
1284         if (flags & NDR_OUT) {
1285                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1286                         NDR_PULL_ALLOC(ndr, r->out.uid);
1287                 }
1288                 _mem_save_uid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1289                 NDR_PULL_SET_MEM_CTX(ndr, r->out.uid, LIBNDR_FLAG_REF_ALLOC);
1290                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, r->out.uid));
1291                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uid_0, LIBNDR_FLAG_REF_ALLOC);
1292                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1293         }
1294         return NDR_ERR_SUCCESS;
1295 }
1296
1297 _PUBLIC_ void ndr_print_wbint_AllocateUid(struct ndr_print *ndr, const char *name, int flags, const struct wbint_AllocateUid *r)
1298 {
1299         ndr_print_struct(ndr, name, "wbint_AllocateUid");
1300         ndr->depth++;
1301         if (flags & NDR_SET_VALUES) {
1302                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1303         }
1304         if (flags & NDR_IN) {
1305                 ndr_print_struct(ndr, "in", "wbint_AllocateUid");
1306                 ndr->depth++;
1307                 ndr->depth--;
1308         }
1309         if (flags & NDR_OUT) {
1310                 ndr_print_struct(ndr, "out", "wbint_AllocateUid");
1311                 ndr->depth++;
1312                 ndr_print_ptr(ndr, "uid", r->out.uid);
1313                 ndr->depth++;
1314                 ndr_print_hyper(ndr, "uid", *r->out.uid);
1315                 ndr->depth--;
1316                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1317                 ndr->depth--;
1318         }
1319         ndr->depth--;
1320 }
1321
1322 static enum ndr_err_code ndr_push_wbint_AllocateGid(struct ndr_push *ndr, int flags, const struct wbint_AllocateGid *r)
1323 {
1324         if (flags & NDR_IN) {
1325         }
1326         if (flags & NDR_OUT) {
1327                 if (r->out.gid == NULL) {
1328                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1329                 }
1330                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, *r->out.gid));
1331                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1332         }
1333         return NDR_ERR_SUCCESS;
1334 }
1335
1336 static enum ndr_err_code ndr_pull_wbint_AllocateGid(struct ndr_pull *ndr, int flags, struct wbint_AllocateGid *r)
1337 {
1338         TALLOC_CTX *_mem_save_gid_0;
1339         if (flags & NDR_IN) {
1340                 ZERO_STRUCT(r->out);
1341
1342                 NDR_PULL_ALLOC(ndr, r->out.gid);
1343                 ZERO_STRUCTP(r->out.gid);
1344         }
1345         if (flags & NDR_OUT) {
1346                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1347                         NDR_PULL_ALLOC(ndr, r->out.gid);
1348                 }
1349                 _mem_save_gid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1350                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gid, LIBNDR_FLAG_REF_ALLOC);
1351                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, r->out.gid));
1352                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gid_0, LIBNDR_FLAG_REF_ALLOC);
1353                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1354         }
1355         return NDR_ERR_SUCCESS;
1356 }
1357
1358 _PUBLIC_ void ndr_print_wbint_AllocateGid(struct ndr_print *ndr, const char *name, int flags, const struct wbint_AllocateGid *r)
1359 {
1360         ndr_print_struct(ndr, name, "wbint_AllocateGid");
1361         ndr->depth++;
1362         if (flags & NDR_SET_VALUES) {
1363                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1364         }
1365         if (flags & NDR_IN) {
1366                 ndr_print_struct(ndr, "in", "wbint_AllocateGid");
1367                 ndr->depth++;
1368                 ndr->depth--;
1369         }
1370         if (flags & NDR_OUT) {
1371                 ndr_print_struct(ndr, "out", "wbint_AllocateGid");
1372                 ndr->depth++;
1373                 ndr_print_ptr(ndr, "gid", r->out.gid);
1374                 ndr->depth++;
1375                 ndr_print_hyper(ndr, "gid", *r->out.gid);
1376                 ndr->depth--;
1377                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1378                 ndr->depth--;
1379         }
1380         ndr->depth--;
1381 }
1382
1383 static enum ndr_err_code ndr_push_wbint_QueryUser(struct ndr_push *ndr, int flags, const struct wbint_QueryUser *r)
1384 {
1385         if (flags & NDR_IN) {
1386                 if (r->in.sid == NULL) {
1387                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1388                 }
1389                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.sid));
1390         }
1391         if (flags & NDR_OUT) {
1392                 if (r->out.info == NULL) {
1393                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1394                 }
1395                 NDR_CHECK(ndr_push_wbint_userinfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
1396                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1397         }
1398         return NDR_ERR_SUCCESS;
1399 }
1400
1401 static enum ndr_err_code ndr_pull_wbint_QueryUser(struct ndr_pull *ndr, int flags, struct wbint_QueryUser *r)
1402 {
1403         TALLOC_CTX *_mem_save_sid_0;
1404         TALLOC_CTX *_mem_save_info_0;
1405         if (flags & NDR_IN) {
1406                 ZERO_STRUCT(r->out);
1407
1408                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1409                         NDR_PULL_ALLOC(ndr, r->in.sid);
1410                 }
1411                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1412                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
1413                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.sid));
1414                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
1415                 NDR_PULL_ALLOC(ndr, r->out.info);
1416                 ZERO_STRUCTP(r->out.info);
1417         }
1418         if (flags & NDR_OUT) {
1419                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1420                         NDR_PULL_ALLOC(ndr, r->out.info);
1421                 }
1422                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
1423                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
1424                 NDR_CHECK(ndr_pull_wbint_userinfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
1425                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
1426                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1427         }
1428         return NDR_ERR_SUCCESS;
1429 }
1430
1431 _PUBLIC_ void ndr_print_wbint_QueryUser(struct ndr_print *ndr, const char *name, int flags, const struct wbint_QueryUser *r)
1432 {
1433         ndr_print_struct(ndr, name, "wbint_QueryUser");
1434         ndr->depth++;
1435         if (flags & NDR_SET_VALUES) {
1436                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1437         }
1438         if (flags & NDR_IN) {
1439                 ndr_print_struct(ndr, "in", "wbint_QueryUser");
1440                 ndr->depth++;
1441                 ndr_print_ptr(ndr, "sid", r->in.sid);
1442                 ndr->depth++;
1443                 ndr_print_dom_sid(ndr, "sid", r->in.sid);
1444                 ndr->depth--;
1445                 ndr->depth--;
1446         }
1447         if (flags & NDR_OUT) {
1448                 ndr_print_struct(ndr, "out", "wbint_QueryUser");
1449                 ndr->depth++;
1450                 ndr_print_ptr(ndr, "info", r->out.info);
1451                 ndr->depth++;
1452                 ndr_print_wbint_userinfo(ndr, "info", r->out.info);
1453                 ndr->depth--;
1454                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1455                 ndr->depth--;
1456         }
1457         ndr->depth--;
1458 }
1459
1460 static enum ndr_err_code ndr_push_wbint_LookupUserAliases(struct ndr_push *ndr, int flags, const struct wbint_LookupUserAliases *r)
1461 {
1462         if (flags & NDR_IN) {
1463                 if (r->in.sids == NULL) {
1464                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1465                 }
1466                 NDR_CHECK(ndr_push_wbint_SidArray(ndr, NDR_SCALARS, r->in.sids));
1467         }
1468         if (flags & NDR_OUT) {
1469                 if (r->out.rids == NULL) {
1470                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1471                 }
1472                 NDR_CHECK(ndr_push_wbint_RidArray(ndr, NDR_SCALARS, r->out.rids));
1473                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1474         }
1475         return NDR_ERR_SUCCESS;
1476 }
1477
1478 static enum ndr_err_code ndr_pull_wbint_LookupUserAliases(struct ndr_pull *ndr, int flags, struct wbint_LookupUserAliases *r)
1479 {
1480         TALLOC_CTX *_mem_save_sids_0;
1481         TALLOC_CTX *_mem_save_rids_0;
1482         if (flags & NDR_IN) {
1483                 ZERO_STRUCT(r->out);
1484
1485                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1486                         NDR_PULL_ALLOC(ndr, r->in.sids);
1487                 }
1488                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1489                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
1490                 NDR_CHECK(ndr_pull_wbint_SidArray(ndr, NDR_SCALARS, r->in.sids));
1491                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
1492                 NDR_PULL_ALLOC(ndr, r->out.rids);
1493                 ZERO_STRUCTP(r->out.rids);
1494         }
1495         if (flags & NDR_OUT) {
1496                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1497                         NDR_PULL_ALLOC(ndr, r->out.rids);
1498                 }
1499                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1500                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
1501                 NDR_CHECK(ndr_pull_wbint_RidArray(ndr, NDR_SCALARS, r->out.rids));
1502                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
1503                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1504         }
1505         return NDR_ERR_SUCCESS;
1506 }
1507
1508 _PUBLIC_ void ndr_print_wbint_LookupUserAliases(struct ndr_print *ndr, const char *name, int flags, const struct wbint_LookupUserAliases *r)
1509 {
1510         ndr_print_struct(ndr, name, "wbint_LookupUserAliases");
1511         ndr->depth++;
1512         if (flags & NDR_SET_VALUES) {
1513                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1514         }
1515         if (flags & NDR_IN) {
1516                 ndr_print_struct(ndr, "in", "wbint_LookupUserAliases");
1517                 ndr->depth++;
1518                 ndr_print_ptr(ndr, "sids", r->in.sids);
1519                 ndr->depth++;
1520                 ndr_print_wbint_SidArray(ndr, "sids", r->in.sids);
1521                 ndr->depth--;
1522                 ndr->depth--;
1523         }
1524         if (flags & NDR_OUT) {
1525                 ndr_print_struct(ndr, "out", "wbint_LookupUserAliases");
1526                 ndr->depth++;
1527                 ndr_print_ptr(ndr, "rids", r->out.rids);
1528                 ndr->depth++;
1529                 ndr_print_wbint_RidArray(ndr, "rids", r->out.rids);
1530                 ndr->depth--;
1531                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1532                 ndr->depth--;
1533         }
1534         ndr->depth--;
1535 }
1536
1537 static enum ndr_err_code ndr_push_wbint_LookupUserGroups(struct ndr_push *ndr, int flags, const struct wbint_LookupUserGroups *r)
1538 {
1539         if (flags & NDR_IN) {
1540                 if (r->in.sid == NULL) {
1541                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1542                 }
1543                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.sid));
1544         }
1545         if (flags & NDR_OUT) {
1546                 if (r->out.sids == NULL) {
1547                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1548                 }
1549                 NDR_CHECK(ndr_push_wbint_SidArray(ndr, NDR_SCALARS, r->out.sids));
1550                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1551         }
1552         return NDR_ERR_SUCCESS;
1553 }
1554
1555 static enum ndr_err_code ndr_pull_wbint_LookupUserGroups(struct ndr_pull *ndr, int flags, struct wbint_LookupUserGroups *r)
1556 {
1557         TALLOC_CTX *_mem_save_sid_0;
1558         TALLOC_CTX *_mem_save_sids_0;
1559         if (flags & NDR_IN) {
1560                 ZERO_STRUCT(r->out);
1561
1562                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1563                         NDR_PULL_ALLOC(ndr, r->in.sid);
1564                 }
1565                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1566                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
1567                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.sid));
1568                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
1569                 NDR_PULL_ALLOC(ndr, r->out.sids);
1570                 ZERO_STRUCTP(r->out.sids);
1571         }
1572         if (flags & NDR_OUT) {
1573                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1574                         NDR_PULL_ALLOC(ndr, r->out.sids);
1575                 }
1576                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1577                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
1578                 NDR_CHECK(ndr_pull_wbint_SidArray(ndr, NDR_SCALARS, r->out.sids));
1579                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
1580                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1581         }
1582         return NDR_ERR_SUCCESS;
1583 }
1584
1585 _PUBLIC_ void ndr_print_wbint_LookupUserGroups(struct ndr_print *ndr, const char *name, int flags, const struct wbint_LookupUserGroups *r)
1586 {
1587         ndr_print_struct(ndr, name, "wbint_LookupUserGroups");
1588         ndr->depth++;
1589         if (flags & NDR_SET_VALUES) {
1590                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1591         }
1592         if (flags & NDR_IN) {
1593                 ndr_print_struct(ndr, "in", "wbint_LookupUserGroups");
1594                 ndr->depth++;
1595                 ndr_print_ptr(ndr, "sid", r->in.sid);
1596                 ndr->depth++;
1597                 ndr_print_dom_sid(ndr, "sid", r->in.sid);
1598                 ndr->depth--;
1599                 ndr->depth--;
1600         }
1601         if (flags & NDR_OUT) {
1602                 ndr_print_struct(ndr, "out", "wbint_LookupUserGroups");
1603                 ndr->depth++;
1604                 ndr_print_ptr(ndr, "sids", r->out.sids);
1605                 ndr->depth++;
1606                 ndr_print_wbint_SidArray(ndr, "sids", r->out.sids);
1607                 ndr->depth--;
1608                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1609                 ndr->depth--;
1610         }
1611         ndr->depth--;
1612 }
1613
1614 static enum ndr_err_code ndr_push_wbint_QuerySequenceNumber(struct ndr_push *ndr, int flags, const struct wbint_QuerySequenceNumber *r)
1615 {
1616         if (flags & NDR_IN) {
1617         }
1618         if (flags & NDR_OUT) {
1619                 if (r->out.sequence == NULL) {
1620                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1621                 }
1622                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.sequence));
1623                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1624         }
1625         return NDR_ERR_SUCCESS;
1626 }
1627
1628 static enum ndr_err_code ndr_pull_wbint_QuerySequenceNumber(struct ndr_pull *ndr, int flags, struct wbint_QuerySequenceNumber *r)
1629 {
1630         TALLOC_CTX *_mem_save_sequence_0;
1631         if (flags & NDR_IN) {
1632                 ZERO_STRUCT(r->out);
1633
1634                 NDR_PULL_ALLOC(ndr, r->out.sequence);
1635                 ZERO_STRUCTP(r->out.sequence);
1636         }
1637         if (flags & NDR_OUT) {
1638                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1639                         NDR_PULL_ALLOC(ndr, r->out.sequence);
1640                 }
1641                 _mem_save_sequence_0 = NDR_PULL_GET_MEM_CTX(ndr);
1642                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sequence, LIBNDR_FLAG_REF_ALLOC);
1643                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.sequence));
1644                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sequence_0, LIBNDR_FLAG_REF_ALLOC);
1645                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1646         }
1647         return NDR_ERR_SUCCESS;
1648 }
1649
1650 _PUBLIC_ void ndr_print_wbint_QuerySequenceNumber(struct ndr_print *ndr, const char *name, int flags, const struct wbint_QuerySequenceNumber *r)
1651 {
1652         ndr_print_struct(ndr, name, "wbint_QuerySequenceNumber");
1653         ndr->depth++;
1654         if (flags & NDR_SET_VALUES) {
1655                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1656         }
1657         if (flags & NDR_IN) {
1658                 ndr_print_struct(ndr, "in", "wbint_QuerySequenceNumber");
1659                 ndr->depth++;
1660                 ndr->depth--;
1661         }
1662         if (flags & NDR_OUT) {
1663                 ndr_print_struct(ndr, "out", "wbint_QuerySequenceNumber");
1664                 ndr->depth++;
1665                 ndr_print_ptr(ndr, "sequence", r->out.sequence);
1666                 ndr->depth++;
1667                 ndr_print_uint32(ndr, "sequence", *r->out.sequence);
1668                 ndr->depth--;
1669                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1670                 ndr->depth--;
1671         }
1672         ndr->depth--;
1673 }
1674
1675 static enum ndr_err_code ndr_push_wbint_LookupGroupMembers(struct ndr_push *ndr, int flags, const struct wbint_LookupGroupMembers *r)
1676 {
1677         if (flags & NDR_IN) {
1678                 if (r->in.sid == NULL) {
1679                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1680                 }
1681                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.sid));
1682                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->in.type));
1683         }
1684         if (flags & NDR_OUT) {
1685                 if (r->out.members == NULL) {
1686                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1687                 }
1688                 NDR_CHECK(ndr_push_wbint_Principals(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.members));
1689                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1690         }
1691         return NDR_ERR_SUCCESS;
1692 }
1693
1694 static enum ndr_err_code ndr_pull_wbint_LookupGroupMembers(struct ndr_pull *ndr, int flags, struct wbint_LookupGroupMembers *r)
1695 {
1696         TALLOC_CTX *_mem_save_sid_0;
1697         TALLOC_CTX *_mem_save_members_0;
1698         if (flags & NDR_IN) {
1699                 ZERO_STRUCT(r->out);
1700
1701                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1702                         NDR_PULL_ALLOC(ndr, r->in.sid);
1703                 }
1704                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1705                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
1706                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.sid));
1707                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
1708                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->in.type));
1709                 NDR_PULL_ALLOC(ndr, r->out.members);
1710                 ZERO_STRUCTP(r->out.members);
1711         }
1712         if (flags & NDR_OUT) {
1713                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1714                         NDR_PULL_ALLOC(ndr, r->out.members);
1715                 }
1716                 _mem_save_members_0 = NDR_PULL_GET_MEM_CTX(ndr);
1717                 NDR_PULL_SET_MEM_CTX(ndr, r->out.members, LIBNDR_FLAG_REF_ALLOC);
1718                 NDR_CHECK(ndr_pull_wbint_Principals(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.members));
1719                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_members_0, LIBNDR_FLAG_REF_ALLOC);
1720                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1721         }
1722         return NDR_ERR_SUCCESS;
1723 }
1724
1725 _PUBLIC_ void ndr_print_wbint_LookupGroupMembers(struct ndr_print *ndr, const char *name, int flags, const struct wbint_LookupGroupMembers *r)
1726 {
1727         ndr_print_struct(ndr, name, "wbint_LookupGroupMembers");
1728         ndr->depth++;
1729         if (flags & NDR_SET_VALUES) {
1730                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1731         }
1732         if (flags & NDR_IN) {
1733                 ndr_print_struct(ndr, "in", "wbint_LookupGroupMembers");
1734                 ndr->depth++;
1735                 ndr_print_ptr(ndr, "sid", r->in.sid);
1736                 ndr->depth++;
1737                 ndr_print_dom_sid(ndr, "sid", r->in.sid);
1738                 ndr->depth--;
1739                 ndr_print_lsa_SidType(ndr, "type", r->in.type);
1740                 ndr->depth--;
1741         }
1742         if (flags & NDR_OUT) {
1743                 ndr_print_struct(ndr, "out", "wbint_LookupGroupMembers");
1744                 ndr->depth++;
1745                 ndr_print_ptr(ndr, "members", r->out.members);
1746                 ndr->depth++;
1747                 ndr_print_wbint_Principals(ndr, "members", r->out.members);
1748                 ndr->depth--;
1749                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1750                 ndr->depth--;
1751         }
1752         ndr->depth--;
1753 }
1754
1755 static enum ndr_err_code ndr_push_wbint_QueryUserList(struct ndr_push *ndr, int flags, const struct wbint_QueryUserList *r)
1756 {
1757         if (flags & NDR_IN) {
1758         }
1759         if (flags & NDR_OUT) {
1760                 if (r->out.users == NULL) {
1761                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1762                 }
1763                 NDR_CHECK(ndr_push_wbint_userinfos(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.users));
1764                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1765         }
1766         return NDR_ERR_SUCCESS;
1767 }
1768
1769 static enum ndr_err_code ndr_pull_wbint_QueryUserList(struct ndr_pull *ndr, int flags, struct wbint_QueryUserList *r)
1770 {
1771         TALLOC_CTX *_mem_save_users_0;
1772         if (flags & NDR_IN) {
1773                 ZERO_STRUCT(r->out);
1774
1775                 NDR_PULL_ALLOC(ndr, r->out.users);
1776                 ZERO_STRUCTP(r->out.users);
1777         }
1778         if (flags & NDR_OUT) {
1779                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1780                         NDR_PULL_ALLOC(ndr, r->out.users);
1781                 }
1782                 _mem_save_users_0 = NDR_PULL_GET_MEM_CTX(ndr);
1783                 NDR_PULL_SET_MEM_CTX(ndr, r->out.users, LIBNDR_FLAG_REF_ALLOC);
1784                 NDR_CHECK(ndr_pull_wbint_userinfos(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.users));
1785                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_users_0, LIBNDR_FLAG_REF_ALLOC);
1786                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1787         }
1788         return NDR_ERR_SUCCESS;
1789 }
1790
1791 _PUBLIC_ void ndr_print_wbint_QueryUserList(struct ndr_print *ndr, const char *name, int flags, const struct wbint_QueryUserList *r)
1792 {
1793         ndr_print_struct(ndr, name, "wbint_QueryUserList");
1794         ndr->depth++;
1795         if (flags & NDR_SET_VALUES) {
1796                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1797         }
1798         if (flags & NDR_IN) {
1799                 ndr_print_struct(ndr, "in", "wbint_QueryUserList");
1800                 ndr->depth++;
1801                 ndr->depth--;
1802         }
1803         if (flags & NDR_OUT) {
1804                 ndr_print_struct(ndr, "out", "wbint_QueryUserList");
1805                 ndr->depth++;
1806                 ndr_print_ptr(ndr, "users", r->out.users);
1807                 ndr->depth++;
1808                 ndr_print_wbint_userinfos(ndr, "users", r->out.users);
1809                 ndr->depth--;
1810                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1811                 ndr->depth--;
1812         }
1813         ndr->depth--;
1814 }
1815
1816 static enum ndr_err_code ndr_push_wbint_QueryGroupList(struct ndr_push *ndr, int flags, const struct wbint_QueryGroupList *r)
1817 {
1818         if (flags & NDR_IN) {
1819         }
1820         if (flags & NDR_OUT) {
1821                 if (r->out.groups == NULL) {
1822                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1823                 }
1824                 NDR_CHECK(ndr_push_wbint_Principals(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.groups));
1825                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1826         }
1827         return NDR_ERR_SUCCESS;
1828 }
1829
1830 static enum ndr_err_code ndr_pull_wbint_QueryGroupList(struct ndr_pull *ndr, int flags, struct wbint_QueryGroupList *r)
1831 {
1832         TALLOC_CTX *_mem_save_groups_0;
1833         if (flags & NDR_IN) {
1834                 ZERO_STRUCT(r->out);
1835
1836                 NDR_PULL_ALLOC(ndr, r->out.groups);
1837                 ZERO_STRUCTP(r->out.groups);
1838         }
1839         if (flags & NDR_OUT) {
1840                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1841                         NDR_PULL_ALLOC(ndr, r->out.groups);
1842                 }
1843                 _mem_save_groups_0 = NDR_PULL_GET_MEM_CTX(ndr);
1844                 NDR_PULL_SET_MEM_CTX(ndr, r->out.groups, LIBNDR_FLAG_REF_ALLOC);
1845                 NDR_CHECK(ndr_pull_wbint_Principals(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.groups));
1846                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_groups_0, LIBNDR_FLAG_REF_ALLOC);
1847                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1848         }
1849         return NDR_ERR_SUCCESS;
1850 }
1851
1852 _PUBLIC_ void ndr_print_wbint_QueryGroupList(struct ndr_print *ndr, const char *name, int flags, const struct wbint_QueryGroupList *r)
1853 {
1854         ndr_print_struct(ndr, name, "wbint_QueryGroupList");
1855         ndr->depth++;
1856         if (flags & NDR_SET_VALUES) {
1857                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1858         }
1859         if (flags & NDR_IN) {
1860                 ndr_print_struct(ndr, "in", "wbint_QueryGroupList");
1861                 ndr->depth++;
1862                 ndr->depth--;
1863         }
1864         if (flags & NDR_OUT) {
1865                 ndr_print_struct(ndr, "out", "wbint_QueryGroupList");
1866                 ndr->depth++;
1867                 ndr_print_ptr(ndr, "groups", r->out.groups);
1868                 ndr->depth++;
1869                 ndr_print_wbint_Principals(ndr, "groups", r->out.groups);
1870                 ndr->depth--;
1871                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1872                 ndr->depth--;
1873         }
1874         ndr->depth--;
1875 }
1876
1877 static enum ndr_err_code ndr_push_wbint_DsGetDcName(struct ndr_push *ndr, int flags, const struct wbint_DsGetDcName *r)
1878 {
1879         if (flags & NDR_IN) {
1880                 if (r->in.domain_name == NULL) {
1881                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1882                 }
1883                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF8)));
1884                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1885                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF8)));
1886                 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));
1887                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.domain_guid));
1888                 if (r->in.domain_guid) {
1889                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.domain_guid));
1890                 }
1891                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.site_name));
1892                 if (r->in.site_name) {
1893                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.site_name, CH_UTF8)));
1894                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1895                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.site_name, CH_UTF8)));
1896                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.site_name, ndr_charset_length(r->in.site_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
1897                 }
1898                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
1899         }
1900         if (flags & NDR_OUT) {
1901                 if (r->out.dc_info == NULL) {
1902                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1903                 }
1904                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.dc_info));
1905                 if (*r->out.dc_info) {
1906                         NDR_CHECK(ndr_push_netr_DsRGetDCNameInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.dc_info));
1907                 }
1908                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1909         }
1910         return NDR_ERR_SUCCESS;
1911 }
1912
1913 static enum ndr_err_code ndr_pull_wbint_DsGetDcName(struct ndr_pull *ndr, int flags, struct wbint_DsGetDcName *r)
1914 {
1915         uint32_t _ptr_domain_guid;
1916         uint32_t _ptr_site_name;
1917         uint32_t _ptr_dc_info;
1918         TALLOC_CTX *_mem_save_domain_guid_0;
1919         TALLOC_CTX *_mem_save_site_name_0;
1920         TALLOC_CTX *_mem_save_dc_info_0;
1921         TALLOC_CTX *_mem_save_dc_info_1;
1922         if (flags & NDR_IN) {
1923                 ZERO_STRUCT(r->out);
1924
1925                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
1926                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
1927                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
1928                         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));
1929                 }
1930                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint8_t)));
1931                 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));
1932                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_guid));
1933                 if (_ptr_domain_guid) {
1934                         NDR_PULL_ALLOC(ndr, r->in.domain_guid);
1935                 } else {
1936                         r->in.domain_guid = NULL;
1937                 }
1938                 if (r->in.domain_guid) {
1939                         _mem_save_domain_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1940                         NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_guid, 0);
1941                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.domain_guid));
1942                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_guid_0, 0);
1943                 }
1944                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
1945                 if (_ptr_site_name) {
1946                         NDR_PULL_ALLOC(ndr, r->in.site_name);
1947                 } else {
1948                         r->in.site_name = NULL;
1949                 }
1950                 if (r->in.site_name) {
1951                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1952                         NDR_PULL_SET_MEM_CTX(ndr, r->in.site_name, 0);
1953                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.site_name));
1954                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.site_name));
1955                         if (ndr_get_array_length(ndr, &r->in.site_name) > ndr_get_array_size(ndr, &r->in.site_name)) {
1956                                 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.site_name), ndr_get_array_length(ndr, &r->in.site_name));
1957                         }
1958                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.site_name), sizeof(uint8_t)));
1959                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.site_name, ndr_get_array_length(ndr, &r->in.site_name), sizeof(uint8_t), CH_UTF8));
1960                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
1961                 }
1962                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
1963                 NDR_PULL_ALLOC(ndr, r->out.dc_info);
1964                 ZERO_STRUCTP(r->out.dc_info);
1965         }
1966         if (flags & NDR_OUT) {
1967                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1968                         NDR_PULL_ALLOC(ndr, r->out.dc_info);
1969                 }
1970                 _mem_save_dc_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
1971                 NDR_PULL_SET_MEM_CTX(ndr, r->out.dc_info, LIBNDR_FLAG_REF_ALLOC);
1972                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dc_info));
1973                 if (_ptr_dc_info) {
1974                         NDR_PULL_ALLOC(ndr, *r->out.dc_info);
1975                 } else {
1976                         *r->out.dc_info = NULL;
1977                 }
1978                 if (*r->out.dc_info) {
1979                         _mem_save_dc_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
1980                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.dc_info, 0);
1981                         NDR_CHECK(ndr_pull_netr_DsRGetDCNameInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.dc_info));
1982                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dc_info_1, 0);
1983                 }
1984                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dc_info_0, LIBNDR_FLAG_REF_ALLOC);
1985                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1986         }
1987         return NDR_ERR_SUCCESS;
1988 }
1989
1990 _PUBLIC_ void ndr_print_wbint_DsGetDcName(struct ndr_print *ndr, const char *name, int flags, const struct wbint_DsGetDcName *r)
1991 {
1992         ndr_print_struct(ndr, name, "wbint_DsGetDcName");
1993         ndr->depth++;
1994         if (flags & NDR_SET_VALUES) {
1995                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1996         }
1997         if (flags & NDR_IN) {
1998                 ndr_print_struct(ndr, "in", "wbint_DsGetDcName");
1999                 ndr->depth++;
2000                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
2001                 ndr->depth++;
2002                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
2003                 ndr->depth--;
2004                 ndr_print_ptr(ndr, "domain_guid", r->in.domain_guid);
2005                 ndr->depth++;
2006                 if (r->in.domain_guid) {
2007                         ndr_print_GUID(ndr, "domain_guid", r->in.domain_guid);
2008                 }
2009                 ndr->depth--;
2010                 ndr_print_ptr(ndr, "site_name", r->in.site_name);
2011                 ndr->depth++;
2012                 if (r->in.site_name) {
2013                         ndr_print_string(ndr, "site_name", r->in.site_name);
2014                 }
2015                 ndr->depth--;
2016                 ndr_print_uint32(ndr, "flags", r->in.flags);
2017                 ndr->depth--;
2018         }
2019         if (flags & NDR_OUT) {
2020                 ndr_print_struct(ndr, "out", "wbint_DsGetDcName");
2021                 ndr->depth++;
2022                 ndr_print_ptr(ndr, "dc_info", r->out.dc_info);
2023                 ndr->depth++;
2024                 ndr_print_ptr(ndr, "dc_info", *r->out.dc_info);
2025                 ndr->depth++;
2026                 if (*r->out.dc_info) {
2027                         ndr_print_netr_DsRGetDCNameInfo(ndr, "dc_info", *r->out.dc_info);
2028                 }
2029                 ndr->depth--;
2030                 ndr->depth--;
2031                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
2032                 ndr->depth--;
2033         }
2034         ndr->depth--;
2035 }
2036
2037 static enum ndr_err_code ndr_push_wbint_LookupRids(struct ndr_push *ndr, int flags, const struct wbint_LookupRids *r)
2038 {
2039         if (flags & NDR_IN) {
2040                 if (r->in.rids == NULL) {
2041                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2042                 }
2043                 NDR_CHECK(ndr_push_wbint_RidArray(ndr, NDR_SCALARS, r->in.rids));
2044         }
2045         if (flags & NDR_OUT) {
2046                 if (r->out.names == NULL) {
2047                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2048                 }
2049                 NDR_CHECK(ndr_push_wbint_Principals(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
2050                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2051         }
2052         return NDR_ERR_SUCCESS;
2053 }
2054
2055 static enum ndr_err_code ndr_pull_wbint_LookupRids(struct ndr_pull *ndr, int flags, struct wbint_LookupRids *r)
2056 {
2057         TALLOC_CTX *_mem_save_rids_0;
2058         TALLOC_CTX *_mem_save_names_0;
2059         if (flags & NDR_IN) {
2060                 ZERO_STRUCT(r->out);
2061
2062                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2063                         NDR_PULL_ALLOC(ndr, r->in.rids);
2064                 }
2065                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
2066                 NDR_PULL_SET_MEM_CTX(ndr, r->in.rids, LIBNDR_FLAG_REF_ALLOC);
2067                 NDR_CHECK(ndr_pull_wbint_RidArray(ndr, NDR_SCALARS, r->in.rids));
2068                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
2069                 NDR_PULL_ALLOC(ndr, r->out.names);
2070                 ZERO_STRUCTP(r->out.names);
2071         }
2072         if (flags & NDR_OUT) {
2073                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2074                         NDR_PULL_ALLOC(ndr, r->out.names);
2075                 }
2076                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
2077                 NDR_PULL_SET_MEM_CTX(ndr, r->out.names, LIBNDR_FLAG_REF_ALLOC);
2078                 NDR_CHECK(ndr_pull_wbint_Principals(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
2079                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
2080                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2081         }
2082         return NDR_ERR_SUCCESS;
2083 }
2084
2085 _PUBLIC_ void ndr_print_wbint_LookupRids(struct ndr_print *ndr, const char *name, int flags, const struct wbint_LookupRids *r)
2086 {
2087         ndr_print_struct(ndr, name, "wbint_LookupRids");
2088         ndr->depth++;
2089         if (flags & NDR_SET_VALUES) {
2090                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2091         }
2092         if (flags & NDR_IN) {
2093                 ndr_print_struct(ndr, "in", "wbint_LookupRids");
2094                 ndr->depth++;
2095                 ndr_print_ptr(ndr, "rids", r->in.rids);
2096                 ndr->depth++;
2097                 ndr_print_wbint_RidArray(ndr, "rids", r->in.rids);
2098                 ndr->depth--;
2099                 ndr->depth--;
2100         }
2101         if (flags & NDR_OUT) {
2102                 ndr_print_struct(ndr, "out", "wbint_LookupRids");
2103                 ndr->depth++;
2104                 ndr_print_ptr(ndr, "names", r->out.names);
2105                 ndr->depth++;
2106                 ndr_print_wbint_Principals(ndr, "names", r->out.names);
2107                 ndr->depth--;
2108                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
2109                 ndr->depth--;
2110         }
2111         ndr->depth--;
2112 }
2113
2114 static enum ndr_err_code ndr_push_wbint_CheckMachineAccount(struct ndr_push *ndr, int flags, const struct wbint_CheckMachineAccount *r)
2115 {
2116         if (flags & NDR_IN) {
2117         }
2118         if (flags & NDR_OUT) {
2119                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2120         }
2121         return NDR_ERR_SUCCESS;
2122 }
2123
2124 static enum ndr_err_code ndr_pull_wbint_CheckMachineAccount(struct ndr_pull *ndr, int flags, struct wbint_CheckMachineAccount *r)
2125 {
2126         if (flags & NDR_IN) {
2127         }
2128         if (flags & NDR_OUT) {
2129                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2130         }
2131         return NDR_ERR_SUCCESS;
2132 }
2133
2134 _PUBLIC_ void ndr_print_wbint_CheckMachineAccount(struct ndr_print *ndr, const char *name, int flags, const struct wbint_CheckMachineAccount *r)
2135 {
2136         ndr_print_struct(ndr, name, "wbint_CheckMachineAccount");
2137         ndr->depth++;
2138         if (flags & NDR_SET_VALUES) {
2139                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2140         }
2141         if (flags & NDR_IN) {
2142                 ndr_print_struct(ndr, "in", "wbint_CheckMachineAccount");
2143                 ndr->depth++;
2144                 ndr->depth--;
2145         }
2146         if (flags & NDR_OUT) {
2147                 ndr_print_struct(ndr, "out", "wbint_CheckMachineAccount");
2148                 ndr->depth++;
2149                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
2150                 ndr->depth--;
2151         }
2152         ndr->depth--;
2153 }
2154
2155 static const struct ndr_interface_call wbint_calls[] = {
2156         {
2157                 "wbint_Ping",
2158                 sizeof(struct wbint_Ping),
2159                 (ndr_push_flags_fn_t) ndr_push_wbint_Ping,
2160                 (ndr_pull_flags_fn_t) ndr_pull_wbint_Ping,
2161                 (ndr_print_function_t) ndr_print_wbint_Ping,
2162                 false,
2163         },
2164         {
2165                 "wbint_LookupSid",
2166                 sizeof(struct wbint_LookupSid),
2167                 (ndr_push_flags_fn_t) ndr_push_wbint_LookupSid,
2168                 (ndr_pull_flags_fn_t) ndr_pull_wbint_LookupSid,
2169                 (ndr_print_function_t) ndr_print_wbint_LookupSid,
2170                 false,
2171         },
2172         {
2173                 "wbint_LookupName",
2174                 sizeof(struct wbint_LookupName),
2175                 (ndr_push_flags_fn_t) ndr_push_wbint_LookupName,
2176                 (ndr_pull_flags_fn_t) ndr_pull_wbint_LookupName,
2177                 (ndr_print_function_t) ndr_print_wbint_LookupName,
2178                 false,
2179         },
2180         {
2181                 "wbint_Sid2Uid",
2182                 sizeof(struct wbint_Sid2Uid),
2183                 (ndr_push_flags_fn_t) ndr_push_wbint_Sid2Uid,
2184                 (ndr_pull_flags_fn_t) ndr_pull_wbint_Sid2Uid,
2185                 (ndr_print_function_t) ndr_print_wbint_Sid2Uid,
2186                 false,
2187         },
2188         {
2189                 "wbint_Sid2Gid",
2190                 sizeof(struct wbint_Sid2Gid),
2191                 (ndr_push_flags_fn_t) ndr_push_wbint_Sid2Gid,
2192                 (ndr_pull_flags_fn_t) ndr_pull_wbint_Sid2Gid,
2193                 (ndr_print_function_t) ndr_print_wbint_Sid2Gid,
2194                 false,
2195         },
2196         {
2197                 "wbint_Uid2Sid",
2198                 sizeof(struct wbint_Uid2Sid),
2199                 (ndr_push_flags_fn_t) ndr_push_wbint_Uid2Sid,
2200                 (ndr_pull_flags_fn_t) ndr_pull_wbint_Uid2Sid,
2201                 (ndr_print_function_t) ndr_print_wbint_Uid2Sid,
2202                 false,
2203         },
2204         {
2205                 "wbint_Gid2Sid",
2206                 sizeof(struct wbint_Gid2Sid),
2207                 (ndr_push_flags_fn_t) ndr_push_wbint_Gid2Sid,
2208                 (ndr_pull_flags_fn_t) ndr_pull_wbint_Gid2Sid,
2209                 (ndr_print_function_t) ndr_print_wbint_Gid2Sid,
2210                 false,
2211         },
2212         {
2213                 "wbint_AllocateUid",
2214                 sizeof(struct wbint_AllocateUid),
2215                 (ndr_push_flags_fn_t) ndr_push_wbint_AllocateUid,
2216                 (ndr_pull_flags_fn_t) ndr_pull_wbint_AllocateUid,
2217                 (ndr_print_function_t) ndr_print_wbint_AllocateUid,
2218                 false,
2219         },
2220         {
2221                 "wbint_AllocateGid",
2222                 sizeof(struct wbint_AllocateGid),
2223                 (ndr_push_flags_fn_t) ndr_push_wbint_AllocateGid,
2224                 (ndr_pull_flags_fn_t) ndr_pull_wbint_AllocateGid,
2225                 (ndr_print_function_t) ndr_print_wbint_AllocateGid,
2226                 false,
2227         },
2228         {
2229                 "wbint_QueryUser",
2230                 sizeof(struct wbint_QueryUser),
2231                 (ndr_push_flags_fn_t) ndr_push_wbint_QueryUser,
2232                 (ndr_pull_flags_fn_t) ndr_pull_wbint_QueryUser,
2233                 (ndr_print_function_t) ndr_print_wbint_QueryUser,
2234                 false,
2235         },
2236         {
2237                 "wbint_LookupUserAliases",
2238                 sizeof(struct wbint_LookupUserAliases),
2239                 (ndr_push_flags_fn_t) ndr_push_wbint_LookupUserAliases,
2240                 (ndr_pull_flags_fn_t) ndr_pull_wbint_LookupUserAliases,
2241                 (ndr_print_function_t) ndr_print_wbint_LookupUserAliases,
2242                 false,
2243         },
2244         {
2245                 "wbint_LookupUserGroups",
2246                 sizeof(struct wbint_LookupUserGroups),
2247                 (ndr_push_flags_fn_t) ndr_push_wbint_LookupUserGroups,
2248                 (ndr_pull_flags_fn_t) ndr_pull_wbint_LookupUserGroups,
2249                 (ndr_print_function_t) ndr_print_wbint_LookupUserGroups,
2250                 false,
2251         },
2252         {
2253                 "wbint_QuerySequenceNumber",
2254                 sizeof(struct wbint_QuerySequenceNumber),
2255                 (ndr_push_flags_fn_t) ndr_push_wbint_QuerySequenceNumber,
2256                 (ndr_pull_flags_fn_t) ndr_pull_wbint_QuerySequenceNumber,
2257                 (ndr_print_function_t) ndr_print_wbint_QuerySequenceNumber,
2258                 false,
2259         },
2260         {
2261                 "wbint_LookupGroupMembers",
2262                 sizeof(struct wbint_LookupGroupMembers),
2263                 (ndr_push_flags_fn_t) ndr_push_wbint_LookupGroupMembers,
2264                 (ndr_pull_flags_fn_t) ndr_pull_wbint_LookupGroupMembers,
2265                 (ndr_print_function_t) ndr_print_wbint_LookupGroupMembers,
2266                 false,
2267         },
2268         {
2269                 "wbint_QueryUserList",
2270                 sizeof(struct wbint_QueryUserList),
2271                 (ndr_push_flags_fn_t) ndr_push_wbint_QueryUserList,
2272                 (ndr_pull_flags_fn_t) ndr_pull_wbint_QueryUserList,
2273                 (ndr_print_function_t) ndr_print_wbint_QueryUserList,
2274                 false,
2275         },
2276         {
2277                 "wbint_QueryGroupList",
2278                 sizeof(struct wbint_QueryGroupList),
2279                 (ndr_push_flags_fn_t) ndr_push_wbint_QueryGroupList,
2280                 (ndr_pull_flags_fn_t) ndr_pull_wbint_QueryGroupList,
2281                 (ndr_print_function_t) ndr_print_wbint_QueryGroupList,
2282                 false,
2283         },
2284         {
2285                 "wbint_DsGetDcName",
2286                 sizeof(struct wbint_DsGetDcName),
2287                 (ndr_push_flags_fn_t) ndr_push_wbint_DsGetDcName,
2288                 (ndr_pull_flags_fn_t) ndr_pull_wbint_DsGetDcName,
2289                 (ndr_print_function_t) ndr_print_wbint_DsGetDcName,
2290                 false,
2291         },
2292         {
2293                 "wbint_LookupRids",
2294                 sizeof(struct wbint_LookupRids),
2295                 (ndr_push_flags_fn_t) ndr_push_wbint_LookupRids,
2296                 (ndr_pull_flags_fn_t) ndr_pull_wbint_LookupRids,
2297                 (ndr_print_function_t) ndr_print_wbint_LookupRids,
2298                 false,
2299         },
2300         {
2301                 "wbint_CheckMachineAccount",
2302                 sizeof(struct wbint_CheckMachineAccount),
2303                 (ndr_push_flags_fn_t) ndr_push_wbint_CheckMachineAccount,
2304                 (ndr_pull_flags_fn_t) ndr_pull_wbint_CheckMachineAccount,
2305                 (ndr_print_function_t) ndr_print_wbint_CheckMachineAccount,
2306                 false,
2307         },
2308         { NULL, 0, NULL, NULL, NULL, false }
2309 };
2310
2311 static const char * const wbint_endpoint_strings[] = {
2312         "ncalrpc:",
2313 };
2314
2315 static const struct ndr_interface_string_array wbint_endpoints = {
2316         .count  = 1,
2317         .names  = wbint_endpoint_strings
2318 };
2319
2320 static const char * const wbint_authservice_strings[] = {
2321         "host",
2322 };
2323
2324 static const struct ndr_interface_string_array wbint_authservices = {
2325         .count  = 1,
2326         .names  = wbint_authservice_strings
2327 };
2328
2329
2330 const struct ndr_interface_table ndr_table_wbint = {
2331         .name           = "wbint",
2332         .syntax_id      = {
2333                 {0xbf09192c,0xed60,0x4928,{0x9d,0xff},{0xd0,0xd7,0xbc,0xb0,0x3e,0xd8}},
2334                 NDR_WBINT_VERSION
2335         },
2336         .helpstring     = NDR_WBINT_HELPSTRING,
2337         .num_calls      = 19,
2338         .calls          = wbint_calls,
2339         .endpoints      = &wbint_endpoints,
2340         .authservices   = &wbint_authservices
2341 };
2342