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 abartlet/fix-coverage dd10fb34 Lines: 992 2697 36.8 %
Date: 2021-09-23 10:06:22 Functions: 89 241 36.9 %

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

Generated by: LCOV version 1.13