LCOV - code coverage report
Current view: top level - bin/default/librpc/gen_ndr - ndr_epmapper.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 979 1824 53.7 %
Date: 2021-09-23 10:06:22 Functions: 72 160 45.0 %

          Line data    Source code
       1             : /* parser auto-generated by pidl */
       2             : 
       3             : #include "includes.h"
       4             : #include "bin/default/librpc/gen_ndr/ndr_epmapper.h"
       5             : 
       6             : #include "librpc/gen_ndr/ndr_misc.h"
       7      473022 : static enum ndr_err_code ndr_push_epm_protocol(struct ndr_push *ndr, int ndr_flags, enum epm_protocol r)
       8             : {
       9      475506 :         NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
      10      473022 :         return NDR_ERR_SUCCESS;
      11             : }
      12             : 
      13     1385500 : static enum ndr_err_code ndr_pull_epm_protocol(struct ndr_pull *ndr, int ndr_flags, enum epm_protocol *r)
      14             : {
      15             :         uint8_t v;
      16     1386752 :         NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
      17     1386752 :         *r = v;
      18     1385500 :         return NDR_ERR_SUCCESS;
      19             : }
      20             : 
      21        2722 : _PUBLIC_ void ndr_print_epm_protocol(struct ndr_print *ndr, const char *name, enum epm_protocol r)
      22             : {
      23        2722 :         const char *val = NULL;
      24             : 
      25        2722 :         switch (r) {
      26           0 :                 case EPM_PROTOCOL_DNET_NSP: val = "EPM_PROTOCOL_DNET_NSP"; break;
      27           0 :                 case EPM_PROTOCOL_OSI_TP4: val = "EPM_PROTOCOL_OSI_TP4"; break;
      28           0 :                 case EPM_PROTOCOL_OSI_CLNS: val = "EPM_PROTOCOL_OSI_CLNS"; break;
      29         190 :                 case EPM_PROTOCOL_TCP: val = "EPM_PROTOCOL_TCP"; break;
      30           0 :                 case EPM_PROTOCOL_UDP: val = "EPM_PROTOCOL_UDP"; break;
      31         240 :                 case EPM_PROTOCOL_IP: val = "EPM_PROTOCOL_IP"; break;
      32           0 :                 case EPM_PROTOCOL_NCADG: val = "EPM_PROTOCOL_NCADG"; break;
      33         506 :                 case EPM_PROTOCOL_NCACN: val = "EPM_PROTOCOL_NCACN"; break;
      34          48 :                 case EPM_PROTOCOL_NCALRPC: val = "EPM_PROTOCOL_NCALRPC"; break;
      35        1108 :                 case EPM_PROTOCOL_UUID: val = "EPM_PROTOCOL_UUID"; break;
      36           0 :                 case EPM_PROTOCOL_IPX: val = "EPM_PROTOCOL_IPX"; break;
      37         266 :                 case EPM_PROTOCOL_SMB: val = "EPM_PROTOCOL_SMB"; break;
      38          48 :                 case EPM_PROTOCOL_NAMED_PIPE: val = "EPM_PROTOCOL_NAMED_PIPE"; break;
      39         266 :                 case EPM_PROTOCOL_NETBIOS: val = "EPM_PROTOCOL_NETBIOS"; break;
      40           0 :                 case EPM_PROTOCOL_NETBEUI: val = "EPM_PROTOCOL_NETBEUI"; break;
      41           0 :                 case EPM_PROTOCOL_SPX: val = "EPM_PROTOCOL_SPX"; break;
      42           0 :                 case EPM_PROTOCOL_NB_IPX: val = "EPM_PROTOCOL_NB_IPX"; break;
      43           0 :                 case EPM_PROTOCOL_DSP: val = "EPM_PROTOCOL_DSP"; break;
      44           0 :                 case EPM_PROTOCOL_DDP: val = "EPM_PROTOCOL_DDP"; break;
      45           0 :                 case EPM_PROTOCOL_APPLETALK: val = "EPM_PROTOCOL_APPLETALK"; break;
      46           0 :                 case EPM_PROTOCOL_VINES_SPP: val = "EPM_PROTOCOL_VINES_SPP"; break;
      47           0 :                 case EPM_PROTOCOL_VINES_IPC: val = "EPM_PROTOCOL_VINES_IPC"; break;
      48           0 :                 case EPM_PROTOCOL_STREETTALK: val = "EPM_PROTOCOL_STREETTALK"; break;
      49          50 :                 case EPM_PROTOCOL_HTTP: val = "EPM_PROTOCOL_HTTP"; break;
      50           0 :                 case EPM_PROTOCOL_UNIX_DS: val = "EPM_PROTOCOL_UNIX_DS"; break;
      51           0 :                 case EPM_PROTOCOL_NULL: val = "EPM_PROTOCOL_NULL"; break;
      52             :         }
      53        2722 :         ndr_print_enum(ndr, name, "ENUM", val, r);
      54        2722 : }
      55             : 
      56           0 : static enum ndr_err_code ndr_push_epm_rhs_dnet_nsp(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_dnet_nsp *r)
      57             : {
      58           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
      59           0 :         if (ndr_flags & NDR_SCALARS) {
      60           0 :                 NDR_CHECK(ndr_push_align(ndr, 1));
      61           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
      62             :         }
      63           0 :         if (ndr_flags & NDR_BUFFERS) {
      64             :         }
      65           0 :         return NDR_ERR_SUCCESS;
      66             : }
      67             : 
      68           0 : static enum ndr_err_code ndr_pull_epm_rhs_dnet_nsp(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_dnet_nsp *r)
      69             : {
      70           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
      71           0 :         if (ndr_flags & NDR_SCALARS) {
      72           0 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
      73           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
      74             :         }
      75           0 :         if (ndr_flags & NDR_BUFFERS) {
      76             :         }
      77           0 :         return NDR_ERR_SUCCESS;
      78             : }
      79             : 
      80           0 : _PUBLIC_ void ndr_print_epm_rhs_dnet_nsp(struct ndr_print *ndr, const char *name, const struct epm_rhs_dnet_nsp *r)
      81             : {
      82           0 :         ndr_print_struct(ndr, name, "epm_rhs_dnet_nsp");
      83           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
      84           0 :         ndr->depth++;
      85           0 :         ndr->depth--;
      86             : }
      87             : 
      88           0 : static enum ndr_err_code ndr_push_epm_rhs_osi_tp4(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_osi_tp4 *r)
      89             : {
      90           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
      91           0 :         if (ndr_flags & NDR_SCALARS) {
      92           0 :                 NDR_CHECK(ndr_push_align(ndr, 1));
      93           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
      94             :         }
      95           0 :         if (ndr_flags & NDR_BUFFERS) {
      96             :         }
      97           0 :         return NDR_ERR_SUCCESS;
      98             : }
      99             : 
     100           0 : static enum ndr_err_code ndr_pull_epm_rhs_osi_tp4(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_osi_tp4 *r)
     101             : {
     102           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     103           0 :         if (ndr_flags & NDR_SCALARS) {
     104           0 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
     105           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
     106             :         }
     107           0 :         if (ndr_flags & NDR_BUFFERS) {
     108             :         }
     109           0 :         return NDR_ERR_SUCCESS;
     110             : }
     111             : 
     112           0 : _PUBLIC_ void ndr_print_epm_rhs_osi_tp4(struct ndr_print *ndr, const char *name, const struct epm_rhs_osi_tp4 *r)
     113             : {
     114           0 :         ndr_print_struct(ndr, name, "epm_rhs_osi_tp4");
     115           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     116           0 :         ndr->depth++;
     117           0 :         ndr->depth--;
     118             : }
     119             : 
     120           0 : static enum ndr_err_code ndr_push_epm_rhs_osi_clns(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_osi_clns *r)
     121             : {
     122           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     123           0 :         if (ndr_flags & NDR_SCALARS) {
     124           0 :                 NDR_CHECK(ndr_push_align(ndr, 1));
     125           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
     126             :         }
     127           0 :         if (ndr_flags & NDR_BUFFERS) {
     128             :         }
     129           0 :         return NDR_ERR_SUCCESS;
     130             : }
     131             : 
     132           0 : static enum ndr_err_code ndr_pull_epm_rhs_osi_clns(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_osi_clns *r)
     133             : {
     134           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     135           0 :         if (ndr_flags & NDR_SCALARS) {
     136           0 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
     137           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
     138             :         }
     139           0 :         if (ndr_flags & NDR_BUFFERS) {
     140             :         }
     141           0 :         return NDR_ERR_SUCCESS;
     142             : }
     143             : 
     144           0 : _PUBLIC_ void ndr_print_epm_rhs_osi_clns(struct ndr_print *ndr, const char *name, const struct epm_rhs_osi_clns *r)
     145             : {
     146           0 :         ndr_print_struct(ndr, name, "epm_rhs_osi_clns");
     147           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     148           0 :         ndr->depth++;
     149           0 :         ndr->depth--;
     150             : }
     151             : 
     152        1056 : static enum ndr_err_code ndr_push_epm_rhs_udp(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_udp *r)
     153             : {
     154        1056 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     155        1056 :         if (ndr_flags & NDR_SCALARS) {
     156        1056 :                 NDR_CHECK(ndr_push_align(ndr, 2));
     157        1056 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->port));
     158        1056 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
     159             :         }
     160        1056 :         if (ndr_flags & NDR_BUFFERS) {
     161             :         }
     162        1056 :         return NDR_ERR_SUCCESS;
     163             : }
     164             : 
     165         184 : static enum ndr_err_code ndr_pull_epm_rhs_udp(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_udp *r)
     166             : {
     167         184 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     168         184 :         if (ndr_flags & NDR_SCALARS) {
     169         184 :                 NDR_CHECK(ndr_pull_align(ndr, 2));
     170         184 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->port));
     171         184 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
     172             :         }
     173         184 :         if (ndr_flags & NDR_BUFFERS) {
     174             :         }
     175         184 :         return NDR_ERR_SUCCESS;
     176             : }
     177             : 
     178           0 : _PUBLIC_ void ndr_print_epm_rhs_udp(struct ndr_print *ndr, const char *name, const struct epm_rhs_udp *r)
     179             : {
     180           0 :         ndr_print_struct(ndr, name, "epm_rhs_udp");
     181           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     182           0 :         ndr->depth++;
     183           0 :         ndr_print_uint16(ndr, "port", r->port);
     184           0 :         ndr->depth--;
     185             : }
     186             : 
     187       20596 : static enum ndr_err_code ndr_push_epm_rhs_tcp(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_tcp *r)
     188             : {
     189       20596 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     190       20596 :         if (ndr_flags & NDR_SCALARS) {
     191       20596 :                 NDR_CHECK(ndr_push_align(ndr, 2));
     192       20596 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->port));
     193       20596 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
     194             :         }
     195       20112 :         if (ndr_flags & NDR_BUFFERS) {
     196             :         }
     197       20596 :         return NDR_ERR_SUCCESS;
     198             : }
     199             : 
     200        9752 : static enum ndr_err_code ndr_pull_epm_rhs_tcp(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_tcp *r)
     201             : {
     202        9752 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     203        9752 :         if (ndr_flags & NDR_SCALARS) {
     204        9752 :                 NDR_CHECK(ndr_pull_align(ndr, 2));
     205        9752 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->port));
     206        9752 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
     207             :         }
     208        9508 :         if (ndr_flags & NDR_BUFFERS) {
     209             :         }
     210        9752 :         return NDR_ERR_SUCCESS;
     211             : }
     212             : 
     213         190 : _PUBLIC_ void ndr_print_epm_rhs_tcp(struct ndr_print *ndr, const char *name, const struct epm_rhs_tcp *r)
     214             : {
     215         190 :         ndr_print_struct(ndr, name, "epm_rhs_tcp");
     216         190 :         if (r == NULL) { ndr_print_null(ndr); return; }
     217         190 :         ndr->depth++;
     218         190 :         ndr_print_uint16(ndr, "port", r->port);
     219         190 :         ndr->depth--;
     220             : }
     221             : 
     222       22974 : static enum ndr_err_code ndr_push_epm_rhs_ip(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_ip *r)
     223             : {
     224       22974 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     225       22974 :         if (ndr_flags & NDR_SCALARS) {
     226       22974 :                 NDR_CHECK(ndr_push_align(ndr, 4));
     227       22974 :                 NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->ipaddr));
     228       22974 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
     229             :         }
     230       22490 :         if (ndr_flags & NDR_BUFFERS) {
     231             :         }
     232       22974 :         return NDR_ERR_SUCCESS;
     233             : }
     234             : 
     235       10228 : static enum ndr_err_code ndr_pull_epm_rhs_ip(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_ip *r)
     236             : {
     237       10228 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     238       10228 :         if (ndr_flags & NDR_SCALARS) {
     239       10228 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
     240       10228 :                 NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->ipaddr));
     241       10228 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
     242             :         }
     243        9984 :         if (ndr_flags & NDR_BUFFERS) {
     244             :         }
     245       10228 :         return NDR_ERR_SUCCESS;
     246             : }
     247             : 
     248         240 : _PUBLIC_ void ndr_print_epm_rhs_ip(struct ndr_print *ndr, const char *name, const struct epm_rhs_ip *r)
     249             : {
     250         240 :         ndr_print_struct(ndr, name, "epm_rhs_ip");
     251         240 :         if (r == NULL) { ndr_print_null(ndr); return; }
     252         240 :         ndr->depth++;
     253         240 :         ndr_print_ipv4address(ndr, "ipaddr", r->ipaddr);
     254         240 :         ndr->depth--;
     255             : }
     256             : 
     257           0 : static enum ndr_err_code ndr_push_epm_rhs_ncadg(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_ncadg *r)
     258             : {
     259           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     260           0 :         if (ndr_flags & NDR_SCALARS) {
     261           0 :                 NDR_CHECK(ndr_push_align(ndr, 2));
     262           0 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minor_version));
     263           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
     264             :         }
     265           0 :         if (ndr_flags & NDR_BUFFERS) {
     266             :         }
     267           0 :         return NDR_ERR_SUCCESS;
     268             : }
     269             : 
     270           0 : static enum ndr_err_code ndr_pull_epm_rhs_ncadg(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_ncadg *r)
     271             : {
     272           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     273           0 :         if (ndr_flags & NDR_SCALARS) {
     274           0 :                 NDR_CHECK(ndr_pull_align(ndr, 2));
     275           0 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minor_version));
     276           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
     277             :         }
     278           0 :         if (ndr_flags & NDR_BUFFERS) {
     279             :         }
     280           0 :         return NDR_ERR_SUCCESS;
     281             : }
     282             : 
     283           0 : _PUBLIC_ void ndr_print_epm_rhs_ncadg(struct ndr_print *ndr, const char *name, const struct epm_rhs_ncadg *r)
     284             : {
     285           0 :         ndr_print_struct(ndr, name, "epm_rhs_ncadg");
     286           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     287           0 :         ndr->depth++;
     288           0 :         ndr_print_uint16(ndr, "minor_version", r->minor_version);
     289           0 :         ndr->depth--;
     290             : }
     291             : 
     292       91474 : static enum ndr_err_code ndr_push_epm_rhs_ncacn(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_ncacn *r)
     293             : {
     294       91474 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     295       91474 :         if (ndr_flags & NDR_SCALARS) {
     296       91474 :                 NDR_CHECK(ndr_push_align(ndr, 2));
     297       91474 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minor_version));
     298       91474 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
     299             :         }
     300       90990 :         if (ndr_flags & NDR_BUFFERS) {
     301             :         }
     302       91474 :         return NDR_ERR_SUCCESS;
     303             : }
     304             : 
     305      276040 : static enum ndr_err_code ndr_pull_epm_rhs_ncacn(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_ncacn *r)
     306             : {
     307      276040 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     308      276040 :         if (ndr_flags & NDR_SCALARS) {
     309      276040 :                 NDR_CHECK(ndr_pull_align(ndr, 2));
     310      276040 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minor_version));
     311      276040 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
     312             :         }
     313      275796 :         if (ndr_flags & NDR_BUFFERS) {
     314             :         }
     315      276040 :         return NDR_ERR_SUCCESS;
     316             : }
     317             : 
     318         506 : _PUBLIC_ void ndr_print_epm_rhs_ncacn(struct ndr_print *ndr, const char *name, const struct epm_rhs_ncacn *r)
     319             : {
     320         506 :         ndr_print_struct(ndr, name, "epm_rhs_ncacn");
     321         506 :         if (r == NULL) { ndr_print_null(ndr); return; }
     322         506 :         ndr->depth++;
     323         506 :         ndr_print_uint16(ndr, "minor_version", r->minor_version);
     324         506 :         ndr->depth--;
     325             : }
     326             : 
     327      192016 : static enum ndr_err_code ndr_push_epm_rhs_uuid(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_uuid *r)
     328             : {
     329      192016 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     330      192016 :         if (ndr_flags & NDR_SCALARS) {
     331      192016 :                 NDR_CHECK(ndr_push_align(ndr, 4));
     332             :                 {
     333      192016 :                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
     334      192016 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
     335      192016 :                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->unknown));
     336      192016 :                         ndr->flags = _flags_save_DATA_BLOB;
     337             :                 }
     338      192016 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
     339             :         }
     340      191016 :         if (ndr_flags & NDR_BUFFERS) {
     341             :         }
     342      192016 :         return NDR_ERR_SUCCESS;
     343             : }
     344             : 
     345      555356 : static enum ndr_err_code ndr_pull_epm_rhs_uuid(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_uuid *r)
     346             : {
     347      555356 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     348      555356 :         if (ndr_flags & NDR_SCALARS) {
     349      555356 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
     350             :                 {
     351      555356 :                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
     352      555356 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
     353      555356 :                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->unknown));
     354      555356 :                         ndr->flags = _flags_save_DATA_BLOB;
     355             :                 }
     356      555356 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
     357             :         }
     358      554852 :         if (ndr_flags & NDR_BUFFERS) {
     359             :         }
     360      555356 :         return NDR_ERR_SUCCESS;
     361             : }
     362             : 
     363        1108 : _PUBLIC_ void ndr_print_epm_rhs_uuid(struct ndr_print *ndr, const char *name, const struct epm_rhs_uuid *r)
     364             : {
     365        1108 :         ndr_print_struct(ndr, name, "epm_rhs_uuid");
     366        1108 :         if (r == NULL) { ndr_print_null(ndr); return; }
     367        1108 :         ndr->depth++;
     368             :         {
     369        1108 :                 uint32_t _flags_save_DATA_BLOB = ndr->flags;
     370        1108 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
     371        1108 :                 ndr_print_DATA_BLOB(ndr, "unknown", r->unknown);
     372        1108 :                 ndr->flags = _flags_save_DATA_BLOB;
     373             :         }
     374        1108 :         ndr->depth--;
     375             : }
     376             : 
     377           0 : static enum ndr_err_code ndr_push_epm_rhs_ipx(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_ipx *r)
     378             : {
     379           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     380           0 :         if (ndr_flags & NDR_SCALARS) {
     381           0 :                 NDR_CHECK(ndr_push_align(ndr, 1));
     382           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
     383             :         }
     384           0 :         if (ndr_flags & NDR_BUFFERS) {
     385             :         }
     386           0 :         return NDR_ERR_SUCCESS;
     387             : }
     388             : 
     389           0 : static enum ndr_err_code ndr_pull_epm_rhs_ipx(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_ipx *r)
     390             : {
     391           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     392           0 :         if (ndr_flags & NDR_SCALARS) {
     393           0 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
     394           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
     395             :         }
     396           0 :         if (ndr_flags & NDR_BUFFERS) {
     397             :         }
     398           0 :         return NDR_ERR_SUCCESS;
     399             : }
     400             : 
     401           0 : _PUBLIC_ void ndr_print_epm_rhs_ipx(struct ndr_print *ndr, const char *name, const struct epm_rhs_ipx *r)
     402             : {
     403           0 :         ndr_print_struct(ndr, name, "epm_rhs_ipx");
     404           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     405           0 :         ndr->depth++;
     406           0 :         ndr->depth--;
     407             : }
     408             : 
     409       68500 : static enum ndr_err_code ndr_push_epm_rhs_smb(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_smb *r)
     410             : {
     411       68500 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     412       68500 :         if (ndr_flags & NDR_SCALARS) {
     413       68500 :                 NDR_CHECK(ndr_push_align(ndr, 4));
     414             :                 {
     415       68500 :                         uint32_t _flags_save_string = ndr->flags;
     416       68500 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
     417       68500 :                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->unc));
     418       68500 :                         ndr->flags = _flags_save_string;
     419             :                 }
     420       68500 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
     421             :         }
     422       68500 :         if (ndr_flags & NDR_BUFFERS) {
     423             :         }
     424       68500 :         return NDR_ERR_SUCCESS;
     425             : }
     426             : 
     427      265812 : static enum ndr_err_code ndr_pull_epm_rhs_smb(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_smb *r)
     428             : {
     429      265812 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     430      265812 :         if (ndr_flags & NDR_SCALARS) {
     431      265812 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
     432             :                 {
     433      265812 :                         uint32_t _flags_save_string = ndr->flags;
     434      265812 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
     435      265812 :                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->unc));
     436      265812 :                         ndr->flags = _flags_save_string;
     437             :                 }
     438      265812 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
     439             :         }
     440      265812 :         if (ndr_flags & NDR_BUFFERS) {
     441             :         }
     442      265812 :         return NDR_ERR_SUCCESS;
     443             : }
     444             : 
     445         266 : _PUBLIC_ void ndr_print_epm_rhs_smb(struct ndr_print *ndr, const char *name, const struct epm_rhs_smb *r)
     446             : {
     447         266 :         ndr_print_struct(ndr, name, "epm_rhs_smb");
     448         266 :         if (r == NULL) { ndr_print_null(ndr); return; }
     449         266 :         ndr->depth++;
     450             :         {
     451         266 :                 uint32_t _flags_save_string = ndr->flags;
     452         266 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
     453         266 :                 ndr_print_string(ndr, "unc", r->unc);
     454         266 :                 ndr->flags = _flags_save_string;
     455             :         }
     456         266 :         ndr->depth--;
     457             : }
     458             : 
     459        4534 : static enum ndr_err_code ndr_push_epm_rhs_named_pipe(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_named_pipe *r)
     460             : {
     461        4534 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     462        4534 :         if (ndr_flags & NDR_SCALARS) {
     463        4534 :                 NDR_CHECK(ndr_push_align(ndr, 4));
     464             :                 {
     465        4534 :                         uint32_t _flags_save_string = ndr->flags;
     466        4534 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
     467        4534 :                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->path));
     468        4534 :                         ndr->flags = _flags_save_string;
     469             :                 }
     470        4534 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
     471             :         }
     472        4518 :         if (ndr_flags & NDR_BUFFERS) {
     473             :         }
     474        4534 :         return NDR_ERR_SUCCESS;
     475             : }
     476             : 
     477        1638 : static enum ndr_err_code ndr_pull_epm_rhs_named_pipe(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_named_pipe *r)
     478             : {
     479        1638 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     480        1638 :         if (ndr_flags & NDR_SCALARS) {
     481        1638 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
     482             :                 {
     483        1638 :                         uint32_t _flags_save_string = ndr->flags;
     484        1638 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
     485        1638 :                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->path));
     486        1638 :                         ndr->flags = _flags_save_string;
     487             :                 }
     488        1638 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
     489             :         }
     490        1630 :         if (ndr_flags & NDR_BUFFERS) {
     491             :         }
     492        1638 :         return NDR_ERR_SUCCESS;
     493             : }
     494             : 
     495          48 : _PUBLIC_ void ndr_print_epm_rhs_named_pipe(struct ndr_print *ndr, const char *name, const struct epm_rhs_named_pipe *r)
     496             : {
     497          48 :         ndr_print_struct(ndr, name, "epm_rhs_named_pipe");
     498          48 :         if (r == NULL) { ndr_print_null(ndr); return; }
     499          48 :         ndr->depth++;
     500             :         {
     501          48 :                 uint32_t _flags_save_string = ndr->flags;
     502          48 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
     503          48 :                 ndr_print_string(ndr, "path", r->path);
     504          48 :                 ndr->flags = _flags_save_string;
     505             :         }
     506          48 :         ndr->depth--;
     507             : }
     508             : 
     509       68500 : static enum ndr_err_code ndr_push_epm_rhs_netbios(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_netbios *r)
     510             : {
     511       68500 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     512       68500 :         if (ndr_flags & NDR_SCALARS) {
     513       68500 :                 NDR_CHECK(ndr_push_align(ndr, 4));
     514             :                 {
     515       68500 :                         uint32_t _flags_save_string = ndr->flags;
     516       68500 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
     517       68500 :                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
     518       68500 :                         ndr->flags = _flags_save_string;
     519             :                 }
     520       68500 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
     521             :         }
     522       68500 :         if (ndr_flags & NDR_BUFFERS) {
     523             :         }
     524       68500 :         return NDR_ERR_SUCCESS;
     525             : }
     526             : 
     527      265812 : static enum ndr_err_code ndr_pull_epm_rhs_netbios(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_netbios *r)
     528             : {
     529      265812 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     530      265812 :         if (ndr_flags & NDR_SCALARS) {
     531      265812 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
     532             :                 {
     533      265812 :                         uint32_t _flags_save_string = ndr->flags;
     534      265812 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
     535      265812 :                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
     536      265812 :                         ndr->flags = _flags_save_string;
     537             :                 }
     538      265812 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
     539             :         }
     540      265812 :         if (ndr_flags & NDR_BUFFERS) {
     541             :         }
     542      265812 :         return NDR_ERR_SUCCESS;
     543             : }
     544             : 
     545         266 : _PUBLIC_ void ndr_print_epm_rhs_netbios(struct ndr_print *ndr, const char *name, const struct epm_rhs_netbios *r)
     546             : {
     547         266 :         ndr_print_struct(ndr, name, "epm_rhs_netbios");
     548         266 :         if (r == NULL) { ndr_print_null(ndr); return; }
     549         266 :         ndr->depth++;
     550             :         {
     551         266 :                 uint32_t _flags_save_string = ndr->flags;
     552         266 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
     553         266 :                 ndr_print_string(ndr, "name", r->name);
     554         266 :                 ndr->flags = _flags_save_string;
     555             :         }
     556         266 :         ndr->depth--;
     557             : }
     558             : 
     559           0 : static enum ndr_err_code ndr_push_epm_rhs_netbeui(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_netbeui *r)
     560             : {
     561           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     562           0 :         if (ndr_flags & NDR_SCALARS) {
     563           0 :                 NDR_CHECK(ndr_push_align(ndr, 1));
     564           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
     565             :         }
     566           0 :         if (ndr_flags & NDR_BUFFERS) {
     567             :         }
     568           0 :         return NDR_ERR_SUCCESS;
     569             : }
     570             : 
     571           0 : static enum ndr_err_code ndr_pull_epm_rhs_netbeui(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_netbeui *r)
     572             : {
     573           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     574           0 :         if (ndr_flags & NDR_SCALARS) {
     575           0 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
     576           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
     577             :         }
     578           0 :         if (ndr_flags & NDR_BUFFERS) {
     579             :         }
     580           0 :         return NDR_ERR_SUCCESS;
     581             : }
     582             : 
     583           0 : _PUBLIC_ void ndr_print_epm_rhs_netbeui(struct ndr_print *ndr, const char *name, const struct epm_rhs_netbeui *r)
     584             : {
     585           0 :         ndr_print_struct(ndr, name, "epm_rhs_netbeui");
     586           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     587           0 :         ndr->depth++;
     588           0 :         ndr->depth--;
     589             : }
     590             : 
     591           0 : static enum ndr_err_code ndr_push_epm_rhs_spx(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_spx *r)
     592             : {
     593           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     594           0 :         if (ndr_flags & NDR_SCALARS) {
     595           0 :                 NDR_CHECK(ndr_push_align(ndr, 1));
     596           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
     597             :         }
     598           0 :         if (ndr_flags & NDR_BUFFERS) {
     599             :         }
     600           0 :         return NDR_ERR_SUCCESS;
     601             : }
     602             : 
     603           0 : static enum ndr_err_code ndr_pull_epm_rhs_spx(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_spx *r)
     604             : {
     605           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     606           0 :         if (ndr_flags & NDR_SCALARS) {
     607           0 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
     608           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
     609             :         }
     610           0 :         if (ndr_flags & NDR_BUFFERS) {
     611             :         }
     612           0 :         return NDR_ERR_SUCCESS;
     613             : }
     614             : 
     615           0 : _PUBLIC_ void ndr_print_epm_rhs_spx(struct ndr_print *ndr, const char *name, const struct epm_rhs_spx *r)
     616             : {
     617           0 :         ndr_print_struct(ndr, name, "epm_rhs_spx");
     618           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     619           0 :         ndr->depth++;
     620           0 :         ndr->depth--;
     621             : }
     622             : 
     623           0 : static enum ndr_err_code ndr_push_epm_rhs_nb_ipx(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_nb_ipx *r)
     624             : {
     625           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     626           0 :         if (ndr_flags & NDR_SCALARS) {
     627           0 :                 NDR_CHECK(ndr_push_align(ndr, 1));
     628           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
     629             :         }
     630           0 :         if (ndr_flags & NDR_BUFFERS) {
     631             :         }
     632           0 :         return NDR_ERR_SUCCESS;
     633             : }
     634             : 
     635           0 : static enum ndr_err_code ndr_pull_epm_rhs_nb_ipx(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_nb_ipx *r)
     636             : {
     637           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     638           0 :         if (ndr_flags & NDR_SCALARS) {
     639           0 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
     640           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
     641             :         }
     642           0 :         if (ndr_flags & NDR_BUFFERS) {
     643             :         }
     644           0 :         return NDR_ERR_SUCCESS;
     645             : }
     646             : 
     647           0 : _PUBLIC_ void ndr_print_epm_rhs_nb_ipx(struct ndr_print *ndr, const char *name, const struct epm_rhs_nb_ipx *r)
     648             : {
     649           0 :         ndr_print_struct(ndr, name, "epm_rhs_nb_ipx");
     650           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     651           0 :         ndr->depth++;
     652           0 :         ndr->depth--;
     653             : }
     654             : 
     655        1322 : static enum ndr_err_code ndr_push_epm_rhs_http(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_http *r)
     656             : {
     657        1322 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     658        1322 :         if (ndr_flags & NDR_SCALARS) {
     659        1322 :                 NDR_CHECK(ndr_push_align(ndr, 2));
     660        1322 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->port));
     661        1322 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
     662             :         }
     663        1322 :         if (ndr_flags & NDR_BUFFERS) {
     664             :         }
     665        1322 :         return NDR_ERR_SUCCESS;
     666             : }
     667             : 
     668         292 : static enum ndr_err_code ndr_pull_epm_rhs_http(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_http *r)
     669             : {
     670         292 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     671         292 :         if (ndr_flags & NDR_SCALARS) {
     672         292 :                 NDR_CHECK(ndr_pull_align(ndr, 2));
     673         292 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->port));
     674         292 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
     675             :         }
     676         292 :         if (ndr_flags & NDR_BUFFERS) {
     677             :         }
     678         292 :         return NDR_ERR_SUCCESS;
     679             : }
     680             : 
     681          50 : _PUBLIC_ void ndr_print_epm_rhs_http(struct ndr_print *ndr, const char *name, const struct epm_rhs_http *r)
     682             : {
     683          50 :         ndr_print_struct(ndr, name, "epm_rhs_http");
     684          50 :         if (r == NULL) { ndr_print_null(ndr); return; }
     685          50 :         ndr->depth++;
     686          50 :         ndr_print_uint16(ndr, "port", r->port);
     687          50 :         ndr->depth--;
     688             : }
     689             : 
     690           0 : static enum ndr_err_code ndr_push_epm_rhs_unix_ds(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_unix_ds *r)
     691             : {
     692           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     693           0 :         if (ndr_flags & NDR_SCALARS) {
     694           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
     695             :                 {
     696           0 :                         uint32_t _flags_save_string = ndr->flags;
     697           0 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
     698           0 :                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->path));
     699           0 :                         ndr->flags = _flags_save_string;
     700             :                 }
     701           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
     702             :         }
     703           0 :         if (ndr_flags & NDR_BUFFERS) {
     704             :         }
     705           0 :         return NDR_ERR_SUCCESS;
     706             : }
     707             : 
     708           0 : static enum ndr_err_code ndr_pull_epm_rhs_unix_ds(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_unix_ds *r)
     709             : {
     710           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     711           0 :         if (ndr_flags & NDR_SCALARS) {
     712           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
     713             :                 {
     714           0 :                         uint32_t _flags_save_string = ndr->flags;
     715           0 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
     716           0 :                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->path));
     717           0 :                         ndr->flags = _flags_save_string;
     718             :                 }
     719           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
     720             :         }
     721           0 :         if (ndr_flags & NDR_BUFFERS) {
     722             :         }
     723           0 :         return NDR_ERR_SUCCESS;
     724             : }
     725             : 
     726           0 : _PUBLIC_ void ndr_print_epm_rhs_unix_ds(struct ndr_print *ndr, const char *name, const struct epm_rhs_unix_ds *r)
     727             : {
     728           0 :         ndr_print_struct(ndr, name, "epm_rhs_unix_ds");
     729           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     730           0 :         ndr->depth++;
     731             :         {
     732           0 :                 uint32_t _flags_save_string = ndr->flags;
     733           0 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
     734           0 :                 ndr_print_string(ndr, "path", r->path);
     735           0 :                 ndr->flags = _flags_save_string;
     736             :         }
     737           0 :         ndr->depth--;
     738             : }
     739             : 
     740           0 : static enum ndr_err_code ndr_push_epm_rhs_null(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_null *r)
     741             : {
     742           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     743           0 :         if (ndr_flags & NDR_SCALARS) {
     744           0 :                 NDR_CHECK(ndr_push_align(ndr, 1));
     745           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
     746             :         }
     747           0 :         if (ndr_flags & NDR_BUFFERS) {
     748             :         }
     749           0 :         return NDR_ERR_SUCCESS;
     750             : }
     751             : 
     752           0 : static enum ndr_err_code ndr_pull_epm_rhs_null(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_null *r)
     753             : {
     754           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     755           0 :         if (ndr_flags & NDR_SCALARS) {
     756           0 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
     757           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
     758             :         }
     759           0 :         if (ndr_flags & NDR_BUFFERS) {
     760             :         }
     761           0 :         return NDR_ERR_SUCCESS;
     762             : }
     763             : 
     764           0 : _PUBLIC_ void ndr_print_epm_rhs_null(struct ndr_print *ndr, const char *name, const struct epm_rhs_null *r)
     765             : {
     766           0 :         ndr_print_struct(ndr, name, "epm_rhs_null");
     767           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     768           0 :         ndr->depth++;
     769           0 :         ndr->depth--;
     770             : }
     771             : 
     772        4534 : static enum ndr_err_code ndr_push_epm_rhs_ncalrpc(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_ncalrpc *r)
     773             : {
     774        4534 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     775        4534 :         if (ndr_flags & NDR_SCALARS) {
     776        4534 :                 NDR_CHECK(ndr_push_align(ndr, 2));
     777        4534 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minor_version));
     778        4534 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
     779             :         }
     780        4518 :         if (ndr_flags & NDR_BUFFERS) {
     781             :         }
     782        4534 :         return NDR_ERR_SUCCESS;
     783             : }
     784             : 
     785        1638 : static enum ndr_err_code ndr_pull_epm_rhs_ncalrpc(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_ncalrpc *r)
     786             : {
     787        1638 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     788        1638 :         if (ndr_flags & NDR_SCALARS) {
     789        1638 :                 NDR_CHECK(ndr_pull_align(ndr, 2));
     790        1638 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minor_version));
     791        1638 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
     792             :         }
     793        1630 :         if (ndr_flags & NDR_BUFFERS) {
     794             :         }
     795        1638 :         return NDR_ERR_SUCCESS;
     796             : }
     797             : 
     798          48 : _PUBLIC_ void ndr_print_epm_rhs_ncalrpc(struct ndr_print *ndr, const char *name, const struct epm_rhs_ncalrpc *r)
     799             : {
     800          48 :         ndr_print_struct(ndr, name, "epm_rhs_ncalrpc");
     801          48 :         if (r == NULL) { ndr_print_null(ndr); return; }
     802          48 :         ndr->depth++;
     803          48 :         ndr_print_uint16(ndr, "minor_version", r->minor_version);
     804          48 :         ndr->depth--;
     805             : }
     806             : 
     807           0 : static enum ndr_err_code ndr_push_epm_rhs_appletalk(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_appletalk *r)
     808             : {
     809           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     810           0 :         if (ndr_flags & NDR_SCALARS) {
     811           0 :                 NDR_CHECK(ndr_push_align(ndr, 1));
     812           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
     813             :         }
     814           0 :         if (ndr_flags & NDR_BUFFERS) {
     815             :         }
     816           0 :         return NDR_ERR_SUCCESS;
     817             : }
     818             : 
     819           0 : static enum ndr_err_code ndr_pull_epm_rhs_appletalk(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_appletalk *r)
     820             : {
     821           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     822           0 :         if (ndr_flags & NDR_SCALARS) {
     823           0 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
     824           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
     825             :         }
     826           0 :         if (ndr_flags & NDR_BUFFERS) {
     827             :         }
     828           0 :         return NDR_ERR_SUCCESS;
     829             : }
     830             : 
     831           0 : _PUBLIC_ void ndr_print_epm_rhs_appletalk(struct ndr_print *ndr, const char *name, const struct epm_rhs_appletalk *r)
     832             : {
     833           0 :         ndr_print_struct(ndr, name, "epm_rhs_appletalk");
     834           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     835           0 :         ndr->depth++;
     836           0 :         ndr->depth--;
     837             : }
     838             : 
     839           0 : static enum ndr_err_code ndr_push_epm_rhs_atalk_stream(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_atalk_stream *r)
     840             : {
     841           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     842           0 :         if (ndr_flags & NDR_SCALARS) {
     843           0 :                 NDR_CHECK(ndr_push_align(ndr, 1));
     844           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
     845             :         }
     846           0 :         if (ndr_flags & NDR_BUFFERS) {
     847             :         }
     848           0 :         return NDR_ERR_SUCCESS;
     849             : }
     850             : 
     851           0 : static enum ndr_err_code ndr_pull_epm_rhs_atalk_stream(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_atalk_stream *r)
     852             : {
     853           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     854           0 :         if (ndr_flags & NDR_SCALARS) {
     855           0 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
     856           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
     857             :         }
     858           0 :         if (ndr_flags & NDR_BUFFERS) {
     859             :         }
     860           0 :         return NDR_ERR_SUCCESS;
     861             : }
     862             : 
     863           0 : _PUBLIC_ void ndr_print_epm_rhs_atalk_stream(struct ndr_print *ndr, const char *name, const struct epm_rhs_atalk_stream *r)
     864             : {
     865           0 :         ndr_print_struct(ndr, name, "epm_rhs_atalk_stream");
     866           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     867           0 :         ndr->depth++;
     868           0 :         ndr->depth--;
     869             : }
     870             : 
     871           0 : static enum ndr_err_code ndr_push_epm_rhs_atalk_datagram(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_atalk_datagram *r)
     872             : {
     873           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     874           0 :         if (ndr_flags & NDR_SCALARS) {
     875           0 :                 NDR_CHECK(ndr_push_align(ndr, 1));
     876           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
     877             :         }
     878           0 :         if (ndr_flags & NDR_BUFFERS) {
     879             :         }
     880           0 :         return NDR_ERR_SUCCESS;
     881             : }
     882             : 
     883           0 : static enum ndr_err_code ndr_pull_epm_rhs_atalk_datagram(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_atalk_datagram *r)
     884             : {
     885           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     886           0 :         if (ndr_flags & NDR_SCALARS) {
     887           0 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
     888           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
     889             :         }
     890           0 :         if (ndr_flags & NDR_BUFFERS) {
     891             :         }
     892           0 :         return NDR_ERR_SUCCESS;
     893             : }
     894             : 
     895           0 : _PUBLIC_ void ndr_print_epm_rhs_atalk_datagram(struct ndr_print *ndr, const char *name, const struct epm_rhs_atalk_datagram *r)
     896             : {
     897           0 :         ndr_print_struct(ndr, name, "epm_rhs_atalk_datagram");
     898           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     899           0 :         ndr->depth++;
     900           0 :         ndr->depth--;
     901             : }
     902             : 
     903           0 : static enum ndr_err_code ndr_push_epm_rhs_vines_spp(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_vines_spp *r)
     904             : {
     905           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     906           0 :         if (ndr_flags & NDR_SCALARS) {
     907           0 :                 NDR_CHECK(ndr_push_align(ndr, 2));
     908           0 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->port));
     909           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
     910             :         }
     911           0 :         if (ndr_flags & NDR_BUFFERS) {
     912             :         }
     913           0 :         return NDR_ERR_SUCCESS;
     914             : }
     915             : 
     916           0 : static enum ndr_err_code ndr_pull_epm_rhs_vines_spp(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_vines_spp *r)
     917             : {
     918           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     919           0 :         if (ndr_flags & NDR_SCALARS) {
     920           0 :                 NDR_CHECK(ndr_pull_align(ndr, 2));
     921           0 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->port));
     922           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
     923             :         }
     924           0 :         if (ndr_flags & NDR_BUFFERS) {
     925             :         }
     926           0 :         return NDR_ERR_SUCCESS;
     927             : }
     928             : 
     929           0 : _PUBLIC_ void ndr_print_epm_rhs_vines_spp(struct ndr_print *ndr, const char *name, const struct epm_rhs_vines_spp *r)
     930             : {
     931           0 :         ndr_print_struct(ndr, name, "epm_rhs_vines_spp");
     932           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     933           0 :         ndr->depth++;
     934           0 :         ndr_print_uint16(ndr, "port", r->port);
     935           0 :         ndr->depth--;
     936             : }
     937             : 
     938           0 : static enum ndr_err_code ndr_push_epm_rhs_vines_ipc(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_vines_ipc *r)
     939             : {
     940           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     941           0 :         if (ndr_flags & NDR_SCALARS) {
     942           0 :                 NDR_CHECK(ndr_push_align(ndr, 2));
     943           0 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->port));
     944           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
     945             :         }
     946           0 :         if (ndr_flags & NDR_BUFFERS) {
     947             :         }
     948           0 :         return NDR_ERR_SUCCESS;
     949             : }
     950             : 
     951           0 : static enum ndr_err_code ndr_pull_epm_rhs_vines_ipc(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_vines_ipc *r)
     952             : {
     953           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     954           0 :         if (ndr_flags & NDR_SCALARS) {
     955           0 :                 NDR_CHECK(ndr_pull_align(ndr, 2));
     956           0 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->port));
     957           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
     958             :         }
     959           0 :         if (ndr_flags & NDR_BUFFERS) {
     960             :         }
     961           0 :         return NDR_ERR_SUCCESS;
     962             : }
     963             : 
     964           0 : _PUBLIC_ void ndr_print_epm_rhs_vines_ipc(struct ndr_print *ndr, const char *name, const struct epm_rhs_vines_ipc *r)
     965             : {
     966           0 :         ndr_print_struct(ndr, name, "epm_rhs_vines_ipc");
     967           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     968           0 :         ndr->depth++;
     969           0 :         ndr_print_uint16(ndr, "port", r->port);
     970           0 :         ndr->depth--;
     971             : }
     972             : 
     973           0 : static enum ndr_err_code ndr_push_epm_rhs_streettalk(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_streettalk *r)
     974             : {
     975           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     976           0 :         if (ndr_flags & NDR_SCALARS) {
     977           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
     978             :                 {
     979           0 :                         uint32_t _flags_save_string = ndr->flags;
     980           0 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
     981           0 :                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->streettalk));
     982           0 :                         ndr->flags = _flags_save_string;
     983             :                 }
     984           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
     985             :         }
     986           0 :         if (ndr_flags & NDR_BUFFERS) {
     987             :         }
     988           0 :         return NDR_ERR_SUCCESS;
     989             : }
     990             : 
     991           0 : static enum ndr_err_code ndr_pull_epm_rhs_streettalk(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_streettalk *r)
     992             : {
     993           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     994           0 :         if (ndr_flags & NDR_SCALARS) {
     995           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
     996             :                 {
     997           0 :                         uint32_t _flags_save_string = ndr->flags;
     998           0 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
     999           0 :                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->streettalk));
    1000           0 :                         ndr->flags = _flags_save_string;
    1001             :                 }
    1002           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    1003             :         }
    1004           0 :         if (ndr_flags & NDR_BUFFERS) {
    1005             :         }
    1006           0 :         return NDR_ERR_SUCCESS;
    1007             : }
    1008             : 
    1009           0 : _PUBLIC_ void ndr_print_epm_rhs_streettalk(struct ndr_print *ndr, const char *name, const struct epm_rhs_streettalk *r)
    1010             : {
    1011           0 :         ndr_print_struct(ndr, name, "epm_rhs_streettalk");
    1012           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1013           0 :         ndr->depth++;
    1014             :         {
    1015           0 :                 uint32_t _flags_save_string = ndr->flags;
    1016           0 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
    1017           0 :                 ndr_print_string(ndr, "streettalk", r->streettalk);
    1018           0 :                 ndr->flags = _flags_save_string;
    1019             :         }
    1020           0 :         ndr->depth--;
    1021             : }
    1022             : 
    1023      475506 : static enum ndr_err_code ndr_push_epm_rhs(struct ndr_push *ndr, int ndr_flags, const union epm_rhs *r)
    1024             : {
    1025             :         uint32_t level;
    1026             :         {
    1027      475506 :                 uint32_t _flags_save_UNION = ndr->flags;
    1028      475506 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
    1029      475506 :                 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1030      475506 :                 if (ndr_flags & NDR_SCALARS) {
    1031             :                         /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
    1032      475506 :                         NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
    1033      475506 :                         NDR_CHECK(ndr_push_union_align(ndr, 4));
    1034      475506 :                         switch (level) {
    1035           0 :                                 case EPM_PROTOCOL_DNET_NSP: {
    1036           0 :                                         NDR_CHECK(ndr_push_epm_rhs_dnet_nsp(ndr, NDR_SCALARS, &r->dnet_nsp));
    1037           0 :                                 break; }
    1038             : 
    1039           0 :                                 case EPM_PROTOCOL_OSI_TP4: {
    1040           0 :                                         NDR_CHECK(ndr_push_epm_rhs_osi_tp4(ndr, NDR_SCALARS, &r->osi_tp4));
    1041           0 :                                 break; }
    1042             : 
    1043           0 :                                 case EPM_PROTOCOL_OSI_CLNS: {
    1044           0 :                                         NDR_CHECK(ndr_push_epm_rhs_osi_clns(ndr, NDR_SCALARS, &r->osi_clns));
    1045           0 :                                 break; }
    1046             : 
    1047       20596 :                                 case EPM_PROTOCOL_TCP: {
    1048       20596 :                                         NDR_CHECK(ndr_push_epm_rhs_tcp(ndr, NDR_SCALARS, &r->tcp));
    1049       20112 :                                 break; }
    1050             : 
    1051        1056 :                                 case EPM_PROTOCOL_UDP: {
    1052        1056 :                                         NDR_CHECK(ndr_push_epm_rhs_udp(ndr, NDR_SCALARS, &r->udp));
    1053        1056 :                                 break; }
    1054             : 
    1055       22974 :                                 case EPM_PROTOCOL_IP: {
    1056       22974 :                                         NDR_CHECK(ndr_push_epm_rhs_ip(ndr, NDR_SCALARS, &r->ip));
    1057       22490 :                                 break; }
    1058             : 
    1059           0 :                                 case EPM_PROTOCOL_NCADG: {
    1060           0 :                                         NDR_CHECK(ndr_push_epm_rhs_ncadg(ndr, NDR_SCALARS, &r->ncadg));
    1061           0 :                                 break; }
    1062             : 
    1063       91474 :                                 case EPM_PROTOCOL_NCACN: {
    1064       91474 :                                         NDR_CHECK(ndr_push_epm_rhs_ncacn(ndr, NDR_SCALARS, &r->ncacn));
    1065       90990 :                                 break; }
    1066             : 
    1067        4534 :                                 case EPM_PROTOCOL_NCALRPC: {
    1068        4534 :                                         NDR_CHECK(ndr_push_epm_rhs_ncalrpc(ndr, NDR_SCALARS, &r->ncalrpc));
    1069        4518 :                                 break; }
    1070             : 
    1071      192016 :                                 case EPM_PROTOCOL_UUID: {
    1072      192016 :                                         NDR_CHECK(ndr_push_epm_rhs_uuid(ndr, NDR_SCALARS, &r->uuid));
    1073      191016 :                                 break; }
    1074             : 
    1075           0 :                                 case EPM_PROTOCOL_IPX: {
    1076           0 :                                         NDR_CHECK(ndr_push_epm_rhs_ipx(ndr, NDR_SCALARS, &r->ipx));
    1077           0 :                                 break; }
    1078             : 
    1079       68500 :                                 case EPM_PROTOCOL_SMB: {
    1080       68500 :                                         NDR_CHECK(ndr_push_epm_rhs_smb(ndr, NDR_SCALARS, &r->smb));
    1081       68500 :                                 break; }
    1082             : 
    1083        4534 :                                 case EPM_PROTOCOL_NAMED_PIPE: {
    1084        4534 :                                         NDR_CHECK(ndr_push_epm_rhs_named_pipe(ndr, NDR_SCALARS, &r->named_pipe));
    1085        4518 :                                 break; }
    1086             : 
    1087       68500 :                                 case EPM_PROTOCOL_NETBIOS: {
    1088       68500 :                                         NDR_CHECK(ndr_push_epm_rhs_netbios(ndr, NDR_SCALARS, &r->netbios));
    1089       68500 :                                 break; }
    1090             : 
    1091           0 :                                 case EPM_PROTOCOL_NETBEUI: {
    1092           0 :                                         NDR_CHECK(ndr_push_epm_rhs_netbeui(ndr, NDR_SCALARS, &r->netbeui));
    1093           0 :                                 break; }
    1094             : 
    1095           0 :                                 case EPM_PROTOCOL_SPX: {
    1096           0 :                                         NDR_CHECK(ndr_push_epm_rhs_spx(ndr, NDR_SCALARS, &r->spx));
    1097           0 :                                 break; }
    1098             : 
    1099           0 :                                 case EPM_PROTOCOL_NB_IPX: {
    1100           0 :                                         NDR_CHECK(ndr_push_epm_rhs_nb_ipx(ndr, NDR_SCALARS, &r->nb_ipx));
    1101           0 :                                 break; }
    1102             : 
    1103           0 :                                 case EPM_PROTOCOL_DSP: {
    1104           0 :                                         NDR_CHECK(ndr_push_epm_rhs_atalk_stream(ndr, NDR_SCALARS, &r->atalk_stream));
    1105           0 :                                 break; }
    1106             : 
    1107           0 :                                 case EPM_PROTOCOL_DDP: {
    1108           0 :                                         NDR_CHECK(ndr_push_epm_rhs_atalk_datagram(ndr, NDR_SCALARS, &r->atalk_datagram));
    1109           0 :                                 break; }
    1110             : 
    1111           0 :                                 case EPM_PROTOCOL_APPLETALK: {
    1112           0 :                                         NDR_CHECK(ndr_push_epm_rhs_appletalk(ndr, NDR_SCALARS, &r->appletalk));
    1113           0 :                                 break; }
    1114             : 
    1115           0 :                                 case EPM_PROTOCOL_VINES_SPP: {
    1116           0 :                                         NDR_CHECK(ndr_push_epm_rhs_vines_spp(ndr, NDR_SCALARS, &r->vines_spp));
    1117           0 :                                 break; }
    1118             : 
    1119           0 :                                 case EPM_PROTOCOL_VINES_IPC: {
    1120           0 :                                         NDR_CHECK(ndr_push_epm_rhs_vines_ipc(ndr, NDR_SCALARS, &r->vines_ipc));
    1121           0 :                                 break; }
    1122             : 
    1123           0 :                                 case EPM_PROTOCOL_STREETTALK: {
    1124           0 :                                         NDR_CHECK(ndr_push_epm_rhs_streettalk(ndr, NDR_SCALARS, &r->streettalk));
    1125           0 :                                 break; }
    1126             : 
    1127        1322 :                                 case EPM_PROTOCOL_HTTP: {
    1128        1322 :                                         NDR_CHECK(ndr_push_epm_rhs_http(ndr, NDR_SCALARS, &r->http));
    1129        1322 :                                 break; }
    1130             : 
    1131           0 :                                 case EPM_PROTOCOL_UNIX_DS: {
    1132           0 :                                         NDR_CHECK(ndr_push_epm_rhs_unix_ds(ndr, NDR_SCALARS, &r->unix_ds));
    1133           0 :                                 break; }
    1134             : 
    1135           0 :                                 case EPM_PROTOCOL_NULL: {
    1136           0 :                                         NDR_CHECK(ndr_push_epm_rhs_null(ndr, NDR_SCALARS, &r->null));
    1137           0 :                                 break; }
    1138             : 
    1139           0 :                                 default: {
    1140             :                                         {
    1141           0 :                                                 uint32_t _flags_save_DATA_BLOB = ndr->flags;
    1142           0 :                                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    1143           0 :                                                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->unknown));
    1144           0 :                                                 ndr->flags = _flags_save_DATA_BLOB;
    1145             :                                         }
    1146           0 :                                 break; }
    1147             : 
    1148             :                         }
    1149           0 :                 }
    1150      475506 :                 ndr->flags = _flags_save_UNION;
    1151             :         }
    1152      475506 :         return NDR_ERR_SUCCESS;
    1153             : }
    1154             : 
    1155     1386752 : static enum ndr_err_code ndr_pull_epm_rhs(struct ndr_pull *ndr, int ndr_flags, union epm_rhs *r)
    1156             : {
    1157             :         uint32_t level;
    1158             :         {
    1159     1386752 :                 uint32_t _flags_save_UNION = ndr->flags;
    1160     1386752 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
    1161     1386752 :                 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1162     1386752 :                 if (ndr_flags & NDR_SCALARS) {
    1163             :                         /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
    1164     1386752 :                         NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
    1165     1386752 :                         NDR_CHECK(ndr_pull_union_align(ndr, 4));
    1166     1386752 :                         switch (level) {
    1167           0 :                                 case EPM_PROTOCOL_DNET_NSP: {
    1168           0 :                                         NDR_CHECK(ndr_pull_epm_rhs_dnet_nsp(ndr, NDR_SCALARS, &r->dnet_nsp));
    1169           0 :                                 break; }
    1170             : 
    1171           0 :                                 case EPM_PROTOCOL_OSI_TP4: {
    1172           0 :                                         NDR_CHECK(ndr_pull_epm_rhs_osi_tp4(ndr, NDR_SCALARS, &r->osi_tp4));
    1173           0 :                                 break; }
    1174             : 
    1175           0 :                                 case EPM_PROTOCOL_OSI_CLNS: {
    1176           0 :                                         NDR_CHECK(ndr_pull_epm_rhs_osi_clns(ndr, NDR_SCALARS, &r->osi_clns));
    1177           0 :                                 break; }
    1178             : 
    1179        9752 :                                 case EPM_PROTOCOL_TCP: {
    1180        9752 :                                         NDR_CHECK(ndr_pull_epm_rhs_tcp(ndr, NDR_SCALARS, &r->tcp));
    1181        9508 :                                 break; }
    1182             : 
    1183         184 :                                 case EPM_PROTOCOL_UDP: {
    1184         184 :                                         NDR_CHECK(ndr_pull_epm_rhs_udp(ndr, NDR_SCALARS, &r->udp));
    1185         184 :                                 break; }
    1186             : 
    1187       10228 :                                 case EPM_PROTOCOL_IP: {
    1188       10228 :                                         NDR_CHECK(ndr_pull_epm_rhs_ip(ndr, NDR_SCALARS, &r->ip));
    1189        9984 :                                 break; }
    1190             : 
    1191           0 :                                 case EPM_PROTOCOL_NCADG: {
    1192           0 :                                         NDR_CHECK(ndr_pull_epm_rhs_ncadg(ndr, NDR_SCALARS, &r->ncadg));
    1193           0 :                                 break; }
    1194             : 
    1195      276040 :                                 case EPM_PROTOCOL_NCACN: {
    1196      276040 :                                         NDR_CHECK(ndr_pull_epm_rhs_ncacn(ndr, NDR_SCALARS, &r->ncacn));
    1197      275796 :                                 break; }
    1198             : 
    1199        1638 :                                 case EPM_PROTOCOL_NCALRPC: {
    1200        1638 :                                         NDR_CHECK(ndr_pull_epm_rhs_ncalrpc(ndr, NDR_SCALARS, &r->ncalrpc));
    1201        1630 :                                 break; }
    1202             : 
    1203      555356 :                                 case EPM_PROTOCOL_UUID: {
    1204      555356 :                                         NDR_CHECK(ndr_pull_epm_rhs_uuid(ndr, NDR_SCALARS, &r->uuid));
    1205      554852 :                                 break; }
    1206             : 
    1207           0 :                                 case EPM_PROTOCOL_IPX: {
    1208           0 :                                         NDR_CHECK(ndr_pull_epm_rhs_ipx(ndr, NDR_SCALARS, &r->ipx));
    1209           0 :                                 break; }
    1210             : 
    1211      265812 :                                 case EPM_PROTOCOL_SMB: {
    1212      265812 :                                         NDR_CHECK(ndr_pull_epm_rhs_smb(ndr, NDR_SCALARS, &r->smb));
    1213      265812 :                                 break; }
    1214             : 
    1215        1638 :                                 case EPM_PROTOCOL_NAMED_PIPE: {
    1216        1638 :                                         NDR_CHECK(ndr_pull_epm_rhs_named_pipe(ndr, NDR_SCALARS, &r->named_pipe));
    1217        1630 :                                 break; }
    1218             : 
    1219      265812 :                                 case EPM_PROTOCOL_NETBIOS: {
    1220      265812 :                                         NDR_CHECK(ndr_pull_epm_rhs_netbios(ndr, NDR_SCALARS, &r->netbios));
    1221      265812 :                                 break; }
    1222             : 
    1223           0 :                                 case EPM_PROTOCOL_NETBEUI: {
    1224           0 :                                         NDR_CHECK(ndr_pull_epm_rhs_netbeui(ndr, NDR_SCALARS, &r->netbeui));
    1225           0 :                                 break; }
    1226             : 
    1227           0 :                                 case EPM_PROTOCOL_SPX: {
    1228           0 :                                         NDR_CHECK(ndr_pull_epm_rhs_spx(ndr, NDR_SCALARS, &r->spx));
    1229           0 :                                 break; }
    1230             : 
    1231           0 :                                 case EPM_PROTOCOL_NB_IPX: {
    1232           0 :                                         NDR_CHECK(ndr_pull_epm_rhs_nb_ipx(ndr, NDR_SCALARS, &r->nb_ipx));
    1233           0 :                                 break; }
    1234             : 
    1235           0 :                                 case EPM_PROTOCOL_DSP: {
    1236           0 :                                         NDR_CHECK(ndr_pull_epm_rhs_atalk_stream(ndr, NDR_SCALARS, &r->atalk_stream));
    1237           0 :                                 break; }
    1238             : 
    1239           0 :                                 case EPM_PROTOCOL_DDP: {
    1240           0 :                                         NDR_CHECK(ndr_pull_epm_rhs_atalk_datagram(ndr, NDR_SCALARS, &r->atalk_datagram));
    1241           0 :                                 break; }
    1242             : 
    1243           0 :                                 case EPM_PROTOCOL_APPLETALK: {
    1244           0 :                                         NDR_CHECK(ndr_pull_epm_rhs_appletalk(ndr, NDR_SCALARS, &r->appletalk));
    1245           0 :                                 break; }
    1246             : 
    1247           0 :                                 case EPM_PROTOCOL_VINES_SPP: {
    1248           0 :                                         NDR_CHECK(ndr_pull_epm_rhs_vines_spp(ndr, NDR_SCALARS, &r->vines_spp));
    1249           0 :                                 break; }
    1250             : 
    1251           0 :                                 case EPM_PROTOCOL_VINES_IPC: {
    1252           0 :                                         NDR_CHECK(ndr_pull_epm_rhs_vines_ipc(ndr, NDR_SCALARS, &r->vines_ipc));
    1253           0 :                                 break; }
    1254             : 
    1255           0 :                                 case EPM_PROTOCOL_STREETTALK: {
    1256           0 :                                         NDR_CHECK(ndr_pull_epm_rhs_streettalk(ndr, NDR_SCALARS, &r->streettalk));
    1257           0 :                                 break; }
    1258             : 
    1259         292 :                                 case EPM_PROTOCOL_HTTP: {
    1260         292 :                                         NDR_CHECK(ndr_pull_epm_rhs_http(ndr, NDR_SCALARS, &r->http));
    1261         292 :                                 break; }
    1262             : 
    1263           0 :                                 case EPM_PROTOCOL_UNIX_DS: {
    1264           0 :                                         NDR_CHECK(ndr_pull_epm_rhs_unix_ds(ndr, NDR_SCALARS, &r->unix_ds));
    1265           0 :                                 break; }
    1266             : 
    1267           0 :                                 case EPM_PROTOCOL_NULL: {
    1268           0 :                                         NDR_CHECK(ndr_pull_epm_rhs_null(ndr, NDR_SCALARS, &r->null));
    1269           0 :                                 break; }
    1270             : 
    1271           0 :                                 default: {
    1272             :                                         {
    1273           0 :                                                 uint32_t _flags_save_DATA_BLOB = ndr->flags;
    1274           0 :                                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    1275           0 :                                                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->unknown));
    1276           0 :                                                 ndr->flags = _flags_save_DATA_BLOB;
    1277             :                                         }
    1278           0 :                                 break; }
    1279             : 
    1280             :                         }
    1281           0 :                 }
    1282     1386752 :                 ndr->flags = _flags_save_UNION;
    1283             :         }
    1284     1386752 :         return NDR_ERR_SUCCESS;
    1285             : }
    1286             : 
    1287        2722 : _PUBLIC_ void ndr_print_epm_rhs(struct ndr_print *ndr, const char *name, const union epm_rhs *r)
    1288             : {
    1289             :         uint32_t level;
    1290             :         {
    1291        2722 :                 uint32_t _flags_save_UNION = ndr->flags;
    1292        2722 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
    1293        2722 :                 level = ndr_print_steal_switch_value(ndr, r);
    1294        2722 :                 ndr_print_union(ndr, name, level, "epm_rhs");
    1295        2722 :                 switch (level) {
    1296           0 :                         case EPM_PROTOCOL_DNET_NSP:
    1297           0 :                                 ndr_print_epm_rhs_dnet_nsp(ndr, "dnet_nsp", &r->dnet_nsp);
    1298           0 :                         break;
    1299             : 
    1300           0 :                         case EPM_PROTOCOL_OSI_TP4:
    1301           0 :                                 ndr_print_epm_rhs_osi_tp4(ndr, "osi_tp4", &r->osi_tp4);
    1302           0 :                         break;
    1303             : 
    1304           0 :                         case EPM_PROTOCOL_OSI_CLNS:
    1305           0 :                                 ndr_print_epm_rhs_osi_clns(ndr, "osi_clns", &r->osi_clns);
    1306           0 :                         break;
    1307             : 
    1308         190 :                         case EPM_PROTOCOL_TCP:
    1309         190 :                                 ndr_print_epm_rhs_tcp(ndr, "tcp", &r->tcp);
    1310         190 :                         break;
    1311             : 
    1312           0 :                         case EPM_PROTOCOL_UDP:
    1313           0 :                                 ndr_print_epm_rhs_udp(ndr, "udp", &r->udp);
    1314           0 :                         break;
    1315             : 
    1316         240 :                         case EPM_PROTOCOL_IP:
    1317         240 :                                 ndr_print_epm_rhs_ip(ndr, "ip", &r->ip);
    1318         240 :                         break;
    1319             : 
    1320           0 :                         case EPM_PROTOCOL_NCADG:
    1321           0 :                                 ndr_print_epm_rhs_ncadg(ndr, "ncadg", &r->ncadg);
    1322           0 :                         break;
    1323             : 
    1324         506 :                         case EPM_PROTOCOL_NCACN:
    1325         506 :                                 ndr_print_epm_rhs_ncacn(ndr, "ncacn", &r->ncacn);
    1326         506 :                         break;
    1327             : 
    1328          48 :                         case EPM_PROTOCOL_NCALRPC:
    1329          48 :                                 ndr_print_epm_rhs_ncalrpc(ndr, "ncalrpc", &r->ncalrpc);
    1330          48 :                         break;
    1331             : 
    1332        1108 :                         case EPM_PROTOCOL_UUID:
    1333        1108 :                                 ndr_print_epm_rhs_uuid(ndr, "uuid", &r->uuid);
    1334        1108 :                         break;
    1335             : 
    1336           0 :                         case EPM_PROTOCOL_IPX:
    1337           0 :                                 ndr_print_epm_rhs_ipx(ndr, "ipx", &r->ipx);
    1338           0 :                         break;
    1339             : 
    1340         266 :                         case EPM_PROTOCOL_SMB:
    1341         266 :                                 ndr_print_epm_rhs_smb(ndr, "smb", &r->smb);
    1342         266 :                         break;
    1343             : 
    1344          48 :                         case EPM_PROTOCOL_NAMED_PIPE:
    1345          48 :                                 ndr_print_epm_rhs_named_pipe(ndr, "named_pipe", &r->named_pipe);
    1346          48 :                         break;
    1347             : 
    1348         266 :                         case EPM_PROTOCOL_NETBIOS:
    1349         266 :                                 ndr_print_epm_rhs_netbios(ndr, "netbios", &r->netbios);
    1350         266 :                         break;
    1351             : 
    1352           0 :                         case EPM_PROTOCOL_NETBEUI:
    1353           0 :                                 ndr_print_epm_rhs_netbeui(ndr, "netbeui", &r->netbeui);
    1354           0 :                         break;
    1355             : 
    1356           0 :                         case EPM_PROTOCOL_SPX:
    1357           0 :                                 ndr_print_epm_rhs_spx(ndr, "spx", &r->spx);
    1358           0 :                         break;
    1359             : 
    1360           0 :                         case EPM_PROTOCOL_NB_IPX:
    1361           0 :                                 ndr_print_epm_rhs_nb_ipx(ndr, "nb_ipx", &r->nb_ipx);
    1362           0 :                         break;
    1363             : 
    1364           0 :                         case EPM_PROTOCOL_DSP:
    1365           0 :                                 ndr_print_epm_rhs_atalk_stream(ndr, "atalk_stream", &r->atalk_stream);
    1366           0 :                         break;
    1367             : 
    1368           0 :                         case EPM_PROTOCOL_DDP:
    1369           0 :                                 ndr_print_epm_rhs_atalk_datagram(ndr, "atalk_datagram", &r->atalk_datagram);
    1370           0 :                         break;
    1371             : 
    1372           0 :                         case EPM_PROTOCOL_APPLETALK:
    1373           0 :                                 ndr_print_epm_rhs_appletalk(ndr, "appletalk", &r->appletalk);
    1374           0 :                         break;
    1375             : 
    1376           0 :                         case EPM_PROTOCOL_VINES_SPP:
    1377           0 :                                 ndr_print_epm_rhs_vines_spp(ndr, "vines_spp", &r->vines_spp);
    1378           0 :                         break;
    1379             : 
    1380           0 :                         case EPM_PROTOCOL_VINES_IPC:
    1381           0 :                                 ndr_print_epm_rhs_vines_ipc(ndr, "vines_ipc", &r->vines_ipc);
    1382           0 :                         break;
    1383             : 
    1384           0 :                         case EPM_PROTOCOL_STREETTALK:
    1385           0 :                                 ndr_print_epm_rhs_streettalk(ndr, "streettalk", &r->streettalk);
    1386           0 :                         break;
    1387             : 
    1388          50 :                         case EPM_PROTOCOL_HTTP:
    1389          50 :                                 ndr_print_epm_rhs_http(ndr, "http", &r->http);
    1390          50 :                         break;
    1391             : 
    1392           0 :                         case EPM_PROTOCOL_UNIX_DS:
    1393           0 :                                 ndr_print_epm_rhs_unix_ds(ndr, "unix_ds", &r->unix_ds);
    1394           0 :                         break;
    1395             : 
    1396           0 :                         case EPM_PROTOCOL_NULL:
    1397           0 :                                 ndr_print_epm_rhs_null(ndr, "null", &r->null);
    1398           0 :                         break;
    1399             : 
    1400           0 :                         default:
    1401             :                                 {
    1402           0 :                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
    1403           0 :                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    1404           0 :                                         ndr_print_DATA_BLOB(ndr, "unknown", r->unknown);
    1405           0 :                                         ndr->flags = _flags_save_DATA_BLOB;
    1406             :                                 }
    1407           0 :                         break;
    1408             : 
    1409             :                 }
    1410        2722 :                 ndr->flags = _flags_save_UNION;
    1411             :         }
    1412        2722 : }
    1413             : 
    1414      475506 : static enum ndr_err_code ndr_push_epm_lhs(struct ndr_push *ndr, int ndr_flags, const struct epm_lhs *r)
    1415             : {
    1416      475506 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1417      475506 :         if (ndr_flags & NDR_SCALARS) {
    1418      475506 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    1419      477990 :                 NDR_CHECK(ndr_push_epm_protocol(ndr, NDR_SCALARS, r->protocol));
    1420             :                 {
    1421      475506 :                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
    1422      475506 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    1423      475506 :                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->lhs_data));
    1424      475506 :                         ndr->flags = _flags_save_DATA_BLOB;
    1425             :                 }
    1426      475506 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    1427             :         }
    1428      473022 :         if (ndr_flags & NDR_BUFFERS) {
    1429             :         }
    1430      473022 :         return NDR_ERR_SUCCESS;
    1431             : }
    1432             : 
    1433     1386752 : static enum ndr_err_code ndr_pull_epm_lhs(struct ndr_pull *ndr, int ndr_flags, struct epm_lhs *r)
    1434             : {
    1435     1386752 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1436     1386752 :         if (ndr_flags & NDR_SCALARS) {
    1437     1386752 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    1438     1388004 :                 NDR_CHECK(ndr_pull_epm_protocol(ndr, NDR_SCALARS, &r->protocol));
    1439             :                 {
    1440     1386752 :                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
    1441     1386752 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    1442     1386752 :                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->lhs_data));
    1443     1386752 :                         ndr->flags = _flags_save_DATA_BLOB;
    1444             :                 }
    1445     1386752 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    1446             :         }
    1447     1385500 :         if (ndr_flags & NDR_BUFFERS) {
    1448             :         }
    1449     1386752 :         return NDR_ERR_SUCCESS;
    1450             : }
    1451             : 
    1452        2722 : _PUBLIC_ void ndr_print_epm_lhs(struct ndr_print *ndr, const char *name, const struct epm_lhs *r)
    1453             : {
    1454        2722 :         ndr_print_struct(ndr, name, "epm_lhs");
    1455        2722 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1456        2722 :         ndr->depth++;
    1457        2722 :         ndr_print_epm_protocol(ndr, "protocol", r->protocol);
    1458             :         {
    1459        2722 :                 uint32_t _flags_save_DATA_BLOB = ndr->flags;
    1460        2722 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    1461        2722 :                 ndr_print_DATA_BLOB(ndr, "lhs_data", r->lhs_data);
    1462        2722 :                 ndr->flags = _flags_save_DATA_BLOB;
    1463             :         }
    1464        2722 :         ndr->depth--;
    1465             : }
    1466             : 
    1467      475506 : static enum ndr_err_code ndr_push_epm_floor(struct ndr_push *ndr, int ndr_flags, const struct epm_floor *r)
    1468             : {
    1469      475506 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1470      475506 :         if (ndr_flags & NDR_SCALARS) {
    1471      475506 :                 NDR_CHECK(ndr_push_align(ndr, 1));
    1472             :                 {
    1473             :                         struct ndr_push *_ndr_lhs;
    1474      475506 :                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_lhs, 2, -1));
    1475      475506 :                         NDR_CHECK(ndr_push_epm_lhs(_ndr_lhs, NDR_SCALARS, &r->lhs));
    1476      475506 :                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_lhs, 2, -1));
    1477             :                 }
    1478             :                 {
    1479             :                         struct ndr_push *_ndr_rhs;
    1480      475506 :                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_rhs, 2, -1));
    1481      475506 :                         NDR_CHECK(ndr_push_set_switch_value(_ndr_rhs, &r->rhs, r->lhs.protocol));
    1482      475506 :                         NDR_CHECK(ndr_push_epm_rhs(_ndr_rhs, NDR_SCALARS, &r->rhs));
    1483      475506 :                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_rhs, 2, -1));
    1484             :                 }
    1485      475506 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
    1486             :         }
    1487      473022 :         if (ndr_flags & NDR_BUFFERS) {
    1488             :         }
    1489      475506 :         return NDR_ERR_SUCCESS;
    1490             : }
    1491             : 
    1492     1386752 : static enum ndr_err_code ndr_pull_epm_floor(struct ndr_pull *ndr, int ndr_flags, struct epm_floor *r)
    1493             : {
    1494     1386752 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1495     1386752 :         if (ndr_flags & NDR_SCALARS) {
    1496     1386752 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
    1497             :                 {
    1498             :                         struct ndr_pull *_ndr_lhs;
    1499     1386752 :                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_lhs, 2, -1));
    1500     1386752 :                         NDR_CHECK(ndr_pull_epm_lhs(_ndr_lhs, NDR_SCALARS, &r->lhs));
    1501     1386752 :                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_lhs, 2, -1));
    1502             :                 }
    1503             :                 {
    1504             :                         struct ndr_pull *_ndr_rhs;
    1505     1386752 :                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_rhs, 2, -1));
    1506     1386752 :                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_rhs, &r->rhs, r->lhs.protocol));
    1507     1386752 :                         NDR_CHECK(ndr_pull_epm_rhs(_ndr_rhs, NDR_SCALARS, &r->rhs));
    1508     1386752 :                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_rhs, 2, -1));
    1509             :                 }
    1510     1386752 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
    1511             :         }
    1512     1385500 :         if (ndr_flags & NDR_BUFFERS) {
    1513             :         }
    1514     1386752 :         return NDR_ERR_SUCCESS;
    1515             : }
    1516             : 
    1517        2722 : _PUBLIC_ void ndr_print_epm_floor(struct ndr_print *ndr, const char *name, const struct epm_floor *r)
    1518             : {
    1519        2722 :         ndr_print_struct(ndr, name, "epm_floor");
    1520        2722 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1521        2722 :         ndr->depth++;
    1522        2722 :         ndr_print_epm_lhs(ndr, "lhs", &r->lhs);
    1523        2722 :         ndr_print_set_switch_value(ndr, &r->rhs, r->lhs.protocol);
    1524        2722 :         ndr_print_epm_rhs(ndr, "rhs", &r->rhs);
    1525        2722 :         ndr->depth--;
    1526             : }
    1527             : 
    1528       96008 : static enum ndr_err_code ndr_push_epm_tower(struct ndr_push *ndr, int ndr_flags, const struct epm_tower *r)
    1529             : {
    1530             :         uint32_t cntr_floors_0;
    1531             :         {
    1532       96008 :                 uint32_t _flags_save_STRUCT = ndr->flags;
    1533       96008 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_LITTLE_ENDIAN);
    1534       96008 :                 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1535       96008 :                 if (ndr_flags & NDR_SCALARS) {
    1536       96008 :                         NDR_CHECK(ndr_push_align(ndr, 2));
    1537       96008 :                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_floors));
    1538      571014 :                         for (cntr_floors_0 = 0; cntr_floors_0 < (r->num_floors); cntr_floors_0++) {
    1539      475506 :                                 NDR_CHECK(ndr_push_epm_floor(ndr, NDR_SCALARS, &r->floors[cntr_floors_0]));
    1540             :                         }
    1541       96008 :                         NDR_CHECK(ndr_push_trailer_align(ndr, 2));
    1542             :                 }
    1543       95508 :                 if (ndr_flags & NDR_BUFFERS) {
    1544             :                 }
    1545       96008 :                 ndr->flags = _flags_save_STRUCT;
    1546             :         }
    1547       96008 :         return NDR_ERR_SUCCESS;
    1548             : }
    1549             : 
    1550      277678 : static enum ndr_err_code ndr_pull_epm_tower(struct ndr_pull *ndr, int ndr_flags, struct epm_tower *r)
    1551             : {
    1552      277678 :         uint32_t size_floors_0 = 0;
    1553             :         uint32_t cntr_floors_0;
    1554      277678 :         TALLOC_CTX *_mem_save_floors_0 = NULL;
    1555             :         {
    1556      277678 :                 uint32_t _flags_save_STRUCT = ndr->flags;
    1557      277678 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_LITTLE_ENDIAN);
    1558      277678 :                 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1559      277678 :                 if (ndr_flags & NDR_SCALARS) {
    1560      277678 :                         NDR_CHECK(ndr_pull_align(ndr, 2));
    1561      277678 :                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_floors));
    1562      277678 :                         size_floors_0 = r->num_floors;
    1563      277678 :                         NDR_PULL_ALLOC_N(ndr, r->floors, size_floors_0);
    1564      277678 :                         _mem_save_floors_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1565      277678 :                         NDR_PULL_SET_MEM_CTX(ndr, r->floors, 0);
    1566     1664430 :                         for (cntr_floors_0 = 0; cntr_floors_0 < (size_floors_0); cntr_floors_0++) {
    1567     1386752 :                                 NDR_CHECK(ndr_pull_epm_floor(ndr, NDR_SCALARS, &r->floors[cntr_floors_0]));
    1568             :                         }
    1569      277678 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_floors_0, 0);
    1570      277678 :                         NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
    1571             :                 }
    1572      277426 :                 if (ndr_flags & NDR_BUFFERS) {
    1573             :                 }
    1574      277678 :                 ndr->flags = _flags_save_STRUCT;
    1575             :         }
    1576      277678 :         return NDR_ERR_SUCCESS;
    1577             : }
    1578             : 
    1579         554 : _PUBLIC_ void ndr_print_epm_tower(struct ndr_print *ndr, const char *name, const struct epm_tower *r)
    1580             : {
    1581             :         uint32_t cntr_floors_0;
    1582         554 :         ndr_print_struct(ndr, name, "epm_tower");
    1583         554 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1584             :         {
    1585         554 :                 uint32_t _flags_save_STRUCT = ndr->flags;
    1586         554 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_LITTLE_ENDIAN);
    1587         554 :                 ndr->depth++;
    1588         554 :                 ndr_print_uint16(ndr, "num_floors", r->num_floors);
    1589         554 :                 ndr->print(ndr, "%s: ARRAY(%d)", "floors", (int)r->num_floors);
    1590         554 :                 ndr->depth++;
    1591        3276 :                 for (cntr_floors_0 = 0; cntr_floors_0 < (r->num_floors); cntr_floors_0++) {
    1592        2722 :                         ndr_print_epm_floor(ndr, "floors", &r->floors[cntr_floors_0]);
    1593             :                 }
    1594         554 :                 ndr->depth--;
    1595         554 :                 ndr->depth--;
    1596         554 :                 ndr->flags = _flags_save_STRUCT;
    1597             :         }
    1598             : }
    1599             : 
    1600       47754 : static size_t ndr_size_epm_tower(const struct epm_tower *r, int flags)
    1601             : {
    1602       48004 :         flags |= LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_LITTLE_ENDIAN;
    1603       48004 :         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_epm_tower);
    1604             : }
    1605             : 
    1606       48004 : _PUBLIC_ enum ndr_err_code ndr_push_epm_twr_t(struct ndr_push *ndr, int ndr_flags, const struct epm_twr_t *r)
    1607             : {
    1608       48004 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1609       48004 :         if (ndr_flags & NDR_SCALARS) {
    1610       48004 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    1611       48254 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_epm_tower(&r->tower, ndr->flags)));
    1612             :                 {
    1613             :                         struct ndr_push *_ndr_tower;
    1614       48004 :                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_tower, 4, -1));
    1615       48004 :                         NDR_CHECK(ndr_push_epm_tower(_ndr_tower, NDR_SCALARS, &r->tower));
    1616       48004 :                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_tower, 4, -1));
    1617             :                 }
    1618       48004 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    1619             :         }
    1620       47754 :         if (ndr_flags & NDR_BUFFERS) {
    1621             :         }
    1622       48004 :         return NDR_ERR_SUCCESS;
    1623             : }
    1624             : 
    1625      277678 : _PUBLIC_ enum ndr_err_code ndr_pull_epm_twr_t(struct ndr_pull *ndr, int ndr_flags, struct epm_twr_t *r)
    1626             : {
    1627      277678 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1628      277678 :         if (ndr_flags & NDR_SCALARS) {
    1629      277678 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    1630      277678 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->tower_length));
    1631             :                 {
    1632             :                         struct ndr_pull *_ndr_tower;
    1633      277678 :                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_tower, 4, -1));
    1634      277678 :                         NDR_CHECK(ndr_pull_epm_tower(_ndr_tower, NDR_SCALARS, &r->tower));
    1635      277678 :                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_tower, 4, -1));
    1636             :                 }
    1637      277678 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    1638             :         }
    1639      277426 :         if (ndr_flags & NDR_BUFFERS) {
    1640             :         }
    1641      277678 :         return NDR_ERR_SUCCESS;
    1642             : }
    1643             : 
    1644           0 : static void ndr_print_flags_epm_twr_t(struct ndr_print *ndr, const char *name, int unused, const struct epm_twr_t *r)
    1645             : {
    1646           0 :         ndr_print_epm_twr_t(ndr, name, r);
    1647           0 : }
    1648             : 
    1649         554 : _PUBLIC_ void ndr_print_epm_twr_t(struct ndr_print *ndr, const char *name, const struct epm_twr_t *r)
    1650             : {
    1651         554 :         ndr_print_struct(ndr, name, "epm_twr_t");
    1652         554 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1653         554 :         ndr->depth++;
    1654         554 :         ndr_print_uint32(ndr, "tower_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_epm_tower(&r->tower, ndr->flags):r->tower_length);
    1655         554 :         ndr_print_epm_tower(ndr, "tower", &r->tower);
    1656         554 :         ndr->depth--;
    1657             : }
    1658             : 
    1659       10418 : static enum ndr_err_code ndr_push_epm_entry_t(struct ndr_push *ndr, int ndr_flags, const struct epm_entry_t *r)
    1660             : {
    1661       10418 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1662       10418 :         if (ndr_flags & NDR_SCALARS) {
    1663        5209 :                 NDR_CHECK(ndr_push_align(ndr, 5));
    1664        5209 :                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->object));
    1665        5209 :                 NDR_CHECK(ndr_push_full_ptr(ndr, r->tower));
    1666        5209 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
    1667        5209 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen(r->annotation) + 1));
    1668        5209 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->annotation, strlen(r->annotation) + 1, sizeof(uint8_t), CH_DOS));
    1669        5209 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
    1670             :         }
    1671       10418 :         if (ndr_flags & NDR_BUFFERS) {
    1672        5209 :                 if (r->tower) {
    1673        5209 :                         NDR_CHECK(ndr_push_epm_twr_t(ndr, NDR_SCALARS, r->tower));
    1674             :                 }
    1675             :         }
    1676       10418 :         return NDR_ERR_SUCCESS;
    1677             : }
    1678             : 
    1679        2624 : static enum ndr_err_code ndr_pull_epm_entry_t(struct ndr_pull *ndr, int ndr_flags, struct epm_entry_t *r)
    1680             : {
    1681             :         uint32_t _ptr_tower;
    1682        2624 :         TALLOC_CTX *_mem_save_tower_0 = NULL;
    1683        2624 :         uint32_t size_annotation_0 = 0;
    1684        2624 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1685        2624 :         if (ndr_flags & NDR_SCALARS) {
    1686        1312 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
    1687        1312 :                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->object));
    1688        1312 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_tower));
    1689        1312 :                 if (_ptr_tower) {
    1690        1312 :                         NDR_PULL_ALLOC(ndr, r->tower);
    1691             :                 } else {
    1692           0 :                         r->tower = NULL;
    1693             :                 }
    1694        1312 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__annotation_offset));
    1695        1312 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__annotation_length));
    1696        1312 :                 size_annotation_0 = r->__annotation_length;
    1697        1312 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->annotation, size_annotation_0, sizeof(uint8_t), CH_DOS));
    1698        1312 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
    1699             :         }
    1700        2624 :         if (ndr_flags & NDR_BUFFERS) {
    1701        1312 :                 if (r->tower) {
    1702        1312 :                         _mem_save_tower_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1703        1312 :                         NDR_PULL_SET_MEM_CTX(ndr, r->tower, 0);
    1704        1312 :                         NDR_CHECK(ndr_pull_epm_twr_t(ndr, NDR_SCALARS, r->tower));
    1705        1312 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_tower_0, 0);
    1706             :                 }
    1707             :         }
    1708        2624 :         return NDR_ERR_SUCCESS;
    1709             : }
    1710             : 
    1711         240 : _PUBLIC_ void ndr_print_epm_entry_t(struct ndr_print *ndr, const char *name, const struct epm_entry_t *r)
    1712             : {
    1713         240 :         ndr_print_struct(ndr, name, "epm_entry_t");
    1714         240 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1715         240 :         ndr->depth++;
    1716         240 :         ndr_print_GUID(ndr, "object", &r->object);
    1717         240 :         ndr_print_ptr(ndr, "tower", r->tower);
    1718         240 :         ndr->depth++;
    1719         240 :         if (r->tower) {
    1720         240 :                 ndr_print_epm_twr_t(ndr, "tower", r->tower);
    1721             :         }
    1722         240 :         ndr->depth--;
    1723         240 :         ndr_print_uint32(ndr, "__annotation_offset", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->__annotation_offset);
    1724         240 :         ndr_print_uint32(ndr, "__annotation_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen(r->annotation) + 1:r->__annotation_length);
    1725         240 :         ndr_print_string(ndr, "annotation", r->annotation);
    1726         240 :         ndr->depth--;
    1727             : }
    1728             : 
    1729           0 : static enum ndr_err_code ndr_push_rpc_if_id_t(struct ndr_push *ndr, int ndr_flags, const struct rpc_if_id_t *r)
    1730             : {
    1731           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1732           0 :         if (ndr_flags & NDR_SCALARS) {
    1733           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    1734           0 :                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->uuid));
    1735           0 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->vers_major));
    1736           0 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->vers_minor));
    1737           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    1738             :         }
    1739           0 :         if (ndr_flags & NDR_BUFFERS) {
    1740             :         }
    1741           0 :         return NDR_ERR_SUCCESS;
    1742             : }
    1743             : 
    1744           0 : static enum ndr_err_code ndr_pull_rpc_if_id_t(struct ndr_pull *ndr, int ndr_flags, struct rpc_if_id_t *r)
    1745             : {
    1746           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1747           0 :         if (ndr_flags & NDR_SCALARS) {
    1748           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    1749           0 :                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->uuid));
    1750           0 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->vers_major));
    1751           0 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->vers_minor));
    1752           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    1753             :         }
    1754           0 :         if (ndr_flags & NDR_BUFFERS) {
    1755             :         }
    1756           0 :         return NDR_ERR_SUCCESS;
    1757             : }
    1758             : 
    1759           0 : _PUBLIC_ void ndr_print_rpc_if_id_t(struct ndr_print *ndr, const char *name, const struct rpc_if_id_t *r)
    1760             : {
    1761           0 :         ndr_print_struct(ndr, name, "rpc_if_id_t");
    1762           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1763           0 :         ndr->depth++;
    1764           0 :         ndr_print_GUID(ndr, "uuid", &r->uuid);
    1765           0 :         ndr_print_uint16(ndr, "vers_major", r->vers_major);
    1766           0 :         ndr_print_uint16(ndr, "vers_minor", r->vers_minor);
    1767           0 :         ndr->depth--;
    1768             : }
    1769             : 
    1770         162 : static enum ndr_err_code ndr_push_epm_InquiryType(struct ndr_push *ndr, int ndr_flags, enum epm_InquiryType r)
    1771             : {
    1772         162 :         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
    1773         162 :         return NDR_ERR_SUCCESS;
    1774             : }
    1775             : 
    1776          70 : static enum ndr_err_code ndr_pull_epm_InquiryType(struct ndr_pull *ndr, int ndr_flags, enum epm_InquiryType *r)
    1777             : {
    1778             :         uint32_t v;
    1779          70 :         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
    1780          70 :         *r = v;
    1781          70 :         return NDR_ERR_SUCCESS;
    1782             : }
    1783             : 
    1784           0 : _PUBLIC_ void ndr_print_epm_InquiryType(struct ndr_print *ndr, const char *name, enum epm_InquiryType r)
    1785             : {
    1786           0 :         const char *val = NULL;
    1787             : 
    1788           0 :         switch (r) {
    1789           0 :                 case RPC_C_EP_ALL_ELTS: val = "RPC_C_EP_ALL_ELTS"; break;
    1790           0 :                 case RPC_C_EP_MATCH_BY_IF: val = "RPC_C_EP_MATCH_BY_IF"; break;
    1791           0 :                 case RPC_C_EP_MATCH_BY_OBJ: val = "RPC_C_EP_MATCH_BY_OBJ"; break;
    1792           0 :                 case RPC_C_EP_MATCH_BY_BOTH: val = "RPC_C_EP_MATCH_BY_BOTH"; break;
    1793             :         }
    1794           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
    1795           0 : }
    1796             : 
    1797         162 : static enum ndr_err_code ndr_push_epm_VersionOption(struct ndr_push *ndr, int ndr_flags, enum epm_VersionOption r)
    1798             : {
    1799         162 :         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
    1800         162 :         return NDR_ERR_SUCCESS;
    1801             : }
    1802             : 
    1803          70 : static enum ndr_err_code ndr_pull_epm_VersionOption(struct ndr_pull *ndr, int ndr_flags, enum epm_VersionOption *r)
    1804             : {
    1805             :         uint32_t v;
    1806          70 :         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
    1807          70 :         *r = v;
    1808          70 :         return NDR_ERR_SUCCESS;
    1809             : }
    1810             : 
    1811           0 : _PUBLIC_ void ndr_print_epm_VersionOption(struct ndr_print *ndr, const char *name, enum epm_VersionOption r)
    1812             : {
    1813           0 :         const char *val = NULL;
    1814             : 
    1815           0 :         switch (r) {
    1816           0 :                 case RPC_C_VERS_ALL: val = "RPC_C_VERS_ALL"; break;
    1817           0 :                 case RPC_C_VERS_COMPATIBLE: val = "RPC_C_VERS_COMPATIBLE"; break;
    1818           0 :                 case RPC_C_VERS_EXACT: val = "RPC_C_VERS_EXACT"; break;
    1819           0 :                 case RPC_C_VERS_MAJOR_ONLY: val = "RPC_C_VERS_MAJOR_ONLY"; break;
    1820           0 :                 case RPC_C_VERS_UPTO: val = "RPC_C_VERS_UPTO"; break;
    1821             :         }
    1822           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
    1823           0 : }
    1824             : 
    1825       12112 : static enum ndr_err_code ndr_push_epm_twr_p_t(struct ndr_push *ndr, int ndr_flags, const struct epm_twr_p_t *r)
    1826             : {
    1827       12112 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1828       12112 :         if (ndr_flags & NDR_SCALARS) {
    1829        6056 :                 NDR_CHECK(ndr_push_align(ndr, 5));
    1830        6056 :                 NDR_CHECK(ndr_push_full_ptr(ndr, r->twr));
    1831        6056 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
    1832             :         }
    1833       12112 :         if (ndr_flags & NDR_BUFFERS) {
    1834        6056 :                 if (r->twr) {
    1835        6056 :                         NDR_CHECK(ndr_push_epm_twr_t(ndr, NDR_SCALARS, r->twr));
    1836             :                 }
    1837             :         }
    1838       11862 :         return NDR_ERR_SUCCESS;
    1839             : }
    1840             : 
    1841      540280 : static enum ndr_err_code ndr_pull_epm_twr_p_t(struct ndr_pull *ndr, int ndr_flags, struct epm_twr_p_t *r)
    1842             : {
    1843             :         uint32_t _ptr_twr;
    1844      540280 :         TALLOC_CTX *_mem_save_twr_0 = NULL;
    1845      540280 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1846      540280 :         if (ndr_flags & NDR_SCALARS) {
    1847      270140 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
    1848      270140 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_twr));
    1849      270140 :                 if (_ptr_twr) {
    1850      270140 :                         NDR_PULL_ALLOC(ndr, r->twr);
    1851             :                 } else {
    1852           0 :                         r->twr = NULL;
    1853             :                 }
    1854      270140 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
    1855             :         }
    1856      540280 :         if (ndr_flags & NDR_BUFFERS) {
    1857      270140 :                 if (r->twr) {
    1858      270140 :                         _mem_save_twr_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1859      270140 :                         NDR_PULL_SET_MEM_CTX(ndr, r->twr, 0);
    1860      270140 :                         NDR_CHECK(ndr_pull_epm_twr_t(ndr, NDR_SCALARS, r->twr));
    1861      270140 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_twr_0, 0);
    1862             :                 }
    1863             :         }
    1864      540030 :         return NDR_ERR_SUCCESS;
    1865             : }
    1866             : 
    1867         312 : _PUBLIC_ void ndr_print_epm_twr_p_t(struct ndr_print *ndr, const char *name, const struct epm_twr_p_t *r)
    1868             : {
    1869         312 :         ndr_print_struct(ndr, name, "epm_twr_p_t");
    1870         312 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1871         312 :         ndr->depth++;
    1872         312 :         ndr_print_ptr(ndr, "twr", r->twr);
    1873         312 :         ndr->depth++;
    1874         312 :         if (r->twr) {
    1875         312 :                 ndr_print_epm_twr_t(ndr, "twr", r->twr);
    1876             :         }
    1877         312 :         ndr->depth--;
    1878         312 :         ndr->depth--;
    1879             : }
    1880             : 
    1881         412 : static enum ndr_err_code ndr_push_epm_Insert(struct ndr_push *ndr, int flags, const struct epm_Insert *r)
    1882             : {
    1883             :         uint32_t cntr_entries_0;
    1884         412 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1885         412 :         if (flags & NDR_IN) {
    1886         412 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_ents));
    1887         412 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_ents));
    1888        5013 :                 for (cntr_entries_0 = 0; cntr_entries_0 < (r->in.num_ents); cntr_entries_0++) {
    1889        4601 :                         NDR_CHECK(ndr_push_epm_entry_t(ndr, NDR_SCALARS, &r->in.entries[cntr_entries_0]));
    1890             :                 }
    1891        5013 :                 for (cntr_entries_0 = 0; cntr_entries_0 < (r->in.num_ents); cntr_entries_0++) {
    1892        4601 :                         NDR_CHECK(ndr_push_epm_entry_t(ndr, NDR_BUFFERS, &r->in.entries[cntr_entries_0]));
    1893             :                 }
    1894         412 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.replace));
    1895             :         }
    1896         412 :         if (flags & NDR_OUT) {
    1897           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
    1898             :         }
    1899         412 :         return NDR_ERR_SUCCESS;
    1900             : }
    1901             : 
    1902         412 : static enum ndr_err_code ndr_pull_epm_Insert(struct ndr_pull *ndr, int flags, struct epm_Insert *r)
    1903             : {
    1904         412 :         uint32_t size_entries_0 = 0;
    1905             :         uint32_t cntr_entries_0;
    1906         412 :         TALLOC_CTX *_mem_save_entries_0 = NULL;
    1907         412 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1908         412 :         if (flags & NDR_IN) {
    1909           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_ents));
    1910           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.entries));
    1911           0 :                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->in.entries, &size_entries_0));
    1912           0 :                 NDR_PULL_ALLOC_N(ndr, r->in.entries, size_entries_0);
    1913           0 :                 _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1914           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.entries, 0);
    1915           0 :                 for (cntr_entries_0 = 0; cntr_entries_0 < (size_entries_0); cntr_entries_0++) {
    1916           0 :                         NDR_CHECK(ndr_pull_epm_entry_t(ndr, NDR_SCALARS, &r->in.entries[cntr_entries_0]));
    1917             :                 }
    1918           0 :                 for (cntr_entries_0 = 0; cntr_entries_0 < (size_entries_0); cntr_entries_0++) {
    1919           0 :                         NDR_CHECK(ndr_pull_epm_entry_t(ndr, NDR_BUFFERS, &r->in.entries[cntr_entries_0]));
    1920             :                 }
    1921           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
    1922           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.replace));
    1923           0 :                 if (r->in.entries) {
    1924           0 :                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.entries, r->in.num_ents));
    1925             :                 }
    1926           0 :                 for (cntr_entries_0 = 0; cntr_entries_0 < (size_entries_0); cntr_entries_0++) {
    1927             :                 }
    1928             :         }
    1929         412 :         if (flags & NDR_OUT) {
    1930             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1931             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1932         412 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
    1933             :         }
    1934         412 :         return NDR_ERR_SUCCESS;
    1935             : }
    1936             : 
    1937           0 : _PUBLIC_ void ndr_print_epm_Insert(struct ndr_print *ndr, const char *name, int flags, const struct epm_Insert *r)
    1938             : {
    1939             :         uint32_t cntr_entries_0;
    1940           0 :         ndr_print_struct(ndr, name, "epm_Insert");
    1941           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1942           0 :         ndr->depth++;
    1943           0 :         if (flags & NDR_SET_VALUES) {
    1944           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1945             :         }
    1946           0 :         if (flags & NDR_IN) {
    1947           0 :                 ndr_print_struct(ndr, "in", "epm_Insert");
    1948           0 :                 ndr->depth++;
    1949           0 :                 ndr_print_uint32(ndr, "num_ents", r->in.num_ents);
    1950           0 :                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->in.num_ents);
    1951           0 :                 ndr->depth++;
    1952           0 :                 for (cntr_entries_0 = 0; cntr_entries_0 < (r->in.num_ents); cntr_entries_0++) {
    1953           0 :                         ndr_print_epm_entry_t(ndr, "entries", &r->in.entries[cntr_entries_0]);
    1954             :                 }
    1955           0 :                 ndr->depth--;
    1956           0 :                 ndr_print_uint32(ndr, "replace", r->in.replace);
    1957           0 :                 ndr->depth--;
    1958             :         }
    1959           0 :         if (flags & NDR_OUT) {
    1960           0 :                 ndr_print_struct(ndr, "out", "epm_Insert");
    1961           0 :                 ndr->depth++;
    1962           0 :                 ndr_print_uint32(ndr, "result", r->out.result);
    1963           0 :                 ndr->depth--;
    1964             :         }
    1965           0 :         ndr->depth--;
    1966             : }
    1967             : 
    1968           4 : static enum ndr_err_code ndr_push_epm_Delete(struct ndr_push *ndr, int flags, const struct epm_Delete *r)
    1969             : {
    1970             :         uint32_t cntr_entries_0;
    1971           4 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1972           4 :         if (flags & NDR_IN) {
    1973           4 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_ents));
    1974           4 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_ents));
    1975           8 :                 for (cntr_entries_0 = 0; cntr_entries_0 < (r->in.num_ents); cntr_entries_0++) {
    1976           4 :                         NDR_CHECK(ndr_push_epm_entry_t(ndr, NDR_SCALARS, &r->in.entries[cntr_entries_0]));
    1977             :                 }
    1978           8 :                 for (cntr_entries_0 = 0; cntr_entries_0 < (r->in.num_ents); cntr_entries_0++) {
    1979           4 :                         NDR_CHECK(ndr_push_epm_entry_t(ndr, NDR_BUFFERS, &r->in.entries[cntr_entries_0]));
    1980             :                 }
    1981             :         }
    1982           4 :         if (flags & NDR_OUT) {
    1983           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
    1984             :         }
    1985           4 :         return NDR_ERR_SUCCESS;
    1986             : }
    1987             : 
    1988           4 : static enum ndr_err_code ndr_pull_epm_Delete(struct ndr_pull *ndr, int flags, struct epm_Delete *r)
    1989             : {
    1990           4 :         uint32_t size_entries_0 = 0;
    1991             :         uint32_t cntr_entries_0;
    1992           4 :         TALLOC_CTX *_mem_save_entries_0 = NULL;
    1993           4 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1994           4 :         if (flags & NDR_IN) {
    1995           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_ents));
    1996           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.entries));
    1997           0 :                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->in.entries, &size_entries_0));
    1998           0 :                 NDR_PULL_ALLOC_N(ndr, r->in.entries, size_entries_0);
    1999           0 :                 _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2000           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.entries, 0);
    2001           0 :                 for (cntr_entries_0 = 0; cntr_entries_0 < (size_entries_0); cntr_entries_0++) {
    2002           0 :                         NDR_CHECK(ndr_pull_epm_entry_t(ndr, NDR_SCALARS, &r->in.entries[cntr_entries_0]));
    2003             :                 }
    2004           0 :                 for (cntr_entries_0 = 0; cntr_entries_0 < (size_entries_0); cntr_entries_0++) {
    2005           0 :                         NDR_CHECK(ndr_pull_epm_entry_t(ndr, NDR_BUFFERS, &r->in.entries[cntr_entries_0]));
    2006             :                 }
    2007           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
    2008           0 :                 if (r->in.entries) {
    2009           0 :                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.entries, r->in.num_ents));
    2010             :                 }
    2011           0 :                 for (cntr_entries_0 = 0; cntr_entries_0 < (size_entries_0); cntr_entries_0++) {
    2012             :                 }
    2013             :         }
    2014           4 :         if (flags & NDR_OUT) {
    2015             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2016             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2017           4 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
    2018             :         }
    2019           4 :         return NDR_ERR_SUCCESS;
    2020             : }
    2021             : 
    2022           0 : _PUBLIC_ void ndr_print_epm_Delete(struct ndr_print *ndr, const char *name, int flags, const struct epm_Delete *r)
    2023             : {
    2024             :         uint32_t cntr_entries_0;
    2025           0 :         ndr_print_struct(ndr, name, "epm_Delete");
    2026           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2027           0 :         ndr->depth++;
    2028           0 :         if (flags & NDR_SET_VALUES) {
    2029           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2030             :         }
    2031           0 :         if (flags & NDR_IN) {
    2032           0 :                 ndr_print_struct(ndr, "in", "epm_Delete");
    2033           0 :                 ndr->depth++;
    2034           0 :                 ndr_print_uint32(ndr, "num_ents", r->in.num_ents);
    2035           0 :                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->in.num_ents);
    2036           0 :                 ndr->depth++;
    2037           0 :                 for (cntr_entries_0 = 0; cntr_entries_0 < (r->in.num_ents); cntr_entries_0++) {
    2038           0 :                         ndr_print_epm_entry_t(ndr, "entries", &r->in.entries[cntr_entries_0]);
    2039             :                 }
    2040           0 :                 ndr->depth--;
    2041           0 :                 ndr->depth--;
    2042             :         }
    2043           0 :         if (flags & NDR_OUT) {
    2044           0 :                 ndr_print_struct(ndr, "out", "epm_Delete");
    2045           0 :                 ndr->depth++;
    2046           0 :                 ndr_print_uint32(ndr, "result", r->out.result);
    2047           0 :                 ndr->depth--;
    2048             :         }
    2049           0 :         ndr->depth--;
    2050             : }
    2051             : 
    2052         241 : static enum ndr_err_code ndr_push_epm_Lookup(struct ndr_push *ndr, int flags, const struct epm_Lookup *r)
    2053             : {
    2054             :         uint32_t cntr_entries_0;
    2055         241 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2056         241 :         if (flags & NDR_IN) {
    2057         162 :                 if (r->in.entry_handle == NULL) {
    2058           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2059             :                 }
    2060         162 :                 NDR_CHECK(ndr_push_epm_InquiryType(ndr, NDR_SCALARS, r->in.inquiry_type));
    2061         162 :                 NDR_CHECK(ndr_push_full_ptr(ndr, r->in.object));
    2062         162 :                 if (r->in.object) {
    2063           0 :                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.object));
    2064             :                 }
    2065         162 :                 NDR_CHECK(ndr_push_full_ptr(ndr, r->in.interface_id));
    2066         162 :                 if (r->in.interface_id) {
    2067           0 :                         NDR_CHECK(ndr_push_rpc_if_id_t(ndr, NDR_SCALARS, r->in.interface_id));
    2068             :                 }
    2069         162 :                 NDR_CHECK(ndr_push_epm_VersionOption(ndr, NDR_SCALARS, r->in.vers_option));
    2070         162 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.entry_handle));
    2071         162 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_ents));
    2072             :         }
    2073         241 :         if (flags & NDR_OUT) {
    2074          79 :                 if (r->out.entry_handle == NULL) {
    2075           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2076             :                 }
    2077          79 :                 if (r->out.num_ents == NULL) {
    2078           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2079             :                 }
    2080          79 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.entry_handle));
    2081          79 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_ents));
    2082          79 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.max_ents));
    2083          79 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    2084          79 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.num_ents));
    2085         683 :                 for (cntr_entries_0 = 0; cntr_entries_0 < (*r->out.num_ents); cntr_entries_0++) {
    2086         604 :                         NDR_CHECK(ndr_push_epm_entry_t(ndr, NDR_SCALARS, &r->out.entries[cntr_entries_0]));
    2087             :                 }
    2088         683 :                 for (cntr_entries_0 = 0; cntr_entries_0 < (*r->out.num_ents); cntr_entries_0++) {
    2089         604 :                         NDR_CHECK(ndr_push_epm_entry_t(ndr, NDR_BUFFERS, &r->out.entries[cntr_entries_0]));
    2090             :                 }
    2091          79 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
    2092             :         }
    2093         241 :         return NDR_ERR_SUCCESS;
    2094             : }
    2095             : 
    2096         224 : static enum ndr_err_code ndr_pull_epm_Lookup(struct ndr_pull *ndr, int flags, struct epm_Lookup *r)
    2097             : {
    2098             :         uint32_t _ptr_object;
    2099             :         uint32_t _ptr_interface_id;
    2100         224 :         uint32_t size_entries_0 = 0;
    2101         224 :         uint32_t length_entries_0 = 0;
    2102             :         uint32_t cntr_entries_0;
    2103         224 :         TALLOC_CTX *_mem_save_object_0 = NULL;
    2104         224 :         TALLOC_CTX *_mem_save_interface_id_0 = NULL;
    2105         224 :         TALLOC_CTX *_mem_save_entry_handle_0 = NULL;
    2106         224 :         TALLOC_CTX *_mem_save_num_ents_0 = NULL;
    2107         224 :         TALLOC_CTX *_mem_save_entries_0 = NULL;
    2108         224 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2109         224 :         if (flags & NDR_IN) {
    2110          70 :                 NDR_ZERO_STRUCT(r->out);
    2111             : 
    2112          70 :                 NDR_CHECK(ndr_pull_epm_InquiryType(ndr, NDR_SCALARS, &r->in.inquiry_type));
    2113          70 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object));
    2114          70 :                 if (_ptr_object) {
    2115           0 :                         NDR_PULL_ALLOC(ndr, r->in.object);
    2116             :                 } else {
    2117          70 :                         r->in.object = NULL;
    2118             :                 }
    2119          70 :                 if (r->in.object) {
    2120           0 :                         _mem_save_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2121           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->in.object, 0);
    2122           0 :                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.object));
    2123           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_0, 0);
    2124             :                 }
    2125          70 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_interface_id));
    2126          70 :                 if (_ptr_interface_id) {
    2127           0 :                         NDR_PULL_ALLOC(ndr, r->in.interface_id);
    2128             :                 } else {
    2129          70 :                         r->in.interface_id = NULL;
    2130             :                 }
    2131          70 :                 if (r->in.interface_id) {
    2132           0 :                         _mem_save_interface_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2133           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->in.interface_id, 0);
    2134           0 :                         NDR_CHECK(ndr_pull_rpc_if_id_t(ndr, NDR_SCALARS, r->in.interface_id));
    2135           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_interface_id_0, 0);
    2136             :                 }
    2137          70 :                 NDR_CHECK(ndr_pull_epm_VersionOption(ndr, NDR_SCALARS, &r->in.vers_option));
    2138          70 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2139          70 :                         NDR_PULL_ALLOC(ndr, r->in.entry_handle);
    2140             :                 }
    2141          70 :                 _mem_save_entry_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2142          70 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.entry_handle, LIBNDR_FLAG_REF_ALLOC);
    2143          70 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.entry_handle));
    2144          70 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entry_handle_0, LIBNDR_FLAG_REF_ALLOC);
    2145          70 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_ents));
    2146          70 :                 NDR_PULL_ALLOC(ndr, r->out.entry_handle);
    2147          70 :                 *r->out.entry_handle = *r->in.entry_handle;
    2148          70 :                 NDR_PULL_ALLOC(ndr, r->out.num_ents);
    2149          70 :                 NDR_ZERO_STRUCTP(r->out.num_ents);
    2150             :         }
    2151         224 :         if (flags & NDR_OUT) {
    2152             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2153             :                 if (r->in.entry_handle == NULL) {
    2154             :                         NDR_PULL_ALLOC(ndr, r->in.entry_handle);
    2155             :                         NDR_ZERO_STRUCTP(r->in.entry_handle);
    2156             :                 }
    2157             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2158         154 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2159          15 :                         NDR_PULL_ALLOC(ndr, r->out.entry_handle);
    2160             :                 }
    2161         154 :                 _mem_save_entry_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2162         154 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.entry_handle, LIBNDR_FLAG_REF_ALLOC);
    2163         154 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.entry_handle));
    2164         154 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entry_handle_0, LIBNDR_FLAG_REF_ALLOC);
    2165         154 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2166          15 :                         NDR_PULL_ALLOC(ndr, r->out.num_ents);
    2167             :                 }
    2168         154 :                 _mem_save_num_ents_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2169         154 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_ents, LIBNDR_FLAG_REF_ALLOC);
    2170         154 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_ents));
    2171         154 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ents_0, LIBNDR_FLAG_REF_ALLOC);
    2172         154 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.entries));
    2173         154 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->out.entries));
    2174         154 :                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->out.entries, &size_entries_0));
    2175         154 :                 NDR_CHECK(ndr_get_array_length(ndr, (void*)&r->out.entries, &length_entries_0));
    2176         154 :                 if (length_entries_0 > size_entries_0) {
    2177           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_entries_0, length_entries_0);
    2178             :                 }
    2179         154 :                 NDR_PULL_ALLOC_N(ndr, r->out.entries, size_entries_0);
    2180         154 :                 _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2181         154 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.entries, 0);
    2182        1466 :                 for (cntr_entries_0 = 0; cntr_entries_0 < (length_entries_0); cntr_entries_0++) {
    2183        1312 :                         NDR_CHECK(ndr_pull_epm_entry_t(ndr, NDR_SCALARS, &r->out.entries[cntr_entries_0]));
    2184             :                 }
    2185        1466 :                 for (cntr_entries_0 = 0; cntr_entries_0 < (length_entries_0); cntr_entries_0++) {
    2186        1312 :                         NDR_CHECK(ndr_pull_epm_entry_t(ndr, NDR_BUFFERS, &r->out.entries[cntr_entries_0]));
    2187             :                 }
    2188         154 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
    2189         154 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
    2190         154 :                 if (r->out.entries) {
    2191         154 :                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.entries, r->in.max_ents));
    2192             :                 }
    2193         154 :                 if (r->out.entries) {
    2194         154 :                         NDR_CHECK(ndr_check_steal_array_length(ndr, (void*)&r->out.entries, *r->out.num_ents));
    2195             :                 }
    2196         156 :                 for (cntr_entries_0 = 0; cntr_entries_0 < (length_entries_0); cntr_entries_0++) {
    2197             :                 }
    2198             :         }
    2199         224 :         return NDR_ERR_SUCCESS;
    2200             : }
    2201             : 
    2202          30 : _PUBLIC_ void ndr_print_epm_Lookup(struct ndr_print *ndr, const char *name, int flags, const struct epm_Lookup *r)
    2203             : {
    2204             :         uint32_t cntr_entries_0;
    2205          30 :         ndr_print_struct(ndr, name, "epm_Lookup");
    2206          30 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2207          30 :         ndr->depth++;
    2208          30 :         if (flags & NDR_SET_VALUES) {
    2209           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2210             :         }
    2211          30 :         if (flags & NDR_IN) {
    2212           0 :                 ndr_print_struct(ndr, "in", "epm_Lookup");
    2213           0 :                 ndr->depth++;
    2214           0 :                 ndr_print_epm_InquiryType(ndr, "inquiry_type", r->in.inquiry_type);
    2215           0 :                 ndr_print_ptr(ndr, "object", r->in.object);
    2216           0 :                 ndr->depth++;
    2217           0 :                 if (r->in.object) {
    2218           0 :                         ndr_print_GUID(ndr, "object", r->in.object);
    2219             :                 }
    2220           0 :                 ndr->depth--;
    2221           0 :                 ndr_print_ptr(ndr, "interface_id", r->in.interface_id);
    2222           0 :                 ndr->depth++;
    2223           0 :                 if (r->in.interface_id) {
    2224           0 :                         ndr_print_rpc_if_id_t(ndr, "interface_id", r->in.interface_id);
    2225             :                 }
    2226           0 :                 ndr->depth--;
    2227           0 :                 ndr_print_epm_VersionOption(ndr, "vers_option", r->in.vers_option);
    2228           0 :                 ndr_print_ptr(ndr, "entry_handle", r->in.entry_handle);
    2229           0 :                 ndr->depth++;
    2230           0 :                 ndr_print_policy_handle(ndr, "entry_handle", r->in.entry_handle);
    2231           0 :                 ndr->depth--;
    2232           0 :                 ndr_print_uint32(ndr, "max_ents", r->in.max_ents);
    2233           0 :                 ndr->depth--;
    2234             :         }
    2235          30 :         if (flags & NDR_OUT) {
    2236          30 :                 ndr_print_struct(ndr, "out", "epm_Lookup");
    2237          30 :                 ndr->depth++;
    2238          30 :                 ndr_print_ptr(ndr, "entry_handle", r->out.entry_handle);
    2239          30 :                 ndr->depth++;
    2240          30 :                 ndr_print_policy_handle(ndr, "entry_handle", r->out.entry_handle);
    2241          30 :                 ndr->depth--;
    2242          30 :                 ndr_print_ptr(ndr, "num_ents", r->out.num_ents);
    2243          30 :                 ndr->depth++;
    2244          30 :                 ndr_print_uint32(ndr, "num_ents", *r->out.num_ents);
    2245          30 :                 ndr->depth--;
    2246          30 :                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)*r->out.num_ents);
    2247          30 :                 ndr->depth++;
    2248         270 :                 for (cntr_entries_0 = 0; cntr_entries_0 < (*r->out.num_ents); cntr_entries_0++) {
    2249         240 :                         ndr_print_epm_entry_t(ndr, "entries", &r->out.entries[cntr_entries_0]);
    2250             :                 }
    2251          30 :                 ndr->depth--;
    2252          30 :                 ndr_print_uint32(ndr, "result", r->out.result);
    2253          30 :                 ndr->depth--;
    2254             :         }
    2255          30 :         ndr->depth--;
    2256             : }
    2257             : 
    2258       43194 : _PUBLIC_ enum ndr_err_code ndr_push_epm_Map(struct ndr_push *ndr, int flags, const struct epm_Map *r)
    2259             : {
    2260             :         uint32_t cntr_towers_0;
    2261       43194 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2262       43194 :         if (flags & NDR_IN) {
    2263       36739 :                 if (r->in.entry_handle == NULL) {
    2264           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2265             :                 }
    2266       36739 :                 NDR_CHECK(ndr_push_full_ptr(ndr, r->in.object));
    2267       36739 :                 if (r->in.object) {
    2268       36737 :                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.object));
    2269             :                 }
    2270       36739 :                 NDR_CHECK(ndr_push_full_ptr(ndr, r->in.map_tower));
    2271       36739 :                 if (r->in.map_tower) {
    2272       36739 :                         NDR_CHECK(ndr_push_epm_twr_t(ndr, NDR_SCALARS, r->in.map_tower));
    2273             :                 }
    2274       36739 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.entry_handle));
    2275       36739 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_towers));
    2276             :         }
    2277       43194 :         if (flags & NDR_OUT) {
    2278        6455 :                 if (r->out.entry_handle == NULL) {
    2279           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2280             :                 }
    2281        6455 :                 if (r->out.num_towers == NULL) {
    2282           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2283             :                 }
    2284        6455 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.entry_handle));
    2285        6455 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_towers));
    2286        6455 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.max_towers));
    2287        6455 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    2288        6455 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.num_towers));
    2289       12386 :                 for (cntr_towers_0 = 0; cntr_towers_0 < (*r->out.num_towers); cntr_towers_0++) {
    2290        6056 :                         NDR_CHECK(ndr_push_epm_twr_p_t(ndr, NDR_SCALARS, &r->out.towers[cntr_towers_0]));
    2291             :                 }
    2292       12386 :                 for (cntr_towers_0 = 0; cntr_towers_0 < (*r->out.num_towers); cntr_towers_0++) {
    2293        6056 :                         NDR_CHECK(ndr_push_epm_twr_p_t(ndr, NDR_BUFFERS, &r->out.towers[cntr_towers_0]));
    2294             :                 }
    2295        6455 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
    2296             :         }
    2297       42944 :         return NDR_ERR_SUCCESS;
    2298             : }
    2299             : 
    2300       42965 : _PUBLIC_ enum ndr_err_code ndr_pull_epm_Map(struct ndr_pull *ndr, int flags, struct epm_Map *r)
    2301             : {
    2302             :         uint32_t _ptr_object;
    2303             :         uint32_t _ptr_map_tower;
    2304       42965 :         uint32_t size_towers_0 = 0;
    2305       42965 :         uint32_t length_towers_0 = 0;
    2306             :         uint32_t cntr_towers_0;
    2307       42965 :         TALLOC_CTX *_mem_save_object_0 = NULL;
    2308       42965 :         TALLOC_CTX *_mem_save_map_tower_0 = NULL;
    2309       42965 :         TALLOC_CTX *_mem_save_entry_handle_0 = NULL;
    2310       42965 :         TALLOC_CTX *_mem_save_num_towers_0 = NULL;
    2311       42965 :         TALLOC_CTX *_mem_save_towers_0 = NULL;
    2312       42965 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2313       42965 :         if (flags & NDR_IN) {
    2314        6226 :                 NDR_ZERO_STRUCT(r->out);
    2315             : 
    2316        6226 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object));
    2317        6226 :                 if (_ptr_object) {
    2318        5994 :                         NDR_PULL_ALLOC(ndr, r->in.object);
    2319             :                 } else {
    2320         232 :                         r->in.object = NULL;
    2321             :                 }
    2322        6226 :                 if (r->in.object) {
    2323        5994 :                         _mem_save_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2324        5994 :                         NDR_PULL_SET_MEM_CTX(ndr, r->in.object, 0);
    2325        5994 :                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.object));
    2326        5994 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_0, 0);
    2327             :                 }
    2328        6226 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_map_tower));
    2329        6226 :                 if (_ptr_map_tower) {
    2330        6226 :                         NDR_PULL_ALLOC(ndr, r->in.map_tower);
    2331             :                 } else {
    2332           0 :                         r->in.map_tower = NULL;
    2333             :                 }
    2334        6226 :                 if (r->in.map_tower) {
    2335        6226 :                         _mem_save_map_tower_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2336        6226 :                         NDR_PULL_SET_MEM_CTX(ndr, r->in.map_tower, 0);
    2337        6226 :                         NDR_CHECK(ndr_pull_epm_twr_t(ndr, NDR_SCALARS, r->in.map_tower));
    2338        6226 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_map_tower_0, 0);
    2339             :                 }
    2340        6226 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2341        6226 :                         NDR_PULL_ALLOC(ndr, r->in.entry_handle);
    2342             :                 }
    2343        6226 :                 _mem_save_entry_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2344        6226 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.entry_handle, LIBNDR_FLAG_REF_ALLOC);
    2345        6226 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.entry_handle));
    2346        6226 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entry_handle_0, LIBNDR_FLAG_REF_ALLOC);
    2347        6226 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_towers));
    2348        6226 :                 NDR_PULL_ALLOC(ndr, r->out.entry_handle);
    2349        6226 :                 *r->out.entry_handle = *r->in.entry_handle;
    2350        6226 :                 NDR_PULL_ALLOC(ndr, r->out.num_towers);
    2351        6226 :                 NDR_ZERO_STRUCTP(r->out.num_towers);
    2352             :         }
    2353       42965 :         if (flags & NDR_OUT) {
    2354             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2355             :                 if (r->in.entry_handle == NULL) {
    2356             :                         NDR_PULL_ALLOC(ndr, r->in.entry_handle);
    2357             :                         NDR_ZERO_STRUCTP(r->in.entry_handle);
    2358             :                 }
    2359             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2360       36739 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2361       29126 :                         NDR_PULL_ALLOC(ndr, r->out.entry_handle);
    2362             :                 }
    2363       36739 :                 _mem_save_entry_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2364       36739 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.entry_handle, LIBNDR_FLAG_REF_ALLOC);
    2365       36739 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.entry_handle));
    2366       36739 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entry_handle_0, LIBNDR_FLAG_REF_ALLOC);
    2367       36739 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2368       29126 :                         NDR_PULL_ALLOC(ndr, r->out.num_towers);
    2369             :                 }
    2370       36739 :                 _mem_save_num_towers_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2371       36739 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_towers, LIBNDR_FLAG_REF_ALLOC);
    2372       36739 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_towers));
    2373       36739 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_towers_0, LIBNDR_FLAG_REF_ALLOC);
    2374       36739 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.towers));
    2375       36739 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->out.towers));
    2376       36739 :                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->out.towers, &size_towers_0));
    2377       36739 :                 NDR_CHECK(ndr_get_array_length(ndr, (void*)&r->out.towers, &length_towers_0));
    2378       36739 :                 if (length_towers_0 > size_towers_0) {
    2379           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_towers_0, length_towers_0);
    2380             :                 }
    2381       36739 :                 NDR_PULL_ALLOC_N(ndr, r->out.towers, size_towers_0);
    2382       36739 :                 _mem_save_towers_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2383       36739 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.towers, 0);
    2384      306879 :                 for (cntr_towers_0 = 0; cntr_towers_0 < (length_towers_0); cntr_towers_0++) {
    2385      270140 :                         NDR_CHECK(ndr_pull_epm_twr_p_t(ndr, NDR_SCALARS, &r->out.towers[cntr_towers_0]));
    2386             :                 }
    2387      306754 :                 for (cntr_towers_0 = 0; cntr_towers_0 < (length_towers_0); cntr_towers_0++) {
    2388      270140 :                         NDR_CHECK(ndr_pull_epm_twr_p_t(ndr, NDR_BUFFERS, &r->out.towers[cntr_towers_0]));
    2389             :                 }
    2390       36739 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_towers_0, 0);
    2391       36739 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
    2392       36739 :                 if (r->out.towers) {
    2393       36739 :                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.towers, r->in.max_towers));
    2394             :                 }
    2395       36739 :                 if (r->out.towers) {
    2396       36739 :                         NDR_CHECK(ndr_check_steal_array_length(ndr, (void*)&r->out.towers, *r->out.num_towers));
    2397             :                 }
    2398       37300 :                 for (cntr_towers_0 = 0; cntr_towers_0 < (length_towers_0); cntr_towers_0++) {
    2399             :                 }
    2400             :         }
    2401       42713 :         return NDR_ERR_SUCCESS;
    2402             : }
    2403             : 
    2404         464 : _PUBLIC_ void ndr_print_epm_Map(struct ndr_print *ndr, const char *name, int flags, const struct epm_Map *r)
    2405             : {
    2406             :         uint32_t cntr_towers_0;
    2407         464 :         ndr_print_struct(ndr, name, "epm_Map");
    2408         464 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2409         464 :         ndr->depth++;
    2410         464 :         if (flags & NDR_SET_VALUES) {
    2411           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2412             :         }
    2413         464 :         if (flags & NDR_IN) {
    2414           2 :                 ndr_print_struct(ndr, "in", "epm_Map");
    2415           2 :                 ndr->depth++;
    2416           2 :                 ndr_print_ptr(ndr, "object", r->in.object);
    2417           2 :                 ndr->depth++;
    2418           2 :                 if (r->in.object) {
    2419           2 :                         ndr_print_GUID(ndr, "object", r->in.object);
    2420             :                 }
    2421           2 :                 ndr->depth--;
    2422           2 :                 ndr_print_ptr(ndr, "map_tower", r->in.map_tower);
    2423           2 :                 ndr->depth++;
    2424           2 :                 if (r->in.map_tower) {
    2425           2 :                         ndr_print_epm_twr_t(ndr, "map_tower", r->in.map_tower);
    2426             :                 }
    2427           2 :                 ndr->depth--;
    2428           2 :                 ndr_print_ptr(ndr, "entry_handle", r->in.entry_handle);
    2429           2 :                 ndr->depth++;
    2430           2 :                 ndr_print_policy_handle(ndr, "entry_handle", r->in.entry_handle);
    2431           2 :                 ndr->depth--;
    2432           2 :                 ndr_print_uint32(ndr, "max_towers", r->in.max_towers);
    2433           2 :                 ndr->depth--;
    2434             :         }
    2435         464 :         if (flags & NDR_OUT) {
    2436         462 :                 ndr_print_struct(ndr, "out", "epm_Map");
    2437         462 :                 ndr->depth++;
    2438         462 :                 ndr_print_ptr(ndr, "entry_handle", r->out.entry_handle);
    2439         462 :                 ndr->depth++;
    2440         462 :                 ndr_print_policy_handle(ndr, "entry_handle", r->out.entry_handle);
    2441         462 :                 ndr->depth--;
    2442         462 :                 ndr_print_ptr(ndr, "num_towers", r->out.num_towers);
    2443         462 :                 ndr->depth++;
    2444         462 :                 ndr_print_uint32(ndr, "num_towers", *r->out.num_towers);
    2445         462 :                 ndr->depth--;
    2446         462 :                 ndr->print(ndr, "%s: ARRAY(%d)", "towers", (int)*r->out.num_towers);
    2447         462 :                 ndr->depth++;
    2448         774 :                 for (cntr_towers_0 = 0; cntr_towers_0 < (*r->out.num_towers); cntr_towers_0++) {
    2449         312 :                         ndr_print_epm_twr_p_t(ndr, "towers", &r->out.towers[cntr_towers_0]);
    2450             :                 }
    2451         462 :                 ndr->depth--;
    2452         462 :                 ndr_print_uint32(ndr, "result", r->out.result);
    2453         462 :                 ndr->depth--;
    2454             :         }
    2455         464 :         ndr->depth--;
    2456             : }
    2457             : 
    2458       28751 : static enum ndr_err_code ndr_push_epm_LookupHandleFree(struct ndr_push *ndr, int flags, const struct epm_LookupHandleFree *r)
    2459             : {
    2460       28751 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2461       28751 :         if (flags & NDR_IN) {
    2462       28739 :                 if (r->in.entry_handle == NULL) {
    2463           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2464             :                 }
    2465       28739 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.entry_handle));
    2466             :         }
    2467       28751 :         if (flags & NDR_OUT) {
    2468          12 :                 if (r->out.entry_handle == NULL) {
    2469           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2470             :                 }
    2471          12 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.entry_handle));
    2472          12 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
    2473             :         }
    2474       28751 :         return NDR_ERR_SUCCESS;
    2475             : }
    2476             : 
    2477       28749 : static enum ndr_err_code ndr_pull_epm_LookupHandleFree(struct ndr_pull *ndr, int flags, struct epm_LookupHandleFree *r)
    2478             : {
    2479       28749 :         TALLOC_CTX *_mem_save_entry_handle_0 = NULL;
    2480       28749 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2481       28749 :         if (flags & NDR_IN) {
    2482          10 :                 NDR_ZERO_STRUCT(r->out);
    2483             : 
    2484          10 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2485          10 :                         NDR_PULL_ALLOC(ndr, r->in.entry_handle);
    2486             :                 }
    2487          10 :                 _mem_save_entry_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2488          10 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.entry_handle, LIBNDR_FLAG_REF_ALLOC);
    2489          10 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.entry_handle));
    2490          10 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entry_handle_0, LIBNDR_FLAG_REF_ALLOC);
    2491          10 :                 NDR_PULL_ALLOC(ndr, r->out.entry_handle);
    2492          10 :                 *r->out.entry_handle = *r->in.entry_handle;
    2493             :         }
    2494       28749 :         if (flags & NDR_OUT) {
    2495             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2496             :                 if (r->in.entry_handle == NULL) {
    2497             :                         NDR_PULL_ALLOC(ndr, r->in.entry_handle);
    2498             :                         NDR_ZERO_STRUCTP(r->in.entry_handle);
    2499             :                 }
    2500             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2501       28739 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2502       28727 :                         NDR_PULL_ALLOC(ndr, r->out.entry_handle);
    2503             :                 }
    2504       28739 :                 _mem_save_entry_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2505       28739 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.entry_handle, LIBNDR_FLAG_REF_ALLOC);
    2506       28739 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.entry_handle));
    2507       28739 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entry_handle_0, LIBNDR_FLAG_REF_ALLOC);
    2508       28739 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
    2509             :         }
    2510       28749 :         return NDR_ERR_SUCCESS;
    2511             : }
    2512             : 
    2513           4 : _PUBLIC_ void ndr_print_epm_LookupHandleFree(struct ndr_print *ndr, const char *name, int flags, const struct epm_LookupHandleFree *r)
    2514             : {
    2515           4 :         ndr_print_struct(ndr, name, "epm_LookupHandleFree");
    2516           4 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2517           4 :         ndr->depth++;
    2518           4 :         if (flags & NDR_SET_VALUES) {
    2519           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2520             :         }
    2521           4 :         if (flags & NDR_IN) {
    2522           0 :                 ndr_print_struct(ndr, "in", "epm_LookupHandleFree");
    2523           0 :                 ndr->depth++;
    2524           0 :                 ndr_print_ptr(ndr, "entry_handle", r->in.entry_handle);
    2525           0 :                 ndr->depth++;
    2526           0 :                 ndr_print_policy_handle(ndr, "entry_handle", r->in.entry_handle);
    2527           0 :                 ndr->depth--;
    2528           0 :                 ndr->depth--;
    2529             :         }
    2530           4 :         if (flags & NDR_OUT) {
    2531           4 :                 ndr_print_struct(ndr, "out", "epm_LookupHandleFree");
    2532           4 :                 ndr->depth++;
    2533           4 :                 ndr_print_ptr(ndr, "entry_handle", r->out.entry_handle);
    2534           4 :                 ndr->depth++;
    2535           4 :                 ndr_print_policy_handle(ndr, "entry_handle", r->out.entry_handle);
    2536           4 :                 ndr->depth--;
    2537           4 :                 ndr_print_uint32(ndr, "result", r->out.result);
    2538           4 :                 ndr->depth--;
    2539             :         }
    2540           4 :         ndr->depth--;
    2541             : }
    2542             : 
    2543           0 : static enum ndr_err_code ndr_push_epm_InqObject(struct ndr_push *ndr, int flags, const struct epm_InqObject *r)
    2544             : {
    2545           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2546           0 :         if (flags & NDR_IN) {
    2547           0 :                 if (r->in.epm_object == NULL) {
    2548           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2549             :                 }
    2550           0 :                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.epm_object));
    2551             :         }
    2552           0 :         if (flags & NDR_OUT) {
    2553           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
    2554             :         }
    2555           0 :         return NDR_ERR_SUCCESS;
    2556             : }
    2557             : 
    2558           0 : static enum ndr_err_code ndr_pull_epm_InqObject(struct ndr_pull *ndr, int flags, struct epm_InqObject *r)
    2559             : {
    2560           0 :         TALLOC_CTX *_mem_save_epm_object_0 = NULL;
    2561           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2562           0 :         if (flags & NDR_IN) {
    2563           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2564           0 :                         NDR_PULL_ALLOC(ndr, r->in.epm_object);
    2565             :                 }
    2566           0 :                 _mem_save_epm_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2567           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.epm_object, LIBNDR_FLAG_REF_ALLOC);
    2568           0 :                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.epm_object));
    2569           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_epm_object_0, LIBNDR_FLAG_REF_ALLOC);
    2570             :         }
    2571           0 :         if (flags & NDR_OUT) {
    2572             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2573             :                 if (r->in.epm_object == NULL) {
    2574             :                         NDR_PULL_ALLOC(ndr, r->in.epm_object);
    2575             :                         NDR_ZERO_STRUCTP(r->in.epm_object);
    2576             :                 }
    2577             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2578           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
    2579             :         }
    2580           0 :         return NDR_ERR_SUCCESS;
    2581             : }
    2582             : 
    2583           0 : _PUBLIC_ void ndr_print_epm_InqObject(struct ndr_print *ndr, const char *name, int flags, const struct epm_InqObject *r)
    2584             : {
    2585           0 :         ndr_print_struct(ndr, name, "epm_InqObject");
    2586           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2587           0 :         ndr->depth++;
    2588           0 :         if (flags & NDR_SET_VALUES) {
    2589           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2590             :         }
    2591           0 :         if (flags & NDR_IN) {
    2592           0 :                 ndr_print_struct(ndr, "in", "epm_InqObject");
    2593           0 :                 ndr->depth++;
    2594           0 :                 ndr_print_ptr(ndr, "epm_object", r->in.epm_object);
    2595           0 :                 ndr->depth++;
    2596           0 :                 ndr_print_GUID(ndr, "epm_object", r->in.epm_object);
    2597           0 :                 ndr->depth--;
    2598           0 :                 ndr->depth--;
    2599             :         }
    2600           0 :         if (flags & NDR_OUT) {
    2601           0 :                 ndr_print_struct(ndr, "out", "epm_InqObject");
    2602           0 :                 ndr->depth++;
    2603           0 :                 ndr_print_uint32(ndr, "result", r->out.result);
    2604           0 :                 ndr->depth--;
    2605             :         }
    2606           0 :         ndr->depth--;
    2607             : }
    2608             : 
    2609           0 : static enum ndr_err_code ndr_push_epm_MgmtDelete(struct ndr_push *ndr, int flags, const struct epm_MgmtDelete *r)
    2610             : {
    2611           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2612           0 :         if (flags & NDR_IN) {
    2613           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.object_speced));
    2614           0 :                 NDR_CHECK(ndr_push_full_ptr(ndr, r->in.object));
    2615           0 :                 if (r->in.object) {
    2616           0 :                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.object));
    2617             :                 }
    2618           0 :                 NDR_CHECK(ndr_push_full_ptr(ndr, r->in.tower));
    2619           0 :                 if (r->in.tower) {
    2620           0 :                         NDR_CHECK(ndr_push_epm_twr_t(ndr, NDR_SCALARS, r->in.tower));
    2621             :                 }
    2622             :         }
    2623           0 :         if (flags & NDR_OUT) {
    2624           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
    2625             :         }
    2626           0 :         return NDR_ERR_SUCCESS;
    2627             : }
    2628             : 
    2629           0 : static enum ndr_err_code ndr_pull_epm_MgmtDelete(struct ndr_pull *ndr, int flags, struct epm_MgmtDelete *r)
    2630             : {
    2631             :         uint32_t _ptr_object;
    2632             :         uint32_t _ptr_tower;
    2633           0 :         TALLOC_CTX *_mem_save_object_0 = NULL;
    2634           0 :         TALLOC_CTX *_mem_save_tower_0 = NULL;
    2635           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2636           0 :         if (flags & NDR_IN) {
    2637           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.object_speced));
    2638           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object));
    2639           0 :                 if (_ptr_object) {
    2640           0 :                         NDR_PULL_ALLOC(ndr, r->in.object);
    2641             :                 } else {
    2642           0 :                         r->in.object = NULL;
    2643             :                 }
    2644           0 :                 if (r->in.object) {
    2645           0 :                         _mem_save_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2646           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->in.object, 0);
    2647           0 :                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.object));
    2648           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_0, 0);
    2649             :                 }
    2650           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_tower));
    2651           0 :                 if (_ptr_tower) {
    2652           0 :                         NDR_PULL_ALLOC(ndr, r->in.tower);
    2653             :                 } else {
    2654           0 :                         r->in.tower = NULL;
    2655             :                 }
    2656           0 :                 if (r->in.tower) {
    2657           0 :                         _mem_save_tower_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2658           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->in.tower, 0);
    2659           0 :                         NDR_CHECK(ndr_pull_epm_twr_t(ndr, NDR_SCALARS, r->in.tower));
    2660           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_tower_0, 0);
    2661             :                 }
    2662             :         }
    2663           0 :         if (flags & NDR_OUT) {
    2664             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2665             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2666           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
    2667             :         }
    2668           0 :         return NDR_ERR_SUCCESS;
    2669             : }
    2670             : 
    2671           0 : _PUBLIC_ void ndr_print_epm_MgmtDelete(struct ndr_print *ndr, const char *name, int flags, const struct epm_MgmtDelete *r)
    2672             : {
    2673           0 :         ndr_print_struct(ndr, name, "epm_MgmtDelete");
    2674           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2675           0 :         ndr->depth++;
    2676           0 :         if (flags & NDR_SET_VALUES) {
    2677           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2678             :         }
    2679           0 :         if (flags & NDR_IN) {
    2680           0 :                 ndr_print_struct(ndr, "in", "epm_MgmtDelete");
    2681           0 :                 ndr->depth++;
    2682           0 :                 ndr_print_uint32(ndr, "object_speced", r->in.object_speced);
    2683           0 :                 ndr_print_ptr(ndr, "object", r->in.object);
    2684           0 :                 ndr->depth++;
    2685           0 :                 if (r->in.object) {
    2686           0 :                         ndr_print_GUID(ndr, "object", r->in.object);
    2687             :                 }
    2688           0 :                 ndr->depth--;
    2689           0 :                 ndr_print_ptr(ndr, "tower", r->in.tower);
    2690           0 :                 ndr->depth++;
    2691           0 :                 if (r->in.tower) {
    2692           0 :                         ndr_print_epm_twr_t(ndr, "tower", r->in.tower);
    2693             :                 }
    2694           0 :                 ndr->depth--;
    2695           0 :                 ndr->depth--;
    2696             :         }
    2697           0 :         if (flags & NDR_OUT) {
    2698           0 :                 ndr_print_struct(ndr, "out", "epm_MgmtDelete");
    2699           0 :                 ndr->depth++;
    2700           0 :                 ndr_print_uint32(ndr, "result", r->out.result);
    2701           0 :                 ndr->depth--;
    2702             :         }
    2703           0 :         ndr->depth--;
    2704             : }
    2705             : 
    2706           0 : static enum ndr_err_code ndr_push_epm_MapAuth(struct ndr_push *ndr, int flags, const struct epm_MapAuth *r)
    2707             : {
    2708           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2709           0 :         if (flags & NDR_IN) {
    2710             :         }
    2711           0 :         if (flags & NDR_OUT) {
    2712           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
    2713             :         }
    2714           0 :         return NDR_ERR_SUCCESS;
    2715             : }
    2716             : 
    2717           0 : static enum ndr_err_code ndr_pull_epm_MapAuth(struct ndr_pull *ndr, int flags, struct epm_MapAuth *r)
    2718             : {
    2719           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2720           0 :         if (flags & NDR_IN) {
    2721             :         }
    2722           0 :         if (flags & NDR_OUT) {
    2723             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2724             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2725           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
    2726             :         }
    2727           0 :         return NDR_ERR_SUCCESS;
    2728             : }
    2729             : 
    2730           0 : _PUBLIC_ void ndr_print_epm_MapAuth(struct ndr_print *ndr, const char *name, int flags, const struct epm_MapAuth *r)
    2731             : {
    2732           0 :         ndr_print_struct(ndr, name, "epm_MapAuth");
    2733           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2734           0 :         ndr->depth++;
    2735           0 :         if (flags & NDR_SET_VALUES) {
    2736           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2737             :         }
    2738           0 :         if (flags & NDR_IN) {
    2739           0 :                 ndr_print_struct(ndr, "in", "epm_MapAuth");
    2740           0 :                 ndr->depth++;
    2741           0 :                 ndr->depth--;
    2742             :         }
    2743           0 :         if (flags & NDR_OUT) {
    2744           0 :                 ndr_print_struct(ndr, "out", "epm_MapAuth");
    2745           0 :                 ndr->depth++;
    2746           0 :                 ndr_print_uint32(ndr, "result", r->out.result);
    2747           0 :                 ndr->depth--;
    2748             :         }
    2749           0 :         ndr->depth--;
    2750             : }
    2751             : 
    2752             : #ifndef SKIP_NDR_TABLE_epmapper
    2753             : static const struct ndr_interface_public_struct epmapper_public_structs[] = {
    2754             :         {
    2755             :                 .name = "epm_twr_t",
    2756             :                 .struct_size = sizeof(struct epm_twr_t ),
    2757             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_epm_twr_t,
    2758             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_epm_twr_t,
    2759             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_epm_twr_t,
    2760             :         },
    2761             :         { .name = NULL }
    2762             : };
    2763             : 
    2764             : static const struct ndr_interface_call epmapper_calls[] = {
    2765             :         {
    2766             :                 "epm_Insert",
    2767             :                 sizeof(struct epm_Insert),
    2768             :                 (ndr_push_flags_fn_t) ndr_push_epm_Insert,
    2769             :                 (ndr_pull_flags_fn_t) ndr_pull_epm_Insert,
    2770             :                 (ndr_print_function_t) ndr_print_epm_Insert,
    2771             :                 { 0, NULL },
    2772             :                 { 0, NULL },
    2773             :         },
    2774             :         {
    2775             :                 "epm_Delete",
    2776             :                 sizeof(struct epm_Delete),
    2777             :                 (ndr_push_flags_fn_t) ndr_push_epm_Delete,
    2778             :                 (ndr_pull_flags_fn_t) ndr_pull_epm_Delete,
    2779             :                 (ndr_print_function_t) ndr_print_epm_Delete,
    2780             :                 { 0, NULL },
    2781             :                 { 0, NULL },
    2782             :         },
    2783             :         {
    2784             :                 "epm_Lookup",
    2785             :                 sizeof(struct epm_Lookup),
    2786             :                 (ndr_push_flags_fn_t) ndr_push_epm_Lookup,
    2787             :                 (ndr_pull_flags_fn_t) ndr_pull_epm_Lookup,
    2788             :                 (ndr_print_function_t) ndr_print_epm_Lookup,
    2789             :                 { 0, NULL },
    2790             :                 { 0, NULL },
    2791             :         },
    2792             :         {
    2793             :                 "epm_Map",
    2794             :                 sizeof(struct epm_Map),
    2795             :                 (ndr_push_flags_fn_t) ndr_push_epm_Map,
    2796             :                 (ndr_pull_flags_fn_t) ndr_pull_epm_Map,
    2797             :                 (ndr_print_function_t) ndr_print_epm_Map,
    2798             :                 { 0, NULL },
    2799             :                 { 0, NULL },
    2800             :         },
    2801             :         {
    2802             :                 "epm_LookupHandleFree",
    2803             :                 sizeof(struct epm_LookupHandleFree),
    2804             :                 (ndr_push_flags_fn_t) ndr_push_epm_LookupHandleFree,
    2805             :                 (ndr_pull_flags_fn_t) ndr_pull_epm_LookupHandleFree,
    2806             :                 (ndr_print_function_t) ndr_print_epm_LookupHandleFree,
    2807             :                 { 0, NULL },
    2808             :                 { 0, NULL },
    2809             :         },
    2810             :         {
    2811             :                 "epm_InqObject",
    2812             :                 sizeof(struct epm_InqObject),
    2813             :                 (ndr_push_flags_fn_t) ndr_push_epm_InqObject,
    2814             :                 (ndr_pull_flags_fn_t) ndr_pull_epm_InqObject,
    2815             :                 (ndr_print_function_t) ndr_print_epm_InqObject,
    2816             :                 { 0, NULL },
    2817             :                 { 0, NULL },
    2818             :         },
    2819             :         {
    2820             :                 "epm_MgmtDelete",
    2821             :                 sizeof(struct epm_MgmtDelete),
    2822             :                 (ndr_push_flags_fn_t) ndr_push_epm_MgmtDelete,
    2823             :                 (ndr_pull_flags_fn_t) ndr_pull_epm_MgmtDelete,
    2824             :                 (ndr_print_function_t) ndr_print_epm_MgmtDelete,
    2825             :                 { 0, NULL },
    2826             :                 { 0, NULL },
    2827             :         },
    2828             :         {
    2829             :                 "epm_MapAuth",
    2830             :                 sizeof(struct epm_MapAuth),
    2831             :                 (ndr_push_flags_fn_t) ndr_push_epm_MapAuth,
    2832             :                 (ndr_pull_flags_fn_t) ndr_pull_epm_MapAuth,
    2833             :                 (ndr_print_function_t) ndr_print_epm_MapAuth,
    2834             :                 { 0, NULL },
    2835             :                 { 0, NULL },
    2836             :         },
    2837             :         { .name = NULL }
    2838             : };
    2839             : 
    2840             : static const char * const epmapper_endpoint_strings[] = {
    2841             :         "ncacn_np:[\\pipe\\epmapper]", 
    2842             :         "ncacn_ip_tcp:[135]", 
    2843             :         "ncacn_http:[593]", 
    2844             :         "ncalrpc:[EPMAPPER]", 
    2845             : };
    2846             : 
    2847             : static const struct ndr_interface_string_array epmapper_endpoints = {
    2848             :         .count  = 4,
    2849             :         .names  = epmapper_endpoint_strings
    2850             : };
    2851             : 
    2852             : static const char * const epmapper_authservice_strings[] = {
    2853             :         "host", 
    2854             : };
    2855             : 
    2856             : static const struct ndr_interface_string_array epmapper_authservices = {
    2857             :         .count  = 1,
    2858             :         .names  = epmapper_authservice_strings
    2859             : };
    2860             : 
    2861             : 
    2862             : const struct ndr_interface_table ndr_table_epmapper = {
    2863             :         .name           = "epmapper",
    2864             :         .syntax_id      = {
    2865             :                 {0xe1af8308,0x5d1f,0x11c9,{0x91,0xa4},{0x08,0x00,0x2b,0x14,0xa0,0xfa}},
    2866             :                 NDR_EPMAPPER_VERSION
    2867             :         },
    2868             :         .helpstring     = NDR_EPMAPPER_HELPSTRING,
    2869             :         .num_calls      = 8,
    2870             :         .calls          = epmapper_calls,
    2871             :         .num_public_structs     = 1,
    2872             :         .public_structs         = epmapper_public_structs,
    2873             :         .endpoints      = &epmapper_endpoints,
    2874             :         .authservices   = &epmapper_authservices
    2875             : };
    2876             : 
    2877             : #endif /* SKIP_NDR_TABLE_epmapper */

Generated by: LCOV version 1.13