LCOV - code coverage report
Current view: top level - bin/default/librpc/gen_ndr - ndr_ioctl.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 448 1031 43.5 %
Date: 2021-09-23 10:06:22 Functions: 37 109 33.9 %

          Line data    Source code
       1             : /* parser auto-generated by pidl */
       2             : 
       3             : #include "includes.h"
       4             : #include "bin/default/librpc/gen_ndr/ndr_ioctl.h"
       5             : 
       6         220 : _PUBLIC_ enum ndr_err_code ndr_push_req_resume_key_rsp(struct ndr_push *ndr, int ndr_flags, const struct req_resume_key_rsp *r)
       7             : {
       8         220 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
       9         220 :         if (ndr_flags & NDR_SCALARS) {
      10         220 :                 NDR_CHECK(ndr_push_align(ndr, 4));
      11         220 :                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->resume_key, 24));
      12         220 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->context_len));
      13         220 :                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->context, 4));
      14         220 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
      15             :         }
      16         220 :         if (ndr_flags & NDR_BUFFERS) {
      17             :         }
      18         220 :         return NDR_ERR_SUCCESS;
      19             : }
      20             : 
      21         220 : _PUBLIC_ enum ndr_err_code ndr_pull_req_resume_key_rsp(struct ndr_pull *ndr, int ndr_flags, struct req_resume_key_rsp *r)
      22             : {
      23         220 :         uint32_t size_resume_key_0 = 0;
      24         220 :         uint32_t size_context_0 = 0;
      25         220 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
      26         220 :         if (ndr_flags & NDR_SCALARS) {
      27         220 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
      28         220 :                 size_resume_key_0 = 24;
      29         220 :                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->resume_key, size_resume_key_0));
      30         220 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->context_len));
      31         220 :                 size_context_0 = 4;
      32         220 :                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->context, size_context_0));
      33         220 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
      34             :         }
      35         220 :         if (ndr_flags & NDR_BUFFERS) {
      36             :         }
      37         220 :         return NDR_ERR_SUCCESS;
      38             : }
      39             : 
      40           0 : static void ndr_print_flags_req_resume_key_rsp(struct ndr_print *ndr, const char *name, int unused, const struct req_resume_key_rsp *r)
      41             : {
      42           0 :         ndr_print_req_resume_key_rsp(ndr, name, r);
      43           0 : }
      44             : 
      45          18 : _PUBLIC_ void ndr_print_req_resume_key_rsp(struct ndr_print *ndr, const char *name, const struct req_resume_key_rsp *r)
      46             : {
      47          18 :         ndr_print_struct(ndr, name, "req_resume_key_rsp");
      48          18 :         if (r == NULL) { ndr_print_null(ndr); return; }
      49          18 :         ndr->depth++;
      50          18 :         ndr_print_array_uint8(ndr, "resume_key", r->resume_key, 24);
      51          18 :         ndr_print_uint32(ndr, "context_len", r->context_len);
      52          18 :         ndr_print_array_uint8(ndr, "context", r->context, 4);
      53          18 :         ndr->depth--;
      54             : }
      55             : 
      56         228 : static enum ndr_err_code ndr_push_srv_copychunk(struct ndr_push *ndr, int ndr_flags, const struct srv_copychunk *r)
      57             : {
      58         228 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
      59         228 :         if (ndr_flags & NDR_SCALARS) {
      60         228 :                 NDR_CHECK(ndr_push_align(ndr, 8));
      61         228 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->source_off));
      62         228 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->target_off));
      63         228 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
      64         228 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
      65         228 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
      66             :         }
      67         228 :         if (ndr_flags & NDR_BUFFERS) {
      68             :         }
      69         228 :         return NDR_ERR_SUCCESS;
      70             : }
      71             : 
      72         240 : static enum ndr_err_code ndr_pull_srv_copychunk(struct ndr_pull *ndr, int ndr_flags, struct srv_copychunk *r)
      73             : {
      74         240 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
      75         240 :         if (ndr_flags & NDR_SCALARS) {
      76         240 :                 NDR_CHECK(ndr_pull_align(ndr, 8));
      77         240 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->source_off));
      78         240 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->target_off));
      79         240 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
      80         240 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
      81         240 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
      82             :         }
      83         240 :         if (ndr_flags & NDR_BUFFERS) {
      84             :         }
      85         240 :         return NDR_ERR_SUCCESS;
      86             : }
      87             : 
      88           0 : _PUBLIC_ void ndr_print_srv_copychunk(struct ndr_print *ndr, const char *name, const struct srv_copychunk *r)
      89             : {
      90           0 :         ndr_print_struct(ndr, name, "srv_copychunk");
      91           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
      92           0 :         ndr->depth++;
      93           0 :         ndr_print_hyper(ndr, "source_off", r->source_off);
      94           0 :         ndr_print_hyper(ndr, "target_off", r->target_off);
      95           0 :         ndr_print_uint32(ndr, "length", r->length);
      96           0 :         ndr_print_uint32(ndr, "reserved", r->reserved);
      97           0 :         ndr->depth--;
      98             : }
      99             : 
     100         208 : _PUBLIC_ enum ndr_err_code ndr_push_srv_copychunk_copy(struct ndr_push *ndr, int ndr_flags, const struct srv_copychunk_copy *r)
     101             : {
     102             :         uint32_t cntr_chunks_0;
     103         208 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     104         208 :         if (ndr_flags & NDR_SCALARS) {
     105         208 :                 NDR_CHECK(ndr_push_align(ndr, 8));
     106         208 :                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->source_key, 24));
     107         208 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chunk_count));
     108         208 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
     109         436 :                 for (cntr_chunks_0 = 0; cntr_chunks_0 < (r->chunk_count); cntr_chunks_0++) {
     110         228 :                         NDR_CHECK(ndr_push_srv_copychunk(ndr, NDR_SCALARS, &r->chunks[cntr_chunks_0]));
     111             :                 }
     112         208 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
     113             :         }
     114         208 :         if (ndr_flags & NDR_BUFFERS) {
     115             :         }
     116         208 :         return NDR_ERR_SUCCESS;
     117             : }
     118             : 
     119         220 : _PUBLIC_ enum ndr_err_code ndr_pull_srv_copychunk_copy(struct ndr_pull *ndr, int ndr_flags, struct srv_copychunk_copy *r)
     120             : {
     121         220 :         uint32_t size_source_key_0 = 0;
     122         220 :         uint32_t size_chunks_0 = 0;
     123             :         uint32_t cntr_chunks_0;
     124         220 :         TALLOC_CTX *_mem_save_chunks_0 = NULL;
     125         220 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     126         220 :         if (ndr_flags & NDR_SCALARS) {
     127         220 :                 NDR_CHECK(ndr_pull_align(ndr, 8));
     128         220 :                 size_source_key_0 = 24;
     129         220 :                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->source_key, size_source_key_0));
     130         220 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chunk_count));
     131         220 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
     132         220 :                 size_chunks_0 = r->chunk_count;
     133         220 :                 NDR_PULL_ALLOC_N(ndr, r->chunks, size_chunks_0);
     134         220 :                 _mem_save_chunks_0 = NDR_PULL_GET_MEM_CTX(ndr);
     135         220 :                 NDR_PULL_SET_MEM_CTX(ndr, r->chunks, 0);
     136         460 :                 for (cntr_chunks_0 = 0; cntr_chunks_0 < (size_chunks_0); cntr_chunks_0++) {
     137         240 :                         NDR_CHECK(ndr_pull_srv_copychunk(ndr, NDR_SCALARS, &r->chunks[cntr_chunks_0]));
     138             :                 }
     139         220 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_chunks_0, 0);
     140         220 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
     141             :         }
     142         220 :         if (ndr_flags & NDR_BUFFERS) {
     143             :         }
     144         220 :         return NDR_ERR_SUCCESS;
     145             : }
     146             : 
     147           0 : static void ndr_print_flags_srv_copychunk_copy(struct ndr_print *ndr, const char *name, int unused, const struct srv_copychunk_copy *r)
     148             : {
     149           0 :         ndr_print_srv_copychunk_copy(ndr, name, r);
     150           0 : }
     151             : 
     152           0 : _PUBLIC_ void ndr_print_srv_copychunk_copy(struct ndr_print *ndr, const char *name, const struct srv_copychunk_copy *r)
     153             : {
     154             :         uint32_t cntr_chunks_0;
     155           0 :         ndr_print_struct(ndr, name, "srv_copychunk_copy");
     156           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     157           0 :         ndr->depth++;
     158           0 :         ndr_print_array_uint8(ndr, "source_key", r->source_key, 24);
     159           0 :         ndr_print_uint32(ndr, "chunk_count", r->chunk_count);
     160           0 :         ndr_print_uint32(ndr, "reserved", r->reserved);
     161           0 :         ndr->print(ndr, "%s: ARRAY(%d)", "chunks", (int)r->chunk_count);
     162           0 :         ndr->depth++;
     163           0 :         for (cntr_chunks_0 = 0; cntr_chunks_0 < (r->chunk_count); cntr_chunks_0++) {
     164           0 :                 ndr_print_srv_copychunk(ndr, "chunks", &r->chunks[cntr_chunks_0]);
     165             :         }
     166           0 :         ndr->depth--;
     167           0 :         ndr->depth--;
     168             : }
     169             : 
     170         220 : _PUBLIC_ enum ndr_err_code ndr_push_srv_copychunk_rsp(struct ndr_push *ndr, int ndr_flags, const struct srv_copychunk_rsp *r)
     171             : {
     172         220 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     173         220 :         if (ndr_flags & NDR_SCALARS) {
     174         220 :                 NDR_CHECK(ndr_push_align(ndr, 4));
     175         220 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chunks_written));
     176         220 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chunk_bytes_written));
     177         220 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes_written));
     178         220 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
     179             :         }
     180         220 :         if (ndr_flags & NDR_BUFFERS) {
     181             :         }
     182         220 :         return NDR_ERR_SUCCESS;
     183             : }
     184             : 
     185         160 : _PUBLIC_ enum ndr_err_code ndr_pull_srv_copychunk_rsp(struct ndr_pull *ndr, int ndr_flags, struct srv_copychunk_rsp *r)
     186             : {
     187         160 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     188         160 :         if (ndr_flags & NDR_SCALARS) {
     189         160 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
     190         160 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chunks_written));
     191         160 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chunk_bytes_written));
     192         160 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes_written));
     193         160 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
     194             :         }
     195         160 :         if (ndr_flags & NDR_BUFFERS) {
     196             :         }
     197         160 :         return NDR_ERR_SUCCESS;
     198             : }
     199             : 
     200           0 : static void ndr_print_flags_srv_copychunk_rsp(struct ndr_print *ndr, const char *name, int unused, const struct srv_copychunk_rsp *r)
     201             : {
     202           0 :         ndr_print_srv_copychunk_rsp(ndr, name, r);
     203           0 : }
     204             : 
     205           0 : _PUBLIC_ void ndr_print_srv_copychunk_rsp(struct ndr_print *ndr, const char *name, const struct srv_copychunk_rsp *r)
     206             : {
     207           0 :         ndr_print_struct(ndr, name, "srv_copychunk_rsp");
     208           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     209           0 :         ndr->depth++;
     210           0 :         ndr_print_uint32(ndr, "chunks_written", r->chunks_written);
     211           0 :         ndr_print_uint32(ndr, "chunk_bytes_written", r->chunk_bytes_written);
     212           0 :         ndr_print_uint32(ndr, "total_bytes_written", r->total_bytes_written);
     213           0 :         ndr->depth--;
     214             : }
     215             : 
     216           0 : _PUBLIC_ enum ndr_err_code ndr_push_device_copy_offload_descriptor(struct ndr_push *ndr, int ndr_flags, const struct device_copy_offload_descriptor *r)
     217             : {
     218           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     219           0 :         if (ndr_flags & NDR_SCALARS) {
     220           0 :                 NDR_CHECK(ndr_push_align(ndr, 8));
     221           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
     222           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
     223           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maximum_token_lifetime));
     224           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->default_token_lifetime));
     225           0 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->maximum_xfer_size));
     226           0 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->optimal_xfer_count));
     227           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maximum_data_descriptors));
     228           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maximum_xfer_length_per_descriptor));
     229           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->optimal_xfer_length_per_descriptor));
     230           0 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->optimal_xfer_length_granularity));
     231           0 :                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->reserved, 2));
     232           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
     233             :         }
     234           0 :         if (ndr_flags & NDR_BUFFERS) {
     235             :         }
     236           0 :         return NDR_ERR_SUCCESS;
     237             : }
     238             : 
     239           0 : _PUBLIC_ enum ndr_err_code ndr_pull_device_copy_offload_descriptor(struct ndr_pull *ndr, int ndr_flags, struct device_copy_offload_descriptor *r)
     240             : {
     241           0 :         uint32_t size_reserved_0 = 0;
     242           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     243           0 :         if (ndr_flags & NDR_SCALARS) {
     244           0 :                 NDR_CHECK(ndr_pull_align(ndr, 8));
     245           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
     246           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
     247           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maximum_token_lifetime));
     248           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->default_token_lifetime));
     249           0 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->maximum_xfer_size));
     250           0 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->optimal_xfer_count));
     251           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maximum_data_descriptors));
     252           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maximum_xfer_length_per_descriptor));
     253           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->optimal_xfer_length_per_descriptor));
     254           0 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->optimal_xfer_length_granularity));
     255           0 :                 size_reserved_0 = 2;
     256           0 :                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->reserved, size_reserved_0));
     257           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
     258             :         }
     259           0 :         if (ndr_flags & NDR_BUFFERS) {
     260             :         }
     261           0 :         return NDR_ERR_SUCCESS;
     262             : }
     263             : 
     264           0 : static void ndr_print_flags_device_copy_offload_descriptor(struct ndr_print *ndr, const char *name, int unused, const struct device_copy_offload_descriptor *r)
     265             : {
     266           0 :         ndr_print_device_copy_offload_descriptor(ndr, name, r);
     267           0 : }
     268             : 
     269           0 : _PUBLIC_ void ndr_print_device_copy_offload_descriptor(struct ndr_print *ndr, const char *name, const struct device_copy_offload_descriptor *r)
     270             : {
     271           0 :         ndr_print_struct(ndr, name, "device_copy_offload_descriptor");
     272           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     273           0 :         ndr->depth++;
     274           0 :         ndr_print_uint32(ndr, "version", r->version);
     275           0 :         ndr_print_uint32(ndr, "size", r->size);
     276           0 :         ndr_print_uint32(ndr, "maximum_token_lifetime", r->maximum_token_lifetime);
     277           0 :         ndr_print_uint32(ndr, "default_token_lifetime", r->default_token_lifetime);
     278           0 :         ndr_print_hyper(ndr, "maximum_xfer_size", r->maximum_xfer_size);
     279           0 :         ndr_print_hyper(ndr, "optimal_xfer_count", r->optimal_xfer_count);
     280           0 :         ndr_print_uint32(ndr, "maximum_data_descriptors", r->maximum_data_descriptors);
     281           0 :         ndr_print_uint32(ndr, "maximum_xfer_length_per_descriptor", r->maximum_xfer_length_per_descriptor);
     282           0 :         ndr_print_uint32(ndr, "optimal_xfer_length_per_descriptor", r->optimal_xfer_length_per_descriptor);
     283           0 :         ndr_print_uint16(ndr, "optimal_xfer_length_granularity", r->optimal_xfer_length_granularity);
     284           0 :         ndr_print_array_uint8(ndr, "reserved", r->reserved, 2);
     285           0 :         ndr->depth--;
     286             : }
     287             : 
     288           0 : _PUBLIC_ enum ndr_err_code ndr_push_storage_offload_token(struct ndr_push *ndr, int ndr_flags, const struct storage_offload_token *r)
     289             : {
     290           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     291           0 :         if (ndr_flags & NDR_SCALARS) {
     292           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->token_id_len));
     293           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
     294           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->token_type));
     295           0 :                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->reserved, 2));
     296           0 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->token_id_len));
     297           0 :                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->token, r->token_id_len));
     298           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
     299             :         }
     300           0 :         if (ndr_flags & NDR_BUFFERS) {
     301             :         }
     302           0 :         return NDR_ERR_SUCCESS;
     303             : }
     304             : 
     305           0 : _PUBLIC_ enum ndr_err_code ndr_pull_storage_offload_token(struct ndr_pull *ndr, int ndr_flags, struct storage_offload_token *r)
     306             : {
     307           0 :         uint32_t size_reserved_0 = 0;
     308           0 :         uint32_t size_token_0 = 0;
     309           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     310           0 :         if (ndr_flags & NDR_SCALARS) {
     311           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->token));
     312           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
     313           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->token_type));
     314           0 :                 size_reserved_0 = 2;
     315           0 :                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->reserved, size_reserved_0));
     316           0 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->token_id_len));
     317           0 :                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->token, &size_token_0));
     318           0 :                 NDR_PULL_ALLOC_N(ndr, r->token, size_token_0);
     319           0 :                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->token, size_token_0));
     320           0 :                 if (r->token) {
     321           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->token, r->token_id_len));
     322             :                 }
     323           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
     324             :         }
     325           0 :         if (ndr_flags & NDR_BUFFERS) {
     326             :         }
     327           0 :         return NDR_ERR_SUCCESS;
     328             : }
     329             : 
     330           0 : static void ndr_print_flags_storage_offload_token(struct ndr_print *ndr, const char *name, int unused, const struct storage_offload_token *r)
     331             : {
     332           0 :         ndr_print_storage_offload_token(ndr, name, r);
     333           0 : }
     334             : 
     335           0 : _PUBLIC_ void ndr_print_storage_offload_token(struct ndr_print *ndr, const char *name, const struct storage_offload_token *r)
     336             : {
     337           0 :         ndr_print_struct(ndr, name, "storage_offload_token");
     338           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     339           0 :         ndr->depth++;
     340           0 :         ndr_print_uint32(ndr, "token_type", r->token_type);
     341           0 :         ndr_print_array_uint8(ndr, "reserved", r->reserved, 2);
     342           0 :         ndr_print_uint16(ndr, "token_id_len", r->token_id_len);
     343           0 :         ndr_print_array_uint8(ndr, "token", r->token, r->token_id_len);
     344           0 :         ndr->depth--;
     345             : }
     346             : 
     347           0 : _PUBLIC_ enum ndr_err_code ndr_push_fsctl_offload_read_input(struct ndr_push *ndr, int ndr_flags, const struct fsctl_offload_read_input *r)
     348             : {
     349           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     350           0 :         if (ndr_flags & NDR_SCALARS) {
     351           0 :                 NDR_CHECK(ndr_push_align(ndr, 8));
     352           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
     353           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
     354           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->token_time_to_live));
     355           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
     356           0 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->file_offset));
     357           0 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->length));
     358           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
     359             :         }
     360           0 :         if (ndr_flags & NDR_BUFFERS) {
     361             :         }
     362           0 :         return NDR_ERR_SUCCESS;
     363             : }
     364             : 
     365           0 : _PUBLIC_ enum ndr_err_code ndr_pull_fsctl_offload_read_input(struct ndr_pull *ndr, int ndr_flags, struct fsctl_offload_read_input *r)
     366             : {
     367           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     368           0 :         if (ndr_flags & NDR_SCALARS) {
     369           0 :                 NDR_CHECK(ndr_pull_align(ndr, 8));
     370           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
     371           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
     372           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->token_time_to_live));
     373           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
     374           0 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->file_offset));
     375           0 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->length));
     376           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
     377             :         }
     378           0 :         if (ndr_flags & NDR_BUFFERS) {
     379             :         }
     380           0 :         return NDR_ERR_SUCCESS;
     381             : }
     382             : 
     383           0 : static void ndr_print_flags_fsctl_offload_read_input(struct ndr_print *ndr, const char *name, int unused, const struct fsctl_offload_read_input *r)
     384             : {
     385           0 :         ndr_print_fsctl_offload_read_input(ndr, name, r);
     386           0 : }
     387             : 
     388           0 : _PUBLIC_ void ndr_print_fsctl_offload_read_input(struct ndr_print *ndr, const char *name, const struct fsctl_offload_read_input *r)
     389             : {
     390           0 :         ndr_print_struct(ndr, name, "fsctl_offload_read_input");
     391           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     392           0 :         ndr->depth++;
     393           0 :         ndr_print_uint32(ndr, "size", r->size);
     394           0 :         ndr_print_uint32(ndr, "flags", r->flags);
     395           0 :         ndr_print_uint32(ndr, "token_time_to_live", r->token_time_to_live);
     396           0 :         ndr_print_uint32(ndr, "reserved", r->reserved);
     397           0 :         ndr_print_hyper(ndr, "file_offset", r->file_offset);
     398           0 :         ndr_print_hyper(ndr, "length", r->length);
     399           0 :         ndr->depth--;
     400             : }
     401             : 
     402           0 : _PUBLIC_ enum ndr_err_code ndr_push_offload_flags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
     403             : {
     404           0 :         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
     405           0 :         return NDR_ERR_SUCCESS;
     406             : }
     407             : 
     408           0 : _PUBLIC_ enum ndr_err_code ndr_pull_offload_flags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
     409             : {
     410             :         uint32_t v;
     411           0 :         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
     412           0 :         *r = v;
     413           0 :         return NDR_ERR_SUCCESS;
     414             : }
     415             : 
     416           0 : _PUBLIC_ void ndr_print_offload_flags(struct ndr_print *ndr, const char *name, uint32_t r)
     417             : {
     418           0 :         ndr_print_uint32(ndr, name, r);
     419           0 :         ndr->depth++;
     420           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "OFFLOAD_READ_FLAG_FILE_TOO_SMALL", OFFLOAD_READ_FLAG_FILE_TOO_SMALL, r);
     421           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "OFFLOAD_READ_FLAG_ALL_ZERO_BEYOND_RANGE", OFFLOAD_READ_FLAG_ALL_ZERO_BEYOND_RANGE, r);
     422           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "OFFLOAD_READ_FLAG_CANNOT_OFFLOAD_BEYOND_RANGE", OFFLOAD_READ_FLAG_CANNOT_OFFLOAD_BEYOND_RANGE, r);
     423           0 :         ndr->depth--;
     424           0 : }
     425             : 
     426           0 : _PUBLIC_ enum ndr_err_code ndr_push_fsctl_offload_read_output(struct ndr_push *ndr, int ndr_flags, const struct fsctl_offload_read_output *r)
     427             : {
     428           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     429           0 :         if (ndr_flags & NDR_SCALARS) {
     430           0 :                 NDR_CHECK(ndr_push_align(ndr, 8));
     431           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
     432           0 :                 NDR_CHECK(ndr_push_offload_flags(ndr, NDR_SCALARS, r->flags));
     433           0 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->xfer_length));
     434           0 :                 NDR_CHECK(ndr_push_storage_offload_token(ndr, NDR_SCALARS, &r->token));
     435           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
     436             :         }
     437           0 :         if (ndr_flags & NDR_BUFFERS) {
     438             :         }
     439           0 :         return NDR_ERR_SUCCESS;
     440             : }
     441             : 
     442           0 : _PUBLIC_ enum ndr_err_code ndr_pull_fsctl_offload_read_output(struct ndr_pull *ndr, int ndr_flags, struct fsctl_offload_read_output *r)
     443             : {
     444           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     445           0 :         if (ndr_flags & NDR_SCALARS) {
     446           0 :                 NDR_CHECK(ndr_pull_align(ndr, 8));
     447           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
     448           0 :                 NDR_CHECK(ndr_pull_offload_flags(ndr, NDR_SCALARS, &r->flags));
     449           0 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->xfer_length));
     450           0 :                 NDR_CHECK(ndr_pull_storage_offload_token(ndr, NDR_SCALARS, &r->token));
     451           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
     452             :         }
     453           0 :         if (ndr_flags & NDR_BUFFERS) {
     454             :         }
     455           0 :         return NDR_ERR_SUCCESS;
     456             : }
     457             : 
     458           0 : static void ndr_print_flags_fsctl_offload_read_output(struct ndr_print *ndr, const char *name, int unused, const struct fsctl_offload_read_output *r)
     459             : {
     460           0 :         ndr_print_fsctl_offload_read_output(ndr, name, r);
     461           0 : }
     462             : 
     463           0 : _PUBLIC_ void ndr_print_fsctl_offload_read_output(struct ndr_print *ndr, const char *name, const struct fsctl_offload_read_output *r)
     464             : {
     465           0 :         ndr_print_struct(ndr, name, "fsctl_offload_read_output");
     466           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     467           0 :         ndr->depth++;
     468           0 :         ndr_print_uint32(ndr, "size", r->size);
     469           0 :         ndr_print_offload_flags(ndr, "flags", r->flags);
     470           0 :         ndr_print_hyper(ndr, "xfer_length", r->xfer_length);
     471           0 :         ndr_print_storage_offload_token(ndr, "token", &r->token);
     472           0 :         ndr->depth--;
     473             : }
     474             : 
     475           0 : _PUBLIC_ enum ndr_err_code ndr_push_fsctl_offload_write_input(struct ndr_push *ndr, int ndr_flags, const struct fsctl_offload_write_input *r)
     476             : {
     477           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     478           0 :         if (ndr_flags & NDR_SCALARS) {
     479           0 :                 NDR_CHECK(ndr_push_align(ndr, 8));
     480           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
     481           0 :                 NDR_CHECK(ndr_push_offload_flags(ndr, NDR_SCALARS, r->flags));
     482           0 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->file_offset));
     483           0 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->copy_length));
     484           0 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->xfer_offset));
     485           0 :                 NDR_CHECK(ndr_push_storage_offload_token(ndr, NDR_SCALARS, &r->token));
     486           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
     487             :         }
     488           0 :         if (ndr_flags & NDR_BUFFERS) {
     489             :         }
     490           0 :         return NDR_ERR_SUCCESS;
     491             : }
     492             : 
     493           0 : _PUBLIC_ enum ndr_err_code ndr_pull_fsctl_offload_write_input(struct ndr_pull *ndr, int ndr_flags, struct fsctl_offload_write_input *r)
     494             : {
     495           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     496           0 :         if (ndr_flags & NDR_SCALARS) {
     497           0 :                 NDR_CHECK(ndr_pull_align(ndr, 8));
     498           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
     499           0 :                 NDR_CHECK(ndr_pull_offload_flags(ndr, NDR_SCALARS, &r->flags));
     500           0 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->file_offset));
     501           0 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->copy_length));
     502           0 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->xfer_offset));
     503           0 :                 NDR_CHECK(ndr_pull_storage_offload_token(ndr, NDR_SCALARS, &r->token));
     504           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
     505             :         }
     506           0 :         if (ndr_flags & NDR_BUFFERS) {
     507             :         }
     508           0 :         return NDR_ERR_SUCCESS;
     509             : }
     510             : 
     511           0 : static void ndr_print_flags_fsctl_offload_write_input(struct ndr_print *ndr, const char *name, int unused, const struct fsctl_offload_write_input *r)
     512             : {
     513           0 :         ndr_print_fsctl_offload_write_input(ndr, name, r);
     514           0 : }
     515             : 
     516           0 : _PUBLIC_ void ndr_print_fsctl_offload_write_input(struct ndr_print *ndr, const char *name, const struct fsctl_offload_write_input *r)
     517             : {
     518           0 :         ndr_print_struct(ndr, name, "fsctl_offload_write_input");
     519           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     520           0 :         ndr->depth++;
     521           0 :         ndr_print_uint32(ndr, "size", r->size);
     522           0 :         ndr_print_offload_flags(ndr, "flags", r->flags);
     523           0 :         ndr_print_hyper(ndr, "file_offset", r->file_offset);
     524           0 :         ndr_print_hyper(ndr, "copy_length", r->copy_length);
     525           0 :         ndr_print_hyper(ndr, "xfer_offset", r->xfer_offset);
     526           0 :         ndr_print_storage_offload_token(ndr, "token", &r->token);
     527           0 :         ndr->depth--;
     528             : }
     529             : 
     530           0 : _PUBLIC_ enum ndr_err_code ndr_push_fsctl_offload_write_output(struct ndr_push *ndr, int ndr_flags, const struct fsctl_offload_write_output *r)
     531             : {
     532           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     533           0 :         if (ndr_flags & NDR_SCALARS) {
     534           0 :                 NDR_CHECK(ndr_push_align(ndr, 8));
     535           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
     536           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
     537           0 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->length_written));
     538           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
     539             :         }
     540           0 :         if (ndr_flags & NDR_BUFFERS) {
     541             :         }
     542           0 :         return NDR_ERR_SUCCESS;
     543             : }
     544             : 
     545           0 : _PUBLIC_ enum ndr_err_code ndr_pull_fsctl_offload_write_output(struct ndr_pull *ndr, int ndr_flags, struct fsctl_offload_write_output *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->size));
     551           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
     552           0 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->length_written));
     553           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
     554             :         }
     555           0 :         if (ndr_flags & NDR_BUFFERS) {
     556             :         }
     557           0 :         return NDR_ERR_SUCCESS;
     558             : }
     559             : 
     560           0 : static void ndr_print_flags_fsctl_offload_write_output(struct ndr_print *ndr, const char *name, int unused, const struct fsctl_offload_write_output *r)
     561             : {
     562           0 :         ndr_print_fsctl_offload_write_output(ndr, name, r);
     563           0 : }
     564             : 
     565           0 : _PUBLIC_ void ndr_print_fsctl_offload_write_output(struct ndr_print *ndr, const char *name, const struct fsctl_offload_write_output *r)
     566             : {
     567           0 :         ndr_print_struct(ndr, name, "fsctl_offload_write_output");
     568           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     569           0 :         ndr->depth++;
     570           0 :         ndr_print_uint32(ndr, "size", r->size);
     571           0 :         ndr_print_uint32(ndr, "flags", r->flags);
     572           0 :         ndr_print_hyper(ndr, "length_written", r->length_written);
     573           0 :         ndr->depth--;
     574             : }
     575             : 
     576           0 : _PUBLIC_ enum ndr_err_code ndr_push_fsctl_dup_extents_to_file(struct ndr_push *ndr, int ndr_flags, const struct fsctl_dup_extents_to_file *r)
     577             : {
     578           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     579           0 :         if (ndr_flags & NDR_SCALARS) {
     580           0 :                 NDR_CHECK(ndr_push_align(ndr, 8));
     581           0 :                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->source_fid, 16));
     582           0 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->source_off));
     583           0 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->target_off));
     584           0 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->byte_count));
     585           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
     586             :         }
     587           0 :         if (ndr_flags & NDR_BUFFERS) {
     588             :         }
     589           0 :         return NDR_ERR_SUCCESS;
     590             : }
     591             : 
     592           0 : _PUBLIC_ enum ndr_err_code ndr_pull_fsctl_dup_extents_to_file(struct ndr_pull *ndr, int ndr_flags, struct fsctl_dup_extents_to_file *r)
     593             : {
     594           0 :         uint32_t size_source_fid_0 = 0;
     595           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     596           0 :         if (ndr_flags & NDR_SCALARS) {
     597           0 :                 NDR_CHECK(ndr_pull_align(ndr, 8));
     598           0 :                 size_source_fid_0 = 16;
     599           0 :                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->source_fid, size_source_fid_0));
     600           0 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->source_off));
     601           0 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->target_off));
     602           0 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->byte_count));
     603           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
     604             :         }
     605           0 :         if (ndr_flags & NDR_BUFFERS) {
     606             :         }
     607           0 :         return NDR_ERR_SUCCESS;
     608             : }
     609             : 
     610           0 : static void ndr_print_flags_fsctl_dup_extents_to_file(struct ndr_print *ndr, const char *name, int unused, const struct fsctl_dup_extents_to_file *r)
     611             : {
     612           0 :         ndr_print_fsctl_dup_extents_to_file(ndr, name, r);
     613           0 : }
     614             : 
     615           0 : _PUBLIC_ void ndr_print_fsctl_dup_extents_to_file(struct ndr_print *ndr, const char *name, const struct fsctl_dup_extents_to_file *r)
     616             : {
     617           0 :         ndr_print_struct(ndr, name, "fsctl_dup_extents_to_file");
     618           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     619           0 :         ndr->depth++;
     620           0 :         ndr_print_array_uint8(ndr, "source_fid", r->source_fid, 16);
     621           0 :         ndr_print_hyper(ndr, "source_off", r->source_off);
     622           0 :         ndr_print_hyper(ndr, "target_off", r->target_off);
     623           0 :         ndr_print_hyper(ndr, "byte_count", r->byte_count);
     624           0 :         ndr->depth--;
     625             : }
     626             : 
     627             : #ifndef SKIP_NDR_TABLE_copychunk
     628             : static const struct ndr_interface_public_struct copychunk_public_structs[] = {
     629             :         {
     630             :                 .name = "req_resume_key_rsp",
     631             :                 .struct_size = sizeof(struct req_resume_key_rsp ),
     632             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_req_resume_key_rsp,
     633             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_req_resume_key_rsp,
     634             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_req_resume_key_rsp,
     635             :         },
     636             :         {
     637             :                 .name = "srv_copychunk_copy",
     638             :                 .struct_size = sizeof(struct srv_copychunk_copy ),
     639             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_srv_copychunk_copy,
     640             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_srv_copychunk_copy,
     641             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_srv_copychunk_copy,
     642             :         },
     643             :         {
     644             :                 .name = "srv_copychunk_rsp",
     645             :                 .struct_size = sizeof(struct srv_copychunk_rsp ),
     646             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_srv_copychunk_rsp,
     647             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_srv_copychunk_rsp,
     648             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_srv_copychunk_rsp,
     649             :         },
     650             :         {
     651             :                 .name = "device_copy_offload_descriptor",
     652             :                 .struct_size = sizeof(struct device_copy_offload_descriptor ),
     653             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_device_copy_offload_descriptor,
     654             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_device_copy_offload_descriptor,
     655             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_device_copy_offload_descriptor,
     656             :         },
     657             :         {
     658             :                 .name = "storage_offload_token",
     659             :                 .struct_size = sizeof(struct storage_offload_token ),
     660             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_storage_offload_token,
     661             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_storage_offload_token,
     662             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_storage_offload_token,
     663             :         },
     664             :         {
     665             :                 .name = "fsctl_offload_read_input",
     666             :                 .struct_size = sizeof(struct fsctl_offload_read_input ),
     667             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_fsctl_offload_read_input,
     668             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_fsctl_offload_read_input,
     669             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_fsctl_offload_read_input,
     670             :         },
     671             :         {
     672             :                 .name = "fsctl_offload_read_output",
     673             :                 .struct_size = sizeof(struct fsctl_offload_read_output ),
     674             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_fsctl_offload_read_output,
     675             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_fsctl_offload_read_output,
     676             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_fsctl_offload_read_output,
     677             :         },
     678             :         {
     679             :                 .name = "fsctl_offload_write_input",
     680             :                 .struct_size = sizeof(struct fsctl_offload_write_input ),
     681             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_fsctl_offload_write_input,
     682             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_fsctl_offload_write_input,
     683             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_fsctl_offload_write_input,
     684             :         },
     685             :         {
     686             :                 .name = "fsctl_offload_write_output",
     687             :                 .struct_size = sizeof(struct fsctl_offload_write_output ),
     688             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_fsctl_offload_write_output,
     689             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_fsctl_offload_write_output,
     690             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_fsctl_offload_write_output,
     691             :         },
     692             :         {
     693             :                 .name = "fsctl_dup_extents_to_file",
     694             :                 .struct_size = sizeof(struct fsctl_dup_extents_to_file ),
     695             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_fsctl_dup_extents_to_file,
     696             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_fsctl_dup_extents_to_file,
     697             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_fsctl_dup_extents_to_file,
     698             :         },
     699             :         { .name = NULL }
     700             : };
     701             : 
     702             : static const struct ndr_interface_call copychunk_calls[] = {
     703             :         { .name = NULL }
     704             : };
     705             : 
     706             : static const char * const copychunk_endpoint_strings[] = {
     707             :         "ncacn_np:[\\pipe\\copychunk]", 
     708             : };
     709             : 
     710             : static const struct ndr_interface_string_array copychunk_endpoints = {
     711             :         .count  = 1,
     712             :         .names  = copychunk_endpoint_strings
     713             : };
     714             : 
     715             : static const char * const copychunk_authservice_strings[] = {
     716             :         "host", 
     717             : };
     718             : 
     719             : static const struct ndr_interface_string_array copychunk_authservices = {
     720             :         .count  = 1,
     721             :         .names  = copychunk_authservice_strings
     722             : };
     723             : 
     724             : 
     725             : const struct ndr_interface_table ndr_table_copychunk = {
     726             :         .name           = "copychunk",
     727             :         .num_calls      = 0,
     728             :         .calls          = copychunk_calls,
     729             :         .num_public_structs     = 10,
     730             :         .public_structs         = copychunk_public_structs,
     731             :         .endpoints      = &copychunk_endpoints,
     732             :         .authservices   = &copychunk_authservices
     733             : };
     734             : 
     735             : #endif /* SKIP_NDR_TABLE_copychunk */
     736          19 : _PUBLIC_ enum ndr_err_code ndr_push_compression_state(struct ndr_push *ndr, int ndr_flags, const struct compression_state *r)
     737             : {
     738          19 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     739          19 :         if (ndr_flags & NDR_SCALARS) {
     740          19 :                 NDR_CHECK(ndr_push_align(ndr, 2));
     741          19 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->format));
     742          19 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
     743             :         }
     744          19 :         if (ndr_flags & NDR_BUFFERS) {
     745             :         }
     746          19 :         return NDR_ERR_SUCCESS;
     747             : }
     748             : 
     749          18 : _PUBLIC_ enum ndr_err_code ndr_pull_compression_state(struct ndr_pull *ndr, int ndr_flags, struct compression_state *r)
     750             : {
     751          18 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     752          18 :         if (ndr_flags & NDR_SCALARS) {
     753          18 :                 NDR_CHECK(ndr_pull_align(ndr, 2));
     754          18 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->format));
     755          18 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
     756             :         }
     757          18 :         if (ndr_flags & NDR_BUFFERS) {
     758             :         }
     759          18 :         return NDR_ERR_SUCCESS;
     760             : }
     761             : 
     762           0 : static void ndr_print_flags_compression_state(struct ndr_print *ndr, const char *name, int unused, const struct compression_state *r)
     763             : {
     764           0 :         ndr_print_compression_state(ndr, name, r);
     765           0 : }
     766             : 
     767           0 : _PUBLIC_ void ndr_print_compression_state(struct ndr_print *ndr, const char *name, const struct compression_state *r)
     768             : {
     769           0 :         ndr_print_struct(ndr, name, "compression_state");
     770           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     771           0 :         ndr->depth++;
     772           0 :         ndr_print_uint16(ndr, "format", r->format);
     773           0 :         ndr->depth--;
     774             : }
     775             : 
     776             : #ifndef SKIP_NDR_TABLE_compression
     777             : static const struct ndr_interface_public_struct compression_public_structs[] = {
     778             :         {
     779             :                 .name = "compression_state",
     780             :                 .struct_size = sizeof(struct compression_state ),
     781             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_compression_state,
     782             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_compression_state,
     783             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_compression_state,
     784             :         },
     785             :         { .name = NULL }
     786             : };
     787             : 
     788             : static const struct ndr_interface_call compression_calls[] = {
     789             :         { .name = NULL }
     790             : };
     791             : 
     792             : static const char * const compression_endpoint_strings[] = {
     793             :         "ncacn_np:[\\pipe\\compression]", 
     794             : };
     795             : 
     796             : static const struct ndr_interface_string_array compression_endpoints = {
     797             :         .count  = 1,
     798             :         .names  = compression_endpoint_strings
     799             : };
     800             : 
     801             : static const char * const compression_authservice_strings[] = {
     802             :         "host", 
     803             : };
     804             : 
     805             : static const struct ndr_interface_string_array compression_authservices = {
     806             :         .count  = 1,
     807             :         .names  = compression_authservice_strings
     808             : };
     809             : 
     810             : 
     811             : const struct ndr_interface_table ndr_table_compression = {
     812             :         .name           = "compression",
     813             :         .num_calls      = 0,
     814             :         .calls          = compression_calls,
     815             :         .num_public_structs     = 1,
     816             :         .public_structs         = compression_public_structs,
     817             :         .endpoints      = &compression_endpoints,
     818             :         .authservices   = &compression_authservices
     819             : };
     820             : 
     821             : #endif /* SKIP_NDR_TABLE_compression */
     822          84 : static enum ndr_err_code ndr_push_fsctl_net_iface_capability(struct ndr_push *ndr, int ndr_flags, uint32_t r)
     823             : {
     824          84 :         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
     825          84 :         return NDR_ERR_SUCCESS;
     826             : }
     827             : 
     828          84 : static enum ndr_err_code ndr_pull_fsctl_net_iface_capability(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
     829             : {
     830             :         uint32_t v;
     831          84 :         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
     832          84 :         *r = v;
     833          84 :         return NDR_ERR_SUCCESS;
     834             : }
     835             : 
     836          84 : _PUBLIC_ void ndr_print_fsctl_net_iface_capability(struct ndr_print *ndr, const char *name, uint32_t r)
     837             : {
     838          84 :         ndr_print_uint32(ndr, name, r);
     839          84 :         ndr->depth++;
     840          84 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "FSCTL_NET_IFACE_NONE_CAPABLE", FSCTL_NET_IFACE_NONE_CAPABLE, r);
     841          84 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "FSCTL_NET_IFACE_RSS_CAPABLE", FSCTL_NET_IFACE_RSS_CAPABLE, r);
     842          84 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "FSCTL_NET_IFACE_RDMA_CAPABLE", FSCTL_NET_IFACE_RDMA_CAPABLE, r);
     843          84 :         ndr->depth--;
     844          84 : }
     845             : 
     846          84 : static enum ndr_err_code ndr_push_fsctl_sockaddr_af(struct ndr_push *ndr, int ndr_flags, enum fsctl_sockaddr_af r)
     847             : {
     848          84 :         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
     849          84 :         return NDR_ERR_SUCCESS;
     850             : }
     851             : 
     852          84 : static enum ndr_err_code ndr_pull_fsctl_sockaddr_af(struct ndr_pull *ndr, int ndr_flags, enum fsctl_sockaddr_af *r)
     853             : {
     854             :         uint16_t v;
     855          84 :         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
     856          84 :         *r = v;
     857          84 :         return NDR_ERR_SUCCESS;
     858             : }
     859             : 
     860          84 : _PUBLIC_ void ndr_print_fsctl_sockaddr_af(struct ndr_print *ndr, const char *name, enum fsctl_sockaddr_af r)
     861             : {
     862          84 :         const char *val = NULL;
     863             : 
     864          84 :         switch (r) {
     865          42 :                 case FSCTL_NET_IFACE_AF_INET: val = "FSCTL_NET_IFACE_AF_INET"; break;
     866          42 :                 case FSCTL_NET_IFACE_AF_INET6: val = "FSCTL_NET_IFACE_AF_INET6"; break;
     867             :         }
     868          84 :         ndr_print_enum(ndr, name, "ENUM", val, r);
     869          84 : }
     870             : 
     871          42 : static enum ndr_err_code ndr_push_fsctl_sockaddr_in(struct ndr_push *ndr, int ndr_flags, const struct fsctl_sockaddr_in *r)
     872             : {
     873             :         {
     874          42 :                 uint32_t _flags_save_STRUCT = ndr->flags;
     875          42 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
     876          42 :                 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     877          42 :                 if (ndr_flags & NDR_SCALARS) {
     878          42 :                         NDR_CHECK(ndr_push_align(ndr, 8));
     879          42 :                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
     880             :                         {
     881          42 :                                 uint32_t _flags_save_ipv4address = ndr->flags;
     882          42 :                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
     883          42 :                                 NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->ipv4));
     884          42 :                                 ndr->flags = _flags_save_ipv4address;
     885             :                         }
     886          42 :                         NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, 0));
     887          42 :                         NDR_CHECK(ndr_push_trailer_align(ndr, 8));
     888             :                 }
     889          42 :                 if (ndr_flags & NDR_BUFFERS) {
     890             :                 }
     891          42 :                 ndr->flags = _flags_save_STRUCT;
     892             :         }
     893          42 :         return NDR_ERR_SUCCESS;
     894             : }
     895             : 
     896          42 : static enum ndr_err_code ndr_pull_fsctl_sockaddr_in(struct ndr_pull *ndr, int ndr_flags, struct fsctl_sockaddr_in *r)
     897             : {
     898             :         {
     899          42 :                 uint32_t _flags_save_STRUCT = ndr->flags;
     900          42 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
     901          42 :                 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     902          42 :                 if (ndr_flags & NDR_SCALARS) {
     903          42 :                         NDR_CHECK(ndr_pull_align(ndr, 8));
     904          42 :                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->port));
     905             :                         {
     906          42 :                                 uint32_t _flags_save_ipv4address = ndr->flags;
     907          42 :                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
     908          42 :                                 NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->ipv4));
     909          42 :                                 ndr->flags = _flags_save_ipv4address;
     910             :                         }
     911          42 :                         NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->reserved));
     912          42 :                         NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
     913             :                 }
     914          42 :                 if (ndr_flags & NDR_BUFFERS) {
     915             :                 }
     916          42 :                 ndr->flags = _flags_save_STRUCT;
     917             :         }
     918          42 :         return NDR_ERR_SUCCESS;
     919             : }
     920             : 
     921          42 : _PUBLIC_ void ndr_print_fsctl_sockaddr_in(struct ndr_print *ndr, const char *name, const struct fsctl_sockaddr_in *r)
     922             : {
     923          42 :         ndr_print_struct(ndr, name, "fsctl_sockaddr_in");
     924          42 :         if (r == NULL) { ndr_print_null(ndr); return; }
     925             :         {
     926          42 :                 uint32_t _flags_save_STRUCT = ndr->flags;
     927          42 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
     928          42 :                 ndr->depth++;
     929          42 :                 ndr_print_uint16(ndr, "port", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->port);
     930             :                 {
     931          42 :                         uint32_t _flags_save_ipv4address = ndr->flags;
     932          42 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
     933          42 :                         ndr_print_ipv4address(ndr, "ipv4", r->ipv4);
     934          42 :                         ndr->flags = _flags_save_ipv4address;
     935             :                 }
     936          42 :                 ndr_print_hyper(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved);
     937          42 :                 ndr->depth--;
     938          42 :                 ndr->flags = _flags_save_STRUCT;
     939             :         }
     940             : }
     941             : 
     942          42 : static enum ndr_err_code ndr_push_fsctl_sockaddr_in6(struct ndr_push *ndr, int ndr_flags, const struct fsctl_sockaddr_in6 *r)
     943             : {
     944             :         {
     945          42 :                 uint32_t _flags_save_STRUCT = ndr->flags;
     946          42 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
     947          42 :                 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     948          42 :                 if (ndr_flags & NDR_SCALARS) {
     949          42 :                         NDR_CHECK(ndr_push_align(ndr, 4));
     950          42 :                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
     951          42 :                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
     952             :                         {
     953          42 :                                 uint32_t _flags_save_ipv6address = ndr->flags;
     954          42 :                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
     955          42 :                                 NDR_CHECK(ndr_push_ipv6address(ndr, NDR_SCALARS, r->ipv6));
     956          42 :                                 ndr->flags = _flags_save_ipv6address;
     957             :                         }
     958          42 :                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
     959          42 :                         NDR_CHECK(ndr_push_trailer_align(ndr, 4));
     960             :                 }
     961          42 :                 if (ndr_flags & NDR_BUFFERS) {
     962             :                 }
     963          42 :                 ndr->flags = _flags_save_STRUCT;
     964             :         }
     965          42 :         return NDR_ERR_SUCCESS;
     966             : }
     967             : 
     968          42 : static enum ndr_err_code ndr_pull_fsctl_sockaddr_in6(struct ndr_pull *ndr, int ndr_flags, struct fsctl_sockaddr_in6 *r)
     969             : {
     970             :         {
     971          42 :                 uint32_t _flags_save_STRUCT = ndr->flags;
     972          42 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
     973          42 :                 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     974          42 :                 if (ndr_flags & NDR_SCALARS) {
     975          42 :                         NDR_CHECK(ndr_pull_align(ndr, 4));
     976          42 :                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->port));
     977          42 :                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flowinfo));
     978             :                         {
     979          42 :                                 uint32_t _flags_save_ipv6address = ndr->flags;
     980          42 :                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
     981          42 :                                 NDR_CHECK(ndr_pull_ipv6address(ndr, NDR_SCALARS, &r->ipv6));
     982          42 :                                 ndr->flags = _flags_save_ipv6address;
     983             :                         }
     984          42 :                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->scopeid));
     985          42 :                         NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
     986             :                 }
     987          42 :                 if (ndr_flags & NDR_BUFFERS) {
     988             :                 }
     989          42 :                 ndr->flags = _flags_save_STRUCT;
     990             :         }
     991          42 :         return NDR_ERR_SUCCESS;
     992             : }
     993             : 
     994          42 : _PUBLIC_ void ndr_print_fsctl_sockaddr_in6(struct ndr_print *ndr, const char *name, const struct fsctl_sockaddr_in6 *r)
     995             : {
     996          42 :         ndr_print_struct(ndr, name, "fsctl_sockaddr_in6");
     997          42 :         if (r == NULL) { ndr_print_null(ndr); return; }
     998             :         {
     999          42 :                 uint32_t _flags_save_STRUCT = ndr->flags;
    1000          42 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
    1001          42 :                 ndr->depth++;
    1002          42 :                 ndr_print_uint16(ndr, "port", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->port);
    1003          42 :                 ndr_print_uint32(ndr, "flowinfo", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->flowinfo);
    1004             :                 {
    1005          42 :                         uint32_t _flags_save_ipv6address = ndr->flags;
    1006          42 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
    1007          42 :                         ndr_print_ipv6address(ndr, "ipv6", r->ipv6);
    1008          42 :                         ndr->flags = _flags_save_ipv6address;
    1009             :                 }
    1010          42 :                 ndr_print_uint32(ndr, "scopeid", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->scopeid);
    1011          42 :                 ndr->depth--;
    1012          42 :                 ndr->flags = _flags_save_STRUCT;
    1013             :         }
    1014             : }
    1015             : 
    1016          84 : static enum ndr_err_code ndr_push_fsctl_sockaddr_union(struct ndr_push *ndr, int ndr_flags, const union fsctl_sockaddr_union *r)
    1017             : {
    1018             :         uint32_t level;
    1019             :         {
    1020          84 :                 uint32_t _flags_save_UNION = ndr->flags;
    1021          84 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
    1022          84 :                 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1023          84 :                 if (ndr_flags & NDR_SCALARS) {
    1024             :                         /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
    1025          84 :                         NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
    1026          84 :                         NDR_CHECK(ndr_push_union_align(ndr, 8));
    1027          84 :                         switch (level) {
    1028          42 :                                 case FSCTL_NET_IFACE_AF_INET: {
    1029          42 :                                         NDR_CHECK(ndr_push_fsctl_sockaddr_in(ndr, NDR_SCALARS, &r->saddr_in));
    1030          42 :                                 break; }
    1031             : 
    1032          42 :                                 case FSCTL_NET_IFACE_AF_INET6: {
    1033          42 :                                         NDR_CHECK(ndr_push_fsctl_sockaddr_in6(ndr, NDR_SCALARS, &r->saddr_in6));
    1034          42 :                                 break; }
    1035             : 
    1036           0 :                                 default:
    1037           0 :                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
    1038             :                         }
    1039           0 :                 }
    1040          84 :                 if (ndr_flags & NDR_BUFFERS) {
    1041           0 :                         if (!(ndr_flags & NDR_SCALARS)) {
    1042             :                                 /* We didn't get it above, and the token is not needed after this. */
    1043           0 :                                 NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
    1044             :                         }
    1045           0 :                         switch (level) {
    1046           0 :                                 case FSCTL_NET_IFACE_AF_INET:
    1047           0 :                                 break;
    1048             : 
    1049           0 :                                 case FSCTL_NET_IFACE_AF_INET6:
    1050           0 :                                 break;
    1051             : 
    1052           0 :                                 default:
    1053           0 :                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
    1054             :                         }
    1055          64 :                 }
    1056          84 :                 ndr->flags = _flags_save_UNION;
    1057             :         }
    1058          84 :         return NDR_ERR_SUCCESS;
    1059             : }
    1060             : 
    1061          84 : static enum ndr_err_code ndr_pull_fsctl_sockaddr_union(struct ndr_pull *ndr, int ndr_flags, union fsctl_sockaddr_union *r)
    1062             : {
    1063             :         uint32_t level;
    1064             :         {
    1065          84 :                 uint32_t _flags_save_UNION = ndr->flags;
    1066          84 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
    1067          84 :                 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1068          84 :                 if (ndr_flags & NDR_SCALARS) {
    1069             :                         /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
    1070          84 :                         NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
    1071          84 :                         NDR_CHECK(ndr_pull_union_align(ndr, 8));
    1072          84 :                         switch (level) {
    1073          42 :                                 case FSCTL_NET_IFACE_AF_INET: {
    1074          42 :                                         NDR_CHECK(ndr_pull_fsctl_sockaddr_in(ndr, NDR_SCALARS, &r->saddr_in));
    1075          42 :                                 break; }
    1076             : 
    1077          42 :                                 case FSCTL_NET_IFACE_AF_INET6: {
    1078          42 :                                         NDR_CHECK(ndr_pull_fsctl_sockaddr_in6(ndr, NDR_SCALARS, &r->saddr_in6));
    1079          42 :                                 break; }
    1080             : 
    1081           0 :                                 default:
    1082           0 :                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
    1083             :                         }
    1084           0 :                 }
    1085          84 :                 if (ndr_flags & NDR_BUFFERS) {
    1086           0 :                         if (!(ndr_flags & NDR_SCALARS)) {
    1087             :                                 /* We didn't get it above, and the token is not needed after this. */
    1088           0 :                                 NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
    1089             :                         }
    1090           0 :                         switch (level) {
    1091           0 :                                 case FSCTL_NET_IFACE_AF_INET:
    1092           0 :                                 break;
    1093             : 
    1094           0 :                                 case FSCTL_NET_IFACE_AF_INET6:
    1095           0 :                                 break;
    1096             : 
    1097           0 :                                 default:
    1098           0 :                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
    1099             :                         }
    1100          64 :                 }
    1101          84 :                 ndr->flags = _flags_save_UNION;
    1102             :         }
    1103          84 :         return NDR_ERR_SUCCESS;
    1104             : }
    1105             : 
    1106          84 : _PUBLIC_ void ndr_print_fsctl_sockaddr_union(struct ndr_print *ndr, const char *name, const union fsctl_sockaddr_union *r)
    1107             : {
    1108             :         uint32_t level;
    1109             :         {
    1110          84 :                 uint32_t _flags_save_UNION = ndr->flags;
    1111          84 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
    1112          84 :                 level = ndr_print_steal_switch_value(ndr, r);
    1113          84 :                 ndr_print_union(ndr, name, level, "fsctl_sockaddr_union");
    1114          84 :                 switch (level) {
    1115          42 :                         case FSCTL_NET_IFACE_AF_INET:
    1116          42 :                                 ndr_print_fsctl_sockaddr_in(ndr, "saddr_in", &r->saddr_in);
    1117          42 :                         break;
    1118             : 
    1119          42 :                         case FSCTL_NET_IFACE_AF_INET6:
    1120          42 :                                 ndr_print_fsctl_sockaddr_in6(ndr, "saddr_in6", &r->saddr_in6);
    1121          42 :                         break;
    1122             : 
    1123           0 :                         default:
    1124           0 :                                 ndr_print_bad_level(ndr, name, level);
    1125             :                 }
    1126          84 :                 ndr->flags = _flags_save_UNION;
    1127             :         }
    1128          84 : }
    1129             : 
    1130          84 : static enum ndr_err_code ndr_push_fsctl_sockaddr_storage(struct ndr_push *ndr, int ndr_flags, const struct fsctl_sockaddr_storage *r)
    1131             : {
    1132             :         {
    1133          84 :                 uint32_t _flags_save_STRUCT = ndr->flags;
    1134          84 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
    1135          84 :                 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1136          84 :                 if (ndr_flags & NDR_SCALARS) {
    1137          84 :                         NDR_CHECK(ndr_push_align(ndr, 8));
    1138          84 :                         NDR_CHECK(ndr_push_fsctl_sockaddr_af(ndr, NDR_SCALARS, r->family));
    1139             :                         {
    1140             :                                 struct ndr_push *_ndr_saddr;
    1141          84 :                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_saddr, 0, 126));
    1142          84 :                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_saddr, &r->saddr, r->family));
    1143          84 :                                 NDR_CHECK(ndr_push_fsctl_sockaddr_union(_ndr_saddr, NDR_SCALARS, &r->saddr));
    1144          84 :                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_saddr, 0, 126));
    1145             :                         }
    1146          84 :                         NDR_CHECK(ndr_push_trailer_align(ndr, 8));
    1147             :                 }
    1148          84 :                 if (ndr_flags & NDR_BUFFERS) {
    1149             :                 }
    1150          84 :                 ndr->flags = _flags_save_STRUCT;
    1151             :         }
    1152          84 :         return NDR_ERR_SUCCESS;
    1153             : }
    1154             : 
    1155          84 : static enum ndr_err_code ndr_pull_fsctl_sockaddr_storage(struct ndr_pull *ndr, int ndr_flags, struct fsctl_sockaddr_storage *r)
    1156             : {
    1157             :         {
    1158          84 :                 uint32_t _flags_save_STRUCT = ndr->flags;
    1159          84 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
    1160          84 :                 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1161          84 :                 if (ndr_flags & NDR_SCALARS) {
    1162          84 :                         NDR_CHECK(ndr_pull_align(ndr, 8));
    1163          84 :                         NDR_CHECK(ndr_pull_fsctl_sockaddr_af(ndr, NDR_SCALARS, &r->family));
    1164             :                         {
    1165             :                                 struct ndr_pull *_ndr_saddr;
    1166          84 :                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_saddr, 0, 126));
    1167          84 :                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_saddr, &r->saddr, r->family));
    1168          84 :                                 NDR_CHECK(ndr_pull_fsctl_sockaddr_union(_ndr_saddr, NDR_SCALARS, &r->saddr));
    1169          84 :                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_saddr, 0, 126));
    1170             :                         }
    1171          84 :                         NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
    1172             :                 }
    1173          84 :                 if (ndr_flags & NDR_BUFFERS) {
    1174             :                 }
    1175          84 :                 ndr->flags = _flags_save_STRUCT;
    1176             :         }
    1177          84 :         return NDR_ERR_SUCCESS;
    1178             : }
    1179             : 
    1180          84 : _PUBLIC_ void ndr_print_fsctl_sockaddr_storage(struct ndr_print *ndr, const char *name, const struct fsctl_sockaddr_storage *r)
    1181             : {
    1182          84 :         ndr_print_struct(ndr, name, "fsctl_sockaddr_storage");
    1183          84 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1184             :         {
    1185          84 :                 uint32_t _flags_save_STRUCT = ndr->flags;
    1186          84 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
    1187          84 :                 ndr->depth++;
    1188          84 :                 ndr_print_fsctl_sockaddr_af(ndr, "family", r->family);
    1189          84 :                 ndr_print_set_switch_value(ndr, &r->saddr, r->family);
    1190          84 :                 ndr_print_fsctl_sockaddr_union(ndr, "saddr", &r->saddr);
    1191          84 :                 ndr->depth--;
    1192          84 :                 ndr->flags = _flags_save_STRUCT;
    1193             :         }
    1194             : }
    1195             : 
    1196          84 : _PUBLIC_ enum ndr_err_code ndr_push_fsctl_net_iface_info(struct ndr_push *ndr, int ndr_flags, const struct fsctl_net_iface_info *r)
    1197             : {
    1198          84 :         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
    1199          84 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1200          84 :         if (ndr_flags & NDR_SCALARS) {
    1201          84 :                 NDR_CHECK(ndr_push_align(ndr, 8));
    1202          84 :                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
    1203          84 :                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->next));
    1204          84 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ifindex));
    1205          84 :                 NDR_CHECK(ndr_push_fsctl_net_iface_capability(ndr, NDR_SCALARS, r->capability));
    1206          84 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
    1207          84 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->linkspeed));
    1208          84 :                 NDR_CHECK(ndr_push_fsctl_sockaddr_storage(ndr, NDR_SCALARS, &r->sockaddr));
    1209          84 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
    1210             :         }
    1211          84 :         if (ndr_flags & NDR_BUFFERS) {
    1212          84 :                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
    1213          84 :                 if (r->next) {
    1214          42 :                         NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->next));
    1215          42 :                         NDR_CHECK(ndr_push_fsctl_net_iface_info(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
    1216          42 :                         NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->next));
    1217             :                 }
    1218             :         }
    1219          84 :         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
    1220          84 :         return NDR_ERR_SUCCESS;
    1221             : }
    1222             : 
    1223          84 : _PUBLIC_ enum ndr_err_code ndr_pull_fsctl_net_iface_info(struct ndr_pull *ndr, int ndr_flags, struct fsctl_net_iface_info *r)
    1224             : {
    1225          84 :         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
    1226             :         uint32_t _ptr_next;
    1227          84 :         TALLOC_CTX *_mem_save_next_0 = NULL;
    1228          84 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1229          84 :         if (ndr_flags & NDR_SCALARS) {
    1230          84 :                 NDR_CHECK(ndr_pull_align(ndr, 8));
    1231          84 :                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
    1232          84 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next));
    1233          84 :                 if (_ptr_next) {
    1234          42 :                         NDR_PULL_ALLOC(ndr, r->next);
    1235          42 :                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->next, _ptr_next));
    1236             :                 } else {
    1237          42 :                         r->next = NULL;
    1238             :                 }
    1239          84 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ifindex));
    1240          84 :                 NDR_CHECK(ndr_pull_fsctl_net_iface_capability(ndr, NDR_SCALARS, &r->capability));
    1241          84 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
    1242          84 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->linkspeed));
    1243          84 :                 NDR_CHECK(ndr_pull_fsctl_sockaddr_storage(ndr, NDR_SCALARS, &r->sockaddr));
    1244          84 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
    1245             :         }
    1246          84 :         if (ndr_flags & NDR_BUFFERS) {
    1247          84 :                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
    1248          84 :                 if (r->next) {
    1249             :                         uint32_t _relative_save_offset;
    1250          42 :                         _relative_save_offset = ndr->offset;
    1251          42 :                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->next));
    1252          42 :                         _mem_save_next_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1253          42 :                         NDR_PULL_SET_MEM_CTX(ndr, r->next, 0);
    1254          42 :                         NDR_RECURSION_CHECK(ndr, 20000);
    1255          42 :                         NDR_CHECK(ndr_pull_fsctl_net_iface_info(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
    1256          42 :                         NDR_RECURSION_UNWIND(ndr);
    1257          42 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_0, 0);
    1258          42 :                         if (ndr->offset > ndr->relative_highest_offset) {
    1259          42 :                                 ndr->relative_highest_offset = ndr->offset;
    1260             :                         }
    1261          42 :                         ndr->offset = _relative_save_offset;
    1262             :                 }
    1263             :         }
    1264          84 :         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
    1265          84 :         return NDR_ERR_SUCCESS;
    1266             : }
    1267             : 
    1268           0 : static void ndr_print_flags_fsctl_net_iface_info(struct ndr_print *ndr, const char *name, int unused, const struct fsctl_net_iface_info *r)
    1269             : {
    1270           0 :         ndr_print_fsctl_net_iface_info(ndr, name, r);
    1271           0 : }
    1272             : 
    1273             : #ifndef SKIP_NDR_TABLE_netinterface
    1274             : static const struct ndr_interface_public_struct netinterface_public_structs[] = {
    1275             :         {
    1276             :                 .name = "fsctl_net_iface_info",
    1277             :                 .struct_size = sizeof(struct fsctl_net_iface_info ),
    1278             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_fsctl_net_iface_info,
    1279             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_fsctl_net_iface_info,
    1280             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_fsctl_net_iface_info,
    1281             :         },
    1282             :         { .name = NULL }
    1283             : };
    1284             : 
    1285             : static const struct ndr_interface_call netinterface_calls[] = {
    1286             :         { .name = NULL }
    1287             : };
    1288             : 
    1289             : static const char * const netinterface_endpoint_strings[] = {
    1290             :         "ncacn_np:[\\pipe\\netinterface]", 
    1291             : };
    1292             : 
    1293             : static const struct ndr_interface_string_array netinterface_endpoints = {
    1294             :         .count  = 1,
    1295             :         .names  = netinterface_endpoint_strings
    1296             : };
    1297             : 
    1298             : static const char * const netinterface_authservice_strings[] = {
    1299             :         "host", 
    1300             : };
    1301             : 
    1302             : static const struct ndr_interface_string_array netinterface_authservices = {
    1303             :         .count  = 1,
    1304             :         .names  = netinterface_authservice_strings
    1305             : };
    1306             : 
    1307             : 
    1308             : const struct ndr_interface_table ndr_table_netinterface = {
    1309             :         .name           = "netinterface",
    1310             :         .num_calls      = 0,
    1311             :         .calls          = netinterface_calls,
    1312             :         .num_public_structs     = 1,
    1313             :         .public_structs         = netinterface_public_structs,
    1314             :         .endpoints      = &netinterface_endpoints,
    1315             :         .authservices   = &netinterface_authservices
    1316             : };
    1317             : 
    1318             : #endif /* SKIP_NDR_TABLE_netinterface */
    1319         432 : _PUBLIC_ enum ndr_err_code ndr_push_file_alloced_range_buf(struct ndr_push *ndr, int ndr_flags, const struct file_alloced_range_buf *r)
    1320             : {
    1321         432 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1322         432 :         if (ndr_flags & NDR_SCALARS) {
    1323         432 :                 NDR_CHECK(ndr_push_align(ndr, 8));
    1324         432 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->file_off));
    1325         432 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->len));
    1326         432 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
    1327             :         }
    1328         432 :         if (ndr_flags & NDR_BUFFERS) {
    1329             :         }
    1330         432 :         return NDR_ERR_SUCCESS;
    1331             : }
    1332             : 
    1333         426 : _PUBLIC_ enum ndr_err_code ndr_pull_file_alloced_range_buf(struct ndr_pull *ndr, int ndr_flags, struct file_alloced_range_buf *r)
    1334             : {
    1335         426 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1336         426 :         if (ndr_flags & NDR_SCALARS) {
    1337         426 :                 NDR_CHECK(ndr_pull_align(ndr, 8));
    1338         426 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->file_off));
    1339         420 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->len));
    1340         420 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
    1341             :         }
    1342         420 :         if (ndr_flags & NDR_BUFFERS) {
    1343             :         }
    1344         420 :         return NDR_ERR_SUCCESS;
    1345             : }
    1346             : 
    1347           0 : static void ndr_print_flags_file_alloced_range_buf(struct ndr_print *ndr, const char *name, int unused, const struct file_alloced_range_buf *r)
    1348             : {
    1349           0 :         ndr_print_file_alloced_range_buf(ndr, name, r);
    1350           0 : }
    1351             : 
    1352           0 : _PUBLIC_ void ndr_print_file_alloced_range_buf(struct ndr_print *ndr, const char *name, const struct file_alloced_range_buf *r)
    1353             : {
    1354           0 :         ndr_print_struct(ndr, name, "file_alloced_range_buf");
    1355           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1356           0 :         ndr->depth++;
    1357           0 :         ndr_print_hyper(ndr, "file_off", r->file_off);
    1358           0 :         ndr_print_hyper(ndr, "len", r->len);
    1359           0 :         ndr->depth--;
    1360             : }
    1361             : 
    1362           0 : _PUBLIC_ enum ndr_err_code ndr_push_fsctl_query_alloced_ranges_req(struct ndr_push *ndr, int ndr_flags, const struct fsctl_query_alloced_ranges_req *r)
    1363             : {
    1364           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1365           0 :         if (ndr_flags & NDR_SCALARS) {
    1366           0 :                 NDR_CHECK(ndr_push_align(ndr, 8));
    1367           0 :                 NDR_CHECK(ndr_push_file_alloced_range_buf(ndr, NDR_SCALARS, &r->buf));
    1368           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
    1369             :         }
    1370           0 :         if (ndr_flags & NDR_BUFFERS) {
    1371             :         }
    1372           0 :         return NDR_ERR_SUCCESS;
    1373             : }
    1374             : 
    1375         240 : _PUBLIC_ enum ndr_err_code ndr_pull_fsctl_query_alloced_ranges_req(struct ndr_pull *ndr, int ndr_flags, struct fsctl_query_alloced_ranges_req *r)
    1376             : {
    1377         240 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1378         240 :         if (ndr_flags & NDR_SCALARS) {
    1379         240 :                 NDR_CHECK(ndr_pull_align(ndr, 8));
    1380         240 :                 NDR_CHECK(ndr_pull_file_alloced_range_buf(ndr, NDR_SCALARS, &r->buf));
    1381         234 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
    1382             :         }
    1383         234 :         if (ndr_flags & NDR_BUFFERS) {
    1384             :         }
    1385         234 :         return NDR_ERR_SUCCESS;
    1386             : }
    1387             : 
    1388           0 : static void ndr_print_flags_fsctl_query_alloced_ranges_req(struct ndr_print *ndr, const char *name, int unused, const struct fsctl_query_alloced_ranges_req *r)
    1389             : {
    1390           0 :         ndr_print_fsctl_query_alloced_ranges_req(ndr, name, r);
    1391           0 : }
    1392             : 
    1393           0 : _PUBLIC_ void ndr_print_fsctl_query_alloced_ranges_req(struct ndr_print *ndr, const char *name, const struct fsctl_query_alloced_ranges_req *r)
    1394             : {
    1395           0 :         ndr_print_struct(ndr, name, "fsctl_query_alloced_ranges_req");
    1396           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1397           0 :         ndr->depth++;
    1398           0 :         ndr_print_file_alloced_range_buf(ndr, "buf", &r->buf);
    1399           0 :         ndr->depth--;
    1400             : }
    1401             : 
    1402         168 : _PUBLIC_ enum ndr_err_code ndr_push_fsctl_query_alloced_ranges_rsp(struct ndr_push *ndr, int ndr_flags, const struct fsctl_query_alloced_ranges_rsp *r)
    1403             : {
    1404         168 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1405         168 :         if (ndr_flags & NDR_SCALARS) {
    1406         168 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    1407             :                 {
    1408         168 :                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
    1409         168 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    1410         168 :                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->far_buf_array));
    1411         168 :                         ndr->flags = _flags_save_DATA_BLOB;
    1412             :                 }
    1413         168 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    1414             :         }
    1415         168 :         if (ndr_flags & NDR_BUFFERS) {
    1416             :         }
    1417         168 :         return NDR_ERR_SUCCESS;
    1418             : }
    1419             : 
    1420           0 : _PUBLIC_ enum ndr_err_code ndr_pull_fsctl_query_alloced_ranges_rsp(struct ndr_pull *ndr, int ndr_flags, struct fsctl_query_alloced_ranges_rsp *r)
    1421             : {
    1422           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1423           0 :         if (ndr_flags & NDR_SCALARS) {
    1424           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    1425             :                 {
    1426           0 :                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
    1427           0 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    1428           0 :                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->far_buf_array));
    1429           0 :                         ndr->flags = _flags_save_DATA_BLOB;
    1430             :                 }
    1431           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    1432             :         }
    1433           0 :         if (ndr_flags & NDR_BUFFERS) {
    1434             :         }
    1435           0 :         return NDR_ERR_SUCCESS;
    1436             : }
    1437             : 
    1438           0 : static void ndr_print_flags_fsctl_query_alloced_ranges_rsp(struct ndr_print *ndr, const char *name, int unused, const struct fsctl_query_alloced_ranges_rsp *r)
    1439             : {
    1440           0 :         ndr_print_fsctl_query_alloced_ranges_rsp(ndr, name, r);
    1441           0 : }
    1442             : 
    1443           0 : _PUBLIC_ void ndr_print_fsctl_query_alloced_ranges_rsp(struct ndr_print *ndr, const char *name, const struct fsctl_query_alloced_ranges_rsp *r)
    1444             : {
    1445           0 :         ndr_print_struct(ndr, name, "fsctl_query_alloced_ranges_rsp");
    1446           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1447           0 :         ndr->depth++;
    1448             :         {
    1449           0 :                 uint32_t _flags_save_DATA_BLOB = ndr->flags;
    1450           0 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    1451           0 :                 ndr_print_DATA_BLOB(ndr, "far_buf_array", r->far_buf_array);
    1452           0 :                 ndr->flags = _flags_save_DATA_BLOB;
    1453             :         }
    1454           0 :         ndr->depth--;
    1455             : }
    1456             : 
    1457         194 : _PUBLIC_ enum ndr_err_code ndr_push_file_zero_data_info(struct ndr_push *ndr, int ndr_flags, const struct file_zero_data_info *r)
    1458             : {
    1459         194 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1460         194 :         if (ndr_flags & NDR_SCALARS) {
    1461         194 :                 NDR_CHECK(ndr_push_align(ndr, 8));
    1462         194 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->file_off));
    1463         194 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->beyond_final_zero));
    1464         194 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
    1465             :         }
    1466         194 :         if (ndr_flags & NDR_BUFFERS) {
    1467             :         }
    1468         194 :         return NDR_ERR_SUCCESS;
    1469             : }
    1470             : 
    1471         176 : _PUBLIC_ enum ndr_err_code ndr_pull_file_zero_data_info(struct ndr_pull *ndr, int ndr_flags, struct file_zero_data_info *r)
    1472             : {
    1473         176 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1474         176 :         if (ndr_flags & NDR_SCALARS) {
    1475         176 :                 NDR_CHECK(ndr_pull_align(ndr, 8));
    1476         176 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->file_off));
    1477         176 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->beyond_final_zero));
    1478         176 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
    1479             :         }
    1480         176 :         if (ndr_flags & NDR_BUFFERS) {
    1481             :         }
    1482         176 :         return NDR_ERR_SUCCESS;
    1483             : }
    1484             : 
    1485           0 : static void ndr_print_flags_file_zero_data_info(struct ndr_print *ndr, const char *name, int unused, const struct file_zero_data_info *r)
    1486             : {
    1487           0 :         ndr_print_file_zero_data_info(ndr, name, r);
    1488           0 : }
    1489             : 
    1490           0 : _PUBLIC_ void ndr_print_file_zero_data_info(struct ndr_print *ndr, const char *name, const struct file_zero_data_info *r)
    1491             : {
    1492           0 :         ndr_print_struct(ndr, name, "file_zero_data_info");
    1493           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1494           0 :         ndr->depth++;
    1495           0 :         ndr_print_hyper(ndr, "file_off", r->file_off);
    1496           0 :         ndr_print_hyper(ndr, "beyond_final_zero", r->beyond_final_zero);
    1497           0 :         ndr->depth--;
    1498             : }
    1499             : 
    1500           0 : _PUBLIC_ enum ndr_err_code ndr_push_fsctl_set_zero_data_req(struct ndr_push *ndr, int ndr_flags, const struct fsctl_set_zero_data_req *r)
    1501             : {
    1502           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1503           0 :         if (ndr_flags & NDR_SCALARS) {
    1504           0 :                 NDR_CHECK(ndr_push_align(ndr, 8));
    1505           0 :                 NDR_CHECK(ndr_push_file_zero_data_info(ndr, NDR_SCALARS, &r->info));
    1506           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
    1507             :         }
    1508           0 :         if (ndr_flags & NDR_BUFFERS) {
    1509             :         }
    1510           0 :         return NDR_ERR_SUCCESS;
    1511             : }
    1512             : 
    1513           0 : _PUBLIC_ enum ndr_err_code ndr_pull_fsctl_set_zero_data_req(struct ndr_pull *ndr, int ndr_flags, struct fsctl_set_zero_data_req *r)
    1514             : {
    1515           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1516           0 :         if (ndr_flags & NDR_SCALARS) {
    1517           0 :                 NDR_CHECK(ndr_pull_align(ndr, 8));
    1518           0 :                 NDR_CHECK(ndr_pull_file_zero_data_info(ndr, NDR_SCALARS, &r->info));
    1519           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
    1520             :         }
    1521           0 :         if (ndr_flags & NDR_BUFFERS) {
    1522             :         }
    1523           0 :         return NDR_ERR_SUCCESS;
    1524             : }
    1525             : 
    1526           0 : static void ndr_print_flags_fsctl_set_zero_data_req(struct ndr_print *ndr, const char *name, int unused, const struct fsctl_set_zero_data_req *r)
    1527             : {
    1528           0 :         ndr_print_fsctl_set_zero_data_req(ndr, name, r);
    1529           0 : }
    1530             : 
    1531           0 : _PUBLIC_ void ndr_print_fsctl_set_zero_data_req(struct ndr_print *ndr, const char *name, const struct fsctl_set_zero_data_req *r)
    1532             : {
    1533           0 :         ndr_print_struct(ndr, name, "fsctl_set_zero_data_req");
    1534           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1535           0 :         ndr->depth++;
    1536           0 :         ndr_print_file_zero_data_info(ndr, "info", &r->info);
    1537           0 :         ndr->depth--;
    1538             : }
    1539             : 
    1540             : #ifndef SKIP_NDR_TABLE_sparse
    1541             : static const struct ndr_interface_public_struct sparse_public_structs[] = {
    1542             :         {
    1543             :                 .name = "file_alloced_range_buf",
    1544             :                 .struct_size = sizeof(struct file_alloced_range_buf ),
    1545             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_file_alloced_range_buf,
    1546             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_file_alloced_range_buf,
    1547             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_file_alloced_range_buf,
    1548             :         },
    1549             :         {
    1550             :                 .name = "fsctl_query_alloced_ranges_req",
    1551             :                 .struct_size = sizeof(struct fsctl_query_alloced_ranges_req ),
    1552             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_fsctl_query_alloced_ranges_req,
    1553             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_fsctl_query_alloced_ranges_req,
    1554             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_fsctl_query_alloced_ranges_req,
    1555             :         },
    1556             :         {
    1557             :                 .name = "fsctl_query_alloced_ranges_rsp",
    1558             :                 .struct_size = sizeof(struct fsctl_query_alloced_ranges_rsp ),
    1559             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_fsctl_query_alloced_ranges_rsp,
    1560             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_fsctl_query_alloced_ranges_rsp,
    1561             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_fsctl_query_alloced_ranges_rsp,
    1562             :         },
    1563             :         {
    1564             :                 .name = "file_zero_data_info",
    1565             :                 .struct_size = sizeof(struct file_zero_data_info ),
    1566             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_file_zero_data_info,
    1567             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_file_zero_data_info,
    1568             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_file_zero_data_info,
    1569             :         },
    1570             :         {
    1571             :                 .name = "fsctl_set_zero_data_req",
    1572             :                 .struct_size = sizeof(struct fsctl_set_zero_data_req ),
    1573             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_fsctl_set_zero_data_req,
    1574             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_fsctl_set_zero_data_req,
    1575             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_fsctl_set_zero_data_req,
    1576             :         },
    1577             :         { .name = NULL }
    1578             : };
    1579             : 
    1580             : static const struct ndr_interface_call sparse_calls[] = {
    1581             :         { .name = NULL }
    1582             : };
    1583             : 
    1584             : static const char * const sparse_endpoint_strings[] = {
    1585             :         "ncacn_np:[\\pipe\\sparse]", 
    1586             : };
    1587             : 
    1588             : static const struct ndr_interface_string_array sparse_endpoints = {
    1589             :         .count  = 1,
    1590             :         .names  = sparse_endpoint_strings
    1591             : };
    1592             : 
    1593             : static const char * const sparse_authservice_strings[] = {
    1594             :         "host", 
    1595             : };
    1596             : 
    1597             : static const struct ndr_interface_string_array sparse_authservices = {
    1598             :         .count  = 1,
    1599             :         .names  = sparse_authservice_strings
    1600             : };
    1601             : 
    1602             : 
    1603             : const struct ndr_interface_table ndr_table_sparse = {
    1604             :         .name           = "sparse",
    1605             :         .num_calls      = 0,
    1606             :         .calls          = sparse_calls,
    1607             :         .num_public_structs     = 5,
    1608             :         .public_structs         = sparse_public_structs,
    1609             :         .endpoints      = &sparse_endpoints,
    1610             :         .authservices   = &sparse_authservices
    1611             : };
    1612             : 
    1613             : #endif /* SKIP_NDR_TABLE_sparse */
    1614           0 : _PUBLIC_ enum ndr_err_code ndr_push_network_resiliency_request(struct ndr_push *ndr, int ndr_flags, const struct network_resiliency_request *r)
    1615             : {
    1616           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1617           0 :         if (ndr_flags & NDR_SCALARS) {
    1618           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    1619           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timeout));
    1620           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
    1621           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    1622             :         }
    1623           0 :         if (ndr_flags & NDR_BUFFERS) {
    1624             :         }
    1625           0 :         return NDR_ERR_SUCCESS;
    1626             : }
    1627             : 
    1628           0 : _PUBLIC_ enum ndr_err_code ndr_pull_network_resiliency_request(struct ndr_pull *ndr, int ndr_flags, struct network_resiliency_request *r)
    1629             : {
    1630           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1631           0 :         if (ndr_flags & NDR_SCALARS) {
    1632           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    1633           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timeout));
    1634           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
    1635           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    1636             :         }
    1637           0 :         if (ndr_flags & NDR_BUFFERS) {
    1638             :         }
    1639           0 :         return NDR_ERR_SUCCESS;
    1640             : }
    1641             : 
    1642           0 : static void ndr_print_flags_network_resiliency_request(struct ndr_print *ndr, const char *name, int unused, const struct network_resiliency_request *r)
    1643             : {
    1644           0 :         ndr_print_network_resiliency_request(ndr, name, r);
    1645           0 : }
    1646             : 
    1647           0 : _PUBLIC_ void ndr_print_network_resiliency_request(struct ndr_print *ndr, const char *name, const struct network_resiliency_request *r)
    1648             : {
    1649           0 :         ndr_print_struct(ndr, name, "network_resiliency_request");
    1650           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1651           0 :         ndr->depth++;
    1652           0 :         ndr_print_uint32(ndr, "timeout", r->timeout);
    1653           0 :         ndr_print_uint32(ndr, "reserved", r->reserved);
    1654           0 :         ndr->depth--;
    1655             : }
    1656             : 
    1657             : #ifndef SKIP_NDR_TABLE_resiliency
    1658             : static const struct ndr_interface_public_struct resiliency_public_structs[] = {
    1659             :         {
    1660             :                 .name = "network_resiliency_request",
    1661             :                 .struct_size = sizeof(struct network_resiliency_request ),
    1662             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_network_resiliency_request,
    1663             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_network_resiliency_request,
    1664             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_network_resiliency_request,
    1665             :         },
    1666             :         { .name = NULL }
    1667             : };
    1668             : 
    1669             : static const struct ndr_interface_call resiliency_calls[] = {
    1670             :         { .name = NULL }
    1671             : };
    1672             : 
    1673             : static const char * const resiliency_endpoint_strings[] = {
    1674             :         "ncacn_np:[\\pipe\\resiliency]", 
    1675             : };
    1676             : 
    1677             : static const struct ndr_interface_string_array resiliency_endpoints = {
    1678             :         .count  = 1,
    1679             :         .names  = resiliency_endpoint_strings
    1680             : };
    1681             : 
    1682             : static const char * const resiliency_authservice_strings[] = {
    1683             :         "host", 
    1684             : };
    1685             : 
    1686             : static const struct ndr_interface_string_array resiliency_authservices = {
    1687             :         .count  = 1,
    1688             :         .names  = resiliency_authservice_strings
    1689             : };
    1690             : 
    1691             : 
    1692             : const struct ndr_interface_table ndr_table_resiliency = {
    1693             :         .name           = "resiliency",
    1694             :         .num_calls      = 0,
    1695             :         .calls          = resiliency_calls,
    1696             :         .num_public_structs     = 1,
    1697             :         .public_structs         = resiliency_public_structs,
    1698             :         .endpoints      = &resiliency_endpoints,
    1699             :         .authservices   = &resiliency_authservices
    1700             : };
    1701             : 
    1702             : #endif /* SKIP_NDR_TABLE_resiliency */
    1703           0 : _PUBLIC_ enum ndr_err_code ndr_push_file_level_trim_range(struct ndr_push *ndr, int ndr_flags, const struct file_level_trim_range *r)
    1704             : {
    1705           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1706           0 :         if (ndr_flags & NDR_SCALARS) {
    1707           0 :                 NDR_CHECK(ndr_push_align(ndr, 8));
    1708           0 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->off));
    1709           0 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->len));
    1710           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
    1711             :         }
    1712           0 :         if (ndr_flags & NDR_BUFFERS) {
    1713             :         }
    1714           0 :         return NDR_ERR_SUCCESS;
    1715             : }
    1716             : 
    1717           0 : _PUBLIC_ enum ndr_err_code ndr_pull_file_level_trim_range(struct ndr_pull *ndr, int ndr_flags, struct file_level_trim_range *r)
    1718             : {
    1719           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1720           0 :         if (ndr_flags & NDR_SCALARS) {
    1721           0 :                 NDR_CHECK(ndr_pull_align(ndr, 8));
    1722           0 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->off));
    1723           0 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->len));
    1724           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
    1725             :         }
    1726           0 :         if (ndr_flags & NDR_BUFFERS) {
    1727             :         }
    1728           0 :         return NDR_ERR_SUCCESS;
    1729             : }
    1730             : 
    1731           0 : static void ndr_print_flags_file_level_trim_range(struct ndr_print *ndr, const char *name, int unused, const struct file_level_trim_range *r)
    1732             : {
    1733           0 :         ndr_print_file_level_trim_range(ndr, name, r);
    1734           0 : }
    1735             : 
    1736           0 : _PUBLIC_ void ndr_print_file_level_trim_range(struct ndr_print *ndr, const char *name, const struct file_level_trim_range *r)
    1737             : {
    1738           0 :         ndr_print_struct(ndr, name, "file_level_trim_range");
    1739           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1740           0 :         ndr->depth++;
    1741           0 :         ndr_print_hyper(ndr, "off", r->off);
    1742           0 :         ndr_print_hyper(ndr, "len", r->len);
    1743           0 :         ndr->depth--;
    1744             : }
    1745             : 
    1746           0 : _PUBLIC_ enum ndr_err_code ndr_push_fsctl_file_level_trim_req(struct ndr_push *ndr, int ndr_flags, const struct fsctl_file_level_trim_req *r)
    1747             : {
    1748             :         uint32_t cntr_ranges_0;
    1749           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1750           0 :         if (ndr_flags & NDR_SCALARS) {
    1751           0 :                 NDR_CHECK(ndr_push_align(ndr, 8));
    1752           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->key));
    1753           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_ranges));
    1754           0 :                 for (cntr_ranges_0 = 0; cntr_ranges_0 < (r->num_ranges); cntr_ranges_0++) {
    1755           0 :                         NDR_CHECK(ndr_push_file_level_trim_range(ndr, NDR_SCALARS, &r->ranges[cntr_ranges_0]));
    1756             :                 }
    1757           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
    1758             :         }
    1759           0 :         if (ndr_flags & NDR_BUFFERS) {
    1760             :         }
    1761           0 :         return NDR_ERR_SUCCESS;
    1762             : }
    1763             : 
    1764           0 : _PUBLIC_ enum ndr_err_code ndr_pull_fsctl_file_level_trim_req(struct ndr_pull *ndr, int ndr_flags, struct fsctl_file_level_trim_req *r)
    1765             : {
    1766           0 :         uint32_t size_ranges_0 = 0;
    1767             :         uint32_t cntr_ranges_0;
    1768           0 :         TALLOC_CTX *_mem_save_ranges_0 = NULL;
    1769           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1770           0 :         if (ndr_flags & NDR_SCALARS) {
    1771           0 :                 NDR_CHECK(ndr_pull_align(ndr, 8));
    1772           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->key));
    1773           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_ranges));
    1774           0 :                 size_ranges_0 = r->num_ranges;
    1775           0 :                 NDR_PULL_ALLOC_N(ndr, r->ranges, size_ranges_0);
    1776           0 :                 _mem_save_ranges_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1777           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->ranges, 0);
    1778           0 :                 for (cntr_ranges_0 = 0; cntr_ranges_0 < (size_ranges_0); cntr_ranges_0++) {
    1779           0 :                         NDR_CHECK(ndr_pull_file_level_trim_range(ndr, NDR_SCALARS, &r->ranges[cntr_ranges_0]));
    1780             :                 }
    1781           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ranges_0, 0);
    1782           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
    1783             :         }
    1784           0 :         if (ndr_flags & NDR_BUFFERS) {
    1785             :         }
    1786           0 :         return NDR_ERR_SUCCESS;
    1787             : }
    1788             : 
    1789           0 : static void ndr_print_flags_fsctl_file_level_trim_req(struct ndr_print *ndr, const char *name, int unused, const struct fsctl_file_level_trim_req *r)
    1790             : {
    1791           0 :         ndr_print_fsctl_file_level_trim_req(ndr, name, r);
    1792           0 : }
    1793             : 
    1794           0 : _PUBLIC_ void ndr_print_fsctl_file_level_trim_req(struct ndr_print *ndr, const char *name, const struct fsctl_file_level_trim_req *r)
    1795             : {
    1796             :         uint32_t cntr_ranges_0;
    1797           0 :         ndr_print_struct(ndr, name, "fsctl_file_level_trim_req");
    1798           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1799           0 :         ndr->depth++;
    1800           0 :         ndr_print_uint32(ndr, "key", r->key);
    1801           0 :         ndr_print_uint32(ndr, "num_ranges", r->num_ranges);
    1802           0 :         ndr->print(ndr, "%s: ARRAY(%d)", "ranges", (int)r->num_ranges);
    1803           0 :         ndr->depth++;
    1804           0 :         for (cntr_ranges_0 = 0; cntr_ranges_0 < (r->num_ranges); cntr_ranges_0++) {
    1805           0 :                 ndr_print_file_level_trim_range(ndr, "ranges", &r->ranges[cntr_ranges_0]);
    1806             :         }
    1807           0 :         ndr->depth--;
    1808           0 :         ndr->depth--;
    1809             : }
    1810             : 
    1811           0 : _PUBLIC_ enum ndr_err_code ndr_push_fsctl_file_level_trim_rsp(struct ndr_push *ndr, int ndr_flags, const struct fsctl_file_level_trim_rsp *r)
    1812             : {
    1813           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1814           0 :         if (ndr_flags & NDR_SCALARS) {
    1815           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    1816           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_ranges_processed));
    1817           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    1818             :         }
    1819           0 :         if (ndr_flags & NDR_BUFFERS) {
    1820             :         }
    1821           0 :         return NDR_ERR_SUCCESS;
    1822             : }
    1823             : 
    1824           0 : _PUBLIC_ enum ndr_err_code ndr_pull_fsctl_file_level_trim_rsp(struct ndr_pull *ndr, int ndr_flags, struct fsctl_file_level_trim_rsp *r)
    1825             : {
    1826           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1827           0 :         if (ndr_flags & NDR_SCALARS) {
    1828           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    1829           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_ranges_processed));
    1830           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    1831             :         }
    1832           0 :         if (ndr_flags & NDR_BUFFERS) {
    1833             :         }
    1834           0 :         return NDR_ERR_SUCCESS;
    1835             : }
    1836             : 
    1837           0 : static void ndr_print_flags_fsctl_file_level_trim_rsp(struct ndr_print *ndr, const char *name, int unused, const struct fsctl_file_level_trim_rsp *r)
    1838             : {
    1839           0 :         ndr_print_fsctl_file_level_trim_rsp(ndr, name, r);
    1840           0 : }
    1841             : 
    1842           0 : _PUBLIC_ void ndr_print_fsctl_file_level_trim_rsp(struct ndr_print *ndr, const char *name, const struct fsctl_file_level_trim_rsp *r)
    1843             : {
    1844           0 :         ndr_print_struct(ndr, name, "fsctl_file_level_trim_rsp");
    1845           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1846           0 :         ndr->depth++;
    1847           0 :         ndr_print_uint32(ndr, "num_ranges_processed", r->num_ranges_processed);
    1848           0 :         ndr->depth--;
    1849             : }
    1850             : 
    1851             : #ifndef SKIP_NDR_TABLE_trim
    1852             : static const struct ndr_interface_public_struct trim_public_structs[] = {
    1853             :         {
    1854             :                 .name = "file_level_trim_range",
    1855             :                 .struct_size = sizeof(struct file_level_trim_range ),
    1856             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_file_level_trim_range,
    1857             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_file_level_trim_range,
    1858             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_file_level_trim_range,
    1859             :         },
    1860             :         {
    1861             :                 .name = "fsctl_file_level_trim_req",
    1862             :                 .struct_size = sizeof(struct fsctl_file_level_trim_req ),
    1863             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_fsctl_file_level_trim_req,
    1864             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_fsctl_file_level_trim_req,
    1865             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_fsctl_file_level_trim_req,
    1866             :         },
    1867             :         {
    1868             :                 .name = "fsctl_file_level_trim_rsp",
    1869             :                 .struct_size = sizeof(struct fsctl_file_level_trim_rsp ),
    1870             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_fsctl_file_level_trim_rsp,
    1871             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_fsctl_file_level_trim_rsp,
    1872             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_fsctl_file_level_trim_rsp,
    1873             :         },
    1874             :         { .name = NULL }
    1875             : };
    1876             : 
    1877             : static const struct ndr_interface_call trim_calls[] = {
    1878             :         { .name = NULL }
    1879             : };
    1880             : 
    1881             : static const char * const trim_endpoint_strings[] = {
    1882             :         "ncacn_np:[\\pipe\\trim]", 
    1883             : };
    1884             : 
    1885             : static const struct ndr_interface_string_array trim_endpoints = {
    1886             :         .count  = 1,
    1887             :         .names  = trim_endpoint_strings
    1888             : };
    1889             : 
    1890             : static const char * const trim_authservice_strings[] = {
    1891             :         "host", 
    1892             : };
    1893             : 
    1894             : static const struct ndr_interface_string_array trim_authservices = {
    1895             :         .count  = 1,
    1896             :         .names  = trim_authservice_strings
    1897             : };
    1898             : 
    1899             : 
    1900             : const struct ndr_interface_table ndr_table_trim = {
    1901             :         .name           = "trim",
    1902             :         .num_calls      = 0,
    1903             :         .calls          = trim_calls,
    1904             :         .num_public_structs     = 3,
    1905             :         .public_structs         = trim_public_structs,
    1906             :         .endpoints      = &trim_endpoints,
    1907             :         .authservices   = &trim_authservices
    1908             : };
    1909             : 
    1910             : #endif /* SKIP_NDR_TABLE_trim */

Generated by: LCOV version 1.13