bin.gen_ndr/default/librpc/gen_ndr/ndr_ioctl.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "bin/default/librpc/gen_ndr/ndr_ioctl.h"
   5
   6 _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         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
   9         if (ndr_flags & NDR_SCALARS) {
  10                 NDR_CHECK(ndr_push_align(ndr, 4));
  11                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->resume_key, 24));
  12                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->context_len));
  13                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->context, 4));
  14                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
  15         }
  16         if (ndr_flags & NDR_BUFFERS) {
  17         }
  18         return NDR_ERR_SUCCESS;
  19 }
  20
  21 _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         uint32_t size_resume_key_0 = 0;
  24         uint32_t size_context_0 = 0;
  25         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
  26         if (ndr_flags & NDR_SCALARS) {
  27                 NDR_CHECK(ndr_pull_align(ndr, 4));
  28                 size_resume_key_0 = 24;
  29                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->resume_key, size_resume_key_0));
  30                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->context_len));
  31                 size_context_0 = 4;
  32                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->context, size_context_0));
  33                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
  34         }
  35         if (ndr_flags & NDR_BUFFERS) {
  36         }
  37         return NDR_ERR_SUCCESS;
  38 }
  39
  40 _PUBLIC_ void ndr_print_req_resume_key_rsp(struct ndr_print *ndr, const char *name, const struct req_resume_key_rsp *r)
  41 {
  42         ndr_print_struct(ndr, name, "req_resume_key_rsp");
  43         if (r == NULL) { ndr_print_null(ndr); return; }
  44         ndr->depth++;
  45         ndr_print_array_uint8(ndr, "resume_key", r->resume_key, 24);
  46         ndr_print_uint32(ndr, "context_len", r->context_len);
  47         ndr_print_array_uint8(ndr, "context", r->context, 4);
  48         ndr->depth--;
  49 }
  50
  51 static enum ndr_err_code ndr_push_srv_copychunk(struct ndr_push *ndr, int ndr_flags, const struct srv_copychunk *r)
  52 {
  53         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
  54         if (ndr_flags & NDR_SCALARS) {
  55                 NDR_CHECK(ndr_push_align(ndr, 8));
  56                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->source_off));
  57                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->target_off));
  58                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
  59                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
  60                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
  61         }
  62         if (ndr_flags & NDR_BUFFERS) {
  63         }
  64         return NDR_ERR_SUCCESS;
  65 }
  66
  67 static enum ndr_err_code ndr_pull_srv_copychunk(struct ndr_pull *ndr, int ndr_flags, struct srv_copychunk *r)
  68 {
  69         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
  70         if (ndr_flags & NDR_SCALARS) {
  71                 NDR_CHECK(ndr_pull_align(ndr, 8));
  72                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->source_off));
  73                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->target_off));
  74                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
  75                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
  76                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
  77         }
  78         if (ndr_flags & NDR_BUFFERS) {
  79         }
  80         return NDR_ERR_SUCCESS;
  81 }
  82
  83 _PUBLIC_ void ndr_print_srv_copychunk(struct ndr_print *ndr, const char *name, const struct srv_copychunk *r)
  84 {
  85         ndr_print_struct(ndr, name, "srv_copychunk");
  86         if (r == NULL) { ndr_print_null(ndr); return; }
  87         ndr->depth++;
  88         ndr_print_hyper(ndr, "source_off", r->source_off);
  89         ndr_print_hyper(ndr, "target_off", r->target_off);
  90         ndr_print_uint32(ndr, "length", r->length);
  91         ndr_print_uint32(ndr, "reserved", r->reserved);
  92         ndr->depth--;
  93 }
  94
  95 _PUBLIC_ enum ndr_err_code ndr_push_srv_copychunk_copy(struct ndr_push *ndr, int ndr_flags, const struct srv_copychunk_copy *r)
  96 {
  97         uint32_t cntr_chunks_0;
  98         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
  99         if (ndr_flags & NDR_SCALARS) {
 100                 NDR_CHECK(ndr_push_align(ndr, 8));
 101                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->source_key, 24));
 102                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chunk_count));
 103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
 104                 for (cntr_chunks_0 = 0; cntr_chunks_0 < r->chunk_count; cntr_chunks_0++) {
 105                         NDR_CHECK(ndr_push_srv_copychunk(ndr, NDR_SCALARS, &r->chunks[cntr_chunks_0]));
 106                 }
 107                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 108         }
 109         if (ndr_flags & NDR_BUFFERS) {
 110         }
 111         return NDR_ERR_SUCCESS;
 112 }
 113
 114 _PUBLIC_ enum ndr_err_code ndr_pull_srv_copychunk_copy(struct ndr_pull *ndr, int ndr_flags, struct srv_copychunk_copy *r)
 115 {
 116         uint32_t size_source_key_0 = 0;
 117         uint32_t size_chunks_0 = 0;
 118         uint32_t cntr_chunks_0;
 119         TALLOC_CTX *_mem_save_chunks_0;
 120         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 121         if (ndr_flags & NDR_SCALARS) {
 122                 NDR_CHECK(ndr_pull_align(ndr, 8));
 123                 size_source_key_0 = 24;
 124                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->source_key, size_source_key_0));
 125                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chunk_count));
 126                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
 127                 size_chunks_0 = r->chunk_count;
 128                 NDR_PULL_ALLOC_N(ndr, r->chunks, size_chunks_0);
 129                 _mem_save_chunks_0 = NDR_PULL_GET_MEM_CTX(ndr);
 130                 NDR_PULL_SET_MEM_CTX(ndr, r->chunks, 0);
 131                 for (cntr_chunks_0 = 0; cntr_chunks_0 < size_chunks_0; cntr_chunks_0++) {
 132                         NDR_CHECK(ndr_pull_srv_copychunk(ndr, NDR_SCALARS, &r->chunks[cntr_chunks_0]));
 133                 }
 134                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_chunks_0, 0);
 135                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 136         }
 137         if (ndr_flags & NDR_BUFFERS) {
 138         }
 139         return NDR_ERR_SUCCESS;
 140 }
 141
 142 _PUBLIC_ void ndr_print_srv_copychunk_copy(struct ndr_print *ndr, const char *name, const struct srv_copychunk_copy *r)
 143 {
 144         uint32_t cntr_chunks_0;
 145         ndr_print_struct(ndr, name, "srv_copychunk_copy");
 146         if (r == NULL) { ndr_print_null(ndr); return; }
 147         ndr->depth++;
 148         ndr_print_array_uint8(ndr, "source_key", r->source_key, 24);
 149         ndr_print_uint32(ndr, "chunk_count", r->chunk_count);
 150         ndr_print_uint32(ndr, "reserved", r->reserved);
 151         ndr->print(ndr, "%s: ARRAY(%d)", "chunks", (int)r->chunk_count);
 152         ndr->depth++;
 153         for (cntr_chunks_0=0;cntr_chunks_0<r->chunk_count;cntr_chunks_0++) {
 154                 ndr_print_srv_copychunk(ndr, "chunks", &r->chunks[cntr_chunks_0]);
 155         }
 156         ndr->depth--;
 157         ndr->depth--;
 158 }
 159
 160 _PUBLIC_ enum ndr_err_code ndr_push_srv_copychunk_rsp(struct ndr_push *ndr, int ndr_flags, const struct srv_copychunk_rsp *r)
 161 {
 162         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 163         if (ndr_flags & NDR_SCALARS) {
 164                 NDR_CHECK(ndr_push_align(ndr, 4));
 165                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chunks_written));
 166                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chunk_bytes_written));
 167                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes_written));
 168                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 169         }
 170         if (ndr_flags & NDR_BUFFERS) {
 171         }
 172         return NDR_ERR_SUCCESS;
 173 }
 174
 175 _PUBLIC_ enum ndr_err_code ndr_pull_srv_copychunk_rsp(struct ndr_pull *ndr, int ndr_flags, struct srv_copychunk_rsp *r)
 176 {
 177         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 178         if (ndr_flags & NDR_SCALARS) {
 179                 NDR_CHECK(ndr_pull_align(ndr, 4));
 180                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chunks_written));
 181                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chunk_bytes_written));
 182                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes_written));
 183                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 184         }
 185         if (ndr_flags & NDR_BUFFERS) {
 186         }
 187         return NDR_ERR_SUCCESS;
 188 }
 189
 190 _PUBLIC_ void ndr_print_srv_copychunk_rsp(struct ndr_print *ndr, const char *name, const struct srv_copychunk_rsp *r)
 191 {
 192         ndr_print_struct(ndr, name, "srv_copychunk_rsp");
 193         if (r == NULL) { ndr_print_null(ndr); return; }
 194         ndr->depth++;
 195         ndr_print_uint32(ndr, "chunks_written", r->chunks_written);
 196         ndr_print_uint32(ndr, "chunk_bytes_written", r->chunk_bytes_written);
 197         ndr_print_uint32(ndr, "total_bytes_written", r->total_bytes_written);
 198         ndr->depth--;
 199 }
 200
 201 _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)
 202 {
 203         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 204         if (ndr_flags & NDR_SCALARS) {
 205                 NDR_CHECK(ndr_push_align(ndr, 8));
 206                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 207                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
 208                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maximum_token_lifetime));
 209                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->default_token_lifetime));
 210                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->maximum_xfer_size));
 211                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->optimal_xfer_count));
 212                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maximum_data_descriptors));
 213                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maximum_xfer_length_per_descriptor));
 214                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->optimal_xfer_length_per_descriptor));
 215                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->optimal_xfer_length_granularity));
 216                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->reserved, 2));
 217                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 218         }
 219         if (ndr_flags & NDR_BUFFERS) {
 220         }
 221         return NDR_ERR_SUCCESS;
 222 }
 223
 224 _PUBLIC_ enum ndr_err_code ndr_pull_device_copy_offload_descriptor(struct ndr_pull *ndr, int ndr_flags, struct device_copy_offload_descriptor *r)
 225 {
 226         uint32_t size_reserved_0 = 0;
 227         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 228         if (ndr_flags & NDR_SCALARS) {
 229                 NDR_CHECK(ndr_pull_align(ndr, 8));
 230                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 231                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
 232                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maximum_token_lifetime));
 233                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->default_token_lifetime));
 234                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->maximum_xfer_size));
 235                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->optimal_xfer_count));
 236                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maximum_data_descriptors));
 237                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maximum_xfer_length_per_descriptor));
 238                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->optimal_xfer_length_per_descriptor));
 239                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->optimal_xfer_length_granularity));
 240                 size_reserved_0 = 2;
 241                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->reserved, size_reserved_0));
 242                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 243         }
 244         if (ndr_flags & NDR_BUFFERS) {
 245         }
 246         return NDR_ERR_SUCCESS;
 247 }
 248
 249 _PUBLIC_ void ndr_print_device_copy_offload_descriptor(struct ndr_print *ndr, const char *name, const struct device_copy_offload_descriptor *r)
 250 {
 251         ndr_print_struct(ndr, name, "device_copy_offload_descriptor");
 252         if (r == NULL) { ndr_print_null(ndr); return; }
 253         ndr->depth++;
 254         ndr_print_uint32(ndr, "version", r->version);
 255         ndr_print_uint32(ndr, "size", r->size);
 256         ndr_print_uint32(ndr, "maximum_token_lifetime", r->maximum_token_lifetime);
 257         ndr_print_uint32(ndr, "default_token_lifetime", r->default_token_lifetime);
 258         ndr_print_hyper(ndr, "maximum_xfer_size", r->maximum_xfer_size);
 259         ndr_print_hyper(ndr, "optimal_xfer_count", r->optimal_xfer_count);
 260         ndr_print_uint32(ndr, "maximum_data_descriptors", r->maximum_data_descriptors);
 261         ndr_print_uint32(ndr, "maximum_xfer_length_per_descriptor", r->maximum_xfer_length_per_descriptor);
 262         ndr_print_uint32(ndr, "optimal_xfer_length_per_descriptor", r->optimal_xfer_length_per_descriptor);
 263         ndr_print_uint16(ndr, "optimal_xfer_length_granularity", r->optimal_xfer_length_granularity);
 264         ndr_print_array_uint8(ndr, "reserved", r->reserved, 2);
 265         ndr->depth--;
 266 }
 267
 268 _PUBLIC_ enum ndr_err_code ndr_push_storage_offload_token(struct ndr_push *ndr, int ndr_flags, const struct storage_offload_token *r)
 269 {
 270         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 271         if (ndr_flags & NDR_SCALARS) {
 272                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->token_id_len));
 273                 NDR_CHECK(ndr_push_align(ndr, 4));
 274                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->token_type));
 275                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->reserved, 2));
 276                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->token_id_len));
 277                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->token, r->token_id_len));
 278                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 279         }
 280         if (ndr_flags & NDR_BUFFERS) {
 281         }
 282         return NDR_ERR_SUCCESS;
 283 }
 284
 285 _PUBLIC_ enum ndr_err_code ndr_pull_storage_offload_token(struct ndr_pull *ndr, int ndr_flags, struct storage_offload_token *r)
 286 {
 287         uint32_t size_reserved_0 = 0;
 288         uint32_t size_token_0 = 0;
 289         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 290         if (ndr_flags & NDR_SCALARS) {
 291                 NDR_CHECK(ndr_pull_array_size(ndr, &r->token));
 292                 NDR_CHECK(ndr_pull_align(ndr, 4));
 293                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->token_type));
 294                 size_reserved_0 = 2;
 295                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->reserved, size_reserved_0));
 296                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->token_id_len));
 297                 size_token_0 = ndr_get_array_size(ndr, &r->token);
 298                 NDR_PULL_ALLOC_N(ndr, r->token, size_token_0);
 299                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->token, size_token_0));
 300                 if (r->token) {
 301                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->token, r->token_id_len));
 302                 }
 303                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 304         }
 305         if (ndr_flags & NDR_BUFFERS) {
 306         }
 307         return NDR_ERR_SUCCESS;
 308 }
 309
 310 _PUBLIC_ void ndr_print_storage_offload_token(struct ndr_print *ndr, const char *name, const struct storage_offload_token *r)
 311 {
 312         ndr_print_struct(ndr, name, "storage_offload_token");
 313         if (r == NULL) { ndr_print_null(ndr); return; }
 314         ndr->depth++;
 315         ndr_print_uint32(ndr, "token_type", r->token_type);
 316         ndr_print_array_uint8(ndr, "reserved", r->reserved, 2);
 317         ndr_print_uint16(ndr, "token_id_len", r->token_id_len);
 318         ndr_print_array_uint8(ndr, "token", r->token, r->token_id_len);
 319         ndr->depth--;
 320 }
 321
 322 _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)
 323 {
 324         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 325         if (ndr_flags & NDR_SCALARS) {
 326                 NDR_CHECK(ndr_push_align(ndr, 8));
 327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
 328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
 329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->token_time_to_live));
 330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
 331                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->file_offset));
 332                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->length));
 333                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 334         }
 335         if (ndr_flags & NDR_BUFFERS) {
 336         }
 337         return NDR_ERR_SUCCESS;
 338 }
 339
 340 _PUBLIC_ enum ndr_err_code ndr_pull_fsctl_offload_read_input(struct ndr_pull *ndr, int ndr_flags, struct fsctl_offload_read_input *r)
 341 {
 342         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 343         if (ndr_flags & NDR_SCALARS) {
 344                 NDR_CHECK(ndr_pull_align(ndr, 8));
 345                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
 346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
 347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->token_time_to_live));
 348                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
 349                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->file_offset));
 350                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->length));
 351                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 352         }
 353         if (ndr_flags & NDR_BUFFERS) {
 354         }
 355         return NDR_ERR_SUCCESS;
 356 }
 357
 358 _PUBLIC_ void ndr_print_fsctl_offload_read_input(struct ndr_print *ndr, const char *name, const struct fsctl_offload_read_input *r)
 359 {
 360         ndr_print_struct(ndr, name, "fsctl_offload_read_input");
 361         if (r == NULL) { ndr_print_null(ndr); return; }
 362         ndr->depth++;
 363         ndr_print_uint32(ndr, "size", r->size);
 364         ndr_print_uint32(ndr, "flags", r->flags);
 365         ndr_print_uint32(ndr, "token_time_to_live", r->token_time_to_live);
 366         ndr_print_uint32(ndr, "reserved", r->reserved);
 367         ndr_print_hyper(ndr, "file_offset", r->file_offset);
 368         ndr_print_hyper(ndr, "length", r->length);
 369         ndr->depth--;
 370 }
 371
 372 _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)
 373 {
 374         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 375         if (ndr_flags & NDR_SCALARS) {
 376                 NDR_CHECK(ndr_push_align(ndr, 8));
 377                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
 378                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
 379                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->xfer_length));
 380                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->token, 512));
 381                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 382         }
 383         if (ndr_flags & NDR_BUFFERS) {
 384         }
 385         return NDR_ERR_SUCCESS;
 386 }
 387
 388 _PUBLIC_ enum ndr_err_code ndr_pull_fsctl_offload_read_output(struct ndr_pull *ndr, int ndr_flags, struct fsctl_offload_read_output *r)
 389 {
 390         uint32_t size_token_0 = 0;
 391         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 392         if (ndr_flags & NDR_SCALARS) {
 393                 NDR_CHECK(ndr_pull_align(ndr, 8));
 394                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
 395                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
 396                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->xfer_length));
 397                 size_token_0 = 512;
 398                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->token, size_token_0));
 399                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 400         }
 401         if (ndr_flags & NDR_BUFFERS) {
 402         }
 403         return NDR_ERR_SUCCESS;
 404 }
 405
 406 _PUBLIC_ void ndr_print_fsctl_offload_read_output(struct ndr_print *ndr, const char *name, const struct fsctl_offload_read_output *r)
 407 {
 408         ndr_print_struct(ndr, name, "fsctl_offload_read_output");
 409         if (r == NULL) { ndr_print_null(ndr); return; }
 410         ndr->depth++;
 411         ndr_print_uint32(ndr, "size", r->size);
 412         ndr_print_uint32(ndr, "flags", r->flags);
 413         ndr_print_hyper(ndr, "xfer_length", r->xfer_length);
 414         ndr_print_array_uint8(ndr, "token", r->token, 512);
 415         ndr->depth--;
 416 }
 417
 418 _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)
 419 {
 420         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 421         if (ndr_flags & NDR_SCALARS) {
 422                 NDR_CHECK(ndr_push_align(ndr, 8));
 423                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
 424                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
 425                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->file_offset));
 426                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->copy_length));
 427                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->xfer_offset));
 428                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->token, 512));
 429                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 430         }
 431         if (ndr_flags & NDR_BUFFERS) {
 432         }
 433         return NDR_ERR_SUCCESS;
 434 }
 435
 436 _PUBLIC_ enum ndr_err_code ndr_pull_fsctl_offload_write_input(struct ndr_pull *ndr, int ndr_flags, struct fsctl_offload_write_input *r)
 437 {
 438         uint32_t size_token_0 = 0;
 439         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 440         if (ndr_flags & NDR_SCALARS) {
 441                 NDR_CHECK(ndr_pull_align(ndr, 8));
 442                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
 443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
 444                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->file_offset));
 445                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->copy_length));
 446                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->xfer_offset));
 447                 size_token_0 = 512;
 448                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->token, size_token_0));
 449                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 450         }
 451         if (ndr_flags & NDR_BUFFERS) {
 452         }
 453         return NDR_ERR_SUCCESS;
 454 }
 455
 456 _PUBLIC_ void ndr_print_fsctl_offload_write_input(struct ndr_print *ndr, const char *name, const struct fsctl_offload_write_input *r)
 457 {
 458         ndr_print_struct(ndr, name, "fsctl_offload_write_input");
 459         if (r == NULL) { ndr_print_null(ndr); return; }
 460         ndr->depth++;
 461         ndr_print_uint32(ndr, "size", r->size);
 462         ndr_print_uint32(ndr, "flags", r->flags);
 463         ndr_print_hyper(ndr, "file_offset", r->file_offset);
 464         ndr_print_hyper(ndr, "copy_length", r->copy_length);
 465         ndr_print_hyper(ndr, "xfer_offset", r->xfer_offset);
 466         ndr_print_array_uint8(ndr, "token", r->token, 512);
 467         ndr->depth--;
 468 }
 469
 470 _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)
 471 {
 472         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 473         if (ndr_flags & NDR_SCALARS) {
 474                 NDR_CHECK(ndr_push_align(ndr, 8));
 475                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
 476                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
 477                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->length_written));
 478                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 479         }
 480         if (ndr_flags & NDR_BUFFERS) {
 481         }
 482         return NDR_ERR_SUCCESS;
 483 }
 484
 485 _PUBLIC_ enum ndr_err_code ndr_pull_fsctl_offload_write_output(struct ndr_pull *ndr, int ndr_flags, struct fsctl_offload_write_output *r)
 486 {
 487         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 488         if (ndr_flags & NDR_SCALARS) {
 489                 NDR_CHECK(ndr_pull_align(ndr, 8));
 490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
 491                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
 492                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->length_written));
 493                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 494         }
 495         if (ndr_flags & NDR_BUFFERS) {
 496         }
 497         return NDR_ERR_SUCCESS;
 498 }
 499
 500 _PUBLIC_ void ndr_print_fsctl_offload_write_output(struct ndr_print *ndr, const char *name, const struct fsctl_offload_write_output *r)
 501 {
 502         ndr_print_struct(ndr, name, "fsctl_offload_write_output");
 503         if (r == NULL) { ndr_print_null(ndr); return; }
 504         ndr->depth++;
 505         ndr_print_uint32(ndr, "size", r->size);
 506         ndr_print_uint32(ndr, "flags", r->flags);
 507         ndr_print_hyper(ndr, "length_written", r->length_written);
 508         ndr->depth--;
 509 }
 510
 511 _PUBLIC_ enum ndr_err_code ndr_push_compression_state(struct ndr_push *ndr, int ndr_flags, const struct compression_state *r)
 512 {
 513         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 514         if (ndr_flags & NDR_SCALARS) {
 515                 NDR_CHECK(ndr_push_align(ndr, 2));
 516                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->format));
 517                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
 518         }
 519         if (ndr_flags & NDR_BUFFERS) {
 520         }
 521         return NDR_ERR_SUCCESS;
 522 }
 523
 524 _PUBLIC_ enum ndr_err_code ndr_pull_compression_state(struct ndr_pull *ndr, int ndr_flags, struct compression_state *r)
 525 {
 526         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 527         if (ndr_flags & NDR_SCALARS) {
 528                 NDR_CHECK(ndr_pull_align(ndr, 2));
 529                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->format));
 530                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
 531         }
 532         if (ndr_flags & NDR_BUFFERS) {
 533         }
 534         return NDR_ERR_SUCCESS;
 535 }
 536
 537 _PUBLIC_ void ndr_print_compression_state(struct ndr_print *ndr, const char *name, const struct compression_state *r)
 538 {
 539         ndr_print_struct(ndr, name, "compression_state");
 540         if (r == NULL) { ndr_print_null(ndr); return; }
 541         ndr->depth++;
 542         ndr_print_uint16(ndr, "format", r->format);
 543         ndr->depth--;
 544 }
 545