source3/librpc/gen_ndr/ndr_wbint.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "librpc/gen_ndr/ndr_wbint.h"
   5
   6 #include "librpc/gen_ndr/ndr_lsa.h"
   7 _PUBLIC_ enum ndr_err_code ndr_push_wbint_userinfo(struct ndr_push *ndr, int ndr_flags, const struct wbint_userinfo *r)
   8 {
   9         if (ndr_flags & NDR_SCALARS) {
  10                 NDR_CHECK(ndr_push_align(ndr, 8));
  11                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->acct_name));
  12                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->full_name));
  13                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->homedir));
  14                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->shell));
  15                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->primary_gid));
  16                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->user_sid));
  17                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->group_sid));
  18         }
  19         if (ndr_flags & NDR_BUFFERS) {
  20                 if (r->acct_name) {
  21                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->acct_name, CH_UTF8)));
  22                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  23                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->acct_name, CH_UTF8)));
  24                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->acct_name, ndr_charset_length(r->acct_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
  25                 }
  26                 if (r->full_name) {
  27                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->full_name, CH_UTF8)));
  28                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  29                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->full_name, CH_UTF8)));
  30                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->full_name, ndr_charset_length(r->full_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
  31                 }
  32                 if (r->homedir) {
  33                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->homedir, CH_UTF8)));
  34                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  35                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->homedir, CH_UTF8)));
  36                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->homedir, ndr_charset_length(r->homedir, CH_UTF8), sizeof(uint8_t), CH_UTF8));
  37                 }
  38                 if (r->shell) {
  39                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->shell, CH_UTF8)));
  40                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  41                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->shell, CH_UTF8)));
  42                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->shell, ndr_charset_length(r->shell, CH_UTF8), sizeof(uint8_t), CH_UTF8));
  43                 }
  44         }
  45         return NDR_ERR_SUCCESS;
  46 }
  47
  48 _PUBLIC_ enum ndr_err_code ndr_pull_wbint_userinfo(struct ndr_pull *ndr, int ndr_flags, struct wbint_userinfo *r)
  49 {
  50         uint32_t _ptr_acct_name;
  51         TALLOC_CTX *_mem_save_acct_name_0;
  52         uint32_t _ptr_full_name;
  53         TALLOC_CTX *_mem_save_full_name_0;
  54         uint32_t _ptr_homedir;
  55         TALLOC_CTX *_mem_save_homedir_0;
  56         uint32_t _ptr_shell;
  57         TALLOC_CTX *_mem_save_shell_0;
  58         if (ndr_flags & NDR_SCALARS) {
  59                 NDR_CHECK(ndr_pull_align(ndr, 8));
  60                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_acct_name));
  61                 if (_ptr_acct_name) {
  62                         NDR_PULL_ALLOC(ndr, r->acct_name);
  63                 } else {
  64                         r->acct_name = NULL;
  65                 }
  66                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_full_name));
  67                 if (_ptr_full_name) {
  68                         NDR_PULL_ALLOC(ndr, r->full_name);
  69                 } else {
  70                         r->full_name = NULL;
  71                 }
  72                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_homedir));
  73                 if (_ptr_homedir) {
  74                         NDR_PULL_ALLOC(ndr, r->homedir);
  75                 } else {
  76                         r->homedir = NULL;
  77                 }
  78                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_shell));
  79                 if (_ptr_shell) {
  80                         NDR_PULL_ALLOC(ndr, r->shell);
  81                 } else {
  82                         r->shell = NULL;
  83                 }
  84                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->primary_gid));
  85                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, &r->user_sid));
  86                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, &r->group_sid));
  87         }
  88         if (ndr_flags & NDR_BUFFERS) {
  89                 if (r->acct_name) {
  90                         _mem_save_acct_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
  91                         NDR_PULL_SET_MEM_CTX(ndr, r->acct_name, 0);
  92                         NDR_CHECK(ndr_pull_array_size(ndr, &r->acct_name));
  93                         NDR_CHECK(ndr_pull_array_length(ndr, &r->acct_name));
  94                         if (ndr_get_array_length(ndr, &r->acct_name) > ndr_get_array_size(ndr, &r->acct_name)) {
  95                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->acct_name), ndr_get_array_length(ndr, &r->acct_name));
  96                         }
  97                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->acct_name), sizeof(uint8_t)));
  98                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->acct_name, ndr_get_array_length(ndr, &r->acct_name), sizeof(uint8_t), CH_UTF8));
  99                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_acct_name_0, 0);
 100                 }
 101                 if (r->full_name) {
 102                         _mem_save_full_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 103                         NDR_PULL_SET_MEM_CTX(ndr, r->full_name, 0);
 104                         NDR_CHECK(ndr_pull_array_size(ndr, &r->full_name));
 105                         NDR_CHECK(ndr_pull_array_length(ndr, &r->full_name));
 106                         if (ndr_get_array_length(ndr, &r->full_name) > ndr_get_array_size(ndr, &r->full_name)) {
 107                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->full_name), ndr_get_array_length(ndr, &r->full_name));
 108                         }
 109                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->full_name), sizeof(uint8_t)));
 110                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->full_name, ndr_get_array_length(ndr, &r->full_name), sizeof(uint8_t), CH_UTF8));
 111                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_full_name_0, 0);
 112                 }
 113                 if (r->homedir) {
 114                         _mem_save_homedir_0 = NDR_PULL_GET_MEM_CTX(ndr);
 115                         NDR_PULL_SET_MEM_CTX(ndr, r->homedir, 0);
 116                         NDR_CHECK(ndr_pull_array_size(ndr, &r->homedir));
 117                         NDR_CHECK(ndr_pull_array_length(ndr, &r->homedir));
 118                         if (ndr_get_array_length(ndr, &r->homedir) > ndr_get_array_size(ndr, &r->homedir)) {
 119                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->homedir), ndr_get_array_length(ndr, &r->homedir));
 120                         }
 121                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->homedir), sizeof(uint8_t)));
 122                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->homedir, ndr_get_array_length(ndr, &r->homedir), sizeof(uint8_t), CH_UTF8));
 123                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_homedir_0, 0);
 124                 }
 125                 if (r->shell) {
 126                         _mem_save_shell_0 = NDR_PULL_GET_MEM_CTX(ndr);
 127                         NDR_PULL_SET_MEM_CTX(ndr, r->shell, 0);
 128                         NDR_CHECK(ndr_pull_array_size(ndr, &r->shell));
 129                         NDR_CHECK(ndr_pull_array_length(ndr, &r->shell));
 130                         if (ndr_get_array_length(ndr, &r->shell) > ndr_get_array_size(ndr, &r->shell)) {
 131                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->shell), ndr_get_array_length(ndr, &r->shell));
 132                         }
 133                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->shell), sizeof(uint8_t)));
 134                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->shell, ndr_get_array_length(ndr, &r->shell), sizeof(uint8_t), CH_UTF8));
 135                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_shell_0, 0);
 136                 }
 137         }
 138         return NDR_ERR_SUCCESS;
 139 }
 140
 141 _PUBLIC_ void ndr_print_wbint_userinfo(struct ndr_print *ndr, const char *name, const struct wbint_userinfo *r)
 142 {
 143         ndr_print_struct(ndr, name, "wbint_userinfo");
 144         ndr->depth++;
 145         ndr_print_ptr(ndr, "acct_name", r->acct_name);
 146         ndr->depth++;
 147         if (r->acct_name) {
 148                 ndr_print_string(ndr, "acct_name", r->acct_name);
 149         }
 150         ndr->depth--;
 151         ndr_print_ptr(ndr, "full_name", r->full_name);
 152         ndr->depth++;
 153         if (r->full_name) {
 154                 ndr_print_string(ndr, "full_name", r->full_name);
 155         }
 156         ndr->depth--;
 157         ndr_print_ptr(ndr, "homedir", r->homedir);
 158         ndr->depth++;
 159         if (r->homedir) {
 160                 ndr_print_string(ndr, "homedir", r->homedir);
 161         }
 162         ndr->depth--;
 163         ndr_print_ptr(ndr, "shell", r->shell);
 164         ndr->depth++;
 165         if (r->shell) {
 166                 ndr_print_string(ndr, "shell", r->shell);
 167         }
 168         ndr->depth--;
 169         ndr_print_hyper(ndr, "primary_gid", r->primary_gid);
 170         ndr_print_dom_sid(ndr, "user_sid", &r->user_sid);
 171         ndr_print_dom_sid(ndr, "group_sid", &r->group_sid);
 172         ndr->depth--;
 173 }
 174
 175 _PUBLIC_ enum ndr_err_code ndr_push_wbint_SidArray(struct ndr_push *ndr, int ndr_flags, const struct wbint_SidArray *r)
 176 {
 177         uint32_t cntr_sids_0;
 178         if (ndr_flags & NDR_SCALARS) {
 179                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
 180                 NDR_CHECK(ndr_push_align(ndr, 4));
 181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
 182                 for (cntr_sids_0 = 0; cntr_sids_0 < r->num_sids; cntr_sids_0++) {
 183                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->sids[cntr_sids_0]));
 184                 }
 185         }
 186         if (ndr_flags & NDR_BUFFERS) {
 187         }
 188         return NDR_ERR_SUCCESS;
 189 }
 190
 191 _PUBLIC_ enum ndr_err_code ndr_pull_wbint_SidArray(struct ndr_pull *ndr, int ndr_flags, struct wbint_SidArray *r)
 192 {
 193         uint32_t cntr_sids_0;
 194         TALLOC_CTX *_mem_save_sids_0;
 195         if (ndr_flags & NDR_SCALARS) {
 196                 NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
 197                 NDR_CHECK(ndr_pull_align(ndr, 4));
 198                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sids));
 199                 NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
 200                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 201                 NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
 202                 for (cntr_sids_0 = 0; cntr_sids_0 < r->num_sids; cntr_sids_0++) {
 203                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, &r->sids[cntr_sids_0]));
 204                 }
 205                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
 206                 if (r->sids) {
 207                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->num_sids));
 208                 }
 209         }
 210         if (ndr_flags & NDR_BUFFERS) {
 211         }
 212         return NDR_ERR_SUCCESS;
 213 }
 214
 215 _PUBLIC_ void ndr_print_wbint_SidArray(struct ndr_print *ndr, const char *name, const struct wbint_SidArray *r)
 216 {
 217         uint32_t cntr_sids_0;
 218         ndr_print_struct(ndr, name, "wbint_SidArray");
 219         ndr->depth++;
 220         ndr_print_uint32(ndr, "num_sids", r->num_sids);
 221         ndr->print(ndr, "%s: ARRAY(%d)", "sids", (int)r->num_sids);
 222         ndr->depth++;
 223         for (cntr_sids_0=0;cntr_sids_0<r->num_sids;cntr_sids_0++) {
 224                 char *idx_0=NULL;
 225                 if (asprintf(&idx_0, "[%d]", cntr_sids_0) != -1) {
 226                         ndr_print_dom_sid(ndr, "sids", &r->sids[cntr_sids_0]);
 227                         free(idx_0);
 228                 }
 229         }
 230         ndr->depth--;
 231         ndr->depth--;
 232 }
 233
 234 _PUBLIC_ enum ndr_err_code ndr_push_wbint_RidArray(struct ndr_push *ndr, int ndr_flags, const struct wbint_RidArray *r)
 235 {
 236         uint32_t cntr_rids_0;
 237         if (ndr_flags & NDR_SCALARS) {
 238                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_rids));
 239                 NDR_CHECK(ndr_push_align(ndr, 4));
 240                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_rids));
 241                 for (cntr_rids_0 = 0; cntr_rids_0 < r->num_rids; cntr_rids_0++) {
 242                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rids[cntr_rids_0]));
 243                 }
 244         }
 245         if (ndr_flags & NDR_BUFFERS) {
 246         }
 247         return NDR_ERR_SUCCESS;
 248 }
 249
 250 _PUBLIC_ enum ndr_err_code ndr_pull_wbint_RidArray(struct ndr_pull *ndr, int ndr_flags, struct wbint_RidArray *r)
 251 {
 252         uint32_t cntr_rids_0;
 253         TALLOC_CTX *_mem_save_rids_0;
 254         if (ndr_flags & NDR_SCALARS) {
 255                 NDR_CHECK(ndr_pull_array_size(ndr, &r->rids));
 256                 NDR_CHECK(ndr_pull_align(ndr, 4));
 257                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_rids));
 258                 NDR_PULL_ALLOC_N(ndr, r->rids, ndr_get_array_size(ndr, &r->rids));
 259                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 260                 NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
 261                 for (cntr_rids_0 = 0; cntr_rids_0 < r->num_rids; cntr_rids_0++) {
 262                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rids[cntr_rids_0]));
 263                 }
 264                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
 265                 if (r->rids) {
 266                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->rids, r->num_rids));
 267                 }
 268         }
 269         if (ndr_flags & NDR_BUFFERS) {
 270         }
 271         return NDR_ERR_SUCCESS;
 272 }
 273
 274 _PUBLIC_ void ndr_print_wbint_RidArray(struct ndr_print *ndr, const char *name, const struct wbint_RidArray *r)
 275 {
 276         uint32_t cntr_rids_0;
 277         ndr_print_struct(ndr, name, "wbint_RidArray");
 278         ndr->depth++;
 279         ndr_print_uint32(ndr, "num_rids", r->num_rids);
 280         ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->num_rids);
 281         ndr->depth++;
 282         for (cntr_rids_0=0;cntr_rids_0<r->num_rids;cntr_rids_0++) {
 283                 char *idx_0=NULL;
 284                 if (asprintf(&idx_0, "[%d]", cntr_rids_0) != -1) {
 285                         ndr_print_uint32(ndr, "rids", r->rids[cntr_rids_0]);
 286                         free(idx_0);
 287                 }
 288         }
 289         ndr->depth--;
 290         ndr->depth--;
 291 }
 292
 293 _PUBLIC_ enum ndr_err_code ndr_push_wbint_Principal(struct ndr_push *ndr, int ndr_flags, const struct wbint_Principal *r)
 294 {
 295         if (ndr_flags & NDR_SCALARS) {
 296                 NDR_CHECK(ndr_push_align(ndr, 4));
 297                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->sid));
 298                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->type));
 299                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
 300         }
 301         if (ndr_flags & NDR_BUFFERS) {
 302                 if (r->name) {
 303                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF8)));
 304                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 305                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF8)));
 306                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 307                 }
 308         }
 309         return NDR_ERR_SUCCESS;
 310 }
 311
 312 _PUBLIC_ enum ndr_err_code ndr_pull_wbint_Principal(struct ndr_pull *ndr, int ndr_flags, struct wbint_Principal *r)
 313 {
 314         uint32_t _ptr_name;
 315         TALLOC_CTX *_mem_save_name_0;
 316         if (ndr_flags & NDR_SCALARS) {
 317                 NDR_CHECK(ndr_pull_align(ndr, 4));
 318                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, &r->sid));
 319                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->type));
 320                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
 321                 if (_ptr_name) {
 322                         NDR_PULL_ALLOC(ndr, r->name);
 323                 } else {
 324                         r->name = NULL;
 325                 }
 326         }
 327         if (ndr_flags & NDR_BUFFERS) {
 328                 if (r->name) {
 329                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 330                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
 331                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
 332                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
 333                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
 334                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
 335                         }
 336                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint8_t)));
 337                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint8_t), CH_UTF8));
 338                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
 339                 }
 340         }
 341         return NDR_ERR_SUCCESS;
 342 }
 343
 344 _PUBLIC_ void ndr_print_wbint_Principal(struct ndr_print *ndr, const char *name, const struct wbint_Principal *r)
 345 {
 346         ndr_print_struct(ndr, name, "wbint_Principal");
 347         ndr->depth++;
 348         ndr_print_dom_sid(ndr, "sid", &r->sid);
 349         ndr_print_lsa_SidType(ndr, "type", r->type);
 350         ndr_print_ptr(ndr, "name", r->name);
 351         ndr->depth++;
 352         if (r->name) {
 353                 ndr_print_string(ndr, "name", r->name);
 354         }
 355         ndr->depth--;
 356         ndr->depth--;
 357 }
 358
 359 _PUBLIC_ enum ndr_err_code ndr_push_wbint_Principals(struct ndr_push *ndr, int ndr_flags, const struct wbint_Principals *r)
 360 {
 361         uint32_t cntr_principals_0;
 362         if (ndr_flags & NDR_SCALARS) {
 363                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_principals));
 364                 NDR_CHECK(ndr_push_align(ndr, 4));
 365                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->num_principals));
 366                 for (cntr_principals_0 = 0; cntr_principals_0 < r->num_principals; cntr_principals_0++) {
 367                         NDR_CHECK(ndr_push_wbint_Principal(ndr, NDR_SCALARS, &r->principals[cntr_principals_0]));
 368                 }
 369         }
 370         if (ndr_flags & NDR_BUFFERS) {
 371                 for (cntr_principals_0 = 0; cntr_principals_0 < r->num_principals; cntr_principals_0++) {
 372                         NDR_CHECK(ndr_push_wbint_Principal(ndr, NDR_BUFFERS, &r->principals[cntr_principals_0]));
 373                 }
 374         }
 375         return NDR_ERR_SUCCESS;
 376 }
 377
 378 _PUBLIC_ enum ndr_err_code ndr_pull_wbint_Principals(struct ndr_pull *ndr, int ndr_flags, struct wbint_Principals *r)
 379 {
 380         uint32_t cntr_principals_0;
 381         TALLOC_CTX *_mem_save_principals_0;
 382         if (ndr_flags & NDR_SCALARS) {
 383                 NDR_CHECK(ndr_pull_array_size(ndr, &r->principals));
 384                 NDR_CHECK(ndr_pull_align(ndr, 4));
 385                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->num_principals));
 386                 NDR_PULL_ALLOC_N(ndr, r->principals, ndr_get_array_size(ndr, &r->principals));
 387                 _mem_save_principals_0 = NDR_PULL_GET_MEM_CTX(ndr);
 388                 NDR_PULL_SET_MEM_CTX(ndr, r->principals, 0);
 389                 for (cntr_principals_0 = 0; cntr_principals_0 < r->num_principals; cntr_principals_0++) {
 390                         NDR_CHECK(ndr_pull_wbint_Principal(ndr, NDR_SCALARS, &r->principals[cntr_principals_0]));
 391                 }
 392                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_principals_0, 0);
 393                 if (r->principals) {
 394                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->principals, r->num_principals));
 395                 }
 396         }
 397         if (ndr_flags & NDR_BUFFERS) {
 398                 _mem_save_principals_0 = NDR_PULL_GET_MEM_CTX(ndr);
 399                 NDR_PULL_SET_MEM_CTX(ndr, r->principals, 0);
 400                 for (cntr_principals_0 = 0; cntr_principals_0 < r->num_principals; cntr_principals_0++) {
 401                         NDR_CHECK(ndr_pull_wbint_Principal(ndr, NDR_BUFFERS, &r->principals[cntr_principals_0]));
 402                 }
 403                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_principals_0, 0);
 404         }
 405         return NDR_ERR_SUCCESS;
 406 }
 407
 408 _PUBLIC_ void ndr_print_wbint_Principals(struct ndr_print *ndr, const char *name, const struct wbint_Principals *r)
 409 {
 410         uint32_t cntr_principals_0;
 411         ndr_print_struct(ndr, name, "wbint_Principals");
 412         ndr->depth++;
 413         ndr_print_int32(ndr, "num_principals", r->num_principals);
 414         ndr->print(ndr, "%s: ARRAY(%d)", "principals", (int)r->num_principals);
 415         ndr->depth++;
 416         for (cntr_principals_0=0;cntr_principals_0<r->num_principals;cntr_principals_0++) {
 417                 char *idx_0=NULL;
 418                 if (asprintf(&idx_0, "[%d]", cntr_principals_0) != -1) {
 419                         ndr_print_wbint_Principal(ndr, "principals", &r->principals[cntr_principals_0]);
 420                         free(idx_0);
 421                 }
 422         }
 423         ndr->depth--;
 424         ndr->depth--;
 425 }
 426
 427 _PUBLIC_ enum ndr_err_code ndr_push_wbint_userinfos(struct ndr_push *ndr, int ndr_flags, const struct wbint_userinfos *r)
 428 {
 429         uint32_t cntr_userinfos_0;
 430         if (ndr_flags & NDR_SCALARS) {
 431                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_userinfos));
 432                 NDR_CHECK(ndr_push_align(ndr, 8));
 433                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_userinfos));
 434                 for (cntr_userinfos_0 = 0; cntr_userinfos_0 < r->num_userinfos; cntr_userinfos_0++) {
 435                         NDR_CHECK(ndr_push_wbint_userinfo(ndr, NDR_SCALARS, &r->userinfos[cntr_userinfos_0]));
 436                 }
 437         }
 438         if (ndr_flags & NDR_BUFFERS) {
 439                 for (cntr_userinfos_0 = 0; cntr_userinfos_0 < r->num_userinfos; cntr_userinfos_0++) {
 440                         NDR_CHECK(ndr_push_wbint_userinfo(ndr, NDR_BUFFERS, &r->userinfos[cntr_userinfos_0]));
 441                 }
 442         }
 443         return NDR_ERR_SUCCESS;
 444 }
 445
 446 _PUBLIC_ enum ndr_err_code ndr_pull_wbint_userinfos(struct ndr_pull *ndr, int ndr_flags, struct wbint_userinfos *r)
 447 {
 448         uint32_t cntr_userinfos_0;
 449         TALLOC_CTX *_mem_save_userinfos_0;
 450         if (ndr_flags & NDR_SCALARS) {
 451                 NDR_CHECK(ndr_pull_array_size(ndr, &r->userinfos));
 452                 NDR_CHECK(ndr_pull_align(ndr, 8));
 453                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_userinfos));
 454                 NDR_PULL_ALLOC_N(ndr, r->userinfos, ndr_get_array_size(ndr, &r->userinfos));
 455                 _mem_save_userinfos_0 = NDR_PULL_GET_MEM_CTX(ndr);
 456                 NDR_PULL_SET_MEM_CTX(ndr, r->userinfos, 0);
 457                 for (cntr_userinfos_0 = 0; cntr_userinfos_0 < r->num_userinfos; cntr_userinfos_0++) {
 458                         NDR_CHECK(ndr_pull_wbint_userinfo(ndr, NDR_SCALARS, &r->userinfos[cntr_userinfos_0]));
 459                 }
 460                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userinfos_0, 0);
 461                 if (r->userinfos) {
 462                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->userinfos, r->num_userinfos));
 463                 }
 464         }
 465         if (ndr_flags & NDR_BUFFERS) {
 466                 _mem_save_userinfos_0 = NDR_PULL_GET_MEM_CTX(ndr);
 467                 NDR_PULL_SET_MEM_CTX(ndr, r->userinfos, 0);
 468                 for (cntr_userinfos_0 = 0; cntr_userinfos_0 < r->num_userinfos; cntr_userinfos_0++) {
 469                         NDR_CHECK(ndr_pull_wbint_userinfo(ndr, NDR_BUFFERS, &r->userinfos[cntr_userinfos_0]));
 470                 }
 471                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userinfos_0, 0);
 472         }
 473         return NDR_ERR_SUCCESS;
 474 }
 475
 476 _PUBLIC_ void ndr_print_wbint_userinfos(struct ndr_print *ndr, const char *name, const struct wbint_userinfos *r)
 477 {
 478         uint32_t cntr_userinfos_0;
 479         ndr_print_struct(ndr, name, "wbint_userinfos");
 480         ndr->depth++;
 481         ndr_print_uint32(ndr, "num_userinfos", r->num_userinfos);
 482         ndr->print(ndr, "%s: ARRAY(%d)", "userinfos", (int)r->num_userinfos);
 483         ndr->depth++;
 484         for (cntr_userinfos_0=0;cntr_userinfos_0<r->num_userinfos;cntr_userinfos_0++) {
 485                 char *idx_0=NULL;
 486                 if (asprintf(&idx_0, "[%d]", cntr_userinfos_0) != -1) {
 487                         ndr_print_wbint_userinfo(ndr, "userinfos", &r->userinfos[cntr_userinfos_0]);
 488                         free(idx_0);
 489                 }
 490         }
 491         ndr->depth--;
 492         ndr->depth--;
 493 }
 494
 495 static enum ndr_err_code ndr_push_wbint_Ping(struct ndr_push *ndr, int flags, const struct wbint_Ping *r)
 496 {
 497         if (flags & NDR_IN) {
 498                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data));
 499         }
 500         if (flags & NDR_OUT) {
 501                 if (r->out.out_data == NULL) {
 502                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 503                 }
 504                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.out_data));
 505         }
 506         return NDR_ERR_SUCCESS;
 507 }
 508
 509 static enum ndr_err_code ndr_pull_wbint_Ping(struct ndr_pull *ndr, int flags, struct wbint_Ping *r)
 510 {
 511         TALLOC_CTX *_mem_save_out_data_0;
 512         if (flags & NDR_IN) {
 513                 ZERO_STRUCT(r->out);
 514
 515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.in_data));
 516                 NDR_PULL_ALLOC(ndr, r->out.out_data);
 517                 ZERO_STRUCTP(r->out.out_data);
 518         }
 519         if (flags & NDR_OUT) {
 520                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 521                         NDR_PULL_ALLOC(ndr, r->out.out_data);
 522                 }
 523                 _mem_save_out_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
 524                 NDR_PULL_SET_MEM_CTX(ndr, r->out.out_data, LIBNDR_FLAG_REF_ALLOC);
 525                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.out_data));
 526                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_out_data_0, LIBNDR_FLAG_REF_ALLOC);
 527         }
 528         return NDR_ERR_SUCCESS;
 529 }
 530
 531 _PUBLIC_ void ndr_print_wbint_Ping(struct ndr_print *ndr, const char *name, int flags, const struct wbint_Ping *r)
 532 {
 533         ndr_print_struct(ndr, name, "wbint_Ping");
 534         ndr->depth++;
 535         if (flags & NDR_SET_VALUES) {
 536                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 537         }
 538         if (flags & NDR_IN) {
 539                 ndr_print_struct(ndr, "in", "wbint_Ping");
 540                 ndr->depth++;
 541                 ndr_print_uint32(ndr, "in_data", r->in.in_data);
 542                 ndr->depth--;
 543         }
 544         if (flags & NDR_OUT) {
 545                 ndr_print_struct(ndr, "out", "wbint_Ping");
 546                 ndr->depth++;
 547                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
 548                 ndr->depth++;
 549                 ndr_print_uint32(ndr, "out_data", *r->out.out_data);
 550                 ndr->depth--;
 551                 ndr->depth--;
 552         }
 553         ndr->depth--;
 554 }
 555
 556 static enum ndr_err_code ndr_push_wbint_LookupSid(struct ndr_push *ndr, int flags, const struct wbint_LookupSid *r)
 557 {
 558         if (flags & NDR_IN) {
 559                 if (r->in.sid == NULL) {
 560                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 561                 }
 562                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.sid));
 563         }
 564         if (flags & NDR_OUT) {
 565                 if (r->out.type == NULL) {
 566                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 567                 }
 568                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, *r->out.type));
 569                 if (r->out.domain == NULL) {
 570                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 571                 }
 572                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domain));
 573                 if (*r->out.domain) {
 574                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.domain, CH_UTF8)));
 575                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 576                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.domain, CH_UTF8)));
 577                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.domain, ndr_charset_length(*r->out.domain, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 578                 }
 579                 if (r->out.name == NULL) {
 580                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 581                 }
 582                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.name));
 583                 if (*r->out.name) {
 584                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.name, CH_UTF8)));
 585                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 586                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.name, CH_UTF8)));
 587                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.name, ndr_charset_length(*r->out.name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 588                 }
 589                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 590         }
 591         return NDR_ERR_SUCCESS;
 592 }
 593
 594 static enum ndr_err_code ndr_pull_wbint_LookupSid(struct ndr_pull *ndr, int flags, struct wbint_LookupSid *r)
 595 {
 596         uint32_t _ptr_domain;
 597         uint32_t _ptr_name;
 598         TALLOC_CTX *_mem_save_sid_0;
 599         TALLOC_CTX *_mem_save_type_0;
 600         TALLOC_CTX *_mem_save_domain_0;
 601         TALLOC_CTX *_mem_save_domain_1;
 602         TALLOC_CTX *_mem_save_name_0;
 603         TALLOC_CTX *_mem_save_name_1;
 604         if (flags & NDR_IN) {
 605                 ZERO_STRUCT(r->out);
 606
 607                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 608                         NDR_PULL_ALLOC(ndr, r->in.sid);
 609                 }
 610                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 611                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
 612                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.sid));
 613                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
 614                 NDR_PULL_ALLOC(ndr, r->out.type);
 615                 ZERO_STRUCTP(r->out.type);
 616                 NDR_PULL_ALLOC(ndr, r->out.domain);
 617                 ZERO_STRUCTP(r->out.domain);
 618                 NDR_PULL_ALLOC(ndr, r->out.name);
 619                 ZERO_STRUCTP(r->out.name);
 620         }
 621         if (flags & NDR_OUT) {
 622                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 623                         NDR_PULL_ALLOC(ndr, r->out.type);
 624                 }
 625                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
 626                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
 627                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, r->out.type));
 628                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
 629                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 630                         NDR_PULL_ALLOC(ndr, r->out.domain);
 631                 }
 632                 _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
 633                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domain, LIBNDR_FLAG_REF_ALLOC);
 634                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
 635                 if (_ptr_domain) {
 636                         NDR_PULL_ALLOC(ndr, *r->out.domain);
 637                 } else {
 638                         *r->out.domain = NULL;
 639                 }
 640                 if (*r->out.domain) {
 641                         _mem_save_domain_1 = NDR_PULL_GET_MEM_CTX(ndr);
 642                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domain, 0);
 643                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.domain));
 644                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.domain));
 645                         if (ndr_get_array_length(ndr, r->out.domain) > ndr_get_array_size(ndr, r->out.domain)) {
 646                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, r->out.domain), ndr_get_array_length(ndr, r->out.domain));
 647                         }
 648                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.domain), sizeof(uint8_t)));
 649                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.domain, ndr_get_array_length(ndr, r->out.domain), sizeof(uint8_t), CH_UTF8));
 650                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_1, 0);
 651                 }
 652                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, LIBNDR_FLAG_REF_ALLOC);
 653                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 654                         NDR_PULL_ALLOC(ndr, r->out.name);
 655                 }
 656                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 657                 NDR_PULL_SET_MEM_CTX(ndr, r->out.name, LIBNDR_FLAG_REF_ALLOC);
 658                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
 659                 if (_ptr_name) {
 660                         NDR_PULL_ALLOC(ndr, *r->out.name);
 661                 } else {
 662                         *r->out.name = NULL;
 663                 }
 664                 if (*r->out.name) {
 665                         _mem_save_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
 666                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.name, 0);
 667                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.name));
 668                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.name));
 669                         if (ndr_get_array_length(ndr, r->out.name) > ndr_get_array_size(ndr, r->out.name)) {
 670                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, r->out.name), ndr_get_array_length(ndr, r->out.name));
 671                         }
 672                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.name), sizeof(uint8_t)));
 673                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.name, ndr_get_array_length(ndr, r->out.name), sizeof(uint8_t), CH_UTF8));
 674                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_1, 0);
 675                 }
 676                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
 677                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 678         }
 679         return NDR_ERR_SUCCESS;
 680 }
 681
 682 _PUBLIC_ void ndr_print_wbint_LookupSid(struct ndr_print *ndr, const char *name, int flags, const struct wbint_LookupSid *r)
 683 {
 684         ndr_print_struct(ndr, name, "wbint_LookupSid");
 685         ndr->depth++;
 686         if (flags & NDR_SET_VALUES) {
 687                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 688         }
 689         if (flags & NDR_IN) {
 690                 ndr_print_struct(ndr, "in", "wbint_LookupSid");
 691                 ndr->depth++;
 692                 ndr_print_ptr(ndr, "sid", r->in.sid);
 693                 ndr->depth++;
 694                 ndr_print_dom_sid(ndr, "sid", r->in.sid);
 695                 ndr->depth--;
 696                 ndr->depth--;
 697         }
 698         if (flags & NDR_OUT) {
 699                 ndr_print_struct(ndr, "out", "wbint_LookupSid");
 700                 ndr->depth++;
 701                 ndr_print_ptr(ndr, "type", r->out.type);
 702                 ndr->depth++;
 703                 ndr_print_lsa_SidType(ndr, "type", *r->out.type);
 704                 ndr->depth--;
 705                 ndr_print_ptr(ndr, "domain", r->out.domain);
 706                 ndr->depth++;
 707                 ndr_print_ptr(ndr, "domain", *r->out.domain);
 708                 ndr->depth++;
 709                 if (*r->out.domain) {
 710                         ndr_print_string(ndr, "domain", *r->out.domain);
 711                 }
 712                 ndr->depth--;
 713                 ndr->depth--;
 714                 ndr_print_ptr(ndr, "name", r->out.name);
 715                 ndr->depth++;
 716                 ndr_print_ptr(ndr, "name", *r->out.name);
 717                 ndr->depth++;
 718                 if (*r->out.name) {
 719                         ndr_print_string(ndr, "name", *r->out.name);
 720                 }
 721                 ndr->depth--;
 722                 ndr->depth--;
 723                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
 724                 ndr->depth--;
 725         }
 726         ndr->depth--;
 727 }
 728
 729 static enum ndr_err_code ndr_push_wbint_LookupName(struct ndr_push *ndr, int flags, const struct wbint_LookupName *r)
 730 {
 731         if (flags & NDR_IN) {
 732                 if (r->in.domain == NULL) {
 733                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 734                 }
 735                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain, CH_UTF8)));
 736                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 737                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain, CH_UTF8)));
 738                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.domain, ndr_charset_length(r->in.domain, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 739                 if (r->in.name == NULL) {
 740                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 741                 }
 742                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF8)));
 743                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 744                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF8)));
 745                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name, ndr_charset_length(r->in.name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 746                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
 747         }
 748         if (flags & NDR_OUT) {
 749                 if (r->out.type == NULL) {
 750                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 751                 }
 752                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, *r->out.type));
 753                 if (r->out.sid == NULL) {
 754                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 755                 }
 756                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->out.sid));
 757                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 758         }
 759         return NDR_ERR_SUCCESS;
 760 }
 761
 762 static enum ndr_err_code ndr_pull_wbint_LookupName(struct ndr_pull *ndr, int flags, struct wbint_LookupName *r)
 763 {
 764         TALLOC_CTX *_mem_save_type_0;
 765         TALLOC_CTX *_mem_save_sid_0;
 766         if (flags & NDR_IN) {
 767                 ZERO_STRUCT(r->out);
 768
 769                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain));
 770                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain));
 771                 if (ndr_get_array_length(ndr, &r->in.domain) > ndr_get_array_size(ndr, &r->in.domain)) {
 772                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.domain), ndr_get_array_length(ndr, &r->in.domain));
 773                 }
 774                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain), sizeof(uint8_t)));
 775                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.domain, ndr_get_array_length(ndr, &r->in.domain), sizeof(uint8_t), CH_UTF8));
 776                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name));
 777                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name));
 778                 if (ndr_get_array_length(ndr, &r->in.name) > ndr_get_array_size(ndr, &r->in.name)) {
 779                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.name), ndr_get_array_length(ndr, &r->in.name));
 780                 }
 781                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.name), sizeof(uint8_t)));
 782                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name, ndr_get_array_length(ndr, &r->in.name), sizeof(uint8_t), CH_UTF8));
 783                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
 784                 NDR_PULL_ALLOC(ndr, r->out.type);
 785                 ZERO_STRUCTP(r->out.type);
 786                 NDR_PULL_ALLOC(ndr, r->out.sid);
 787                 ZERO_STRUCTP(r->out.sid);
 788         }
 789         if (flags & NDR_OUT) {
 790                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 791                         NDR_PULL_ALLOC(ndr, r->out.type);
 792                 }
 793                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
 794                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
 795                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, r->out.type));
 796                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
 797                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 798                         NDR_PULL_ALLOC(ndr, r->out.sid);
 799                 }
 800                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 801                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);
 802                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->out.sid));
 803                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
 804                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 805         }
 806         return NDR_ERR_SUCCESS;
 807 }
 808
 809 _PUBLIC_ void ndr_print_wbint_LookupName(struct ndr_print *ndr, const char *name, int flags, const struct wbint_LookupName *r)
 810 {
 811         ndr_print_struct(ndr, name, "wbint_LookupName");
 812         ndr->depth++;
 813         if (flags & NDR_SET_VALUES) {
 814                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 815         }
 816         if (flags & NDR_IN) {
 817                 ndr_print_struct(ndr, "in", "wbint_LookupName");
 818                 ndr->depth++;
 819                 ndr_print_ptr(ndr, "domain", r->in.domain);
 820                 ndr->depth++;
 821                 ndr_print_string(ndr, "domain", r->in.domain);
 822                 ndr->depth--;
 823                 ndr_print_ptr(ndr, "name", r->in.name);
 824                 ndr->depth++;
 825                 ndr_print_string(ndr, "name", r->in.name);
 826                 ndr->depth--;
 827                 ndr_print_uint32(ndr, "flags", r->in.flags);
 828                 ndr->depth--;
 829         }
 830         if (flags & NDR_OUT) {
 831                 ndr_print_struct(ndr, "out", "wbint_LookupName");
 832                 ndr->depth++;
 833                 ndr_print_ptr(ndr, "type", r->out.type);
 834                 ndr->depth++;
 835                 ndr_print_lsa_SidType(ndr, "type", *r->out.type);
 836                 ndr->depth--;
 837                 ndr_print_ptr(ndr, "sid", r->out.sid);
 838                 ndr->depth++;
 839                 ndr_print_dom_sid(ndr, "sid", r->out.sid);
 840                 ndr->depth--;
 841                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
 842                 ndr->depth--;
 843         }
 844         ndr->depth--;
 845 }
 846
 847 static enum ndr_err_code ndr_push_wbint_Sid2Uid(struct ndr_push *ndr, int flags, const struct wbint_Sid2Uid *r)
 848 {
 849         if (flags & NDR_IN) {
 850                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dom_name));
 851                 if (r->in.dom_name) {
 852                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
 853                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 854                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
 855                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dom_name, ndr_charset_length(r->in.dom_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 856                 }
 857                 if (r->in.sid == NULL) {
 858                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 859                 }
 860                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.sid));
 861         }
 862         if (flags & NDR_OUT) {
 863                 if (r->out.uid == NULL) {
 864                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 865                 }
 866                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, *r->out.uid));
 867                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 868         }
 869         return NDR_ERR_SUCCESS;
 870 }
 871
 872 static enum ndr_err_code ndr_pull_wbint_Sid2Uid(struct ndr_pull *ndr, int flags, struct wbint_Sid2Uid *r)
 873 {
 874         uint32_t _ptr_dom_name;
 875         TALLOC_CTX *_mem_save_dom_name_0;
 876         TALLOC_CTX *_mem_save_sid_0;
 877         TALLOC_CTX *_mem_save_uid_0;
 878         if (flags & NDR_IN) {
 879                 ZERO_STRUCT(r->out);
 880
 881                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dom_name));
 882                 if (_ptr_dom_name) {
 883                         NDR_PULL_ALLOC(ndr, r->in.dom_name);
 884                 } else {
 885                         r->in.dom_name = NULL;
 886                 }
 887                 if (r->in.dom_name) {
 888                         _mem_save_dom_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 889                         NDR_PULL_SET_MEM_CTX(ndr, r->in.dom_name, 0);
 890                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dom_name));
 891                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dom_name));
 892                         if (ndr_get_array_length(ndr, &r->in.dom_name) > ndr_get_array_size(ndr, &r->in.dom_name)) {
 893                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.dom_name), ndr_get_array_length(ndr, &r->in.dom_name));
 894                         }
 895                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dom_name), sizeof(uint8_t)));
 896                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dom_name, ndr_get_array_length(ndr, &r->in.dom_name), sizeof(uint8_t), CH_UTF8));
 897                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dom_name_0, 0);
 898                 }
 899                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 900                         NDR_PULL_ALLOC(ndr, r->in.sid);
 901                 }
 902                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 903                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
 904                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.sid));
 905                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
 906                 NDR_PULL_ALLOC(ndr, r->out.uid);
 907                 ZERO_STRUCTP(r->out.uid);
 908         }
 909         if (flags & NDR_OUT) {
 910                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 911                         NDR_PULL_ALLOC(ndr, r->out.uid);
 912                 }
 913                 _mem_save_uid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 914                 NDR_PULL_SET_MEM_CTX(ndr, r->out.uid, LIBNDR_FLAG_REF_ALLOC);
 915                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, r->out.uid));
 916                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uid_0, LIBNDR_FLAG_REF_ALLOC);
 917                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 918         }
 919         return NDR_ERR_SUCCESS;
 920 }
 921
 922 _PUBLIC_ void ndr_print_wbint_Sid2Uid(struct ndr_print *ndr, const char *name, int flags, const struct wbint_Sid2Uid *r)
 923 {
 924         ndr_print_struct(ndr, name, "wbint_Sid2Uid");
 925         ndr->depth++;
 926         if (flags & NDR_SET_VALUES) {
 927                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 928         }
 929         if (flags & NDR_IN) {
 930                 ndr_print_struct(ndr, "in", "wbint_Sid2Uid");
 931                 ndr->depth++;
 932                 ndr_print_ptr(ndr, "dom_name", r->in.dom_name);
 933                 ndr->depth++;
 934                 if (r->in.dom_name) {
 935                         ndr_print_string(ndr, "dom_name", r->in.dom_name);
 936                 }
 937                 ndr->depth--;
 938                 ndr_print_ptr(ndr, "sid", r->in.sid);
 939                 ndr->depth++;
 940                 ndr_print_dom_sid(ndr, "sid", r->in.sid);
 941                 ndr->depth--;
 942                 ndr->depth--;
 943         }
 944         if (flags & NDR_OUT) {
 945                 ndr_print_struct(ndr, "out", "wbint_Sid2Uid");
 946                 ndr->depth++;
 947                 ndr_print_ptr(ndr, "uid", r->out.uid);
 948                 ndr->depth++;
 949                 ndr_print_hyper(ndr, "uid", *r->out.uid);
 950                 ndr->depth--;
 951                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
 952                 ndr->depth--;
 953         }
 954         ndr->depth--;
 955 }
 956
 957 static enum ndr_err_code ndr_push_wbint_Sid2Gid(struct ndr_push *ndr, int flags, const struct wbint_Sid2Gid *r)
 958 {
 959         if (flags & NDR_IN) {
 960                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dom_name));
 961                 if (r->in.dom_name) {
 962                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
 963                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 964                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
 965                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dom_name, ndr_charset_length(r->in.dom_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 966                 }
 967                 if (r->in.sid == NULL) {
 968                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 969                 }
 970                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.sid));
 971         }
 972         if (flags & NDR_OUT) {
 973                 if (r->out.gid == NULL) {
 974                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 975                 }
 976                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, *r->out.gid));
 977                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 978         }
 979         return NDR_ERR_SUCCESS;
 980 }
 981
 982 static enum ndr_err_code ndr_pull_wbint_Sid2Gid(struct ndr_pull *ndr, int flags, struct wbint_Sid2Gid *r)
 983 {
 984         uint32_t _ptr_dom_name;
 985         TALLOC_CTX *_mem_save_dom_name_0;
 986         TALLOC_CTX *_mem_save_sid_0;
 987         TALLOC_CTX *_mem_save_gid_0;
 988         if (flags & NDR_IN) {
 989                 ZERO_STRUCT(r->out);
 990
 991                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dom_name));
 992                 if (_ptr_dom_name) {
 993                         NDR_PULL_ALLOC(ndr, r->in.dom_name);
 994                 } else {
 995                         r->in.dom_name = NULL;
 996                 }
 997                 if (r->in.dom_name) {
 998                         _mem_save_dom_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 999                         NDR_PULL_SET_MEM_CTX(ndr, r->in.dom_name, 0);
1000                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dom_name));
1001                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dom_name));
1002                         if (ndr_get_array_length(ndr, &r->in.dom_name) > ndr_get_array_size(ndr, &r->in.dom_name)) {
1003                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.dom_name), ndr_get_array_length(ndr, &r->in.dom_name));
1004                         }
1005                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dom_name), sizeof(uint8_t)));
1006                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dom_name, ndr_get_array_length(ndr, &r->in.dom_name), sizeof(uint8_t), CH_UTF8));
1007                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dom_name_0, 0);
1008                 }
1009                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1010                         NDR_PULL_ALLOC(ndr, r->in.sid);
1011                 }
1012                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1013                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
1014                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.sid));
1015                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
1016                 NDR_PULL_ALLOC(ndr, r->out.gid);
1017                 ZERO_STRUCTP(r->out.gid);
1018         }
1019         if (flags & NDR_OUT) {
1020                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1021                         NDR_PULL_ALLOC(ndr, r->out.gid);
1022                 }
1023                 _mem_save_gid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1024                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gid, LIBNDR_FLAG_REF_ALLOC);
1025                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, r->out.gid));
1026                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gid_0, LIBNDR_FLAG_REF_ALLOC);
1027                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1028         }
1029         return NDR_ERR_SUCCESS;
1030 }
1031
1032 _PUBLIC_ void ndr_print_wbint_Sid2Gid(struct ndr_print *ndr, const char *name, int flags, const struct wbint_Sid2Gid *r)
1033 {
1034         ndr_print_struct(ndr, name, "wbint_Sid2Gid");
1035         ndr->depth++;
1036         if (flags & NDR_SET_VALUES) {
1037                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1038         }
1039         if (flags & NDR_IN) {
1040                 ndr_print_struct(ndr, "in", "wbint_Sid2Gid");
1041                 ndr->depth++;
1042                 ndr_print_ptr(ndr, "dom_name", r->in.dom_name);
1043                 ndr->depth++;
1044                 if (r->in.dom_name) {
1045                         ndr_print_string(ndr, "dom_name", r->in.dom_name);
1046                 }
1047                 ndr->depth--;
1048                 ndr_print_ptr(ndr, "sid", r->in.sid);
1049                 ndr->depth++;
1050                 ndr_print_dom_sid(ndr, "sid", r->in.sid);
1051                 ndr->depth--;
1052                 ndr->depth--;
1053         }
1054         if (flags & NDR_OUT) {
1055                 ndr_print_struct(ndr, "out", "wbint_Sid2Gid");
1056                 ndr->depth++;
1057                 ndr_print_ptr(ndr, "gid", r->out.gid);
1058                 ndr->depth++;
1059                 ndr_print_hyper(ndr, "gid", *r->out.gid);
1060                 ndr->depth--;
1061                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1062                 ndr->depth--;
1063         }
1064         ndr->depth--;
1065 }
1066
1067 static enum ndr_err_code ndr_push_wbint_Uid2Sid(struct ndr_push *ndr, int flags, const struct wbint_Uid2Sid *r)
1068 {
1069         if (flags & NDR_IN) {
1070                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dom_name));
1071                 if (r->in.dom_name) {
1072                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
1073                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1074                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
1075                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dom_name, ndr_charset_length(r->in.dom_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
1076                 }
1077                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->in.uid));
1078         }
1079         if (flags & NDR_OUT) {
1080                 if (r->out.sid == NULL) {
1081                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1082                 }
1083                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->out.sid));
1084                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1085         }
1086         return NDR_ERR_SUCCESS;
1087 }
1088
1089 static enum ndr_err_code ndr_pull_wbint_Uid2Sid(struct ndr_pull *ndr, int flags, struct wbint_Uid2Sid *r)
1090 {
1091         uint32_t _ptr_dom_name;
1092         TALLOC_CTX *_mem_save_dom_name_0;
1093         TALLOC_CTX *_mem_save_sid_0;
1094         if (flags & NDR_IN) {
1095                 ZERO_STRUCT(r->out);
1096
1097                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dom_name));
1098                 if (_ptr_dom_name) {
1099                         NDR_PULL_ALLOC(ndr, r->in.dom_name);
1100                 } else {
1101                         r->in.dom_name = NULL;
1102                 }
1103                 if (r->in.dom_name) {
1104                         _mem_save_dom_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1105                         NDR_PULL_SET_MEM_CTX(ndr, r->in.dom_name, 0);
1106                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dom_name));
1107                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dom_name));
1108                         if (ndr_get_array_length(ndr, &r->in.dom_name) > ndr_get_array_size(ndr, &r->in.dom_name)) {
1109                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.dom_name), ndr_get_array_length(ndr, &r->in.dom_name));
1110                         }
1111                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dom_name), sizeof(uint8_t)));
1112                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dom_name, ndr_get_array_length(ndr, &r->in.dom_name), sizeof(uint8_t), CH_UTF8));
1113                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dom_name_0, 0);
1114                 }
1115                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->in.uid));
1116                 NDR_PULL_ALLOC(ndr, r->out.sid);
1117                 ZERO_STRUCTP(r->out.sid);
1118         }
1119         if (flags & NDR_OUT) {
1120                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1121                         NDR_PULL_ALLOC(ndr, r->out.sid);
1122                 }
1123                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1124                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);
1125                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->out.sid));
1126                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
1127                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1128         }
1129         return NDR_ERR_SUCCESS;
1130 }
1131
1132 _PUBLIC_ void ndr_print_wbint_Uid2Sid(struct ndr_print *ndr, const char *name, int flags, const struct wbint_Uid2Sid *r)
1133 {
1134         ndr_print_struct(ndr, name, "wbint_Uid2Sid");
1135         ndr->depth++;
1136         if (flags & NDR_SET_VALUES) {
1137                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1138         }
1139         if (flags & NDR_IN) {
1140                 ndr_print_struct(ndr, "in", "wbint_Uid2Sid");
1141                 ndr->depth++;
1142                 ndr_print_ptr(ndr, "dom_name", r->in.dom_name);
1143                 ndr->depth++;
1144                 if (r->in.dom_name) {
1145                         ndr_print_string(ndr, "dom_name", r->in.dom_name);
1146                 }
1147                 ndr->depth--;
1148                 ndr_print_hyper(ndr, "uid", r->in.uid);
1149                 ndr->depth--;
1150         }
1151         if (flags & NDR_OUT) {
1152                 ndr_print_struct(ndr, "out", "wbint_Uid2Sid");
1153                 ndr->depth++;
1154                 ndr_print_ptr(ndr, "sid", r->out.sid);
1155                 ndr->depth++;
1156                 ndr_print_dom_sid(ndr, "sid", r->out.sid);
1157                 ndr->depth--;
1158                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1159                 ndr->depth--;
1160         }
1161         ndr->depth--;
1162 }
1163
1164 static enum ndr_err_code ndr_push_wbint_Gid2Sid(struct ndr_push *ndr, int flags, const struct wbint_Gid2Sid *r)
1165 {
1166         if (flags & NDR_IN) {
1167                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dom_name));
1168                 if (r->in.dom_name) {
1169                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
1170                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1171                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
1172                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dom_name, ndr_charset_length(r->in.dom_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
1173                 }
1174                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->in.gid));
1175         }
1176         if (flags & NDR_OUT) {
1177                 if (r->out.sid == NULL) {
1178                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1179                 }
1180                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->out.sid));
1181                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1182         }
1183         return NDR_ERR_SUCCESS;
1184 }
1185
1186 static enum ndr_err_code ndr_pull_wbint_Gid2Sid(struct ndr_pull *ndr, int flags, struct wbint_Gid2Sid *r)
1187 {
1188         uint32_t _ptr_dom_name;
1189         TALLOC_CTX *_mem_save_dom_name_0;
1190         TALLOC_CTX *_mem_save_sid_0;
1191         if (flags & NDR_IN) {
1192                 ZERO_STRUCT(r->out);
1193
1194                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dom_name));
1195                 if (_ptr_dom_name) {
1196                         NDR_PULL_ALLOC(ndr, r->in.dom_name);
1197                 } else {
1198                         r->in.dom_name = NULL;
1199                 }
1200                 if (r->in.dom_name) {
1201                         _mem_save_dom_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1202                         NDR_PULL_SET_MEM_CTX(ndr, r->in.dom_name, 0);
1203                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dom_name));
1204                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dom_name));
1205                         if (ndr_get_array_length(ndr, &r->in.dom_name) > ndr_get_array_size(ndr, &r->in.dom_name)) {
1206                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.dom_name), ndr_get_array_length(ndr, &r->in.dom_name));
1207                         }
1208                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dom_name), sizeof(uint8_t)));
1209                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dom_name, ndr_get_array_length(ndr, &r->in.dom_name), sizeof(uint8_t), CH_UTF8));
1210                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dom_name_0, 0);
1211                 }
1212                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->in.gid));
1213                 NDR_PULL_ALLOC(ndr, r->out.sid);
1214                 ZERO_STRUCTP(r->out.sid);
1215         }
1216         if (flags & NDR_OUT) {
1217                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1218                         NDR_PULL_ALLOC(ndr, r->out.sid);
1219                 }
1220                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1221                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);
1222                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->out.sid));
1223                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
1224                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1225         }
1226         return NDR_ERR_SUCCESS;
1227 }
1228
1229 _PUBLIC_ void ndr_print_wbint_Gid2Sid(struct ndr_print *ndr, const char *name, int flags, const struct wbint_Gid2Sid *r)
1230 {
1231         ndr_print_struct(ndr, name, "wbint_Gid2Sid");
1232         ndr->depth++;
1233         if (flags & NDR_SET_VALUES) {
1234                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1235         }
1236         if (flags & NDR_IN) {
1237                 ndr_print_struct(ndr, "in", "wbint_Gid2Sid");
1238                 ndr->depth++;
1239                 ndr_print_ptr(ndr, "dom_name", r->in.dom_name);
1240                 ndr->depth++;
1241                 if (r->in.dom_name) {
1242                         ndr_print_string(ndr, "dom_name", r->in.dom_name);
1243                 }
1244                 ndr->depth--;
1245                 ndr_print_hyper(ndr, "gid", r->in.gid);
1246                 ndr->depth--;
1247         }
1248         if (flags & NDR_OUT) {
1249                 ndr_print_struct(ndr, "out", "wbint_Gid2Sid");
1250                 ndr->depth++;
1251                 ndr_print_ptr(ndr, "sid", r->out.sid);
1252                 ndr->depth++;
1253                 ndr_print_dom_sid(ndr, "sid", r->out.sid);
1254                 ndr->depth--;
1255                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1256                 ndr->depth--;
1257         }
1258         ndr->depth--;
1259 }
1260
1261 static enum ndr_err_code ndr_push_wbint_QueryUser(struct ndr_push *ndr, int flags, const struct wbint_QueryUser *r)
1262 {
1263         if (flags & NDR_IN) {
1264                 if (r->in.sid == NULL) {
1265                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1266                 }
1267                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.sid));
1268         }
1269         if (flags & NDR_OUT) {
1270                 if (r->out.info == NULL) {
1271                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1272                 }
1273                 NDR_CHECK(ndr_push_wbint_userinfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
1274                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1275         }
1276         return NDR_ERR_SUCCESS;
1277 }
1278
1279 static enum ndr_err_code ndr_pull_wbint_QueryUser(struct ndr_pull *ndr, int flags, struct wbint_QueryUser *r)
1280 {
1281         TALLOC_CTX *_mem_save_sid_0;
1282         TALLOC_CTX *_mem_save_info_0;
1283         if (flags & NDR_IN) {
1284                 ZERO_STRUCT(r->out);
1285
1286                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1287                         NDR_PULL_ALLOC(ndr, r->in.sid);
1288                 }
1289                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1290                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
1291                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.sid));
1292                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
1293                 NDR_PULL_ALLOC(ndr, r->out.info);
1294                 ZERO_STRUCTP(r->out.info);
1295         }
1296         if (flags & NDR_OUT) {
1297                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1298                         NDR_PULL_ALLOC(ndr, r->out.info);
1299                 }
1300                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
1301                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
1302                 NDR_CHECK(ndr_pull_wbint_userinfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
1303                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
1304                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1305         }
1306         return NDR_ERR_SUCCESS;
1307 }
1308
1309 _PUBLIC_ void ndr_print_wbint_QueryUser(struct ndr_print *ndr, const char *name, int flags, const struct wbint_QueryUser *r)
1310 {
1311         ndr_print_struct(ndr, name, "wbint_QueryUser");
1312         ndr->depth++;
1313         if (flags & NDR_SET_VALUES) {
1314                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1315         }
1316         if (flags & NDR_IN) {
1317                 ndr_print_struct(ndr, "in", "wbint_QueryUser");
1318                 ndr->depth++;
1319                 ndr_print_ptr(ndr, "sid", r->in.sid);
1320                 ndr->depth++;
1321                 ndr_print_dom_sid(ndr, "sid", r->in.sid);
1322                 ndr->depth--;
1323                 ndr->depth--;
1324         }
1325         if (flags & NDR_OUT) {
1326                 ndr_print_struct(ndr, "out", "wbint_QueryUser");
1327                 ndr->depth++;
1328                 ndr_print_ptr(ndr, "info", r->out.info);
1329                 ndr->depth++;
1330                 ndr_print_wbint_userinfo(ndr, "info", r->out.info);
1331                 ndr->depth--;
1332                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1333                 ndr->depth--;
1334         }
1335         ndr->depth--;
1336 }
1337
1338 static enum ndr_err_code ndr_push_wbint_LookupUserAliases(struct ndr_push *ndr, int flags, const struct wbint_LookupUserAliases *r)
1339 {
1340         if (flags & NDR_IN) {
1341                 if (r->in.sids == NULL) {
1342                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1343                 }
1344                 NDR_CHECK(ndr_push_wbint_SidArray(ndr, NDR_SCALARS, r->in.sids));
1345         }
1346         if (flags & NDR_OUT) {
1347                 if (r->out.rids == NULL) {
1348                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1349                 }
1350                 NDR_CHECK(ndr_push_wbint_RidArray(ndr, NDR_SCALARS, r->out.rids));
1351                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1352         }
1353         return NDR_ERR_SUCCESS;
1354 }
1355
1356 static enum ndr_err_code ndr_pull_wbint_LookupUserAliases(struct ndr_pull *ndr, int flags, struct wbint_LookupUserAliases *r)
1357 {
1358         TALLOC_CTX *_mem_save_sids_0;
1359         TALLOC_CTX *_mem_save_rids_0;
1360         if (flags & NDR_IN) {
1361                 ZERO_STRUCT(r->out);
1362
1363                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1364                         NDR_PULL_ALLOC(ndr, r->in.sids);
1365                 }
1366                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1367                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
1368                 NDR_CHECK(ndr_pull_wbint_SidArray(ndr, NDR_SCALARS, r->in.sids));
1369                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
1370                 NDR_PULL_ALLOC(ndr, r->out.rids);
1371                 ZERO_STRUCTP(r->out.rids);
1372         }
1373         if (flags & NDR_OUT) {
1374                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1375                         NDR_PULL_ALLOC(ndr, r->out.rids);
1376                 }
1377                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1378                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
1379                 NDR_CHECK(ndr_pull_wbint_RidArray(ndr, NDR_SCALARS, r->out.rids));
1380                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
1381                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1382         }
1383         return NDR_ERR_SUCCESS;
1384 }
1385
1386 _PUBLIC_ void ndr_print_wbint_LookupUserAliases(struct ndr_print *ndr, const char *name, int flags, const struct wbint_LookupUserAliases *r)
1387 {
1388         ndr_print_struct(ndr, name, "wbint_LookupUserAliases");
1389         ndr->depth++;
1390         if (flags & NDR_SET_VALUES) {
1391                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1392         }
1393         if (flags & NDR_IN) {
1394                 ndr_print_struct(ndr, "in", "wbint_LookupUserAliases");
1395                 ndr->depth++;
1396                 ndr_print_ptr(ndr, "sids", r->in.sids);
1397                 ndr->depth++;
1398                 ndr_print_wbint_SidArray(ndr, "sids", r->in.sids);
1399                 ndr->depth--;
1400                 ndr->depth--;
1401         }
1402         if (flags & NDR_OUT) {
1403                 ndr_print_struct(ndr, "out", "wbint_LookupUserAliases");
1404                 ndr->depth++;
1405                 ndr_print_ptr(ndr, "rids", r->out.rids);
1406                 ndr->depth++;
1407                 ndr_print_wbint_RidArray(ndr, "rids", r->out.rids);
1408                 ndr->depth--;
1409                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1410                 ndr->depth--;
1411         }
1412         ndr->depth--;
1413 }
1414
1415 static enum ndr_err_code ndr_push_wbint_LookupUserGroups(struct ndr_push *ndr, int flags, const struct wbint_LookupUserGroups *r)
1416 {
1417         if (flags & NDR_IN) {
1418                 if (r->in.sid == NULL) {
1419                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1420                 }
1421                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.sid));
1422         }
1423         if (flags & NDR_OUT) {
1424                 if (r->out.sids == NULL) {
1425                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1426                 }
1427                 NDR_CHECK(ndr_push_wbint_SidArray(ndr, NDR_SCALARS, r->out.sids));
1428                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1429         }
1430         return NDR_ERR_SUCCESS;
1431 }
1432
1433 static enum ndr_err_code ndr_pull_wbint_LookupUserGroups(struct ndr_pull *ndr, int flags, struct wbint_LookupUserGroups *r)
1434 {
1435         TALLOC_CTX *_mem_save_sid_0;
1436         TALLOC_CTX *_mem_save_sids_0;
1437         if (flags & NDR_IN) {
1438                 ZERO_STRUCT(r->out);
1439
1440                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1441                         NDR_PULL_ALLOC(ndr, r->in.sid);
1442                 }
1443                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1444                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
1445                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.sid));
1446                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
1447                 NDR_PULL_ALLOC(ndr, r->out.sids);
1448                 ZERO_STRUCTP(r->out.sids);
1449         }
1450         if (flags & NDR_OUT) {
1451                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1452                         NDR_PULL_ALLOC(ndr, r->out.sids);
1453                 }
1454                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1455                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
1456                 NDR_CHECK(ndr_pull_wbint_SidArray(ndr, NDR_SCALARS, r->out.sids));
1457                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
1458                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1459         }
1460         return NDR_ERR_SUCCESS;
1461 }
1462
1463 _PUBLIC_ void ndr_print_wbint_LookupUserGroups(struct ndr_print *ndr, const char *name, int flags, const struct wbint_LookupUserGroups *r)
1464 {
1465         ndr_print_struct(ndr, name, "wbint_LookupUserGroups");
1466         ndr->depth++;
1467         if (flags & NDR_SET_VALUES) {
1468                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1469         }
1470         if (flags & NDR_IN) {
1471                 ndr_print_struct(ndr, "in", "wbint_LookupUserGroups");
1472                 ndr->depth++;
1473                 ndr_print_ptr(ndr, "sid", r->in.sid);
1474                 ndr->depth++;
1475                 ndr_print_dom_sid(ndr, "sid", r->in.sid);
1476                 ndr->depth--;
1477                 ndr->depth--;
1478         }
1479         if (flags & NDR_OUT) {
1480                 ndr_print_struct(ndr, "out", "wbint_LookupUserGroups");
1481                 ndr->depth++;
1482                 ndr_print_ptr(ndr, "sids", r->out.sids);
1483                 ndr->depth++;
1484                 ndr_print_wbint_SidArray(ndr, "sids", r->out.sids);
1485                 ndr->depth--;
1486                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1487                 ndr->depth--;
1488         }
1489         ndr->depth--;
1490 }
1491
1492 static enum ndr_err_code ndr_push_wbint_QuerySequenceNumber(struct ndr_push *ndr, int flags, const struct wbint_QuerySequenceNumber *r)
1493 {
1494         if (flags & NDR_IN) {
1495         }
1496         if (flags & NDR_OUT) {
1497                 if (r->out.sequence == NULL) {
1498                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1499                 }
1500                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.sequence));
1501                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1502         }
1503         return NDR_ERR_SUCCESS;
1504 }
1505
1506 static enum ndr_err_code ndr_pull_wbint_QuerySequenceNumber(struct ndr_pull *ndr, int flags, struct wbint_QuerySequenceNumber *r)
1507 {
1508         TALLOC_CTX *_mem_save_sequence_0;
1509         if (flags & NDR_IN) {
1510                 ZERO_STRUCT(r->out);
1511
1512                 NDR_PULL_ALLOC(ndr, r->out.sequence);
1513                 ZERO_STRUCTP(r->out.sequence);
1514         }
1515         if (flags & NDR_OUT) {
1516                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1517                         NDR_PULL_ALLOC(ndr, r->out.sequence);
1518                 }
1519                 _mem_save_sequence_0 = NDR_PULL_GET_MEM_CTX(ndr);
1520                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sequence, LIBNDR_FLAG_REF_ALLOC);
1521                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.sequence));
1522                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sequence_0, LIBNDR_FLAG_REF_ALLOC);
1523                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1524         }
1525         return NDR_ERR_SUCCESS;
1526 }
1527
1528 _PUBLIC_ void ndr_print_wbint_QuerySequenceNumber(struct ndr_print *ndr, const char *name, int flags, const struct wbint_QuerySequenceNumber *r)
1529 {
1530         ndr_print_struct(ndr, name, "wbint_QuerySequenceNumber");
1531         ndr->depth++;
1532         if (flags & NDR_SET_VALUES) {
1533                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1534         }
1535         if (flags & NDR_IN) {
1536                 ndr_print_struct(ndr, "in", "wbint_QuerySequenceNumber");
1537                 ndr->depth++;
1538                 ndr->depth--;
1539         }
1540         if (flags & NDR_OUT) {
1541                 ndr_print_struct(ndr, "out", "wbint_QuerySequenceNumber");
1542                 ndr->depth++;
1543                 ndr_print_ptr(ndr, "sequence", r->out.sequence);
1544                 ndr->depth++;
1545                 ndr_print_uint32(ndr, "sequence", *r->out.sequence);
1546                 ndr->depth--;
1547                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1548                 ndr->depth--;
1549         }
1550         ndr->depth--;
1551 }
1552
1553 static enum ndr_err_code ndr_push_wbint_LookupGroupMembers(struct ndr_push *ndr, int flags, const struct wbint_LookupGroupMembers *r)
1554 {
1555         if (flags & NDR_IN) {
1556                 if (r->in.sid == NULL) {
1557                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1558                 }
1559                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.sid));
1560                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->in.type));
1561         }
1562         if (flags & NDR_OUT) {
1563                 if (r->out.members == NULL) {
1564                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1565                 }
1566                 NDR_CHECK(ndr_push_wbint_Principals(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.members));
1567                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1568         }
1569         return NDR_ERR_SUCCESS;
1570 }
1571
1572 static enum ndr_err_code ndr_pull_wbint_LookupGroupMembers(struct ndr_pull *ndr, int flags, struct wbint_LookupGroupMembers *r)
1573 {
1574         TALLOC_CTX *_mem_save_sid_0;
1575         TALLOC_CTX *_mem_save_members_0;
1576         if (flags & NDR_IN) {
1577                 ZERO_STRUCT(r->out);
1578
1579                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1580                         NDR_PULL_ALLOC(ndr, r->in.sid);
1581                 }
1582                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1583                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
1584                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.sid));
1585                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
1586                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->in.type));
1587                 NDR_PULL_ALLOC(ndr, r->out.members);
1588                 ZERO_STRUCTP(r->out.members);
1589         }
1590         if (flags & NDR_OUT) {
1591                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1592                         NDR_PULL_ALLOC(ndr, r->out.members);
1593                 }
1594                 _mem_save_members_0 = NDR_PULL_GET_MEM_CTX(ndr);
1595                 NDR_PULL_SET_MEM_CTX(ndr, r->out.members, LIBNDR_FLAG_REF_ALLOC);
1596                 NDR_CHECK(ndr_pull_wbint_Principals(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.members));
1597                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_members_0, LIBNDR_FLAG_REF_ALLOC);
1598                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1599         }
1600         return NDR_ERR_SUCCESS;
1601 }
1602
1603 _PUBLIC_ void ndr_print_wbint_LookupGroupMembers(struct ndr_print *ndr, const char *name, int flags, const struct wbint_LookupGroupMembers *r)
1604 {
1605         ndr_print_struct(ndr, name, "wbint_LookupGroupMembers");
1606         ndr->depth++;
1607         if (flags & NDR_SET_VALUES) {
1608                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1609         }
1610         if (flags & NDR_IN) {
1611                 ndr_print_struct(ndr, "in", "wbint_LookupGroupMembers");
1612                 ndr->depth++;
1613                 ndr_print_ptr(ndr, "sid", r->in.sid);
1614                 ndr->depth++;
1615                 ndr_print_dom_sid(ndr, "sid", r->in.sid);
1616                 ndr->depth--;
1617                 ndr_print_lsa_SidType(ndr, "type", r->in.type);
1618                 ndr->depth--;
1619         }
1620         if (flags & NDR_OUT) {
1621                 ndr_print_struct(ndr, "out", "wbint_LookupGroupMembers");
1622                 ndr->depth++;
1623                 ndr_print_ptr(ndr, "members", r->out.members);
1624                 ndr->depth++;
1625                 ndr_print_wbint_Principals(ndr, "members", r->out.members);
1626                 ndr->depth--;
1627                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1628                 ndr->depth--;
1629         }
1630         ndr->depth--;
1631 }
1632
1633 static enum ndr_err_code ndr_push_wbint_QueryUserList(struct ndr_push *ndr, int flags, const struct wbint_QueryUserList *r)
1634 {
1635         if (flags & NDR_IN) {
1636         }
1637         if (flags & NDR_OUT) {
1638                 if (r->out.users == NULL) {
1639                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1640                 }
1641                 NDR_CHECK(ndr_push_wbint_userinfos(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.users));
1642                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1643         }
1644         return NDR_ERR_SUCCESS;
1645 }
1646
1647 static enum ndr_err_code ndr_pull_wbint_QueryUserList(struct ndr_pull *ndr, int flags, struct wbint_QueryUserList *r)
1648 {
1649         TALLOC_CTX *_mem_save_users_0;
1650         if (flags & NDR_IN) {
1651                 ZERO_STRUCT(r->out);
1652
1653                 NDR_PULL_ALLOC(ndr, r->out.users);
1654                 ZERO_STRUCTP(r->out.users);
1655         }
1656         if (flags & NDR_OUT) {
1657                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1658                         NDR_PULL_ALLOC(ndr, r->out.users);
1659                 }
1660                 _mem_save_users_0 = NDR_PULL_GET_MEM_CTX(ndr);
1661                 NDR_PULL_SET_MEM_CTX(ndr, r->out.users, LIBNDR_FLAG_REF_ALLOC);
1662                 NDR_CHECK(ndr_pull_wbint_userinfos(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.users));
1663                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_users_0, LIBNDR_FLAG_REF_ALLOC);
1664                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1665         }
1666         return NDR_ERR_SUCCESS;
1667 }
1668
1669 _PUBLIC_ void ndr_print_wbint_QueryUserList(struct ndr_print *ndr, const char *name, int flags, const struct wbint_QueryUserList *r)
1670 {
1671         ndr_print_struct(ndr, name, "wbint_QueryUserList");
1672         ndr->depth++;
1673         if (flags & NDR_SET_VALUES) {
1674                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1675         }
1676         if (flags & NDR_IN) {
1677                 ndr_print_struct(ndr, "in", "wbint_QueryUserList");
1678                 ndr->depth++;
1679                 ndr->depth--;
1680         }
1681         if (flags & NDR_OUT) {
1682                 ndr_print_struct(ndr, "out", "wbint_QueryUserList");
1683                 ndr->depth++;
1684                 ndr_print_ptr(ndr, "users", r->out.users);
1685                 ndr->depth++;
1686                 ndr_print_wbint_userinfos(ndr, "users", r->out.users);
1687                 ndr->depth--;
1688                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1689                 ndr->depth--;
1690         }
1691         ndr->depth--;
1692 }
1693
1694 static const struct ndr_interface_call wbint_calls[] = {
1695         {
1696                 "wbint_Ping",
1697                 sizeof(struct wbint_Ping),
1698                 (ndr_push_flags_fn_t) ndr_push_wbint_Ping,
1699                 (ndr_pull_flags_fn_t) ndr_pull_wbint_Ping,
1700                 (ndr_print_function_t) ndr_print_wbint_Ping,
1701                 false,
1702         },
1703         {
1704                 "wbint_LookupSid",
1705                 sizeof(struct wbint_LookupSid),
1706                 (ndr_push_flags_fn_t) ndr_push_wbint_LookupSid,
1707                 (ndr_pull_flags_fn_t) ndr_pull_wbint_LookupSid,
1708                 (ndr_print_function_t) ndr_print_wbint_LookupSid,
1709                 false,
1710         },
1711         {
1712                 "wbint_LookupName",
1713                 sizeof(struct wbint_LookupName),
1714                 (ndr_push_flags_fn_t) ndr_push_wbint_LookupName,
1715                 (ndr_pull_flags_fn_t) ndr_pull_wbint_LookupName,
1716                 (ndr_print_function_t) ndr_print_wbint_LookupName,
1717                 false,
1718         },
1719         {
1720                 "wbint_Sid2Uid",
1721                 sizeof(struct wbint_Sid2Uid),
1722                 (ndr_push_flags_fn_t) ndr_push_wbint_Sid2Uid,
1723                 (ndr_pull_flags_fn_t) ndr_pull_wbint_Sid2Uid,
1724                 (ndr_print_function_t) ndr_print_wbint_Sid2Uid,
1725                 false,
1726         },
1727         {
1728                 "wbint_Sid2Gid",
1729                 sizeof(struct wbint_Sid2Gid),
1730                 (ndr_push_flags_fn_t) ndr_push_wbint_Sid2Gid,
1731                 (ndr_pull_flags_fn_t) ndr_pull_wbint_Sid2Gid,
1732                 (ndr_print_function_t) ndr_print_wbint_Sid2Gid,
1733                 false,
1734         },
1735         {
1736                 "wbint_Uid2Sid",
1737                 sizeof(struct wbint_Uid2Sid),
1738                 (ndr_push_flags_fn_t) ndr_push_wbint_Uid2Sid,
1739                 (ndr_pull_flags_fn_t) ndr_pull_wbint_Uid2Sid,
1740                 (ndr_print_function_t) ndr_print_wbint_Uid2Sid,
1741                 false,
1742         },
1743         {
1744                 "wbint_Gid2Sid",
1745                 sizeof(struct wbint_Gid2Sid),
1746                 (ndr_push_flags_fn_t) ndr_push_wbint_Gid2Sid,
1747                 (ndr_pull_flags_fn_t) ndr_pull_wbint_Gid2Sid,
1748                 (ndr_print_function_t) ndr_print_wbint_Gid2Sid,
1749                 false,
1750         },
1751         {
1752                 "wbint_QueryUser",
1753                 sizeof(struct wbint_QueryUser),
1754                 (ndr_push_flags_fn_t) ndr_push_wbint_QueryUser,
1755                 (ndr_pull_flags_fn_t) ndr_pull_wbint_QueryUser,
1756                 (ndr_print_function_t) ndr_print_wbint_QueryUser,
1757                 false,
1758         },
1759         {
1760                 "wbint_LookupUserAliases",
1761                 sizeof(struct wbint_LookupUserAliases),
1762                 (ndr_push_flags_fn_t) ndr_push_wbint_LookupUserAliases,
1763                 (ndr_pull_flags_fn_t) ndr_pull_wbint_LookupUserAliases,
1764                 (ndr_print_function_t) ndr_print_wbint_LookupUserAliases,
1765                 false,
1766         },
1767         {
1768                 "wbint_LookupUserGroups",
1769                 sizeof(struct wbint_LookupUserGroups),
1770                 (ndr_push_flags_fn_t) ndr_push_wbint_LookupUserGroups,
1771                 (ndr_pull_flags_fn_t) ndr_pull_wbint_LookupUserGroups,
1772                 (ndr_print_function_t) ndr_print_wbint_LookupUserGroups,
1773                 false,
1774         },
1775         {
1776                 "wbint_QuerySequenceNumber",
1777                 sizeof(struct wbint_QuerySequenceNumber),
1778                 (ndr_push_flags_fn_t) ndr_push_wbint_QuerySequenceNumber,
1779                 (ndr_pull_flags_fn_t) ndr_pull_wbint_QuerySequenceNumber,
1780                 (ndr_print_function_t) ndr_print_wbint_QuerySequenceNumber,
1781                 false,
1782         },
1783         {
1784                 "wbint_LookupGroupMembers",
1785                 sizeof(struct wbint_LookupGroupMembers),
1786                 (ndr_push_flags_fn_t) ndr_push_wbint_LookupGroupMembers,
1787                 (ndr_pull_flags_fn_t) ndr_pull_wbint_LookupGroupMembers,
1788                 (ndr_print_function_t) ndr_print_wbint_LookupGroupMembers,
1789                 false,
1790         },
1791         {
1792                 "wbint_QueryUserList",
1793                 sizeof(struct wbint_QueryUserList),
1794                 (ndr_push_flags_fn_t) ndr_push_wbint_QueryUserList,
1795                 (ndr_pull_flags_fn_t) ndr_pull_wbint_QueryUserList,
1796                 (ndr_print_function_t) ndr_print_wbint_QueryUserList,
1797                 false,
1798         },
1799         { NULL, 0, NULL, NULL, NULL, false }
1800 };
1801
1802 static const char * const wbint_endpoint_strings[] = {
1803         "ncalrpc:",
1804 };
1805
1806 static const struct ndr_interface_string_array wbint_endpoints = {
1807         .count  = 1,
1808         .names  = wbint_endpoint_strings
1809 };
1810
1811 static const char * const wbint_authservice_strings[] = {
1812         "host",
1813 };
1814
1815 static const struct ndr_interface_string_array wbint_authservices = {
1816         .count  = 1,
1817         .names  = wbint_authservice_strings
1818 };
1819
1820
1821 const struct ndr_interface_table ndr_table_wbint = {
1822         .name           = "wbint",
1823         .syntax_id      = {
1824                 {0xbf09192c,0xed60,0x4928,{0x9d,0xff},{0xd0,0xd7,0xbc,0xb0,0x3e,0xd8}},
1825                 NDR_WBINT_VERSION
1826         },
1827         .helpstring     = NDR_WBINT_HELPSTRING,
1828         .num_calls      = 13,
1829         .calls          = wbint_calls,
1830         .endpoints      = &wbint_endpoints,
1831         .authservices   = &wbint_authservices
1832 };
1833