bin/default/source4/librpc/gen_ndr/ndr_irpc.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "bin/default/source4/librpc/gen_ndr/ndr_irpc.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 #include "librpc/gen_ndr/ndr_security.h"
   8 #include "librpc/gen_ndr/ndr_nbt.h"
   9 #include "librpc/gen_ndr/ndr_netlogon.h"
  10 #include "librpc/gen_ndr/ndr_server_id.h"
  11 static enum ndr_err_code ndr_push_irpc_flags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  12 {
  13         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  14         return NDR_ERR_SUCCESS;
  15 }
  16
  17 static enum ndr_err_code ndr_pull_irpc_flags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  18 {
  19         uint32_t v;
  20         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  21         *r = v;
  22         return NDR_ERR_SUCCESS;
  23 }
  24
  25 _PUBLIC_ void ndr_print_irpc_flags(struct ndr_print *ndr, const char *name, uint32_t r)
  26 {
  27         ndr_print_uint32(ndr, name, r);
  28         ndr->depth++;
  29         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "IRPC_FLAG_REPLY", IRPC_FLAG_REPLY, r);
  30         ndr->depth--;
  31 }
  32
  33 static enum ndr_err_code ndr_push_irpc_creds(struct ndr_push *ndr, int ndr_flags, const struct irpc_creds *r)
  34 {
  35         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
  36         if (ndr_flags & NDR_SCALARS) {
  37                 NDR_CHECK(ndr_push_align(ndr, 5));
  38                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->token));
  39                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
  40         }
  41         if (ndr_flags & NDR_BUFFERS) {
  42                 if (r->token) {
  43                         NDR_CHECK(ndr_push_security_token(ndr, NDR_SCALARS, r->token));
  44                 }
  45         }
  46         return NDR_ERR_SUCCESS;
  47 }
  48
  49 static enum ndr_err_code ndr_pull_irpc_creds(struct ndr_pull *ndr, int ndr_flags, struct irpc_creds *r)
  50 {
  51         uint32_t _ptr_token;
  52         TALLOC_CTX *_mem_save_token_0 = NULL;
  53         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
  54         if (ndr_flags & NDR_SCALARS) {
  55                 NDR_CHECK(ndr_pull_align(ndr, 5));
  56                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_token));
  57                 if (_ptr_token) {
  58                         NDR_PULL_ALLOC(ndr, r->token);
  59                 } else {
  60                         r->token = NULL;
  61                 }
  62                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
  63         }
  64         if (ndr_flags & NDR_BUFFERS) {
  65                 if (r->token) {
  66                         _mem_save_token_0 = NDR_PULL_GET_MEM_CTX(ndr);
  67                         NDR_PULL_SET_MEM_CTX(ndr, r->token, 0);
  68                         NDR_CHECK(ndr_pull_security_token(ndr, NDR_SCALARS, r->token));
  69                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_token_0, 0);
  70                 }
  71         }
  72         return NDR_ERR_SUCCESS;
  73 }
  74
  75 _PUBLIC_ void ndr_print_irpc_creds(struct ndr_print *ndr, const char *name, const struct irpc_creds *r)
  76 {
  77         ndr_print_struct(ndr, name, "irpc_creds");
  78         if (r == NULL) { ndr_print_null(ndr); return; }
  79         ndr->depth++;
  80         ndr_print_ptr(ndr, "token", r->token);
  81         ndr->depth++;
  82         if (r->token) {
  83                 ndr_print_security_token(ndr, "token", r->token);
  84         }
  85         ndr->depth--;
  86         ndr->depth--;
  87 }
  88
  89 _PUBLIC_ enum ndr_err_code ndr_push_irpc_header(struct ndr_push *ndr, int ndr_flags, const struct irpc_header *r)
  90 {
  91         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
  92         if (ndr_flags & NDR_SCALARS) {
  93                 NDR_CHECK(ndr_push_align(ndr, 4));
  94                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->uuid));
  95                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->if_version));
  96                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->callnum));
  97                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->callid));
  98                 NDR_CHECK(ndr_push_irpc_flags(ndr, NDR_SCALARS, r->flags));
  99                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
 100                 {
 101                         struct ndr_push *_ndr_creds;
 102                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_creds, 4, -1));
 103                         NDR_CHECK(ndr_push_irpc_creds(_ndr_creds, NDR_SCALARS|NDR_BUFFERS, &r->creds));
 104                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_creds, 4, -1));
 105                 }
 106                 {
 107                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 108                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
 109                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
 110                         ndr->flags = _flags_save_DATA_BLOB;
 111                 }
 112                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 113         }
 114         if (ndr_flags & NDR_BUFFERS) {
 115         }
 116         return NDR_ERR_SUCCESS;
 117 }
 118
 119 _PUBLIC_ enum ndr_err_code ndr_pull_irpc_header(struct ndr_pull *ndr, int ndr_flags, struct irpc_header *r)
 120 {
 121         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 122         if (ndr_flags & NDR_SCALARS) {
 123                 NDR_CHECK(ndr_pull_align(ndr, 4));
 124                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->uuid));
 125                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->if_version));
 126                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->callnum));
 127                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->callid));
 128                 NDR_CHECK(ndr_pull_irpc_flags(ndr, NDR_SCALARS, &r->flags));
 129                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
 130                 {
 131                         struct ndr_pull *_ndr_creds;
 132                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_creds, 4, -1));
 133                         NDR_CHECK(ndr_pull_irpc_creds(_ndr_creds, NDR_SCALARS|NDR_BUFFERS, &r->creds));
 134                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_creds, 4, -1));
 135                 }
 136                 {
 137                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 138                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
 139                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
 140                         ndr->flags = _flags_save_DATA_BLOB;
 141                 }
 142                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 143         }
 144         if (ndr_flags & NDR_BUFFERS) {
 145         }
 146         return NDR_ERR_SUCCESS;
 147 }
 148
 149 _PUBLIC_ void ndr_print_irpc_header(struct ndr_print *ndr, const char *name, const struct irpc_header *r)
 150 {
 151         ndr_print_struct(ndr, name, "irpc_header");
 152         if (r == NULL) { ndr_print_null(ndr); return; }
 153         ndr->depth++;
 154         ndr_print_GUID(ndr, "uuid", &r->uuid);
 155         ndr_print_uint32(ndr, "if_version", r->if_version);
 156         ndr_print_uint32(ndr, "callnum", r->callnum);
 157         ndr_print_uint32(ndr, "callid", r->callid);
 158         ndr_print_irpc_flags(ndr, "flags", r->flags);
 159         ndr_print_NTSTATUS(ndr, "status", r->status);
 160         ndr_print_irpc_creds(ndr, "creds", &r->creds);
 161         ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
 162         ndr->depth--;
 163 }
 164
 165 _PUBLIC_ enum ndr_err_code ndr_push_irpc_name_record(struct ndr_push *ndr, int ndr_flags, const struct irpc_name_record *r)
 166 {
 167         uint32_t cntr_ids_0;
 168         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 169         if (ndr_flags & NDR_SCALARS) {
 170                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
 171                 NDR_CHECK(ndr_push_align(ndr, 8));
 172                 {
 173                         uint32_t _flags_save_string = ndr->flags;
 174                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
 175                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
 176                         ndr->flags = _flags_save_string;
 177                 }
 178                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 179                 for (cntr_ids_0 = 0; cntr_ids_0 < (r->count); cntr_ids_0++) {
 180                         NDR_CHECK(ndr_push_server_id(ndr, NDR_SCALARS, &r->ids[cntr_ids_0]));
 181                 }
 182                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 183         }
 184         if (ndr_flags & NDR_BUFFERS) {
 185         }
 186         return NDR_ERR_SUCCESS;
 187 }
 188
 189 _PUBLIC_ enum ndr_err_code ndr_pull_irpc_name_record(struct ndr_pull *ndr, int ndr_flags, struct irpc_name_record *r)
 190 {
 191         uint32_t size_ids_0 = 0;
 192         uint32_t cntr_ids_0;
 193         TALLOC_CTX *_mem_save_ids_0 = NULL;
 194         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 195         if (ndr_flags & NDR_SCALARS) {
 196                 NDR_CHECK(ndr_pull_array_size(ndr, &r->ids));
 197                 NDR_CHECK(ndr_pull_align(ndr, 8));
 198                 {
 199                         uint32_t _flags_save_string = ndr->flags;
 200                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
 201                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
 202                         ndr->flags = _flags_save_string;
 203                 }
 204                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 205                 size_ids_0 = ndr_get_array_size(ndr, &r->ids);
 206                 NDR_PULL_ALLOC_N(ndr, r->ids, size_ids_0);
 207                 _mem_save_ids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 208                 NDR_PULL_SET_MEM_CTX(ndr, r->ids, 0);
 209                 for (cntr_ids_0 = 0; cntr_ids_0 < (size_ids_0); cntr_ids_0++) {
 210                         NDR_CHECK(ndr_pull_server_id(ndr, NDR_SCALARS, &r->ids[cntr_ids_0]));
 211                 }
 212                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ids_0, 0);
 213                 if (r->ids) {
 214                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->ids, r->count));
 215                 }
 216                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 217         }
 218         if (ndr_flags & NDR_BUFFERS) {
 219         }
 220         return NDR_ERR_SUCCESS;
 221 }
 222
 223 _PUBLIC_ void ndr_print_irpc_name_record(struct ndr_print *ndr, const char *name, const struct irpc_name_record *r)
 224 {
 225         uint32_t cntr_ids_0;
 226         ndr_print_struct(ndr, name, "irpc_name_record");
 227         if (r == NULL) { ndr_print_null(ndr); return; }
 228         ndr->depth++;
 229         ndr_print_string(ndr, "name", r->name);
 230         ndr_print_uint32(ndr, "count", r->count);
 231         ndr->print(ndr, "%s: ARRAY(%d)", "ids", (int)r->count);
 232         ndr->depth++;
 233         for (cntr_ids_0 = 0; cntr_ids_0 < (r->count); cntr_ids_0++) {
 234                 ndr_print_server_id(ndr, "ids", &r->ids[cntr_ids_0]);
 235         }
 236         ndr->depth--;
 237         ndr->depth--;
 238 }
 239
 240 _PUBLIC_ enum ndr_err_code ndr_push_irpc_name_records(struct ndr_push *ndr, int ndr_flags, const struct irpc_name_records *r)
 241 {
 242         uint32_t cntr_names_0;
 243         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 244         if (ndr_flags & NDR_SCALARS) {
 245                 NDR_CHECK(ndr_push_align(ndr, 5));
 246                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_records));
 247                 for (cntr_names_0 = 0; cntr_names_0 < (r->num_records); cntr_names_0++) {
 248                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->names[cntr_names_0]));
 249                 }
 250                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_records));
 251                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 252         }
 253         if (ndr_flags & NDR_BUFFERS) {
 254                 for (cntr_names_0 = 0; cntr_names_0 < (r->num_records); cntr_names_0++) {
 255                         if (r->names[cntr_names_0]) {
 256                                 NDR_CHECK(ndr_push_irpc_name_record(ndr, NDR_SCALARS, r->names[cntr_names_0]));
 257                         }
 258                 }
 259         }
 260         return NDR_ERR_SUCCESS;
 261 }
 262
 263 _PUBLIC_ enum ndr_err_code ndr_pull_irpc_name_records(struct ndr_pull *ndr, int ndr_flags, struct irpc_name_records *r)
 264 {
 265         uint32_t _ptr_names;
 266         uint32_t size_names_0 = 0;
 267         uint32_t cntr_names_0;
 268         TALLOC_CTX *_mem_save_names_0 = NULL;
 269         TALLOC_CTX *_mem_save_names_1 = NULL;
 270         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 271         if (ndr_flags & NDR_SCALARS) {
 272                 NDR_CHECK(ndr_pull_align(ndr, 5));
 273                 NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
 274                 size_names_0 = ndr_get_array_size(ndr, &r->names);
 275                 NDR_PULL_ALLOC_N(ndr, r->names, size_names_0);
 276                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
 277                 NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
 278                 for (cntr_names_0 = 0; cntr_names_0 < (size_names_0); cntr_names_0++) {
 279                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
 280                         if (_ptr_names) {
 281                                 NDR_PULL_ALLOC(ndr, r->names[cntr_names_0]);
 282                         } else {
 283                                 r->names[cntr_names_0] = NULL;
 284                         }
 285                 }
 286                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
 287                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_records));
 288                 if (r->names) {
 289                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->num_records));
 290                 }
 291                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 292         }
 293         if (ndr_flags & NDR_BUFFERS) {
 294                 size_names_0 = ndr_get_array_size(ndr, &r->names);
 295                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
 296                 NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
 297                 for (cntr_names_0 = 0; cntr_names_0 < (size_names_0); cntr_names_0++) {
 298                         if (r->names[cntr_names_0]) {
 299                                 _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
 300                                 NDR_PULL_SET_MEM_CTX(ndr, r->names[cntr_names_0], 0);
 301                                 NDR_CHECK(ndr_pull_irpc_name_record(ndr, NDR_SCALARS, r->names[cntr_names_0]));
 302                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
 303                         }
 304                 }
 305                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
 306         }
 307         return NDR_ERR_SUCCESS;
 308 }
 309
 310 _PUBLIC_ void ndr_print_irpc_name_records(struct ndr_print *ndr, const char *name, const struct irpc_name_records *r)
 311 {
 312         uint32_t cntr_names_0;
 313         ndr_print_struct(ndr, name, "irpc_name_records");
 314         if (r == NULL) { ndr_print_null(ndr); return; }
 315         ndr->depth++;
 316         ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->num_records);
 317         ndr->depth++;
 318         for (cntr_names_0 = 0; cntr_names_0 < (r->num_records); cntr_names_0++) {
 319                 ndr_print_ptr(ndr, "names", r->names[cntr_names_0]);
 320                 ndr->depth++;
 321                 if (r->names[cntr_names_0]) {
 322                         ndr_print_irpc_name_record(ndr, "names", r->names[cntr_names_0]);
 323                 }
 324                 ndr->depth--;
 325         }
 326         ndr->depth--;
 327         ndr_print_uint32(ndr, "num_records", r->num_records);
 328         ndr->depth--;
 329 }
 330
 331 static enum ndr_err_code ndr_push_nbtd_info_level(struct ndr_push *ndr, int ndr_flags, enum nbtd_info_level r)
 332 {
 333         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 334         return NDR_ERR_SUCCESS;
 335 }
 336
 337 static enum ndr_err_code ndr_pull_nbtd_info_level(struct ndr_pull *ndr, int ndr_flags, enum nbtd_info_level *r)
 338 {
 339         uint32_t v;
 340         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 341         *r = v;
 342         return NDR_ERR_SUCCESS;
 343 }
 344
 345 _PUBLIC_ void ndr_print_nbtd_info_level(struct ndr_print *ndr, const char *name, enum nbtd_info_level r)
 346 {
 347         const char *val = NULL;
 348
 349         switch (r) {
 350                 case NBTD_INFO_STATISTICS: val = "NBTD_INFO_STATISTICS"; break;
 351         }
 352         ndr_print_enum(ndr, name, "ENUM", val, r);
 353 }
 354
 355 static enum ndr_err_code ndr_push_nbtd_statistics(struct ndr_push *ndr, int ndr_flags, const struct nbtd_statistics *r)
 356 {
 357         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 358         if (ndr_flags & NDR_SCALARS) {
 359                 NDR_CHECK(ndr_push_align(ndr, 8));
 360                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->total_received));
 361                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->total_sent));
 362                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->query_count));
 363                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->register_count));
 364                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->release_count));
 365                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 366         }
 367         if (ndr_flags & NDR_BUFFERS) {
 368         }
 369         return NDR_ERR_SUCCESS;
 370 }
 371
 372 static enum ndr_err_code ndr_pull_nbtd_statistics(struct ndr_pull *ndr, int ndr_flags, struct nbtd_statistics *r)
 373 {
 374         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 375         if (ndr_flags & NDR_SCALARS) {
 376                 NDR_CHECK(ndr_pull_align(ndr, 8));
 377                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->total_received));
 378                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->total_sent));
 379                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->query_count));
 380                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->register_count));
 381                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->release_count));
 382                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 383         }
 384         if (ndr_flags & NDR_BUFFERS) {
 385         }
 386         return NDR_ERR_SUCCESS;
 387 }
 388
 389 _PUBLIC_ void ndr_print_nbtd_statistics(struct ndr_print *ndr, const char *name, const struct nbtd_statistics *r)
 390 {
 391         ndr_print_struct(ndr, name, "nbtd_statistics");
 392         if (r == NULL) { ndr_print_null(ndr); return; }
 393         ndr->depth++;
 394         ndr_print_hyper(ndr, "total_received", r->total_received);
 395         ndr_print_hyper(ndr, "total_sent", r->total_sent);
 396         ndr_print_hyper(ndr, "query_count", r->query_count);
 397         ndr_print_hyper(ndr, "register_count", r->register_count);
 398         ndr_print_hyper(ndr, "release_count", r->release_count);
 399         ndr->depth--;
 400 }
 401
 402 static enum ndr_err_code ndr_push_nbtd_info(struct ndr_push *ndr, int ndr_flags, const union nbtd_info *r)
 403 {
 404         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 405         if (ndr_flags & NDR_SCALARS) {
 406                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 407                 NDR_CHECK(ndr_push_union_align(ndr, 5));
 408                 NDR_CHECK(ndr_push_nbtd_info_level(ndr, NDR_SCALARS, level));
 409                 NDR_CHECK(ndr_push_union_align(ndr, 5));
 410                 switch (level) {
 411                         case NBTD_INFO_STATISTICS: {
 412                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->stats));
 413                         break; }
 414
 415                         default:
 416                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 417                 }
 418         }
 419         if (ndr_flags & NDR_BUFFERS) {
 420                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 421                 switch (level) {
 422                         case NBTD_INFO_STATISTICS:
 423                                 if (r->stats) {
 424                                         NDR_CHECK(ndr_push_nbtd_statistics(ndr, NDR_SCALARS, r->stats));
 425                                 }
 426                         break;
 427
 428                         default:
 429                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 430                 }
 431         }
 432         return NDR_ERR_SUCCESS;
 433 }
 434
 435 static enum ndr_err_code ndr_pull_nbtd_info(struct ndr_pull *ndr, int ndr_flags, union nbtd_info *r)
 436 {
 437         uint32_t level;
 438         uint32_t _level;
 439         TALLOC_CTX *_mem_save_stats_0 = NULL;
 440         uint32_t _ptr_stats;
 441         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 442         if (ndr_flags & NDR_SCALARS) {
 443                 level = ndr_pull_get_switch_value(ndr, r);
 444                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
 445                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
 446                 if (_level != level) {
 447                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 448                 }
 449                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
 450                 switch (level) {
 451                         case NBTD_INFO_STATISTICS: {
 452                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_stats));
 453                                 if (_ptr_stats) {
 454                                         NDR_PULL_ALLOC(ndr, r->stats);
 455                                 } else {
 456                                         r->stats = NULL;
 457                                 }
 458                         break; }
 459
 460                         default:
 461                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 462                 }
 463         }
 464         if (ndr_flags & NDR_BUFFERS) {
 465                 /* The token is not needed after this. */
 466                 level = ndr_pull_steal_switch_value(ndr, r);
 467                 switch (level) {
 468                         case NBTD_INFO_STATISTICS:
 469                                 if (r->stats) {
 470                                         _mem_save_stats_0 = NDR_PULL_GET_MEM_CTX(ndr);
 471                                         NDR_PULL_SET_MEM_CTX(ndr, r->stats, 0);
 472                                         NDR_CHECK(ndr_pull_nbtd_statistics(ndr, NDR_SCALARS, r->stats));
 473                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_stats_0, 0);
 474                                 }
 475                         break;
 476
 477                         default:
 478                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 479                 }
 480         }
 481         return NDR_ERR_SUCCESS;
 482 }
 483
 484 _PUBLIC_ void ndr_print_nbtd_info(struct ndr_print *ndr, const char *name, const union nbtd_info *r)
 485 {
 486         uint32_t level;
 487         level = ndr_print_get_switch_value(ndr, r);
 488         ndr_print_union(ndr, name, level, "nbtd_info");
 489         switch (level) {
 490                 case NBTD_INFO_STATISTICS:
 491                         ndr_print_ptr(ndr, "stats", r->stats);
 492                         ndr->depth++;
 493                         if (r->stats) {
 494                                 ndr_print_nbtd_statistics(ndr, "stats", r->stats);
 495                         }
 496                         ndr->depth--;
 497                 break;
 498
 499                 default:
 500                         ndr_print_bad_level(ndr, name, level);
 501         }
 502 }
 503
 504 static enum ndr_err_code ndr_push_nbtd_proxy_wins_addr(struct ndr_push *ndr, int ndr_flags, const struct nbtd_proxy_wins_addr *r)
 505 {
 506         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 507         if (ndr_flags & NDR_SCALARS) {
 508                 NDR_CHECK(ndr_push_align(ndr, 4));
 509                 NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->addr));
 510                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 511         }
 512         if (ndr_flags & NDR_BUFFERS) {
 513         }
 514         return NDR_ERR_SUCCESS;
 515 }
 516
 517 static enum ndr_err_code ndr_pull_nbtd_proxy_wins_addr(struct ndr_pull *ndr, int ndr_flags, struct nbtd_proxy_wins_addr *r)
 518 {
 519         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 520         if (ndr_flags & NDR_SCALARS) {
 521                 NDR_CHECK(ndr_pull_align(ndr, 4));
 522                 NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->addr));
 523                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 524         }
 525         if (ndr_flags & NDR_BUFFERS) {
 526         }
 527         return NDR_ERR_SUCCESS;
 528 }
 529
 530 _PUBLIC_ void ndr_print_nbtd_proxy_wins_addr(struct ndr_print *ndr, const char *name, const struct nbtd_proxy_wins_addr *r)
 531 {
 532         ndr_print_struct(ndr, name, "nbtd_proxy_wins_addr");
 533         if (r == NULL) { ndr_print_null(ndr); return; }
 534         ndr->depth++;
 535         ndr_print_ipv4address(ndr, "addr", r->addr);
 536         ndr->depth--;
 537 }
 538
 539 static enum ndr_err_code ndr_push_smbsrv_info_level(struct ndr_push *ndr, int ndr_flags, enum smbsrv_info_level r)
 540 {
 541         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 542         return NDR_ERR_SUCCESS;
 543 }
 544
 545 static enum ndr_err_code ndr_pull_smbsrv_info_level(struct ndr_pull *ndr, int ndr_flags, enum smbsrv_info_level *r)
 546 {
 547         uint32_t v;
 548         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 549         *r = v;
 550         return NDR_ERR_SUCCESS;
 551 }
 552
 553 _PUBLIC_ void ndr_print_smbsrv_info_level(struct ndr_print *ndr, const char *name, enum smbsrv_info_level r)
 554 {
 555         const char *val = NULL;
 556
 557         switch (r) {
 558                 case SMBSRV_INFO_SESSIONS: val = "SMBSRV_INFO_SESSIONS"; break;
 559                 case SMBSRV_INFO_TCONS: val = "SMBSRV_INFO_TCONS"; break;
 560         }
 561         ndr_print_enum(ndr, name, "ENUM", val, r);
 562 }
 563
 564 static enum ndr_err_code ndr_push_smbsrv_session_info(struct ndr_push *ndr, int ndr_flags, const struct smbsrv_session_info *r)
 565 {
 566         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 567         if (ndr_flags & NDR_SCALARS) {
 568                 NDR_CHECK(ndr_push_align(ndr, 8));
 569                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->vuid));
 570                 {
 571                         uint32_t _flags_save_string = ndr->flags;
 572                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 573                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->account_name));
 574                         ndr->flags = _flags_save_string;
 575                 }
 576                 {
 577                         uint32_t _flags_save_string = ndr->flags;
 578                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 579                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->domain_name));
 580                         ndr->flags = _flags_save_string;
 581                 }
 582                 {
 583                         uint32_t _flags_save_string = ndr->flags;
 584                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 585                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->client_ip));
 586                         ndr->flags = _flags_save_string;
 587                 }
 588                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->connect_time));
 589                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->auth_time));
 590                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_use_time));
 591                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 592         }
 593         if (ndr_flags & NDR_BUFFERS) {
 594         }
 595         return NDR_ERR_SUCCESS;
 596 }
 597
 598 static enum ndr_err_code ndr_pull_smbsrv_session_info(struct ndr_pull *ndr, int ndr_flags, struct smbsrv_session_info *r)
 599 {
 600         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 601         if (ndr_flags & NDR_SCALARS) {
 602                 NDR_CHECK(ndr_pull_align(ndr, 8));
 603                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->vuid));
 604                 {
 605                         uint32_t _flags_save_string = ndr->flags;
 606                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 607                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->account_name));
 608                         ndr->flags = _flags_save_string;
 609                 }
 610                 {
 611                         uint32_t _flags_save_string = ndr->flags;
 612                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 613                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->domain_name));
 614                         ndr->flags = _flags_save_string;
 615                 }
 616                 {
 617                         uint32_t _flags_save_string = ndr->flags;
 618                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 619                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->client_ip));
 620                         ndr->flags = _flags_save_string;
 621                 }
 622                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->connect_time));
 623                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->auth_time));
 624                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_use_time));
 625                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 626         }
 627         if (ndr_flags & NDR_BUFFERS) {
 628         }
 629         return NDR_ERR_SUCCESS;
 630 }
 631
 632 _PUBLIC_ void ndr_print_smbsrv_session_info(struct ndr_print *ndr, const char *name, const struct smbsrv_session_info *r)
 633 {
 634         ndr_print_struct(ndr, name, "smbsrv_session_info");
 635         if (r == NULL) { ndr_print_null(ndr); return; }
 636         ndr->depth++;
 637         ndr_print_hyper(ndr, "vuid", r->vuid);
 638         ndr_print_string(ndr, "account_name", r->account_name);
 639         ndr_print_string(ndr, "domain_name", r->domain_name);
 640         ndr_print_string(ndr, "client_ip", r->client_ip);
 641         ndr_print_NTTIME(ndr, "connect_time", r->connect_time);
 642         ndr_print_NTTIME(ndr, "auth_time", r->auth_time);
 643         ndr_print_NTTIME(ndr, "last_use_time", r->last_use_time);
 644         ndr->depth--;
 645 }
 646
 647 static enum ndr_err_code ndr_push_smbsrv_sessions(struct ndr_push *ndr, int ndr_flags, const struct smbsrv_sessions *r)
 648 {
 649         uint32_t cntr_sessions_1;
 650         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 651         if (ndr_flags & NDR_SCALARS) {
 652                 NDR_CHECK(ndr_push_align(ndr, 5));
 653                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sessions));
 654                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sessions));
 655                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 656         }
 657         if (ndr_flags & NDR_BUFFERS) {
 658                 if (r->sessions) {
 659                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_sessions));
 660                         for (cntr_sessions_1 = 0; cntr_sessions_1 < (r->num_sessions); cntr_sessions_1++) {
 661                                 NDR_CHECK(ndr_push_smbsrv_session_info(ndr, NDR_SCALARS, &r->sessions[cntr_sessions_1]));
 662                         }
 663                 }
 664         }
 665         return NDR_ERR_SUCCESS;
 666 }
 667
 668 static enum ndr_err_code ndr_pull_smbsrv_sessions(struct ndr_pull *ndr, int ndr_flags, struct smbsrv_sessions *r)
 669 {
 670         uint32_t _ptr_sessions;
 671         uint32_t size_sessions_1 = 0;
 672         uint32_t cntr_sessions_1;
 673         TALLOC_CTX *_mem_save_sessions_0 = NULL;
 674         TALLOC_CTX *_mem_save_sessions_1 = NULL;
 675         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 676         if (ndr_flags & NDR_SCALARS) {
 677                 NDR_CHECK(ndr_pull_align(ndr, 5));
 678                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sessions));
 679                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sessions));
 680                 if (_ptr_sessions) {
 681                         NDR_PULL_ALLOC(ndr, r->sessions);
 682                 } else {
 683                         r->sessions = NULL;
 684                 }
 685                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 686         }
 687         if (ndr_flags & NDR_BUFFERS) {
 688                 if (r->sessions) {
 689                         _mem_save_sessions_0 = NDR_PULL_GET_MEM_CTX(ndr);
 690                         NDR_PULL_SET_MEM_CTX(ndr, r->sessions, 0);
 691                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sessions));
 692                         size_sessions_1 = ndr_get_array_size(ndr, &r->sessions);
 693                         NDR_PULL_ALLOC_N(ndr, r->sessions, size_sessions_1);
 694                         _mem_save_sessions_1 = NDR_PULL_GET_MEM_CTX(ndr);
 695                         NDR_PULL_SET_MEM_CTX(ndr, r->sessions, 0);
 696                         for (cntr_sessions_1 = 0; cntr_sessions_1 < (size_sessions_1); cntr_sessions_1++) {
 697                                 NDR_CHECK(ndr_pull_smbsrv_session_info(ndr, NDR_SCALARS, &r->sessions[cntr_sessions_1]));
 698                         }
 699                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sessions_1, 0);
 700                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sessions_0, 0);
 701                 }
 702                 if (r->sessions) {
 703                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sessions, r->num_sessions));
 704                 }
 705         }
 706         return NDR_ERR_SUCCESS;
 707 }
 708
 709 _PUBLIC_ void ndr_print_smbsrv_sessions(struct ndr_print *ndr, const char *name, const struct smbsrv_sessions *r)
 710 {
 711         uint32_t cntr_sessions_1;
 712         ndr_print_struct(ndr, name, "smbsrv_sessions");
 713         if (r == NULL) { ndr_print_null(ndr); return; }
 714         ndr->depth++;
 715         ndr_print_uint32(ndr, "num_sessions", r->num_sessions);
 716         ndr_print_ptr(ndr, "sessions", r->sessions);
 717         ndr->depth++;
 718         if (r->sessions) {
 719                 ndr->print(ndr, "%s: ARRAY(%d)", "sessions", (int)r->num_sessions);
 720                 ndr->depth++;
 721                 for (cntr_sessions_1 = 0; cntr_sessions_1 < (r->num_sessions); cntr_sessions_1++) {
 722                         ndr_print_smbsrv_session_info(ndr, "sessions", &r->sessions[cntr_sessions_1]);
 723                 }
 724                 ndr->depth--;
 725         }
 726         ndr->depth--;
 727         ndr->depth--;
 728 }
 729
 730 static enum ndr_err_code ndr_push_smbsrv_tcon_info(struct ndr_push *ndr, int ndr_flags, const struct smbsrv_tcon_info *r)
 731 {
 732         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 733         if (ndr_flags & NDR_SCALARS) {
 734                 NDR_CHECK(ndr_push_align(ndr, 4));
 735                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->tid));
 736                 {
 737                         uint32_t _flags_save_string = ndr->flags;
 738                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 739                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->share_name));
 740                         ndr->flags = _flags_save_string;
 741                 }
 742                 {
 743                         uint32_t _flags_save_string = ndr->flags;
 744                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 745                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->client_ip));
 746                         ndr->flags = _flags_save_string;
 747                 }
 748                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->connect_time));
 749                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_use_time));
 750                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 751         }
 752         if (ndr_flags & NDR_BUFFERS) {
 753         }
 754         return NDR_ERR_SUCCESS;
 755 }
 756
 757 static enum ndr_err_code ndr_pull_smbsrv_tcon_info(struct ndr_pull *ndr, int ndr_flags, struct smbsrv_tcon_info *r)
 758 {
 759         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 760         if (ndr_flags & NDR_SCALARS) {
 761                 NDR_CHECK(ndr_pull_align(ndr, 4));
 762                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->tid));
 763                 {
 764                         uint32_t _flags_save_string = ndr->flags;
 765                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 766                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->share_name));
 767                         ndr->flags = _flags_save_string;
 768                 }
 769                 {
 770                         uint32_t _flags_save_string = ndr->flags;
 771                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 772                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->client_ip));
 773                         ndr->flags = _flags_save_string;
 774                 }
 775                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->connect_time));
 776                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_use_time));
 777                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 778         }
 779         if (ndr_flags & NDR_BUFFERS) {
 780         }
 781         return NDR_ERR_SUCCESS;
 782 }
 783
 784 _PUBLIC_ void ndr_print_smbsrv_tcon_info(struct ndr_print *ndr, const char *name, const struct smbsrv_tcon_info *r)
 785 {
 786         ndr_print_struct(ndr, name, "smbsrv_tcon_info");
 787         if (r == NULL) { ndr_print_null(ndr); return; }
 788         ndr->depth++;
 789         ndr_print_uint32(ndr, "tid", r->tid);
 790         ndr_print_string(ndr, "share_name", r->share_name);
 791         ndr_print_string(ndr, "client_ip", r->client_ip);
 792         ndr_print_NTTIME(ndr, "connect_time", r->connect_time);
 793         ndr_print_NTTIME(ndr, "last_use_time", r->last_use_time);
 794         ndr->depth--;
 795 }
 796
 797 static enum ndr_err_code ndr_push_smbsrv_tcons(struct ndr_push *ndr, int ndr_flags, const struct smbsrv_tcons *r)
 798 {
 799         uint32_t cntr_tcons_1;
 800         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 801         if (ndr_flags & NDR_SCALARS) {
 802                 NDR_CHECK(ndr_push_align(ndr, 5));
 803                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_tcons));
 804                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->tcons));
 805                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 806         }
 807         if (ndr_flags & NDR_BUFFERS) {
 808                 if (r->tcons) {
 809                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_tcons));
 810                         for (cntr_tcons_1 = 0; cntr_tcons_1 < (r->num_tcons); cntr_tcons_1++) {
 811                                 NDR_CHECK(ndr_push_smbsrv_tcon_info(ndr, NDR_SCALARS, &r->tcons[cntr_tcons_1]));
 812                         }
 813                 }
 814         }
 815         return NDR_ERR_SUCCESS;
 816 }
 817
 818 static enum ndr_err_code ndr_pull_smbsrv_tcons(struct ndr_pull *ndr, int ndr_flags, struct smbsrv_tcons *r)
 819 {
 820         uint32_t _ptr_tcons;
 821         uint32_t size_tcons_1 = 0;
 822         uint32_t cntr_tcons_1;
 823         TALLOC_CTX *_mem_save_tcons_0 = NULL;
 824         TALLOC_CTX *_mem_save_tcons_1 = NULL;
 825         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 826         if (ndr_flags & NDR_SCALARS) {
 827                 NDR_CHECK(ndr_pull_align(ndr, 5));
 828                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_tcons));
 829                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_tcons));
 830                 if (_ptr_tcons) {
 831                         NDR_PULL_ALLOC(ndr, r->tcons);
 832                 } else {
 833                         r->tcons = NULL;
 834                 }
 835                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 836         }
 837         if (ndr_flags & NDR_BUFFERS) {
 838                 if (r->tcons) {
 839                         _mem_save_tcons_0 = NDR_PULL_GET_MEM_CTX(ndr);
 840                         NDR_PULL_SET_MEM_CTX(ndr, r->tcons, 0);
 841                         NDR_CHECK(ndr_pull_array_size(ndr, &r->tcons));
 842                         size_tcons_1 = ndr_get_array_size(ndr, &r->tcons);
 843                         NDR_PULL_ALLOC_N(ndr, r->tcons, size_tcons_1);
 844                         _mem_save_tcons_1 = NDR_PULL_GET_MEM_CTX(ndr);
 845                         NDR_PULL_SET_MEM_CTX(ndr, r->tcons, 0);
 846                         for (cntr_tcons_1 = 0; cntr_tcons_1 < (size_tcons_1); cntr_tcons_1++) {
 847                                 NDR_CHECK(ndr_pull_smbsrv_tcon_info(ndr, NDR_SCALARS, &r->tcons[cntr_tcons_1]));
 848                         }
 849                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_tcons_1, 0);
 850                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_tcons_0, 0);
 851                 }
 852                 if (r->tcons) {
 853                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->tcons, r->num_tcons));
 854                 }
 855         }
 856         return NDR_ERR_SUCCESS;
 857 }
 858
 859 _PUBLIC_ void ndr_print_smbsrv_tcons(struct ndr_print *ndr, const char *name, const struct smbsrv_tcons *r)
 860 {
 861         uint32_t cntr_tcons_1;
 862         ndr_print_struct(ndr, name, "smbsrv_tcons");
 863         if (r == NULL) { ndr_print_null(ndr); return; }
 864         ndr->depth++;
 865         ndr_print_uint32(ndr, "num_tcons", r->num_tcons);
 866         ndr_print_ptr(ndr, "tcons", r->tcons);
 867         ndr->depth++;
 868         if (r->tcons) {
 869                 ndr->print(ndr, "%s: ARRAY(%d)", "tcons", (int)r->num_tcons);
 870                 ndr->depth++;
 871                 for (cntr_tcons_1 = 0; cntr_tcons_1 < (r->num_tcons); cntr_tcons_1++) {
 872                         ndr_print_smbsrv_tcon_info(ndr, "tcons", &r->tcons[cntr_tcons_1]);
 873                 }
 874                 ndr->depth--;
 875         }
 876         ndr->depth--;
 877         ndr->depth--;
 878 }
 879
 880 static enum ndr_err_code ndr_push_smbsrv_info(struct ndr_push *ndr, int ndr_flags, const union smbsrv_info *r)
 881 {
 882         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 883         if (ndr_flags & NDR_SCALARS) {
 884                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 885                 NDR_CHECK(ndr_push_union_align(ndr, 5));
 886                 NDR_CHECK(ndr_push_smbsrv_info_level(ndr, NDR_SCALARS, level));
 887                 NDR_CHECK(ndr_push_union_align(ndr, 5));
 888                 switch (level) {
 889                         case SMBSRV_INFO_SESSIONS: {
 890                                 NDR_CHECK(ndr_push_smbsrv_sessions(ndr, NDR_SCALARS, &r->sessions));
 891                         break; }
 892
 893                         case SMBSRV_INFO_TCONS: {
 894                                 NDR_CHECK(ndr_push_smbsrv_tcons(ndr, NDR_SCALARS, &r->tcons));
 895                         break; }
 896
 897                         default:
 898                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 899                 }
 900         }
 901         if (ndr_flags & NDR_BUFFERS) {
 902                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 903                 switch (level) {
 904                         case SMBSRV_INFO_SESSIONS:
 905                                 NDR_CHECK(ndr_push_smbsrv_sessions(ndr, NDR_BUFFERS, &r->sessions));
 906                         break;
 907
 908                         case SMBSRV_INFO_TCONS:
 909                                 NDR_CHECK(ndr_push_smbsrv_tcons(ndr, NDR_BUFFERS, &r->tcons));
 910                         break;
 911
 912                         default:
 913                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 914                 }
 915         }
 916         return NDR_ERR_SUCCESS;
 917 }
 918
 919 static enum ndr_err_code ndr_pull_smbsrv_info(struct ndr_pull *ndr, int ndr_flags, union smbsrv_info *r)
 920 {
 921         uint32_t level;
 922         uint32_t _level;
 923         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 924         if (ndr_flags & NDR_SCALARS) {
 925                 level = ndr_pull_get_switch_value(ndr, r);
 926                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
 927                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
 928                 if (_level != level) {
 929                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 930                 }
 931                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
 932                 switch (level) {
 933                         case SMBSRV_INFO_SESSIONS: {
 934                                 NDR_CHECK(ndr_pull_smbsrv_sessions(ndr, NDR_SCALARS, &r->sessions));
 935                         break; }
 936
 937                         case SMBSRV_INFO_TCONS: {
 938                                 NDR_CHECK(ndr_pull_smbsrv_tcons(ndr, NDR_SCALARS, &r->tcons));
 939                         break; }
 940
 941                         default:
 942                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 943                 }
 944         }
 945         if (ndr_flags & NDR_BUFFERS) {
 946                 /* The token is not needed after this. */
 947                 level = ndr_pull_steal_switch_value(ndr, r);
 948                 switch (level) {
 949                         case SMBSRV_INFO_SESSIONS:
 950                                 NDR_CHECK(ndr_pull_smbsrv_sessions(ndr, NDR_BUFFERS, &r->sessions));
 951                         break;
 952
 953                         case SMBSRV_INFO_TCONS:
 954                                 NDR_CHECK(ndr_pull_smbsrv_tcons(ndr, NDR_BUFFERS, &r->tcons));
 955                         break;
 956
 957                         default:
 958                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 959                 }
 960         }
 961         return NDR_ERR_SUCCESS;
 962 }
 963
 964 _PUBLIC_ void ndr_print_smbsrv_info(struct ndr_print *ndr, const char *name, const union smbsrv_info *r)
 965 {
 966         uint32_t level;
 967         level = ndr_print_get_switch_value(ndr, r);
 968         ndr_print_union(ndr, name, level, "smbsrv_info");
 969         switch (level) {
 970                 case SMBSRV_INFO_SESSIONS:
 971                         ndr_print_smbsrv_sessions(ndr, "sessions", &r->sessions);
 972                 break;
 973
 974                 case SMBSRV_INFO_TCONS:
 975                         ndr_print_smbsrv_tcons(ndr, "tcons", &r->tcons);
 976                 break;
 977
 978                 default:
 979                         ndr_print_bad_level(ndr, name, level);
 980         }
 981 }
 982
 983 static enum ndr_err_code ndr_push_drepl_role_master(struct ndr_push *ndr, int ndr_flags, enum drepl_role_master r)
 984 {
 985         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 986         return NDR_ERR_SUCCESS;
 987 }
 988
 989 static enum ndr_err_code ndr_pull_drepl_role_master(struct ndr_pull *ndr, int ndr_flags, enum drepl_role_master *r)
 990 {
 991         uint32_t v;
 992         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 993         *r = v;
 994         return NDR_ERR_SUCCESS;
 995 }
 996
 997 _PUBLIC_ void ndr_print_drepl_role_master(struct ndr_print *ndr, const char *name, enum drepl_role_master r)
 998 {
 999         const char *val = NULL;
1000
1001         switch (r) {
1002                 case DREPL_SCHEMA_MASTER: val = "DREPL_SCHEMA_MASTER"; break;
1003                 case DREPL_RID_MASTER: val = "DREPL_RID_MASTER"; break;
1004                 case DREPL_INFRASTRUCTURE_MASTER: val = "DREPL_INFRASTRUCTURE_MASTER"; break;
1005                 case DREPL_NAMING_MASTER: val = "DREPL_NAMING_MASTER"; break;
1006                 case DREPL_PDC_MASTER: val = "DREPL_PDC_MASTER"; break;
1007         }
1008         ndr_print_enum(ndr, name, "ENUM", val, r);
1009 }
1010
1011 static enum ndr_err_code ndr_push_irpc_uptime(struct ndr_push *ndr, int flags, const struct irpc_uptime *r)
1012 {
1013         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1014         if (flags & NDR_IN) {
1015         }
1016         if (flags & NDR_OUT) {
1017                 if (r->out.start_time == NULL) {
1018                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1019                 }
1020                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, *r->out.start_time));
1021         }
1022         return NDR_ERR_SUCCESS;
1023 }
1024
1025 static enum ndr_err_code ndr_pull_irpc_uptime(struct ndr_pull *ndr, int flags, struct irpc_uptime *r)
1026 {
1027         TALLOC_CTX *_mem_save_start_time_0 = NULL;
1028         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1029         if (flags & NDR_IN) {
1030                 ZERO_STRUCT(r->out);
1031
1032                 NDR_PULL_ALLOC(ndr, r->out.start_time);
1033                 ZERO_STRUCTP(r->out.start_time);
1034         }
1035         if (flags & NDR_OUT) {
1036                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1037                         NDR_PULL_ALLOC(ndr, r->out.start_time);
1038                 }
1039                 _mem_save_start_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
1040                 NDR_PULL_SET_MEM_CTX(ndr, r->out.start_time, LIBNDR_FLAG_REF_ALLOC);
1041                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, r->out.start_time));
1042                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_start_time_0, LIBNDR_FLAG_REF_ALLOC);
1043         }
1044         return NDR_ERR_SUCCESS;
1045 }
1046
1047 _PUBLIC_ void ndr_print_irpc_uptime(struct ndr_print *ndr, const char *name, int flags, const struct irpc_uptime *r)
1048 {
1049         ndr_print_struct(ndr, name, "irpc_uptime");
1050         if (r == NULL) { ndr_print_null(ndr); return; }
1051         ndr->depth++;
1052         if (flags & NDR_SET_VALUES) {
1053                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1054         }
1055         if (flags & NDR_IN) {
1056                 ndr_print_struct(ndr, "in", "irpc_uptime");
1057                 ndr->depth++;
1058                 ndr->depth--;
1059         }
1060         if (flags & NDR_OUT) {
1061                 ndr_print_struct(ndr, "out", "irpc_uptime");
1062                 ndr->depth++;
1063                 ndr_print_ptr(ndr, "start_time", r->out.start_time);
1064                 ndr->depth++;
1065                 ndr_print_NTTIME(ndr, "start_time", *r->out.start_time);
1066                 ndr->depth--;
1067                 ndr->depth--;
1068         }
1069         ndr->depth--;
1070 }
1071
1072 static enum ndr_err_code ndr_push_nbtd_information(struct ndr_push *ndr, int flags, const struct nbtd_information *r)
1073 {
1074         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1075         if (flags & NDR_IN) {
1076                 NDR_CHECK(ndr_push_nbtd_info_level(ndr, NDR_SCALARS, r->in.level));
1077         }
1078         if (flags & NDR_OUT) {
1079                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info, r->in.level));
1080                 NDR_CHECK(ndr_push_nbtd_info(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.info));
1081         }
1082         return NDR_ERR_SUCCESS;
1083 }
1084
1085 static enum ndr_err_code ndr_pull_nbtd_information(struct ndr_pull *ndr, int flags, struct nbtd_information *r)
1086 {
1087         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1088         if (flags & NDR_IN) {
1089                 ZERO_STRUCT(r->out);
1090
1091                 NDR_CHECK(ndr_pull_nbtd_info_level(ndr, NDR_SCALARS, &r->in.level));
1092         }
1093         if (flags & NDR_OUT) {
1094                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info, r->in.level));
1095                 NDR_CHECK(ndr_pull_nbtd_info(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.info));
1096         }
1097         return NDR_ERR_SUCCESS;
1098 }
1099
1100 _PUBLIC_ void ndr_print_nbtd_information(struct ndr_print *ndr, const char *name, int flags, const struct nbtd_information *r)
1101 {
1102         ndr_print_struct(ndr, name, "nbtd_information");
1103         if (r == NULL) { ndr_print_null(ndr); return; }
1104         ndr->depth++;
1105         if (flags & NDR_SET_VALUES) {
1106                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1107         }
1108         if (flags & NDR_IN) {
1109                 ndr_print_struct(ndr, "in", "nbtd_information");
1110                 ndr->depth++;
1111                 ndr_print_nbtd_info_level(ndr, "level", r->in.level);
1112                 ndr->depth--;
1113         }
1114         if (flags & NDR_OUT) {
1115                 ndr_print_struct(ndr, "out", "nbtd_information");
1116                 ndr->depth++;
1117                 ndr_print_set_switch_value(ndr, &r->out.info, r->in.level);
1118                 ndr_print_nbtd_info(ndr, "info", &r->out.info);
1119                 ndr->depth--;
1120         }
1121         ndr->depth--;
1122 }
1123
1124 static enum ndr_err_code ndr_push_nbtd_getdcname(struct ndr_push *ndr, int flags, const struct nbtd_getdcname *r)
1125 {
1126         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1127         if (flags & NDR_IN) {
1128                 if (r->in.domain_sid == NULL) {
1129                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1130                 }
1131                 {
1132                         uint32_t _flags_save_string = ndr->flags;
1133                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
1134                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->in.domainname));
1135                         ndr->flags = _flags_save_string;
1136                 }
1137                 {
1138                         uint32_t _flags_save_string = ndr->flags;
1139                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
1140                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->in.ip_address));
1141                         ndr->flags = _flags_save_string;
1142                 }
1143                 {
1144                         uint32_t _flags_save_string = ndr->flags;
1145                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
1146                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->in.my_computername));
1147                         ndr->flags = _flags_save_string;
1148                 }
1149                 {
1150                         uint32_t _flags_save_string = ndr->flags;
1151                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
1152                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->in.my_accountname));
1153                         ndr->flags = _flags_save_string;
1154                 }
1155                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.account_control));
1156                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.domain_sid));
1157         }
1158         if (flags & NDR_OUT) {
1159                 {
1160                         uint32_t _flags_save_string = ndr->flags;
1161                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
1162                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.dcname));
1163                         if (r->out.dcname) {
1164                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->out.dcname));
1165                         }
1166                         ndr->flags = _flags_save_string;
1167                 }
1168         }
1169         return NDR_ERR_SUCCESS;
1170 }
1171
1172 static enum ndr_err_code ndr_pull_nbtd_getdcname(struct ndr_pull *ndr, int flags, struct nbtd_getdcname *r)
1173 {
1174         uint32_t _ptr_dcname;
1175         TALLOC_CTX *_mem_save_domain_sid_0 = NULL;
1176         TALLOC_CTX *_mem_save_dcname_0 = NULL;
1177         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1178         if (flags & NDR_IN) {
1179                 ZERO_STRUCT(r->out);
1180
1181                 {
1182                         uint32_t _flags_save_string = ndr->flags;
1183                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
1184                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->in.domainname));
1185                         ndr->flags = _flags_save_string;
1186                 }
1187                 {
1188                         uint32_t _flags_save_string = ndr->flags;
1189                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
1190                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->in.ip_address));
1191                         ndr->flags = _flags_save_string;
1192                 }
1193                 {
1194                         uint32_t _flags_save_string = ndr->flags;
1195                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
1196                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->in.my_computername));
1197                         ndr->flags = _flags_save_string;
1198                 }
1199                 {
1200                         uint32_t _flags_save_string = ndr->flags;
1201                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
1202                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->in.my_accountname));
1203                         ndr->flags = _flags_save_string;
1204                 }
1205                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.account_control));
1206                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1207                         NDR_PULL_ALLOC(ndr, r->in.domain_sid);
1208                 }
1209                 _mem_save_domain_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1210                 NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_sid, LIBNDR_FLAG_REF_ALLOC);
1211                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.domain_sid));
1212                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_sid_0, LIBNDR_FLAG_REF_ALLOC);
1213         }
1214         if (flags & NDR_OUT) {
1215                 {
1216                         uint32_t _flags_save_string = ndr->flags;
1217                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
1218                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dcname));
1219                         if (_ptr_dcname) {
1220                                 NDR_PULL_ALLOC(ndr, r->out.dcname);
1221                         } else {
1222                                 r->out.dcname = NULL;
1223                         }
1224                         if (r->out.dcname) {
1225                                 _mem_save_dcname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1226                                 NDR_PULL_SET_MEM_CTX(ndr, r->out.dcname, 0);
1227                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->out.dcname));
1228                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dcname_0, 0);
1229                         }
1230                         ndr->flags = _flags_save_string;
1231                 }
1232         }
1233         return NDR_ERR_SUCCESS;
1234 }
1235
1236 _PUBLIC_ void ndr_print_nbtd_getdcname(struct ndr_print *ndr, const char *name, int flags, const struct nbtd_getdcname *r)
1237 {
1238         ndr_print_struct(ndr, name, "nbtd_getdcname");
1239         if (r == NULL) { ndr_print_null(ndr); return; }
1240         ndr->depth++;
1241         if (flags & NDR_SET_VALUES) {
1242                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1243         }
1244         if (flags & NDR_IN) {
1245                 ndr_print_struct(ndr, "in", "nbtd_getdcname");
1246                 ndr->depth++;
1247                 ndr_print_string(ndr, "domainname", r->in.domainname);
1248                 ndr_print_string(ndr, "ip_address", r->in.ip_address);
1249                 ndr_print_string(ndr, "my_computername", r->in.my_computername);
1250                 ndr_print_string(ndr, "my_accountname", r->in.my_accountname);
1251                 ndr_print_uint32(ndr, "account_control", r->in.account_control);
1252                 ndr_print_ptr(ndr, "domain_sid", r->in.domain_sid);
1253                 ndr->depth++;
1254                 ndr_print_dom_sid(ndr, "domain_sid", r->in.domain_sid);
1255                 ndr->depth--;
1256                 ndr->depth--;
1257         }
1258         if (flags & NDR_OUT) {
1259                 ndr_print_struct(ndr, "out", "nbtd_getdcname");
1260                 ndr->depth++;
1261                 ndr_print_ptr(ndr, "dcname", r->out.dcname);
1262                 ndr->depth++;
1263                 if (r->out.dcname) {
1264                         ndr_print_string(ndr, "dcname", r->out.dcname);
1265                 }
1266                 ndr->depth--;
1267                 ndr->depth--;
1268         }
1269         ndr->depth--;
1270 }
1271
1272 static enum ndr_err_code ndr_push_nbtd_proxy_wins_challenge(struct ndr_push *ndr, int flags, const struct nbtd_proxy_wins_challenge *r)
1273 {
1274         uint32_t cntr_addrs_0;
1275         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1276         if (flags & NDR_IN) {
1277                 NDR_CHECK(ndr_push_nbt_name(ndr, NDR_SCALARS, &r->in.name));
1278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_addrs));
1279                 for (cntr_addrs_0 = 0; cntr_addrs_0 < (r->in.num_addrs); cntr_addrs_0++) {
1280                         NDR_CHECK(ndr_push_nbtd_proxy_wins_addr(ndr, NDR_SCALARS, &r->in.addrs[cntr_addrs_0]));
1281                 }
1282         }
1283         if (flags & NDR_OUT) {
1284                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.num_addrs));
1285                 for (cntr_addrs_0 = 0; cntr_addrs_0 < (r->out.num_addrs); cntr_addrs_0++) {
1286                         NDR_CHECK(ndr_push_nbtd_proxy_wins_addr(ndr, NDR_SCALARS, &r->out.addrs[cntr_addrs_0]));
1287                 }
1288         }
1289         return NDR_ERR_SUCCESS;
1290 }
1291
1292 static enum ndr_err_code ndr_pull_nbtd_proxy_wins_challenge(struct ndr_pull *ndr, int flags, struct nbtd_proxy_wins_challenge *r)
1293 {
1294         uint32_t size_addrs_0 = 0;
1295         uint32_t cntr_addrs_0;
1296         TALLOC_CTX *_mem_save_addrs_0 = NULL;
1297         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1298         if (flags & NDR_IN) {
1299                 ZERO_STRUCT(r->out);
1300
1301                 NDR_CHECK(ndr_pull_nbt_name(ndr, NDR_SCALARS, &r->in.name));
1302                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_addrs));
1303                 size_addrs_0 = r->in.num_addrs;
1304                 NDR_PULL_ALLOC_N(ndr, r->in.addrs, size_addrs_0);
1305                 _mem_save_addrs_0 = NDR_PULL_GET_MEM_CTX(ndr);
1306                 NDR_PULL_SET_MEM_CTX(ndr, r->in.addrs, 0);
1307                 for (cntr_addrs_0 = 0; cntr_addrs_0 < (size_addrs_0); cntr_addrs_0++) {
1308                         NDR_CHECK(ndr_pull_nbtd_proxy_wins_addr(ndr, NDR_SCALARS, &r->in.addrs[cntr_addrs_0]));
1309                 }
1310                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_addrs_0, 0);
1311         }
1312         if (flags & NDR_OUT) {
1313                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.num_addrs));
1314                 size_addrs_0 = r->out.num_addrs;
1315                 NDR_PULL_ALLOC_N(ndr, r->out.addrs, size_addrs_0);
1316                 _mem_save_addrs_0 = NDR_PULL_GET_MEM_CTX(ndr);
1317                 NDR_PULL_SET_MEM_CTX(ndr, r->out.addrs, 0);
1318                 for (cntr_addrs_0 = 0; cntr_addrs_0 < (size_addrs_0); cntr_addrs_0++) {
1319                         NDR_CHECK(ndr_pull_nbtd_proxy_wins_addr(ndr, NDR_SCALARS, &r->out.addrs[cntr_addrs_0]));
1320                 }
1321                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_addrs_0, 0);
1322         }
1323         return NDR_ERR_SUCCESS;
1324 }
1325
1326 _PUBLIC_ void ndr_print_nbtd_proxy_wins_challenge(struct ndr_print *ndr, const char *name, int flags, const struct nbtd_proxy_wins_challenge *r)
1327 {
1328         uint32_t cntr_addrs_0;
1329         ndr_print_struct(ndr, name, "nbtd_proxy_wins_challenge");
1330         if (r == NULL) { ndr_print_null(ndr); return; }
1331         ndr->depth++;
1332         if (flags & NDR_SET_VALUES) {
1333                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1334         }
1335         if (flags & NDR_IN) {
1336                 ndr_print_struct(ndr, "in", "nbtd_proxy_wins_challenge");
1337                 ndr->depth++;
1338                 ndr_print_nbt_name(ndr, "name", &r->in.name);
1339                 ndr_print_uint32(ndr, "num_addrs", r->in.num_addrs);
1340                 ndr->print(ndr, "%s: ARRAY(%d)", "addrs", (int)r->in.num_addrs);
1341                 ndr->depth++;
1342                 for (cntr_addrs_0 = 0; cntr_addrs_0 < (r->in.num_addrs); cntr_addrs_0++) {
1343                         ndr_print_nbtd_proxy_wins_addr(ndr, "addrs", &r->in.addrs[cntr_addrs_0]);
1344                 }
1345                 ndr->depth--;
1346                 ndr->depth--;
1347         }
1348         if (flags & NDR_OUT) {
1349                 ndr_print_struct(ndr, "out", "nbtd_proxy_wins_challenge");
1350                 ndr->depth++;
1351                 ndr_print_uint32(ndr, "num_addrs", r->out.num_addrs);
1352                 ndr->print(ndr, "%s: ARRAY(%d)", "addrs", (int)r->out.num_addrs);
1353                 ndr->depth++;
1354                 for (cntr_addrs_0 = 0; cntr_addrs_0 < (r->out.num_addrs); cntr_addrs_0++) {
1355                         ndr_print_nbtd_proxy_wins_addr(ndr, "addrs", &r->out.addrs[cntr_addrs_0]);
1356                 }
1357                 ndr->depth--;
1358                 ndr->depth--;
1359         }
1360         ndr->depth--;
1361 }
1362
1363 static enum ndr_err_code ndr_push_nbtd_proxy_wins_release_demand(struct ndr_push *ndr, int flags, const struct nbtd_proxy_wins_release_demand *r)
1364 {
1365         uint32_t cntr_addrs_0;
1366         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1367         if (flags & NDR_IN) {
1368                 NDR_CHECK(ndr_push_nbt_name(ndr, NDR_SCALARS, &r->in.name));
1369                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_addrs));
1370                 for (cntr_addrs_0 = 0; cntr_addrs_0 < (r->in.num_addrs); cntr_addrs_0++) {
1371                         NDR_CHECK(ndr_push_nbtd_proxy_wins_addr(ndr, NDR_SCALARS, &r->in.addrs[cntr_addrs_0]));
1372                 }
1373         }
1374         if (flags & NDR_OUT) {
1375         }
1376         return NDR_ERR_SUCCESS;
1377 }
1378
1379 static enum ndr_err_code ndr_pull_nbtd_proxy_wins_release_demand(struct ndr_pull *ndr, int flags, struct nbtd_proxy_wins_release_demand *r)
1380 {
1381         uint32_t size_addrs_0 = 0;
1382         uint32_t cntr_addrs_0;
1383         TALLOC_CTX *_mem_save_addrs_0 = NULL;
1384         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1385         if (flags & NDR_IN) {
1386                 NDR_CHECK(ndr_pull_nbt_name(ndr, NDR_SCALARS, &r->in.name));
1387                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_addrs));
1388                 size_addrs_0 = r->in.num_addrs;
1389                 NDR_PULL_ALLOC_N(ndr, r->in.addrs, size_addrs_0);
1390                 _mem_save_addrs_0 = NDR_PULL_GET_MEM_CTX(ndr);
1391                 NDR_PULL_SET_MEM_CTX(ndr, r->in.addrs, 0);
1392                 for (cntr_addrs_0 = 0; cntr_addrs_0 < (size_addrs_0); cntr_addrs_0++) {
1393                         NDR_CHECK(ndr_pull_nbtd_proxy_wins_addr(ndr, NDR_SCALARS, &r->in.addrs[cntr_addrs_0]));
1394                 }
1395                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_addrs_0, 0);
1396         }
1397         if (flags & NDR_OUT) {
1398         }
1399         return NDR_ERR_SUCCESS;
1400 }
1401
1402 _PUBLIC_ void ndr_print_nbtd_proxy_wins_release_demand(struct ndr_print *ndr, const char *name, int flags, const struct nbtd_proxy_wins_release_demand *r)
1403 {
1404         uint32_t cntr_addrs_0;
1405         ndr_print_struct(ndr, name, "nbtd_proxy_wins_release_demand");
1406         if (r == NULL) { ndr_print_null(ndr); return; }
1407         ndr->depth++;
1408         if (flags & NDR_SET_VALUES) {
1409                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1410         }
1411         if (flags & NDR_IN) {
1412                 ndr_print_struct(ndr, "in", "nbtd_proxy_wins_release_demand");
1413                 ndr->depth++;
1414                 ndr_print_nbt_name(ndr, "name", &r->in.name);
1415                 ndr_print_uint32(ndr, "num_addrs", r->in.num_addrs);
1416                 ndr->print(ndr, "%s: ARRAY(%d)", "addrs", (int)r->in.num_addrs);
1417                 ndr->depth++;
1418                 for (cntr_addrs_0 = 0; cntr_addrs_0 < (r->in.num_addrs); cntr_addrs_0++) {
1419                         ndr_print_nbtd_proxy_wins_addr(ndr, "addrs", &r->in.addrs[cntr_addrs_0]);
1420                 }
1421                 ndr->depth--;
1422                 ndr->depth--;
1423         }
1424         if (flags & NDR_OUT) {
1425                 ndr_print_struct(ndr, "out", "nbtd_proxy_wins_release_demand");
1426                 ndr->depth++;
1427                 ndr->depth--;
1428         }
1429         ndr->depth--;
1430 }
1431
1432 static enum ndr_err_code ndr_push_kdc_check_generic_kerberos(struct ndr_push *ndr, int flags, const struct kdc_check_generic_kerberos *r)
1433 {
1434         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1435         if (flags & NDR_IN) {
1436                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.generic_request));
1437         }
1438         if (flags & NDR_OUT) {
1439                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.generic_reply));
1440         }
1441         return NDR_ERR_SUCCESS;
1442 }
1443
1444 static enum ndr_err_code ndr_pull_kdc_check_generic_kerberos(struct ndr_pull *ndr, int flags, struct kdc_check_generic_kerberos *r)
1445 {
1446         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1447         if (flags & NDR_IN) {
1448                 ZERO_STRUCT(r->out);
1449
1450                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.generic_request));
1451         }
1452         if (flags & NDR_OUT) {
1453                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.generic_reply));
1454         }
1455         return NDR_ERR_SUCCESS;
1456 }
1457
1458 _PUBLIC_ void ndr_print_kdc_check_generic_kerberos(struct ndr_print *ndr, const char *name, int flags, const struct kdc_check_generic_kerberos *r)
1459 {
1460         ndr_print_struct(ndr, name, "kdc_check_generic_kerberos");
1461         if (r == NULL) { ndr_print_null(ndr); return; }
1462         ndr->depth++;
1463         if (flags & NDR_SET_VALUES) {
1464                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1465         }
1466         if (flags & NDR_IN) {
1467                 ndr_print_struct(ndr, "in", "kdc_check_generic_kerberos");
1468                 ndr->depth++;
1469                 ndr_print_DATA_BLOB(ndr, "generic_request", r->in.generic_request);
1470                 ndr->depth--;
1471         }
1472         if (flags & NDR_OUT) {
1473                 ndr_print_struct(ndr, "out", "kdc_check_generic_kerberos");
1474                 ndr->depth++;
1475                 ndr_print_DATA_BLOB(ndr, "generic_reply", r->out.generic_reply);
1476                 ndr->depth--;
1477         }
1478         ndr->depth--;
1479 }
1480
1481 static enum ndr_err_code ndr_push_smbsrv_information(struct ndr_push *ndr, int flags, const struct smbsrv_information *r)
1482 {
1483         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1484         if (flags & NDR_IN) {
1485                 NDR_CHECK(ndr_push_smbsrv_info_level(ndr, NDR_SCALARS, r->in.level));
1486         }
1487         if (flags & NDR_OUT) {
1488                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info, r->in.level));
1489                 NDR_CHECK(ndr_push_smbsrv_info(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.info));
1490         }
1491         return NDR_ERR_SUCCESS;
1492 }
1493
1494 static enum ndr_err_code ndr_pull_smbsrv_information(struct ndr_pull *ndr, int flags, struct smbsrv_information *r)
1495 {
1496         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1497         if (flags & NDR_IN) {
1498                 ZERO_STRUCT(r->out);
1499
1500                 NDR_CHECK(ndr_pull_smbsrv_info_level(ndr, NDR_SCALARS, &r->in.level));
1501         }
1502         if (flags & NDR_OUT) {
1503                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info, r->in.level));
1504                 NDR_CHECK(ndr_pull_smbsrv_info(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.info));
1505         }
1506         return NDR_ERR_SUCCESS;
1507 }
1508
1509 _PUBLIC_ void ndr_print_smbsrv_information(struct ndr_print *ndr, const char *name, int flags, const struct smbsrv_information *r)
1510 {
1511         ndr_print_struct(ndr, name, "smbsrv_information");
1512         if (r == NULL) { ndr_print_null(ndr); return; }
1513         ndr->depth++;
1514         if (flags & NDR_SET_VALUES) {
1515                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1516         }
1517         if (flags & NDR_IN) {
1518                 ndr_print_struct(ndr, "in", "smbsrv_information");
1519                 ndr->depth++;
1520                 ndr_print_smbsrv_info_level(ndr, "level", r->in.level);
1521                 ndr->depth--;
1522         }
1523         if (flags & NDR_OUT) {
1524                 ndr_print_struct(ndr, "out", "smbsrv_information");
1525                 ndr->depth++;
1526                 ndr_print_set_switch_value(ndr, &r->out.info, r->in.level);
1527                 ndr_print_smbsrv_info(ndr, "info", &r->out.info);
1528                 ndr->depth--;
1529         }
1530         ndr->depth--;
1531 }
1532
1533 static enum ndr_err_code ndr_push_samba_terminate(struct ndr_push *ndr, int flags, const struct samba_terminate *r)
1534 {
1535         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1536         if (flags & NDR_IN) {
1537                 {
1538                         uint32_t _flags_save_string = ndr->flags;
1539                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
1540                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->in.reason));
1541                         ndr->flags = _flags_save_string;
1542                 }
1543         }
1544         if (flags & NDR_OUT) {
1545         }
1546         return NDR_ERR_SUCCESS;
1547 }
1548
1549 static enum ndr_err_code ndr_pull_samba_terminate(struct ndr_pull *ndr, int flags, struct samba_terminate *r)
1550 {
1551         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1552         if (flags & NDR_IN) {
1553                 {
1554                         uint32_t _flags_save_string = ndr->flags;
1555                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
1556                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->in.reason));
1557                         ndr->flags = _flags_save_string;
1558                 }
1559         }
1560         if (flags & NDR_OUT) {
1561         }
1562         return NDR_ERR_SUCCESS;
1563 }
1564
1565 _PUBLIC_ void ndr_print_samba_terminate(struct ndr_print *ndr, const char *name, int flags, const struct samba_terminate *r)
1566 {
1567         ndr_print_struct(ndr, name, "samba_terminate");
1568         if (r == NULL) { ndr_print_null(ndr); return; }
1569         ndr->depth++;
1570         if (flags & NDR_SET_VALUES) {
1571                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1572         }
1573         if (flags & NDR_IN) {
1574                 ndr_print_struct(ndr, "in", "samba_terminate");
1575                 ndr->depth++;
1576                 ndr_print_string(ndr, "reason", r->in.reason);
1577                 ndr->depth--;
1578         }
1579         if (flags & NDR_OUT) {
1580                 ndr_print_struct(ndr, "out", "samba_terminate");
1581                 ndr->depth++;
1582                 ndr->depth--;
1583         }
1584         ndr->depth--;
1585 }
1586
1587 static enum ndr_err_code ndr_push_dreplsrv_refresh(struct ndr_push *ndr, int flags, const struct dreplsrv_refresh *r)
1588 {
1589         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1590         if (flags & NDR_IN) {
1591         }
1592         if (flags & NDR_OUT) {
1593                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1594         }
1595         return NDR_ERR_SUCCESS;
1596 }
1597
1598 static enum ndr_err_code ndr_pull_dreplsrv_refresh(struct ndr_pull *ndr, int flags, struct dreplsrv_refresh *r)
1599 {
1600         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1601         if (flags & NDR_IN) {
1602         }
1603         if (flags & NDR_OUT) {
1604                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1605         }
1606         return NDR_ERR_SUCCESS;
1607 }
1608
1609 _PUBLIC_ void ndr_print_dreplsrv_refresh(struct ndr_print *ndr, const char *name, int flags, const struct dreplsrv_refresh *r)
1610 {
1611         ndr_print_struct(ndr, name, "dreplsrv_refresh");
1612         if (r == NULL) { ndr_print_null(ndr); return; }
1613         ndr->depth++;
1614         if (flags & NDR_SET_VALUES) {
1615                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1616         }
1617         if (flags & NDR_IN) {
1618                 ndr_print_struct(ndr, "in", "dreplsrv_refresh");
1619                 ndr->depth++;
1620                 ndr->depth--;
1621         }
1622         if (flags & NDR_OUT) {
1623                 ndr_print_struct(ndr, "out", "dreplsrv_refresh");
1624                 ndr->depth++;
1625                 ndr_print_WERROR(ndr, "result", r->out.result);
1626                 ndr->depth--;
1627         }
1628         ndr->depth--;
1629 }
1630
1631 static enum ndr_err_code ndr_push_drepl_takeFSMORole(struct ndr_push *ndr, int flags, const struct drepl_takeFSMORole *r)
1632 {
1633         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1634         if (flags & NDR_IN) {
1635                 NDR_CHECK(ndr_push_drepl_role_master(ndr, NDR_SCALARS, r->in.role));
1636         }
1637         if (flags & NDR_OUT) {
1638                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1639         }
1640         return NDR_ERR_SUCCESS;
1641 }
1642
1643 static enum ndr_err_code ndr_pull_drepl_takeFSMORole(struct ndr_pull *ndr, int flags, struct drepl_takeFSMORole *r)
1644 {
1645         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1646         if (flags & NDR_IN) {
1647                 NDR_CHECK(ndr_pull_drepl_role_master(ndr, NDR_SCALARS, &r->in.role));
1648         }
1649         if (flags & NDR_OUT) {
1650                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1651         }
1652         return NDR_ERR_SUCCESS;
1653 }
1654
1655 _PUBLIC_ void ndr_print_drepl_takeFSMORole(struct ndr_print *ndr, const char *name, int flags, const struct drepl_takeFSMORole *r)
1656 {
1657         ndr_print_struct(ndr, name, "drepl_takeFSMORole");
1658         if (r == NULL) { ndr_print_null(ndr); return; }
1659         ndr->depth++;
1660         if (flags & NDR_SET_VALUES) {
1661                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1662         }
1663         if (flags & NDR_IN) {
1664                 ndr_print_struct(ndr, "in", "drepl_takeFSMORole");
1665                 ndr->depth++;
1666                 ndr_print_drepl_role_master(ndr, "role", r->in.role);
1667                 ndr->depth--;
1668         }
1669         if (flags & NDR_OUT) {
1670                 ndr_print_struct(ndr, "out", "drepl_takeFSMORole");
1671                 ndr->depth++;
1672                 ndr_print_WERROR(ndr, "result", r->out.result);
1673                 ndr->depth--;
1674         }
1675         ndr->depth--;
1676 }
1677
1678 static enum ndr_err_code ndr_push_drepl_trigger_repl_secret(struct ndr_push *ndr, int flags, const struct drepl_trigger_repl_secret *r)
1679 {
1680         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1681         if (flags & NDR_IN) {
1682                 {
1683                         uint32_t _flags_save_string = ndr->flags;
1684                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
1685                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->in.user_dn));
1686                         ndr->flags = _flags_save_string;
1687                 }
1688         }
1689         if (flags & NDR_OUT) {
1690         }
1691         return NDR_ERR_SUCCESS;
1692 }
1693
1694 static enum ndr_err_code ndr_pull_drepl_trigger_repl_secret(struct ndr_pull *ndr, int flags, struct drepl_trigger_repl_secret *r)
1695 {
1696         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1697         if (flags & NDR_IN) {
1698                 {
1699                         uint32_t _flags_save_string = ndr->flags;
1700                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
1701                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->in.user_dn));
1702                         ndr->flags = _flags_save_string;
1703                 }
1704         }
1705         if (flags & NDR_OUT) {
1706         }
1707         return NDR_ERR_SUCCESS;
1708 }
1709
1710 _PUBLIC_ void ndr_print_drepl_trigger_repl_secret(struct ndr_print *ndr, const char *name, int flags, const struct drepl_trigger_repl_secret *r)
1711 {
1712         ndr_print_struct(ndr, name, "drepl_trigger_repl_secret");
1713         if (r == NULL) { ndr_print_null(ndr); return; }
1714         ndr->depth++;
1715         if (flags & NDR_SET_VALUES) {
1716                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1717         }
1718         if (flags & NDR_IN) {
1719                 ndr_print_struct(ndr, "in", "drepl_trigger_repl_secret");
1720                 ndr->depth++;
1721                 ndr_print_string(ndr, "user_dn", r->in.user_dn);
1722                 ndr->depth--;
1723         }
1724         if (flags & NDR_OUT) {
1725                 ndr_print_struct(ndr, "out", "drepl_trigger_repl_secret");
1726                 ndr->depth++;
1727                 ndr->depth--;
1728         }
1729         ndr->depth--;
1730 }
1731
1732 static enum ndr_err_code ndr_push_dnsupdate_RODC(struct ndr_push *ndr, int flags, const struct dnsupdate_RODC *r)
1733 {
1734         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1735         if (flags & NDR_IN) {
1736                 if (r->in.dns_names == NULL) {
1737                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1738                 }
1739                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dom_sid));
1740                 if (r->in.dom_sid) {
1741                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.dom_sid));
1742                 }
1743                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.site_name));
1744                 if (r->in.site_name) {
1745                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.site_name, CH_UTF16)));
1746                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
1747                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.site_name, CH_UTF16)));
1748                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.site_name, ndr_charset_length(r->in.site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1749                 }
1750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.dns_ttl));
1751                 NDR_CHECK(ndr_push_NL_DNS_NAME_INFO_ARRAY(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.dns_names));
1752         }
1753         if (flags & NDR_OUT) {
1754                 if (r->out.dns_names == NULL) {
1755                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1756                 }
1757                 NDR_CHECK(ndr_push_NL_DNS_NAME_INFO_ARRAY(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.dns_names));
1758                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1759         }
1760         return NDR_ERR_SUCCESS;
1761 }
1762
1763 static enum ndr_err_code ndr_pull_dnsupdate_RODC(struct ndr_pull *ndr, int flags, struct dnsupdate_RODC *r)
1764 {
1765         uint32_t _ptr_dom_sid;
1766         uint32_t _ptr_site_name;
1767         uint32_t size_site_name_1 = 0;
1768         uint32_t length_site_name_1 = 0;
1769         TALLOC_CTX *_mem_save_dom_sid_0 = NULL;
1770         TALLOC_CTX *_mem_save_site_name_0 = NULL;
1771         TALLOC_CTX *_mem_save_dns_names_0 = NULL;
1772         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1773         if (flags & NDR_IN) {
1774                 ZERO_STRUCT(r->out);
1775
1776                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dom_sid));
1777                 if (_ptr_dom_sid) {
1778                         NDR_PULL_ALLOC(ndr, r->in.dom_sid);
1779                 } else {
1780                         r->in.dom_sid = NULL;
1781                 }
1782                 if (r->in.dom_sid) {
1783                         _mem_save_dom_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1784                         NDR_PULL_SET_MEM_CTX(ndr, r->in.dom_sid, 0);
1785                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.dom_sid));
1786                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dom_sid_0, 0);
1787                 }
1788                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
1789                 if (_ptr_site_name) {
1790                         NDR_PULL_ALLOC(ndr, r->in.site_name);
1791                 } else {
1792                         r->in.site_name = NULL;
1793                 }
1794                 if (r->in.site_name) {
1795                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1796                         NDR_PULL_SET_MEM_CTX(ndr, r->in.site_name, 0);
1797                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.site_name));
1798                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.site_name));
1799                         size_site_name_1 = ndr_get_array_size(ndr, &r->in.site_name);
1800                         length_site_name_1 = ndr_get_array_length(ndr, &r->in.site_name);
1801                         if (length_site_name_1 > size_site_name_1) {
1802                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_site_name_1, length_site_name_1);
1803                         }
1804                         NDR_CHECK(ndr_check_string_terminator(ndr, length_site_name_1, sizeof(uint16_t)));
1805                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.site_name, length_site_name_1, sizeof(uint16_t), CH_UTF16));
1806                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
1807                 }
1808                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.dns_ttl));
1809                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1810                         NDR_PULL_ALLOC(ndr, r->in.dns_names);
1811                 }
1812                 _mem_save_dns_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
1813                 NDR_PULL_SET_MEM_CTX(ndr, r->in.dns_names, LIBNDR_FLAG_REF_ALLOC);
1814                 NDR_CHECK(ndr_pull_NL_DNS_NAME_INFO_ARRAY(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.dns_names));
1815                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_names_0, LIBNDR_FLAG_REF_ALLOC);
1816                 NDR_PULL_ALLOC(ndr, r->out.dns_names);
1817                 *r->out.dns_names = *r->in.dns_names;
1818         }
1819         if (flags & NDR_OUT) {
1820                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1821                         NDR_PULL_ALLOC(ndr, r->out.dns_names);
1822                 }
1823                 _mem_save_dns_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
1824                 NDR_PULL_SET_MEM_CTX(ndr, r->out.dns_names, LIBNDR_FLAG_REF_ALLOC);
1825                 NDR_CHECK(ndr_pull_NL_DNS_NAME_INFO_ARRAY(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.dns_names));
1826                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_names_0, LIBNDR_FLAG_REF_ALLOC);
1827                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1828         }
1829         return NDR_ERR_SUCCESS;
1830 }
1831
1832 _PUBLIC_ void ndr_print_dnsupdate_RODC(struct ndr_print *ndr, const char *name, int flags, const struct dnsupdate_RODC *r)
1833 {
1834         ndr_print_struct(ndr, name, "dnsupdate_RODC");
1835         if (r == NULL) { ndr_print_null(ndr); return; }
1836         ndr->depth++;
1837         if (flags & NDR_SET_VALUES) {
1838                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1839         }
1840         if (flags & NDR_IN) {
1841                 ndr_print_struct(ndr, "in", "dnsupdate_RODC");
1842                 ndr->depth++;
1843                 ndr_print_ptr(ndr, "dom_sid", r->in.dom_sid);
1844                 ndr->depth++;
1845                 if (r->in.dom_sid) {
1846                         ndr_print_dom_sid(ndr, "dom_sid", r->in.dom_sid);
1847                 }
1848                 ndr->depth--;
1849                 ndr_print_ptr(ndr, "site_name", r->in.site_name);
1850                 ndr->depth++;
1851                 if (r->in.site_name) {
1852                         ndr_print_string(ndr, "site_name", r->in.site_name);
1853                 }
1854                 ndr->depth--;
1855                 ndr_print_uint32(ndr, "dns_ttl", r->in.dns_ttl);
1856                 ndr_print_ptr(ndr, "dns_names", r->in.dns_names);
1857                 ndr->depth++;
1858                 ndr_print_NL_DNS_NAME_INFO_ARRAY(ndr, "dns_names", r->in.dns_names);
1859                 ndr->depth--;
1860                 ndr->depth--;
1861         }
1862         if (flags & NDR_OUT) {
1863                 ndr_print_struct(ndr, "out", "dnsupdate_RODC");
1864                 ndr->depth++;
1865                 ndr_print_ptr(ndr, "dns_names", r->out.dns_names);
1866                 ndr->depth++;
1867                 ndr_print_NL_DNS_NAME_INFO_ARRAY(ndr, "dns_names", r->out.dns_names);
1868                 ndr->depth--;
1869                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1870                 ndr->depth--;
1871         }
1872         ndr->depth--;
1873 }
1874
1875 static enum ndr_err_code ndr_push_dnssrv_reload_dns_zones(struct ndr_push *ndr, int flags, const struct dnssrv_reload_dns_zones *r)
1876 {
1877         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1878         if (flags & NDR_IN) {
1879         }
1880         if (flags & NDR_OUT) {
1881                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1882         }
1883         return NDR_ERR_SUCCESS;
1884 }
1885
1886 static enum ndr_err_code ndr_pull_dnssrv_reload_dns_zones(struct ndr_pull *ndr, int flags, struct dnssrv_reload_dns_zones *r)
1887 {
1888         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1889         if (flags & NDR_IN) {
1890         }
1891         if (flags & NDR_OUT) {
1892                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1893         }
1894         return NDR_ERR_SUCCESS;
1895 }
1896
1897 _PUBLIC_ void ndr_print_dnssrv_reload_dns_zones(struct ndr_print *ndr, const char *name, int flags, const struct dnssrv_reload_dns_zones *r)
1898 {
1899         ndr_print_struct(ndr, name, "dnssrv_reload_dns_zones");
1900         if (r == NULL) { ndr_print_null(ndr); return; }
1901         ndr->depth++;
1902         if (flags & NDR_SET_VALUES) {
1903                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1904         }
1905         if (flags & NDR_IN) {
1906                 ndr_print_struct(ndr, "in", "dnssrv_reload_dns_zones");
1907                 ndr->depth++;
1908                 ndr->depth--;
1909         }
1910         if (flags & NDR_OUT) {
1911                 ndr_print_struct(ndr, "out", "dnssrv_reload_dns_zones");
1912                 ndr->depth++;
1913                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1914                 ndr->depth--;
1915         }
1916         ndr->depth--;
1917 }
1918
1919 static const struct ndr_interface_call irpc_calls[] = {
1920         {
1921                 "irpc_uptime",
1922                 sizeof(struct irpc_uptime),
1923                 (ndr_push_flags_fn_t) ndr_push_irpc_uptime,
1924                 (ndr_pull_flags_fn_t) ndr_pull_irpc_uptime,
1925                 (ndr_print_function_t) ndr_print_irpc_uptime,
1926                 { 0, NULL },
1927                 { 0, NULL },
1928         },
1929         {
1930                 "nbtd_information",
1931                 sizeof(struct nbtd_information),
1932                 (ndr_push_flags_fn_t) ndr_push_nbtd_information,
1933                 (ndr_pull_flags_fn_t) ndr_pull_nbtd_information,
1934                 (ndr_print_function_t) ndr_print_nbtd_information,
1935                 { 0, NULL },
1936                 { 0, NULL },
1937         },
1938         {
1939                 "nbtd_getdcname",
1940                 sizeof(struct nbtd_getdcname),
1941                 (ndr_push_flags_fn_t) ndr_push_nbtd_getdcname,
1942                 (ndr_pull_flags_fn_t) ndr_pull_nbtd_getdcname,
1943                 (ndr_print_function_t) ndr_print_nbtd_getdcname,
1944                 { 0, NULL },
1945                 { 0, NULL },
1946         },
1947         {
1948                 "nbtd_proxy_wins_challenge",
1949                 sizeof(struct nbtd_proxy_wins_challenge),
1950                 (ndr_push_flags_fn_t) ndr_push_nbtd_proxy_wins_challenge,
1951                 (ndr_pull_flags_fn_t) ndr_pull_nbtd_proxy_wins_challenge,
1952                 (ndr_print_function_t) ndr_print_nbtd_proxy_wins_challenge,
1953                 { 0, NULL },
1954                 { 0, NULL },
1955         },
1956         {
1957                 "nbtd_proxy_wins_release_demand",
1958                 sizeof(struct nbtd_proxy_wins_release_demand),
1959                 (ndr_push_flags_fn_t) ndr_push_nbtd_proxy_wins_release_demand,
1960                 (ndr_pull_flags_fn_t) ndr_pull_nbtd_proxy_wins_release_demand,
1961                 (ndr_print_function_t) ndr_print_nbtd_proxy_wins_release_demand,
1962                 { 0, NULL },
1963                 { 0, NULL },
1964         },
1965         {
1966                 "kdc_check_generic_kerberos",
1967                 sizeof(struct kdc_check_generic_kerberos),
1968                 (ndr_push_flags_fn_t) ndr_push_kdc_check_generic_kerberos,
1969                 (ndr_pull_flags_fn_t) ndr_pull_kdc_check_generic_kerberos,
1970                 (ndr_print_function_t) ndr_print_kdc_check_generic_kerberos,
1971                 { 0, NULL },
1972                 { 0, NULL },
1973         },
1974         {
1975                 "smbsrv_information",
1976                 sizeof(struct smbsrv_information),
1977                 (ndr_push_flags_fn_t) ndr_push_smbsrv_information,
1978                 (ndr_pull_flags_fn_t) ndr_pull_smbsrv_information,
1979                 (ndr_print_function_t) ndr_print_smbsrv_information,
1980                 { 0, NULL },
1981                 { 0, NULL },
1982         },
1983         {
1984                 "samba_terminate",
1985                 sizeof(struct samba_terminate),
1986                 (ndr_push_flags_fn_t) ndr_push_samba_terminate,
1987                 (ndr_pull_flags_fn_t) ndr_pull_samba_terminate,
1988                 (ndr_print_function_t) ndr_print_samba_terminate,
1989                 { 0, NULL },
1990                 { 0, NULL },
1991         },
1992         {
1993                 "dreplsrv_refresh",
1994                 sizeof(struct dreplsrv_refresh),
1995                 (ndr_push_flags_fn_t) ndr_push_dreplsrv_refresh,
1996                 (ndr_pull_flags_fn_t) ndr_pull_dreplsrv_refresh,
1997                 (ndr_print_function_t) ndr_print_dreplsrv_refresh,
1998                 { 0, NULL },
1999                 { 0, NULL },
2000         },
2001         {
2002                 "drepl_takeFSMORole",
2003                 sizeof(struct drepl_takeFSMORole),
2004                 (ndr_push_flags_fn_t) ndr_push_drepl_takeFSMORole,
2005                 (ndr_pull_flags_fn_t) ndr_pull_drepl_takeFSMORole,
2006                 (ndr_print_function_t) ndr_print_drepl_takeFSMORole,
2007                 { 0, NULL },
2008                 { 0, NULL },
2009         },
2010         {
2011                 "drepl_trigger_repl_secret",
2012                 sizeof(struct drepl_trigger_repl_secret),
2013                 (ndr_push_flags_fn_t) ndr_push_drepl_trigger_repl_secret,
2014                 (ndr_pull_flags_fn_t) ndr_pull_drepl_trigger_repl_secret,
2015                 (ndr_print_function_t) ndr_print_drepl_trigger_repl_secret,
2016                 { 0, NULL },
2017                 { 0, NULL },
2018         },
2019         {
2020                 "dnsupdate_RODC",
2021                 sizeof(struct dnsupdate_RODC),
2022                 (ndr_push_flags_fn_t) ndr_push_dnsupdate_RODC,
2023                 (ndr_pull_flags_fn_t) ndr_pull_dnsupdate_RODC,
2024                 (ndr_print_function_t) ndr_print_dnsupdate_RODC,
2025                 { 0, NULL },
2026                 { 0, NULL },
2027         },
2028         {
2029                 "dnssrv_reload_dns_zones",
2030                 sizeof(struct dnssrv_reload_dns_zones),
2031                 (ndr_push_flags_fn_t) ndr_push_dnssrv_reload_dns_zones,
2032                 (ndr_pull_flags_fn_t) ndr_pull_dnssrv_reload_dns_zones,
2033                 (ndr_print_function_t) ndr_print_dnssrv_reload_dns_zones,
2034                 { 0, NULL },
2035                 { 0, NULL },
2036         },
2037         { NULL, 0, NULL, NULL, NULL }
2038 };
2039
2040 static const char * const irpc_endpoint_strings[] = {
2041         "ncacn_np:[\\pipe\\irpc]",
2042 };
2043
2044 static const struct ndr_interface_string_array irpc_endpoints = {
2045         .count  = 1,
2046         .names  = irpc_endpoint_strings
2047 };
2048
2049 static const char * const irpc_authservice_strings[] = {
2050         "host",
2051 };
2052
2053 static const struct ndr_interface_string_array irpc_authservices = {
2054         .count  = 1,
2055         .names  = irpc_authservice_strings
2056 };
2057
2058
2059 const struct ndr_interface_table ndr_table_irpc = {
2060         .name           = "irpc",
2061         .syntax_id      = {
2062                 {0xe770c620,0x0b06,0x4b5e,{0x8d,0x87},{0xa2,0x6e,0x20,0xf2,0x83,0x40}},
2063                 NDR_IRPC_VERSION
2064         },
2065         .helpstring     = NDR_IRPC_HELPSTRING,
2066         .num_calls      = 13,
2067         .calls          = irpc_calls,
2068         .endpoints      = &irpc_endpoints,
2069         .authservices   = &irpc_authservices
2070 };
2071