LCOV - code coverage report
Current view: top level - bin/default/source4/librpc/gen_ndr - ndr_irpc.c (source / functions) Hit Total Coverage
Test: coverage report for master 2b515b7d Lines: 304 1418 21.4 %
Date: 2024-02-28 12:06:22 Functions: 26 90 28.9 %

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

Generated by: LCOV version 1.14