LCOV - code coverage report
Current view: top level - bin/default/librpc/gen_ndr - ndr_frstrans.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 0 1726 0.0 %
Date: 2021-09-23 10:06:22 Functions: 0 123 0.0 %

          Line data    Source code
       1             : /* parser auto-generated by pidl */
       2             : 
       3             : #include "includes.h"
       4             : #include "bin/default/librpc/gen_ndr/ndr_frstrans.h"
       5             : 
       6             : #include "librpc/gen_ndr/ndr_misc.h"
       7           0 : static enum ndr_err_code ndr_push_frstrans_ProtocolVersion(struct ndr_push *ndr, int ndr_flags, enum frstrans_ProtocolVersion r)
       8             : {
       9             :         {
      10           0 :                 uint32_t _flags_save_ENUM = ndr->flags;
      11           0 :                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
      12           0 :                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
      13           0 :                 ndr->flags = _flags_save_ENUM;
      14             :         }
      15           0 :         return NDR_ERR_SUCCESS;
      16             : }
      17             : 
      18           0 : static enum ndr_err_code ndr_pull_frstrans_ProtocolVersion(struct ndr_pull *ndr, int ndr_flags, enum frstrans_ProtocolVersion *r)
      19             : {
      20             :         uint32_t v;
      21             :         {
      22           0 :                 uint32_t _flags_save_ENUM = ndr->flags;
      23           0 :                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
      24           0 :                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
      25           0 :                 *r = v;
      26           0 :                 ndr->flags = _flags_save_ENUM;
      27             :         }
      28           0 :         return NDR_ERR_SUCCESS;
      29             : }
      30             : 
      31           0 : _PUBLIC_ void ndr_print_frstrans_ProtocolVersion(struct ndr_print *ndr, const char *name, enum frstrans_ProtocolVersion r)
      32             : {
      33           0 :         const char *val = NULL;
      34             : 
      35             :         {
      36           0 :                 uint32_t _flags_save_ENUM = ndr->flags;
      37           0 :                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
      38           0 :                 switch (r) {
      39           0 :                         case FRSTRANS_PROTOCOL_VERSION_W2K3R2: val = "FRSTRANS_PROTOCOL_VERSION_W2K3R2"; break;
      40           0 :                         case FRSTRANS_PROTOCOL_VERSION_LONGHORN_SERVER: val = "FRSTRANS_PROTOCOL_VERSION_LONGHORN_SERVER"; break;
      41             :                 }
      42           0 :                 ndr_print_enum(ndr, name, "ENUM", val, r);
      43           0 :                 ndr->flags = _flags_save_ENUM;
      44             :         }
      45           0 : }
      46             : 
      47           0 : static enum ndr_err_code ndr_push_frstrans_TransportFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
      48             : {
      49           0 :         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
      50           0 :         return NDR_ERR_SUCCESS;
      51             : }
      52             : 
      53           0 : static enum ndr_err_code ndr_pull_frstrans_TransportFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
      54             : {
      55             :         uint32_t v;
      56           0 :         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
      57           0 :         *r = v;
      58           0 :         return NDR_ERR_SUCCESS;
      59             : }
      60             : 
      61           0 : _PUBLIC_ void ndr_print_frstrans_TransportFlags(struct ndr_print *ndr, const char *name, uint32_t r)
      62             : {
      63           0 :         ndr_print_uint32(ndr, name, r);
      64           0 :         ndr->depth++;
      65           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "FRSTRANS_TRANSPORT_SUPPORTS_RDC_SIMILARITY", FRSTRANS_TRANSPORT_SUPPORTS_RDC_SIMILARITY, r);
      66           0 :         ndr->depth--;
      67           0 : }
      68             : 
      69           0 : static enum ndr_err_code ndr_push_frstrans_UpdateRequestType(struct ndr_push *ndr, int ndr_flags, enum frstrans_UpdateRequestType r)
      70             : {
      71           0 :         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
      72           0 :         return NDR_ERR_SUCCESS;
      73             : }
      74             : 
      75           0 : static enum ndr_err_code ndr_pull_frstrans_UpdateRequestType(struct ndr_pull *ndr, int ndr_flags, enum frstrans_UpdateRequestType *r)
      76             : {
      77             :         uint16_t v;
      78           0 :         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
      79           0 :         *r = v;
      80           0 :         return NDR_ERR_SUCCESS;
      81             : }
      82             : 
      83           0 : _PUBLIC_ void ndr_print_frstrans_UpdateRequestType(struct ndr_print *ndr, const char *name, enum frstrans_UpdateRequestType r)
      84             : {
      85           0 :         const char *val = NULL;
      86             : 
      87           0 :         switch (r) {
      88           0 :                 case FRSTRANS_UPDATE_REQUEST_ALL: val = "FRSTRANS_UPDATE_REQUEST_ALL"; break;
      89           0 :                 case FRSTRANS_UPDATE_REQUEST_TOMBSTONES: val = "FRSTRANS_UPDATE_REQUEST_TOMBSTONES"; break;
      90           0 :                 case FRSTRANS_UPDATE_REQUEST_LIVE: val = "FRSTRANS_UPDATE_REQUEST_LIVE"; break;
      91             :         }
      92           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
      93           0 : }
      94             : 
      95           0 : static enum ndr_err_code ndr_push_frstrans_UpdateStatus(struct ndr_push *ndr, int ndr_flags, enum frstrans_UpdateStatus r)
      96             : {
      97           0 :         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
      98           0 :         return NDR_ERR_SUCCESS;
      99             : }
     100             : 
     101           0 : static enum ndr_err_code ndr_pull_frstrans_UpdateStatus(struct ndr_pull *ndr, int ndr_flags, enum frstrans_UpdateStatus *r)
     102             : {
     103             :         uint16_t v;
     104           0 :         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
     105           0 :         *r = v;
     106           0 :         return NDR_ERR_SUCCESS;
     107             : }
     108             : 
     109           0 : _PUBLIC_ void ndr_print_frstrans_UpdateStatus(struct ndr_print *ndr, const char *name, enum frstrans_UpdateStatus r)
     110             : {
     111           0 :         const char *val = NULL;
     112             : 
     113           0 :         switch (r) {
     114           0 :                 case FRSTRANS_UPDATE_STATUS_DONE: val = "FRSTRANS_UPDATE_STATUS_DONE"; break;
     115           0 :                 case FRSTRANS_UPDATE_STATUS_MORE: val = "FRSTRANS_UPDATE_STATUS_MORE"; break;
     116             :         }
     117           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
     118           0 : }
     119             : 
     120           0 : _PUBLIC_ enum ndr_err_code ndr_push_frstrans_VersionVector(struct ndr_push *ndr, int ndr_flags, const struct frstrans_VersionVector *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, 8));
     125           0 :                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->db_guid));
     126           0 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->low));
     127           0 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->high));
     128           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
     129             :         }
     130           0 :         if (ndr_flags & NDR_BUFFERS) {
     131             :         }
     132           0 :         return NDR_ERR_SUCCESS;
     133             : }
     134             : 
     135           0 : _PUBLIC_ enum ndr_err_code ndr_pull_frstrans_VersionVector(struct ndr_pull *ndr, int ndr_flags, struct frstrans_VersionVector *r)
     136             : {
     137           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     138           0 :         if (ndr_flags & NDR_SCALARS) {
     139           0 :                 NDR_CHECK(ndr_pull_align(ndr, 8));
     140           0 :                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->db_guid));
     141           0 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->low));
     142           0 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->high));
     143           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
     144             :         }
     145           0 :         if (ndr_flags & NDR_BUFFERS) {
     146             :         }
     147           0 :         return NDR_ERR_SUCCESS;
     148             : }
     149             : 
     150           0 : static void ndr_print_flags_frstrans_VersionVector(struct ndr_print *ndr, const char *name, int unused, const struct frstrans_VersionVector *r)
     151             : {
     152           0 :         ndr_print_frstrans_VersionVector(ndr, name, r);
     153           0 : }
     154             : 
     155           0 : _PUBLIC_ void ndr_print_frstrans_VersionVector(struct ndr_print *ndr, const char *name, const struct frstrans_VersionVector *r)
     156             : {
     157           0 :         ndr_print_struct(ndr, name, "frstrans_VersionVector");
     158           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     159           0 :         ndr->depth++;
     160           0 :         ndr_print_GUID(ndr, "db_guid", &r->db_guid);
     161           0 :         ndr_print_hyper(ndr, "low", r->low);
     162           0 :         ndr_print_hyper(ndr, "high", r->high);
     163           0 :         ndr->depth--;
     164             : }
     165             : 
     166           0 : static enum ndr_err_code ndr_push_frstrans_Update(struct ndr_push *ndr, int ndr_flags, const struct frstrans_Update *r)
     167             : {
     168             :         {
     169           0 :                 uint32_t _flags_save_STRUCT = ndr->flags;
     170           0 :                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
     171           0 :                 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     172           0 :                 if (ndr_flags & NDR_SCALARS) {
     173           0 :                         NDR_CHECK(ndr_push_align(ndr, 8));
     174           0 :                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->present));
     175           0 :                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->name_conflict));
     176           0 :                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->attributes));
     177           0 :                         NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->fence));
     178           0 :                         NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->clock));
     179           0 :                         NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->create_time));
     180           0 :                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->content_set_guid));
     181           0 :                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->sha1_hash, 20));
     182           0 :                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->rdc_similarity, 16));
     183           0 :                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->uid_db_guid));
     184           0 :                         NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->uid_version));
     185           0 :                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->gsvn_db_guid));
     186           0 :                         NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->gsvn_version));
     187           0 :                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->parent_db_guid));
     188           0 :                         NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->parent_version));
     189           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     190           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 261));
     191           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, 261, sizeof(uint16_t), CH_UTF16));
     192           0 :                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
     193           0 :                         NDR_CHECK(ndr_push_trailer_align(ndr, 8));
     194             :                 }
     195           0 :                 if (ndr_flags & NDR_BUFFERS) {
     196             :                 }
     197           0 :                 ndr->flags = _flags_save_STRUCT;
     198             :         }
     199           0 :         return NDR_ERR_SUCCESS;
     200             : }
     201             : 
     202           0 : static enum ndr_err_code ndr_pull_frstrans_Update(struct ndr_pull *ndr, int ndr_flags, struct frstrans_Update *r)
     203             : {
     204           0 :         uint32_t size_sha1_hash_0 = 0;
     205           0 :         uint32_t size_rdc_similarity_0 = 0;
     206           0 :         uint32_t size_name_0 = 0;
     207           0 :         uint32_t length_name_0 = 0;
     208             :         {
     209           0 :                 uint32_t _flags_save_STRUCT = ndr->flags;
     210           0 :                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
     211           0 :                 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     212           0 :                 if (ndr_flags & NDR_SCALARS) {
     213           0 :                         NDR_CHECK(ndr_pull_align(ndr, 8));
     214           0 :                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->present));
     215           0 :                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->name_conflict));
     216           0 :                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->attributes));
     217           0 :                         NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->fence));
     218           0 :                         NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->clock));
     219           0 :                         NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->create_time));
     220           0 :                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->content_set_guid));
     221           0 :                         size_sha1_hash_0 = 20;
     222           0 :                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->sha1_hash, size_sha1_hash_0));
     223           0 :                         size_rdc_similarity_0 = 16;
     224           0 :                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->rdc_similarity, size_rdc_similarity_0));
     225           0 :                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->uid_db_guid));
     226           0 :                         NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->uid_version));
     227           0 :                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->gsvn_db_guid));
     228           0 :                         NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->gsvn_version));
     229           0 :                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->parent_db_guid));
     230           0 :                         NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->parent_version));
     231           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
     232           0 :                         size_name_0 = 261;
     233           0 :                         NDR_CHECK(ndr_get_array_length(ndr, (void*)&r->name, &length_name_0));
     234           0 :                         if (length_name_0 > size_name_0) {
     235           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_name_0, length_name_0);
     236             :                         }
     237           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_name_0, sizeof(uint16_t)));
     238           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, length_name_0, sizeof(uint16_t), CH_UTF16));
     239           0 :                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
     240           0 :                         if (r->name) {
     241           0 :                                 NDR_CHECK(ndr_check_steal_array_length(ndr, (void*)&r->name, 261));
     242             :                         }
     243           0 :                         NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
     244             :                 }
     245           0 :                 if (ndr_flags & NDR_BUFFERS) {
     246             :                 }
     247           0 :                 ndr->flags = _flags_save_STRUCT;
     248             :         }
     249           0 :         return NDR_ERR_SUCCESS;
     250             : }
     251             : 
     252           0 : _PUBLIC_ void ndr_print_frstrans_Update(struct ndr_print *ndr, const char *name, const struct frstrans_Update *r)
     253             : {
     254           0 :         ndr_print_struct(ndr, name, "frstrans_Update");
     255           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     256             :         {
     257           0 :                 uint32_t _flags_save_STRUCT = ndr->flags;
     258           0 :                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
     259           0 :                 ndr->depth++;
     260           0 :                 ndr_print_uint32(ndr, "present", r->present);
     261           0 :                 ndr_print_uint32(ndr, "name_conflict", r->name_conflict);
     262           0 :                 ndr_print_uint32(ndr, "attributes", r->attributes);
     263           0 :                 ndr_print_NTTIME(ndr, "fence", r->fence);
     264           0 :                 ndr_print_NTTIME(ndr, "clock", r->clock);
     265           0 :                 ndr_print_NTTIME(ndr, "create_time", r->create_time);
     266           0 :                 ndr_print_GUID(ndr, "content_set_guid", &r->content_set_guid);
     267           0 :                 ndr_print_array_uint8(ndr, "sha1_hash", r->sha1_hash, 20);
     268           0 :                 ndr_print_array_uint8(ndr, "rdc_similarity", r->rdc_similarity, 16);
     269           0 :                 ndr_print_GUID(ndr, "uid_db_guid", &r->uid_db_guid);
     270           0 :                 ndr_print_hyper(ndr, "uid_version", r->uid_version);
     271           0 :                 ndr_print_GUID(ndr, "gsvn_db_guid", &r->gsvn_db_guid);
     272           0 :                 ndr_print_hyper(ndr, "gsvn_version", r->gsvn_version);
     273           0 :                 ndr_print_GUID(ndr, "parent_db_guid", &r->parent_db_guid);
     274           0 :                 ndr_print_hyper(ndr, "parent_version", r->parent_version);
     275           0 :                 ndr_print_string(ndr, "name", r->name);
     276           0 :                 ndr_print_uint32(ndr, "flags", r->flags);
     277           0 :                 ndr->depth--;
     278           0 :                 ndr->flags = _flags_save_STRUCT;
     279             :         }
     280             : }
     281             : 
     282           0 : static enum ndr_err_code ndr_push_frstrans_VersionRequestType(struct ndr_push *ndr, int ndr_flags, enum frstrans_VersionRequestType r)
     283             : {
     284           0 :         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
     285           0 :         return NDR_ERR_SUCCESS;
     286             : }
     287             : 
     288           0 : static enum ndr_err_code ndr_pull_frstrans_VersionRequestType(struct ndr_pull *ndr, int ndr_flags, enum frstrans_VersionRequestType *r)
     289             : {
     290             :         uint16_t v;
     291           0 :         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
     292           0 :         *r = v;
     293           0 :         return NDR_ERR_SUCCESS;
     294             : }
     295             : 
     296           0 : _PUBLIC_ void ndr_print_frstrans_VersionRequestType(struct ndr_print *ndr, const char *name, enum frstrans_VersionRequestType r)
     297             : {
     298           0 :         const char *val = NULL;
     299             : 
     300           0 :         switch (r) {
     301           0 :                 case FRSTRANS_VERSION_REQUEST_NORNAL_SYNC: val = "FRSTRANS_VERSION_REQUEST_NORNAL_SYNC"; break;
     302           0 :                 case FRSTRANS_VERSION_REQUEST_SLOW_SYNC: val = "FRSTRANS_VERSION_REQUEST_SLOW_SYNC"; break;
     303           0 :                 case FRSTRANS_VERSION_REQUEST_SLAVE_SYNC: val = "FRSTRANS_VERSION_REQUEST_SLAVE_SYNC"; break;
     304             :         }
     305           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
     306           0 : }
     307             : 
     308           0 : static enum ndr_err_code ndr_push_frstrans_VersionChangeType(struct ndr_push *ndr, int ndr_flags, enum frstrans_VersionChangeType r)
     309             : {
     310           0 :         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
     311           0 :         return NDR_ERR_SUCCESS;
     312             : }
     313             : 
     314           0 : static enum ndr_err_code ndr_pull_frstrans_VersionChangeType(struct ndr_pull *ndr, int ndr_flags, enum frstrans_VersionChangeType *r)
     315             : {
     316             :         uint16_t v;
     317           0 :         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
     318           0 :         *r = v;
     319           0 :         return NDR_ERR_SUCCESS;
     320             : }
     321             : 
     322           0 : _PUBLIC_ void ndr_print_frstrans_VersionChangeType(struct ndr_print *ndr, const char *name, enum frstrans_VersionChangeType r)
     323             : {
     324           0 :         const char *val = NULL;
     325             : 
     326           0 :         switch (r) {
     327           0 :                 case FRSTRANS_VERSION_CHANGE_NOTIFY: val = "FRSTRANS_VERSION_CHANGE_NOTIFY"; break;
     328           0 :                 case FRSTRANS_VERSION_CHANGE_ALL: val = "FRSTRANS_VERSION_CHANGE_ALL"; break;
     329             :         }
     330           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
     331           0 : }
     332             : 
     333           0 : static enum ndr_err_code ndr_push_frstrans_EpoqueVector(struct ndr_push *ndr, int ndr_flags, const struct frstrans_EpoqueVector *r)
     334             : {
     335           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     336           0 :         if (ndr_flags & NDR_SCALARS) {
     337           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
     338           0 :                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->machine_guid));
     339           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->year));
     340           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->month));
     341           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->day_of_week));
     342           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->day));
     343           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->hour));
     344           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minute));
     345           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->second));
     346           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->milli_seconds));
     347           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
     348             :         }
     349           0 :         if (ndr_flags & NDR_BUFFERS) {
     350             :         }
     351           0 :         return NDR_ERR_SUCCESS;
     352             : }
     353             : 
     354           0 : static enum ndr_err_code ndr_pull_frstrans_EpoqueVector(struct ndr_pull *ndr, int ndr_flags, struct frstrans_EpoqueVector *r)
     355             : {
     356           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     357           0 :         if (ndr_flags & NDR_SCALARS) {
     358           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
     359           0 :                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->machine_guid));
     360           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->year));
     361           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->month));
     362           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->day_of_week));
     363           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->day));
     364           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->hour));
     365           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minute));
     366           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->second));
     367           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->milli_seconds));
     368           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
     369             :         }
     370           0 :         if (ndr_flags & NDR_BUFFERS) {
     371             :         }
     372           0 :         return NDR_ERR_SUCCESS;
     373             : }
     374             : 
     375           0 : _PUBLIC_ void ndr_print_frstrans_EpoqueVector(struct ndr_print *ndr, const char *name, const struct frstrans_EpoqueVector *r)
     376             : {
     377           0 :         ndr_print_struct(ndr, name, "frstrans_EpoqueVector");
     378           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     379           0 :         ndr->depth++;
     380           0 :         ndr_print_GUID(ndr, "machine_guid", &r->machine_guid);
     381           0 :         ndr_print_uint32(ndr, "year", r->year);
     382           0 :         ndr_print_uint32(ndr, "month", r->month);
     383           0 :         ndr_print_uint32(ndr, "day_of_week", r->day_of_week);
     384           0 :         ndr_print_uint32(ndr, "day", r->day);
     385           0 :         ndr_print_uint32(ndr, "hour", r->hour);
     386           0 :         ndr_print_uint32(ndr, "minute", r->minute);
     387           0 :         ndr_print_uint32(ndr, "second", r->second);
     388           0 :         ndr_print_uint32(ndr, "milli_seconds", r->milli_seconds);
     389           0 :         ndr->depth--;
     390             : }
     391             : 
     392           0 : static enum ndr_err_code ndr_push_frstrans_AsyncVersionVectorResponse(struct ndr_push *ndr, int ndr_flags, const struct frstrans_AsyncVersionVectorResponse *r)
     393             : {
     394             :         uint32_t cntr_version_vector_1;
     395             :         uint32_t cntr_epoque_vector_1;
     396           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     397           0 :         if (ndr_flags & NDR_SCALARS) {
     398           0 :                 NDR_CHECK(ndr_push_align(ndr, 8));
     399           0 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->vv_generation));
     400           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_vector_count));
     401           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->version_vector));
     402           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->epoque_vector_count));
     403           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->epoque_vector));
     404           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
     405             :         }
     406           0 :         if (ndr_flags & NDR_BUFFERS) {
     407           0 :                 if (r->version_vector) {
     408           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->version_vector_count));
     409           0 :                         for (cntr_version_vector_1 = 0; cntr_version_vector_1 < (r->version_vector_count); cntr_version_vector_1++) {
     410           0 :                                 NDR_CHECK(ndr_push_frstrans_VersionVector(ndr, NDR_SCALARS, &r->version_vector[cntr_version_vector_1]));
     411             :                         }
     412             :                 }
     413           0 :                 if (r->epoque_vector) {
     414           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->epoque_vector_count));
     415           0 :                         for (cntr_epoque_vector_1 = 0; cntr_epoque_vector_1 < (r->epoque_vector_count); cntr_epoque_vector_1++) {
     416           0 :                                 NDR_CHECK(ndr_push_frstrans_EpoqueVector(ndr, NDR_SCALARS, &r->epoque_vector[cntr_epoque_vector_1]));
     417             :                         }
     418             :                 }
     419             :         }
     420           0 :         return NDR_ERR_SUCCESS;
     421             : }
     422             : 
     423           0 : static enum ndr_err_code ndr_pull_frstrans_AsyncVersionVectorResponse(struct ndr_pull *ndr, int ndr_flags, struct frstrans_AsyncVersionVectorResponse *r)
     424             : {
     425             :         uint32_t _ptr_version_vector;
     426           0 :         uint32_t size_version_vector_1 = 0;
     427             :         uint32_t cntr_version_vector_1;
     428           0 :         TALLOC_CTX *_mem_save_version_vector_0 = NULL;
     429           0 :         TALLOC_CTX *_mem_save_version_vector_1 = NULL;
     430             :         uint32_t _ptr_epoque_vector;
     431           0 :         uint32_t size_epoque_vector_1 = 0;
     432             :         uint32_t cntr_epoque_vector_1;
     433           0 :         TALLOC_CTX *_mem_save_epoque_vector_0 = NULL;
     434           0 :         TALLOC_CTX *_mem_save_epoque_vector_1 = NULL;
     435           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     436           0 :         if (ndr_flags & NDR_SCALARS) {
     437           0 :                 NDR_CHECK(ndr_pull_align(ndr, 8));
     438           0 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->vv_generation));
     439           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_vector_count));
     440           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_version_vector));
     441           0 :                 if (_ptr_version_vector) {
     442           0 :                         NDR_PULL_ALLOC(ndr, r->version_vector);
     443             :                 } else {
     444           0 :                         r->version_vector = NULL;
     445             :                 }
     446           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->epoque_vector_count));
     447           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_epoque_vector));
     448           0 :                 if (_ptr_epoque_vector) {
     449           0 :                         NDR_PULL_ALLOC(ndr, r->epoque_vector);
     450             :                 } else {
     451           0 :                         r->epoque_vector = NULL;
     452             :                 }
     453           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
     454             :         }
     455           0 :         if (ndr_flags & NDR_BUFFERS) {
     456           0 :                 if (r->version_vector) {
     457           0 :                         _mem_save_version_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
     458           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->version_vector, 0);
     459           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->version_vector));
     460           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->version_vector, &size_version_vector_1));
     461           0 :                         NDR_PULL_ALLOC_N(ndr, r->version_vector, size_version_vector_1);
     462           0 :                         _mem_save_version_vector_1 = NDR_PULL_GET_MEM_CTX(ndr);
     463           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->version_vector, 0);
     464           0 :                         for (cntr_version_vector_1 = 0; cntr_version_vector_1 < (size_version_vector_1); cntr_version_vector_1++) {
     465           0 :                                 NDR_CHECK(ndr_pull_frstrans_VersionVector(ndr, NDR_SCALARS, &r->version_vector[cntr_version_vector_1]));
     466             :                         }
     467           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_version_vector_1, 0);
     468           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_version_vector_0, 0);
     469             :                 }
     470           0 :                 if (r->epoque_vector) {
     471           0 :                         _mem_save_epoque_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
     472           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->epoque_vector, 0);
     473           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->epoque_vector));
     474           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->epoque_vector, &size_epoque_vector_1));
     475           0 :                         NDR_PULL_ALLOC_N(ndr, r->epoque_vector, size_epoque_vector_1);
     476           0 :                         _mem_save_epoque_vector_1 = NDR_PULL_GET_MEM_CTX(ndr);
     477           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->epoque_vector, 0);
     478           0 :                         for (cntr_epoque_vector_1 = 0; cntr_epoque_vector_1 < (size_epoque_vector_1); cntr_epoque_vector_1++) {
     479           0 :                                 NDR_CHECK(ndr_pull_frstrans_EpoqueVector(ndr, NDR_SCALARS, &r->epoque_vector[cntr_epoque_vector_1]));
     480             :                         }
     481           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_epoque_vector_1, 0);
     482           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_epoque_vector_0, 0);
     483             :                 }
     484           0 :                 if (r->version_vector) {
     485           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->version_vector, r->version_vector_count));
     486             :                 }
     487           0 :                 if (r->epoque_vector) {
     488           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->epoque_vector, r->epoque_vector_count));
     489             :                 }
     490             :         }
     491           0 :         return NDR_ERR_SUCCESS;
     492             : }
     493             : 
     494           0 : _PUBLIC_ void ndr_print_frstrans_AsyncVersionVectorResponse(struct ndr_print *ndr, const char *name, const struct frstrans_AsyncVersionVectorResponse *r)
     495             : {
     496             :         uint32_t cntr_version_vector_1;
     497             :         uint32_t cntr_epoque_vector_1;
     498           0 :         ndr_print_struct(ndr, name, "frstrans_AsyncVersionVectorResponse");
     499           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     500           0 :         ndr->depth++;
     501           0 :         ndr_print_hyper(ndr, "vv_generation", r->vv_generation);
     502           0 :         ndr_print_uint32(ndr, "version_vector_count", r->version_vector_count);
     503           0 :         ndr_print_ptr(ndr, "version_vector", r->version_vector);
     504           0 :         ndr->depth++;
     505           0 :         if (r->version_vector) {
     506           0 :                 ndr->print(ndr, "%s: ARRAY(%d)", "version_vector", (int)r->version_vector_count);
     507           0 :                 ndr->depth++;
     508           0 :                 for (cntr_version_vector_1 = 0; cntr_version_vector_1 < (r->version_vector_count); cntr_version_vector_1++) {
     509           0 :                         ndr_print_frstrans_VersionVector(ndr, "version_vector", &r->version_vector[cntr_version_vector_1]);
     510             :                 }
     511           0 :                 ndr->depth--;
     512             :         }
     513           0 :         ndr->depth--;
     514           0 :         ndr_print_uint32(ndr, "epoque_vector_count", r->epoque_vector_count);
     515           0 :         ndr_print_ptr(ndr, "epoque_vector", r->epoque_vector);
     516           0 :         ndr->depth++;
     517           0 :         if (r->epoque_vector) {
     518           0 :                 ndr->print(ndr, "%s: ARRAY(%d)", "epoque_vector", (int)r->epoque_vector_count);
     519           0 :                 ndr->depth++;
     520           0 :                 for (cntr_epoque_vector_1 = 0; cntr_epoque_vector_1 < (r->epoque_vector_count); cntr_epoque_vector_1++) {
     521           0 :                         ndr_print_frstrans_EpoqueVector(ndr, "epoque_vector", &r->epoque_vector[cntr_epoque_vector_1]);
     522             :                 }
     523           0 :                 ndr->depth--;
     524             :         }
     525           0 :         ndr->depth--;
     526           0 :         ndr->depth--;
     527             : }
     528             : 
     529           0 : static enum ndr_err_code ndr_push_frstrans_AsyncResponseContext(struct ndr_push *ndr, int ndr_flags, const struct frstrans_AsyncResponseContext *r)
     530             : {
     531           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     532           0 :         if (ndr_flags & NDR_SCALARS) {
     533           0 :                 NDR_CHECK(ndr_push_align(ndr, 8));
     534           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sequence_number));
     535           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
     536           0 :                 NDR_CHECK(ndr_push_frstrans_AsyncVersionVectorResponse(ndr, NDR_SCALARS, &r->response));
     537           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
     538             :         }
     539           0 :         if (ndr_flags & NDR_BUFFERS) {
     540           0 :                 NDR_CHECK(ndr_push_frstrans_AsyncVersionVectorResponse(ndr, NDR_BUFFERS, &r->response));
     541             :         }
     542           0 :         return NDR_ERR_SUCCESS;
     543             : }
     544             : 
     545           0 : static enum ndr_err_code ndr_pull_frstrans_AsyncResponseContext(struct ndr_pull *ndr, int ndr_flags, struct frstrans_AsyncResponseContext *r)
     546             : {
     547           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     548           0 :         if (ndr_flags & NDR_SCALARS) {
     549           0 :                 NDR_CHECK(ndr_pull_align(ndr, 8));
     550           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sequence_number));
     551           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
     552           0 :                 NDR_CHECK(ndr_pull_frstrans_AsyncVersionVectorResponse(ndr, NDR_SCALARS, &r->response));
     553           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
     554             :         }
     555           0 :         if (ndr_flags & NDR_BUFFERS) {
     556           0 :                 NDR_CHECK(ndr_pull_frstrans_AsyncVersionVectorResponse(ndr, NDR_BUFFERS, &r->response));
     557             :         }
     558           0 :         return NDR_ERR_SUCCESS;
     559             : }
     560             : 
     561           0 : _PUBLIC_ void ndr_print_frstrans_AsyncResponseContext(struct ndr_print *ndr, const char *name, const struct frstrans_AsyncResponseContext *r)
     562             : {
     563           0 :         ndr_print_struct(ndr, name, "frstrans_AsyncResponseContext");
     564           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     565           0 :         ndr->depth++;
     566           0 :         ndr_print_uint32(ndr, "sequence_number", r->sequence_number);
     567           0 :         ndr_print_WERROR(ndr, "status", r->status);
     568           0 :         ndr_print_frstrans_AsyncVersionVectorResponse(ndr, "response", &r->response);
     569           0 :         ndr->depth--;
     570             : }
     571             : 
     572           0 : static enum ndr_err_code ndr_push_frstrans_RequestedStagingPolicy(struct ndr_push *ndr, int ndr_flags, enum frstrans_RequestedStagingPolicy r)
     573             : {
     574           0 :         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
     575           0 :         return NDR_ERR_SUCCESS;
     576             : }
     577             : 
     578           0 : static enum ndr_err_code ndr_pull_frstrans_RequestedStagingPolicy(struct ndr_pull *ndr, int ndr_flags, enum frstrans_RequestedStagingPolicy *r)
     579             : {
     580             :         uint16_t v;
     581           0 :         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
     582           0 :         *r = v;
     583           0 :         return NDR_ERR_SUCCESS;
     584             : }
     585             : 
     586           0 : _PUBLIC_ void ndr_print_frstrans_RequestedStagingPolicy(struct ndr_print *ndr, const char *name, enum frstrans_RequestedStagingPolicy r)
     587             : {
     588           0 :         const char *val = NULL;
     589             : 
     590           0 :         switch (r) {
     591           0 :                 case FRSTRANS_STAGING_POLICY_SERVER_DEFAULTY: val = "FRSTRANS_STAGING_POLICY_SERVER_DEFAULTY"; break;
     592           0 :                 case FRSTRANS_STAGING_POLICY_STATGING_REQUIRED: val = "FRSTRANS_STAGING_POLICY_STATGING_REQUIRED"; break;
     593           0 :                 case FRSTRANS_STAGING_POLICY_RESTATGING_REQUIRED: val = "FRSTRANS_STAGING_POLICY_RESTATGING_REQUIRED"; break;
     594             :         }
     595           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
     596           0 : }
     597             : 
     598           0 : static enum ndr_err_code ndr_push_frstrans_RdcChunckerAlgorithm(struct ndr_push *ndr, int ndr_flags, enum frstrans_RdcChunckerAlgorithm r)
     599             : {
     600           0 :         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
     601           0 :         return NDR_ERR_SUCCESS;
     602             : }
     603             : 
     604           0 : static enum ndr_err_code ndr_pull_frstrans_RdcChunckerAlgorithm(struct ndr_pull *ndr, int ndr_flags, enum frstrans_RdcChunckerAlgorithm *r)
     605             : {
     606             :         uint16_t v;
     607           0 :         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
     608           0 :         *r = v;
     609           0 :         return NDR_ERR_SUCCESS;
     610             : }
     611             : 
     612           0 : _PUBLIC_ void ndr_print_frstrans_RdcChunckerAlgorithm(struct ndr_print *ndr, const char *name, enum frstrans_RdcChunckerAlgorithm r)
     613             : {
     614           0 :         const char *val = NULL;
     615             : 
     616           0 :         switch (r) {
     617           0 :                 case FRSTRANS_RDC_FILTER_GENERIC: val = "FRSTRANS_RDC_FILTER_GENERIC"; break;
     618           0 :                 case FRSTRANS_RDC_FILTER_MAX: val = "FRSTRANS_RDC_FILTER_MAX"; break;
     619           0 :                 case FRSTRANS_RDC_FILTER_POINT: val = "FRSTRANS_RDC_FILTER_POINT"; break;
     620           0 :                 case FRSTRANS_RDC_MAX_ALGORITHM: val = "FRSTRANS_RDC_MAX_ALGORITHM"; break;
     621             :         }
     622           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
     623           0 : }
     624             : 
     625           0 : static enum ndr_err_code ndr_push_frstrans_RdcParameterGeneric(struct ndr_push *ndr, int ndr_flags, const struct frstrans_RdcParameterGeneric *r)
     626             : {
     627           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     628           0 :         if (ndr_flags & NDR_SCALARS) {
     629           0 :                 NDR_CHECK(ndr_push_align(ndr, 3));
     630           0 :                 NDR_CHECK(ndr_push_frstrans_RdcChunckerAlgorithm(ndr, NDR_SCALARS, r->chunker_type));
     631           0 :                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->chunker_parameters, 64));
     632           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 3));
     633             :         }
     634           0 :         if (ndr_flags & NDR_BUFFERS) {
     635             :         }
     636           0 :         return NDR_ERR_SUCCESS;
     637             : }
     638             : 
     639           0 : static enum ndr_err_code ndr_pull_frstrans_RdcParameterGeneric(struct ndr_pull *ndr, int ndr_flags, struct frstrans_RdcParameterGeneric *r)
     640             : {
     641           0 :         uint32_t size_chunker_parameters_0 = 0;
     642           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     643           0 :         if (ndr_flags & NDR_SCALARS) {
     644           0 :                 NDR_CHECK(ndr_pull_align(ndr, 3));
     645           0 :                 NDR_CHECK(ndr_pull_frstrans_RdcChunckerAlgorithm(ndr, NDR_SCALARS, &r->chunker_type));
     646           0 :                 size_chunker_parameters_0 = 64;
     647           0 :                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->chunker_parameters, size_chunker_parameters_0));
     648           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 3));
     649             :         }
     650           0 :         if (ndr_flags & NDR_BUFFERS) {
     651             :         }
     652           0 :         return NDR_ERR_SUCCESS;
     653             : }
     654             : 
     655           0 : _PUBLIC_ void ndr_print_frstrans_RdcParameterGeneric(struct ndr_print *ndr, const char *name, const struct frstrans_RdcParameterGeneric *r)
     656             : {
     657           0 :         ndr_print_struct(ndr, name, "frstrans_RdcParameterGeneric");
     658           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     659           0 :         ndr->depth++;
     660           0 :         ndr_print_frstrans_RdcChunckerAlgorithm(ndr, "chunker_type", r->chunker_type);
     661           0 :         ndr_print_array_uint8(ndr, "chunker_parameters", r->chunker_parameters, 64);
     662           0 :         ndr->depth--;
     663             : }
     664             : 
     665           0 : static enum ndr_err_code ndr_push_frstrans_RdcParameterFilterMax(struct ndr_push *ndr, int ndr_flags, const struct frstrans_RdcParameterFilterMax *r)
     666             : {
     667           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     668           0 :         if (ndr_flags & NDR_SCALARS) {
     669           0 :                 NDR_CHECK(ndr_push_align(ndr, 2));
     670           0 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->min_horizon_size));
     671           0 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_window_size));
     672           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
     673             :         }
     674           0 :         if (ndr_flags & NDR_BUFFERS) {
     675             :         }
     676           0 :         return NDR_ERR_SUCCESS;
     677             : }
     678             : 
     679           0 : static enum ndr_err_code ndr_pull_frstrans_RdcParameterFilterMax(struct ndr_pull *ndr, int ndr_flags, struct frstrans_RdcParameterFilterMax *r)
     680             : {
     681           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     682           0 :         if (ndr_flags & NDR_SCALARS) {
     683           0 :                 NDR_CHECK(ndr_pull_align(ndr, 2));
     684           0 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->min_horizon_size));
     685           0 :                 if (r->min_horizon_size < 128 || r->min_horizon_size > 1024*16) {
     686           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
     687             :                 }
     688           0 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_window_size));
     689           0 :                 if (r->max_window_size < 2 || r->max_window_size > 96) {
     690           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
     691             :                 }
     692           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
     693             :         }
     694           0 :         if (ndr_flags & NDR_BUFFERS) {
     695             :         }
     696           0 :         return NDR_ERR_SUCCESS;
     697             : }
     698             : 
     699           0 : _PUBLIC_ void ndr_print_frstrans_RdcParameterFilterMax(struct ndr_print *ndr, const char *name, const struct frstrans_RdcParameterFilterMax *r)
     700             : {
     701           0 :         ndr_print_struct(ndr, name, "frstrans_RdcParameterFilterMax");
     702           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     703           0 :         ndr->depth++;
     704           0 :         ndr_print_uint16(ndr, "min_horizon_size", r->min_horizon_size);
     705           0 :         ndr_print_uint16(ndr, "max_window_size", r->max_window_size);
     706           0 :         ndr->depth--;
     707             : }
     708             : 
     709           0 : static enum ndr_err_code ndr_push_frstrans_RdcParameterFilterPoint(struct ndr_push *ndr, int ndr_flags, const struct frstrans_RdcParameterFilterPoint *r)
     710             : {
     711           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     712           0 :         if (ndr_flags & NDR_SCALARS) {
     713           0 :                 NDR_CHECK(ndr_push_align(ndr, 2));
     714           0 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->min_chunk_size));
     715           0 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_chunk_size));
     716           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
     717             :         }
     718           0 :         if (ndr_flags & NDR_BUFFERS) {
     719             :         }
     720           0 :         return NDR_ERR_SUCCESS;
     721             : }
     722             : 
     723           0 : static enum ndr_err_code ndr_pull_frstrans_RdcParameterFilterPoint(struct ndr_pull *ndr, int ndr_flags, struct frstrans_RdcParameterFilterPoint *r)
     724             : {
     725           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     726           0 :         if (ndr_flags & NDR_SCALARS) {
     727           0 :                 NDR_CHECK(ndr_pull_align(ndr, 2));
     728           0 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->min_chunk_size));
     729           0 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_chunk_size));
     730           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
     731             :         }
     732           0 :         if (ndr_flags & NDR_BUFFERS) {
     733             :         }
     734           0 :         return NDR_ERR_SUCCESS;
     735             : }
     736             : 
     737           0 : _PUBLIC_ void ndr_print_frstrans_RdcParameterFilterPoint(struct ndr_print *ndr, const char *name, const struct frstrans_RdcParameterFilterPoint *r)
     738             : {
     739           0 :         ndr_print_struct(ndr, name, "frstrans_RdcParameterFilterPoint");
     740           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     741           0 :         ndr->depth++;
     742           0 :         ndr_print_uint16(ndr, "min_chunk_size", r->min_chunk_size);
     743           0 :         ndr_print_uint16(ndr, "max_chunk_size", r->max_chunk_size);
     744           0 :         ndr->depth--;
     745             : }
     746             : 
     747           0 : static enum ndr_err_code ndr_push_frstrans_RdcParameterUnion(struct ndr_push *ndr, int ndr_flags, const union frstrans_RdcParameterUnion *r)
     748             : {
     749             :         uint32_t level;
     750           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     751           0 :         if (ndr_flags & NDR_SCALARS) {
     752             :                 /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
     753           0 :                 NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
     754           0 :                 NDR_CHECK(ndr_push_union_align(ndr, 3));
     755           0 :                 NDR_CHECK(ndr_push_frstrans_RdcChunckerAlgorithm(ndr, NDR_SCALARS, level));
     756           0 :                 NDR_CHECK(ndr_push_union_align(ndr, 3));
     757           0 :                 switch (level) {
     758           0 :                         case FRSTRANS_RDC_FILTER_GENERIC: {
     759           0 :                                 NDR_CHECK(ndr_push_frstrans_RdcParameterGeneric(ndr, NDR_SCALARS, &r->filter_generic));
     760           0 :                         break; }
     761             : 
     762           0 :                         case FRSTRANS_RDC_FILTER_MAX: {
     763           0 :                                 NDR_CHECK(ndr_push_frstrans_RdcParameterFilterMax(ndr, NDR_SCALARS, &r->filter_max));
     764           0 :                         break; }
     765             : 
     766           0 :                         case FRSTRANS_RDC_FILTER_POINT: {
     767           0 :                                 NDR_CHECK(ndr_push_frstrans_RdcParameterFilterPoint(ndr, NDR_SCALARS, &r->filter_point));
     768           0 :                         break; }
     769             : 
     770           0 :                         default:
     771           0 :                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
     772             :                 }
     773           0 :         }
     774           0 :         if (ndr_flags & NDR_BUFFERS) {
     775           0 :                 if (!(ndr_flags & NDR_SCALARS)) {
     776             :                         /* We didn't get it above, and the token is not needed after this. */
     777           0 :                         NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
     778             :                 }
     779           0 :                 switch (level) {
     780           0 :                         case FRSTRANS_RDC_FILTER_GENERIC:
     781           0 :                         break;
     782             : 
     783           0 :                         case FRSTRANS_RDC_FILTER_MAX:
     784           0 :                         break;
     785             : 
     786           0 :                         case FRSTRANS_RDC_FILTER_POINT:
     787           0 :                         break;
     788             : 
     789           0 :                         default:
     790           0 :                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
     791             :                 }
     792           0 :         }
     793           0 :         return NDR_ERR_SUCCESS;
     794             : }
     795             : 
     796           0 : static enum ndr_err_code ndr_pull_frstrans_RdcParameterUnion(struct ndr_pull *ndr, int ndr_flags, union frstrans_RdcParameterUnion *r)
     797             : {
     798             :         uint32_t level;
     799             :         uint16_t _level;
     800           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     801           0 :         if (ndr_flags & NDR_SCALARS) {
     802             :                 /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
     803           0 :                 NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
     804           0 :                 NDR_CHECK(ndr_pull_union_align(ndr, 3));
     805           0 :                 NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
     806           0 :                 if (_level != level) {
     807           0 :                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
     808             :                 }
     809           0 :                 NDR_CHECK(ndr_pull_union_align(ndr, 3));
     810           0 :                 switch (level) {
     811           0 :                         case FRSTRANS_RDC_FILTER_GENERIC: {
     812           0 :                                 NDR_CHECK(ndr_pull_frstrans_RdcParameterGeneric(ndr, NDR_SCALARS, &r->filter_generic));
     813           0 :                         break; }
     814             : 
     815           0 :                         case FRSTRANS_RDC_FILTER_MAX: {
     816           0 :                                 NDR_CHECK(ndr_pull_frstrans_RdcParameterFilterMax(ndr, NDR_SCALARS, &r->filter_max));
     817           0 :                         break; }
     818             : 
     819           0 :                         case FRSTRANS_RDC_FILTER_POINT: {
     820           0 :                                 NDR_CHECK(ndr_pull_frstrans_RdcParameterFilterPoint(ndr, NDR_SCALARS, &r->filter_point));
     821           0 :                         break; }
     822             : 
     823           0 :                         default:
     824           0 :                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
     825             :                 }
     826           0 :         }
     827           0 :         if (ndr_flags & NDR_BUFFERS) {
     828           0 :                 if (!(ndr_flags & NDR_SCALARS)) {
     829             :                         /* We didn't get it above, and the token is not needed after this. */
     830           0 :                         NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
     831             :                 }
     832           0 :                 switch (level) {
     833           0 :                         case FRSTRANS_RDC_FILTER_GENERIC:
     834           0 :                         break;
     835             : 
     836           0 :                         case FRSTRANS_RDC_FILTER_MAX:
     837           0 :                         break;
     838             : 
     839           0 :                         case FRSTRANS_RDC_FILTER_POINT:
     840           0 :                         break;
     841             : 
     842           0 :                         default:
     843           0 :                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
     844             :                 }
     845           0 :         }
     846           0 :         return NDR_ERR_SUCCESS;
     847             : }
     848             : 
     849           0 : _PUBLIC_ void ndr_print_frstrans_RdcParameterUnion(struct ndr_print *ndr, const char *name, const union frstrans_RdcParameterUnion *r)
     850             : {
     851             :         uint32_t level;
     852           0 :         level = ndr_print_steal_switch_value(ndr, r);
     853           0 :         ndr_print_union(ndr, name, level, "frstrans_RdcParameterUnion");
     854           0 :         switch (level) {
     855           0 :                 case FRSTRANS_RDC_FILTER_GENERIC:
     856           0 :                         ndr_print_frstrans_RdcParameterGeneric(ndr, "filter_generic", &r->filter_generic);
     857           0 :                 break;
     858             : 
     859           0 :                 case FRSTRANS_RDC_FILTER_MAX:
     860           0 :                         ndr_print_frstrans_RdcParameterFilterMax(ndr, "filter_max", &r->filter_max);
     861           0 :                 break;
     862             : 
     863           0 :                 case FRSTRANS_RDC_FILTER_POINT:
     864           0 :                         ndr_print_frstrans_RdcParameterFilterPoint(ndr, "filter_point", &r->filter_point);
     865           0 :                 break;
     866             : 
     867           0 :                 default:
     868           0 :                         ndr_print_bad_level(ndr, name, level);
     869             :         }
     870           0 : }
     871             : 
     872           0 : static enum ndr_err_code ndr_push_frstrans_RdcParameters(struct ndr_push *ndr, int ndr_flags, const struct frstrans_RdcParameters *r)
     873             : {
     874           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     875           0 :         if (ndr_flags & NDR_SCALARS) {
     876           0 :                 NDR_CHECK(ndr_push_align(ndr, 3));
     877           0 :                 NDR_CHECK(ndr_push_frstrans_RdcChunckerAlgorithm(ndr, NDR_SCALARS, r->rdc_chunker_algorithm));
     878           0 :                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->u, r->rdc_chunker_algorithm));
     879           0 :                 NDR_CHECK(ndr_push_frstrans_RdcParameterUnion(ndr, NDR_SCALARS, &r->u));
     880           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 3));
     881             :         }
     882           0 :         if (ndr_flags & NDR_BUFFERS) {
     883             :         }
     884           0 :         return NDR_ERR_SUCCESS;
     885             : }
     886             : 
     887           0 : static enum ndr_err_code ndr_pull_frstrans_RdcParameters(struct ndr_pull *ndr, int ndr_flags, struct frstrans_RdcParameters *r)
     888             : {
     889           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     890           0 :         if (ndr_flags & NDR_SCALARS) {
     891           0 :                 NDR_CHECK(ndr_pull_align(ndr, 3));
     892           0 :                 NDR_CHECK(ndr_pull_frstrans_RdcChunckerAlgorithm(ndr, NDR_SCALARS, &r->rdc_chunker_algorithm));
     893           0 :                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->u, r->rdc_chunker_algorithm));
     894           0 :                 NDR_CHECK(ndr_pull_frstrans_RdcParameterUnion(ndr, NDR_SCALARS, &r->u));
     895           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 3));
     896             :         }
     897           0 :         if (ndr_flags & NDR_BUFFERS) {
     898             :         }
     899           0 :         return NDR_ERR_SUCCESS;
     900             : }
     901             : 
     902           0 : _PUBLIC_ void ndr_print_frstrans_RdcParameters(struct ndr_print *ndr, const char *name, const struct frstrans_RdcParameters *r)
     903             : {
     904           0 :         ndr_print_struct(ndr, name, "frstrans_RdcParameters");
     905           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     906           0 :         ndr->depth++;
     907           0 :         ndr_print_frstrans_RdcChunckerAlgorithm(ndr, "rdc_chunker_algorithm", r->rdc_chunker_algorithm);
     908           0 :         ndr_print_set_switch_value(ndr, &r->u, r->rdc_chunker_algorithm);
     909           0 :         ndr_print_frstrans_RdcParameterUnion(ndr, "u", &r->u);
     910           0 :         ndr->depth--;
     911             : }
     912             : 
     913           0 : static enum ndr_err_code ndr_push_frstrans_RdcVersion(struct ndr_push *ndr, int ndr_flags, enum frstrans_RdcVersion r)
     914             : {
     915           0 :         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
     916           0 :         return NDR_ERR_SUCCESS;
     917             : }
     918             : 
     919           0 : static enum ndr_err_code ndr_pull_frstrans_RdcVersion(struct ndr_pull *ndr, int ndr_flags, enum frstrans_RdcVersion *r)
     920             : {
     921             :         uint16_t v;
     922           0 :         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
     923           0 :         *r = v;
     924           0 :         return NDR_ERR_SUCCESS;
     925             : }
     926             : 
     927           0 : _PUBLIC_ void ndr_print_frstrans_RdcVersion(struct ndr_print *ndr, const char *name, enum frstrans_RdcVersion r)
     928             : {
     929           0 :         const char *val = NULL;
     930             : 
     931           0 :         switch (r) {
     932           0 :                 case FRSTRANS_RDC_VERSION: val = "FRSTRANS_RDC_VERSION"; break;
     933             :         }
     934           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
     935           0 : }
     936             : 
     937           0 : static enum ndr_err_code ndr_push_frstrans_RdcVersionCompatible(struct ndr_push *ndr, int ndr_flags, enum frstrans_RdcVersionCompatible r)
     938             : {
     939           0 :         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
     940           0 :         return NDR_ERR_SUCCESS;
     941             : }
     942             : 
     943           0 : static enum ndr_err_code ndr_pull_frstrans_RdcVersionCompatible(struct ndr_pull *ndr, int ndr_flags, enum frstrans_RdcVersionCompatible *r)
     944             : {
     945             :         uint16_t v;
     946           0 :         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
     947           0 :         *r = v;
     948           0 :         return NDR_ERR_SUCCESS;
     949             : }
     950             : 
     951           0 : _PUBLIC_ void ndr_print_frstrans_RdcVersionCompatible(struct ndr_print *ndr, const char *name, enum frstrans_RdcVersionCompatible r)
     952             : {
     953           0 :         const char *val = NULL;
     954             : 
     955           0 :         switch (r) {
     956           0 :                 case FRSTRANS_RDC_VERSION_COMPATIBLE: val = "FRSTRANS_RDC_VERSION_COMPATIBLE"; break;
     957             :         }
     958           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
     959           0 : }
     960             : 
     961           0 : static enum ndr_err_code ndr_push_frstrans_RdcCompressionAlgorithm(struct ndr_push *ndr, int ndr_flags, enum frstrans_RdcCompressionAlgorithm r)
     962             : {
     963           0 :         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
     964           0 :         return NDR_ERR_SUCCESS;
     965             : }
     966             : 
     967           0 : static enum ndr_err_code ndr_pull_frstrans_RdcCompressionAlgorithm(struct ndr_pull *ndr, int ndr_flags, enum frstrans_RdcCompressionAlgorithm *r)
     968             : {
     969             :         uint16_t v;
     970           0 :         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
     971           0 :         *r = v;
     972           0 :         return NDR_ERR_SUCCESS;
     973             : }
     974             : 
     975           0 : _PUBLIC_ void ndr_print_frstrans_RdcCompressionAlgorithm(struct ndr_print *ndr, const char *name, enum frstrans_RdcCompressionAlgorithm r)
     976             : {
     977           0 :         const char *val = NULL;
     978             : 
     979           0 :         switch (r) {
     980           0 :                 case FRSTRANS_RDC_UNCOMPRESSED: val = "FRSTRANS_RDC_UNCOMPRESSED"; break;
     981           0 :                 case FRSTRANS_RDC_XPRESS: val = "FRSTRANS_RDC_XPRESS"; break;
     982             :         }
     983           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
     984           0 : }
     985             : 
     986           0 : static enum ndr_err_code ndr_push_frstrans_RdcFileInfo(struct ndr_push *ndr, int ndr_flags, const struct frstrans_RdcFileInfo *r)
     987             : {
     988             :         uint32_t cntr_rdc_filter_parameters_0;
     989           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     990           0 :         if (ndr_flags & NDR_SCALARS) {
     991           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->rdc_signature_levels));
     992           0 :                 NDR_CHECK(ndr_push_align(ndr, 8));
     993           0 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->on_disk_file_size));
     994           0 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->file_size_estimate));
     995           0 :                 NDR_CHECK(ndr_push_frstrans_RdcVersion(ndr, NDR_SCALARS, r->rdc_version));
     996           0 :                 NDR_CHECK(ndr_push_frstrans_RdcVersionCompatible(ndr, NDR_SCALARS, r->rdc_minimum_compatible_version));
     997           0 :                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->rdc_signature_levels));
     998           0 :                 NDR_CHECK(ndr_push_frstrans_RdcCompressionAlgorithm(ndr, NDR_SCALARS, r->compression_algorithm));
     999           0 :                 for (cntr_rdc_filter_parameters_0 = 0; cntr_rdc_filter_parameters_0 < (r->rdc_signature_levels); cntr_rdc_filter_parameters_0++) {
    1000           0 :                         NDR_CHECK(ndr_push_frstrans_RdcParameters(ndr, NDR_SCALARS, &r->rdc_filter_parameters[cntr_rdc_filter_parameters_0]));
    1001             :                 }
    1002           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
    1003             :         }
    1004           0 :         if (ndr_flags & NDR_BUFFERS) {
    1005             :         }
    1006           0 :         return NDR_ERR_SUCCESS;
    1007             : }
    1008             : 
    1009           0 : static enum ndr_err_code ndr_pull_frstrans_RdcFileInfo(struct ndr_pull *ndr, int ndr_flags, struct frstrans_RdcFileInfo *r)
    1010             : {
    1011           0 :         uint32_t size_rdc_filter_parameters_0 = 0;
    1012             :         uint32_t cntr_rdc_filter_parameters_0;
    1013           0 :         TALLOC_CTX *_mem_save_rdc_filter_parameters_0 = NULL;
    1014           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1015           0 :         if (ndr_flags & NDR_SCALARS) {
    1016           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->rdc_filter_parameters));
    1017           0 :                 NDR_CHECK(ndr_pull_align(ndr, 8));
    1018           0 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->on_disk_file_size));
    1019           0 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->file_size_estimate));
    1020           0 :                 NDR_CHECK(ndr_pull_frstrans_RdcVersion(ndr, NDR_SCALARS, &r->rdc_version));
    1021           0 :                 NDR_CHECK(ndr_pull_frstrans_RdcVersionCompatible(ndr, NDR_SCALARS, &r->rdc_minimum_compatible_version));
    1022           0 :                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->rdc_signature_levels));
    1023           0 :                 if (r->rdc_signature_levels > 8) {
    1024           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    1025             :                 }
    1026           0 :                 NDR_CHECK(ndr_pull_frstrans_RdcCompressionAlgorithm(ndr, NDR_SCALARS, &r->compression_algorithm));
    1027           0 :                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->rdc_filter_parameters, &size_rdc_filter_parameters_0));
    1028           0 :                 NDR_PULL_ALLOC_N(ndr, r->rdc_filter_parameters, size_rdc_filter_parameters_0);
    1029           0 :                 _mem_save_rdc_filter_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1030           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->rdc_filter_parameters, 0);
    1031           0 :                 for (cntr_rdc_filter_parameters_0 = 0; cntr_rdc_filter_parameters_0 < (size_rdc_filter_parameters_0); cntr_rdc_filter_parameters_0++) {
    1032           0 :                         NDR_CHECK(ndr_pull_frstrans_RdcParameters(ndr, NDR_SCALARS, &r->rdc_filter_parameters[cntr_rdc_filter_parameters_0]));
    1033             :                 }
    1034           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rdc_filter_parameters_0, 0);
    1035           0 :                 if (r->rdc_filter_parameters) {
    1036           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->rdc_filter_parameters, r->rdc_signature_levels));
    1037             :                 }
    1038           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
    1039             :         }
    1040           0 :         if (ndr_flags & NDR_BUFFERS) {
    1041             :         }
    1042           0 :         return NDR_ERR_SUCCESS;
    1043             : }
    1044             : 
    1045           0 : _PUBLIC_ void ndr_print_frstrans_RdcFileInfo(struct ndr_print *ndr, const char *name, const struct frstrans_RdcFileInfo *r)
    1046             : {
    1047             :         uint32_t cntr_rdc_filter_parameters_0;
    1048           0 :         ndr_print_struct(ndr, name, "frstrans_RdcFileInfo");
    1049           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1050           0 :         ndr->depth++;
    1051           0 :         ndr_print_hyper(ndr, "on_disk_file_size", r->on_disk_file_size);
    1052           0 :         ndr_print_hyper(ndr, "file_size_estimate", r->file_size_estimate);
    1053           0 :         ndr_print_frstrans_RdcVersion(ndr, "rdc_version", r->rdc_version);
    1054           0 :         ndr_print_frstrans_RdcVersionCompatible(ndr, "rdc_minimum_compatible_version", r->rdc_minimum_compatible_version);
    1055           0 :         ndr_print_uint8(ndr, "rdc_signature_levels", r->rdc_signature_levels);
    1056           0 :         ndr_print_frstrans_RdcCompressionAlgorithm(ndr, "compression_algorithm", r->compression_algorithm);
    1057           0 :         ndr->print(ndr, "%s: ARRAY(%d)", "rdc_filter_parameters", (int)r->rdc_signature_levels);
    1058           0 :         ndr->depth++;
    1059           0 :         for (cntr_rdc_filter_parameters_0 = 0; cntr_rdc_filter_parameters_0 < (r->rdc_signature_levels); cntr_rdc_filter_parameters_0++) {
    1060           0 :                 ndr_print_frstrans_RdcParameters(ndr, "rdc_filter_parameters", &r->rdc_filter_parameters[cntr_rdc_filter_parameters_0]);
    1061             :         }
    1062           0 :         ndr->depth--;
    1063           0 :         ndr->depth--;
    1064             : }
    1065             : 
    1066           0 : static enum ndr_err_code ndr_push_frstrans_BytePipe_chunk(struct ndr_push *ndr, int ndr_flags, const struct frstrans_BytePipe_chunk *r)
    1067             : {
    1068             :         {
    1069           0 :                 uint32_t _flags_save_STRUCT = ndr->flags;
    1070           0 :                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
    1071           0 :                 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1072           0 :                 if (ndr_flags & NDR_SCALARS) {
    1073           0 :                         NDR_CHECK(ndr_push_align(ndr, 5));
    1074             :                         {
    1075           0 :                                 uint32_t _flags_save_uint3264 = ndr->flags;
    1076           0 :                                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
    1077           0 :                                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
    1078           0 :                                 ndr->flags = _flags_save_uint3264;
    1079             :                         }
    1080             :                         {
    1081           0 :                                 uint32_t _flags_save_uint8 = ndr->flags;
    1082           0 :                                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
    1083           0 :                                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->array, r->count));
    1084           0 :                                 ndr->flags = _flags_save_uint8;
    1085             :                         }
    1086           0 :                         NDR_CHECK(ndr_push_trailer_align(ndr, 5));
    1087             :                 }
    1088           0 :                 if (ndr_flags & NDR_BUFFERS) {
    1089             :                 }
    1090           0 :                 ndr->flags = _flags_save_STRUCT;
    1091             :         }
    1092             : 
    1093           0 :         NDR_CHECK(ndr_push_pipe_chunk_trailer(ndr, ndr_flags, r->count));
    1094             : 
    1095           0 :         return NDR_ERR_SUCCESS;
    1096             : }
    1097             : 
    1098           0 : static enum ndr_err_code ndr_pull_frstrans_BytePipe_chunk(struct ndr_pull *ndr, int ndr_flags, struct frstrans_BytePipe_chunk *r)
    1099             : {
    1100           0 :         uint32_t size_array_0 = 0;
    1101             :         {
    1102           0 :                 uint32_t _flags_save_STRUCT = ndr->flags;
    1103           0 :                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
    1104           0 :                 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1105           0 :                 if (ndr_flags & NDR_SCALARS) {
    1106           0 :                         NDR_CHECK(ndr_pull_align(ndr, 5));
    1107             :                         {
    1108           0 :                                 uint32_t _flags_save_uint3264 = ndr->flags;
    1109           0 :                                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
    1110           0 :                                 NDR_CHECK(ndr_pull_uint3264(ndr, NDR_SCALARS, &r->count));
    1111           0 :                                 ndr->flags = _flags_save_uint3264;
    1112             :                         }
    1113             :                         {
    1114           0 :                                 uint32_t _flags_save_uint8 = ndr->flags;
    1115           0 :                                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
    1116           0 :                                 size_array_0 = r->count;
    1117           0 :                                 NDR_PULL_ALLOC_N(ndr, r->array, size_array_0);
    1118           0 :                                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->array, size_array_0));
    1119           0 :                                 ndr->flags = _flags_save_uint8;
    1120             :                         }
    1121           0 :                         NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
    1122             :                 }
    1123           0 :                 if (ndr_flags & NDR_BUFFERS) {
    1124             :                 }
    1125           0 :                 ndr->flags = _flags_save_STRUCT;
    1126             :         }
    1127             : 
    1128           0 :         NDR_CHECK(ndr_check_pipe_chunk_trailer(ndr, ndr_flags, r->count));
    1129             : 
    1130           0 :         return NDR_ERR_SUCCESS;
    1131             : }
    1132             : 
    1133           0 : _PUBLIC_ void ndr_print_frstrans_BytePipe_chunk(struct ndr_print *ndr, const char *name, const struct frstrans_BytePipe_chunk *r)
    1134             : {
    1135           0 :         ndr_print_struct(ndr, name, "frstrans_BytePipe_chunk");
    1136           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1137             :         {
    1138           0 :                 uint32_t _flags_save_STRUCT = ndr->flags;
    1139           0 :                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
    1140           0 :                 ndr->depth++;
    1141             :                 {
    1142           0 :                         uint32_t _flags_save_uint3264 = ndr->flags;
    1143           0 :                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
    1144           0 :                         ndr_print_uint3264(ndr, "count", r->count);
    1145           0 :                         ndr->flags = _flags_save_uint3264;
    1146             :                 }
    1147             :                 {
    1148           0 :                         uint32_t _flags_save_uint8 = ndr->flags;
    1149           0 :                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
    1150           0 :                         ndr_print_array_uint8(ndr, "array", r->array, r->count);
    1151           0 :                         ndr->flags = _flags_save_uint8;
    1152             :                 }
    1153           0 :                 ndr->depth--;
    1154           0 :                 ndr->flags = _flags_save_STRUCT;
    1155             :         }
    1156             : }
    1157             : 
    1158           0 : static enum ndr_err_code ndr_push_frstrans_CheckConnectivity(struct ndr_push *ndr, int flags, const struct frstrans_CheckConnectivity *r)
    1159             : {
    1160           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1161           0 :         if (flags & NDR_IN) {
    1162           0 :                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.replica_set_guid));
    1163           0 :                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
    1164             :         }
    1165           0 :         if (flags & NDR_OUT) {
    1166           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1167             :         }
    1168           0 :         return NDR_ERR_SUCCESS;
    1169             : }
    1170             : 
    1171           0 : static enum ndr_err_code ndr_pull_frstrans_CheckConnectivity(struct ndr_pull *ndr, int flags, struct frstrans_CheckConnectivity *r)
    1172             : {
    1173           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1174           0 :         if (flags & NDR_IN) {
    1175           0 :                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.replica_set_guid));
    1176           0 :                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
    1177             :         }
    1178           0 :         if (flags & NDR_OUT) {
    1179             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1180             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1181           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1182             :         }
    1183           0 :         return NDR_ERR_SUCCESS;
    1184             : }
    1185             : 
    1186           0 : _PUBLIC_ void ndr_print_frstrans_CheckConnectivity(struct ndr_print *ndr, const char *name, int flags, const struct frstrans_CheckConnectivity *r)
    1187             : {
    1188           0 :         ndr_print_struct(ndr, name, "frstrans_CheckConnectivity");
    1189           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1190           0 :         ndr->depth++;
    1191           0 :         if (flags & NDR_SET_VALUES) {
    1192           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1193             :         }
    1194           0 :         if (flags & NDR_IN) {
    1195           0 :                 ndr_print_struct(ndr, "in", "frstrans_CheckConnectivity");
    1196           0 :                 ndr->depth++;
    1197           0 :                 ndr_print_GUID(ndr, "replica_set_guid", &r->in.replica_set_guid);
    1198           0 :                 ndr_print_GUID(ndr, "connection_guid", &r->in.connection_guid);
    1199           0 :                 ndr->depth--;
    1200             :         }
    1201           0 :         if (flags & NDR_OUT) {
    1202           0 :                 ndr_print_struct(ndr, "out", "frstrans_CheckConnectivity");
    1203           0 :                 ndr->depth++;
    1204           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1205           0 :                 ndr->depth--;
    1206             :         }
    1207           0 :         ndr->depth--;
    1208             : }
    1209             : 
    1210           0 : static enum ndr_err_code ndr_push_frstrans_EstablishConnection(struct ndr_push *ndr, int flags, const struct frstrans_EstablishConnection *r)
    1211             : {
    1212           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1213           0 :         if (flags & NDR_IN) {
    1214           0 :                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.replica_set_guid));
    1215           0 :                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
    1216           0 :                 NDR_CHECK(ndr_push_frstrans_ProtocolVersion(ndr, NDR_SCALARS, r->in.downstream_protocol_version));
    1217           0 :                 NDR_CHECK(ndr_push_frstrans_TransportFlags(ndr, NDR_SCALARS, r->in.downstream_flags));
    1218             :         }
    1219           0 :         if (flags & NDR_OUT) {
    1220           0 :                 if (r->out.upstream_protocol_version == NULL) {
    1221           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1222             :                 }
    1223           0 :                 if (r->out.upstream_flags == NULL) {
    1224           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1225             :                 }
    1226           0 :                 NDR_CHECK(ndr_push_frstrans_ProtocolVersion(ndr, NDR_SCALARS, *r->out.upstream_protocol_version));
    1227           0 :                 NDR_CHECK(ndr_push_frstrans_TransportFlags(ndr, NDR_SCALARS, *r->out.upstream_flags));
    1228           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1229             :         }
    1230           0 :         return NDR_ERR_SUCCESS;
    1231             : }
    1232             : 
    1233           0 : static enum ndr_err_code ndr_pull_frstrans_EstablishConnection(struct ndr_pull *ndr, int flags, struct frstrans_EstablishConnection *r)
    1234             : {
    1235           0 :         TALLOC_CTX *_mem_save_upstream_protocol_version_0 = NULL;
    1236           0 :         TALLOC_CTX *_mem_save_upstream_flags_0 = NULL;
    1237           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1238           0 :         if (flags & NDR_IN) {
    1239           0 :                 NDR_ZERO_STRUCT(r->out);
    1240             : 
    1241           0 :                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.replica_set_guid));
    1242           0 :                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
    1243           0 :                 NDR_CHECK(ndr_pull_frstrans_ProtocolVersion(ndr, NDR_SCALARS, &r->in.downstream_protocol_version));
    1244           0 :                 NDR_CHECK(ndr_pull_frstrans_TransportFlags(ndr, NDR_SCALARS, &r->in.downstream_flags));
    1245           0 :                 NDR_PULL_ALLOC(ndr, r->out.upstream_protocol_version);
    1246           0 :                 NDR_ZERO_STRUCTP(r->out.upstream_protocol_version);
    1247           0 :                 NDR_PULL_ALLOC(ndr, r->out.upstream_flags);
    1248           0 :                 NDR_ZERO_STRUCTP(r->out.upstream_flags);
    1249             :         }
    1250           0 :         if (flags & NDR_OUT) {
    1251             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1252             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1253           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1254           0 :                         NDR_PULL_ALLOC(ndr, r->out.upstream_protocol_version);
    1255             :                 }
    1256           0 :                 _mem_save_upstream_protocol_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1257           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.upstream_protocol_version, LIBNDR_FLAG_REF_ALLOC);
    1258           0 :                 NDR_CHECK(ndr_pull_frstrans_ProtocolVersion(ndr, NDR_SCALARS, r->out.upstream_protocol_version));
    1259           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_upstream_protocol_version_0, LIBNDR_FLAG_REF_ALLOC);
    1260           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1261           0 :                         NDR_PULL_ALLOC(ndr, r->out.upstream_flags);
    1262             :                 }
    1263           0 :                 _mem_save_upstream_flags_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1264           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.upstream_flags, LIBNDR_FLAG_REF_ALLOC);
    1265           0 :                 NDR_CHECK(ndr_pull_frstrans_TransportFlags(ndr, NDR_SCALARS, r->out.upstream_flags));
    1266           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_upstream_flags_0, LIBNDR_FLAG_REF_ALLOC);
    1267           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1268             :         }
    1269           0 :         return NDR_ERR_SUCCESS;
    1270             : }
    1271             : 
    1272           0 : _PUBLIC_ void ndr_print_frstrans_EstablishConnection(struct ndr_print *ndr, const char *name, int flags, const struct frstrans_EstablishConnection *r)
    1273             : {
    1274           0 :         ndr_print_struct(ndr, name, "frstrans_EstablishConnection");
    1275           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1276           0 :         ndr->depth++;
    1277           0 :         if (flags & NDR_SET_VALUES) {
    1278           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1279             :         }
    1280           0 :         if (flags & NDR_IN) {
    1281           0 :                 ndr_print_struct(ndr, "in", "frstrans_EstablishConnection");
    1282           0 :                 ndr->depth++;
    1283           0 :                 ndr_print_GUID(ndr, "replica_set_guid", &r->in.replica_set_guid);
    1284           0 :                 ndr_print_GUID(ndr, "connection_guid", &r->in.connection_guid);
    1285           0 :                 ndr_print_frstrans_ProtocolVersion(ndr, "downstream_protocol_version", r->in.downstream_protocol_version);
    1286           0 :                 ndr_print_frstrans_TransportFlags(ndr, "downstream_flags", r->in.downstream_flags);
    1287           0 :                 ndr->depth--;
    1288             :         }
    1289           0 :         if (flags & NDR_OUT) {
    1290           0 :                 ndr_print_struct(ndr, "out", "frstrans_EstablishConnection");
    1291           0 :                 ndr->depth++;
    1292           0 :                 ndr_print_ptr(ndr, "upstream_protocol_version", r->out.upstream_protocol_version);
    1293           0 :                 ndr->depth++;
    1294           0 :                 ndr_print_frstrans_ProtocolVersion(ndr, "upstream_protocol_version", *r->out.upstream_protocol_version);
    1295           0 :                 ndr->depth--;
    1296           0 :                 ndr_print_ptr(ndr, "upstream_flags", r->out.upstream_flags);
    1297           0 :                 ndr->depth++;
    1298           0 :                 ndr_print_frstrans_TransportFlags(ndr, "upstream_flags", *r->out.upstream_flags);
    1299           0 :                 ndr->depth--;
    1300           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1301           0 :                 ndr->depth--;
    1302             :         }
    1303           0 :         ndr->depth--;
    1304             : }
    1305             : 
    1306           0 : static enum ndr_err_code ndr_push_frstrans_EstablishSession(struct ndr_push *ndr, int flags, const struct frstrans_EstablishSession *r)
    1307             : {
    1308           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1309           0 :         if (flags & NDR_IN) {
    1310           0 :                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
    1311           0 :                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.content_set_guid));
    1312             :         }
    1313           0 :         if (flags & NDR_OUT) {
    1314           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1315             :         }
    1316           0 :         return NDR_ERR_SUCCESS;
    1317             : }
    1318             : 
    1319           0 : static enum ndr_err_code ndr_pull_frstrans_EstablishSession(struct ndr_pull *ndr, int flags, struct frstrans_EstablishSession *r)
    1320             : {
    1321           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1322           0 :         if (flags & NDR_IN) {
    1323           0 :                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
    1324           0 :                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.content_set_guid));
    1325             :         }
    1326           0 :         if (flags & NDR_OUT) {
    1327             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1328             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1329           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1330             :         }
    1331           0 :         return NDR_ERR_SUCCESS;
    1332             : }
    1333             : 
    1334           0 : _PUBLIC_ void ndr_print_frstrans_EstablishSession(struct ndr_print *ndr, const char *name, int flags, const struct frstrans_EstablishSession *r)
    1335             : {
    1336           0 :         ndr_print_struct(ndr, name, "frstrans_EstablishSession");
    1337           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1338           0 :         ndr->depth++;
    1339           0 :         if (flags & NDR_SET_VALUES) {
    1340           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1341             :         }
    1342           0 :         if (flags & NDR_IN) {
    1343           0 :                 ndr_print_struct(ndr, "in", "frstrans_EstablishSession");
    1344           0 :                 ndr->depth++;
    1345           0 :                 ndr_print_GUID(ndr, "connection_guid", &r->in.connection_guid);
    1346           0 :                 ndr_print_GUID(ndr, "content_set_guid", &r->in.content_set_guid);
    1347           0 :                 ndr->depth--;
    1348             :         }
    1349           0 :         if (flags & NDR_OUT) {
    1350           0 :                 ndr_print_struct(ndr, "out", "frstrans_EstablishSession");
    1351           0 :                 ndr->depth++;
    1352           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1353           0 :                 ndr->depth--;
    1354             :         }
    1355           0 :         ndr->depth--;
    1356             : }
    1357             : 
    1358           0 : static enum ndr_err_code ndr_push_frstrans_RequestUpdates(struct ndr_push *ndr, int flags, const struct frstrans_RequestUpdates *r)
    1359             : {
    1360             :         uint32_t cntr_version_vector_diff_1;
    1361             :         uint32_t cntr_frs_update_1;
    1362           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1363           0 :         if (flags & NDR_IN) {
    1364           0 :                 if (r->in.version_vector_diff == NULL) {
    1365           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1366             :                 }
    1367           0 :                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
    1368           0 :                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.content_set_guid));
    1369           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.credits_available));
    1370           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.hash_requested));
    1371           0 :                 NDR_CHECK(ndr_push_frstrans_UpdateRequestType(ndr, NDR_SCALARS, r->in.update_request_type));
    1372           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version_vector_diff_count));
    1373           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.version_vector_diff_count));
    1374           0 :                 for (cntr_version_vector_diff_1 = 0; cntr_version_vector_diff_1 < (r->in.version_vector_diff_count); cntr_version_vector_diff_1++) {
    1375           0 :                         NDR_CHECK(ndr_push_frstrans_VersionVector(ndr, NDR_SCALARS, &r->in.version_vector_diff[cntr_version_vector_diff_1]));
    1376             :                 }
    1377             :         }
    1378           0 :         if (flags & NDR_OUT) {
    1379           0 :                 if (r->out.frs_update == NULL) {
    1380           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1381             :                 }
    1382           0 :                 if (r->out.update_count == NULL) {
    1383           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1384             :                 }
    1385           0 :                 if (r->out.update_status == NULL) {
    1386           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1387             :                 }
    1388           0 :                 if (r->out.gvsn_db_guid == NULL) {
    1389           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1390             :                 }
    1391           0 :                 if (r->out.gvsn_version == NULL) {
    1392           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1393             :                 }
    1394           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.credits_available));
    1395           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    1396           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.update_count));
    1397           0 :                 for (cntr_frs_update_1 = 0; cntr_frs_update_1 < (*r->out.update_count); cntr_frs_update_1++) {
    1398           0 :                         NDR_CHECK(ndr_push_frstrans_Update(ndr, NDR_SCALARS, &r->out.frs_update[cntr_frs_update_1]));
    1399             :                 }
    1400           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.update_count));
    1401           0 :                 NDR_CHECK(ndr_push_frstrans_UpdateStatus(ndr, NDR_SCALARS, *r->out.update_status));
    1402           0 :                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->out.gvsn_db_guid));
    1403           0 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, *r->out.gvsn_version));
    1404           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1405             :         }
    1406           0 :         return NDR_ERR_SUCCESS;
    1407             : }
    1408             : 
    1409           0 : static enum ndr_err_code ndr_pull_frstrans_RequestUpdates(struct ndr_pull *ndr, int flags, struct frstrans_RequestUpdates *r)
    1410             : {
    1411           0 :         uint32_t size_version_vector_diff_1 = 0;
    1412             :         uint32_t cntr_version_vector_diff_1;
    1413           0 :         uint32_t size_frs_update_1 = 0;
    1414           0 :         uint32_t length_frs_update_1 = 0;
    1415             :         uint32_t cntr_frs_update_1;
    1416           0 :         TALLOC_CTX *_mem_save_version_vector_diff_1 = NULL;
    1417           0 :         TALLOC_CTX *_mem_save_frs_update_1 = NULL;
    1418           0 :         TALLOC_CTX *_mem_save_update_count_0 = NULL;
    1419           0 :         TALLOC_CTX *_mem_save_update_status_0 = NULL;
    1420           0 :         TALLOC_CTX *_mem_save_gvsn_db_guid_0 = NULL;
    1421           0 :         TALLOC_CTX *_mem_save_gvsn_version_0 = NULL;
    1422           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1423           0 :         if (flags & NDR_IN) {
    1424           0 :                 NDR_ZERO_STRUCT(r->out);
    1425             : 
    1426           0 :                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
    1427           0 :                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.content_set_guid));
    1428           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.credits_available));
    1429           0 :                 if (r->in.credits_available > 256) {
    1430           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    1431             :                 }
    1432           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.hash_requested));
    1433           0 :                 if (r->in.hash_requested > 1) {
    1434           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    1435             :                 }
    1436           0 :                 NDR_CHECK(ndr_pull_frstrans_UpdateRequestType(ndr, NDR_SCALARS, &r->in.update_request_type));
    1437           0 :                 if (r->in.update_request_type > 2) {
    1438           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    1439             :                 }
    1440           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version_vector_diff_count));
    1441           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.version_vector_diff));
    1442           0 :                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->in.version_vector_diff, &size_version_vector_diff_1));
    1443           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1444           0 :                         NDR_PULL_ALLOC_N(ndr, r->in.version_vector_diff, size_version_vector_diff_1);
    1445             :                 }
    1446           0 :                 _mem_save_version_vector_diff_1 = NDR_PULL_GET_MEM_CTX(ndr);
    1447           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.version_vector_diff, 0);
    1448           0 :                 for (cntr_version_vector_diff_1 = 0; cntr_version_vector_diff_1 < (size_version_vector_diff_1); cntr_version_vector_diff_1++) {
    1449           0 :                         NDR_CHECK(ndr_pull_frstrans_VersionVector(ndr, NDR_SCALARS, &r->in.version_vector_diff[cntr_version_vector_diff_1]));
    1450             :                 }
    1451           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_version_vector_diff_1, 0);
    1452           0 :                 NDR_PULL_ALLOC_N(ndr, r->out.frs_update, r->in.credits_available);
    1453           0 :                 memset(r->out.frs_update, 0, (r->in.credits_available) * sizeof(*r->out.frs_update));
    1454           0 :                 NDR_PULL_ALLOC(ndr, r->out.update_count);
    1455           0 :                 NDR_ZERO_STRUCTP(r->out.update_count);
    1456           0 :                 NDR_PULL_ALLOC(ndr, r->out.update_status);
    1457           0 :                 NDR_ZERO_STRUCTP(r->out.update_status);
    1458           0 :                 NDR_PULL_ALLOC(ndr, r->out.gvsn_db_guid);
    1459           0 :                 NDR_ZERO_STRUCTP(r->out.gvsn_db_guid);
    1460           0 :                 NDR_PULL_ALLOC(ndr, r->out.gvsn_version);
    1461           0 :                 NDR_ZERO_STRUCTP(r->out.gvsn_version);
    1462           0 :                 if (r->in.version_vector_diff) {
    1463           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->in.version_vector_diff, r->in.version_vector_diff_count));
    1464             :                 }
    1465             :         }
    1466           0 :         if (flags & NDR_OUT) {
    1467             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1468             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1469           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.frs_update));
    1470           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->out.frs_update));
    1471           0 :                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->out.frs_update, &size_frs_update_1));
    1472           0 :                 NDR_CHECK(ndr_get_array_length(ndr, (void*)&r->out.frs_update, &length_frs_update_1));
    1473           0 :                 if (length_frs_update_1 > size_frs_update_1) {
    1474           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_frs_update_1, length_frs_update_1);
    1475             :                 }
    1476           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1477           0 :                         NDR_PULL_ALLOC_N(ndr, r->out.frs_update, size_frs_update_1);
    1478             :                 }
    1479           0 :                 _mem_save_frs_update_1 = NDR_PULL_GET_MEM_CTX(ndr);
    1480           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.frs_update, 0);
    1481           0 :                 for (cntr_frs_update_1 = 0; cntr_frs_update_1 < (length_frs_update_1); cntr_frs_update_1++) {
    1482           0 :                         NDR_CHECK(ndr_pull_frstrans_Update(ndr, NDR_SCALARS, &r->out.frs_update[cntr_frs_update_1]));
    1483             :                 }
    1484           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_frs_update_1, 0);
    1485           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1486           0 :                         NDR_PULL_ALLOC(ndr, r->out.update_count);
    1487             :                 }
    1488           0 :                 _mem_save_update_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1489           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.update_count, LIBNDR_FLAG_REF_ALLOC);
    1490           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.update_count));
    1491           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_update_count_0, LIBNDR_FLAG_REF_ALLOC);
    1492           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1493           0 :                         NDR_PULL_ALLOC(ndr, r->out.update_status);
    1494             :                 }
    1495           0 :                 _mem_save_update_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1496           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.update_status, LIBNDR_FLAG_REF_ALLOC);
    1497           0 :                 NDR_CHECK(ndr_pull_frstrans_UpdateStatus(ndr, NDR_SCALARS, r->out.update_status));
    1498           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_update_status_0, LIBNDR_FLAG_REF_ALLOC);
    1499           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1500           0 :                         NDR_PULL_ALLOC(ndr, r->out.gvsn_db_guid);
    1501             :                 }
    1502           0 :                 _mem_save_gvsn_db_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1503           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gvsn_db_guid, LIBNDR_FLAG_REF_ALLOC);
    1504           0 :                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->out.gvsn_db_guid));
    1505           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gvsn_db_guid_0, LIBNDR_FLAG_REF_ALLOC);
    1506           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1507           0 :                         NDR_PULL_ALLOC(ndr, r->out.gvsn_version);
    1508             :                 }
    1509           0 :                 _mem_save_gvsn_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1510           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gvsn_version, LIBNDR_FLAG_REF_ALLOC);
    1511           0 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, r->out.gvsn_version));
    1512           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gvsn_version_0, LIBNDR_FLAG_REF_ALLOC);
    1513           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1514           0 :                 if (r->out.frs_update) {
    1515           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->out.frs_update, r->in.credits_available));
    1516             :                 }
    1517           0 :                 if (r->out.frs_update) {
    1518           0 :                         NDR_CHECK(ndr_check_steal_array_length(ndr, (void*)&r->out.frs_update, *r->out.update_count));
    1519             :                 }
    1520             :         }
    1521           0 :         return NDR_ERR_SUCCESS;
    1522             : }
    1523             : 
    1524           0 : _PUBLIC_ void ndr_print_frstrans_RequestUpdates(struct ndr_print *ndr, const char *name, int flags, const struct frstrans_RequestUpdates *r)
    1525             : {
    1526             :         uint32_t cntr_version_vector_diff_1;
    1527             :         uint32_t cntr_frs_update_1;
    1528           0 :         ndr_print_struct(ndr, name, "frstrans_RequestUpdates");
    1529           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1530           0 :         ndr->depth++;
    1531           0 :         if (flags & NDR_SET_VALUES) {
    1532           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1533             :         }
    1534           0 :         if (flags & NDR_IN) {
    1535           0 :                 ndr_print_struct(ndr, "in", "frstrans_RequestUpdates");
    1536           0 :                 ndr->depth++;
    1537           0 :                 ndr_print_GUID(ndr, "connection_guid", &r->in.connection_guid);
    1538           0 :                 ndr_print_GUID(ndr, "content_set_guid", &r->in.content_set_guid);
    1539           0 :                 ndr_print_uint32(ndr, "credits_available", r->in.credits_available);
    1540           0 :                 ndr_print_uint32(ndr, "hash_requested", r->in.hash_requested);
    1541           0 :                 ndr_print_frstrans_UpdateRequestType(ndr, "update_request_type", r->in.update_request_type);
    1542           0 :                 ndr_print_uint32(ndr, "version_vector_diff_count", r->in.version_vector_diff_count);
    1543           0 :                 ndr_print_ptr(ndr, "version_vector_diff", r->in.version_vector_diff);
    1544           0 :                 ndr->depth++;
    1545           0 :                 ndr->print(ndr, "%s: ARRAY(%d)", "version_vector_diff", (int)r->in.version_vector_diff_count);
    1546           0 :                 ndr->depth++;
    1547           0 :                 for (cntr_version_vector_diff_1 = 0; cntr_version_vector_diff_1 < (r->in.version_vector_diff_count); cntr_version_vector_diff_1++) {
    1548           0 :                         ndr_print_frstrans_VersionVector(ndr, "version_vector_diff", &r->in.version_vector_diff[cntr_version_vector_diff_1]);
    1549             :                 }
    1550           0 :                 ndr->depth--;
    1551           0 :                 ndr->depth--;
    1552           0 :                 ndr->depth--;
    1553             :         }
    1554           0 :         if (flags & NDR_OUT) {
    1555           0 :                 ndr_print_struct(ndr, "out", "frstrans_RequestUpdates");
    1556           0 :                 ndr->depth++;
    1557           0 :                 ndr_print_ptr(ndr, "frs_update", r->out.frs_update);
    1558           0 :                 ndr->depth++;
    1559           0 :                 ndr->print(ndr, "%s: ARRAY(%d)", "frs_update", (int)*r->out.update_count);
    1560           0 :                 ndr->depth++;
    1561           0 :                 for (cntr_frs_update_1 = 0; cntr_frs_update_1 < (*r->out.update_count); cntr_frs_update_1++) {
    1562           0 :                         ndr_print_frstrans_Update(ndr, "frs_update", &r->out.frs_update[cntr_frs_update_1]);
    1563             :                 }
    1564           0 :                 ndr->depth--;
    1565           0 :                 ndr->depth--;
    1566           0 :                 ndr_print_ptr(ndr, "update_count", r->out.update_count);
    1567           0 :                 ndr->depth++;
    1568           0 :                 ndr_print_uint32(ndr, "update_count", *r->out.update_count);
    1569           0 :                 ndr->depth--;
    1570           0 :                 ndr_print_ptr(ndr, "update_status", r->out.update_status);
    1571           0 :                 ndr->depth++;
    1572           0 :                 ndr_print_frstrans_UpdateStatus(ndr, "update_status", *r->out.update_status);
    1573           0 :                 ndr->depth--;
    1574           0 :                 ndr_print_ptr(ndr, "gvsn_db_guid", r->out.gvsn_db_guid);
    1575           0 :                 ndr->depth++;
    1576           0 :                 ndr_print_GUID(ndr, "gvsn_db_guid", r->out.gvsn_db_guid);
    1577           0 :                 ndr->depth--;
    1578           0 :                 ndr_print_ptr(ndr, "gvsn_version", r->out.gvsn_version);
    1579           0 :                 ndr->depth++;
    1580           0 :                 ndr_print_hyper(ndr, "gvsn_version", *r->out.gvsn_version);
    1581           0 :                 ndr->depth--;
    1582           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1583           0 :                 ndr->depth--;
    1584             :         }
    1585           0 :         ndr->depth--;
    1586             : }
    1587             : 
    1588           0 : static enum ndr_err_code ndr_push_frstrans_RequestVersionVector(struct ndr_push *ndr, int flags, const struct frstrans_RequestVersionVector *r)
    1589             : {
    1590           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1591           0 :         if (flags & NDR_IN) {
    1592           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.sequence_number));
    1593           0 :                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
    1594           0 :                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.content_set_guid));
    1595           0 :                 NDR_CHECK(ndr_push_frstrans_VersionRequestType(ndr, NDR_SCALARS, r->in.request_type));
    1596           0 :                 NDR_CHECK(ndr_push_frstrans_VersionChangeType(ndr, NDR_SCALARS, r->in.change_type));
    1597           0 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->in.vv_generation));
    1598             :         }
    1599           0 :         if (flags & NDR_OUT) {
    1600           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1601             :         }
    1602           0 :         return NDR_ERR_SUCCESS;
    1603             : }
    1604             : 
    1605           0 : static enum ndr_err_code ndr_pull_frstrans_RequestVersionVector(struct ndr_pull *ndr, int flags, struct frstrans_RequestVersionVector *r)
    1606             : {
    1607           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1608           0 :         if (flags & NDR_IN) {
    1609           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.sequence_number));
    1610           0 :                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
    1611           0 :                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.content_set_guid));
    1612           0 :                 NDR_CHECK(ndr_pull_frstrans_VersionRequestType(ndr, NDR_SCALARS, &r->in.request_type));
    1613           0 :                 if (r->in.request_type > 2) {
    1614           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    1615             :                 }
    1616           0 :                 NDR_CHECK(ndr_pull_frstrans_VersionChangeType(ndr, NDR_SCALARS, &r->in.change_type));
    1617           0 :                 if (r->in.change_type > 2) {
    1618           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    1619             :                 }
    1620           0 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->in.vv_generation));
    1621             :         }
    1622           0 :         if (flags & NDR_OUT) {
    1623             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1624             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1625           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1626             :         }
    1627           0 :         return NDR_ERR_SUCCESS;
    1628             : }
    1629             : 
    1630           0 : _PUBLIC_ void ndr_print_frstrans_RequestVersionVector(struct ndr_print *ndr, const char *name, int flags, const struct frstrans_RequestVersionVector *r)
    1631             : {
    1632           0 :         ndr_print_struct(ndr, name, "frstrans_RequestVersionVector");
    1633           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1634           0 :         ndr->depth++;
    1635           0 :         if (flags & NDR_SET_VALUES) {
    1636           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1637             :         }
    1638           0 :         if (flags & NDR_IN) {
    1639           0 :                 ndr_print_struct(ndr, "in", "frstrans_RequestVersionVector");
    1640           0 :                 ndr->depth++;
    1641           0 :                 ndr_print_uint32(ndr, "sequence_number", r->in.sequence_number);
    1642           0 :                 ndr_print_GUID(ndr, "connection_guid", &r->in.connection_guid);
    1643           0 :                 ndr_print_GUID(ndr, "content_set_guid", &r->in.content_set_guid);
    1644           0 :                 ndr_print_frstrans_VersionRequestType(ndr, "request_type", r->in.request_type);
    1645           0 :                 ndr_print_frstrans_VersionChangeType(ndr, "change_type", r->in.change_type);
    1646           0 :                 ndr_print_hyper(ndr, "vv_generation", r->in.vv_generation);
    1647           0 :                 ndr->depth--;
    1648             :         }
    1649           0 :         if (flags & NDR_OUT) {
    1650           0 :                 ndr_print_struct(ndr, "out", "frstrans_RequestVersionVector");
    1651           0 :                 ndr->depth++;
    1652           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1653           0 :                 ndr->depth--;
    1654             :         }
    1655           0 :         ndr->depth--;
    1656             : }
    1657             : 
    1658           0 : static enum ndr_err_code ndr_push_frstrans_AsyncPoll(struct ndr_push *ndr, int flags, const struct frstrans_AsyncPoll *r)
    1659             : {
    1660           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1661           0 :         if (flags & NDR_IN) {
    1662           0 :                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
    1663             :         }
    1664           0 :         if (flags & NDR_OUT) {
    1665           0 :                 if (r->out.response == NULL) {
    1666           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1667             :                 }
    1668           0 :                 NDR_CHECK(ndr_push_frstrans_AsyncResponseContext(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.response));
    1669           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1670             :         }
    1671           0 :         return NDR_ERR_SUCCESS;
    1672             : }
    1673             : 
    1674           0 : static enum ndr_err_code ndr_pull_frstrans_AsyncPoll(struct ndr_pull *ndr, int flags, struct frstrans_AsyncPoll *r)
    1675             : {
    1676           0 :         TALLOC_CTX *_mem_save_response_0 = NULL;
    1677           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1678           0 :         if (flags & NDR_IN) {
    1679           0 :                 NDR_ZERO_STRUCT(r->out);
    1680             : 
    1681           0 :                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
    1682           0 :                 NDR_PULL_ALLOC(ndr, r->out.response);
    1683           0 :                 NDR_ZERO_STRUCTP(r->out.response);
    1684             :         }
    1685           0 :         if (flags & NDR_OUT) {
    1686             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1687             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1688           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1689           0 :                         NDR_PULL_ALLOC(ndr, r->out.response);
    1690             :                 }
    1691           0 :                 _mem_save_response_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1692           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.response, LIBNDR_FLAG_REF_ALLOC);
    1693           0 :                 NDR_CHECK(ndr_pull_frstrans_AsyncResponseContext(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.response));
    1694           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_response_0, LIBNDR_FLAG_REF_ALLOC);
    1695           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1696             :         }
    1697           0 :         return NDR_ERR_SUCCESS;
    1698             : }
    1699             : 
    1700           0 : _PUBLIC_ void ndr_print_frstrans_AsyncPoll(struct ndr_print *ndr, const char *name, int flags, const struct frstrans_AsyncPoll *r)
    1701             : {
    1702           0 :         ndr_print_struct(ndr, name, "frstrans_AsyncPoll");
    1703           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1704           0 :         ndr->depth++;
    1705           0 :         if (flags & NDR_SET_VALUES) {
    1706           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1707             :         }
    1708           0 :         if (flags & NDR_IN) {
    1709           0 :                 ndr_print_struct(ndr, "in", "frstrans_AsyncPoll");
    1710           0 :                 ndr->depth++;
    1711           0 :                 ndr_print_GUID(ndr, "connection_guid", &r->in.connection_guid);
    1712           0 :                 ndr->depth--;
    1713             :         }
    1714           0 :         if (flags & NDR_OUT) {
    1715           0 :                 ndr_print_struct(ndr, "out", "frstrans_AsyncPoll");
    1716           0 :                 ndr->depth++;
    1717           0 :                 ndr_print_ptr(ndr, "response", r->out.response);
    1718           0 :                 ndr->depth++;
    1719           0 :                 ndr_print_frstrans_AsyncResponseContext(ndr, "response", r->out.response);
    1720           0 :                 ndr->depth--;
    1721           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1722           0 :                 ndr->depth--;
    1723             :         }
    1724           0 :         ndr->depth--;
    1725             : }
    1726             : 
    1727           0 : static enum ndr_err_code ndr_push_FRSTRANS_REQUEST_RECORDS(struct ndr_push *ndr, int flags, const struct FRSTRANS_REQUEST_RECORDS *r)
    1728             : {
    1729           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1730           0 :         if (flags & NDR_IN) {
    1731             :         }
    1732           0 :         if (flags & NDR_OUT) {
    1733             :         }
    1734           0 :         return NDR_ERR_SUCCESS;
    1735             : }
    1736             : 
    1737           0 : static enum ndr_err_code ndr_pull_FRSTRANS_REQUEST_RECORDS(struct ndr_pull *ndr, int flags, struct FRSTRANS_REQUEST_RECORDS *r)
    1738             : {
    1739           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1740           0 :         if (flags & NDR_IN) {
    1741             :         }
    1742           0 :         if (flags & NDR_OUT) {
    1743             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1744             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1745             :         }
    1746           0 :         return NDR_ERR_SUCCESS;
    1747             : }
    1748             : 
    1749           0 : _PUBLIC_ void ndr_print_FRSTRANS_REQUEST_RECORDS(struct ndr_print *ndr, const char *name, int flags, const struct FRSTRANS_REQUEST_RECORDS *r)
    1750             : {
    1751           0 :         ndr_print_struct(ndr, name, "FRSTRANS_REQUEST_RECORDS");
    1752           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1753           0 :         ndr->depth++;
    1754           0 :         if (flags & NDR_SET_VALUES) {
    1755           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1756             :         }
    1757           0 :         if (flags & NDR_IN) {
    1758           0 :                 ndr_print_struct(ndr, "in", "FRSTRANS_REQUEST_RECORDS");
    1759           0 :                 ndr->depth++;
    1760           0 :                 ndr->depth--;
    1761             :         }
    1762           0 :         if (flags & NDR_OUT) {
    1763           0 :                 ndr_print_struct(ndr, "out", "FRSTRANS_REQUEST_RECORDS");
    1764           0 :                 ndr->depth++;
    1765           0 :                 ndr->depth--;
    1766             :         }
    1767           0 :         ndr->depth--;
    1768             : }
    1769             : 
    1770           0 : static enum ndr_err_code ndr_push_FRSTRANS_UPDATE_CANCEL(struct ndr_push *ndr, int flags, const struct FRSTRANS_UPDATE_CANCEL *r)
    1771             : {
    1772           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1773           0 :         if (flags & NDR_IN) {
    1774             :         }
    1775           0 :         if (flags & NDR_OUT) {
    1776             :         }
    1777           0 :         return NDR_ERR_SUCCESS;
    1778             : }
    1779             : 
    1780           0 : static enum ndr_err_code ndr_pull_FRSTRANS_UPDATE_CANCEL(struct ndr_pull *ndr, int flags, struct FRSTRANS_UPDATE_CANCEL *r)
    1781             : {
    1782           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1783           0 :         if (flags & NDR_IN) {
    1784             :         }
    1785           0 :         if (flags & NDR_OUT) {
    1786             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1787             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1788             :         }
    1789           0 :         return NDR_ERR_SUCCESS;
    1790             : }
    1791             : 
    1792           0 : _PUBLIC_ void ndr_print_FRSTRANS_UPDATE_CANCEL(struct ndr_print *ndr, const char *name, int flags, const struct FRSTRANS_UPDATE_CANCEL *r)
    1793             : {
    1794           0 :         ndr_print_struct(ndr, name, "FRSTRANS_UPDATE_CANCEL");
    1795           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1796           0 :         ndr->depth++;
    1797           0 :         if (flags & NDR_SET_VALUES) {
    1798           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1799             :         }
    1800           0 :         if (flags & NDR_IN) {
    1801           0 :                 ndr_print_struct(ndr, "in", "FRSTRANS_UPDATE_CANCEL");
    1802           0 :                 ndr->depth++;
    1803           0 :                 ndr->depth--;
    1804             :         }
    1805           0 :         if (flags & NDR_OUT) {
    1806           0 :                 ndr_print_struct(ndr, "out", "FRSTRANS_UPDATE_CANCEL");
    1807           0 :                 ndr->depth++;
    1808           0 :                 ndr->depth--;
    1809             :         }
    1810           0 :         ndr->depth--;
    1811             : }
    1812             : 
    1813           0 : static enum ndr_err_code ndr_push_FRSTRANS_RAW_GET_FILE_DATA(struct ndr_push *ndr, int flags, const struct FRSTRANS_RAW_GET_FILE_DATA *r)
    1814             : {
    1815           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1816           0 :         if (flags & NDR_IN) {
    1817             :         }
    1818           0 :         if (flags & NDR_OUT) {
    1819             :         }
    1820           0 :         return NDR_ERR_SUCCESS;
    1821             : }
    1822             : 
    1823           0 : static enum ndr_err_code ndr_pull_FRSTRANS_RAW_GET_FILE_DATA(struct ndr_pull *ndr, int flags, struct FRSTRANS_RAW_GET_FILE_DATA *r)
    1824             : {
    1825           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1826           0 :         if (flags & NDR_IN) {
    1827             :         }
    1828           0 :         if (flags & NDR_OUT) {
    1829             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1830             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1831             :         }
    1832           0 :         return NDR_ERR_SUCCESS;
    1833             : }
    1834             : 
    1835           0 : _PUBLIC_ void ndr_print_FRSTRANS_RAW_GET_FILE_DATA(struct ndr_print *ndr, const char *name, int flags, const struct FRSTRANS_RAW_GET_FILE_DATA *r)
    1836             : {
    1837           0 :         ndr_print_struct(ndr, name, "FRSTRANS_RAW_GET_FILE_DATA");
    1838           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1839           0 :         ndr->depth++;
    1840           0 :         if (flags & NDR_SET_VALUES) {
    1841           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1842             :         }
    1843           0 :         if (flags & NDR_IN) {
    1844           0 :                 ndr_print_struct(ndr, "in", "FRSTRANS_RAW_GET_FILE_DATA");
    1845           0 :                 ndr->depth++;
    1846           0 :                 ndr->depth--;
    1847             :         }
    1848           0 :         if (flags & NDR_OUT) {
    1849           0 :                 ndr_print_struct(ndr, "out", "FRSTRANS_RAW_GET_FILE_DATA");
    1850           0 :                 ndr->depth++;
    1851           0 :                 ndr->depth--;
    1852             :         }
    1853           0 :         ndr->depth--;
    1854             : }
    1855             : 
    1856           0 : static enum ndr_err_code ndr_push_FRSTRANS_RDC_GET_SIGNATURES(struct ndr_push *ndr, int flags, const struct FRSTRANS_RDC_GET_SIGNATURES *r)
    1857             : {
    1858           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1859           0 :         if (flags & NDR_IN) {
    1860             :         }
    1861           0 :         if (flags & NDR_OUT) {
    1862             :         }
    1863           0 :         return NDR_ERR_SUCCESS;
    1864             : }
    1865             : 
    1866           0 : static enum ndr_err_code ndr_pull_FRSTRANS_RDC_GET_SIGNATURES(struct ndr_pull *ndr, int flags, struct FRSTRANS_RDC_GET_SIGNATURES *r)
    1867             : {
    1868           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1869           0 :         if (flags & NDR_IN) {
    1870             :         }
    1871           0 :         if (flags & NDR_OUT) {
    1872             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1873             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1874             :         }
    1875           0 :         return NDR_ERR_SUCCESS;
    1876             : }
    1877             : 
    1878           0 : _PUBLIC_ void ndr_print_FRSTRANS_RDC_GET_SIGNATURES(struct ndr_print *ndr, const char *name, int flags, const struct FRSTRANS_RDC_GET_SIGNATURES *r)
    1879             : {
    1880           0 :         ndr_print_struct(ndr, name, "FRSTRANS_RDC_GET_SIGNATURES");
    1881           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1882           0 :         ndr->depth++;
    1883           0 :         if (flags & NDR_SET_VALUES) {
    1884           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1885             :         }
    1886           0 :         if (flags & NDR_IN) {
    1887           0 :                 ndr_print_struct(ndr, "in", "FRSTRANS_RDC_GET_SIGNATURES");
    1888           0 :                 ndr->depth++;
    1889           0 :                 ndr->depth--;
    1890             :         }
    1891           0 :         if (flags & NDR_OUT) {
    1892           0 :                 ndr_print_struct(ndr, "out", "FRSTRANS_RDC_GET_SIGNATURES");
    1893           0 :                 ndr->depth++;
    1894           0 :                 ndr->depth--;
    1895             :         }
    1896           0 :         ndr->depth--;
    1897             : }
    1898             : 
    1899           0 : static enum ndr_err_code ndr_push_FRSTRANS_RDC_PUSH_SOURCE_NEEDS(struct ndr_push *ndr, int flags, const struct FRSTRANS_RDC_PUSH_SOURCE_NEEDS *r)
    1900             : {
    1901           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1902           0 :         if (flags & NDR_IN) {
    1903             :         }
    1904           0 :         if (flags & NDR_OUT) {
    1905             :         }
    1906           0 :         return NDR_ERR_SUCCESS;
    1907             : }
    1908             : 
    1909           0 : static enum ndr_err_code ndr_pull_FRSTRANS_RDC_PUSH_SOURCE_NEEDS(struct ndr_pull *ndr, int flags, struct FRSTRANS_RDC_PUSH_SOURCE_NEEDS *r)
    1910             : {
    1911           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1912           0 :         if (flags & NDR_IN) {
    1913             :         }
    1914           0 :         if (flags & NDR_OUT) {
    1915             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1916             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1917             :         }
    1918           0 :         return NDR_ERR_SUCCESS;
    1919             : }
    1920             : 
    1921           0 : _PUBLIC_ void ndr_print_FRSTRANS_RDC_PUSH_SOURCE_NEEDS(struct ndr_print *ndr, const char *name, int flags, const struct FRSTRANS_RDC_PUSH_SOURCE_NEEDS *r)
    1922             : {
    1923           0 :         ndr_print_struct(ndr, name, "FRSTRANS_RDC_PUSH_SOURCE_NEEDS");
    1924           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1925           0 :         ndr->depth++;
    1926           0 :         if (flags & NDR_SET_VALUES) {
    1927           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1928             :         }
    1929           0 :         if (flags & NDR_IN) {
    1930           0 :                 ndr_print_struct(ndr, "in", "FRSTRANS_RDC_PUSH_SOURCE_NEEDS");
    1931           0 :                 ndr->depth++;
    1932           0 :                 ndr->depth--;
    1933             :         }
    1934           0 :         if (flags & NDR_OUT) {
    1935           0 :                 ndr_print_struct(ndr, "out", "FRSTRANS_RDC_PUSH_SOURCE_NEEDS");
    1936           0 :                 ndr->depth++;
    1937           0 :                 ndr->depth--;
    1938             :         }
    1939           0 :         ndr->depth--;
    1940             : }
    1941             : 
    1942           0 : static enum ndr_err_code ndr_push_FRSTRANS_RDC_GET_FILE_DATA(struct ndr_push *ndr, int flags, const struct FRSTRANS_RDC_GET_FILE_DATA *r)
    1943             : {
    1944           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1945           0 :         if (flags & NDR_IN) {
    1946             :         }
    1947           0 :         if (flags & NDR_OUT) {
    1948             :         }
    1949           0 :         return NDR_ERR_SUCCESS;
    1950             : }
    1951             : 
    1952           0 : static enum ndr_err_code ndr_pull_FRSTRANS_RDC_GET_FILE_DATA(struct ndr_pull *ndr, int flags, struct FRSTRANS_RDC_GET_FILE_DATA *r)
    1953             : {
    1954           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1955           0 :         if (flags & NDR_IN) {
    1956             :         }
    1957           0 :         if (flags & NDR_OUT) {
    1958             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1959             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1960             :         }
    1961           0 :         return NDR_ERR_SUCCESS;
    1962             : }
    1963             : 
    1964           0 : _PUBLIC_ void ndr_print_FRSTRANS_RDC_GET_FILE_DATA(struct ndr_print *ndr, const char *name, int flags, const struct FRSTRANS_RDC_GET_FILE_DATA *r)
    1965             : {
    1966           0 :         ndr_print_struct(ndr, name, "FRSTRANS_RDC_GET_FILE_DATA");
    1967           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1968           0 :         ndr->depth++;
    1969           0 :         if (flags & NDR_SET_VALUES) {
    1970           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1971             :         }
    1972           0 :         if (flags & NDR_IN) {
    1973           0 :                 ndr_print_struct(ndr, "in", "FRSTRANS_RDC_GET_FILE_DATA");
    1974           0 :                 ndr->depth++;
    1975           0 :                 ndr->depth--;
    1976             :         }
    1977           0 :         if (flags & NDR_OUT) {
    1978           0 :                 ndr_print_struct(ndr, "out", "FRSTRANS_RDC_GET_FILE_DATA");
    1979           0 :                 ndr->depth++;
    1980           0 :                 ndr->depth--;
    1981             :         }
    1982           0 :         ndr->depth--;
    1983             : }
    1984             : 
    1985           0 : static enum ndr_err_code ndr_push_frstrans_RdcClose(struct ndr_push *ndr, int flags, const struct frstrans_RdcClose *r)
    1986             : {
    1987           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1988           0 :         if (flags & NDR_IN) {
    1989           0 :                 if (r->in.server_context == NULL) {
    1990           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1991             :                 }
    1992           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.server_context));
    1993             :         }
    1994           0 :         if (flags & NDR_OUT) {
    1995           0 :                 if (r->out.server_context == NULL) {
    1996           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1997             :                 }
    1998           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.server_context));
    1999           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2000             :         }
    2001           0 :         return NDR_ERR_SUCCESS;
    2002             : }
    2003             : 
    2004           0 : static enum ndr_err_code ndr_pull_frstrans_RdcClose(struct ndr_pull *ndr, int flags, struct frstrans_RdcClose *r)
    2005             : {
    2006           0 :         TALLOC_CTX *_mem_save_server_context_0 = NULL;
    2007           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2008           0 :         if (flags & NDR_IN) {
    2009           0 :                 NDR_ZERO_STRUCT(r->out);
    2010             : 
    2011           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2012           0 :                         NDR_PULL_ALLOC(ndr, r->in.server_context);
    2013             :                 }
    2014           0 :                 _mem_save_server_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2015           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.server_context, LIBNDR_FLAG_REF_ALLOC);
    2016           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.server_context));
    2017           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_context_0, LIBNDR_FLAG_REF_ALLOC);
    2018           0 :                 NDR_PULL_ALLOC(ndr, r->out.server_context);
    2019           0 :                 *r->out.server_context = *r->in.server_context;
    2020             :         }
    2021           0 :         if (flags & NDR_OUT) {
    2022             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2023             :                 if (r->in.server_context == NULL) {
    2024             :                         NDR_PULL_ALLOC(ndr, r->in.server_context);
    2025             :                         NDR_ZERO_STRUCTP(r->in.server_context);
    2026             :                 }
    2027             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2028           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2029           0 :                         NDR_PULL_ALLOC(ndr, r->out.server_context);
    2030             :                 }
    2031           0 :                 _mem_save_server_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2032           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_context, LIBNDR_FLAG_REF_ALLOC);
    2033           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.server_context));
    2034           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_context_0, LIBNDR_FLAG_REF_ALLOC);
    2035           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2036             :         }
    2037           0 :         return NDR_ERR_SUCCESS;
    2038             : }
    2039             : 
    2040           0 : _PUBLIC_ void ndr_print_frstrans_RdcClose(struct ndr_print *ndr, const char *name, int flags, const struct frstrans_RdcClose *r)
    2041             : {
    2042           0 :         ndr_print_struct(ndr, name, "frstrans_RdcClose");
    2043           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2044           0 :         ndr->depth++;
    2045           0 :         if (flags & NDR_SET_VALUES) {
    2046           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2047             :         }
    2048           0 :         if (flags & NDR_IN) {
    2049           0 :                 ndr_print_struct(ndr, "in", "frstrans_RdcClose");
    2050           0 :                 ndr->depth++;
    2051           0 :                 ndr_print_ptr(ndr, "server_context", r->in.server_context);
    2052           0 :                 ndr->depth++;
    2053           0 :                 ndr_print_policy_handle(ndr, "server_context", r->in.server_context);
    2054           0 :                 ndr->depth--;
    2055           0 :                 ndr->depth--;
    2056             :         }
    2057           0 :         if (flags & NDR_OUT) {
    2058           0 :                 ndr_print_struct(ndr, "out", "frstrans_RdcClose");
    2059           0 :                 ndr->depth++;
    2060           0 :                 ndr_print_ptr(ndr, "server_context", r->out.server_context);
    2061           0 :                 ndr->depth++;
    2062           0 :                 ndr_print_policy_handle(ndr, "server_context", r->out.server_context);
    2063           0 :                 ndr->depth--;
    2064           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2065           0 :                 ndr->depth--;
    2066             :         }
    2067           0 :         ndr->depth--;
    2068             : }
    2069             : 
    2070           0 : static enum ndr_err_code ndr_push_frstrans_InitializeFileTransferAsync(struct ndr_push *ndr, int flags, const struct frstrans_InitializeFileTransferAsync *r)
    2071             : {
    2072           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2073           0 :         if (flags & NDR_IN) {
    2074           0 :                 if (r->in.frs_update == NULL) {
    2075           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2076             :                 }
    2077           0 :                 if (r->in.staging_policy == NULL) {
    2078           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2079             :                 }
    2080           0 :                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
    2081           0 :                 NDR_CHECK(ndr_push_frstrans_Update(ndr, NDR_SCALARS, r->in.frs_update));
    2082           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rdc_desired));
    2083           0 :                 NDR_CHECK(ndr_push_frstrans_RequestedStagingPolicy(ndr, NDR_SCALARS, *r->in.staging_policy));
    2084           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buffer_size));
    2085             :         }
    2086           0 :         if (flags & NDR_OUT) {
    2087           0 :                 if (r->out.frs_update == NULL) {
    2088           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2089             :                 }
    2090           0 :                 if (r->out.staging_policy == NULL) {
    2091           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2092             :                 }
    2093           0 :                 if (r->out.server_context == NULL) {
    2094           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2095             :                 }
    2096           0 :                 if (r->out.rdc_file_info == NULL) {
    2097           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2098             :                 }
    2099           0 :                 if (r->out.data_buffer == NULL) {
    2100           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2101             :                 }
    2102           0 :                 if (r->out.size_read == NULL) {
    2103           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2104             :                 }
    2105           0 :                 if (r->out.is_end_of_file == NULL) {
    2106           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2107             :                 }
    2108           0 :                 NDR_CHECK(ndr_push_frstrans_Update(ndr, NDR_SCALARS, r->out.frs_update));
    2109           0 :                 NDR_CHECK(ndr_push_frstrans_RequestedStagingPolicy(ndr, NDR_SCALARS, *r->out.staging_policy));
    2110           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.server_context));
    2111           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rdc_file_info));
    2112           0 :                 if (*r->out.rdc_file_info) {
    2113           0 :                         NDR_CHECK(ndr_push_frstrans_RdcFileInfo(ndr, NDR_SCALARS, *r->out.rdc_file_info));
    2114             :                 }
    2115           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.buffer_size));
    2116           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    2117           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.size_read));
    2118           0 :                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data_buffer, *r->out.size_read));
    2119           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.size_read));
    2120           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.is_end_of_file));
    2121           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2122             :         }
    2123           0 :         return NDR_ERR_SUCCESS;
    2124             : }
    2125             : 
    2126           0 : static enum ndr_err_code ndr_pull_frstrans_InitializeFileTransferAsync(struct ndr_pull *ndr, int flags, struct frstrans_InitializeFileTransferAsync *r)
    2127             : {
    2128             :         uint32_t _ptr_rdc_file_info;
    2129           0 :         uint32_t size_data_buffer_1 = 0;
    2130           0 :         uint32_t length_data_buffer_1 = 0;
    2131           0 :         TALLOC_CTX *_mem_save_frs_update_0 = NULL;
    2132           0 :         TALLOC_CTX *_mem_save_staging_policy_0 = NULL;
    2133           0 :         TALLOC_CTX *_mem_save_server_context_0 = NULL;
    2134           0 :         TALLOC_CTX *_mem_save_rdc_file_info_0 = NULL;
    2135           0 :         TALLOC_CTX *_mem_save_rdc_file_info_1 = NULL;
    2136           0 :         TALLOC_CTX *_mem_save_size_read_0 = NULL;
    2137           0 :         TALLOC_CTX *_mem_save_is_end_of_file_0 = NULL;
    2138           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2139           0 :         if (flags & NDR_IN) {
    2140           0 :                 NDR_ZERO_STRUCT(r->out);
    2141             : 
    2142           0 :                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
    2143           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2144           0 :                         NDR_PULL_ALLOC(ndr, r->in.frs_update);
    2145             :                 }
    2146           0 :                 _mem_save_frs_update_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2147           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.frs_update, LIBNDR_FLAG_REF_ALLOC);
    2148           0 :                 NDR_CHECK(ndr_pull_frstrans_Update(ndr, NDR_SCALARS, r->in.frs_update));
    2149           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_frs_update_0, LIBNDR_FLAG_REF_ALLOC);
    2150           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rdc_desired));
    2151           0 :                 if (r->in.rdc_desired > 1) {
    2152           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    2153             :                 }
    2154           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2155           0 :                         NDR_PULL_ALLOC(ndr, r->in.staging_policy);
    2156             :                 }
    2157           0 :                 _mem_save_staging_policy_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2158           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.staging_policy, LIBNDR_FLAG_REF_ALLOC);
    2159           0 :                 NDR_CHECK(ndr_pull_frstrans_RequestedStagingPolicy(ndr, NDR_SCALARS, r->in.staging_policy));
    2160           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_staging_policy_0, LIBNDR_FLAG_REF_ALLOC);
    2161           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buffer_size));
    2162           0 :                 if (r->in.buffer_size > 262144) {
    2163           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    2164             :                 }
    2165           0 :                 NDR_PULL_ALLOC(ndr, r->out.frs_update);
    2166           0 :                 *r->out.frs_update = *r->in.frs_update;
    2167           0 :                 NDR_PULL_ALLOC(ndr, r->out.staging_policy);
    2168           0 :                 *r->out.staging_policy = *r->in.staging_policy;
    2169           0 :                 NDR_PULL_ALLOC(ndr, r->out.server_context);
    2170           0 :                 NDR_ZERO_STRUCTP(r->out.server_context);
    2171           0 :                 NDR_PULL_ALLOC(ndr, r->out.rdc_file_info);
    2172           0 :                 NDR_ZERO_STRUCTP(r->out.rdc_file_info);
    2173           0 :                 NDR_PULL_ALLOC_N(ndr, r->out.data_buffer, r->in.buffer_size);
    2174           0 :                 memset(r->out.data_buffer, 0, (r->in.buffer_size) * sizeof(*r->out.data_buffer));
    2175           0 :                 NDR_PULL_ALLOC(ndr, r->out.size_read);
    2176           0 :                 NDR_ZERO_STRUCTP(r->out.size_read);
    2177           0 :                 NDR_PULL_ALLOC(ndr, r->out.is_end_of_file);
    2178           0 :                 NDR_ZERO_STRUCTP(r->out.is_end_of_file);
    2179             :         }
    2180           0 :         if (flags & NDR_OUT) {
    2181             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2182             :                 if (r->in.frs_update == NULL) {
    2183             :                         NDR_PULL_ALLOC(ndr, r->in.frs_update);
    2184             :                         NDR_ZERO_STRUCTP(r->in.frs_update);
    2185             :                 }
    2186             :                 if (r->in.staging_policy == NULL) {
    2187             :                         NDR_PULL_ALLOC(ndr, r->in.staging_policy);
    2188             :                         NDR_ZERO_STRUCTP(r->in.staging_policy);
    2189             :                 }
    2190             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2191           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2192           0 :                         NDR_PULL_ALLOC(ndr, r->out.frs_update);
    2193             :                 }
    2194           0 :                 _mem_save_frs_update_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2195           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.frs_update, LIBNDR_FLAG_REF_ALLOC);
    2196           0 :                 NDR_CHECK(ndr_pull_frstrans_Update(ndr, NDR_SCALARS, r->out.frs_update));
    2197           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_frs_update_0, LIBNDR_FLAG_REF_ALLOC);
    2198           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2199           0 :                         NDR_PULL_ALLOC(ndr, r->out.staging_policy);
    2200             :                 }
    2201           0 :                 _mem_save_staging_policy_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2202           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.staging_policy, LIBNDR_FLAG_REF_ALLOC);
    2203           0 :                 NDR_CHECK(ndr_pull_frstrans_RequestedStagingPolicy(ndr, NDR_SCALARS, r->out.staging_policy));
    2204           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_staging_policy_0, LIBNDR_FLAG_REF_ALLOC);
    2205           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2206           0 :                         NDR_PULL_ALLOC(ndr, r->out.server_context);
    2207             :                 }
    2208           0 :                 _mem_save_server_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2209           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_context, LIBNDR_FLAG_REF_ALLOC);
    2210           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.server_context));
    2211           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_context_0, LIBNDR_FLAG_REF_ALLOC);
    2212           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2213           0 :                         NDR_PULL_ALLOC(ndr, r->out.rdc_file_info);
    2214             :                 }
    2215           0 :                 _mem_save_rdc_file_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2216           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rdc_file_info, LIBNDR_FLAG_REF_ALLOC);
    2217           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rdc_file_info));
    2218           0 :                 if (_ptr_rdc_file_info) {
    2219           0 :                         NDR_PULL_ALLOC(ndr, *r->out.rdc_file_info);
    2220             :                 } else {
    2221           0 :                         *r->out.rdc_file_info = NULL;
    2222             :                 }
    2223           0 :                 if (*r->out.rdc_file_info) {
    2224           0 :                         _mem_save_rdc_file_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
    2225           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.rdc_file_info, 0);
    2226           0 :                         NDR_CHECK(ndr_pull_frstrans_RdcFileInfo(ndr, NDR_SCALARS, *r->out.rdc_file_info));
    2227           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rdc_file_info_1, 0);
    2228             :                 }
    2229           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rdc_file_info_0, LIBNDR_FLAG_REF_ALLOC);
    2230           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data_buffer));
    2231           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->out.data_buffer));
    2232           0 :                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->out.data_buffer, &size_data_buffer_1));
    2233           0 :                 NDR_CHECK(ndr_get_array_length(ndr, (void*)&r->out.data_buffer, &length_data_buffer_1));
    2234           0 :                 if (length_data_buffer_1 > size_data_buffer_1) {
    2235           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_data_buffer_1, length_data_buffer_1);
    2236             :                 }
    2237           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2238           0 :                         NDR_PULL_ALLOC_N(ndr, r->out.data_buffer, size_data_buffer_1);
    2239             :                 }
    2240           0 :                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data_buffer, length_data_buffer_1));
    2241           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2242           0 :                         NDR_PULL_ALLOC(ndr, r->out.size_read);
    2243             :                 }
    2244           0 :                 _mem_save_size_read_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2245           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.size_read, LIBNDR_FLAG_REF_ALLOC);
    2246           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.size_read));
    2247           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_size_read_0, LIBNDR_FLAG_REF_ALLOC);
    2248           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2249           0 :                         NDR_PULL_ALLOC(ndr, r->out.is_end_of_file);
    2250             :                 }
    2251           0 :                 _mem_save_is_end_of_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2252           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.is_end_of_file, LIBNDR_FLAG_REF_ALLOC);
    2253           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.is_end_of_file));
    2254           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_is_end_of_file_0, LIBNDR_FLAG_REF_ALLOC);
    2255           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2256           0 :                 if (r->out.data_buffer) {
    2257           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->out.data_buffer, r->in.buffer_size));
    2258             :                 }
    2259           0 :                 if (r->out.data_buffer) {
    2260           0 :                         NDR_CHECK(ndr_check_steal_array_length(ndr, (void*)&r->out.data_buffer, *r->out.size_read));
    2261             :                 }
    2262             :         }
    2263           0 :         return NDR_ERR_SUCCESS;
    2264             : }
    2265             : 
    2266           0 : _PUBLIC_ void ndr_print_frstrans_InitializeFileTransferAsync(struct ndr_print *ndr, const char *name, int flags, const struct frstrans_InitializeFileTransferAsync *r)
    2267             : {
    2268           0 :         ndr_print_struct(ndr, name, "frstrans_InitializeFileTransferAsync");
    2269           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2270           0 :         ndr->depth++;
    2271           0 :         if (flags & NDR_SET_VALUES) {
    2272           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2273             :         }
    2274           0 :         if (flags & NDR_IN) {
    2275           0 :                 ndr_print_struct(ndr, "in", "frstrans_InitializeFileTransferAsync");
    2276           0 :                 ndr->depth++;
    2277           0 :                 ndr_print_GUID(ndr, "connection_guid", &r->in.connection_guid);
    2278           0 :                 ndr_print_ptr(ndr, "frs_update", r->in.frs_update);
    2279           0 :                 ndr->depth++;
    2280           0 :                 ndr_print_frstrans_Update(ndr, "frs_update", r->in.frs_update);
    2281           0 :                 ndr->depth--;
    2282           0 :                 ndr_print_uint32(ndr, "rdc_desired", r->in.rdc_desired);
    2283           0 :                 ndr_print_ptr(ndr, "staging_policy", r->in.staging_policy);
    2284           0 :                 ndr->depth++;
    2285           0 :                 ndr_print_frstrans_RequestedStagingPolicy(ndr, "staging_policy", *r->in.staging_policy);
    2286           0 :                 ndr->depth--;
    2287           0 :                 ndr_print_uint32(ndr, "buffer_size", r->in.buffer_size);
    2288           0 :                 ndr->depth--;
    2289             :         }
    2290           0 :         if (flags & NDR_OUT) {
    2291           0 :                 ndr_print_struct(ndr, "out", "frstrans_InitializeFileTransferAsync");
    2292           0 :                 ndr->depth++;
    2293           0 :                 ndr_print_ptr(ndr, "frs_update", r->out.frs_update);
    2294           0 :                 ndr->depth++;
    2295           0 :                 ndr_print_frstrans_Update(ndr, "frs_update", r->out.frs_update);
    2296           0 :                 ndr->depth--;
    2297           0 :                 ndr_print_ptr(ndr, "staging_policy", r->out.staging_policy);
    2298           0 :                 ndr->depth++;
    2299           0 :                 ndr_print_frstrans_RequestedStagingPolicy(ndr, "staging_policy", *r->out.staging_policy);
    2300           0 :                 ndr->depth--;
    2301           0 :                 ndr_print_ptr(ndr, "server_context", r->out.server_context);
    2302           0 :                 ndr->depth++;
    2303           0 :                 ndr_print_policy_handle(ndr, "server_context", r->out.server_context);
    2304           0 :                 ndr->depth--;
    2305           0 :                 ndr_print_ptr(ndr, "rdc_file_info", r->out.rdc_file_info);
    2306           0 :                 ndr->depth++;
    2307           0 :                 ndr_print_ptr(ndr, "rdc_file_info", *r->out.rdc_file_info);
    2308           0 :                 ndr->depth++;
    2309           0 :                 if (*r->out.rdc_file_info) {
    2310           0 :                         ndr_print_frstrans_RdcFileInfo(ndr, "rdc_file_info", *r->out.rdc_file_info);
    2311             :                 }
    2312           0 :                 ndr->depth--;
    2313           0 :                 ndr->depth--;
    2314           0 :                 ndr_print_ptr(ndr, "data_buffer", r->out.data_buffer);
    2315           0 :                 ndr->depth++;
    2316           0 :                 ndr_print_array_uint8(ndr, "data_buffer", r->out.data_buffer, *r->out.size_read);
    2317           0 :                 ndr->depth--;
    2318           0 :                 ndr_print_ptr(ndr, "size_read", r->out.size_read);
    2319           0 :                 ndr->depth++;
    2320           0 :                 ndr_print_uint32(ndr, "size_read", *r->out.size_read);
    2321           0 :                 ndr->depth--;
    2322           0 :                 ndr_print_ptr(ndr, "is_end_of_file", r->out.is_end_of_file);
    2323           0 :                 ndr->depth++;
    2324           0 :                 ndr_print_uint32(ndr, "is_end_of_file", *r->out.is_end_of_file);
    2325           0 :                 ndr->depth--;
    2326           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2327           0 :                 ndr->depth--;
    2328             :         }
    2329           0 :         ndr->depth--;
    2330             : }
    2331             : 
    2332           0 : static enum ndr_err_code ndr_push_FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE(struct ndr_push *ndr, int flags, const struct FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE *r)
    2333             : {
    2334           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2335           0 :         if (flags & NDR_IN) {
    2336             :         }
    2337           0 :         if (flags & NDR_OUT) {
    2338             :         }
    2339           0 :         return NDR_ERR_SUCCESS;
    2340             : }
    2341             : 
    2342           0 : static enum ndr_err_code ndr_pull_FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE(struct ndr_pull *ndr, int flags, struct FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE *r)
    2343             : {
    2344           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2345           0 :         if (flags & NDR_IN) {
    2346             :         }
    2347           0 :         if (flags & NDR_OUT) {
    2348             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2349             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2350             :         }
    2351           0 :         return NDR_ERR_SUCCESS;
    2352             : }
    2353             : 
    2354           0 : _PUBLIC_ void ndr_print_FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE(struct ndr_print *ndr, const char *name, int flags, const struct FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE *r)
    2355             : {
    2356           0 :         ndr_print_struct(ndr, name, "FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE");
    2357           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2358           0 :         ndr->depth++;
    2359           0 :         if (flags & NDR_SET_VALUES) {
    2360           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2361             :         }
    2362           0 :         if (flags & NDR_IN) {
    2363           0 :                 ndr_print_struct(ndr, "in", "FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE");
    2364           0 :                 ndr->depth++;
    2365           0 :                 ndr->depth--;
    2366             :         }
    2367           0 :         if (flags & NDR_OUT) {
    2368           0 :                 ndr_print_struct(ndr, "out", "FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE");
    2369           0 :                 ndr->depth++;
    2370           0 :                 ndr->depth--;
    2371             :         }
    2372           0 :         ndr->depth--;
    2373             : }
    2374             : 
    2375           0 : static enum ndr_err_code ndr_push_frstrans_RawGetFileDataAsync(struct ndr_push *ndr, int flags, const struct frstrans_RawGetFileDataAsync *r)
    2376             : {
    2377           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2378           0 :         if (flags & NDR_IN) {
    2379           0 :                 if (r->in.server_context == NULL) {
    2380           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2381             :                 }
    2382           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.server_context));
    2383             :         }
    2384           0 :         if (flags & NDR_OUT) {
    2385           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2386             :         }
    2387           0 :         return NDR_ERR_SUCCESS;
    2388             : }
    2389             : 
    2390           0 : static enum ndr_err_code ndr_pull_frstrans_RawGetFileDataAsync(struct ndr_pull *ndr, int flags, struct frstrans_RawGetFileDataAsync *r)
    2391             : {
    2392           0 :         TALLOC_CTX *_mem_save_server_context_0 = NULL;
    2393           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2394           0 :         if (flags & NDR_IN) {
    2395           0 :                 NDR_ZERO_STRUCT(r->out);
    2396             : 
    2397           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2398           0 :                         NDR_PULL_ALLOC(ndr, r->in.server_context);
    2399             :                 }
    2400           0 :                 _mem_save_server_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2401           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.server_context, LIBNDR_FLAG_REF_ALLOC);
    2402           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.server_context));
    2403           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_context_0, LIBNDR_FLAG_REF_ALLOC);
    2404             :         }
    2405           0 :         if (flags & NDR_OUT) {
    2406             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2407             :                 if (r->in.server_context == NULL) {
    2408             :                         NDR_PULL_ALLOC(ndr, r->in.server_context);
    2409             :                         NDR_ZERO_STRUCTP(r->in.server_context);
    2410             :                 }
    2411             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2412           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2413             :         }
    2414           0 :         return NDR_ERR_SUCCESS;
    2415             : }
    2416             : 
    2417           0 : _PUBLIC_ void ndr_print_frstrans_RawGetFileDataAsync(struct ndr_print *ndr, const char *name, int flags, const struct frstrans_RawGetFileDataAsync *r)
    2418             : {
    2419           0 :         ndr_print_struct(ndr, name, "frstrans_RawGetFileDataAsync");
    2420           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2421           0 :         ndr->depth++;
    2422           0 :         if (flags & NDR_SET_VALUES) {
    2423           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2424             :         }
    2425           0 :         if (flags & NDR_IN) {
    2426           0 :                 ndr_print_struct(ndr, "in", "frstrans_RawGetFileDataAsync");
    2427           0 :                 ndr->depth++;
    2428           0 :                 ndr_print_ptr(ndr, "server_context", r->in.server_context);
    2429           0 :                 ndr->depth++;
    2430           0 :                 ndr_print_policy_handle(ndr, "server_context", r->in.server_context);
    2431           0 :                 ndr->depth--;
    2432           0 :                 ndr->depth--;
    2433             :         }
    2434           0 :         if (flags & NDR_OUT) {
    2435           0 :                 ndr_print_struct(ndr, "out", "frstrans_RawGetFileDataAsync");
    2436           0 :                 ndr->depth++;
    2437           0 :                 ndr_print_ptr(ndr, "byte_pipe", r->out.byte_pipe);
    2438           0 :                 ndr->depth++;
    2439           0 :                 ndr->depth--;
    2440           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2441           0 :                 ndr->depth--;
    2442             :         }
    2443           0 :         ndr->depth--;
    2444             : }
    2445             : 
    2446           0 : static enum ndr_err_code ndr_push_frstrans_RdcGetFileDataAsync(struct ndr_push *ndr, int flags, const struct frstrans_RdcGetFileDataAsync *r)
    2447             : {
    2448           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2449           0 :         if (flags & NDR_IN) {
    2450           0 :                 if (r->in.server_context == NULL) {
    2451           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2452             :                 }
    2453           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.server_context));
    2454             :         }
    2455           0 :         if (flags & NDR_OUT) {
    2456           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2457             :         }
    2458           0 :         return NDR_ERR_SUCCESS;
    2459             : }
    2460             : 
    2461           0 : static enum ndr_err_code ndr_pull_frstrans_RdcGetFileDataAsync(struct ndr_pull *ndr, int flags, struct frstrans_RdcGetFileDataAsync *r)
    2462             : {
    2463           0 :         TALLOC_CTX *_mem_save_server_context_0 = NULL;
    2464           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2465           0 :         if (flags & NDR_IN) {
    2466           0 :                 NDR_ZERO_STRUCT(r->out);
    2467             : 
    2468           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2469           0 :                         NDR_PULL_ALLOC(ndr, r->in.server_context);
    2470             :                 }
    2471           0 :                 _mem_save_server_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2472           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.server_context, LIBNDR_FLAG_REF_ALLOC);
    2473           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.server_context));
    2474           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_context_0, LIBNDR_FLAG_REF_ALLOC);
    2475             :         }
    2476           0 :         if (flags & NDR_OUT) {
    2477             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2478             :                 if (r->in.server_context == NULL) {
    2479             :                         NDR_PULL_ALLOC(ndr, r->in.server_context);
    2480             :                         NDR_ZERO_STRUCTP(r->in.server_context);
    2481             :                 }
    2482             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2483           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2484             :         }
    2485           0 :         return NDR_ERR_SUCCESS;
    2486             : }
    2487             : 
    2488           0 : _PUBLIC_ void ndr_print_frstrans_RdcGetFileDataAsync(struct ndr_print *ndr, const char *name, int flags, const struct frstrans_RdcGetFileDataAsync *r)
    2489             : {
    2490           0 :         ndr_print_struct(ndr, name, "frstrans_RdcGetFileDataAsync");
    2491           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2492           0 :         ndr->depth++;
    2493           0 :         if (flags & NDR_SET_VALUES) {
    2494           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2495             :         }
    2496           0 :         if (flags & NDR_IN) {
    2497           0 :                 ndr_print_struct(ndr, "in", "frstrans_RdcGetFileDataAsync");
    2498           0 :                 ndr->depth++;
    2499           0 :                 ndr_print_ptr(ndr, "server_context", r->in.server_context);
    2500           0 :                 ndr->depth++;
    2501           0 :                 ndr_print_policy_handle(ndr, "server_context", r->in.server_context);
    2502           0 :                 ndr->depth--;
    2503           0 :                 ndr->depth--;
    2504             :         }
    2505           0 :         if (flags & NDR_OUT) {
    2506           0 :                 ndr_print_struct(ndr, "out", "frstrans_RdcGetFileDataAsync");
    2507           0 :                 ndr->depth++;
    2508           0 :                 ndr_print_ptr(ndr, "byte_pipe", r->out.byte_pipe);
    2509           0 :                 ndr->depth++;
    2510           0 :                 ndr->depth--;
    2511           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2512           0 :                 ndr->depth--;
    2513             :         }
    2514           0 :         ndr->depth--;
    2515             : }
    2516             : 
    2517             : #ifndef SKIP_NDR_TABLE_frstrans
    2518             : static const struct ndr_interface_call_pipe frstrans_RawGetFileDataAsync_out_pipes[] = {
    2519             :         {
    2520             :                 "out.byte_pipe",
    2521             :                 "frstrans_BytePipe_chunk",
    2522             :                 sizeof(struct frstrans_BytePipe_chunk),
    2523             :                 (ndr_push_flags_fn_t) ndr_push_frstrans_BytePipe_chunk,
    2524             :                 (ndr_pull_flags_fn_t) ndr_pull_frstrans_BytePipe_chunk,
    2525             :                 (ndr_print_fn_t) ndr_print_frstrans_BytePipe_chunk,
    2526             :         },
    2527             :         { .name = NULL }
    2528             : };
    2529             : 
    2530             : static const struct ndr_interface_call_pipe frstrans_RdcGetFileDataAsync_out_pipes[] = {
    2531             :         {
    2532             :                 "out.byte_pipe",
    2533             :                 "frstrans_BytePipe_chunk",
    2534             :                 sizeof(struct frstrans_BytePipe_chunk),
    2535             :                 (ndr_push_flags_fn_t) ndr_push_frstrans_BytePipe_chunk,
    2536             :                 (ndr_pull_flags_fn_t) ndr_pull_frstrans_BytePipe_chunk,
    2537             :                 (ndr_print_fn_t) ndr_print_frstrans_BytePipe_chunk,
    2538             :         },
    2539             :         { .name = NULL }
    2540             : };
    2541             : 
    2542             : static const struct ndr_interface_public_struct frstrans_public_structs[] = {
    2543             :         {
    2544             :                 .name = "frstrans_VersionVector",
    2545             :                 .struct_size = sizeof(struct frstrans_VersionVector ),
    2546             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_frstrans_VersionVector,
    2547             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_frstrans_VersionVector,
    2548             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_frstrans_VersionVector,
    2549             :         },
    2550             :         { .name = NULL }
    2551             : };
    2552             : 
    2553             : static const struct ndr_interface_call frstrans_calls[] = {
    2554             :         {
    2555             :                 "frstrans_CheckConnectivity",
    2556             :                 sizeof(struct frstrans_CheckConnectivity),
    2557             :                 (ndr_push_flags_fn_t) ndr_push_frstrans_CheckConnectivity,
    2558             :                 (ndr_pull_flags_fn_t) ndr_pull_frstrans_CheckConnectivity,
    2559             :                 (ndr_print_function_t) ndr_print_frstrans_CheckConnectivity,
    2560             :                 { 0, NULL },
    2561             :                 { 0, NULL },
    2562             :         },
    2563             :         {
    2564             :                 "frstrans_EstablishConnection",
    2565             :                 sizeof(struct frstrans_EstablishConnection),
    2566             :                 (ndr_push_flags_fn_t) ndr_push_frstrans_EstablishConnection,
    2567             :                 (ndr_pull_flags_fn_t) ndr_pull_frstrans_EstablishConnection,
    2568             :                 (ndr_print_function_t) ndr_print_frstrans_EstablishConnection,
    2569             :                 { 0, NULL },
    2570             :                 { 0, NULL },
    2571             :         },
    2572             :         {
    2573             :                 "frstrans_EstablishSession",
    2574             :                 sizeof(struct frstrans_EstablishSession),
    2575             :                 (ndr_push_flags_fn_t) ndr_push_frstrans_EstablishSession,
    2576             :                 (ndr_pull_flags_fn_t) ndr_pull_frstrans_EstablishSession,
    2577             :                 (ndr_print_function_t) ndr_print_frstrans_EstablishSession,
    2578             :                 { 0, NULL },
    2579             :                 { 0, NULL },
    2580             :         },
    2581             :         {
    2582             :                 "frstrans_RequestUpdates",
    2583             :                 sizeof(struct frstrans_RequestUpdates),
    2584             :                 (ndr_push_flags_fn_t) ndr_push_frstrans_RequestUpdates,
    2585             :                 (ndr_pull_flags_fn_t) ndr_pull_frstrans_RequestUpdates,
    2586             :                 (ndr_print_function_t) ndr_print_frstrans_RequestUpdates,
    2587             :                 { 0, NULL },
    2588             :                 { 0, NULL },
    2589             :         },
    2590             :         {
    2591             :                 "frstrans_RequestVersionVector",
    2592             :                 sizeof(struct frstrans_RequestVersionVector),
    2593             :                 (ndr_push_flags_fn_t) ndr_push_frstrans_RequestVersionVector,
    2594             :                 (ndr_pull_flags_fn_t) ndr_pull_frstrans_RequestVersionVector,
    2595             :                 (ndr_print_function_t) ndr_print_frstrans_RequestVersionVector,
    2596             :                 { 0, NULL },
    2597             :                 { 0, NULL },
    2598             :         },
    2599             :         {
    2600             :                 "frstrans_AsyncPoll",
    2601             :                 sizeof(struct frstrans_AsyncPoll),
    2602             :                 (ndr_push_flags_fn_t) ndr_push_frstrans_AsyncPoll,
    2603             :                 (ndr_pull_flags_fn_t) ndr_pull_frstrans_AsyncPoll,
    2604             :                 (ndr_print_function_t) ndr_print_frstrans_AsyncPoll,
    2605             :                 { 0, NULL },
    2606             :                 { 0, NULL },
    2607             :         },
    2608             :         {
    2609             :                 "FRSTRANS_REQUEST_RECORDS",
    2610             :                 sizeof(struct FRSTRANS_REQUEST_RECORDS),
    2611             :                 (ndr_push_flags_fn_t) ndr_push_FRSTRANS_REQUEST_RECORDS,
    2612             :                 (ndr_pull_flags_fn_t) ndr_pull_FRSTRANS_REQUEST_RECORDS,
    2613             :                 (ndr_print_function_t) ndr_print_FRSTRANS_REQUEST_RECORDS,
    2614             :                 { 0, NULL },
    2615             :                 { 0, NULL },
    2616             :         },
    2617             :         {
    2618             :                 "FRSTRANS_UPDATE_CANCEL",
    2619             :                 sizeof(struct FRSTRANS_UPDATE_CANCEL),
    2620             :                 (ndr_push_flags_fn_t) ndr_push_FRSTRANS_UPDATE_CANCEL,
    2621             :                 (ndr_pull_flags_fn_t) ndr_pull_FRSTRANS_UPDATE_CANCEL,
    2622             :                 (ndr_print_function_t) ndr_print_FRSTRANS_UPDATE_CANCEL,
    2623             :                 { 0, NULL },
    2624             :                 { 0, NULL },
    2625             :         },
    2626             :         {
    2627             :                 "FRSTRANS_RAW_GET_FILE_DATA",
    2628             :                 sizeof(struct FRSTRANS_RAW_GET_FILE_DATA),
    2629             :                 (ndr_push_flags_fn_t) ndr_push_FRSTRANS_RAW_GET_FILE_DATA,
    2630             :                 (ndr_pull_flags_fn_t) ndr_pull_FRSTRANS_RAW_GET_FILE_DATA,
    2631             :                 (ndr_print_function_t) ndr_print_FRSTRANS_RAW_GET_FILE_DATA,
    2632             :                 { 0, NULL },
    2633             :                 { 0, NULL },
    2634             :         },
    2635             :         {
    2636             :                 "FRSTRANS_RDC_GET_SIGNATURES",
    2637             :                 sizeof(struct FRSTRANS_RDC_GET_SIGNATURES),
    2638             :                 (ndr_push_flags_fn_t) ndr_push_FRSTRANS_RDC_GET_SIGNATURES,
    2639             :                 (ndr_pull_flags_fn_t) ndr_pull_FRSTRANS_RDC_GET_SIGNATURES,
    2640             :                 (ndr_print_function_t) ndr_print_FRSTRANS_RDC_GET_SIGNATURES,
    2641             :                 { 0, NULL },
    2642             :                 { 0, NULL },
    2643             :         },
    2644             :         {
    2645             :                 "FRSTRANS_RDC_PUSH_SOURCE_NEEDS",
    2646             :                 sizeof(struct FRSTRANS_RDC_PUSH_SOURCE_NEEDS),
    2647             :                 (ndr_push_flags_fn_t) ndr_push_FRSTRANS_RDC_PUSH_SOURCE_NEEDS,
    2648             :                 (ndr_pull_flags_fn_t) ndr_pull_FRSTRANS_RDC_PUSH_SOURCE_NEEDS,
    2649             :                 (ndr_print_function_t) ndr_print_FRSTRANS_RDC_PUSH_SOURCE_NEEDS,
    2650             :                 { 0, NULL },
    2651             :                 { 0, NULL },
    2652             :         },
    2653             :         {
    2654             :                 "FRSTRANS_RDC_GET_FILE_DATA",
    2655             :                 sizeof(struct FRSTRANS_RDC_GET_FILE_DATA),
    2656             :                 (ndr_push_flags_fn_t) ndr_push_FRSTRANS_RDC_GET_FILE_DATA,
    2657             :                 (ndr_pull_flags_fn_t) ndr_pull_FRSTRANS_RDC_GET_FILE_DATA,
    2658             :                 (ndr_print_function_t) ndr_print_FRSTRANS_RDC_GET_FILE_DATA,
    2659             :                 { 0, NULL },
    2660             :                 { 0, NULL },
    2661             :         },
    2662             :         {
    2663             :                 "frstrans_RdcClose",
    2664             :                 sizeof(struct frstrans_RdcClose),
    2665             :                 (ndr_push_flags_fn_t) ndr_push_frstrans_RdcClose,
    2666             :                 (ndr_pull_flags_fn_t) ndr_pull_frstrans_RdcClose,
    2667             :                 (ndr_print_function_t) ndr_print_frstrans_RdcClose,
    2668             :                 { 0, NULL },
    2669             :                 { 0, NULL },
    2670             :         },
    2671             :         {
    2672             :                 "frstrans_InitializeFileTransferAsync",
    2673             :                 sizeof(struct frstrans_InitializeFileTransferAsync),
    2674             :                 (ndr_push_flags_fn_t) ndr_push_frstrans_InitializeFileTransferAsync,
    2675             :                 (ndr_pull_flags_fn_t) ndr_pull_frstrans_InitializeFileTransferAsync,
    2676             :                 (ndr_print_function_t) ndr_print_frstrans_InitializeFileTransferAsync,
    2677             :                 { 0, NULL },
    2678             :                 { 0, NULL },
    2679             :         },
    2680             :         {
    2681             :                 "FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE",
    2682             :                 sizeof(struct FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE),
    2683             :                 (ndr_push_flags_fn_t) ndr_push_FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE,
    2684             :                 (ndr_pull_flags_fn_t) ndr_pull_FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE,
    2685             :                 (ndr_print_function_t) ndr_print_FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE,
    2686             :                 { 0, NULL },
    2687             :                 { 0, NULL },
    2688             :         },
    2689             :         {
    2690             :                 "frstrans_RawGetFileDataAsync",
    2691             :                 sizeof(struct frstrans_RawGetFileDataAsync),
    2692             :                 (ndr_push_flags_fn_t) ndr_push_frstrans_RawGetFileDataAsync,
    2693             :                 (ndr_pull_flags_fn_t) ndr_pull_frstrans_RawGetFileDataAsync,
    2694             :                 (ndr_print_function_t) ndr_print_frstrans_RawGetFileDataAsync,
    2695             :                 { 0, NULL },
    2696             :                 { 1, frstrans_RawGetFileDataAsync_out_pipes },
    2697             :         },
    2698             :         {
    2699             :                 "frstrans_RdcGetFileDataAsync",
    2700             :                 sizeof(struct frstrans_RdcGetFileDataAsync),
    2701             :                 (ndr_push_flags_fn_t) ndr_push_frstrans_RdcGetFileDataAsync,
    2702             :                 (ndr_pull_flags_fn_t) ndr_pull_frstrans_RdcGetFileDataAsync,
    2703             :                 (ndr_print_function_t) ndr_print_frstrans_RdcGetFileDataAsync,
    2704             :                 { 0, NULL },
    2705             :                 { 1, frstrans_RdcGetFileDataAsync_out_pipes },
    2706             :         },
    2707             :         { .name = NULL }
    2708             : };
    2709             : 
    2710             : static const char * const frstrans_endpoint_strings[] = {
    2711             :         "ncacn_ip_tcp:", 
    2712             :         "ncalrpc:", 
    2713             : };
    2714             : 
    2715             : static const struct ndr_interface_string_array frstrans_endpoints = {
    2716             :         .count  = 2,
    2717             :         .names  = frstrans_endpoint_strings
    2718             : };
    2719             : 
    2720             : static const char * const frstrans_authservice_strings[] = {
    2721             :         "host", 
    2722             : };
    2723             : 
    2724             : static const struct ndr_interface_string_array frstrans_authservices = {
    2725             :         .count  = 1,
    2726             :         .names  = frstrans_authservice_strings
    2727             : };
    2728             : 
    2729             : 
    2730             : const struct ndr_interface_table ndr_table_frstrans = {
    2731             :         .name           = "frstrans",
    2732             :         .syntax_id      = {
    2733             :                 {0x897e2e5f,0x93f3,0x4376,{0x9c,0x9c},{0xfd,0x22,0x77,0x49,0x5c,0x27}},
    2734             :                 NDR_FRSTRANS_VERSION
    2735             :         },
    2736             :         .helpstring     = NDR_FRSTRANS_HELPSTRING,
    2737             :         .num_calls      = 17,
    2738             :         .calls          = frstrans_calls,
    2739             :         .num_public_structs     = 1,
    2740             :         .public_structs         = frstrans_public_structs,
    2741             :         .endpoints      = &frstrans_endpoints,
    2742             :         .authservices   = &frstrans_authservices
    2743             : };
    2744             : 
    2745             : #endif /* SKIP_NDR_TABLE_frstrans */

Generated by: LCOV version 1.13