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