LCOV - code coverage report
Current view: top level - bin/default/librpc/gen_ndr - ndr_dcerpc.c (source / functions) Hit Total Coverage
Test: coverage report for master 2b515b7d Lines: 1078 2820 38.2 %
Date: 2024-02-28 12:06:22 Functions: 89 239 37.2 %

          Line data    Source code
       1             : /* parser auto-generated by pidl */
       2             : 
       3             : #include "includes.h"
       4             : #include "bin/default/librpc/gen_ndr/ndr_dcerpc.h"
       5             : 
       6             : #include "librpc/gen_ndr/ndr_misc.h"
       7       93136 : static enum ndr_err_code ndr_push_dcerpc_ctx_list(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_ctx_list *r)
       8             : {
       9        1857 :         uint32_t cntr_transfer_syntaxes_0;
      10       93136 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
      11       93136 :         if (ndr_flags & NDR_SCALARS) {
      12       93136 :                 NDR_CHECK(ndr_push_align(ndr, 4));
      13       93136 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->context_id));
      14       93136 :                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->num_transfer_syntaxes));
      15       93136 :                 NDR_CHECK(ndr_push_ndr_syntax_id(ndr, NDR_SCALARS, &r->abstract_syntax));
      16      186428 :                 for (cntr_transfer_syntaxes_0 = 0; cntr_transfer_syntaxes_0 < (r->num_transfer_syntaxes); cntr_transfer_syntaxes_0++) {
      17       93292 :                         NDR_CHECK(ndr_push_ndr_syntax_id(ndr, NDR_SCALARS, &r->transfer_syntaxes[cntr_transfer_syntaxes_0]));
      18             :                 }
      19       93136 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
      20             :         }
      21       93136 :         if (ndr_flags & NDR_BUFFERS) {
      22        1857 :         }
      23       93136 :         return NDR_ERR_SUCCESS;
      24             : }
      25             : 
      26      125610 : static enum ndr_err_code ndr_pull_dcerpc_ctx_list(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_ctx_list *r)
      27             : {
      28      125610 :         uint32_t size_transfer_syntaxes_0 = 0;
      29        1865 :         uint32_t cntr_transfer_syntaxes_0;
      30      125610 :         TALLOC_CTX *_mem_save_transfer_syntaxes_0 = NULL;
      31      125610 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
      32      125610 :         if (ndr_flags & NDR_SCALARS) {
      33      125610 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
      34      125610 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->context_id));
      35      125610 :                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->num_transfer_syntaxes));
      36      125610 :                 NDR_CHECK(ndr_pull_ndr_syntax_id(ndr, NDR_SCALARS, &r->abstract_syntax));
      37      125610 :                 size_transfer_syntaxes_0 = r->num_transfer_syntaxes;
      38      125610 :                 NDR_PULL_ALLOC_N(ndr, r->transfer_syntaxes, size_transfer_syntaxes_0);
      39      125610 :                 _mem_save_transfer_syntaxes_0 = NDR_PULL_GET_MEM_CTX(ndr);
      40      125610 :                 NDR_PULL_SET_MEM_CTX(ndr, r->transfer_syntaxes, 0);
      41      251334 :                 for (cntr_transfer_syntaxes_0 = 0; cntr_transfer_syntaxes_0 < (size_transfer_syntaxes_0); cntr_transfer_syntaxes_0++) {
      42      125724 :                         NDR_CHECK(ndr_pull_ndr_syntax_id(ndr, NDR_SCALARS, &r->transfer_syntaxes[cntr_transfer_syntaxes_0]));
      43             :                 }
      44      125610 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transfer_syntaxes_0, 0);
      45      125610 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
      46             :         }
      47      125610 :         if (ndr_flags & NDR_BUFFERS) {
      48        1865 :         }
      49      125610 :         return NDR_ERR_SUCCESS;
      50             : }
      51             : 
      52           4 : _PUBLIC_ void ndr_print_dcerpc_ctx_list(struct ndr_print *ndr, const char *name, const struct dcerpc_ctx_list *r)
      53             : {
      54           0 :         uint32_t cntr_transfer_syntaxes_0;
      55           4 :         ndr_print_struct(ndr, name, "dcerpc_ctx_list");
      56           4 :         if (r == NULL) { ndr_print_null(ndr); return; }
      57           4 :         ndr->depth++;
      58           4 :         ndr_print_uint16(ndr, "context_id", r->context_id);
      59           4 :         ndr_print_uint8(ndr, "num_transfer_syntaxes", r->num_transfer_syntaxes);
      60           4 :         ndr_print_ndr_syntax_id(ndr, "abstract_syntax", &r->abstract_syntax);
      61           4 :         ndr->print(ndr, "%s: ARRAY(%"PRIu32")", "transfer_syntaxes", (uint32_t)(r->num_transfer_syntaxes));
      62           4 :         ndr->depth++;
      63           8 :         for (cntr_transfer_syntaxes_0 = 0; cntr_transfer_syntaxes_0 < (r->num_transfer_syntaxes); cntr_transfer_syntaxes_0++) {
      64           4 :                 ndr_print_ndr_syntax_id(ndr, "transfer_syntaxes", &r->transfer_syntaxes[cntr_transfer_syntaxes_0]);
      65             :         }
      66           4 :         ndr->depth--;
      67           4 :         ndr->depth--;
      68             : }
      69             : 
      70       73171 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_bind(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_bind *r)
      71             : {
      72         987 :         uint32_t cntr_ctx_list_0;
      73       73171 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
      74       73171 :         if (ndr_flags & NDR_SCALARS) {
      75       73171 :                 NDR_CHECK(ndr_push_align(ndr, 4));
      76       73171 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_xmit_frag));
      77       73171 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_recv_frag));
      78       73171 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->assoc_group_id));
      79       73171 :                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->num_contexts));
      80      166307 :                 for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < (r->num_contexts); cntr_ctx_list_0++) {
      81       93136 :                         NDR_CHECK(ndr_push_dcerpc_ctx_list(ndr, NDR_SCALARS, &r->ctx_list[cntr_ctx_list_0]));
      82             :                 }
      83             :                 {
      84       73171 :                         libndr_flags _flags_save_DATA_BLOB = ndr->flags;
      85       73171 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
      86       73171 :                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
      87       73171 :                         ndr->flags = _flags_save_DATA_BLOB;
      88             :                 }
      89       73171 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
      90             :         }
      91       73171 :         if (ndr_flags & NDR_BUFFERS) {
      92         987 :         }
      93       73171 :         return NDR_ERR_SUCCESS;
      94             : }
      95             : 
      96      104602 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_bind(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_bind *r)
      97             : {
      98      104602 :         uint32_t size_ctx_list_0 = 0;
      99         995 :         uint32_t cntr_ctx_list_0;
     100      104602 :         TALLOC_CTX *_mem_save_ctx_list_0 = NULL;
     101      104602 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     102      104602 :         if (ndr_flags & NDR_SCALARS) {
     103      104602 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
     104      104602 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_xmit_frag));
     105      104602 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_recv_frag));
     106      104602 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->assoc_group_id));
     107      104602 :                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->num_contexts));
     108      104602 :                 size_ctx_list_0 = r->num_contexts;
     109      104602 :                 NDR_PULL_ALLOC_N(ndr, r->ctx_list, size_ctx_list_0);
     110      104602 :                 _mem_save_ctx_list_0 = NDR_PULL_GET_MEM_CTX(ndr);
     111      104602 :                 NDR_PULL_SET_MEM_CTX(ndr, r->ctx_list, 0);
     112      230212 :                 for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < (size_ctx_list_0); cntr_ctx_list_0++) {
     113      125610 :                         NDR_CHECK(ndr_pull_dcerpc_ctx_list(ndr, NDR_SCALARS, &r->ctx_list[cntr_ctx_list_0]));
     114             :                 }
     115      104602 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctx_list_0, 0);
     116             :                 {
     117      104602 :                         libndr_flags _flags_save_DATA_BLOB = ndr->flags;
     118      104602 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
     119      104602 :                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
     120      104602 :                         ndr->flags = _flags_save_DATA_BLOB;
     121             :                 }
     122      104602 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
     123             :         }
     124      104602 :         if (ndr_flags & NDR_BUFFERS) {
     125         995 :         }
     126      104602 :         return NDR_ERR_SUCCESS;
     127             : }
     128             : 
     129           0 : static void ndr_print_flags_dcerpc_bind(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_bind *r)
     130             : {
     131           0 :         ndr_print_dcerpc_bind(ndr, name, r);
     132           0 : }
     133             : 
     134           4 : _PUBLIC_ void ndr_print_dcerpc_bind(struct ndr_print *ndr, const char *name, const struct dcerpc_bind *r)
     135             : {
     136           0 :         uint32_t cntr_ctx_list_0;
     137           4 :         ndr_print_struct(ndr, name, "dcerpc_bind");
     138           4 :         if (r == NULL) { ndr_print_null(ndr); return; }
     139           4 :         ndr->depth++;
     140           4 :         ndr_print_uint16(ndr, "max_xmit_frag", r->max_xmit_frag);
     141           4 :         ndr_print_uint16(ndr, "max_recv_frag", r->max_recv_frag);
     142           4 :         ndr_print_uint32(ndr, "assoc_group_id", r->assoc_group_id);
     143           4 :         ndr_print_uint8(ndr, "num_contexts", r->num_contexts);
     144           4 :         ndr->print(ndr, "%s: ARRAY(%"PRIu32")", "ctx_list", (uint32_t)(r->num_contexts));
     145           4 :         ndr->depth++;
     146           8 :         for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < (r->num_contexts); cntr_ctx_list_0++) {
     147           4 :                 ndr_print_dcerpc_ctx_list(ndr, "ctx_list", &r->ctx_list[cntr_ctx_list_0]);
     148             :         }
     149           4 :         ndr->depth--;
     150             :         {
     151           4 :                 libndr_flags _flags_save_DATA_BLOB = ndr->flags;
     152           4 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
     153           4 :                 ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
     154           4 :                 ndr->flags = _flags_save_DATA_BLOB;
     155             :         }
     156           4 :         ndr->depth--;
     157             : }
     158             : 
     159      873081 : static enum ndr_err_code ndr_push_dcerpc_empty(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_empty *r)
     160             : {
     161      873081 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     162      873081 :         if (ndr_flags & NDR_SCALARS) {
     163      873081 :                 NDR_CHECK(ndr_push_align(ndr, 1));
     164      873081 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
     165             :         }
     166      873081 :         if (ndr_flags & NDR_BUFFERS) {
     167        7079 :         }
     168      873081 :         return NDR_ERR_SUCCESS;
     169             : }
     170             : 
     171      854678 : static enum ndr_err_code ndr_pull_dcerpc_empty(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_empty *r)
     172             : {
     173      854678 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     174      854678 :         if (ndr_flags & NDR_SCALARS) {
     175      854678 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
     176      854678 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
     177             :         }
     178      854678 :         if (ndr_flags & NDR_BUFFERS) {
     179        7108 :         }
     180      854678 :         return NDR_ERR_SUCCESS;
     181             : }
     182             : 
     183         118 : _PUBLIC_ void ndr_print_dcerpc_empty(struct ndr_print *ndr, const char *name, const struct dcerpc_empty *r)
     184             : {
     185         118 :         ndr_print_struct(ndr, name, "dcerpc_empty");
     186         118 :         if (r == NULL) { ndr_print_null(ndr); return; }
     187         118 :         ndr->depth++;
     188         118 :         ndr->depth--;
     189             : }
     190             : 
     191      873753 : static enum ndr_err_code ndr_push_dcerpc_object(struct ndr_push *ndr, ndr_flags_type ndr_flags, const union dcerpc_object *r)
     192             : {
     193        7217 :         uint32_t level;
     194      873753 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     195      873753 :         if (ndr_flags & NDR_SCALARS) {
     196             :                 /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
     197      873753 :                 NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
     198      873753 :                 NDR_CHECK(ndr_push_union_align(ndr, 4));
     199      873753 :                 switch (level) {
     200         672 :                         default: {
     201         672 :                                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->object));
     202         534 :                         break; }
     203             : 
     204      873081 :                         case false: {
     205      873081 :                                 NDR_CHECK(ndr_push_dcerpc_empty(ndr, NDR_SCALARS, &r->empty));
     206      866002 :                         break; }
     207             : 
     208             :                 }
     209             :         }
     210      866536 :         return NDR_ERR_SUCCESS;
     211             : }
     212             : 
     213      855350 : static enum ndr_err_code ndr_pull_dcerpc_object(struct ndr_pull *ndr, ndr_flags_type ndr_flags, union dcerpc_object *r)
     214             : {
     215        7246 :         uint32_t level;
     216      855350 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     217      855350 :         if (ndr_flags & NDR_SCALARS) {
     218             :                 /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
     219      855350 :                 NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
     220      855350 :                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
     221      855350 :                 switch (level) {
     222         672 :                         default: {
     223         672 :                                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->object));
     224         534 :                         break; }
     225             : 
     226      854678 :                         case false: {
     227      854678 :                                 NDR_CHECK(ndr_pull_dcerpc_empty(ndr, NDR_SCALARS, &r->empty));
     228      847570 :                         break; }
     229             : 
     230             :                 }
     231             :         }
     232      848104 :         return NDR_ERR_SUCCESS;
     233             : }
     234             : 
     235         118 : _PUBLIC_ void ndr_print_dcerpc_object(struct ndr_print *ndr, const char *name, const union dcerpc_object *r)
     236             : {
     237           0 :         uint32_t level;
     238         118 :         level = ndr_print_steal_switch_value(ndr, r);
     239         118 :         ndr_print_union(ndr, name, level, "dcerpc_object");
     240         118 :         switch (level) {
     241           0 :                 default:
     242           0 :                         ndr_print_GUID(ndr, "object", &r->object);
     243           0 :                 break;
     244             : 
     245         118 :                 case false:
     246         118 :                         ndr_print_dcerpc_empty(ndr, "empty", &r->empty);
     247         118 :                 break;
     248             : 
     249             :         }
     250         118 : }
     251             : 
     252      873753 : static enum ndr_err_code ndr_push_dcerpc_request(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_request *r)
     253             : {
     254      873753 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     255      873753 :         if (ndr_flags & NDR_SCALARS) {
     256      873753 :                 NDR_CHECK(ndr_push_align(ndr, 4));
     257      873753 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alloc_hint));
     258      873753 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->context_id));
     259      873753 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->opnum));
     260      873753 :                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->object, NDR_DCERPC_REQUEST_OBJECT_PRESENT));
     261      873753 :                 NDR_CHECK(ndr_push_dcerpc_object(ndr, NDR_SCALARS, &r->object));
     262             :                 {
     263      873753 :                         libndr_flags _flags_save_DATA_BLOB = ndr->flags;
     264      873753 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
     265      873753 :                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->stub_and_verifier));
     266      873753 :                         ndr->flags = _flags_save_DATA_BLOB;
     267             :                 }
     268      873753 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
     269             :         }
     270      873753 :         if (ndr_flags & NDR_BUFFERS) {
     271        7217 :         }
     272      873753 :         return NDR_ERR_SUCCESS;
     273             : }
     274             : 
     275      855350 : static enum ndr_err_code ndr_pull_dcerpc_request(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_request *r)
     276             : {
     277      855350 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     278      855350 :         if (ndr_flags & NDR_SCALARS) {
     279      855350 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
     280      855350 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alloc_hint));
     281      855350 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->context_id));
     282      855350 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->opnum));
     283      855350 :                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->object, NDR_DCERPC_REQUEST_OBJECT_PRESENT));
     284      855350 :                 NDR_CHECK(ndr_pull_dcerpc_object(ndr, NDR_SCALARS, &r->object));
     285             :                 {
     286      855350 :                         libndr_flags _flags_save_DATA_BLOB = ndr->flags;
     287      855350 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
     288      855350 :                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->stub_and_verifier));
     289      855350 :                         ndr->flags = _flags_save_DATA_BLOB;
     290             :                 }
     291      855350 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
     292             :         }
     293      855350 :         if (ndr_flags & NDR_BUFFERS) {
     294        7246 :         }
     295      855350 :         return NDR_ERR_SUCCESS;
     296             : }
     297             : 
     298         118 : _PUBLIC_ void ndr_print_dcerpc_request(struct ndr_print *ndr, const char *name, const struct dcerpc_request *r)
     299             : {
     300         118 :         ndr_print_struct(ndr, name, "dcerpc_request");
     301         118 :         if (r == NULL) { ndr_print_null(ndr); return; }
     302         118 :         ndr->depth++;
     303         118 :         ndr_print_uint32(ndr, "alloc_hint", r->alloc_hint);
     304         118 :         ndr_print_uint16(ndr, "context_id", r->context_id);
     305         118 :         ndr_print_uint16(ndr, "opnum", r->opnum);
     306         118 :         ndr_print_set_switch_value(ndr, &r->object, NDR_DCERPC_REQUEST_OBJECT_PRESENT);
     307         118 :         ndr_print_dcerpc_object(ndr, "object", &r->object);
     308             :         {
     309         118 :                 libndr_flags _flags_save_DATA_BLOB = ndr->flags;
     310         118 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
     311         118 :                 ndr_print_DATA_BLOB(ndr, "stub_and_verifier", r->stub_and_verifier);
     312         118 :                 ndr->flags = _flags_save_DATA_BLOB;
     313             :         }
     314         118 :         ndr->depth--;
     315             : }
     316             : 
     317       83716 : static enum ndr_err_code ndr_push_dcerpc_bind_ack_result(struct ndr_push *ndr, ndr_flags_type ndr_flags, enum dcerpc_bind_ack_result r)
     318             : {
     319       83716 :         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
     320       81890 :         return NDR_ERR_SUCCESS;
     321             : }
     322             : 
     323      137061 : static enum ndr_err_code ndr_pull_dcerpc_bind_ack_result(struct ndr_pull *ndr, ndr_flags_type ndr_flags, enum dcerpc_bind_ack_result *r)
     324             : {
     325        3636 :         uint16_t v;
     326      137061 :         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
     327      137061 :         *r = v;
     328      137061 :         return NDR_ERR_SUCCESS;
     329             : }
     330             : 
     331           4 : _PUBLIC_ void ndr_print_dcerpc_bind_ack_result(struct ndr_print *ndr, const char *name, enum dcerpc_bind_ack_result r)
     332             : {
     333           4 :         const char *val = NULL;
     334             : 
     335           4 :         switch (r) {
     336           4 :                 case DCERPC_BIND_ACK_RESULT_ACCEPTANCE: val = "DCERPC_BIND_ACK_RESULT_ACCEPTANCE"; break;
     337           0 :                 case DCERPC_BIND_ACK_RESULT_USER_REJECTION: val = "DCERPC_BIND_ACK_RESULT_USER_REJECTION"; break;
     338           0 :                 case DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION: val = "DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION"; break;
     339           0 :                 case DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK: val = "DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK"; break;
     340             :         }
     341           4 :         ndr_print_enum(ndr, name, "ENUM", val, r);
     342           4 : }
     343             : 
     344       64725 : static enum ndr_err_code ndr_push_dcerpc_bind_ack_reason_values(struct ndr_push *ndr, ndr_flags_type ndr_flags, enum dcerpc_bind_ack_reason_values r)
     345             : {
     346       64725 :         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
     347       63751 :         return NDR_ERR_SUCCESS;
     348             : }
     349             : 
     350       97298 : static enum ndr_err_code ndr_pull_dcerpc_bind_ack_reason_values(struct ndr_pull *ndr, ndr_flags_type ndr_flags, enum dcerpc_bind_ack_reason_values *r)
     351             : {
     352        1932 :         uint16_t v;
     353       97298 :         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
     354       97298 :         *r = v;
     355       97298 :         return NDR_ERR_SUCCESS;
     356             : }
     357             : 
     358           4 : _PUBLIC_ void ndr_print_dcerpc_bind_ack_reason_values(struct ndr_print *ndr, const char *name, enum dcerpc_bind_ack_reason_values r)
     359             : {
     360           4 :         const char *val = NULL;
     361             : 
     362           4 :         switch (r) {
     363           4 :                 case DCERPC_BIND_ACK_REASON_NOT_SPECIFIED: val = "DCERPC_BIND_ACK_REASON_NOT_SPECIFIED"; break;
     364           0 :                 case DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED: val = "DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED"; break;
     365           0 :                 case DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED: val = "DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED"; break;
     366           0 :                 case DCERPC_BIND_ACK_REASON_LOCAL_LIMIT_EXCEEDED: val = "DCERPC_BIND_ACK_REASON_LOCAL_LIMIT_EXCEEDED"; break;
     367             :         }
     368           4 :         ndr_print_enum(ndr, name, "ENUM", val, r);
     369           4 : }
     370             : 
     371       18991 : static enum ndr_err_code ndr_push_dcerpc_bind_time_features(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint16_t r)
     372             : {
     373       18991 :         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
     374       18139 :         return NDR_ERR_SUCCESS;
     375             : }
     376             : 
     377       39763 : static enum ndr_err_code ndr_pull_dcerpc_bind_time_features(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint16_t *r)
     378             : {
     379        1704 :         uint16_t v;
     380       39763 :         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
     381       39763 :         *r = v;
     382       39763 :         return NDR_ERR_SUCCESS;
     383             : }
     384             : 
     385           0 : _PUBLIC_ void ndr_print_dcerpc_bind_time_features(struct ndr_print *ndr, const char *name, uint16_t r)
     386             : {
     387           0 :         ndr_print_uint16(ndr, name, r);
     388           0 :         ndr->depth++;
     389           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "DCERPC_BIND_TIME_SECURITY_CONTEXT_MULTIPLEXING", DCERPC_BIND_TIME_SECURITY_CONTEXT_MULTIPLEXING, r);
     390           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "DCERPC_BIND_TIME_KEEP_CONNECTION_ON_ORPHAN", DCERPC_BIND_TIME_KEEP_CONNECTION_ON_ORPHAN, r);
     391           0 :         ndr->depth--;
     392           0 : }
     393             : 
     394       83716 : static enum ndr_err_code ndr_push_dcerpc_bind_ack_reason(struct ndr_push *ndr, ndr_flags_type ndr_flags, const union dcerpc_bind_ack_reason *r)
     395             : {
     396        1826 :         uint32_t level;
     397       83716 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     398       83716 :         if (ndr_flags & NDR_SCALARS) {
     399             :                 /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
     400       83716 :                 NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
     401       83716 :                 NDR_CHECK(ndr_push_union_align(ndr, 2));
     402       83716 :                 switch (level) {
     403       18991 :                         case DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK: {
     404       19843 :                                 NDR_CHECK(ndr_push_dcerpc_bind_time_features(ndr, NDR_SCALARS, r->negotiate));
     405       18139 :                         break; }
     406             : 
     407       64725 :                         default: {
     408       65699 :                                 NDR_CHECK(ndr_push_dcerpc_bind_ack_reason_values(ndr, NDR_SCALARS, r->value));
     409       63751 :                         break; }
     410             : 
     411             :                 }
     412             :         }
     413       81890 :         return NDR_ERR_SUCCESS;
     414             : }
     415             : 
     416      137061 : static enum ndr_err_code ndr_pull_dcerpc_bind_ack_reason(struct ndr_pull *ndr, ndr_flags_type ndr_flags, union dcerpc_bind_ack_reason *r)
     417             : {
     418        3636 :         uint32_t level;
     419      137061 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     420      137061 :         if (ndr_flags & NDR_SCALARS) {
     421             :                 /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
     422      137061 :                 NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
     423      137061 :                 NDR_CHECK(ndr_pull_union_align(ndr, 2));
     424      137061 :                 switch (level) {
     425       39763 :                         case DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK: {
     426       41467 :                                 NDR_CHECK(ndr_pull_dcerpc_bind_time_features(ndr, NDR_SCALARS, &r->negotiate));
     427       38059 :                         break; }
     428             : 
     429       97298 :                         default: {
     430       99230 :                                 NDR_CHECK(ndr_pull_dcerpc_bind_ack_reason_values(ndr, NDR_SCALARS, &r->value));
     431       95366 :                         break; }
     432             : 
     433             :                 }
     434             :         }
     435      133425 :         return NDR_ERR_SUCCESS;
     436             : }
     437             : 
     438           4 : _PUBLIC_ void ndr_print_dcerpc_bind_ack_reason(struct ndr_print *ndr, const char *name, const union dcerpc_bind_ack_reason *r)
     439             : {
     440           0 :         uint32_t level;
     441           4 :         level = ndr_print_steal_switch_value(ndr, r);
     442           4 :         ndr_print_union(ndr, name, level, "dcerpc_bind_ack_reason");
     443           4 :         switch (level) {
     444           0 :                 case DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK:
     445           0 :                         ndr_print_dcerpc_bind_time_features(ndr, "negotiate", r->negotiate);
     446           0 :                 break;
     447             : 
     448           4 :                 default:
     449           4 :                         ndr_print_dcerpc_bind_ack_reason_values(ndr, "value", r->value);
     450           4 :                 break;
     451             : 
     452             :         }
     453           4 : }
     454             : 
     455       83716 : static enum ndr_err_code ndr_push_dcerpc_ack_ctx(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_ack_ctx *r)
     456             : {
     457       83716 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     458       83716 :         if (ndr_flags & NDR_SCALARS) {
     459       83716 :                 NDR_CHECK(ndr_push_align(ndr, 4));
     460       85542 :                 NDR_CHECK(ndr_push_dcerpc_bind_ack_result(ndr, NDR_SCALARS, r->result));
     461       83716 :                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->reason, r->result));
     462       83716 :                 NDR_CHECK(ndr_push_dcerpc_bind_ack_reason(ndr, NDR_SCALARS, &r->reason));
     463       83716 :                 NDR_CHECK(ndr_push_ndr_syntax_id(ndr, NDR_SCALARS, &r->syntax));
     464       83716 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
     465             :         }
     466       83716 :         if (ndr_flags & NDR_BUFFERS) {
     467        1826 :         }
     468       83716 :         return NDR_ERR_SUCCESS;
     469             : }
     470             : 
     471      137061 : static enum ndr_err_code ndr_pull_dcerpc_ack_ctx(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_ack_ctx *r)
     472             : {
     473      137061 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     474      137061 :         if (ndr_flags & NDR_SCALARS) {
     475      137061 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
     476      140697 :                 NDR_CHECK(ndr_pull_dcerpc_bind_ack_result(ndr, NDR_SCALARS, &r->result));
     477      137061 :                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->reason, r->result));
     478      137061 :                 NDR_CHECK(ndr_pull_dcerpc_bind_ack_reason(ndr, NDR_SCALARS, &r->reason));
     479      137061 :                 NDR_CHECK(ndr_pull_ndr_syntax_id(ndr, NDR_SCALARS, &r->syntax));
     480      137061 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
     481             :         }
     482      137061 :         if (ndr_flags & NDR_BUFFERS) {
     483        3636 :         }
     484      137061 :         return NDR_ERR_SUCCESS;
     485             : }
     486             : 
     487           4 : _PUBLIC_ void ndr_print_dcerpc_ack_ctx(struct ndr_print *ndr, const char *name, const struct dcerpc_ack_ctx *r)
     488             : {
     489           4 :         ndr_print_struct(ndr, name, "dcerpc_ack_ctx");
     490           4 :         if (r == NULL) { ndr_print_null(ndr); return; }
     491           4 :         ndr->depth++;
     492           4 :         ndr_print_dcerpc_bind_ack_result(ndr, "result", r->result);
     493           4 :         ndr_print_set_switch_value(ndr, &r->reason, r->result);
     494           4 :         ndr_print_dcerpc_bind_ack_reason(ndr, "reason", &r->reason);
     495           4 :         ndr_print_ndr_syntax_id(ndr, "syntax", &r->syntax);
     496           4 :         ndr->depth--;
     497             : }
     498             : 
     499       64725 : static enum ndr_err_code ndr_push_dcerpc_bind_ack(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_bind_ack *r)
     500             : {
     501         974 :         uint32_t cntr_ctx_list_0;
     502       64725 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     503       64725 :         if (ndr_flags & NDR_SCALARS) {
     504       64725 :                 NDR_CHECK(ndr_push_align(ndr, 4));
     505       64725 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_xmit_frag));
     506       64725 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_recv_frag));
     507       64725 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->assoc_group_id));
     508       64725 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m_term_null(r->secondary_address)));
     509       64725 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->secondary_address, strlen_m_term_null(r->secondary_address), sizeof(uint8_t), CH_DOS));
     510             :                 {
     511       64725 :                         libndr_flags _flags_save_DATA_BLOB = ndr->flags;
     512       64725 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
     513       64725 :                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad1));
     514       64725 :                         ndr->flags = _flags_save_DATA_BLOB;
     515             :                 }
     516       64725 :                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->num_results));
     517      148441 :                 for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < (r->num_results); cntr_ctx_list_0++) {
     518       83716 :                         NDR_CHECK(ndr_push_dcerpc_ack_ctx(ndr, NDR_SCALARS, &r->ctx_list[cntr_ctx_list_0]));
     519             :                 }
     520             :                 {
     521       64725 :                         libndr_flags _flags_save_DATA_BLOB = ndr->flags;
     522       64725 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
     523       64725 :                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
     524       64725 :                         ndr->flags = _flags_save_DATA_BLOB;
     525             :                 }
     526       64725 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
     527             :         }
     528       64725 :         if (ndr_flags & NDR_BUFFERS) {
     529         974 :         }
     530       64725 :         return NDR_ERR_SUCCESS;
     531             : }
     532             : 
     533       97298 : static enum ndr_err_code ndr_pull_dcerpc_bind_ack(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_bind_ack *r)
     534             : {
     535       97298 :         uint32_t size_secondary_address_0 = 0;
     536       97298 :         uint32_t size_ctx_list_0 = 0;
     537        1932 :         uint32_t cntr_ctx_list_0;
     538       97298 :         TALLOC_CTX *_mem_save_ctx_list_0 = NULL;
     539       97298 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     540       97298 :         if (ndr_flags & NDR_SCALARS) {
     541       97298 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
     542       97298 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_xmit_frag));
     543       97298 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_recv_frag));
     544       97298 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->assoc_group_id));
     545       97298 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->secondary_address_size));
     546       97298 :                 size_secondary_address_0 = r->secondary_address_size;
     547       97298 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->secondary_address, size_secondary_address_0, sizeof(uint8_t), CH_DOS));
     548             :                 {
     549       97298 :                         libndr_flags _flags_save_DATA_BLOB = ndr->flags;
     550       97298 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
     551       97298 :                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad1));
     552       97298 :                         ndr->flags = _flags_save_DATA_BLOB;
     553             :                 }
     554       97298 :                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->num_results));
     555       97298 :                 size_ctx_list_0 = r->num_results;
     556       97298 :                 NDR_PULL_ALLOC_N(ndr, r->ctx_list, size_ctx_list_0);
     557       97298 :                 _mem_save_ctx_list_0 = NDR_PULL_GET_MEM_CTX(ndr);
     558       97298 :                 NDR_PULL_SET_MEM_CTX(ndr, r->ctx_list, 0);
     559      234359 :                 for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < (size_ctx_list_0); cntr_ctx_list_0++) {
     560      137061 :                         NDR_CHECK(ndr_pull_dcerpc_ack_ctx(ndr, NDR_SCALARS, &r->ctx_list[cntr_ctx_list_0]));
     561             :                 }
     562       97298 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctx_list_0, 0);
     563             :                 {
     564       97298 :                         libndr_flags _flags_save_DATA_BLOB = ndr->flags;
     565       97298 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
     566       97298 :                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
     567       97298 :                         ndr->flags = _flags_save_DATA_BLOB;
     568             :                 }
     569       97298 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
     570             :         }
     571       97298 :         if (ndr_flags & NDR_BUFFERS) {
     572        1932 :         }
     573       97298 :         return NDR_ERR_SUCCESS;
     574             : }
     575             : 
     576           4 : _PUBLIC_ void ndr_print_dcerpc_bind_ack(struct ndr_print *ndr, const char *name, const struct dcerpc_bind_ack *r)
     577             : {
     578           0 :         uint32_t cntr_ctx_list_0;
     579           4 :         ndr_print_struct(ndr, name, "dcerpc_bind_ack");
     580           4 :         if (r == NULL) { ndr_print_null(ndr); return; }
     581           4 :         ndr->depth++;
     582           4 :         ndr_print_uint16(ndr, "max_xmit_frag", r->max_xmit_frag);
     583           4 :         ndr_print_uint16(ndr, "max_recv_frag", r->max_recv_frag);
     584           4 :         ndr_print_uint32(ndr, "assoc_group_id", r->assoc_group_id);
     585           4 :         ndr_print_uint16(ndr, "secondary_address_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m_term_null(r->secondary_address):r->secondary_address_size);
     586           4 :         ndr_print_string(ndr, "secondary_address", r->secondary_address);
     587             :         {
     588           4 :                 libndr_flags _flags_save_DATA_BLOB = ndr->flags;
     589           4 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
     590           4 :                 ndr_print_DATA_BLOB(ndr, "_pad1", r->_pad1);
     591           4 :                 ndr->flags = _flags_save_DATA_BLOB;
     592             :         }
     593           4 :         ndr_print_uint8(ndr, "num_results", r->num_results);
     594           4 :         ndr->print(ndr, "%s: ARRAY(%"PRIu32")", "ctx_list", (uint32_t)(r->num_results));
     595           4 :         ndr->depth++;
     596           8 :         for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < (r->num_results); cntr_ctx_list_0++) {
     597           4 :                 ndr_print_dcerpc_ack_ctx(ndr, "ctx_list", &r->ctx_list[cntr_ctx_list_0]);
     598             :         }
     599           4 :         ndr->depth--;
     600             :         {
     601           4 :                 libndr_flags _flags_save_DATA_BLOB = ndr->flags;
     602           4 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
     603           4 :                 ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
     604           4 :                 ndr->flags = _flags_save_DATA_BLOB;
     605             :         }
     606           4 :         ndr->depth--;
     607             : }
     608             : 
     609         149 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_bind_nak_reason(struct ndr_push *ndr, ndr_flags_type ndr_flags, enum dcerpc_bind_nak_reason r)
     610             : {
     611         149 :         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
     612         131 :         return NDR_ERR_SUCCESS;
     613             : }
     614             : 
     615         230 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_bind_nak_reason(struct ndr_pull *ndr, ndr_flags_type ndr_flags, enum dcerpc_bind_nak_reason *r)
     616             : {
     617          36 :         uint16_t v;
     618         230 :         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
     619         230 :         *r = v;
     620         230 :         return NDR_ERR_SUCCESS;
     621             : }
     622             : 
     623           0 : _PUBLIC_ void ndr_print_dcerpc_bind_nak_reason(struct ndr_print *ndr, const char *name, enum dcerpc_bind_nak_reason r)
     624             : {
     625           0 :         const char *val = NULL;
     626             : 
     627           0 :         switch (r) {
     628           0 :                 case DCERPC_BIND_NAK_REASON_NOT_SPECIFIED: val = "DCERPC_BIND_NAK_REASON_NOT_SPECIFIED"; break;
     629           0 :                 case DCERPC_BIND_NAK_REASON_TEMPORARY_CONGESTION: val = "DCERPC_BIND_NAK_REASON_TEMPORARY_CONGESTION"; break;
     630           0 :                 case DCERPC_BIND_NAK_REASON_LOCAL_LIMIT_EXCEEDED: val = "DCERPC_BIND_NAK_REASON_LOCAL_LIMIT_EXCEEDED"; break;
     631           0 :                 case DCERPC_BIND_NAK_REASON_PROTOCOL_VERSION_NOT_SUPPORTED: val = "DCERPC_BIND_NAK_REASON_PROTOCOL_VERSION_NOT_SUPPORTED"; break;
     632           0 :                 case DCERPC_BIND_NAK_REASON_INVALID_AUTH_TYPE: val = "DCERPC_BIND_NAK_REASON_INVALID_AUTH_TYPE"; break;
     633           0 :                 case DCERPC_BIND_NAK_REASON_INVALID_CHECKSUM: val = "DCERPC_BIND_NAK_REASON_INVALID_CHECKSUM"; break;
     634             :         }
     635           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
     636           0 : }
     637             : 
     638         149 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_bind_nak_version(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_bind_nak_version *r)
     639             : {
     640         149 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     641         149 :         if (ndr_flags & NDR_SCALARS) {
     642         149 :                 NDR_CHECK(ndr_push_align(ndr, 1));
     643         149 :                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->rpc_vers));
     644         149 :                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->rpc_vers_minor));
     645         149 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
     646             :         }
     647         149 :         if (ndr_flags & NDR_BUFFERS) {
     648          18 :         }
     649         149 :         return NDR_ERR_SUCCESS;
     650             : }
     651             : 
     652         230 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_bind_nak_version(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_bind_nak_version *r)
     653             : {
     654         230 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     655         230 :         if (ndr_flags & NDR_SCALARS) {
     656         230 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
     657         230 :                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->rpc_vers));
     658         230 :                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->rpc_vers_minor));
     659         230 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
     660             :         }
     661         230 :         if (ndr_flags & NDR_BUFFERS) {
     662          36 :         }
     663         230 :         return NDR_ERR_SUCCESS;
     664             : }
     665             : 
     666           0 : static void ndr_print_flags_dcerpc_bind_nak_version(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_bind_nak_version *r)
     667             : {
     668           0 :         ndr_print_dcerpc_bind_nak_version(ndr, name, r);
     669           0 : }
     670             : 
     671           0 : _PUBLIC_ void ndr_print_dcerpc_bind_nak_version(struct ndr_print *ndr, const char *name, const struct dcerpc_bind_nak_version *r)
     672             : {
     673           0 :         ndr_print_struct(ndr, name, "dcerpc_bind_nak_version");
     674           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     675           0 :         ndr->depth++;
     676           0 :         ndr_print_uint8(ndr, "rpc_vers", r->rpc_vers);
     677           0 :         ndr_print_uint8(ndr, "rpc_vers_minor", r->rpc_vers_minor);
     678           0 :         ndr->depth--;
     679             : }
     680             : 
     681         149 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_bind_nak(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_bind_nak *r)
     682             : {
     683          18 :         uint32_t cntr_versions_0;
     684         149 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     685         149 :         if (ndr_flags & NDR_SCALARS) {
     686         149 :                 NDR_CHECK(ndr_push_align(ndr, 4));
     687         149 :                 NDR_CHECK(ndr_push_dcerpc_bind_nak_reason(ndr, NDR_SCALARS, r->reject_reason));
     688         149 :                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->num_versions));
     689         298 :                 for (cntr_versions_0 = 0; cntr_versions_0 < (r->num_versions); cntr_versions_0++) {
     690         149 :                         NDR_CHECK(ndr_push_dcerpc_bind_nak_version(ndr, NDR_SCALARS, &r->versions[cntr_versions_0]));
     691             :                 }
     692             :                 {
     693         149 :                         libndr_flags _flags_save_DATA_BLOB = ndr->flags;
     694         149 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
     695         149 :                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
     696         149 :                         ndr->flags = _flags_save_DATA_BLOB;
     697             :                 }
     698         149 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
     699             :         }
     700         149 :         if (ndr_flags & NDR_BUFFERS) {
     701          18 :         }
     702         149 :         return NDR_ERR_SUCCESS;
     703             : }
     704             : 
     705           0 : static void ndr_print_flags_dcerpc_bind_nak(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_bind_nak *r)
     706             : {
     707           0 :         ndr_print_dcerpc_bind_nak(ndr, name, r);
     708           0 : }
     709             : 
     710           0 : _PUBLIC_ void ndr_print_dcerpc_bind_nak(struct ndr_print *ndr, const char *name, const struct dcerpc_bind_nak *r)
     711             : {
     712           0 :         uint32_t cntr_versions_0;
     713           0 :         ndr_print_struct(ndr, name, "dcerpc_bind_nak");
     714           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     715           0 :         ndr->depth++;
     716           0 :         ndr_print_dcerpc_bind_nak_reason(ndr, "reject_reason", r->reject_reason);
     717           0 :         ndr_print_uint8(ndr, "num_versions", r->num_versions);
     718           0 :         ndr->print(ndr, "%s: ARRAY(%"PRIu32")", "versions", (uint32_t)(r->num_versions));
     719           0 :         ndr->depth++;
     720           0 :         for (cntr_versions_0 = 0; cntr_versions_0 < (r->num_versions); cntr_versions_0++) {
     721           0 :                 ndr_print_dcerpc_bind_nak_version(ndr, "versions", &r->versions[cntr_versions_0]);
     722             :         }
     723           0 :         ndr->depth--;
     724             :         {
     725           0 :                 libndr_flags _flags_save_DATA_BLOB = ndr->flags;
     726           0 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
     727           0 :                 ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
     728           0 :                 ndr->flags = _flags_save_DATA_BLOB;
     729             :         }
     730           0 :         ndr->depth--;
     731             : }
     732             : 
     733     1126099 : static enum ndr_err_code ndr_push_dcerpc_response(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_response *r)
     734             : {
     735     1126099 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     736     1126099 :         if (ndr_flags & NDR_SCALARS) {
     737     1126099 :                 NDR_CHECK(ndr_push_align(ndr, 4));
     738     1126099 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alloc_hint));
     739     1126099 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->context_id));
     740     1126099 :                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->cancel_count));
     741     1126099 :                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, 0));
     742             :                 {
     743     1126099 :                         libndr_flags _flags_save_DATA_BLOB = ndr->flags;
     744     1126099 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
     745     1126099 :                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->stub_and_verifier));
     746     1126099 :                         ndr->flags = _flags_save_DATA_BLOB;
     747             :                 }
     748     1126099 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
     749             :         }
     750     1126099 :         if (ndr_flags & NDR_BUFFERS) {
     751        6902 :         }
     752     1126099 :         return NDR_ERR_SUCCESS;
     753             : }
     754             : 
     755     1723833 : static enum ndr_err_code ndr_pull_dcerpc_response(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_response *r)
     756             : {
     757     1723833 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     758     1723833 :         if (ndr_flags & NDR_SCALARS) {
     759     1723833 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
     760     1723833 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alloc_hint));
     761     1723833 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->context_id));
     762     1723833 :                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->cancel_count));
     763     1723833 :                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->reserved));
     764             :                 {
     765     1723833 :                         libndr_flags _flags_save_DATA_BLOB = ndr->flags;
     766     1723833 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
     767     1723833 :                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->stub_and_verifier));
     768     1723833 :                         ndr->flags = _flags_save_DATA_BLOB;
     769             :                 }
     770     1723833 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
     771             :         }
     772     1723833 :         if (ndr_flags & NDR_BUFFERS) {
     773       13746 :         }
     774     1723833 :         return NDR_ERR_SUCCESS;
     775             : }
     776             : 
     777         118 : _PUBLIC_ void ndr_print_dcerpc_response(struct ndr_print *ndr, const char *name, const struct dcerpc_response *r)
     778             : {
     779         118 :         ndr_print_struct(ndr, name, "dcerpc_response");
     780         118 :         if (r == NULL) { ndr_print_null(ndr); return; }
     781         118 :         ndr->depth++;
     782         118 :         ndr_print_uint32(ndr, "alloc_hint", r->alloc_hint);
     783         118 :         ndr_print_uint16(ndr, "context_id", r->context_id);
     784         118 :         ndr_print_uint8(ndr, "cancel_count", r->cancel_count);
     785         118 :         ndr_print_uint8(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved);
     786             :         {
     787         118 :                 libndr_flags _flags_save_DATA_BLOB = ndr->flags;
     788         118 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
     789         118 :                 ndr_print_DATA_BLOB(ndr, "stub_and_verifier", r->stub_and_verifier);
     790         118 :                 ndr->flags = _flags_save_DATA_BLOB;
     791             :         }
     792         118 :         ndr->depth--;
     793             : }
     794             : 
     795        2885 : static enum ndr_err_code ndr_push_dcerpc_nca_status(struct ndr_push *ndr, ndr_flags_type ndr_flags, enum dcerpc_nca_status r)
     796             : {
     797        2885 :         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
     798        2539 :         return NDR_ERR_SUCCESS;
     799             : }
     800             : 
     801        5733 : static enum ndr_err_code ndr_pull_dcerpc_nca_status(struct ndr_pull *ndr, ndr_flags_type ndr_flags, enum dcerpc_nca_status *r)
     802             : {
     803         686 :         uint32_t v;
     804        5733 :         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
     805        5733 :         *r = v;
     806        5733 :         return NDR_ERR_SUCCESS;
     807             : }
     808             : 
     809           0 : _PUBLIC_ void ndr_print_dcerpc_nca_status(struct ndr_print *ndr, const char *name, enum dcerpc_nca_status r)
     810             : {
     811           0 :         const char *val = NULL;
     812             : 
     813           0 :         switch (r) {
     814           0 :                 case DCERPC_NCA_S_COMM_FAILURE: val = "DCERPC_NCA_S_COMM_FAILURE"; break;
     815           0 :                 case DCERPC_NCA_S_OP_RNG_ERROR: val = "DCERPC_NCA_S_OP_RNG_ERROR"; break;
     816           0 :                 case DCERPC_NCA_S_UNKNOWN_IF: val = "DCERPC_NCA_S_UNKNOWN_IF"; break;
     817           0 :                 case DCERPC_NCA_S_WRONG_BOOT_TIME: val = "DCERPC_NCA_S_WRONG_BOOT_TIME"; break;
     818           0 :                 case DCERPC_NCA_S_YOU_CRASHED: val = "DCERPC_NCA_S_YOU_CRASHED"; break;
     819           0 :                 case DCERPC_NCA_S_PROTO_ERROR: val = "DCERPC_NCA_S_PROTO_ERROR"; break;
     820           0 :                 case DCERPC_NCA_S_OUT_ARGS_TOO_BIG: val = "DCERPC_NCA_S_OUT_ARGS_TOO_BIG"; break;
     821           0 :                 case DCERPC_NCA_S_SERVER_TOO_BUSY: val = "DCERPC_NCA_S_SERVER_TOO_BUSY"; break;
     822           0 :                 case DCERPC_NCA_S_FAULT_STRING_TOO_LARGE: val = "DCERPC_NCA_S_FAULT_STRING_TOO_LARGE"; break;
     823           0 :                 case DCERPC_NCA_S_UNSUPPORTED_TYPE: val = "DCERPC_NCA_S_UNSUPPORTED_TYPE"; break;
     824           0 :                 case DCERPC_NCA_S_FAULT_INT_DIV_BY_ZERO: val = "DCERPC_NCA_S_FAULT_INT_DIV_BY_ZERO"; break;
     825           0 :                 case DCERPC_NCA_S_FAULT_ADDR_ERROR: val = "DCERPC_NCA_S_FAULT_ADDR_ERROR"; break;
     826           0 :                 case DCERPC_NCA_S_FAULT_FP_DIV_BY_ZERO: val = "DCERPC_NCA_S_FAULT_FP_DIV_BY_ZERO"; break;
     827           0 :                 case DCERPC_NCA_S_FAULT_FP_UNDERFLOW: val = "DCERPC_NCA_S_FAULT_FP_UNDERFLOW"; break;
     828           0 :                 case DCERPC_NCA_S_FAULT_FP_OVERRFLOW: val = "DCERPC_NCA_S_FAULT_FP_OVERRFLOW"; break;
     829           0 :                 case DCERPC_NCA_S_FAULT_INVALID_TAG: val = "DCERPC_NCA_S_FAULT_INVALID_TAG"; break;
     830           0 :                 case DCERPC_NCA_S_FAULT_INVALID_BOUND: val = "DCERPC_NCA_S_FAULT_INVALID_BOUND"; break;
     831           0 :                 case DCERPC_NCA_S_FAULT_RPC_VERSION_MISMATCH: val = "DCERPC_NCA_S_FAULT_RPC_VERSION_MISMATCH"; break;
     832           0 :                 case DCERPC_NCA_S_FAULT_UNSPEC_REJECT: val = "DCERPC_NCA_S_FAULT_UNSPEC_REJECT"; break;
     833           0 :                 case DCERPC_NCA_S_FAULT_BAD_ACTID: val = "DCERPC_NCA_S_FAULT_BAD_ACTID"; break;
     834           0 :                 case DCERPC_NCA_S_FAULT_WHO_ARE_YOU_FAILED: val = "DCERPC_NCA_S_FAULT_WHO_ARE_YOU_FAILED"; break;
     835           0 :                 case DCERPC_NCA_S_FAULT_MANAGER_NOT_ENTERED: val = "DCERPC_NCA_S_FAULT_MANAGER_NOT_ENTERED"; break;
     836           0 :                 case DCERPC_NCA_S_FAULT_CANCEL: val = "DCERPC_NCA_S_FAULT_CANCEL"; break;
     837           0 :                 case DCERPC_NCA_S_FAULT_ILL_INST: val = "DCERPC_NCA_S_FAULT_ILL_INST"; break;
     838           0 :                 case DCERPC_NCA_S_FAULT_FP_ERROR: val = "DCERPC_NCA_S_FAULT_FP_ERROR"; break;
     839           0 :                 case DCERPC_NCA_S_FAULT_INT_OVERFLOW: val = "DCERPC_NCA_S_FAULT_INT_OVERFLOW"; break;
     840           0 :                 case DCERPC_NCA_S_UNUSED_1C000011: val = "DCERPC_NCA_S_UNUSED_1C000011"; break;
     841           0 :                 case DCERPC_NCA_S_FAULT_UNSPEC: val = "DCERPC_NCA_S_FAULT_UNSPEC"; break;
     842           0 :                 case DCERPC_NCA_S_FAULT_REMOTE_COMM_FAILURE: val = "DCERPC_NCA_S_FAULT_REMOTE_COMM_FAILURE"; break;
     843           0 :                 case DCERPC_NCA_S_FAULT_PIPE_EMPTY: val = "DCERPC_NCA_S_FAULT_PIPE_EMPTY"; break;
     844           0 :                 case DCERPC_NCA_S_FAULT_PIPE_CLOSED: val = "DCERPC_NCA_S_FAULT_PIPE_CLOSED"; break;
     845           0 :                 case DCERPC_NCA_S_FAULT_PIPE_ORDER: val = "DCERPC_NCA_S_FAULT_PIPE_ORDER"; break;
     846           0 :                 case DCERPC_NCA_S_FAULT_PIPE_DISCIPLINE: val = "DCERPC_NCA_S_FAULT_PIPE_DISCIPLINE"; break;
     847           0 :                 case DCERPC_NCA_S_FAULT_PIPE_COMM_ERROR: val = "DCERPC_NCA_S_FAULT_PIPE_COMM_ERROR"; break;
     848           0 :                 case DCERPC_NCA_S_FAULT_PIPE_MEMORY: val = "DCERPC_NCA_S_FAULT_PIPE_MEMORY"; break;
     849           0 :                 case DCERPC_NCA_S_FAULT_CONTEXT_MISMATCH: val = "DCERPC_NCA_S_FAULT_CONTEXT_MISMATCH"; break;
     850           0 :                 case DCERPC_NCA_S_FAULT_REMOTE_NO_MEMORY: val = "DCERPC_NCA_S_FAULT_REMOTE_NO_MEMORY"; break;
     851           0 :                 case DCERPC_NCA_S_INVALID_PRES_CONTEXT_ID: val = "DCERPC_NCA_S_INVALID_PRES_CONTEXT_ID"; break;
     852           0 :                 case DCERPC_NCA_S_UNSUPPORTED_AUTHN_LEVEL: val = "DCERPC_NCA_S_UNSUPPORTED_AUTHN_LEVEL"; break;
     853           0 :                 case DCERPC_NCA_S_UNUSED_1C00001E: val = "DCERPC_NCA_S_UNUSED_1C00001E"; break;
     854           0 :                 case DCERPC_NCA_S_INVALID_CHECKSUM: val = "DCERPC_NCA_S_INVALID_CHECKSUM"; break;
     855           0 :                 case DCERPC_NCA_S_INVALID_CRC: val = "DCERPC_NCA_S_INVALID_CRC"; break;
     856           0 :                 case DCERPC_NCA_S_FAULT_USER_DEFINED: val = "DCERPC_NCA_S_FAULT_USER_DEFINED"; break;
     857           0 :                 case DCERPC_NCA_S_FAULT_TX_OPEN_FAILED: val = "DCERPC_NCA_S_FAULT_TX_OPEN_FAILED"; break;
     858           0 :                 case DCERPC_NCA_S_FAULT_CODESET_CONV_ERROR: val = "DCERPC_NCA_S_FAULT_CODESET_CONV_ERROR"; break;
     859           0 :                 case DCERPC_NCA_S_FAULT_OBJECT_NOT_FOUND: val = "DCERPC_NCA_S_FAULT_OBJECT_NOT_FOUND"; break;
     860           0 :                 case DCERPC_NCA_S_FAULT_NO_CLIENT_STUB: val = "DCERPC_NCA_S_FAULT_NO_CLIENT_STUB"; break;
     861           0 :                 case DCERPC_FAULT_ACCESS_DENIED: val = "DCERPC_FAULT_ACCESS_DENIED"; break;
     862           0 :                 case DCERPC_FAULT_SERVER_UNAVAILABLE: val = "DCERPC_FAULT_SERVER_UNAVAILABLE"; break;
     863           0 :                 case DCERPC_FAULT_NO_CALL_ACTIVE: val = "DCERPC_FAULT_NO_CALL_ACTIVE"; break;
     864           0 :                 case DCERPC_FAULT_CANT_PERFORM: val = "DCERPC_FAULT_CANT_PERFORM"; break;
     865           0 :                 case DCERPC_FAULT_OUT_OF_RESOURCES: val = "DCERPC_FAULT_OUT_OF_RESOURCES"; break;
     866           0 :                 case DCERPC_FAULT_BAD_STUB_DATA: val = "DCERPC_FAULT_BAD_STUB_DATA"; break;
     867           0 :                 case DCERPC_FAULT_SEC_PKG_ERROR: val = "DCERPC_FAULT_SEC_PKG_ERROR"; break;
     868             :         }
     869           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
     870           0 : }
     871             : 
     872        2885 : static enum ndr_err_code ndr_push_dcerpc_fault_flags(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint8_t r)
     873             : {
     874        2885 :         NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r));
     875        2539 :         return NDR_ERR_SUCCESS;
     876             : }
     877             : 
     878        5733 : static enum ndr_err_code ndr_pull_dcerpc_fault_flags(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint8_t *r)
     879             : {
     880         686 :         uint8_t v;
     881        5733 :         NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &v));
     882        5733 :         *r = v;
     883        5733 :         return NDR_ERR_SUCCESS;
     884             : }
     885             : 
     886           0 : _PUBLIC_ void ndr_print_dcerpc_fault_flags(struct ndr_print *ndr, const char *name, uint8_t r)
     887             : {
     888           0 :         ndr_print_uint8(ndr, name, r);
     889           0 :         ndr->depth++;
     890           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "DCERPC_FAULT_FLAG_EXTENDED_ERROR_INFORMATION", DCERPC_FAULT_FLAG_EXTENDED_ERROR_INFORMATION, r);
     891           0 :         ndr->depth--;
     892           0 : }
     893             : 
     894        2885 : static enum ndr_err_code ndr_push_dcerpc_fault(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_fault *r)
     895             : {
     896        2885 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     897        2885 :         if (ndr_flags & NDR_SCALARS) {
     898        2885 :                 NDR_CHECK(ndr_push_align(ndr, 4));
     899        2885 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alloc_hint));
     900        2885 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->context_id));
     901        2885 :                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->cancel_count));
     902        3231 :                 NDR_CHECK(ndr_push_dcerpc_fault_flags(ndr, NDR_SCALARS, r->flags));
     903        3231 :                 NDR_CHECK(ndr_push_dcerpc_nca_status(ndr, NDR_SCALARS, r->status));
     904        2885 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
     905             :                 {
     906        2885 :                         libndr_flags _flags_save_DATA_BLOB = ndr->flags;
     907        2885 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
     908        2885 :                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->error_and_verifier));
     909        2885 :                         ndr->flags = _flags_save_DATA_BLOB;
     910             :                 }
     911        2885 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
     912             :         }
     913        2885 :         if (ndr_flags & NDR_BUFFERS) {
     914         346 :         }
     915        2885 :         return NDR_ERR_SUCCESS;
     916             : }
     917             : 
     918        5733 : static enum ndr_err_code ndr_pull_dcerpc_fault(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_fault *r)
     919             : {
     920        5733 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     921        5733 :         if (ndr_flags & NDR_SCALARS) {
     922        5733 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
     923        5733 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alloc_hint));
     924        5733 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->context_id));
     925        5733 :                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->cancel_count));
     926        6419 :                 NDR_CHECK(ndr_pull_dcerpc_fault_flags(ndr, NDR_SCALARS, &r->flags));
     927        6419 :                 NDR_CHECK(ndr_pull_dcerpc_nca_status(ndr, NDR_SCALARS, &r->status));
     928        5733 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
     929             :                 {
     930        5733 :                         libndr_flags _flags_save_DATA_BLOB = ndr->flags;
     931        5733 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
     932        5733 :                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->error_and_verifier));
     933        5733 :                         ndr->flags = _flags_save_DATA_BLOB;
     934             :                 }
     935        5733 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
     936             :         }
     937        5733 :         if (ndr_flags & NDR_BUFFERS) {
     938         686 :         }
     939        5733 :         return NDR_ERR_SUCCESS;
     940             : }
     941             : 
     942           0 : _PUBLIC_ void ndr_print_dcerpc_fault(struct ndr_print *ndr, const char *name, const struct dcerpc_fault *r)
     943             : {
     944           0 :         ndr_print_struct(ndr, name, "dcerpc_fault");
     945           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     946           0 :         ndr->depth++;
     947           0 :         ndr_print_uint32(ndr, "alloc_hint", r->alloc_hint);
     948           0 :         ndr_print_uint16(ndr, "context_id", r->context_id);
     949           0 :         ndr_print_uint8(ndr, "cancel_count", r->cancel_count);
     950           0 :         ndr_print_dcerpc_fault_flags(ndr, "flags", r->flags);
     951           0 :         ndr_print_dcerpc_nca_status(ndr, "status", r->status);
     952           0 :         ndr_print_uint32(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved);
     953             :         {
     954           0 :                 libndr_flags _flags_save_DATA_BLOB = ndr->flags;
     955           0 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
     956           0 :                 ndr_print_DATA_BLOB(ndr, "error_and_verifier", r->error_and_verifier);
     957           0 :                 ndr->flags = _flags_save_DATA_BLOB;
     958             :         }
     959           0 :         ndr->depth--;
     960             : }
     961             : 
     962      515618 : static enum ndr_err_code ndr_push_dcerpc_AuthType(struct ndr_push *ndr, ndr_flags_type ndr_flags, enum dcerpc_AuthType r)
     963             : {
     964      515618 :         NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
     965      507786 :         return NDR_ERR_SUCCESS;
     966             : }
     967             : 
     968      514842 : static enum ndr_err_code ndr_pull_dcerpc_AuthType(struct ndr_pull *ndr, ndr_flags_type ndr_flags, enum dcerpc_AuthType *r)
     969             : {
     970        7825 :         uint8_t v;
     971      514842 :         NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
     972      514842 :         *r = v;
     973      514842 :         return NDR_ERR_SUCCESS;
     974             : }
     975             : 
     976           0 : _PUBLIC_ void ndr_print_dcerpc_AuthType(struct ndr_print *ndr, const char *name, enum dcerpc_AuthType r)
     977             : {
     978           0 :         const char *val = NULL;
     979             : 
     980           0 :         switch (r) {
     981           0 :                 case DCERPC_AUTH_TYPE_NONE: val = "DCERPC_AUTH_TYPE_NONE"; break;
     982           0 :                 case DCERPC_AUTH_TYPE_KRB5_1: val = "DCERPC_AUTH_TYPE_KRB5_1"; break;
     983           0 :                 case DCERPC_AUTH_TYPE_SPNEGO: val = "DCERPC_AUTH_TYPE_SPNEGO"; break;
     984           0 :                 case DCERPC_AUTH_TYPE_NTLMSSP: val = "DCERPC_AUTH_TYPE_NTLMSSP"; break;
     985           0 :                 case DCERPC_AUTH_TYPE_KRB5: val = "DCERPC_AUTH_TYPE_KRB5"; break;
     986           0 :                 case DCERPC_AUTH_TYPE_DPA: val = "DCERPC_AUTH_TYPE_DPA"; break;
     987           0 :                 case DCERPC_AUTH_TYPE_MSN: val = "DCERPC_AUTH_TYPE_MSN"; break;
     988           0 :                 case DCERPC_AUTH_TYPE_DIGEST: val = "DCERPC_AUTH_TYPE_DIGEST"; break;
     989           0 :                 case DCERPC_AUTH_TYPE_SCHANNEL: val = "DCERPC_AUTH_TYPE_SCHANNEL"; break;
     990           0 :                 case DCERPC_AUTH_TYPE_MSMQ: val = "DCERPC_AUTH_TYPE_MSMQ"; break;
     991           0 :                 case DCERPC_AUTH_TYPE_NCALRPC_AS_SYSTEM: val = "DCERPC_AUTH_TYPE_NCALRPC_AS_SYSTEM"; break;
     992             :         }
     993           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
     994           0 : }
     995             : 
     996      515618 : static enum ndr_err_code ndr_push_dcerpc_AuthLevel(struct ndr_push *ndr, ndr_flags_type ndr_flags, enum dcerpc_AuthLevel r)
     997             : {
     998      515618 :         NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
     999      507786 :         return NDR_ERR_SUCCESS;
    1000             : }
    1001             : 
    1002      514842 : static enum ndr_err_code ndr_pull_dcerpc_AuthLevel(struct ndr_pull *ndr, ndr_flags_type ndr_flags, enum dcerpc_AuthLevel *r)
    1003             : {
    1004        7825 :         uint8_t v;
    1005      514842 :         NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
    1006      514842 :         *r = v;
    1007      514842 :         return NDR_ERR_SUCCESS;
    1008             : }
    1009             : 
    1010           0 : _PUBLIC_ void ndr_print_dcerpc_AuthLevel(struct ndr_print *ndr, const char *name, enum dcerpc_AuthLevel r)
    1011             : {
    1012           0 :         const char *val = NULL;
    1013             : 
    1014           0 :         switch (r) {
    1015           0 :                 case DCERPC_AUTH_LEVEL_NONE: val = "DCERPC_AUTH_LEVEL_NONE"; break;
    1016           0 :                 case DCERPC_AUTH_LEVEL_CONNECT: val = "DCERPC_AUTH_LEVEL_CONNECT"; break;
    1017           0 :                 case DCERPC_AUTH_LEVEL_CALL: val = "DCERPC_AUTH_LEVEL_CALL"; break;
    1018           0 :                 case DCERPC_AUTH_LEVEL_PACKET: val = "DCERPC_AUTH_LEVEL_PACKET"; break;
    1019           0 :                 case DCERPC_AUTH_LEVEL_INTEGRITY: val = "DCERPC_AUTH_LEVEL_INTEGRITY"; break;
    1020           0 :                 case DCERPC_AUTH_LEVEL_PRIVACY: val = "DCERPC_AUTH_LEVEL_PRIVACY"; break;
    1021             :         }
    1022           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
    1023           0 : }
    1024             : 
    1025      515618 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_auth(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_auth *r)
    1026             : {
    1027      515618 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1028      515618 :         if (ndr_flags & NDR_SCALARS) {
    1029      515618 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    1030      523450 :                 NDR_CHECK(ndr_push_dcerpc_AuthType(ndr, NDR_SCALARS, r->auth_type));
    1031      523450 :                 NDR_CHECK(ndr_push_dcerpc_AuthLevel(ndr, NDR_SCALARS, r->auth_level));
    1032      515618 :                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->auth_pad_length));
    1033      515618 :                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->auth_reserved));
    1034      515618 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->auth_context_id));
    1035             :                 {
    1036      515618 :                         libndr_flags _flags_save_DATA_BLOB = ndr->flags;
    1037      515618 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    1038      515618 :                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->credentials));
    1039      515618 :                         ndr->flags = _flags_save_DATA_BLOB;
    1040             :                 }
    1041      515618 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    1042             :         }
    1043      515618 :         if (ndr_flags & NDR_BUFFERS) {
    1044        7832 :         }
    1045      515618 :         return NDR_ERR_SUCCESS;
    1046             : }
    1047             : 
    1048      514842 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_auth(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_auth *r)
    1049             : {
    1050      514842 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1051      514842 :         if (ndr_flags & NDR_SCALARS) {
    1052      514842 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    1053      522667 :                 NDR_CHECK(ndr_pull_dcerpc_AuthType(ndr, NDR_SCALARS, &r->auth_type));
    1054      522667 :                 NDR_CHECK(ndr_pull_dcerpc_AuthLevel(ndr, NDR_SCALARS, &r->auth_level));
    1055      514842 :                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->auth_pad_length));
    1056      514842 :                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->auth_reserved));
    1057      514842 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->auth_context_id));
    1058             :                 {
    1059      514842 :                         libndr_flags _flags_save_DATA_BLOB = ndr->flags;
    1060      514842 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    1061      514842 :                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->credentials));
    1062      514842 :                         ndr->flags = _flags_save_DATA_BLOB;
    1063             :                 }
    1064      514842 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    1065             :         }
    1066      514842 :         if (ndr_flags & NDR_BUFFERS) {
    1067        7825 :         }
    1068      514842 :         return NDR_ERR_SUCCESS;
    1069             : }
    1070             : 
    1071           0 : static void ndr_print_flags_dcerpc_auth(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_auth *r)
    1072             : {
    1073           0 :         ndr_print_dcerpc_auth(ndr, name, r);
    1074           0 : }
    1075             : 
    1076           0 : _PUBLIC_ void ndr_print_dcerpc_auth(struct ndr_print *ndr, const char *name, const struct dcerpc_auth *r)
    1077             : {
    1078           0 :         ndr_print_struct(ndr, name, "dcerpc_auth");
    1079           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1080           0 :         ndr->depth++;
    1081           0 :         ndr_print_dcerpc_AuthType(ndr, "auth_type", r->auth_type);
    1082           0 :         ndr_print_dcerpc_AuthLevel(ndr, "auth_level", r->auth_level);
    1083           0 :         ndr_print_uint8(ndr, "auth_pad_length", r->auth_pad_length);
    1084           0 :         ndr_print_uint8(ndr, "auth_reserved", r->auth_reserved);
    1085           0 :         ndr_print_uint32(ndr, "auth_context_id", r->auth_context_id);
    1086             :         {
    1087           0 :                 libndr_flags _flags_save_DATA_BLOB = ndr->flags;
    1088           0 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    1089           0 :                 ndr_print_DATA_BLOB(ndr, "credentials", r->credentials);
    1090           0 :                 ndr->flags = _flags_save_DATA_BLOB;
    1091             :         }
    1092           0 :         ndr->depth--;
    1093             : }
    1094             : 
    1095         289 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_auth3(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_auth3 *r)
    1096             : {
    1097         289 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1098         289 :         if (ndr_flags & NDR_SCALARS) {
    1099         289 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    1100         289 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
    1101             :                 {
    1102         289 :                         libndr_flags _flags_save_DATA_BLOB = ndr->flags;
    1103         289 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    1104         289 :                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
    1105         289 :                         ndr->flags = _flags_save_DATA_BLOB;
    1106             :                 }
    1107         289 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    1108             :         }
    1109         289 :         if (ndr_flags & NDR_BUFFERS) {
    1110           0 :         }
    1111         289 :         return NDR_ERR_SUCCESS;
    1112             : }
    1113             : 
    1114         230 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_auth3(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_auth3 *r)
    1115             : {
    1116         230 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1117         230 :         if (ndr_flags & NDR_SCALARS) {
    1118         230 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    1119         230 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_pad));
    1120             :                 {
    1121         230 :                         libndr_flags _flags_save_DATA_BLOB = ndr->flags;
    1122         230 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    1123         230 :                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
    1124         230 :                         ndr->flags = _flags_save_DATA_BLOB;
    1125             :                 }
    1126         230 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    1127             :         }
    1128         230 :         if (ndr_flags & NDR_BUFFERS) {
    1129           0 :         }
    1130         230 :         return NDR_ERR_SUCCESS;
    1131             : }
    1132             : 
    1133           0 : static void ndr_print_flags_dcerpc_auth3(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_auth3 *r)
    1134             : {
    1135           0 :         ndr_print_dcerpc_auth3(ndr, name, r);
    1136           0 : }
    1137             : 
    1138           0 : _PUBLIC_ void ndr_print_dcerpc_auth3(struct ndr_print *ndr, const char *name, const struct dcerpc_auth3 *r)
    1139             : {
    1140           0 :         ndr_print_struct(ndr, name, "dcerpc_auth3");
    1141           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1142           0 :         ndr->depth++;
    1143           0 :         ndr_print_uint32(ndr, "_pad", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->_pad);
    1144             :         {
    1145           0 :                 libndr_flags _flags_save_DATA_BLOB = ndr->flags;
    1146           0 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    1147           0 :                 ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
    1148           0 :                 ndr->flags = _flags_save_DATA_BLOB;
    1149             :         }
    1150           0 :         ndr->depth--;
    1151             : }
    1152             : 
    1153          32 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_orphaned(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_orphaned *r)
    1154             : {
    1155          32 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1156          32 :         if (ndr_flags & NDR_SCALARS) {
    1157          32 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    1158             :                 {
    1159          32 :                         libndr_flags _flags_save_DATA_BLOB = ndr->flags;
    1160          32 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    1161          32 :                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
    1162          32 :                         ndr->flags = _flags_save_DATA_BLOB;
    1163             :                 }
    1164          32 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    1165             :         }
    1166          32 :         if (ndr_flags & NDR_BUFFERS) {
    1167           2 :         }
    1168          32 :         return NDR_ERR_SUCCESS;
    1169             : }
    1170             : 
    1171          17 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_orphaned(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_orphaned *r)
    1172             : {
    1173          17 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1174          17 :         if (ndr_flags & NDR_SCALARS) {
    1175          17 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    1176             :                 {
    1177          17 :                         libndr_flags _flags_save_DATA_BLOB = ndr->flags;
    1178          17 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    1179          17 :                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
    1180          17 :                         ndr->flags = _flags_save_DATA_BLOB;
    1181             :                 }
    1182          17 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    1183             :         }
    1184          17 :         if (ndr_flags & NDR_BUFFERS) {
    1185           2 :         }
    1186          17 :         return NDR_ERR_SUCCESS;
    1187             : }
    1188             : 
    1189           0 : static void ndr_print_flags_dcerpc_orphaned(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_orphaned *r)
    1190             : {
    1191           0 :         ndr_print_dcerpc_orphaned(ndr, name, r);
    1192           0 : }
    1193             : 
    1194           2 : _PUBLIC_ void ndr_print_dcerpc_orphaned(struct ndr_print *ndr, const char *name, const struct dcerpc_orphaned *r)
    1195             : {
    1196           2 :         ndr_print_struct(ndr, name, "dcerpc_orphaned");
    1197           2 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1198           2 :         ndr->depth++;
    1199             :         {
    1200           2 :                 libndr_flags _flags_save_DATA_BLOB = ndr->flags;
    1201           2 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    1202           2 :                 ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
    1203           2 :                 ndr->flags = _flags_save_DATA_BLOB;
    1204             :         }
    1205           2 :         ndr->depth--;
    1206             : }
    1207             : 
    1208          14 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_co_cancel(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_co_cancel *r)
    1209             : {
    1210          14 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1211          14 :         if (ndr_flags & NDR_SCALARS) {
    1212          14 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    1213             :                 {
    1214          14 :                         libndr_flags _flags_save_DATA_BLOB = ndr->flags;
    1215          14 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    1216          14 :                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
    1217          14 :                         ndr->flags = _flags_save_DATA_BLOB;
    1218             :                 }
    1219          14 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    1220             :         }
    1221          14 :         if (ndr_flags & NDR_BUFFERS) {
    1222           2 :         }
    1223          14 :         return NDR_ERR_SUCCESS;
    1224             : }
    1225             : 
    1226           8 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_co_cancel(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_co_cancel *r)
    1227             : {
    1228           8 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1229           8 :         if (ndr_flags & NDR_SCALARS) {
    1230           8 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    1231             :                 {
    1232           8 :                         libndr_flags _flags_save_DATA_BLOB = ndr->flags;
    1233           8 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    1234           8 :                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
    1235           8 :                         ndr->flags = _flags_save_DATA_BLOB;
    1236             :                 }
    1237           8 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    1238             :         }
    1239           8 :         if (ndr_flags & NDR_BUFFERS) {
    1240           2 :         }
    1241           8 :         return NDR_ERR_SUCCESS;
    1242             : }
    1243             : 
    1244           0 : static void ndr_print_flags_dcerpc_co_cancel(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_co_cancel *r)
    1245             : {
    1246           0 :         ndr_print_dcerpc_co_cancel(ndr, name, r);
    1247           0 : }
    1248             : 
    1249           2 : _PUBLIC_ void ndr_print_dcerpc_co_cancel(struct ndr_print *ndr, const char *name, const struct dcerpc_co_cancel *r)
    1250             : {
    1251           2 :         ndr_print_struct(ndr, name, "dcerpc_co_cancel");
    1252           2 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1253           2 :         ndr->depth++;
    1254             :         {
    1255           2 :                 libndr_flags _flags_save_DATA_BLOB = ndr->flags;
    1256           2 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    1257           2 :                 ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
    1258           2 :                 ndr->flags = _flags_save_DATA_BLOB;
    1259             :         }
    1260           2 :         ndr->depth--;
    1261             : }
    1262             : 
    1263           0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_cl_cancel(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_cl_cancel *r)
    1264             : {
    1265           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1266           0 :         if (ndr_flags & NDR_SCALARS) {
    1267           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    1268           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
    1269           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id));
    1270           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    1271             :         }
    1272           0 :         if (ndr_flags & NDR_BUFFERS) {
    1273           0 :         }
    1274           0 :         return NDR_ERR_SUCCESS;
    1275             : }
    1276             : 
    1277           0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_cl_cancel(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_cl_cancel *r)
    1278             : {
    1279           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1280           0 :         if (ndr_flags & NDR_SCALARS) {
    1281           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    1282           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
    1283           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id));
    1284           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    1285             :         }
    1286           0 :         if (ndr_flags & NDR_BUFFERS) {
    1287           0 :         }
    1288           0 :         return NDR_ERR_SUCCESS;
    1289             : }
    1290             : 
    1291           0 : static void ndr_print_flags_dcerpc_cl_cancel(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_cl_cancel *r)
    1292             : {
    1293           0 :         ndr_print_dcerpc_cl_cancel(ndr, name, r);
    1294           0 : }
    1295             : 
    1296           0 : _PUBLIC_ void ndr_print_dcerpc_cl_cancel(struct ndr_print *ndr, const char *name, const struct dcerpc_cl_cancel *r)
    1297             : {
    1298           0 :         ndr_print_struct(ndr, name, "dcerpc_cl_cancel");
    1299           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1300           0 :         ndr->depth++;
    1301           0 :         ndr_print_uint32(ndr, "version", r->version);
    1302           0 :         ndr_print_uint32(ndr, "id", r->id);
    1303           0 :         ndr->depth--;
    1304             : }
    1305             : 
    1306           0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_cancel_ack(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_cancel_ack *r)
    1307             : {
    1308           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1309           0 :         if (ndr_flags & NDR_SCALARS) {
    1310           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    1311           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
    1312           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id));
    1313           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->server_is_accepting));
    1314           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    1315             :         }
    1316           0 :         if (ndr_flags & NDR_BUFFERS) {
    1317           0 :         }
    1318           0 :         return NDR_ERR_SUCCESS;
    1319             : }
    1320             : 
    1321           0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_cancel_ack(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_cancel_ack *r)
    1322             : {
    1323           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1324           0 :         if (ndr_flags & NDR_SCALARS) {
    1325           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    1326           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
    1327           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id));
    1328           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->server_is_accepting));
    1329           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    1330             :         }
    1331           0 :         if (ndr_flags & NDR_BUFFERS) {
    1332           0 :         }
    1333           0 :         return NDR_ERR_SUCCESS;
    1334             : }
    1335             : 
    1336           0 : static void ndr_print_flags_dcerpc_cancel_ack(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_cancel_ack *r)
    1337             : {
    1338           0 :         ndr_print_dcerpc_cancel_ack(ndr, name, r);
    1339           0 : }
    1340             : 
    1341           0 : _PUBLIC_ void ndr_print_dcerpc_cancel_ack(struct ndr_print *ndr, const char *name, const struct dcerpc_cancel_ack *r)
    1342             : {
    1343           0 :         ndr_print_struct(ndr, name, "dcerpc_cancel_ack");
    1344           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1345           0 :         ndr->depth++;
    1346           0 :         ndr_print_uint32(ndr, "version", r->version);
    1347           0 :         ndr_print_uint32(ndr, "id", r->id);
    1348           0 :         ndr_print_uint32(ndr, "server_is_accepting", r->server_is_accepting);
    1349           0 :         ndr->depth--;
    1350             : }
    1351             : 
    1352           0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_fack(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_fack *r)
    1353             : {
    1354           0 :         uint32_t cntr_selack_0;
    1355           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1356           0 :         if (ndr_flags & NDR_SCALARS) {
    1357           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    1358           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
    1359           0 :                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->_pad1));
    1360           0 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->window_size));
    1361           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_tdsu));
    1362           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_frag_size));
    1363           0 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->serial_no));
    1364           0 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->selack_size));
    1365           0 :                 for (cntr_selack_0 = 0; cntr_selack_0 < (r->selack_size); cntr_selack_0++) {
    1366           0 :                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->selack[cntr_selack_0]));
    1367             :                 }
    1368           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    1369             :         }
    1370           0 :         if (ndr_flags & NDR_BUFFERS) {
    1371           0 :         }
    1372           0 :         return NDR_ERR_SUCCESS;
    1373             : }
    1374             : 
    1375           0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_fack(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_fack *r)
    1376             : {
    1377           0 :         uint32_t size_selack_0 = 0;
    1378           0 :         uint32_t cntr_selack_0;
    1379           0 :         TALLOC_CTX *_mem_save_selack_0 = NULL;
    1380           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1381           0 :         if (ndr_flags & NDR_SCALARS) {
    1382           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    1383           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
    1384           0 :                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->_pad1));
    1385           0 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->window_size));
    1386           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_tdsu));
    1387           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_frag_size));
    1388           0 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->serial_no));
    1389           0 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->selack_size));
    1390           0 :                 size_selack_0 = r->selack_size;
    1391           0 :                 NDR_PULL_ALLOC_N(ndr, r->selack, size_selack_0);
    1392           0 :                 _mem_save_selack_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1393           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->selack, 0);
    1394           0 :                 for (cntr_selack_0 = 0; cntr_selack_0 < (size_selack_0); cntr_selack_0++) {
    1395           0 :                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->selack[cntr_selack_0]));
    1396             :                 }
    1397           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_selack_0, 0);
    1398           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    1399             :         }
    1400           0 :         if (ndr_flags & NDR_BUFFERS) {
    1401           0 :         }
    1402           0 :         return NDR_ERR_SUCCESS;
    1403             : }
    1404             : 
    1405           0 : static void ndr_print_flags_dcerpc_fack(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_fack *r)
    1406             : {
    1407           0 :         ndr_print_dcerpc_fack(ndr, name, r);
    1408           0 : }
    1409             : 
    1410           0 : _PUBLIC_ void ndr_print_dcerpc_fack(struct ndr_print *ndr, const char *name, const struct dcerpc_fack *r)
    1411             : {
    1412           0 :         uint32_t cntr_selack_0;
    1413           0 :         ndr_print_struct(ndr, name, "dcerpc_fack");
    1414           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1415           0 :         ndr->depth++;
    1416           0 :         ndr_print_uint32(ndr, "version", r->version);
    1417           0 :         ndr_print_uint8(ndr, "_pad1", r->_pad1);
    1418           0 :         ndr_print_uint16(ndr, "window_size", r->window_size);
    1419           0 :         ndr_print_uint32(ndr, "max_tdsu", r->max_tdsu);
    1420           0 :         ndr_print_uint32(ndr, "max_frag_size", r->max_frag_size);
    1421           0 :         ndr_print_uint16(ndr, "serial_no", r->serial_no);
    1422           0 :         ndr_print_uint16(ndr, "selack_size", r->selack_size);
    1423           0 :         ndr->print(ndr, "%s: ARRAY(%"PRIu32")", "selack", (uint32_t)(r->selack_size));
    1424           0 :         ndr->depth++;
    1425           0 :         for (cntr_selack_0 = 0; cntr_selack_0 < (r->selack_size); cntr_selack_0++) {
    1426           0 :                 ndr_print_uint32(ndr, "selack", r->selack[cntr_selack_0]);
    1427             :         }
    1428           0 :         ndr->depth--;
    1429           0 :         ndr->depth--;
    1430             : }
    1431             : 
    1432           0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_ack(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_ack *r)
    1433             : {
    1434           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1435           0 :         if (ndr_flags & NDR_SCALARS) {
    1436           0 :                 NDR_CHECK(ndr_push_align(ndr, 1));
    1437           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
    1438             :         }
    1439           0 :         if (ndr_flags & NDR_BUFFERS) {
    1440           0 :         }
    1441           0 :         return NDR_ERR_SUCCESS;
    1442             : }
    1443             : 
    1444           0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_ack(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_ack *r)
    1445             : {
    1446           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1447           0 :         if (ndr_flags & NDR_SCALARS) {
    1448           0 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
    1449           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
    1450             :         }
    1451           0 :         if (ndr_flags & NDR_BUFFERS) {
    1452           0 :         }
    1453           0 :         return NDR_ERR_SUCCESS;
    1454             : }
    1455             : 
    1456           0 : static void ndr_print_flags_dcerpc_ack(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_ack *r)
    1457             : {
    1458           0 :         ndr_print_dcerpc_ack(ndr, name, r);
    1459           0 : }
    1460             : 
    1461           0 : _PUBLIC_ void ndr_print_dcerpc_ack(struct ndr_print *ndr, const char *name, const struct dcerpc_ack *r)
    1462             : {
    1463           0 :         ndr_print_struct(ndr, name, "dcerpc_ack");
    1464           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1465           0 :         ndr->depth++;
    1466           0 :         ndr->depth--;
    1467             : }
    1468             : 
    1469           0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_ping(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_ping *r)
    1470             : {
    1471           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1472           0 :         if (ndr_flags & NDR_SCALARS) {
    1473           0 :                 NDR_CHECK(ndr_push_align(ndr, 1));
    1474           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
    1475             :         }
    1476           0 :         if (ndr_flags & NDR_BUFFERS) {
    1477           0 :         }
    1478           0 :         return NDR_ERR_SUCCESS;
    1479             : }
    1480             : 
    1481           0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_ping(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_ping *r)
    1482             : {
    1483           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1484           0 :         if (ndr_flags & NDR_SCALARS) {
    1485           0 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
    1486           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
    1487             :         }
    1488           0 :         if (ndr_flags & NDR_BUFFERS) {
    1489           0 :         }
    1490           0 :         return NDR_ERR_SUCCESS;
    1491             : }
    1492             : 
    1493           0 : static void ndr_print_flags_dcerpc_ping(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_ping *r)
    1494             : {
    1495           0 :         ndr_print_dcerpc_ping(ndr, name, r);
    1496           0 : }
    1497             : 
    1498           0 : _PUBLIC_ void ndr_print_dcerpc_ping(struct ndr_print *ndr, const char *name, const struct dcerpc_ping *r)
    1499             : {
    1500           0 :         ndr_print_struct(ndr, name, "dcerpc_ping");
    1501           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1502           0 :         ndr->depth++;
    1503           0 :         ndr->depth--;
    1504             : }
    1505             : 
    1506           0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_shutdown(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_shutdown *r)
    1507             : {
    1508           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1509           0 :         if (ndr_flags & NDR_SCALARS) {
    1510           0 :                 NDR_CHECK(ndr_push_align(ndr, 1));
    1511           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
    1512             :         }
    1513           0 :         if (ndr_flags & NDR_BUFFERS) {
    1514           0 :         }
    1515           0 :         return NDR_ERR_SUCCESS;
    1516             : }
    1517             : 
    1518           0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_shutdown(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_shutdown *r)
    1519             : {
    1520           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1521           0 :         if (ndr_flags & NDR_SCALARS) {
    1522           0 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
    1523           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
    1524             :         }
    1525           0 :         if (ndr_flags & NDR_BUFFERS) {
    1526           0 :         }
    1527           0 :         return NDR_ERR_SUCCESS;
    1528             : }
    1529             : 
    1530           0 : static void ndr_print_flags_dcerpc_shutdown(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_shutdown *r)
    1531             : {
    1532           0 :         ndr_print_dcerpc_shutdown(ndr, name, r);
    1533           0 : }
    1534             : 
    1535           0 : _PUBLIC_ void ndr_print_dcerpc_shutdown(struct ndr_print *ndr, const char *name, const struct dcerpc_shutdown *r)
    1536             : {
    1537           0 :         ndr_print_struct(ndr, name, "dcerpc_shutdown");
    1538           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1539           0 :         ndr->depth++;
    1540           0 :         ndr->depth--;
    1541             : }
    1542             : 
    1543           0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_working(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_working *r)
    1544             : {
    1545           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1546           0 :         if (ndr_flags & NDR_SCALARS) {
    1547           0 :                 NDR_CHECK(ndr_push_align(ndr, 1));
    1548           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
    1549             :         }
    1550           0 :         if (ndr_flags & NDR_BUFFERS) {
    1551           0 :         }
    1552           0 :         return NDR_ERR_SUCCESS;
    1553             : }
    1554             : 
    1555           0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_working(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_working *r)
    1556             : {
    1557           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1558           0 :         if (ndr_flags & NDR_SCALARS) {
    1559           0 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
    1560           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
    1561             :         }
    1562           0 :         if (ndr_flags & NDR_BUFFERS) {
    1563           0 :         }
    1564           0 :         return NDR_ERR_SUCCESS;
    1565             : }
    1566             : 
    1567           0 : static void ndr_print_flags_dcerpc_working(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_working *r)
    1568             : {
    1569           0 :         ndr_print_dcerpc_working(ndr, name, r);
    1570           0 : }
    1571             : 
    1572           0 : _PUBLIC_ void ndr_print_dcerpc_working(struct ndr_print *ndr, const char *name, const struct dcerpc_working *r)
    1573             : {
    1574           0 :         ndr_print_struct(ndr, name, "dcerpc_working");
    1575           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1576           0 :         ndr->depth++;
    1577           0 :         ndr->depth--;
    1578             : }
    1579             : 
    1580           0 : _PUBLIC_ enum ndr_err_code ndr_push_RTSCookie(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct RTSCookie *r)
    1581             : {
    1582           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1583           0 :         if (ndr_flags & NDR_SCALARS) {
    1584           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    1585           0 :                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->Cookie));
    1586           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    1587             :         }
    1588           0 :         if (ndr_flags & NDR_BUFFERS) {
    1589           0 :         }
    1590           0 :         return NDR_ERR_SUCCESS;
    1591             : }
    1592             : 
    1593           0 : _PUBLIC_ enum ndr_err_code ndr_pull_RTSCookie(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct RTSCookie *r)
    1594             : {
    1595           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1596           0 :         if (ndr_flags & NDR_SCALARS) {
    1597           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    1598           0 :                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->Cookie));
    1599           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    1600             :         }
    1601           0 :         if (ndr_flags & NDR_BUFFERS) {
    1602           0 :         }
    1603           0 :         return NDR_ERR_SUCCESS;
    1604             : }
    1605             : 
    1606           0 : static void ndr_print_flags_RTSCookie(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct RTSCookie *r)
    1607             : {
    1608           0 :         ndr_print_RTSCookie(ndr, name, r);
    1609           0 : }
    1610             : 
    1611           0 : _PUBLIC_ void ndr_print_RTSCookie(struct ndr_print *ndr, const char *name, const struct RTSCookie *r)
    1612             : {
    1613           0 :         ndr_print_struct(ndr, name, "RTSCookie");
    1614           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1615           0 :         ndr->depth++;
    1616           0 :         ndr_print_GUID(ndr, "Cookie", &r->Cookie);
    1617           0 :         ndr->depth--;
    1618             : }
    1619             : 
    1620           0 : _PUBLIC_ enum ndr_err_code ndr_push_AddressType(struct ndr_push *ndr, ndr_flags_type ndr_flags, enum AddressType r)
    1621             : {
    1622           0 :         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
    1623           0 :         return NDR_ERR_SUCCESS;
    1624             : }
    1625             : 
    1626           0 : _PUBLIC_ enum ndr_err_code ndr_pull_AddressType(struct ndr_pull *ndr, ndr_flags_type ndr_flags, enum AddressType *r)
    1627             : {
    1628           0 :         uint32_t v;
    1629           0 :         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
    1630           0 :         *r = v;
    1631           0 :         return NDR_ERR_SUCCESS;
    1632             : }
    1633             : 
    1634           0 : _PUBLIC_ void ndr_print_AddressType(struct ndr_print *ndr, const char *name, enum AddressType r)
    1635             : {
    1636           0 :         const char *val = NULL;
    1637             : 
    1638           0 :         switch (r) {
    1639           0 :                 case RTS_IPV4: val = "RTS_IPV4"; break;
    1640           0 :                 case RTS_IPV6: val = "RTS_IPV6"; break;
    1641             :         }
    1642           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
    1643           0 : }
    1644             : 
    1645           0 : static enum ndr_err_code ndr_push_ClientAddressType(struct ndr_push *ndr, ndr_flags_type ndr_flags, const union ClientAddressType *r)
    1646             : {
    1647           0 :         uint32_t level;
    1648           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1649           0 :         if (ndr_flags & NDR_SCALARS) {
    1650             :                 /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
    1651           0 :                 NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
    1652           0 :                 NDR_CHECK(ndr_push_union_align(ndr, 4));
    1653           0 :                 switch (level) {
    1654           0 :                         case RTS_IPV4: {
    1655           0 :                                 NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->ClientAddressIPV4));
    1656           0 :                         break; }
    1657             : 
    1658           0 :                         case RTS_IPV6: {
    1659           0 :                                 NDR_CHECK(ndr_push_ipv6address(ndr, NDR_SCALARS, r->ClientAddressIPV6));
    1660           0 :                         break; }
    1661             : 
    1662           0 :                         default:
    1663           0 :                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %"PRIu32, level);
    1664             :                 }
    1665             :         }
    1666           0 :         if (ndr_flags & NDR_BUFFERS) {
    1667           0 :                 if (!(ndr_flags & NDR_SCALARS)) {
    1668             :                         /* We didn't get it above, and the token is not needed after this. */
    1669           0 :                         NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
    1670             :                 }
    1671           0 :                 switch (level) {
    1672           0 :                         case RTS_IPV4:
    1673           0 :                         break;
    1674             : 
    1675           0 :                         case RTS_IPV6:
    1676           0 :                         break;
    1677             : 
    1678           0 :                         default:
    1679           0 :                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %"PRIu32, level);
    1680             :                 }
    1681             :         }
    1682           0 :         return NDR_ERR_SUCCESS;
    1683             : }
    1684             : 
    1685           0 : static enum ndr_err_code ndr_pull_ClientAddressType(struct ndr_pull *ndr, ndr_flags_type ndr_flags, union ClientAddressType *r)
    1686             : {
    1687           0 :         uint32_t level;
    1688           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1689           0 :         if (ndr_flags & NDR_SCALARS) {
    1690             :                 /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
    1691           0 :                 NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
    1692           0 :                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
    1693           0 :                 switch (level) {
    1694           0 :                         case RTS_IPV4: {
    1695           0 :                                 NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->ClientAddressIPV4));
    1696           0 :                         break; }
    1697             : 
    1698           0 :                         case RTS_IPV6: {
    1699           0 :                                 NDR_CHECK(ndr_pull_ipv6address(ndr, NDR_SCALARS, &r->ClientAddressIPV6));
    1700           0 :                         break; }
    1701             : 
    1702           0 :                         default:
    1703           0 :                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %"PRIu32" at %s", level, __location__);
    1704             :                 }
    1705             :         }
    1706           0 :         if (ndr_flags & NDR_BUFFERS) {
    1707           0 :                 if (!(ndr_flags & NDR_SCALARS)) {
    1708             :                         /* We didn't get it above, and the token is not needed after this. */
    1709           0 :                         NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
    1710             :                 }
    1711           0 :                 switch (level) {
    1712           0 :                         case RTS_IPV4:
    1713           0 :                         break;
    1714             : 
    1715           0 :                         case RTS_IPV6:
    1716           0 :                         break;
    1717             : 
    1718           0 :                         default:
    1719           0 :                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %"PRIu32" at %s", level, __location__);
    1720             :                 }
    1721             :         }
    1722           0 :         return NDR_ERR_SUCCESS;
    1723             : }
    1724             : 
    1725           0 : _PUBLIC_ void ndr_print_ClientAddressType(struct ndr_print *ndr, const char *name, const union ClientAddressType *r)
    1726             : {
    1727           0 :         uint32_t level;
    1728           0 :         level = ndr_print_steal_switch_value(ndr, r);
    1729           0 :         ndr_print_union(ndr, name, level, "ClientAddressType");
    1730           0 :         switch (level) {
    1731           0 :                 case RTS_IPV4:
    1732           0 :                         ndr_print_ipv4address(ndr, "ClientAddressIPV4", r->ClientAddressIPV4);
    1733           0 :                 break;
    1734             : 
    1735           0 :                 case RTS_IPV6:
    1736           0 :                         ndr_print_ipv6address(ndr, "ClientAddressIPV6", r->ClientAddressIPV6);
    1737           0 :                 break;
    1738             : 
    1739           0 :                 default:
    1740           0 :                         ndr_print_bad_level(ndr, name, level);
    1741             :         }
    1742           0 : }
    1743             : 
    1744           0 : _PUBLIC_ enum ndr_err_code ndr_push_ClientAddress(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct ClientAddress *r)
    1745             : {
    1746           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1747           0 :         if (ndr_flags & NDR_SCALARS) {
    1748           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    1749           0 :                 NDR_CHECK(ndr_push_AddressType(ndr, NDR_SCALARS, r->AddressType));
    1750           0 :                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ClientAddress, r->AddressType));
    1751           0 :                 NDR_CHECK(ndr_push_ClientAddressType(ndr, NDR_SCALARS, &r->ClientAddress));
    1752           0 :                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Padding, 12));
    1753           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    1754             :         }
    1755           0 :         if (ndr_flags & NDR_BUFFERS) {
    1756           0 :         }
    1757           0 :         return NDR_ERR_SUCCESS;
    1758             : }
    1759             : 
    1760           0 : _PUBLIC_ enum ndr_err_code ndr_pull_ClientAddress(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct ClientAddress *r)
    1761             : {
    1762           0 :         uint32_t size_Padding_0 = 0;
    1763           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1764           0 :         if (ndr_flags & NDR_SCALARS) {
    1765           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    1766           0 :                 NDR_CHECK(ndr_pull_AddressType(ndr, NDR_SCALARS, &r->AddressType));
    1767           0 :                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ClientAddress, r->AddressType));
    1768           0 :                 NDR_CHECK(ndr_pull_ClientAddressType(ndr, NDR_SCALARS, &r->ClientAddress));
    1769           0 :                 size_Padding_0 = 12;
    1770           0 :                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Padding, size_Padding_0));
    1771           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    1772             :         }
    1773           0 :         if (ndr_flags & NDR_BUFFERS) {
    1774           0 :         }
    1775           0 :         return NDR_ERR_SUCCESS;
    1776             : }
    1777             : 
    1778           0 : static void ndr_print_flags_ClientAddress(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct ClientAddress *r)
    1779             : {
    1780           0 :         ndr_print_ClientAddress(ndr, name, r);
    1781           0 : }
    1782             : 
    1783           0 : _PUBLIC_ void ndr_print_ClientAddress(struct ndr_print *ndr, const char *name, const struct ClientAddress *r)
    1784             : {
    1785           0 :         ndr_print_struct(ndr, name, "ClientAddress");
    1786           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1787           0 :         ndr->depth++;
    1788           0 :         ndr_print_AddressType(ndr, "AddressType", r->AddressType);
    1789           0 :         ndr_print_set_switch_value(ndr, &r->ClientAddress, r->AddressType);
    1790           0 :         ndr_print_ClientAddressType(ndr, "ClientAddress", &r->ClientAddress);
    1791           0 :         ndr_print_array_uint8(ndr, "Padding", r->Padding, 12);
    1792           0 :         ndr->depth--;
    1793             : }
    1794             : 
    1795           0 : _PUBLIC_ enum ndr_err_code ndr_push_ForwardDestination(struct ndr_push *ndr, ndr_flags_type ndr_flags, enum ForwardDestination r)
    1796             : {
    1797           0 :         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
    1798           0 :         return NDR_ERR_SUCCESS;
    1799             : }
    1800             : 
    1801           0 : _PUBLIC_ enum ndr_err_code ndr_pull_ForwardDestination(struct ndr_pull *ndr, ndr_flags_type ndr_flags, enum ForwardDestination *r)
    1802             : {
    1803           0 :         uint32_t v;
    1804           0 :         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
    1805           0 :         *r = v;
    1806           0 :         return NDR_ERR_SUCCESS;
    1807             : }
    1808             : 
    1809           0 : _PUBLIC_ void ndr_print_ForwardDestination(struct ndr_print *ndr, const char *name, enum ForwardDestination r)
    1810             : {
    1811           0 :         const char *val = NULL;
    1812             : 
    1813           0 :         switch (r) {
    1814           0 :                 case FDClient: val = "FDClient"; break;
    1815           0 :                 case FDInProxy: val = "FDInProxy"; break;
    1816           0 :                 case FDServer: val = "FDServer"; break;
    1817           0 :                 case FDOutProxy: val = "FDOutProxy"; break;
    1818             :         }
    1819           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
    1820           0 : }
    1821             : 
    1822           0 : _PUBLIC_ enum ndr_err_code ndr_push_FlowControlAcknowledgment(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct FlowControlAcknowledgment *r)
    1823             : {
    1824           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1825           0 :         if (ndr_flags & NDR_SCALARS) {
    1826           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    1827           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->BytesReceived));
    1828           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->AvailableWindow));
    1829           0 :                 NDR_CHECK(ndr_push_RTSCookie(ndr, NDR_SCALARS, &r->ChannelCookie));
    1830           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    1831             :         }
    1832           0 :         if (ndr_flags & NDR_BUFFERS) {
    1833           0 :         }
    1834           0 :         return NDR_ERR_SUCCESS;
    1835             : }
    1836             : 
    1837           0 : _PUBLIC_ enum ndr_err_code ndr_pull_FlowControlAcknowledgment(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct FlowControlAcknowledgment *r)
    1838             : {
    1839           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1840           0 :         if (ndr_flags & NDR_SCALARS) {
    1841           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    1842           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->BytesReceived));
    1843           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->AvailableWindow));
    1844           0 :                 NDR_CHECK(ndr_pull_RTSCookie(ndr, NDR_SCALARS, &r->ChannelCookie));
    1845           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    1846             :         }
    1847           0 :         if (ndr_flags & NDR_BUFFERS) {
    1848           0 :         }
    1849           0 :         return NDR_ERR_SUCCESS;
    1850             : }
    1851             : 
    1852           0 : static void ndr_print_flags_FlowControlAcknowledgment(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct FlowControlAcknowledgment *r)
    1853             : {
    1854           0 :         ndr_print_FlowControlAcknowledgment(ndr, name, r);
    1855           0 : }
    1856             : 
    1857           0 : _PUBLIC_ void ndr_print_FlowControlAcknowledgment(struct ndr_print *ndr, const char *name, const struct FlowControlAcknowledgment *r)
    1858             : {
    1859           0 :         ndr_print_struct(ndr, name, "FlowControlAcknowledgment");
    1860           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1861           0 :         ndr->depth++;
    1862           0 :         ndr_print_uint32(ndr, "BytesReceived", r->BytesReceived);
    1863           0 :         ndr_print_uint32(ndr, "AvailableWindow", r->AvailableWindow);
    1864           0 :         ndr_print_RTSCookie(ndr, "ChannelCookie", &r->ChannelCookie);
    1865           0 :         ndr->depth--;
    1866             : }
    1867             : 
    1868           0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_ReceiveWindowSize(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_ReceiveWindowSize *r)
    1869             : {
    1870           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1871           0 :         if (ndr_flags & NDR_SCALARS) {
    1872           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    1873           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ReceiveWindowSize));
    1874           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    1875             :         }
    1876           0 :         if (ndr_flags & NDR_BUFFERS) {
    1877           0 :         }
    1878           0 :         return NDR_ERR_SUCCESS;
    1879             : }
    1880             : 
    1881           0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_ReceiveWindowSize(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_ReceiveWindowSize *r)
    1882             : {
    1883           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1884           0 :         if (ndr_flags & NDR_SCALARS) {
    1885           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    1886           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ReceiveWindowSize));
    1887           0 :                 if (r->ReceiveWindowSize < 8192 || r->ReceiveWindowSize > 262144) {
    1888           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value (%"PRIu32") out of range (%"PRIu32" - %"PRIu32")", (uint32_t)(r->ReceiveWindowSize), (uint32_t)(8192), (uint32_t)(262144));
    1889             :                 }
    1890           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    1891             :         }
    1892           0 :         if (ndr_flags & NDR_BUFFERS) {
    1893           0 :         }
    1894           0 :         return NDR_ERR_SUCCESS;
    1895             : }
    1896             : 
    1897           0 : static void ndr_print_flags_dcerpc_rts_cmd_ReceiveWindowSize(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_ReceiveWindowSize *r)
    1898             : {
    1899           0 :         ndr_print_dcerpc_rts_cmd_ReceiveWindowSize(ndr, name, r);
    1900           0 : }
    1901             : 
    1902           0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_ReceiveWindowSize(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_ReceiveWindowSize *r)
    1903             : {
    1904           0 :         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_ReceiveWindowSize");
    1905           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1906           0 :         ndr->depth++;
    1907           0 :         ndr_print_uint32(ndr, "ReceiveWindowSize", r->ReceiveWindowSize);
    1908           0 :         ndr->depth--;
    1909             : }
    1910             : 
    1911           0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_FlowControlAck(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_FlowControlAck *r)
    1912             : {
    1913           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1914           0 :         if (ndr_flags & NDR_SCALARS) {
    1915           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    1916           0 :                 NDR_CHECK(ndr_push_FlowControlAcknowledgment(ndr, NDR_SCALARS, &r->Ack));
    1917           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    1918             :         }
    1919           0 :         if (ndr_flags & NDR_BUFFERS) {
    1920           0 :         }
    1921           0 :         return NDR_ERR_SUCCESS;
    1922             : }
    1923             : 
    1924           0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_FlowControlAck(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_FlowControlAck *r)
    1925             : {
    1926           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1927           0 :         if (ndr_flags & NDR_SCALARS) {
    1928           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    1929           0 :                 NDR_CHECK(ndr_pull_FlowControlAcknowledgment(ndr, NDR_SCALARS, &r->Ack));
    1930           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    1931             :         }
    1932           0 :         if (ndr_flags & NDR_BUFFERS) {
    1933           0 :         }
    1934           0 :         return NDR_ERR_SUCCESS;
    1935             : }
    1936             : 
    1937           0 : static void ndr_print_flags_dcerpc_rts_cmd_FlowControlAck(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_FlowControlAck *r)
    1938             : {
    1939           0 :         ndr_print_dcerpc_rts_cmd_FlowControlAck(ndr, name, r);
    1940           0 : }
    1941             : 
    1942           0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_FlowControlAck(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_FlowControlAck *r)
    1943             : {
    1944           0 :         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_FlowControlAck");
    1945           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1946           0 :         ndr->depth++;
    1947           0 :         ndr_print_FlowControlAcknowledgment(ndr, "Ack", &r->Ack);
    1948           0 :         ndr->depth--;
    1949             : }
    1950             : 
    1951           0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_ConnectionTimeout(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_ConnectionTimeout *r)
    1952             : {
    1953           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1954           0 :         if (ndr_flags & NDR_SCALARS) {
    1955           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    1956           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ConnectionTimeout));
    1957           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    1958             :         }
    1959           0 :         if (ndr_flags & NDR_BUFFERS) {
    1960           0 :         }
    1961           0 :         return NDR_ERR_SUCCESS;
    1962             : }
    1963             : 
    1964           0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_ConnectionTimeout(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_ConnectionTimeout *r)
    1965             : {
    1966           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1967           0 :         if (ndr_flags & NDR_SCALARS) {
    1968           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    1969           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ConnectionTimeout));
    1970           0 :                 if (r->ConnectionTimeout < 120000 || r->ConnectionTimeout > 14400000) {
    1971           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value (%"PRIu32") out of range (%"PRIu32" - %"PRIu32")", (uint32_t)(r->ConnectionTimeout), (uint32_t)(120000), (uint32_t)(14400000));
    1972             :                 }
    1973           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    1974             :         }
    1975           0 :         if (ndr_flags & NDR_BUFFERS) {
    1976           0 :         }
    1977           0 :         return NDR_ERR_SUCCESS;
    1978             : }
    1979             : 
    1980           0 : static void ndr_print_flags_dcerpc_rts_cmd_ConnectionTimeout(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_ConnectionTimeout *r)
    1981             : {
    1982           0 :         ndr_print_dcerpc_rts_cmd_ConnectionTimeout(ndr, name, r);
    1983           0 : }
    1984             : 
    1985           0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_ConnectionTimeout(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_ConnectionTimeout *r)
    1986             : {
    1987           0 :         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_ConnectionTimeout");
    1988           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1989           0 :         ndr->depth++;
    1990           0 :         ndr_print_uint32(ndr, "ConnectionTimeout", r->ConnectionTimeout);
    1991           0 :         ndr->depth--;
    1992             : }
    1993             : 
    1994           0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_Cookie(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_Cookie *r)
    1995             : {
    1996           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1997           0 :         if (ndr_flags & NDR_SCALARS) {
    1998           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    1999           0 :                 NDR_CHECK(ndr_push_RTSCookie(ndr, NDR_SCALARS, &r->Cookie));
    2000           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    2001             :         }
    2002           0 :         if (ndr_flags & NDR_BUFFERS) {
    2003           0 :         }
    2004           0 :         return NDR_ERR_SUCCESS;
    2005             : }
    2006             : 
    2007           0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_Cookie(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_Cookie *r)
    2008             : {
    2009           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2010           0 :         if (ndr_flags & NDR_SCALARS) {
    2011           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    2012           0 :                 NDR_CHECK(ndr_pull_RTSCookie(ndr, NDR_SCALARS, &r->Cookie));
    2013           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    2014             :         }
    2015           0 :         if (ndr_flags & NDR_BUFFERS) {
    2016           0 :         }
    2017           0 :         return NDR_ERR_SUCCESS;
    2018             : }
    2019             : 
    2020           0 : static void ndr_print_flags_dcerpc_rts_cmd_Cookie(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_Cookie *r)
    2021             : {
    2022           0 :         ndr_print_dcerpc_rts_cmd_Cookie(ndr, name, r);
    2023           0 : }
    2024             : 
    2025           0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_Cookie(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_Cookie *r)
    2026             : {
    2027           0 :         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_Cookie");
    2028           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2029           0 :         ndr->depth++;
    2030           0 :         ndr_print_RTSCookie(ndr, "Cookie", &r->Cookie);
    2031           0 :         ndr->depth--;
    2032             : }
    2033             : 
    2034           0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_ChannelLifetime(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_ChannelLifetime *r)
    2035             : {
    2036           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2037           0 :         if (ndr_flags & NDR_SCALARS) {
    2038           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    2039           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ChannelLifetime));
    2040           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    2041             :         }
    2042           0 :         if (ndr_flags & NDR_BUFFERS) {
    2043           0 :         }
    2044           0 :         return NDR_ERR_SUCCESS;
    2045             : }
    2046             : 
    2047           0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_ChannelLifetime(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_ChannelLifetime *r)
    2048             : {
    2049           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2050           0 :         if (ndr_flags & NDR_SCALARS) {
    2051           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    2052           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ChannelLifetime));
    2053           0 :                 if (r->ChannelLifetime < 131072 || r->ChannelLifetime > 2147483648) {
    2054           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value (%"PRIu32") out of range (%"PRIu32" - %"PRIu32")", (uint32_t)(r->ChannelLifetime), (uint32_t)(131072), (uint32_t)(2147483648));
    2055             :                 }
    2056           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    2057             :         }
    2058           0 :         if (ndr_flags & NDR_BUFFERS) {
    2059           0 :         }
    2060           0 :         return NDR_ERR_SUCCESS;
    2061             : }
    2062             : 
    2063           0 : static void ndr_print_flags_dcerpc_rts_cmd_ChannelLifetime(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_ChannelLifetime *r)
    2064             : {
    2065           0 :         ndr_print_dcerpc_rts_cmd_ChannelLifetime(ndr, name, r);
    2066           0 : }
    2067             : 
    2068           0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_ChannelLifetime(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_ChannelLifetime *r)
    2069             : {
    2070           0 :         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_ChannelLifetime");
    2071           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2072           0 :         ndr->depth++;
    2073           0 :         ndr_print_uint32(ndr, "ChannelLifetime", r->ChannelLifetime);
    2074           0 :         ndr->depth--;
    2075             : }
    2076             : 
    2077           0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_ClientKeepalive(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_ClientKeepalive *r)
    2078             : {
    2079           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2080           0 :         if (ndr_flags & NDR_SCALARS) {
    2081           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    2082           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ClientKeepalive));
    2083           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    2084             :         }
    2085           0 :         if (ndr_flags & NDR_BUFFERS) {
    2086           0 :         }
    2087           0 :         return NDR_ERR_SUCCESS;
    2088             : }
    2089             : 
    2090           0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_ClientKeepalive(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_ClientKeepalive *r)
    2091             : {
    2092           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2093           0 :         if (ndr_flags & NDR_SCALARS) {
    2094           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    2095           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ClientKeepalive));
    2096           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    2097             :         }
    2098           0 :         if (ndr_flags & NDR_BUFFERS) {
    2099           0 :         }
    2100           0 :         return NDR_ERR_SUCCESS;
    2101             : }
    2102             : 
    2103           0 : static void ndr_print_flags_dcerpc_rts_cmd_ClientKeepalive(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_ClientKeepalive *r)
    2104             : {
    2105           0 :         ndr_print_dcerpc_rts_cmd_ClientKeepalive(ndr, name, r);
    2106           0 : }
    2107             : 
    2108           0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_ClientKeepalive(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_ClientKeepalive *r)
    2109             : {
    2110           0 :         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_ClientKeepalive");
    2111           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2112           0 :         ndr->depth++;
    2113           0 :         ndr_print_uint32(ndr, "ClientKeepalive", r->ClientKeepalive);
    2114           0 :         ndr->depth--;
    2115             : }
    2116             : 
    2117           0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_Version(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_Version *r)
    2118             : {
    2119           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2120           0 :         if (ndr_flags & NDR_SCALARS) {
    2121           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    2122           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Version));
    2123           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    2124             :         }
    2125           0 :         if (ndr_flags & NDR_BUFFERS) {
    2126           0 :         }
    2127           0 :         return NDR_ERR_SUCCESS;
    2128             : }
    2129             : 
    2130           0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_Version(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_Version *r)
    2131             : {
    2132           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2133           0 :         if (ndr_flags & NDR_SCALARS) {
    2134           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    2135           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Version));
    2136           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    2137             :         }
    2138           0 :         if (ndr_flags & NDR_BUFFERS) {
    2139           0 :         }
    2140           0 :         return NDR_ERR_SUCCESS;
    2141             : }
    2142             : 
    2143           0 : static void ndr_print_flags_dcerpc_rts_cmd_Version(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_Version *r)
    2144             : {
    2145           0 :         ndr_print_dcerpc_rts_cmd_Version(ndr, name, r);
    2146           0 : }
    2147             : 
    2148           0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_Version(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_Version *r)
    2149             : {
    2150           0 :         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_Version");
    2151           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2152           0 :         ndr->depth++;
    2153           0 :         ndr_print_uint32(ndr, "Version", r->Version);
    2154           0 :         ndr->depth--;
    2155             : }
    2156             : 
    2157           0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_Empty(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_Empty *r)
    2158             : {
    2159           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2160           0 :         if (ndr_flags & NDR_SCALARS) {
    2161           0 :                 NDR_CHECK(ndr_push_align(ndr, 1));
    2162           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
    2163             :         }
    2164           0 :         if (ndr_flags & NDR_BUFFERS) {
    2165           0 :         }
    2166           0 :         return NDR_ERR_SUCCESS;
    2167             : }
    2168             : 
    2169           0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_Empty(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_Empty *r)
    2170             : {
    2171           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2172           0 :         if (ndr_flags & NDR_SCALARS) {
    2173           0 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
    2174           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
    2175             :         }
    2176           0 :         if (ndr_flags & NDR_BUFFERS) {
    2177           0 :         }
    2178           0 :         return NDR_ERR_SUCCESS;
    2179             : }
    2180             : 
    2181           0 : static void ndr_print_flags_dcerpc_rts_cmd_Empty(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_Empty *r)
    2182             : {
    2183           0 :         ndr_print_dcerpc_rts_cmd_Empty(ndr, name, r);
    2184           0 : }
    2185             : 
    2186           0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_Empty(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_Empty *r)
    2187             : {
    2188           0 :         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_Empty");
    2189           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2190           0 :         ndr->depth++;
    2191           0 :         ndr->depth--;
    2192             : }
    2193             : 
    2194           0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_Padding(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_Padding *r)
    2195             : {
    2196           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2197           0 :         if (ndr_flags & NDR_SCALARS) {
    2198           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    2199           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ConformanceCount));
    2200           0 :                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Padding, r->ConformanceCount));
    2201           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    2202             :         }
    2203           0 :         if (ndr_flags & NDR_BUFFERS) {
    2204           0 :         }
    2205           0 :         return NDR_ERR_SUCCESS;
    2206             : }
    2207             : 
    2208           0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_Padding(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_Padding *r)
    2209             : {
    2210           0 :         uint32_t size_Padding_0 = 0;
    2211           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2212           0 :         if (ndr_flags & NDR_SCALARS) {
    2213           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    2214           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ConformanceCount));
    2215           0 :                 if (r->ConformanceCount > 65535) {
    2216           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value (%"PRIu32") out of range (%"PRIu32" - %"PRIu32")", (uint32_t)(r->ConformanceCount), (uint32_t)(0), (uint32_t)(65535));
    2217             :                 }
    2218           0 :                 size_Padding_0 = r->ConformanceCount;
    2219           0 :                 NDR_PULL_ALLOC_N(ndr, r->Padding, size_Padding_0);
    2220           0 :                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Padding, size_Padding_0));
    2221           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    2222             :         }
    2223           0 :         if (ndr_flags & NDR_BUFFERS) {
    2224           0 :         }
    2225           0 :         return NDR_ERR_SUCCESS;
    2226             : }
    2227             : 
    2228           0 : static void ndr_print_flags_dcerpc_rts_cmd_Padding(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_Padding *r)
    2229             : {
    2230           0 :         ndr_print_dcerpc_rts_cmd_Padding(ndr, name, r);
    2231           0 : }
    2232             : 
    2233           0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_Padding(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_Padding *r)
    2234             : {
    2235           0 :         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_Padding");
    2236           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2237           0 :         ndr->depth++;
    2238           0 :         ndr_print_uint32(ndr, "ConformanceCount", r->ConformanceCount);
    2239           0 :         ndr_print_array_uint8(ndr, "Padding", r->Padding, r->ConformanceCount);
    2240           0 :         ndr->depth--;
    2241             : }
    2242             : 
    2243           0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_NegativeANCE(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_NegativeANCE *r)
    2244             : {
    2245           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2246           0 :         if (ndr_flags & NDR_SCALARS) {
    2247           0 :                 NDR_CHECK(ndr_push_align(ndr, 1));
    2248           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
    2249             :         }
    2250           0 :         if (ndr_flags & NDR_BUFFERS) {
    2251           0 :         }
    2252           0 :         return NDR_ERR_SUCCESS;
    2253             : }
    2254             : 
    2255           0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_NegativeANCE(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_NegativeANCE *r)
    2256             : {
    2257           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2258           0 :         if (ndr_flags & NDR_SCALARS) {
    2259           0 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
    2260           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
    2261             :         }
    2262           0 :         if (ndr_flags & NDR_BUFFERS) {
    2263           0 :         }
    2264           0 :         return NDR_ERR_SUCCESS;
    2265             : }
    2266             : 
    2267           0 : static void ndr_print_flags_dcerpc_rts_cmd_NegativeANCE(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_NegativeANCE *r)
    2268             : {
    2269           0 :         ndr_print_dcerpc_rts_cmd_NegativeANCE(ndr, name, r);
    2270           0 : }
    2271             : 
    2272           0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_NegativeANCE(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_NegativeANCE *r)
    2273             : {
    2274           0 :         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_NegativeANCE");
    2275           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2276           0 :         ndr->depth++;
    2277           0 :         ndr->depth--;
    2278             : }
    2279             : 
    2280           0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_ANCE(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_ANCE *r)
    2281             : {
    2282           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2283           0 :         if (ndr_flags & NDR_SCALARS) {
    2284           0 :                 NDR_CHECK(ndr_push_align(ndr, 1));
    2285           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
    2286             :         }
    2287           0 :         if (ndr_flags & NDR_BUFFERS) {
    2288           0 :         }
    2289           0 :         return NDR_ERR_SUCCESS;
    2290             : }
    2291             : 
    2292           0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_ANCE(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_ANCE *r)
    2293             : {
    2294           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2295           0 :         if (ndr_flags & NDR_SCALARS) {
    2296           0 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
    2297           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
    2298             :         }
    2299           0 :         if (ndr_flags & NDR_BUFFERS) {
    2300           0 :         }
    2301           0 :         return NDR_ERR_SUCCESS;
    2302             : }
    2303             : 
    2304           0 : static void ndr_print_flags_dcerpc_rts_cmd_ANCE(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_ANCE *r)
    2305             : {
    2306           0 :         ndr_print_dcerpc_rts_cmd_ANCE(ndr, name, r);
    2307           0 : }
    2308             : 
    2309           0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_ANCE(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_ANCE *r)
    2310             : {
    2311           0 :         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_ANCE");
    2312           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2313           0 :         ndr->depth++;
    2314           0 :         ndr->depth--;
    2315             : }
    2316             : 
    2317           0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_ClientAddress(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_ClientAddress *r)
    2318             : {
    2319           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2320           0 :         if (ndr_flags & NDR_SCALARS) {
    2321           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    2322           0 :                 NDR_CHECK(ndr_push_ClientAddress(ndr, NDR_SCALARS, &r->ClientAddress));
    2323           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    2324             :         }
    2325           0 :         if (ndr_flags & NDR_BUFFERS) {
    2326           0 :         }
    2327           0 :         return NDR_ERR_SUCCESS;
    2328             : }
    2329             : 
    2330           0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_ClientAddress(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_ClientAddress *r)
    2331             : {
    2332           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2333           0 :         if (ndr_flags & NDR_SCALARS) {
    2334           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    2335           0 :                 NDR_CHECK(ndr_pull_ClientAddress(ndr, NDR_SCALARS, &r->ClientAddress));
    2336           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    2337             :         }
    2338           0 :         if (ndr_flags & NDR_BUFFERS) {
    2339           0 :         }
    2340           0 :         return NDR_ERR_SUCCESS;
    2341             : }
    2342             : 
    2343           0 : static void ndr_print_flags_dcerpc_rts_cmd_ClientAddress(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_ClientAddress *r)
    2344             : {
    2345           0 :         ndr_print_dcerpc_rts_cmd_ClientAddress(ndr, name, r);
    2346           0 : }
    2347             : 
    2348           0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_ClientAddress(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_ClientAddress *r)
    2349             : {
    2350           0 :         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_ClientAddress");
    2351           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2352           0 :         ndr->depth++;
    2353           0 :         ndr_print_ClientAddress(ndr, "ClientAddress", &r->ClientAddress);
    2354           0 :         ndr->depth--;
    2355             : }
    2356             : 
    2357           0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_AssociationGroupId(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_AssociationGroupId *r)
    2358             : {
    2359           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2360           0 :         if (ndr_flags & NDR_SCALARS) {
    2361           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    2362           0 :                 NDR_CHECK(ndr_push_RTSCookie(ndr, NDR_SCALARS, &r->AssociationGroupId));
    2363           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    2364             :         }
    2365           0 :         if (ndr_flags & NDR_BUFFERS) {
    2366           0 :         }
    2367           0 :         return NDR_ERR_SUCCESS;
    2368             : }
    2369             : 
    2370           0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_AssociationGroupId(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_AssociationGroupId *r)
    2371             : {
    2372           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2373           0 :         if (ndr_flags & NDR_SCALARS) {
    2374           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    2375           0 :                 NDR_CHECK(ndr_pull_RTSCookie(ndr, NDR_SCALARS, &r->AssociationGroupId));
    2376           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    2377             :         }
    2378           0 :         if (ndr_flags & NDR_BUFFERS) {
    2379           0 :         }
    2380           0 :         return NDR_ERR_SUCCESS;
    2381             : }
    2382             : 
    2383           0 : static void ndr_print_flags_dcerpc_rts_cmd_AssociationGroupId(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_AssociationGroupId *r)
    2384             : {
    2385           0 :         ndr_print_dcerpc_rts_cmd_AssociationGroupId(ndr, name, r);
    2386           0 : }
    2387             : 
    2388           0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_AssociationGroupId(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_AssociationGroupId *r)
    2389             : {
    2390           0 :         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_AssociationGroupId");
    2391           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2392           0 :         ndr->depth++;
    2393           0 :         ndr_print_RTSCookie(ndr, "AssociationGroupId", &r->AssociationGroupId);
    2394           0 :         ndr->depth--;
    2395             : }
    2396             : 
    2397           0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_Destination(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_Destination *r)
    2398             : {
    2399           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2400           0 :         if (ndr_flags & NDR_SCALARS) {
    2401           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    2402           0 :                 NDR_CHECK(ndr_push_ForwardDestination(ndr, NDR_SCALARS, r->ForwardDestination));
    2403           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    2404             :         }
    2405           0 :         if (ndr_flags & NDR_BUFFERS) {
    2406           0 :         }
    2407           0 :         return NDR_ERR_SUCCESS;
    2408             : }
    2409             : 
    2410           0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_Destination(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_Destination *r)
    2411             : {
    2412           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2413           0 :         if (ndr_flags & NDR_SCALARS) {
    2414           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    2415           0 :                 NDR_CHECK(ndr_pull_ForwardDestination(ndr, NDR_SCALARS, &r->ForwardDestination));
    2416           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    2417             :         }
    2418           0 :         if (ndr_flags & NDR_BUFFERS) {
    2419           0 :         }
    2420           0 :         return NDR_ERR_SUCCESS;
    2421             : }
    2422             : 
    2423           0 : static void ndr_print_flags_dcerpc_rts_cmd_Destination(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_Destination *r)
    2424             : {
    2425           0 :         ndr_print_dcerpc_rts_cmd_Destination(ndr, name, r);
    2426           0 : }
    2427             : 
    2428           0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_Destination(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_Destination *r)
    2429             : {
    2430           0 :         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_Destination");
    2431           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2432           0 :         ndr->depth++;
    2433           0 :         ndr_print_ForwardDestination(ndr, "ForwardDestination", r->ForwardDestination);
    2434           0 :         ndr->depth--;
    2435             : }
    2436             : 
    2437           0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_PingTrafficSentNotify(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_PingTrafficSentNotify *r)
    2438             : {
    2439           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2440           0 :         if (ndr_flags & NDR_SCALARS) {
    2441           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    2442           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->PingTrafficSent));
    2443           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    2444             :         }
    2445           0 :         if (ndr_flags & NDR_BUFFERS) {
    2446           0 :         }
    2447           0 :         return NDR_ERR_SUCCESS;
    2448             : }
    2449             : 
    2450           0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_PingTrafficSentNotify(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_PingTrafficSentNotify *r)
    2451             : {
    2452           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2453           0 :         if (ndr_flags & NDR_SCALARS) {
    2454           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    2455           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->PingTrafficSent));
    2456           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    2457             :         }
    2458           0 :         if (ndr_flags & NDR_BUFFERS) {
    2459           0 :         }
    2460           0 :         return NDR_ERR_SUCCESS;
    2461             : }
    2462             : 
    2463           0 : static void ndr_print_flags_dcerpc_rts_cmd_PingTrafficSentNotify(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_PingTrafficSentNotify *r)
    2464             : {
    2465           0 :         ndr_print_dcerpc_rts_cmd_PingTrafficSentNotify(ndr, name, r);
    2466           0 : }
    2467             : 
    2468           0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_PingTrafficSentNotify(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_PingTrafficSentNotify *r)
    2469             : {
    2470           0 :         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_PingTrafficSentNotify");
    2471           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2472           0 :         ndr->depth++;
    2473           0 :         ndr_print_uint32(ndr, "PingTrafficSent", r->PingTrafficSent);
    2474           0 :         ndr->depth--;
    2475             : }
    2476             : 
    2477           0 : static enum ndr_err_code ndr_push_dcerpc_rts_cmds(struct ndr_push *ndr, ndr_flags_type ndr_flags, const union dcerpc_rts_cmds *r)
    2478             : {
    2479           0 :         uint32_t level;
    2480           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2481           0 :         if (ndr_flags & NDR_SCALARS) {
    2482             :                 /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
    2483           0 :                 NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
    2484           0 :                 NDR_CHECK(ndr_push_union_align(ndr, 4));
    2485           0 :                 switch (level) {
    2486           0 :                         case 0x0: {
    2487           0 :                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_ReceiveWindowSize(ndr, NDR_SCALARS, &r->ReceiveWindowSize));
    2488           0 :                         break; }
    2489             : 
    2490           0 :                         case 0x1: {
    2491           0 :                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_FlowControlAck(ndr, NDR_SCALARS, &r->FlowControlAck));
    2492           0 :                         break; }
    2493             : 
    2494           0 :                         case 0x2: {
    2495           0 :                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_ConnectionTimeout(ndr, NDR_SCALARS, &r->ConnectionTimeout));
    2496           0 :                         break; }
    2497             : 
    2498           0 :                         case 0x3: {
    2499           0 :                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_Cookie(ndr, NDR_SCALARS, &r->Cookie));
    2500           0 :                         break; }
    2501             : 
    2502           0 :                         case 0x4: {
    2503           0 :                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_ChannelLifetime(ndr, NDR_SCALARS, &r->ChannelLifetime));
    2504           0 :                         break; }
    2505             : 
    2506           0 :                         case 0x5: {
    2507           0 :                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_ClientKeepalive(ndr, NDR_SCALARS, &r->ClientKeepalive));
    2508           0 :                         break; }
    2509             : 
    2510           0 :                         case 0x6: {
    2511           0 :                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_Version(ndr, NDR_SCALARS, &r->Version));
    2512           0 :                         break; }
    2513             : 
    2514           0 :                         case 0x7: {
    2515           0 :                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_Empty(ndr, NDR_SCALARS, &r->Empty));
    2516           0 :                         break; }
    2517             : 
    2518           0 :                         case 0x8: {
    2519           0 :                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_Padding(ndr, NDR_SCALARS, &r->Padding));
    2520           0 :                         break; }
    2521             : 
    2522           0 :                         case 0x9: {
    2523           0 :                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_NegativeANCE(ndr, NDR_SCALARS, &r->NegativeANCE));
    2524           0 :                         break; }
    2525             : 
    2526           0 :                         case 0xA: {
    2527           0 :                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_ANCE(ndr, NDR_SCALARS, &r->ANCE));
    2528           0 :                         break; }
    2529             : 
    2530           0 :                         case 0xB: {
    2531           0 :                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_ClientAddress(ndr, NDR_SCALARS, &r->ClientAddress));
    2532           0 :                         break; }
    2533             : 
    2534           0 :                         case 0xC: {
    2535           0 :                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_AssociationGroupId(ndr, NDR_SCALARS, &r->AssociationGroupId));
    2536           0 :                         break; }
    2537             : 
    2538           0 :                         case 0xD: {
    2539           0 :                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_Destination(ndr, NDR_SCALARS, &r->Destination));
    2540           0 :                         break; }
    2541             : 
    2542           0 :                         case 0xE: {
    2543           0 :                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_PingTrafficSentNotify(ndr, NDR_SCALARS, &r->PingTrafficSentNotify));
    2544           0 :                         break; }
    2545             : 
    2546           0 :                         default:
    2547           0 :                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %"PRIu32, level);
    2548             :                 }
    2549             :         }
    2550           0 :         if (ndr_flags & NDR_BUFFERS) {
    2551           0 :                 if (!(ndr_flags & NDR_SCALARS)) {
    2552             :                         /* We didn't get it above, and the token is not needed after this. */
    2553           0 :                         NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
    2554             :                 }
    2555           0 :                 switch (level) {
    2556           0 :                         case 0x0:
    2557           0 :                         break;
    2558             : 
    2559           0 :                         case 0x1:
    2560           0 :                         break;
    2561             : 
    2562           0 :                         case 0x2:
    2563           0 :                         break;
    2564             : 
    2565           0 :                         case 0x3:
    2566           0 :                         break;
    2567             : 
    2568           0 :                         case 0x4:
    2569           0 :                         break;
    2570             : 
    2571           0 :                         case 0x5:
    2572           0 :                         break;
    2573             : 
    2574           0 :                         case 0x6:
    2575           0 :                         break;
    2576             : 
    2577           0 :                         case 0x7:
    2578           0 :                         break;
    2579             : 
    2580           0 :                         case 0x8:
    2581           0 :                         break;
    2582             : 
    2583           0 :                         case 0x9:
    2584           0 :                         break;
    2585             : 
    2586           0 :                         case 0xA:
    2587           0 :                         break;
    2588             : 
    2589           0 :                         case 0xB:
    2590           0 :                         break;
    2591             : 
    2592           0 :                         case 0xC:
    2593           0 :                         break;
    2594             : 
    2595           0 :                         case 0xD:
    2596           0 :                         break;
    2597             : 
    2598           0 :                         case 0xE:
    2599           0 :                         break;
    2600             : 
    2601           0 :                         default:
    2602           0 :                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %"PRIu32, level);
    2603             :                 }
    2604             :         }
    2605           0 :         return NDR_ERR_SUCCESS;
    2606             : }
    2607             : 
    2608           0 : static enum ndr_err_code ndr_pull_dcerpc_rts_cmds(struct ndr_pull *ndr, ndr_flags_type ndr_flags, union dcerpc_rts_cmds *r)
    2609             : {
    2610           0 :         uint32_t level;
    2611           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2612           0 :         if (ndr_flags & NDR_SCALARS) {
    2613             :                 /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
    2614           0 :                 NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
    2615           0 :                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
    2616           0 :                 switch (level) {
    2617           0 :                         case 0x0: {
    2618           0 :                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_ReceiveWindowSize(ndr, NDR_SCALARS, &r->ReceiveWindowSize));
    2619           0 :                         break; }
    2620             : 
    2621           0 :                         case 0x1: {
    2622           0 :                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_FlowControlAck(ndr, NDR_SCALARS, &r->FlowControlAck));
    2623           0 :                         break; }
    2624             : 
    2625           0 :                         case 0x2: {
    2626           0 :                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_ConnectionTimeout(ndr, NDR_SCALARS, &r->ConnectionTimeout));
    2627           0 :                         break; }
    2628             : 
    2629           0 :                         case 0x3: {
    2630           0 :                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_Cookie(ndr, NDR_SCALARS, &r->Cookie));
    2631           0 :                         break; }
    2632             : 
    2633           0 :                         case 0x4: {
    2634           0 :                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_ChannelLifetime(ndr, NDR_SCALARS, &r->ChannelLifetime));
    2635           0 :                         break; }
    2636             : 
    2637           0 :                         case 0x5: {
    2638           0 :                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_ClientKeepalive(ndr, NDR_SCALARS, &r->ClientKeepalive));
    2639           0 :                         break; }
    2640             : 
    2641           0 :                         case 0x6: {
    2642           0 :                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_Version(ndr, NDR_SCALARS, &r->Version));
    2643           0 :                         break; }
    2644             : 
    2645           0 :                         case 0x7: {
    2646           0 :                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_Empty(ndr, NDR_SCALARS, &r->Empty));
    2647           0 :                         break; }
    2648             : 
    2649           0 :                         case 0x8: {
    2650           0 :                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_Padding(ndr, NDR_SCALARS, &r->Padding));
    2651           0 :                         break; }
    2652             : 
    2653           0 :                         case 0x9: {
    2654           0 :                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_NegativeANCE(ndr, NDR_SCALARS, &r->NegativeANCE));
    2655           0 :                         break; }
    2656             : 
    2657           0 :                         case 0xA: {
    2658           0 :                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_ANCE(ndr, NDR_SCALARS, &r->ANCE));
    2659           0 :                         break; }
    2660             : 
    2661           0 :                         case 0xB: {
    2662           0 :                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_ClientAddress(ndr, NDR_SCALARS, &r->ClientAddress));
    2663           0 :                         break; }
    2664             : 
    2665           0 :                         case 0xC: {
    2666           0 :                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_AssociationGroupId(ndr, NDR_SCALARS, &r->AssociationGroupId));
    2667           0 :                         break; }
    2668             : 
    2669           0 :                         case 0xD: {
    2670           0 :                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_Destination(ndr, NDR_SCALARS, &r->Destination));
    2671           0 :                         break; }
    2672             : 
    2673           0 :                         case 0xE: {
    2674           0 :                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_PingTrafficSentNotify(ndr, NDR_SCALARS, &r->PingTrafficSentNotify));
    2675           0 :                         break; }
    2676             : 
    2677           0 :                         default:
    2678           0 :                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %"PRIu32" at %s", level, __location__);
    2679             :                 }
    2680             :         }
    2681           0 :         if (ndr_flags & NDR_BUFFERS) {
    2682           0 :                 if (!(ndr_flags & NDR_SCALARS)) {
    2683             :                         /* We didn't get it above, and the token is not needed after this. */
    2684           0 :                         NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
    2685             :                 }
    2686           0 :                 switch (level) {
    2687           0 :                         case 0x0:
    2688           0 :                         break;
    2689             : 
    2690           0 :                         case 0x1:
    2691           0 :                         break;
    2692             : 
    2693           0 :                         case 0x2:
    2694           0 :                         break;
    2695             : 
    2696           0 :                         case 0x3:
    2697           0 :                         break;
    2698             : 
    2699           0 :                         case 0x4:
    2700           0 :                         break;
    2701             : 
    2702           0 :                         case 0x5:
    2703           0 :                         break;
    2704             : 
    2705           0 :                         case 0x6:
    2706           0 :                         break;
    2707             : 
    2708           0 :                         case 0x7:
    2709           0 :                         break;
    2710             : 
    2711           0 :                         case 0x8:
    2712           0 :                         break;
    2713             : 
    2714           0 :                         case 0x9:
    2715           0 :                         break;
    2716             : 
    2717           0 :                         case 0xA:
    2718           0 :                         break;
    2719             : 
    2720           0 :                         case 0xB:
    2721           0 :                         break;
    2722             : 
    2723           0 :                         case 0xC:
    2724           0 :                         break;
    2725             : 
    2726           0 :                         case 0xD:
    2727           0 :                         break;
    2728             : 
    2729           0 :                         case 0xE:
    2730           0 :                         break;
    2731             : 
    2732           0 :                         default:
    2733           0 :                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %"PRIu32" at %s", level, __location__);
    2734             :                 }
    2735             :         }
    2736           0 :         return NDR_ERR_SUCCESS;
    2737             : }
    2738             : 
    2739           0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmds(struct ndr_print *ndr, const char *name, const union dcerpc_rts_cmds *r)
    2740             : {
    2741           0 :         uint32_t level;
    2742           0 :         level = ndr_print_steal_switch_value(ndr, r);
    2743           0 :         ndr_print_union(ndr, name, level, "dcerpc_rts_cmds");
    2744           0 :         switch (level) {
    2745           0 :                 case 0x0:
    2746           0 :                         ndr_print_dcerpc_rts_cmd_ReceiveWindowSize(ndr, "ReceiveWindowSize", &r->ReceiveWindowSize);
    2747           0 :                 break;
    2748             : 
    2749           0 :                 case 0x1:
    2750           0 :                         ndr_print_dcerpc_rts_cmd_FlowControlAck(ndr, "FlowControlAck", &r->FlowControlAck);
    2751           0 :                 break;
    2752             : 
    2753           0 :                 case 0x2:
    2754           0 :                         ndr_print_dcerpc_rts_cmd_ConnectionTimeout(ndr, "ConnectionTimeout", &r->ConnectionTimeout);
    2755           0 :                 break;
    2756             : 
    2757           0 :                 case 0x3:
    2758           0 :                         ndr_print_dcerpc_rts_cmd_Cookie(ndr, "Cookie", &r->Cookie);
    2759           0 :                 break;
    2760             : 
    2761           0 :                 case 0x4:
    2762           0 :                         ndr_print_dcerpc_rts_cmd_ChannelLifetime(ndr, "ChannelLifetime", &r->ChannelLifetime);
    2763           0 :                 break;
    2764             : 
    2765           0 :                 case 0x5:
    2766           0 :                         ndr_print_dcerpc_rts_cmd_ClientKeepalive(ndr, "ClientKeepalive", &r->ClientKeepalive);
    2767           0 :                 break;
    2768             : 
    2769           0 :                 case 0x6:
    2770           0 :                         ndr_print_dcerpc_rts_cmd_Version(ndr, "Version", &r->Version);
    2771           0 :                 break;
    2772             : 
    2773           0 :                 case 0x7:
    2774           0 :                         ndr_print_dcerpc_rts_cmd_Empty(ndr, "Empty", &r->Empty);
    2775           0 :                 break;
    2776             : 
    2777           0 :                 case 0x8:
    2778           0 :                         ndr_print_dcerpc_rts_cmd_Padding(ndr, "Padding", &r->Padding);
    2779           0 :                 break;
    2780             : 
    2781           0 :                 case 0x9:
    2782           0 :                         ndr_print_dcerpc_rts_cmd_NegativeANCE(ndr, "NegativeANCE", &r->NegativeANCE);
    2783           0 :                 break;
    2784             : 
    2785           0 :                 case 0xA:
    2786           0 :                         ndr_print_dcerpc_rts_cmd_ANCE(ndr, "ANCE", &r->ANCE);
    2787           0 :                 break;
    2788             : 
    2789           0 :                 case 0xB:
    2790           0 :                         ndr_print_dcerpc_rts_cmd_ClientAddress(ndr, "ClientAddress", &r->ClientAddress);
    2791           0 :                 break;
    2792             : 
    2793           0 :                 case 0xC:
    2794           0 :                         ndr_print_dcerpc_rts_cmd_AssociationGroupId(ndr, "AssociationGroupId", &r->AssociationGroupId);
    2795           0 :                 break;
    2796             : 
    2797           0 :                 case 0xD:
    2798           0 :                         ndr_print_dcerpc_rts_cmd_Destination(ndr, "Destination", &r->Destination);
    2799           0 :                 break;
    2800             : 
    2801           0 :                 case 0xE:
    2802           0 :                         ndr_print_dcerpc_rts_cmd_PingTrafficSentNotify(ndr, "PingTrafficSentNotify", &r->PingTrafficSentNotify);
    2803           0 :                 break;
    2804             : 
    2805           0 :                 default:
    2806           0 :                         ndr_print_bad_level(ndr, name, level);
    2807             :         }
    2808           0 : }
    2809             : 
    2810           0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd *r)
    2811             : {
    2812           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2813           0 :         if (ndr_flags & NDR_SCALARS) {
    2814           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    2815           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->CommandType));
    2816           0 :                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->Command, r->CommandType));
    2817           0 :                 NDR_CHECK(ndr_push_dcerpc_rts_cmds(ndr, NDR_SCALARS, &r->Command));
    2818           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    2819             :         }
    2820           0 :         if (ndr_flags & NDR_BUFFERS) {
    2821           0 :         }
    2822           0 :         return NDR_ERR_SUCCESS;
    2823             : }
    2824             : 
    2825           0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd *r)
    2826             : {
    2827           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2828           0 :         if (ndr_flags & NDR_SCALARS) {
    2829           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    2830           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->CommandType));
    2831           0 :                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->Command, r->CommandType));
    2832           0 :                 NDR_CHECK(ndr_pull_dcerpc_rts_cmds(ndr, NDR_SCALARS, &r->Command));
    2833           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    2834             :         }
    2835           0 :         if (ndr_flags & NDR_BUFFERS) {
    2836           0 :         }
    2837           0 :         return NDR_ERR_SUCCESS;
    2838             : }
    2839             : 
    2840           0 : static void ndr_print_flags_dcerpc_rts_cmd(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd *r)
    2841             : {
    2842           0 :         ndr_print_dcerpc_rts_cmd(ndr, name, r);
    2843           0 : }
    2844             : 
    2845           0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd *r)
    2846             : {
    2847           0 :         ndr_print_struct(ndr, name, "dcerpc_rts_cmd");
    2848           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2849           0 :         ndr->depth++;
    2850           0 :         ndr_print_uint32(ndr, "CommandType", r->CommandType);
    2851           0 :         ndr_print_set_switch_value(ndr, &r->Command, r->CommandType);
    2852           0 :         ndr_print_dcerpc_rts_cmds(ndr, "Command", &r->Command);
    2853           0 :         ndr->depth--;
    2854             : }
    2855             : 
    2856           0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_flags(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint16_t r)
    2857             : {
    2858           0 :         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
    2859           0 :         return NDR_ERR_SUCCESS;
    2860             : }
    2861             : 
    2862           0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_flags(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint16_t *r)
    2863             : {
    2864           0 :         uint16_t v;
    2865           0 :         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
    2866           0 :         *r = v;
    2867           0 :         return NDR_ERR_SUCCESS;
    2868             : }
    2869             : 
    2870           0 : _PUBLIC_ void ndr_print_dcerpc_rts_flags(struct ndr_print *ndr, const char *name, uint16_t r)
    2871             : {
    2872           0 :         ndr_print_uint16(ndr, name, r);
    2873           0 :         ndr->depth++;
    2874           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_NONE", RTS_FLAG_NONE, r);
    2875           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_PING", RTS_FLAG_PING, r);
    2876           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_OTHER_CMD", RTS_FLAG_OTHER_CMD, r);
    2877           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_RECYCLE_CHANNEL", RTS_FLAG_RECYCLE_CHANNEL, r);
    2878           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_IN_CHANNEL", RTS_FLAG_IN_CHANNEL, r);
    2879           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_OUT_CHANNEL", RTS_FLAG_OUT_CHANNEL, r);
    2880           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_EOF", RTS_FLAG_EOF, r);
    2881           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_ECHO", RTS_FLAG_ECHO, r);
    2882           0 :         ndr->depth--;
    2883           0 : }
    2884             : 
    2885           0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts *r)
    2886             : {
    2887           0 :         uint32_t cntr_Commands_0;
    2888           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2889           0 :         if (ndr_flags & NDR_SCALARS) {
    2890           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    2891           0 :                 NDR_CHECK(ndr_push_dcerpc_rts_flags(ndr, NDR_SCALARS, r->Flags));
    2892           0 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->NumberOfCommands));
    2893           0 :                 for (cntr_Commands_0 = 0; cntr_Commands_0 < (r->NumberOfCommands); cntr_Commands_0++) {
    2894           0 :                         NDR_CHECK(ndr_push_dcerpc_rts_cmd(ndr, NDR_SCALARS, &r->Commands[cntr_Commands_0]));
    2895             :                 }
    2896           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    2897             :         }
    2898           0 :         if (ndr_flags & NDR_BUFFERS) {
    2899           0 :         }
    2900           0 :         return NDR_ERR_SUCCESS;
    2901             : }
    2902             : 
    2903           0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts *r)
    2904             : {
    2905           0 :         uint32_t size_Commands_0 = 0;
    2906           0 :         uint32_t cntr_Commands_0;
    2907           0 :         TALLOC_CTX *_mem_save_Commands_0 = NULL;
    2908           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2909           0 :         if (ndr_flags & NDR_SCALARS) {
    2910           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    2911           0 :                 NDR_CHECK(ndr_pull_dcerpc_rts_flags(ndr, NDR_SCALARS, &r->Flags));
    2912           0 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->NumberOfCommands));
    2913           0 :                 size_Commands_0 = r->NumberOfCommands;
    2914           0 :                 NDR_PULL_ALLOC_N(ndr, r->Commands, size_Commands_0);
    2915           0 :                 _mem_save_Commands_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2916           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->Commands, 0);
    2917           0 :                 for (cntr_Commands_0 = 0; cntr_Commands_0 < (size_Commands_0); cntr_Commands_0++) {
    2918           0 :                         NDR_CHECK(ndr_pull_dcerpc_rts_cmd(ndr, NDR_SCALARS, &r->Commands[cntr_Commands_0]));
    2919             :                 }
    2920           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Commands_0, 0);
    2921           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    2922             :         }
    2923           0 :         if (ndr_flags & NDR_BUFFERS) {
    2924           0 :         }
    2925           0 :         return NDR_ERR_SUCCESS;
    2926             : }
    2927             : 
    2928           0 : static void ndr_print_flags_dcerpc_rts(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts *r)
    2929             : {
    2930           0 :         ndr_print_dcerpc_rts(ndr, name, r);
    2931           0 : }
    2932             : 
    2933           0 : _PUBLIC_ void ndr_print_dcerpc_rts(struct ndr_print *ndr, const char *name, const struct dcerpc_rts *r)
    2934             : {
    2935           0 :         uint32_t cntr_Commands_0;
    2936           0 :         ndr_print_struct(ndr, name, "dcerpc_rts");
    2937           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2938           0 :         ndr->depth++;
    2939           0 :         ndr_print_dcerpc_rts_flags(ndr, "Flags", r->Flags);
    2940           0 :         ndr_print_uint16(ndr, "NumberOfCommands", r->NumberOfCommands);
    2941           0 :         ndr->print(ndr, "%s: ARRAY(%"PRIu32")", "Commands", (uint32_t)(r->NumberOfCommands));
    2942           0 :         ndr->depth++;
    2943           0 :         for (cntr_Commands_0 = 0; cntr_Commands_0 < (r->NumberOfCommands); cntr_Commands_0++) {
    2944           0 :                 ndr_print_dcerpc_rts_cmd(ndr, "Commands", &r->Commands[cntr_Commands_0]);
    2945             :         }
    2946           0 :         ndr->depth--;
    2947           0 :         ndr->depth--;
    2948             : }
    2949             : 
    2950     2149283 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_pkt_type(struct ndr_push *ndr, ndr_flags_type ndr_flags, enum dcerpc_pkt_type r)
    2951             : {
    2952     2149283 :         NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
    2953     2132835 :         return NDR_ERR_SUCCESS;
    2954             : }
    2955             : 
    2956     2795569 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_pkt_type(struct ndr_pull *ndr, ndr_flags_type ndr_flags, enum dcerpc_pkt_type *r)
    2957             : {
    2958       24645 :         uint8_t v;
    2959     2795569 :         NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
    2960     2795569 :         *r = v;
    2961     2795569 :         return NDR_ERR_SUCCESS;
    2962             : }
    2963             : 
    2964         248 : _PUBLIC_ void ndr_print_dcerpc_pkt_type(struct ndr_print *ndr, const char *name, enum dcerpc_pkt_type r)
    2965             : {
    2966         248 :         const char *val = NULL;
    2967             : 
    2968         248 :         switch (r) {
    2969         118 :                 case DCERPC_PKT_REQUEST: val = "DCERPC_PKT_REQUEST"; break;
    2970           0 :                 case DCERPC_PKT_PING: val = "DCERPC_PKT_PING"; break;
    2971         118 :                 case DCERPC_PKT_RESPONSE: val = "DCERPC_PKT_RESPONSE"; break;
    2972           0 :                 case DCERPC_PKT_FAULT: val = "DCERPC_PKT_FAULT"; break;
    2973           0 :                 case DCERPC_PKT_WORKING: val = "DCERPC_PKT_WORKING"; break;
    2974           0 :                 case DCERPC_PKT_NOCALL: val = "DCERPC_PKT_NOCALL"; break;
    2975           0 :                 case DCERPC_PKT_REJECT: val = "DCERPC_PKT_REJECT"; break;
    2976           0 :                 case DCERPC_PKT_ACK: val = "DCERPC_PKT_ACK"; break;
    2977           0 :                 case DCERPC_PKT_CL_CANCEL: val = "DCERPC_PKT_CL_CANCEL"; break;
    2978           0 :                 case DCERPC_PKT_FACK: val = "DCERPC_PKT_FACK"; break;
    2979           0 :                 case DCERPC_PKT_CANCEL_ACK: val = "DCERPC_PKT_CANCEL_ACK"; break;
    2980           4 :                 case DCERPC_PKT_BIND: val = "DCERPC_PKT_BIND"; break;
    2981           4 :                 case DCERPC_PKT_BIND_ACK: val = "DCERPC_PKT_BIND_ACK"; break;
    2982           0 :                 case DCERPC_PKT_BIND_NAK: val = "DCERPC_PKT_BIND_NAK"; break;
    2983           0 :                 case DCERPC_PKT_ALTER: val = "DCERPC_PKT_ALTER"; break;
    2984           0 :                 case DCERPC_PKT_ALTER_RESP: val = "DCERPC_PKT_ALTER_RESP"; break;
    2985           0 :                 case DCERPC_PKT_AUTH3: val = "DCERPC_PKT_AUTH3"; break;
    2986           0 :                 case DCERPC_PKT_SHUTDOWN: val = "DCERPC_PKT_SHUTDOWN"; break;
    2987           2 :                 case DCERPC_PKT_CO_CANCEL: val = "DCERPC_PKT_CO_CANCEL"; break;
    2988           2 :                 case DCERPC_PKT_ORPHANED: val = "DCERPC_PKT_ORPHANED"; break;
    2989           0 :                 case DCERPC_PKT_RTS: val = "DCERPC_PKT_RTS"; break;
    2990             :         }
    2991         248 :         ndr_print_enum(ndr, name, "ENUM", val, r);
    2992         248 : }
    2993             : 
    2994     2141117 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_payload(struct ndr_push *ndr, ndr_flags_type ndr_flags, const union dcerpc_payload *r)
    2995             : {
    2996       16448 :         uint32_t level;
    2997     2141117 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2998     2141117 :         if (ndr_flags & NDR_SCALARS) {
    2999             :                 /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
    3000     2141117 :                 NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
    3001     2141117 :                 NDR_CHECK(ndr_push_union_align(ndr, 4));
    3002     2141117 :                 switch (level) {
    3003      873753 :                         case DCERPC_PKT_REQUEST: {
    3004      873753 :                                 NDR_CHECK(ndr_push_dcerpc_request(ndr, NDR_SCALARS, &r->request));
    3005      866536 :                         break; }
    3006             : 
    3007           0 :                         case DCERPC_PKT_PING: {
    3008           0 :                                 NDR_CHECK(ndr_push_dcerpc_ping(ndr, NDR_SCALARS, &r->ping));
    3009           0 :                         break; }
    3010             : 
    3011     1126099 :                         case DCERPC_PKT_RESPONSE: {
    3012     1126099 :                                 NDR_CHECK(ndr_push_dcerpc_response(ndr, NDR_SCALARS, &r->response));
    3013     1119197 :                         break; }
    3014             : 
    3015        2885 :                         case DCERPC_PKT_FAULT: {
    3016        2885 :                                 NDR_CHECK(ndr_push_dcerpc_fault(ndr, NDR_SCALARS, &r->fault));
    3017        2539 :                         break; }
    3018             : 
    3019           0 :                         case DCERPC_PKT_WORKING: {
    3020           0 :                                 NDR_CHECK(ndr_push_dcerpc_working(ndr, NDR_SCALARS, &r->working));
    3021           0 :                         break; }
    3022             : 
    3023           0 :                         case DCERPC_PKT_NOCALL: {
    3024           0 :                                 NDR_CHECK(ndr_push_dcerpc_fack(ndr, NDR_SCALARS, &r->nocall));
    3025           0 :                         break; }
    3026             : 
    3027           0 :                         case DCERPC_PKT_REJECT: {
    3028           0 :                                 NDR_CHECK(ndr_push_dcerpc_fault(ndr, NDR_SCALARS, &r->reject));
    3029           0 :                         break; }
    3030             : 
    3031           0 :                         case DCERPC_PKT_ACK: {
    3032           0 :                                 NDR_CHECK(ndr_push_dcerpc_ack(ndr, NDR_SCALARS, &r->ack));
    3033           0 :                         break; }
    3034             : 
    3035           0 :                         case DCERPC_PKT_CL_CANCEL: {
    3036           0 :                                 NDR_CHECK(ndr_push_dcerpc_cl_cancel(ndr, NDR_SCALARS, &r->cl_cancel));
    3037           0 :                         break; }
    3038             : 
    3039           0 :                         case DCERPC_PKT_FACK: {
    3040           0 :                                 NDR_CHECK(ndr_push_dcerpc_fack(ndr, NDR_SCALARS, &r->fack));
    3041           0 :                         break; }
    3042             : 
    3043           0 :                         case DCERPC_PKT_CANCEL_ACK: {
    3044           0 :                                 NDR_CHECK(ndr_push_dcerpc_cancel_ack(ndr, NDR_SCALARS, &r->cancel_ack));
    3045           0 :                         break; }
    3046             : 
    3047       65760 :                         case DCERPC_PKT_BIND: {
    3048       65760 :                                 NDR_CHECK(ndr_push_dcerpc_bind(ndr, NDR_SCALARS, &r->bind));
    3049       64890 :                         break; }
    3050             : 
    3051       58446 :                         case DCERPC_PKT_BIND_ACK: {
    3052       58446 :                                 NDR_CHECK(ndr_push_dcerpc_bind_ack(ndr, NDR_SCALARS, &r->bind_ack));
    3053       57586 :                         break; }
    3054             : 
    3055         149 :                         case DCERPC_PKT_BIND_NAK: {
    3056         149 :                                 NDR_CHECK(ndr_push_dcerpc_bind_nak(ndr, NDR_SCALARS, &r->bind_nak));
    3057         131 :                         break; }
    3058             : 
    3059        7411 :                         case DCERPC_PKT_ALTER: {
    3060        7411 :                                 NDR_CHECK(ndr_push_dcerpc_bind(ndr, NDR_SCALARS, &r->alter));
    3061        7294 :                         break; }
    3062             : 
    3063        6279 :                         case DCERPC_PKT_ALTER_RESP: {
    3064        6279 :                                 NDR_CHECK(ndr_push_dcerpc_bind_ack(ndr, NDR_SCALARS, &r->alter_resp));
    3065        6165 :                         break; }
    3066             : 
    3067           0 :                         case DCERPC_PKT_SHUTDOWN: {
    3068           0 :                                 NDR_CHECK(ndr_push_dcerpc_shutdown(ndr, NDR_SCALARS, &r->shutdown));
    3069           0 :                         break; }
    3070             : 
    3071          14 :                         case DCERPC_PKT_CO_CANCEL: {
    3072          14 :                                 NDR_CHECK(ndr_push_dcerpc_co_cancel(ndr, NDR_SCALARS, &r->co_cancel));
    3073          12 :                         break; }
    3074             : 
    3075          32 :                         case DCERPC_PKT_ORPHANED: {
    3076          32 :                                 NDR_CHECK(ndr_push_dcerpc_orphaned(ndr, NDR_SCALARS, &r->orphaned));
    3077          30 :                         break; }
    3078             : 
    3079         289 :                         case DCERPC_PKT_AUTH3: {
    3080         289 :                                 NDR_CHECK(ndr_push_dcerpc_auth3(ndr, NDR_SCALARS, &r->auth3));
    3081         289 :                         break; }
    3082             : 
    3083           0 :                         case DCERPC_PKT_RTS: {
    3084           0 :                                 NDR_CHECK(ndr_push_dcerpc_rts(ndr, NDR_SCALARS, &r->rts));
    3085           0 :                         break; }
    3086             : 
    3087           0 :                         default:
    3088           0 :                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %"PRIu32, level);
    3089             :                 }
    3090             :         }
    3091     2141117 :         if (ndr_flags & NDR_BUFFERS) {
    3092           0 :                 if (!(ndr_flags & NDR_SCALARS)) {
    3093             :                         /* We didn't get it above, and the token is not needed after this. */
    3094           0 :                         NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
    3095             :                 }
    3096           0 :                 switch (level) {
    3097           0 :                         case DCERPC_PKT_REQUEST:
    3098           0 :                         break;
    3099             : 
    3100           0 :                         case DCERPC_PKT_PING:
    3101           0 :                         break;
    3102             : 
    3103           0 :                         case DCERPC_PKT_RESPONSE:
    3104           0 :                         break;
    3105             : 
    3106           0 :                         case DCERPC_PKT_FAULT:
    3107           0 :                         break;
    3108             : 
    3109           0 :                         case DCERPC_PKT_WORKING:
    3110           0 :                         break;
    3111             : 
    3112           0 :                         case DCERPC_PKT_NOCALL:
    3113           0 :                         break;
    3114             : 
    3115           0 :                         case DCERPC_PKT_REJECT:
    3116           0 :                         break;
    3117             : 
    3118           0 :                         case DCERPC_PKT_ACK:
    3119           0 :                         break;
    3120             : 
    3121           0 :                         case DCERPC_PKT_CL_CANCEL:
    3122           0 :                         break;
    3123             : 
    3124           0 :                         case DCERPC_PKT_FACK:
    3125           0 :                         break;
    3126             : 
    3127           0 :                         case DCERPC_PKT_CANCEL_ACK:
    3128           0 :                         break;
    3129             : 
    3130           0 :                         case DCERPC_PKT_BIND:
    3131           0 :                         break;
    3132             : 
    3133           0 :                         case DCERPC_PKT_BIND_ACK:
    3134           0 :                         break;
    3135             : 
    3136           0 :                         case DCERPC_PKT_BIND_NAK:
    3137           0 :                         break;
    3138             : 
    3139           0 :                         case DCERPC_PKT_ALTER:
    3140           0 :                         break;
    3141             : 
    3142           0 :                         case DCERPC_PKT_ALTER_RESP:
    3143           0 :                         break;
    3144             : 
    3145           0 :                         case DCERPC_PKT_SHUTDOWN:
    3146           0 :                         break;
    3147             : 
    3148           0 :                         case DCERPC_PKT_CO_CANCEL:
    3149           0 :                         break;
    3150             : 
    3151           0 :                         case DCERPC_PKT_ORPHANED:
    3152           0 :                         break;
    3153             : 
    3154           0 :                         case DCERPC_PKT_AUTH3:
    3155           0 :                         break;
    3156             : 
    3157           0 :                         case DCERPC_PKT_RTS:
    3158           0 :                         break;
    3159             : 
    3160           0 :                         default:
    3161           0 :                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %"PRIu32, level);
    3162             :                 }
    3163             :         }
    3164     2124669 :         return NDR_ERR_SUCCESS;
    3165             : }
    3166             : 
    3167     2787301 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_payload(struct ndr_pull *ndr, ndr_flags_type ndr_flags, union dcerpc_payload *r)
    3168             : {
    3169       24645 :         uint32_t level;
    3170     2787301 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    3171     2787301 :         if (ndr_flags & NDR_SCALARS) {
    3172             :                 /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
    3173     2787301 :                 NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
    3174     2787301 :                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
    3175     2787301 :                 switch (level) {
    3176      855350 :                         case DCERPC_PKT_REQUEST: {
    3177      855350 :                                 NDR_CHECK(ndr_pull_dcerpc_request(ndr, NDR_SCALARS, &r->request));
    3178      848104 :                         break; }
    3179             : 
    3180           0 :                         case DCERPC_PKT_PING: {
    3181           0 :                                 NDR_CHECK(ndr_pull_dcerpc_ping(ndr, NDR_SCALARS, &r->ping));
    3182           0 :                         break; }
    3183             : 
    3184     1723833 :                         case DCERPC_PKT_RESPONSE: {
    3185     1723833 :                                 NDR_CHECK(ndr_pull_dcerpc_response(ndr, NDR_SCALARS, &r->response));
    3186     1710087 :                         break; }
    3187             : 
    3188        5733 :                         case DCERPC_PKT_FAULT: {
    3189        5733 :                                 NDR_CHECK(ndr_pull_dcerpc_fault(ndr, NDR_SCALARS, &r->fault));
    3190        5047 :                         break; }
    3191             : 
    3192           0 :                         case DCERPC_PKT_WORKING: {
    3193           0 :                                 NDR_CHECK(ndr_pull_dcerpc_working(ndr, NDR_SCALARS, &r->working));
    3194           0 :                         break; }
    3195             : 
    3196           0 :                         case DCERPC_PKT_NOCALL: {
    3197           0 :                                 NDR_CHECK(ndr_pull_dcerpc_fack(ndr, NDR_SCALARS, &r->nocall));
    3198           0 :                         break; }
    3199             : 
    3200           0 :                         case DCERPC_PKT_REJECT: {
    3201           0 :                                 NDR_CHECK(ndr_pull_dcerpc_fault(ndr, NDR_SCALARS, &r->reject));
    3202           0 :                         break; }
    3203             : 
    3204           0 :                         case DCERPC_PKT_ACK: {
    3205           0 :                                 NDR_CHECK(ndr_pull_dcerpc_ack(ndr, NDR_SCALARS, &r->ack));
    3206           0 :                         break; }
    3207             : 
    3208           0 :                         case DCERPC_PKT_CL_CANCEL: {
    3209           0 :                                 NDR_CHECK(ndr_pull_dcerpc_cl_cancel(ndr, NDR_SCALARS, &r->cl_cancel));
    3210           0 :                         break; }
    3211             : 
    3212           0 :                         case DCERPC_PKT_FACK: {
    3213           0 :                                 NDR_CHECK(ndr_pull_dcerpc_fack(ndr, NDR_SCALARS, &r->fack));
    3214           0 :                         break; }
    3215             : 
    3216           0 :                         case DCERPC_PKT_CANCEL_ACK: {
    3217           0 :                                 NDR_CHECK(ndr_pull_dcerpc_cancel_ack(ndr, NDR_SCALARS, &r->cancel_ack));
    3218           0 :                         break; }
    3219             : 
    3220       98269 :                         case DCERPC_PKT_BIND: {
    3221       98269 :                                 NDR_CHECK(ndr_pull_dcerpc_bind(ndr, NDR_SCALARS, &r->bind));
    3222       97391 :                         break; }
    3223             : 
    3224       84834 :                         case DCERPC_PKT_BIND_ACK: {
    3225       84834 :                                 NDR_CHECK(ndr_pull_dcerpc_bind_ack(ndr, NDR_SCALARS, &r->bind_ack));
    3226       83130 :                         break; }
    3227             : 
    3228         230 :                         case DCERPC_PKT_BIND_NAK: {
    3229         230 :                                 NDR_CHECK(ndr_pull_dcerpc_bind_nak(ndr, NDR_SCALARS, &r->bind_nak));
    3230         194 :                         break; }
    3231             : 
    3232        6333 :                         case DCERPC_PKT_ALTER: {
    3233        6333 :                                 NDR_CHECK(ndr_pull_dcerpc_bind(ndr, NDR_SCALARS, &r->alter));
    3234        6216 :                         break; }
    3235             : 
    3236       12464 :                         case DCERPC_PKT_ALTER_RESP: {
    3237       12464 :                                 NDR_CHECK(ndr_pull_dcerpc_bind_ack(ndr, NDR_SCALARS, &r->alter_resp));
    3238       12236 :                         break; }
    3239             : 
    3240           0 :                         case DCERPC_PKT_SHUTDOWN: {
    3241           0 :                                 NDR_CHECK(ndr_pull_dcerpc_shutdown(ndr, NDR_SCALARS, &r->shutdown));
    3242           0 :                         break; }
    3243             : 
    3244           8 :                         case DCERPC_PKT_CO_CANCEL: {
    3245           8 :                                 NDR_CHECK(ndr_pull_dcerpc_co_cancel(ndr, NDR_SCALARS, &r->co_cancel));
    3246           6 :                         break; }
    3247             : 
    3248          17 :                         case DCERPC_PKT_ORPHANED: {
    3249          17 :                                 NDR_CHECK(ndr_pull_dcerpc_orphaned(ndr, NDR_SCALARS, &r->orphaned));
    3250          15 :                         break; }
    3251             : 
    3252         230 :                         case DCERPC_PKT_AUTH3: {
    3253         230 :                                 NDR_CHECK(ndr_pull_dcerpc_auth3(ndr, NDR_SCALARS, &r->auth3));
    3254         230 :                         break; }
    3255             : 
    3256           0 :                         case DCERPC_PKT_RTS: {
    3257           0 :                                 NDR_CHECK(ndr_pull_dcerpc_rts(ndr, NDR_SCALARS, &r->rts));
    3258           0 :                         break; }
    3259             : 
    3260           0 :                         default:
    3261           0 :                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %"PRIu32" at %s", level, __location__);
    3262             :                 }
    3263             :         }
    3264     2787301 :         if (ndr_flags & NDR_BUFFERS) {
    3265           0 :                 if (!(ndr_flags & NDR_SCALARS)) {
    3266             :                         /* We didn't get it above, and the token is not needed after this. */
    3267           0 :                         NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
    3268             :                 }
    3269           0 :                 switch (level) {
    3270           0 :                         case DCERPC_PKT_REQUEST:
    3271           0 :                         break;
    3272             : 
    3273           0 :                         case DCERPC_PKT_PING:
    3274           0 :                         break;
    3275             : 
    3276           0 :                         case DCERPC_PKT_RESPONSE:
    3277           0 :                         break;
    3278             : 
    3279           0 :                         case DCERPC_PKT_FAULT:
    3280           0 :                         break;
    3281             : 
    3282           0 :                         case DCERPC_PKT_WORKING:
    3283           0 :                         break;
    3284             : 
    3285           0 :                         case DCERPC_PKT_NOCALL:
    3286           0 :                         break;
    3287             : 
    3288           0 :                         case DCERPC_PKT_REJECT:
    3289           0 :                         break;
    3290             : 
    3291           0 :                         case DCERPC_PKT_ACK:
    3292           0 :                         break;
    3293             : 
    3294           0 :                         case DCERPC_PKT_CL_CANCEL:
    3295           0 :                         break;
    3296             : 
    3297           0 :                         case DCERPC_PKT_FACK:
    3298           0 :                         break;
    3299             : 
    3300           0 :                         case DCERPC_PKT_CANCEL_ACK:
    3301           0 :                         break;
    3302             : 
    3303           0 :                         case DCERPC_PKT_BIND:
    3304           0 :                         break;
    3305             : 
    3306           0 :                         case DCERPC_PKT_BIND_ACK:
    3307           0 :                         break;
    3308             : 
    3309           0 :                         case DCERPC_PKT_BIND_NAK:
    3310           0 :                         break;
    3311             : 
    3312           0 :                         case DCERPC_PKT_ALTER:
    3313           0 :                         break;
    3314             : 
    3315           0 :                         case DCERPC_PKT_ALTER_RESP:
    3316           0 :                         break;
    3317             : 
    3318           0 :                         case DCERPC_PKT_SHUTDOWN:
    3319           0 :                         break;
    3320             : 
    3321           0 :                         case DCERPC_PKT_CO_CANCEL:
    3322           0 :                         break;
    3323             : 
    3324           0 :                         case DCERPC_PKT_ORPHANED:
    3325           0 :                         break;
    3326             : 
    3327           0 :                         case DCERPC_PKT_AUTH3:
    3328           0 :                         break;
    3329             : 
    3330           0 :                         case DCERPC_PKT_RTS:
    3331           0 :                         break;
    3332             : 
    3333           0 :                         default:
    3334           0 :                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %"PRIu32" at %s", level, __location__);
    3335             :                 }
    3336             :         }
    3337     2762656 :         return NDR_ERR_SUCCESS;
    3338             : }
    3339             : 
    3340         248 : _PUBLIC_ void ndr_print_dcerpc_payload(struct ndr_print *ndr, const char *name, const union dcerpc_payload *r)
    3341             : {
    3342           4 :         uint32_t level;
    3343         248 :         level = ndr_print_steal_switch_value(ndr, r);
    3344         248 :         ndr_print_union(ndr, name, level, "dcerpc_payload");
    3345         248 :         switch (level) {
    3346         118 :                 case DCERPC_PKT_REQUEST:
    3347         118 :                         ndr_print_dcerpc_request(ndr, "request", &r->request);
    3348         118 :                 break;
    3349             : 
    3350           0 :                 case DCERPC_PKT_PING:
    3351           0 :                         ndr_print_dcerpc_ping(ndr, "ping", &r->ping);
    3352           0 :                 break;
    3353             : 
    3354         118 :                 case DCERPC_PKT_RESPONSE:
    3355         118 :                         ndr_print_dcerpc_response(ndr, "response", &r->response);
    3356         118 :                 break;
    3357             : 
    3358           0 :                 case DCERPC_PKT_FAULT:
    3359           0 :                         ndr_print_dcerpc_fault(ndr, "fault", &r->fault);
    3360           0 :                 break;
    3361             : 
    3362           0 :                 case DCERPC_PKT_WORKING:
    3363           0 :                         ndr_print_dcerpc_working(ndr, "working", &r->working);
    3364           0 :                 break;
    3365             : 
    3366           0 :                 case DCERPC_PKT_NOCALL:
    3367           0 :                         ndr_print_dcerpc_fack(ndr, "nocall", &r->nocall);
    3368           0 :                 break;
    3369             : 
    3370           0 :                 case DCERPC_PKT_REJECT:
    3371           0 :                         ndr_print_dcerpc_fault(ndr, "reject", &r->reject);
    3372           0 :                 break;
    3373             : 
    3374           0 :                 case DCERPC_PKT_ACK:
    3375           0 :                         ndr_print_dcerpc_ack(ndr, "ack", &r->ack);
    3376           0 :                 break;
    3377             : 
    3378           0 :                 case DCERPC_PKT_CL_CANCEL:
    3379           0 :                         ndr_print_dcerpc_cl_cancel(ndr, "cl_cancel", &r->cl_cancel);
    3380           0 :                 break;
    3381             : 
    3382           0 :                 case DCERPC_PKT_FACK:
    3383           0 :                         ndr_print_dcerpc_fack(ndr, "fack", &r->fack);
    3384           0 :                 break;
    3385             : 
    3386           0 :                 case DCERPC_PKT_CANCEL_ACK:
    3387           0 :                         ndr_print_dcerpc_cancel_ack(ndr, "cancel_ack", &r->cancel_ack);
    3388           0 :                 break;
    3389             : 
    3390           4 :                 case DCERPC_PKT_BIND:
    3391           4 :                         ndr_print_dcerpc_bind(ndr, "bind", &r->bind);
    3392           4 :                 break;
    3393             : 
    3394           4 :                 case DCERPC_PKT_BIND_ACK:
    3395           4 :                         ndr_print_dcerpc_bind_ack(ndr, "bind_ack", &r->bind_ack);
    3396           4 :                 break;
    3397             : 
    3398           0 :                 case DCERPC_PKT_BIND_NAK:
    3399           0 :                         ndr_print_dcerpc_bind_nak(ndr, "bind_nak", &r->bind_nak);
    3400           0 :                 break;
    3401             : 
    3402           0 :                 case DCERPC_PKT_ALTER:
    3403           0 :                         ndr_print_dcerpc_bind(ndr, "alter", &r->alter);
    3404           0 :                 break;
    3405             : 
    3406           0 :                 case DCERPC_PKT_ALTER_RESP:
    3407           0 :                         ndr_print_dcerpc_bind_ack(ndr, "alter_resp", &r->alter_resp);
    3408           0 :                 break;
    3409             : 
    3410           0 :                 case DCERPC_PKT_SHUTDOWN:
    3411           0 :                         ndr_print_dcerpc_shutdown(ndr, "shutdown", &r->shutdown);
    3412           0 :                 break;
    3413             : 
    3414           2 :                 case DCERPC_PKT_CO_CANCEL:
    3415           2 :                         ndr_print_dcerpc_co_cancel(ndr, "co_cancel", &r->co_cancel);
    3416           2 :                 break;
    3417             : 
    3418           2 :                 case DCERPC_PKT_ORPHANED:
    3419           2 :                         ndr_print_dcerpc_orphaned(ndr, "orphaned", &r->orphaned);
    3420           2 :                 break;
    3421             : 
    3422           0 :                 case DCERPC_PKT_AUTH3:
    3423           0 :                         ndr_print_dcerpc_auth3(ndr, "auth3", &r->auth3);
    3424           0 :                 break;
    3425             : 
    3426           0 :                 case DCERPC_PKT_RTS:
    3427           0 :                         ndr_print_dcerpc_rts(ndr, "rts", &r->rts);
    3428           0 :                 break;
    3429             : 
    3430           0 :                 default:
    3431           0 :                         ndr_print_bad_level(ndr, name, level);
    3432             :         }
    3433         248 : }
    3434             : 
    3435     2141117 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_pfc_flags(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint8_t r)
    3436             : {
    3437     2141117 :         NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r));
    3438     2124669 :         return NDR_ERR_SUCCESS;
    3439             : }
    3440             : 
    3441     2787301 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_pfc_flags(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint8_t *r)
    3442             : {
    3443       24645 :         uint8_t v;
    3444     2787301 :         NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &v));
    3445     2787301 :         *r = v;
    3446     2787301 :         return NDR_ERR_SUCCESS;
    3447             : }
    3448             : 
    3449         248 : _PUBLIC_ void ndr_print_dcerpc_pfc_flags(struct ndr_print *ndr, const char *name, uint8_t r)
    3450             : {
    3451         248 :         ndr_print_uint8(ndr, name, r);
    3452         248 :         ndr->depth++;
    3453         248 :         ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "DCERPC_PFC_FLAG_FIRST", DCERPC_PFC_FLAG_FIRST, r);
    3454         248 :         ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "DCERPC_PFC_FLAG_LAST", DCERPC_PFC_FLAG_LAST, r);
    3455         248 :         ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "DCERPC_PFC_FLAG_PENDING_CANCEL_OR_HDR_SIGNING", DCERPC_PFC_FLAG_PENDING_CANCEL_OR_HDR_SIGNING, r);
    3456         248 :         ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "DCERPC_PFC_FLAG_CONC_MPX", DCERPC_PFC_FLAG_CONC_MPX, r);
    3457         248 :         ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "DCERPC_PFC_FLAG_DID_NOT_EXECUTE", DCERPC_PFC_FLAG_DID_NOT_EXECUTE, r);
    3458         248 :         ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "DCERPC_PFC_FLAG_MAYBE", DCERPC_PFC_FLAG_MAYBE, r);
    3459         248 :         ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "DCERPC_PFC_FLAG_OBJECT_UUID", DCERPC_PFC_FLAG_OBJECT_UUID, r);
    3460         248 :         ndr->depth--;
    3461         248 : }
    3462             : 
    3463           0 : static void ndr_print_flags_ncacn_packet(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct ncacn_packet *r)
    3464             : {
    3465           0 :         ndr_print_ncacn_packet(ndr, name, r);
    3466           0 : }
    3467             : 
    3468           0 : _PUBLIC_ enum ndr_err_code ndr_push_ncadg_packet(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct ncadg_packet *r)
    3469             : {
    3470           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    3471           0 :         if (ndr_flags & NDR_SCALARS) {
    3472           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    3473           0 :                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->rpc_vers));
    3474           0 :                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->ptype));
    3475           0 :                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->pfc_flags));
    3476           0 :                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->ncadg_flags));
    3477           0 :                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->drep, 3));
    3478           0 :                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->serial_high));
    3479           0 :                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->object));
    3480           0 :                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->iface));
    3481           0 :                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->activity));
    3482           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->server_boot));
    3483           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->iface_version));
    3484           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->seq_num));
    3485           0 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->opnum));
    3486           0 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ihint));
    3487           0 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ahint));
    3488           0 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->len));
    3489           0 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->fragnum));
    3490           0 :                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->auth_proto));
    3491           0 :                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->serial_low));
    3492           0 :                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->u, r->ptype));
    3493           0 :                 NDR_CHECK(ndr_push_dcerpc_payload(ndr, NDR_SCALARS, &r->u));
    3494           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    3495             :         }
    3496           0 :         if (ndr_flags & NDR_BUFFERS) {
    3497           0 :         }
    3498           0 :         return NDR_ERR_SUCCESS;
    3499             : }
    3500             : 
    3501           0 : _PUBLIC_ enum ndr_err_code ndr_pull_ncadg_packet(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct ncadg_packet *r)
    3502             : {
    3503           0 :         uint32_t size_drep_0 = 0;
    3504           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    3505           0 :         if (ndr_flags & NDR_SCALARS) {
    3506           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    3507           0 :                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->rpc_vers));
    3508           0 :                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->ptype));
    3509           0 :                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->pfc_flags));
    3510           0 :                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->ncadg_flags));
    3511           0 :                 size_drep_0 = 3;
    3512           0 :                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->drep, size_drep_0));
    3513           0 :                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->serial_high));
    3514           0 :                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->object));
    3515           0 :                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->iface));
    3516           0 :                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->activity));
    3517           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->server_boot));
    3518           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->iface_version));
    3519           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->seq_num));
    3520           0 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->opnum));
    3521           0 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ihint));
    3522           0 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ahint));
    3523           0 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->len));
    3524           0 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->fragnum));
    3525           0 :                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->auth_proto));
    3526           0 :                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->serial_low));
    3527           0 :                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->u, r->ptype));
    3528           0 :                 NDR_CHECK(ndr_pull_dcerpc_payload(ndr, NDR_SCALARS, &r->u));
    3529           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    3530             :         }
    3531           0 :         if (ndr_flags & NDR_BUFFERS) {
    3532           0 :         }
    3533           0 :         return NDR_ERR_SUCCESS;
    3534             : }
    3535             : 
    3536           0 : static void ndr_print_flags_ncadg_packet(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct ncadg_packet *r)
    3537             : {
    3538           0 :         ndr_print_ncadg_packet(ndr, name, r);
    3539           0 : }
    3540             : 
    3541           0 : _PUBLIC_ void ndr_print_ncadg_packet(struct ndr_print *ndr, const char *name, const struct ncadg_packet *r)
    3542             : {
    3543           0 :         ndr_print_struct(ndr, name, "ncadg_packet");
    3544           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3545           0 :         ndr->depth++;
    3546           0 :         ndr_print_uint8(ndr, "rpc_vers", r->rpc_vers);
    3547           0 :         ndr_print_uint8(ndr, "ptype", r->ptype);
    3548           0 :         ndr_print_uint8(ndr, "pfc_flags", r->pfc_flags);
    3549           0 :         ndr_print_uint8(ndr, "ncadg_flags", r->ncadg_flags);
    3550           0 :         ndr_print_array_uint8(ndr, "drep", r->drep, 3);
    3551           0 :         ndr_print_uint8(ndr, "serial_high", r->serial_high);
    3552           0 :         ndr_print_GUID(ndr, "object", &r->object);
    3553           0 :         ndr_print_GUID(ndr, "iface", &r->iface);
    3554           0 :         ndr_print_GUID(ndr, "activity", &r->activity);
    3555           0 :         ndr_print_uint32(ndr, "server_boot", r->server_boot);
    3556           0 :         ndr_print_uint32(ndr, "iface_version", r->iface_version);
    3557           0 :         ndr_print_uint32(ndr, "seq_num", r->seq_num);
    3558           0 :         ndr_print_uint16(ndr, "opnum", r->opnum);
    3559           0 :         ndr_print_uint16(ndr, "ihint", r->ihint);
    3560           0 :         ndr_print_uint16(ndr, "ahint", r->ahint);
    3561           0 :         ndr_print_uint16(ndr, "len", r->len);
    3562           0 :         ndr_print_uint16(ndr, "fragnum", r->fragnum);
    3563           0 :         ndr_print_uint8(ndr, "auth_proto", r->auth_proto);
    3564           0 :         ndr_print_uint8(ndr, "serial_low", r->serial_low);
    3565           0 :         ndr_print_set_switch_value(ndr, &r->u, r->ptype);
    3566           0 :         ndr_print_dcerpc_payload(ndr, "u", &r->u);
    3567           0 :         ndr->depth--;
    3568             : }
    3569             : 
    3570       27077 : static enum ndr_err_code ndr_push_dcerpc_sec_vt_command(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint16_t r)
    3571             : {
    3572       27077 :         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
    3573       25862 :         return NDR_ERR_SUCCESS;
    3574             : }
    3575             : 
    3576       26686 : static enum ndr_err_code ndr_pull_dcerpc_sec_vt_command(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint16_t *r)
    3577             : {
    3578        1216 :         uint16_t v;
    3579       26686 :         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
    3580       26686 :         *r = v;
    3581       26686 :         return NDR_ERR_SUCCESS;
    3582             : }
    3583             : 
    3584           1 : _PUBLIC_ void ndr_print_dcerpc_sec_vt_command(struct ndr_print *ndr, const char *name, uint16_t r)
    3585             : {
    3586           1 :         ndr_print_uint16(ndr, name, r);
    3587           1 :         ndr->depth++;
    3588           1 :         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "DCERPC_SEC_VT_COMMAND_ENUM", DCERPC_SEC_VT_COMMAND_ENUM, r);
    3589           1 :         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "DCERPC_SEC_VT_COMMAND_END", DCERPC_SEC_VT_COMMAND_END, r);
    3590           1 :         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "DCERPC_SEC_VT_MUST_PROCESS", DCERPC_SEC_VT_MUST_PROCESS, r);
    3591           1 :         ndr->depth--;
    3592           1 : }
    3593             : 
    3594        9452 : static enum ndr_err_code ndr_push_dcerpc_sec_vt_bitmask1(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint32_t r)
    3595             : {
    3596        9452 :         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
    3597        8845 :         return NDR_ERR_SUCCESS;
    3598             : }
    3599             : 
    3600        9205 : static enum ndr_err_code ndr_pull_dcerpc_sec_vt_bitmask1(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint32_t *r)
    3601             : {
    3602         607 :         uint32_t v;
    3603        9205 :         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
    3604        9205 :         *r = v;
    3605        9205 :         return NDR_ERR_SUCCESS;
    3606             : }
    3607             : 
    3608           0 : _PUBLIC_ void ndr_print_dcerpc_sec_vt_bitmask1(struct ndr_print *ndr, const char *name, uint32_t r)
    3609             : {
    3610           0 :         ndr_print_uint32(ndr, name, r);
    3611           0 :         ndr->depth++;
    3612           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DCERPC_SEC_VT_CLIENT_SUPPORTS_HEADER_SIGNING", DCERPC_SEC_VT_CLIENT_SUPPORTS_HEADER_SIGNING, r);
    3613           0 :         ndr->depth--;
    3614           0 : }
    3615             : 
    3616        9459 : static enum ndr_err_code ndr_push_dcerpc_sec_vt_pcontext(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_sec_vt_pcontext *r)
    3617             : {
    3618        9459 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    3619        9459 :         if (ndr_flags & NDR_SCALARS) {
    3620        9459 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    3621        9459 :                 NDR_CHECK(ndr_push_ndr_syntax_id(ndr, NDR_SCALARS, &r->abstract_syntax));
    3622        9459 :                 NDR_CHECK(ndr_push_ndr_syntax_id(ndr, NDR_SCALARS, &r->transfer_syntax));
    3623        9459 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    3624             :         }
    3625        9459 :         if (ndr_flags & NDR_BUFFERS) {
    3626         608 :         }
    3627        9459 :         return NDR_ERR_SUCCESS;
    3628             : }
    3629             : 
    3630        9213 : static enum ndr_err_code ndr_pull_dcerpc_sec_vt_pcontext(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_sec_vt_pcontext *r)
    3631             : {
    3632        9213 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    3633        9213 :         if (ndr_flags & NDR_SCALARS) {
    3634        9213 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    3635        9213 :                 NDR_CHECK(ndr_pull_ndr_syntax_id(ndr, NDR_SCALARS, &r->abstract_syntax));
    3636        9213 :                 NDR_CHECK(ndr_pull_ndr_syntax_id(ndr, NDR_SCALARS, &r->transfer_syntax));
    3637        9213 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    3638             :         }
    3639        9213 :         if (ndr_flags & NDR_BUFFERS) {
    3640         609 :         }
    3641        9213 :         return NDR_ERR_SUCCESS;
    3642             : }
    3643             : 
    3644           1 : _PUBLIC_ void ndr_print_dcerpc_sec_vt_pcontext(struct ndr_print *ndr, const char *name, const struct dcerpc_sec_vt_pcontext *r)
    3645             : {
    3646           1 :         ndr_print_struct(ndr, name, "dcerpc_sec_vt_pcontext");
    3647           1 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3648           1 :         ndr->depth++;
    3649           1 :         ndr_print_ndr_syntax_id(ndr, "abstract_syntax", &r->abstract_syntax);
    3650           1 :         ndr_print_ndr_syntax_id(ndr, "transfer_syntax", &r->transfer_syntax);
    3651           1 :         ndr->depth--;
    3652             : }
    3653             : 
    3654        8166 : static enum ndr_err_code ndr_push_dcerpc_sec_vt_header2(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_sec_vt_header2 *r)
    3655             : {
    3656        8166 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    3657        8166 :         if (ndr_flags & NDR_SCALARS) {
    3658        8166 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    3659        8166 :                 NDR_CHECK(ndr_push_dcerpc_pkt_type(ndr, NDR_SCALARS, r->ptype));
    3660        8166 :                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, 0));
    3661        8166 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
    3662        8166 :                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->drep, 4));
    3663        8166 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->call_id));
    3664        8166 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->context_id));
    3665        8166 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->opnum));
    3666        8166 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    3667             :         }
    3668        8166 :         if (ndr_flags & NDR_BUFFERS) {
    3669           0 :         }
    3670        8166 :         return NDR_ERR_SUCCESS;
    3671             : }
    3672             : 
    3673        8268 : static enum ndr_err_code ndr_pull_dcerpc_sec_vt_header2(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_sec_vt_header2 *r)
    3674             : {
    3675        8268 :         uint32_t size_drep_0 = 0;
    3676        8268 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    3677        8268 :         if (ndr_flags & NDR_SCALARS) {
    3678        8268 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    3679        8268 :                 NDR_CHECK(ndr_pull_dcerpc_pkt_type(ndr, NDR_SCALARS, &r->ptype));
    3680        8268 :                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->reserved1));
    3681        8268 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved2));
    3682        8268 :                 size_drep_0 = 4;
    3683        8268 :                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->drep, size_drep_0));
    3684        8268 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->call_id));
    3685        8268 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->context_id));
    3686        8268 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->opnum));
    3687        8268 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    3688             :         }
    3689        8268 :         if (ndr_flags & NDR_BUFFERS) {
    3690           0 :         }
    3691        8268 :         return NDR_ERR_SUCCESS;
    3692             : }
    3693             : 
    3694           0 : _PUBLIC_ void ndr_print_dcerpc_sec_vt_header2(struct ndr_print *ndr, const char *name, const struct dcerpc_sec_vt_header2 *r)
    3695             : {
    3696           0 :         ndr_print_struct(ndr, name, "dcerpc_sec_vt_header2");
    3697           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3698           0 :         ndr->depth++;
    3699           0 :         ndr_print_dcerpc_pkt_type(ndr, "ptype", r->ptype);
    3700           0 :         ndr_print_uint8(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
    3701           0 :         ndr_print_uint16(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
    3702           0 :         ndr_print_array_uint8(ndr, "drep", r->drep, 4);
    3703           0 :         ndr_print_uint32(ndr, "call_id", r->call_id);
    3704           0 :         ndr_print_uint16(ndr, "context_id", r->context_id);
    3705           0 :         ndr_print_uint16(ndr, "opnum", r->opnum);
    3706           0 :         ndr->depth--;
    3707             : }
    3708             : 
    3709       27077 : static enum ndr_err_code ndr_push_dcerpc_sec_vt_union(struct ndr_push *ndr, ndr_flags_type ndr_flags, const union dcerpc_sec_vt_union *r)
    3710             : {
    3711        1215 :         uint32_t level;
    3712       27077 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    3713       27077 :         if (ndr_flags & NDR_SCALARS) {
    3714             :                 /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
    3715       27077 :                 NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
    3716       27077 :                 NDR_CHECK(ndr_push_union_align(ndr, 4));
    3717       27077 :                 switch (level) {
    3718        9452 :                         case DCERPC_SEC_VT_COMMAND_BITMASK1: {
    3719       10059 :                                 NDR_CHECK(ndr_push_dcerpc_sec_vt_bitmask1(ndr, NDR_SCALARS, r->bitmask1));
    3720        8845 :                         break; }
    3721             : 
    3722        9459 :                         case DCERPC_SEC_VT_COMMAND_PCONTEXT: {
    3723        9459 :                                 NDR_CHECK(ndr_push_dcerpc_sec_vt_pcontext(ndr, NDR_SCALARS, &r->pcontext));
    3724        8851 :                         break; }
    3725             : 
    3726        8166 :                         case DCERPC_SEC_VT_COMMAND_HEADER2: {
    3727        8166 :                                 NDR_CHECK(ndr_push_dcerpc_sec_vt_header2(ndr, NDR_SCALARS, &r->header2));
    3728        8166 :                         break; }
    3729             : 
    3730           0 :                         default: {
    3731             :                                 {
    3732           0 :                                         libndr_flags _flags_save_DATA_BLOB = ndr->flags;
    3733           0 :                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    3734           0 :                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_unknown));
    3735           0 :                                         ndr->flags = _flags_save_DATA_BLOB;
    3736             :                                 }
    3737           0 :                         break; }
    3738             : 
    3739             :                 }
    3740             :         }
    3741       25862 :         return NDR_ERR_SUCCESS;
    3742             : }
    3743             : 
    3744       26686 : static enum ndr_err_code ndr_pull_dcerpc_sec_vt_union(struct ndr_pull *ndr, ndr_flags_type ndr_flags, union dcerpc_sec_vt_union *r)
    3745             : {
    3746        1216 :         uint32_t level;
    3747       26686 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    3748       26686 :         if (ndr_flags & NDR_SCALARS) {
    3749             :                 /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
    3750       26686 :                 NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
    3751       26686 :                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
    3752       26686 :                 switch (level) {
    3753        9205 :                         case DCERPC_SEC_VT_COMMAND_BITMASK1: {
    3754        9812 :                                 NDR_CHECK(ndr_pull_dcerpc_sec_vt_bitmask1(ndr, NDR_SCALARS, &r->bitmask1));
    3755        8598 :                         break; }
    3756             : 
    3757        9213 :                         case DCERPC_SEC_VT_COMMAND_PCONTEXT: {
    3758        9213 :                                 NDR_CHECK(ndr_pull_dcerpc_sec_vt_pcontext(ndr, NDR_SCALARS, &r->pcontext));
    3759        8604 :                         break; }
    3760             : 
    3761        8268 :                         case DCERPC_SEC_VT_COMMAND_HEADER2: {
    3762        8268 :                                 NDR_CHECK(ndr_pull_dcerpc_sec_vt_header2(ndr, NDR_SCALARS, &r->header2));
    3763        8268 :                         break; }
    3764             : 
    3765           0 :                         default: {
    3766             :                                 {
    3767           0 :                                         libndr_flags _flags_save_DATA_BLOB = ndr->flags;
    3768           0 :                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    3769           0 :                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_unknown));
    3770           0 :                                         ndr->flags = _flags_save_DATA_BLOB;
    3771             :                                 }
    3772           0 :                         break; }
    3773             : 
    3774             :                 }
    3775             :         }
    3776       25470 :         return NDR_ERR_SUCCESS;
    3777             : }
    3778             : 
    3779           1 : _PUBLIC_ void ndr_print_dcerpc_sec_vt_union(struct ndr_print *ndr, const char *name, const union dcerpc_sec_vt_union *r)
    3780             : {
    3781           1 :         uint32_t level;
    3782           1 :         level = ndr_print_steal_switch_value(ndr, r);
    3783           1 :         ndr_print_union(ndr, name, level, "dcerpc_sec_vt_union");
    3784           1 :         switch (level) {
    3785           0 :                 case DCERPC_SEC_VT_COMMAND_BITMASK1:
    3786           0 :                         ndr_print_dcerpc_sec_vt_bitmask1(ndr, "bitmask1", r->bitmask1);
    3787           0 :                 break;
    3788             : 
    3789           1 :                 case DCERPC_SEC_VT_COMMAND_PCONTEXT:
    3790           1 :                         ndr_print_dcerpc_sec_vt_pcontext(ndr, "pcontext", &r->pcontext);
    3791           1 :                 break;
    3792             : 
    3793           0 :                 case DCERPC_SEC_VT_COMMAND_HEADER2:
    3794           0 :                         ndr_print_dcerpc_sec_vt_header2(ndr, "header2", &r->header2);
    3795           0 :                 break;
    3796             : 
    3797           0 :                 default:
    3798             :                         {
    3799           0 :                                 libndr_flags _flags_save_DATA_BLOB = ndr->flags;
    3800           0 :                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    3801           0 :                                 ndr_print_DATA_BLOB(ndr, "_unknown", r->_unknown);
    3802           0 :                                 ndr->flags = _flags_save_DATA_BLOB;
    3803             :                         }
    3804           0 :                 break;
    3805             : 
    3806             :         }
    3807           1 : }
    3808             : 
    3809       27077 : static enum ndr_err_code ndr_push_dcerpc_sec_vt(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_sec_vt *r)
    3810             : {
    3811       27077 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    3812       27077 :         if (ndr_flags & NDR_SCALARS) {
    3813       27077 :                 NDR_CHECK(ndr_push_align(ndr, 2));
    3814       28292 :                 NDR_CHECK(ndr_push_dcerpc_sec_vt_command(ndr, NDR_SCALARS, r->command));
    3815             :                 {
    3816       27077 :                         libndr_flags _flags_save_dcerpc_sec_vt_union = ndr->flags;
    3817       27077 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_SUBCONTEXT_NO_UNREAD_BYTES);
    3818             :                         {
    3819        1215 :                                 struct ndr_push *_ndr_u;
    3820       27077 :                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_u, 2, -1));
    3821       27077 :                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_u, &r->u, r->command & DCERPC_SEC_VT_COMMAND_ENUM));
    3822       27077 :                                 NDR_CHECK(ndr_push_dcerpc_sec_vt_union(_ndr_u, NDR_SCALARS, &r->u));
    3823       27077 :                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_u, 2, -1));
    3824             :                         }
    3825       27077 :                         ndr->flags = _flags_save_dcerpc_sec_vt_union;
    3826             :                 }
    3827       27077 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
    3828             :         }
    3829       27077 :         if (ndr_flags & NDR_BUFFERS) {
    3830        1215 :         }
    3831       27077 :         return NDR_ERR_SUCCESS;
    3832             : }
    3833             : 
    3834       26686 : static enum ndr_err_code ndr_pull_dcerpc_sec_vt(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_sec_vt *r)
    3835             : {
    3836       26686 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    3837       26686 :         if (ndr_flags & NDR_SCALARS) {
    3838       26686 :                 NDR_CHECK(ndr_pull_align(ndr, 2));
    3839       27902 :                 NDR_CHECK(ndr_pull_dcerpc_sec_vt_command(ndr, NDR_SCALARS, &r->command));
    3840             :                 {
    3841       26686 :                         libndr_flags _flags_save_dcerpc_sec_vt_union = ndr->flags;
    3842       26686 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_SUBCONTEXT_NO_UNREAD_BYTES);
    3843             :                         {
    3844        1216 :                                 struct ndr_pull *_ndr_u;
    3845       26686 :                                 ssize_t sub_size = -1;
    3846       26686 :                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_u, 2, sub_size));
    3847       26686 :                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_u, &r->u, r->command & DCERPC_SEC_VT_COMMAND_ENUM));
    3848       26686 :                                 NDR_CHECK(ndr_pull_dcerpc_sec_vt_union(_ndr_u, NDR_SCALARS, &r->u));
    3849       26686 :                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_u, 2, sub_size));
    3850             :                         }
    3851       26686 :                         ndr->flags = _flags_save_dcerpc_sec_vt_union;
    3852             :                 }
    3853       26686 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
    3854             :         }
    3855       26686 :         if (ndr_flags & NDR_BUFFERS) {
    3856        1216 :         }
    3857       26686 :         return NDR_ERR_SUCCESS;
    3858             : }
    3859             : 
    3860           1 : _PUBLIC_ void ndr_print_dcerpc_sec_vt(struct ndr_print *ndr, const char *name, const struct dcerpc_sec_vt *r)
    3861             : {
    3862           1 :         ndr_print_struct(ndr, name, "dcerpc_sec_vt");
    3863           1 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3864           1 :         ndr->depth++;
    3865           1 :         ndr_print_dcerpc_sec_vt_command(ndr, "command", r->command);
    3866             :         {
    3867           1 :                 libndr_flags _flags_save_dcerpc_sec_vt_union = ndr->flags;
    3868           1 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_SUBCONTEXT_NO_UNREAD_BYTES);
    3869           1 :                 ndr_print_set_switch_value(ndr, &r->u, r->command & DCERPC_SEC_VT_COMMAND_ENUM);
    3870           1 :                 ndr_print_dcerpc_sec_vt_union(ndr, "u", &r->u);
    3871           1 :                 ndr->flags = _flags_save_dcerpc_sec_vt_union;
    3872             :         }
    3873           1 :         ndr->depth--;
    3874             : }
    3875             : 
    3876           0 : static void ndr_print_flags_dcerpc_sec_vt_count(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_sec_vt_count *r)
    3877             : {
    3878           0 :         ndr_print_dcerpc_sec_vt_count(ndr, name, r);
    3879           0 : }
    3880             : 
    3881           1 : _PUBLIC_ void ndr_print_dcerpc_sec_vt_count(struct ndr_print *ndr, const char *name, const struct dcerpc_sec_vt_count *r)
    3882             : {
    3883           1 :         ndr_print_struct(ndr, name, "dcerpc_sec_vt_count");
    3884           1 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3885           1 :         ndr->depth++;
    3886           1 :         ndr_print_uint16(ndr, "count", r->count);
    3887           1 :         ndr->depth--;
    3888             : }
    3889             : 
    3890       17123 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_sec_verification_trailer(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_sec_verification_trailer *r)
    3891             : {
    3892         608 :         uint32_t cntr_commands_0;
    3893             :         {
    3894       17123 :                 libndr_flags _flags_save_STRUCT = ndr->flags;
    3895       17123 :                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
    3896       17123 :                 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    3897       17123 :                 if (ndr_flags & NDR_SCALARS) {
    3898       17123 :                         NDR_CHECK(ndr_push_align(ndr, 4));
    3899             :                         {
    3900       17123 :                                 libndr_flags _flags_save_DATA_BLOB = ndr->flags;
    3901       17123 :                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
    3902       17123 :                                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
    3903       17123 :                                 ndr->flags = _flags_save_DATA_BLOB;
    3904             :                         }
    3905       17123 :                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, DCERPC_SEC_VT_MAGIC, 8));
    3906       17123 :                         NDR_CHECK(ndr_push_dcerpc_sec_vt_count(ndr, NDR_SCALARS, &r->count));
    3907       44200 :                         for (cntr_commands_0 = 0; cntr_commands_0 < (r->count.count); cntr_commands_0++) {
    3908       27077 :                                 NDR_CHECK(ndr_push_dcerpc_sec_vt(ndr, NDR_SCALARS, &r->commands[cntr_commands_0]));
    3909             :                         }
    3910       17123 :                         NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    3911             :                 }
    3912       17123 :                 if (ndr_flags & NDR_BUFFERS) {
    3913         608 :                 }
    3914       17123 :                 ndr->flags = _flags_save_STRUCT;
    3915             :         }
    3916       17123 :         return NDR_ERR_SUCCESS;
    3917             : }
    3918             : 
    3919       16965 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_sec_verification_trailer(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_sec_verification_trailer *r)
    3920             : {
    3921       16965 :         uint32_t size_magic_0 = 0;
    3922       16965 :         uint32_t size_commands_0 = 0;
    3923         609 :         uint32_t cntr_commands_0;
    3924       16965 :         TALLOC_CTX *_mem_save_commands_0 = NULL;
    3925             :         {
    3926       16965 :                 libndr_flags _flags_save_STRUCT = ndr->flags;
    3927       16965 :                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
    3928       16965 :                 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    3929       16965 :                 if (ndr_flags & NDR_SCALARS) {
    3930       16965 :                         NDR_CHECK(ndr_pull_align(ndr, 4));
    3931             :                         {
    3932       16965 :                                 libndr_flags _flags_save_DATA_BLOB = ndr->flags;
    3933       16965 :                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
    3934       16965 :                                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
    3935       16965 :                                 ndr->flags = _flags_save_DATA_BLOB;
    3936             :                         }
    3937       16965 :                         size_magic_0 = 8;
    3938       16965 :                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->magic, size_magic_0));
    3939       16965 :                         NDR_CHECK(ndr_pull_dcerpc_sec_vt_count(ndr, NDR_SCALARS, &r->count));
    3940       16965 :                         size_commands_0 = r->count.count;
    3941       16965 :                         NDR_PULL_ALLOC_N(ndr, r->commands, size_commands_0);
    3942       16965 :                         _mem_save_commands_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3943       16965 :                         NDR_PULL_SET_MEM_CTX(ndr, r->commands, 0);
    3944       43651 :                         for (cntr_commands_0 = 0; cntr_commands_0 < (size_commands_0); cntr_commands_0++) {
    3945       26686 :                                 NDR_CHECK(ndr_pull_dcerpc_sec_vt(ndr, NDR_SCALARS, &r->commands[cntr_commands_0]));
    3946             :                         }
    3947       16965 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_commands_0, 0);
    3948       16965 :                         NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    3949             :                 }
    3950       16965 :                 if (ndr_flags & NDR_BUFFERS) {
    3951         609 :                 }
    3952       16965 :                 ndr->flags = _flags_save_STRUCT;
    3953             :         }
    3954       16965 :         return NDR_ERR_SUCCESS;
    3955             : }
    3956             : 
    3957           0 : static void ndr_print_flags_dcerpc_sec_verification_trailer(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_sec_verification_trailer *r)
    3958             : {
    3959           0 :         ndr_print_dcerpc_sec_verification_trailer(ndr, name, r);
    3960           0 : }
    3961             : 
    3962           1 : _PUBLIC_ void ndr_print_dcerpc_sec_verification_trailer(struct ndr_print *ndr, const char *name, const struct dcerpc_sec_verification_trailer *r)
    3963             : {
    3964           1 :         uint32_t cntr_commands_0;
    3965           1 :         ndr_print_struct(ndr, name, "dcerpc_sec_verification_trailer");
    3966           1 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3967             :         {
    3968           1 :                 libndr_flags _flags_save_STRUCT = ndr->flags;
    3969           1 :                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
    3970           1 :                 ndr->depth++;
    3971             :                 {
    3972           1 :                         libndr_flags _flags_save_DATA_BLOB = ndr->flags;
    3973           1 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
    3974           1 :                         ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
    3975           1 :                         ndr->flags = _flags_save_DATA_BLOB;
    3976             :                 }
    3977           1 :                 ndr_print_array_uint8(ndr, "magic", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?DCERPC_SEC_VT_MAGIC:r->magic, 8);
    3978           1 :                 ndr_print_dcerpc_sec_vt_count(ndr, "count", &r->count);
    3979           1 :                 ndr->print(ndr, "%s: ARRAY(%"PRIu32")", "commands", (uint32_t)(r->count.count));
    3980           1 :                 ndr->depth++;
    3981           2 :                 for (cntr_commands_0 = 0; cntr_commands_0 < (r->count.count); cntr_commands_0++) {
    3982           1 :                         ndr_print_dcerpc_sec_vt(ndr, "commands", &r->commands[cntr_commands_0]);
    3983             :                 }
    3984           1 :                 ndr->depth--;
    3985           1 :                 ndr->depth--;
    3986           1 :                 ndr->flags = _flags_save_STRUCT;
    3987             :         }
    3988             : }
    3989             : 
    3990             : #ifndef SKIP_NDR_TABLE_dcerpc
    3991             : static const struct ndr_interface_public_struct dcerpc_public_structs[] = {
    3992             :         {
    3993             :                 .name = "dcerpc_bind",
    3994             :                 .struct_size = sizeof(struct dcerpc_bind ),
    3995             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_bind,
    3996             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_bind,
    3997             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_bind,
    3998             :         },
    3999             :         {
    4000             :                 .name = "dcerpc_bind_nak_version",
    4001             :                 .struct_size = sizeof(struct dcerpc_bind_nak_version ),
    4002             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_bind_nak_version,
    4003             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_bind_nak_version,
    4004             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_bind_nak_version,
    4005             :         },
    4006             :         {
    4007             :                 .name = "dcerpc_bind_nak",
    4008             :                 .struct_size = sizeof(struct dcerpc_bind_nak ),
    4009             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_bind_nak,
    4010             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_bind_nak,
    4011             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_bind_nak,
    4012             :         },
    4013             :         {
    4014             :                 .name = "dcerpc_auth",
    4015             :                 .struct_size = sizeof(struct dcerpc_auth ),
    4016             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_auth,
    4017             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_auth,
    4018             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_auth,
    4019             :         },
    4020             :         {
    4021             :                 .name = "dcerpc_auth3",
    4022             :                 .struct_size = sizeof(struct dcerpc_auth3 ),
    4023             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_auth3,
    4024             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_auth3,
    4025             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_auth3,
    4026             :         },
    4027             :         {
    4028             :                 .name = "dcerpc_orphaned",
    4029             :                 .struct_size = sizeof(struct dcerpc_orphaned ),
    4030             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_orphaned,
    4031             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_orphaned,
    4032             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_orphaned,
    4033             :         },
    4034             :         {
    4035             :                 .name = "dcerpc_co_cancel",
    4036             :                 .struct_size = sizeof(struct dcerpc_co_cancel ),
    4037             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_co_cancel,
    4038             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_co_cancel,
    4039             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_co_cancel,
    4040             :         },
    4041             :         {
    4042             :                 .name = "dcerpc_cl_cancel",
    4043             :                 .struct_size = sizeof(struct dcerpc_cl_cancel ),
    4044             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_cl_cancel,
    4045             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_cl_cancel,
    4046             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_cl_cancel,
    4047             :         },
    4048             :         {
    4049             :                 .name = "dcerpc_cancel_ack",
    4050             :                 .struct_size = sizeof(struct dcerpc_cancel_ack ),
    4051             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_cancel_ack,
    4052             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_cancel_ack,
    4053             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_cancel_ack,
    4054             :         },
    4055             :         {
    4056             :                 .name = "dcerpc_fack",
    4057             :                 .struct_size = sizeof(struct dcerpc_fack ),
    4058             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_fack,
    4059             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_fack,
    4060             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_fack,
    4061             :         },
    4062             :         {
    4063             :                 .name = "dcerpc_ack",
    4064             :                 .struct_size = sizeof(struct dcerpc_ack ),
    4065             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_ack,
    4066             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_ack,
    4067             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_ack,
    4068             :         },
    4069             :         {
    4070             :                 .name = "dcerpc_ping",
    4071             :                 .struct_size = sizeof(struct dcerpc_ping ),
    4072             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_ping,
    4073             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_ping,
    4074             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_ping,
    4075             :         },
    4076             :         {
    4077             :                 .name = "dcerpc_shutdown",
    4078             :                 .struct_size = sizeof(struct dcerpc_shutdown ),
    4079             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_shutdown,
    4080             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_shutdown,
    4081             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_shutdown,
    4082             :         },
    4083             :         {
    4084             :                 .name = "dcerpc_working",
    4085             :                 .struct_size = sizeof(struct dcerpc_working ),
    4086             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_working,
    4087             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_working,
    4088             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_working,
    4089             :         },
    4090             :         {
    4091             :                 .name = "RTSCookie",
    4092             :                 .struct_size = sizeof(struct RTSCookie ),
    4093             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_RTSCookie,
    4094             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_RTSCookie,
    4095             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_RTSCookie,
    4096             :         },
    4097             :         {
    4098             :                 .name = "ClientAddress",
    4099             :                 .struct_size = sizeof(struct ClientAddress ),
    4100             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_ClientAddress,
    4101             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_ClientAddress,
    4102             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_ClientAddress,
    4103             :         },
    4104             :         {
    4105             :                 .name = "FlowControlAcknowledgment",
    4106             :                 .struct_size = sizeof(struct FlowControlAcknowledgment ),
    4107             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_FlowControlAcknowledgment,
    4108             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_FlowControlAcknowledgment,
    4109             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_FlowControlAcknowledgment,
    4110             :         },
    4111             :         {
    4112             :                 .name = "dcerpc_rts_cmd_ReceiveWindowSize",
    4113             :                 .struct_size = sizeof(struct dcerpc_rts_cmd_ReceiveWindowSize ),
    4114             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_ReceiveWindowSize,
    4115             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_ReceiveWindowSize,
    4116             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_ReceiveWindowSize,
    4117             :         },
    4118             :         {
    4119             :                 .name = "dcerpc_rts_cmd_FlowControlAck",
    4120             :                 .struct_size = sizeof(struct dcerpc_rts_cmd_FlowControlAck ),
    4121             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_FlowControlAck,
    4122             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_FlowControlAck,
    4123             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_FlowControlAck,
    4124             :         },
    4125             :         {
    4126             :                 .name = "dcerpc_rts_cmd_ConnectionTimeout",
    4127             :                 .struct_size = sizeof(struct dcerpc_rts_cmd_ConnectionTimeout ),
    4128             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_ConnectionTimeout,
    4129             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_ConnectionTimeout,
    4130             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_ConnectionTimeout,
    4131             :         },
    4132             :         {
    4133             :                 .name = "dcerpc_rts_cmd_Cookie",
    4134             :                 .struct_size = sizeof(struct dcerpc_rts_cmd_Cookie ),
    4135             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_Cookie,
    4136             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_Cookie,
    4137             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_Cookie,
    4138             :         },
    4139             :         {
    4140             :                 .name = "dcerpc_rts_cmd_ChannelLifetime",
    4141             :                 .struct_size = sizeof(struct dcerpc_rts_cmd_ChannelLifetime ),
    4142             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_ChannelLifetime,
    4143             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_ChannelLifetime,
    4144             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_ChannelLifetime,
    4145             :         },
    4146             :         {
    4147             :                 .name = "dcerpc_rts_cmd_ClientKeepalive",
    4148             :                 .struct_size = sizeof(struct dcerpc_rts_cmd_ClientKeepalive ),
    4149             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_ClientKeepalive,
    4150             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_ClientKeepalive,
    4151             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_ClientKeepalive,
    4152             :         },
    4153             :         {
    4154             :                 .name = "dcerpc_rts_cmd_Version",
    4155             :                 .struct_size = sizeof(struct dcerpc_rts_cmd_Version ),
    4156             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_Version,
    4157             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_Version,
    4158             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_Version,
    4159             :         },
    4160             :         {
    4161             :                 .name = "dcerpc_rts_cmd_Empty",
    4162             :                 .struct_size = sizeof(struct dcerpc_rts_cmd_Empty ),
    4163             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_Empty,
    4164             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_Empty,
    4165             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_Empty,
    4166             :         },
    4167             :         {
    4168             :                 .name = "dcerpc_rts_cmd_Padding",
    4169             :                 .struct_size = sizeof(struct dcerpc_rts_cmd_Padding ),
    4170             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_Padding,
    4171             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_Padding,
    4172             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_Padding,
    4173             :         },
    4174             :         {
    4175             :                 .name = "dcerpc_rts_cmd_NegativeANCE",
    4176             :                 .struct_size = sizeof(struct dcerpc_rts_cmd_NegativeANCE ),
    4177             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_NegativeANCE,
    4178             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_NegativeANCE,
    4179             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_NegativeANCE,
    4180             :         },
    4181             :         {
    4182             :                 .name = "dcerpc_rts_cmd_ANCE",
    4183             :                 .struct_size = sizeof(struct dcerpc_rts_cmd_ANCE ),
    4184             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_ANCE,
    4185             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_ANCE,
    4186             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_ANCE,
    4187             :         },
    4188             :         {
    4189             :                 .name = "dcerpc_rts_cmd_ClientAddress",
    4190             :                 .struct_size = sizeof(struct dcerpc_rts_cmd_ClientAddress ),
    4191             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_ClientAddress,
    4192             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_ClientAddress,
    4193             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_ClientAddress,
    4194             :         },
    4195             :         {
    4196             :                 .name = "dcerpc_rts_cmd_AssociationGroupId",
    4197             :                 .struct_size = sizeof(struct dcerpc_rts_cmd_AssociationGroupId ),
    4198             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_AssociationGroupId,
    4199             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_AssociationGroupId,
    4200             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_AssociationGroupId,
    4201             :         },
    4202             :         {
    4203             :                 .name = "dcerpc_rts_cmd_Destination",
    4204             :                 .struct_size = sizeof(struct dcerpc_rts_cmd_Destination ),
    4205             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_Destination,
    4206             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_Destination,
    4207             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_Destination,
    4208             :         },
    4209             :         {
    4210             :                 .name = "dcerpc_rts_cmd_PingTrafficSentNotify",
    4211             :                 .struct_size = sizeof(struct dcerpc_rts_cmd_PingTrafficSentNotify ),
    4212             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_PingTrafficSentNotify,
    4213             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_PingTrafficSentNotify,
    4214             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_PingTrafficSentNotify,
    4215             :         },
    4216             :         {
    4217             :                 .name = "dcerpc_rts_cmd",
    4218             :                 .struct_size = sizeof(struct dcerpc_rts_cmd ),
    4219             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd,
    4220             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd,
    4221             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd,
    4222             :         },
    4223             :         {
    4224             :                 .name = "dcerpc_rts",
    4225             :                 .struct_size = sizeof(struct dcerpc_rts ),
    4226             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts,
    4227             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts,
    4228             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts,
    4229             :         },
    4230             :         {
    4231             :                 .name = "ncacn_packet",
    4232             :                 .struct_size = sizeof(struct ncacn_packet ),
    4233             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_ncacn_packet,
    4234             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_ncacn_packet,
    4235             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_ncacn_packet,
    4236             :         },
    4237             :         {
    4238             :                 .name = "ncadg_packet",
    4239             :                 .struct_size = sizeof(struct ncadg_packet ),
    4240             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_ncadg_packet,
    4241             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_ncadg_packet,
    4242             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_ncadg_packet,
    4243             :         },
    4244             :         {
    4245             :                 .name = "dcerpc_sec_vt_count",
    4246             :                 .struct_size = sizeof(struct dcerpc_sec_vt_count ),
    4247             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_sec_vt_count,
    4248             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_sec_vt_count,
    4249             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_sec_vt_count,
    4250             :         },
    4251             :         {
    4252             :                 .name = "dcerpc_sec_verification_trailer",
    4253             :                 .struct_size = sizeof(struct dcerpc_sec_verification_trailer ),
    4254             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_sec_verification_trailer,
    4255             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_sec_verification_trailer,
    4256             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_sec_verification_trailer,
    4257             :         },
    4258             :         { .name = NULL }
    4259             : };
    4260             : 
    4261             : static const struct ndr_interface_call dcerpc_calls[] = {
    4262             :         { .name = NULL }
    4263             : };
    4264             : 
    4265             : static const char * const dcerpc_endpoint_strings[] = {
    4266             :         "ncacn_np:[\\pipe\\dcerpc]", 
    4267             : };
    4268             : 
    4269             : static const struct ndr_interface_string_array dcerpc_endpoints = {
    4270             :         .count  = 1,
    4271             :         .names  = dcerpc_endpoint_strings
    4272             : };
    4273             : 
    4274             : static const char * const dcerpc_authservice_strings[] = {
    4275             :         "host", 
    4276             : };
    4277             : 
    4278             : static const struct ndr_interface_string_array dcerpc_authservices = {
    4279             :         .count  = 1,
    4280             :         .names  = dcerpc_authservice_strings
    4281             : };
    4282             : 
    4283             : 
    4284             : const struct ndr_interface_table ndr_table_dcerpc = {
    4285             :         .name           = "dcerpc",
    4286             :         .num_calls      = 0,
    4287             :         .calls          = dcerpc_calls,
    4288             :         .num_public_structs     = 38,
    4289             :         .public_structs         = dcerpc_public_structs,
    4290             :         .endpoints      = &dcerpc_endpoints,
    4291             :         .authservices   = &dcerpc_authservices
    4292             : };
    4293             : 
    4294             : #endif /* SKIP_NDR_TABLE_dcerpc */

Generated by: LCOV version 1.14