ReactOS  0.4.13-dev-482-ge57f103
nfs41_xdr.c
Go to the documentation of this file.
1 /* NFSv4.1 client for Windows
2  * Copyright 2012 The Regents of the University of Michigan
3  *
4  * Olga Kornievskaia <aglo@umich.edu>
5  * Casey Bodley <cbodley@umich.edu>
6  *
7  * This library is free software; you can redistribute it and/or modify it
8  * under the terms of the GNU Lesser General Public License as published by
9  * the Free Software Foundation; either version 2.1 of the License, or (at
10  * your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful, but
13  * without any warranty; without even the implied warranty of merchantability
14  * or fitness for a particular purpose. See the GNU Lesser General Public
15  * License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public License
18  * along with this library; if not, write to the Free Software Foundation,
19  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA
20  */
21 
22 #include <windows.h>
23 #include <strsafe.h>
24 
25 #include "nfs41_compound.h"
26 #include "nfs41_ops.h"
27 #include "nfs41_xdr.h"
28 #include "util.h"
29 #include "daemon_debug.h"
30 #include "rpc/rpc.h"
31 
33  fattr4 *attrs,
35 
36 static __inline int unexpected_op(uint32_t op, uint32_t expected)
37 {
38  if (op == expected)
39  return 0;
40 
41  eprintf("Op table mismatch. Got %s (%d), expected %s (%d).\n",
44  return 1;
45 }
46 
47 /* typedef uint32_t bitmap4<> */
49  XDR *xdr,
50  bitmap4 *bitmap)
51 {
52  uint32_t i;
53 
54  if (xdr->x_op == XDR_ENCODE) {
55  if (bitmap->count > 3) {
56  eprintf("encode_bitmap4: count (%d) must be <= 3\n",
57  bitmap->count);
58  return FALSE;
59  }
60  if (!xdr_u_int32_t(xdr, &bitmap->count))
61  return FALSE;
62 
63  for (i = 0; i < bitmap->count; i++)
64  if (!xdr_u_int32_t(xdr, &bitmap->arr[i]))
65  return FALSE;
66 
67  } else if (xdr->x_op == XDR_DECODE) {
68  if (!xdr_u_int32_t(xdr, &bitmap->count))
69  return FALSE;
70  if (bitmap->count > 3) {
71  eprintf("decode_bitmap4: count (%d) must be <= 3\n",
72  bitmap->count);
73  return FALSE;
74  }
75 
76  for (i = 0; i < bitmap->count; i++)
77  if (!xdr_u_int32_t(xdr, &bitmap->arr[i]))
78  return FALSE;
79  } else
80  return FALSE;
81 
82  return TRUE;
83 }
84 
85 /* nfstime4 */
87  XDR *xdr,
88  nfstime4 *nt)
89 {
90  if (!xdr_hyper(xdr, &nt->seconds))
91  return FALSE;
92 
93  return xdr_u_int32_t(xdr, &nt->nseconds);
94 }
95 
96 
97 /* settime4 */
99  nfstime4 *newtime,
100  const nfstime4 *time_delta)
101 {
104  /* get the absolute difference between current and newtime */
105  nfstime_diff(&current, newtime, &current);
107  /* compare the difference with time_delta */
108  nfstime_diff(time_delta, &current, &current);
109  /* use client time if diff > delta (i.e. time_delta - current < 0) */
110  return current.seconds < 0 ? SET_TO_CLIENT_TIME4 : SET_TO_SERVER_TIME4;
111 }
112 
114  XDR *xdr,
115  nfstime4 *nt,
116  const nfstime4 *time_delta)
117 {
118  uint32_t how = settime_how(nt, time_delta);
119 
120  if (xdr->x_op != XDR_ENCODE) /* not used for decode */
121  return FALSE;
122 
123  if (!xdr_u_int32_t(xdr, &how))
124  return FALSE;
125 
126  if (how == SET_TO_CLIENT_TIME4)
127  return xdr_nfstime4(xdr, nt);
128 
129  return TRUE;
130 }
131 
132 /* stateid4 */
134  XDR *xdr,
135  stateid4 *si)
136 {
137  if (!xdr_u_int32_t(xdr, &si->seqid))
138  return FALSE;
139 
140  return xdr_opaque(xdr, (char *)si->other, NFS4_STATEID_OTHER);
141 }
142 
143 /* fattr4 */
145  XDR *xdr,
146  fattr4 *fattr)
147 {
148  unsigned char *attr_vals = fattr->attr_vals;
149 
150  if (!xdr_bitmap4(xdr, &fattr->attrmask))
151  return FALSE;
152 
153  return xdr_bytes(xdr, (char **)&attr_vals, &fattr->attr_vals_len, NFS4_OPAQUE_LIMIT);
154 }
155 
156 /* nfs41_fh */
157 static bool_t xdr_fh(
158  XDR *xdr,
159  nfs41_fh *fh)
160 {
161  unsigned char *pfh = fh->fh;
162  return xdr_bytes(xdr, (char **)&pfh, &fh->len, NFS4_FHSIZE);
163 }
164 
165 /* nfs41_fsid */
167  XDR *xdr,
168  nfs41_fsid *fsid)
169 {
170  if (!xdr_u_hyper(xdr, &fsid->major))
171  return FALSE;
172 
173  return xdr_u_hyper(xdr, &fsid->minor);
174 }
175 
176 
177 /* nfs41_component */
179  XDR *xdr,
180  const nfs41_component *component)
181 {
182  uint32_t len = component->len;
183  return xdr_bytes(xdr, (char **)&component->name, &len, NFS4_OPAQUE_LIMIT);
184 }
185 
187  XDR *xdr,
188  nfs41_component *component)
189 {
190  bool_t result;
191  uint32_t len;
192 
193  result = xdr_bytes(xdr, (char **)&component->name, &len, NFS4_OPAQUE_LIMIT);
194  component->len = (result == FALSE) ? 0 : (unsigned short)len;
195  return result;
196 }
197 
198 
199 /* state_owner4 */
201  XDR *xdr,
202  state_owner4 *so)
203 {
204  u_quad_t clientid = 0;
205  unsigned char *owner = so->owner;
206 
207  /* 18.16.3. "The client can set the clientid field to any value and
208  * the server MUST ignore it. Instead the server MUST derive the
209  * client ID from the session ID of the SEQUENCE operation of the
210  * COMPOUND request. */
211  if (xdr->x_op == XDR_ENCODE) {
212  if (!xdr_u_hyper(xdr, &clientid)) /* clientid = 0 */
213  return FALSE;
214  } else if (xdr->x_op == XDR_DECODE) {
215  if (!xdr_u_hyper(xdr, &clientid))
216  return FALSE;
217  } else return FALSE;
218 
219  return xdr_bytes(xdr, (char **)&owner, &so->owner_len, NFS4_OPAQUE_LIMIT);
220 }
221 
223  XDR *xdr,
224  uint32_t *layout_type)
225 {
226  u_int32_t i, count, type;
227 
228  if (xdr->x_op != XDR_DECODE) {
229  eprintf("xdr_layout_types: xdr->x_op is not XDR_DECODE! "
230  "x_op %d not supported.\n", xdr->x_op);
231  return FALSE;
232  }
233 
234  *layout_type = 0;
235 
236  if (!xdr_u_int32_t(xdr, &count))
237  return FALSE;
238 
239  for (i = 0; i < count; i++) {
240  if (!xdr_u_int32_t(xdr, &type))
241  return FALSE;
242 
243  *layout_type |= 1 << (type - 1);
244  }
245  return TRUE;
246 }
247 
249  XDR *xdr,
251 {
252  bitmap4 bitmap;
253 
254  if (!xdr_u_int32_t(xdr, &item->type))
255  return FALSE;
256 
257  if (!xdr_bitmap4(xdr, &bitmap))
258  return FALSE;
259 
260  if (!xdr_u_int32_t(xdr, &bitmap.count))
261  return FALSE;
262 
263  if (bitmap.count) {
264  if (bitmap.arr[0] & 0x1 && !xdr_u_hyper(xdr, &item->hints[0]))
265  return FALSE;
266  if (bitmap.arr[0] & 0x2 && !xdr_u_hyper(xdr, &item->hints[1]))
267  return FALSE;
268  if (bitmap.arr[0] & 0x4 && !xdr_u_hyper(xdr, &item->hints[2]))
269  return FALSE;
270  if (bitmap.arr[0] & 0x8 && !xdr_u_hyper(xdr, &item->hints[3]))
271  return FALSE;
272  }
273  return TRUE;
274 }
275 
277  XDR *xdr,
278  mdsthreshold4 *mdsthreshold)
279 {
280  uint32_t i;
281 
282  if (!xdr_u_int32_t(xdr, &mdsthreshold->count))
283  return FALSE;
284 
285  if (mdsthreshold->count > MAX_MDSTHRESHOLD_ITEMS)
286  return FALSE;
287 
288  for (i = 0; i < mdsthreshold->count; i++)
289  if (!xdr_threshold_item(xdr, &mdsthreshold->items[i]))
290  return FALSE;
291  return TRUE;
292 }
293 
295  XDR *xdr,
296  nfsace4 *ace)
297 {
298  char *who = ace->who;
299 
300  if (!xdr_u_int32_t(xdr, &ace->acetype))
301  return FALSE;
302 
303  if (!xdr_u_int32_t(xdr, &ace->aceflag))
304  return FALSE;
305 
306  if (!xdr_u_int32_t(xdr, &ace->acemask))
307  return FALSE;
308 
309  /* 'who' is a static array, so don't try to free it */
310  if (xdr->x_op == XDR_FREE)
311  return TRUE;
312 
313  return xdr_string(xdr, &who, NFS4_OPAQUE_LIMIT);
314 }
315 
317  XDR *xdr,
318  nfsacl41 *acl)
319 {
320  if (!xdr_u_int32_t(xdr, &acl->flag))
321  return FALSE;
322 
323  return xdr_array(xdr, (char**)&acl->aces, &acl->count,
324  32, sizeof(nfsace4), (xdrproc_t)xdr_nfsace4);
325 }
326 
328  XDR *xdr,
329  nfsacl41 *acl)
330 {
331  return xdr_array(xdr, (char**)&acl->aces, &acl->count,
332  32, sizeof(nfsace4), (xdrproc_t)xdr_nfsace4);
333 }
334 
336 {
337  XDR xdr = { XDR_FREE };
338  xdr_nfsacl41(&xdr, acl);
339 }
340 
341 /* pathname4
342  * decode a variable array of components into a nfs41_abs_path */
344  XDR *xdr,
346 {
347  char *pos;
348  u_int32_t i, count, len, remaining;
349 
350  /* decode the number of components */
351  if (!xdr_u_int32_t(xdr, &count))
352  return FALSE;
353 
354  pos = (char *)path->path;
355  remaining = NFS41_MAX_PATH_LEN;
356 
357  /* decode each component */
358  for (i = 0; i < count; i++) {
359  len = remaining;
360  if (!xdr_bytes(xdr, (char **)&pos, &len, NFS41_MAX_PATH_LEN))
361  return FALSE;
362  remaining -= len;
363  pos += len;
364 
365  if (i < count-1) { /* add a \ between components */
366  if (remaining < 1)
367  return FALSE;
368  *pos++ = '\\';
369  remaining--;
370  }
371  }
372  path->len = (unsigned short)(NFS41_MAX_PATH_LEN - remaining);
373  return TRUE;
374 }
375 
376 /* fs_location4 */
378  XDR *xdr,
380 {
381  fs_location_server *arr;
382  char *address;
383  u_int32_t i, count, len;
384 
385  /* decode the number of servers */
386  if (!xdr_u_int32_t(xdr, &count))
387  return FALSE;
388 
389  /* allocate the fs_location_server array */
390  if (count == 0) {
391  free(location->servers);
392  arr = NULL;
393  } else if (count != location->server_count) {
394  arr = realloc(location->servers, count * sizeof(fs_location_server));
395  if (arr == NULL)
396  return FALSE;
397  ZeroMemory(arr, count * sizeof(fs_location_server));
398  } else {
399  arr = location->servers;
400  }
401 
402  location->servers = arr;
403  location->server_count = count;
404 
405  for (i = 0; i < count; i++) {
407  address = arr[i].address;
408  if (!xdr_bytes(xdr, &address, &len, NFS41_HOSTNAME_LEN)) {
409  free(arr);
410  return FALSE;
411  }
412  arr[i].address[len] = '\0';
413  }
414 
415  return decode_pathname4(xdr, &location->path);
416 }
417 
418 /* fs_locations4 */
420  XDR *xdr,
422 {
423  u_int32_t i, count;
424  fs_location4 *arr;
425 
426  if (!decode_pathname4(xdr, &locations->path))
427  return FALSE;
428 
429  if (!xdr_u_int32_t(xdr, &count))
430  return FALSE;
431 
432  /* allocate the fs_location array */
433  if (count == 0) {
434  free(locations->locations);
435  arr = NULL;
436  } else if (count != locations->location_count) {
437  arr = realloc(locations->locations, count * sizeof(fs_location4));
438  if (arr == NULL)
439  return FALSE;
440  ZeroMemory(arr, count * sizeof(fs_location4));
441  } else {
442  arr = locations->locations;
443  }
444 
445  locations->locations = arr;
446  locations->location_count = count;
447 
448  for (i = 0; i < count; i++) {
449  if (!decode_fs_location4(xdr, &arr[i])) {
450  free(arr);
451  return FALSE;
452  }
453  }
454  return TRUE;
455 }
456 
457 /*
458  * OP_EXCHANGE_ID
459  */
461  XDR *xdr,
462  client_owner4 *co)
463 {
464  unsigned char *co_ownerid = co->co_ownerid;
465  if (!xdr_opaque(xdr, (char *)&co->co_verifier[0], NFS4_VERIFIER_SIZE))
466  return FALSE;
467 
468  return xdr_bytes(xdr, (char **)&co_ownerid, &co->co_ownerid_len, NFS4_OPAQUE_LIMIT);
469 }
470 
471 #if 0
472 static bool_t encode_state_protect_ops4(
473  XDR *xdr,
474  state_protect_ops4 *spo)
475 {
476  if (!xdr_bitmap4(xdr, &spo->spo_must_enforce))
477  return FALSE;
478 
479  return xdr_bitmap4(xdr, &spo->spo_must_allow);
480 }
481 
482 static bool_t encode_ssv_sp_parms4(
483  XDR *xdr,
484  ssv_sp_parms4 *spp)
485 {
486  if (!encode_state_protect_ops4(xdr, &spp->ssp_ops))
487  return FALSE;
488 
489  if (!xdr_bytes(xdr, &spp->ssp_hash_algs,
490  &spp->ssp_hash_algs_len, NFS4_OPAQUE_LIMIT))
491  return FALSE;
492 
493  if (!xdr_bytes(xdr, &spp->ssp_encr_algs,
494  &spp->ssp_encr_algs_len, NFS4_OPAQUE_LIMIT))
495  return FALSE;
496 
497  if (!xdr_u_int32_t(xdr, &spp->ssp_window))
498  return FALSE;
499 
500  return xdr_u_int32_t(xdr, &spp->ssp_num_gss_handles);
501 }
502 #endif
503 
505  XDR *xdr,
506  state_protect4_a *spa)
507 {
508  bool_t result = TRUE;
509 
510  if (!xdr_u_int32_t(xdr, (u_int32_t *)&spa->spa_how))
511  return FALSE;
512 
513  switch (spa->spa_how)
514  {
515  case SP4_NONE:
516  break;
517 #if 0
518  case SP4_MACH_CRED:
519  result = xdr_state_protect_ops4(xdr, &spa->u.spa_mach_ops);
520  break;
521  case SP4_SSV:
522  result = xdr_ssv_sp_parms4(xdr, &spa->u.spa_ssv_parms);
523  break;
524 #endif
525  default:
526  eprintf("encode_state_protect4_a: state protect "
527  "type %d not supported.\n", spa->spa_how);
528  result = FALSE;
529  break;
530  }
531  return result;
532 }
533 
535  XDR *xdr,
536  nfs_impl_id4 *nii)
537 {
538  unsigned char *nii_domain = nii->nii_domain;
539  unsigned char *nii_name = nii->nii_name;
540 
541  if (!xdr_bytes(xdr, (char **)&nii_domain, &nii->nii_domain_len, NFS4_OPAQUE_LIMIT))
542  return FALSE;
543 
544  if (!xdr_bytes(xdr, (char **)&nii_name, &nii->nii_name_len, NFS4_OPAQUE_LIMIT))
545  return FALSE;
546 
547  return xdr_nfstime4(xdr, &nii->nii_date);
548 }
549 
550 
552  XDR *xdr,
553  nfs_argop4 *argop)
554 {
555  uint32_t zero = 0;
556  uint32_t one = 1;
557 
559 
560  if (unexpected_op(argop->op, OP_EXCHANGE_ID))
561  return FALSE;
562 
563  if (!xdr_client_owner4(xdr, args->eia_clientowner))
564  return FALSE;
565 
566  if (!xdr_u_int32_t(xdr, &args->eia_flags))
567  return FALSE;
568 
569  if (!xdr_state_protect4_a(xdr, &args->eia_state_protect))
570  return FALSE;
571 
572  if (args->eia_client_impl_id)
573  {
574  if (!xdr_u_int32_t(xdr, &one))
575  return FALSE;
576  return xdr_nfs_impl_id4(xdr, args->eia_client_impl_id);
577  }
578  else
579  return xdr_u_int32_t(xdr, &zero);
580 }
581 
582 #if 0
583 
584 static bool_t decode_state_protect_ops4(
585  XDR *xdr,
586  state_protect_ops4 *spo)
587 {
588  if (!xdr_bitmap4(xdr, &spo->spo_must_enforce))
589  return FALSE;
590 
591  return xdr_bitmap4(xdr, &spo->spo_must_allow);
592 }
593 
594 static bool_t decode_ssv_prot_info4(
595  XDR *xdr,
596  ssv_prot_info4 *spi)
597 {
598 /* uint32_t i; */
599 
600  if (!decode_state_protect_ops4(xdr, &spi->spi_ops))
601  return FALSE;
602 
603  if (!xdr_u_int32_t(xdr, &spi->spi_hash_alg))
604  return FALSE;
605 
606  if (!xdr_u_int32_t(xdr, &spi->spi_encr_alg))
607  return FALSE;
608 
609  if (!xdr_u_int32_t(xdr, &spi->spi_ssv_len))
610  return FALSE;
611 
612  if (!xdr_u_int32_t(xdr, &spi->spi_window))
613  return FALSE;
614 
615 /* TODO: spi->spi_handles */
616  return xdr_u_int32_t(xdr, 0);
617  /*
618  if (!xdr_u_int32_t(xdr, &spi->spi_handles.count))
619  return FALSE;
620 
621  for (i = 0; i < spi->spi_handles.count; i++)
622  if (!xdr_opaque(xdr, &spi->spi_handles.arr[i])
623  return FALSE;
624 */
625  return TRUE;
626 }
627 #endif
628 
630  XDR *xdr,
631  state_protect4_r *spr)
632 {
633  bool_t result = TRUE;
634 
635  if (!xdr_u_int32_t(xdr, (uint32_t *)&spr->spr_how))
636  return FALSE;
637 
638  switch (spr->spr_how)
639  {
640  case SP4_NONE:
641  break;
642 #if 0
643  case SP4_MACH_CRED:
644  result = decode_state_protect_ops4(xdr, &spr->u.spr_mach_ops);
645  break;
646  case SP4_SSV:
647  result = decode_ssv_prot_info4(xdr, &spr->u.spr_ssv_info);
648  break;
649 #endif
650  default:
651  eprintf("decode_state_protect4_r: state protect "
652  "type %d not supported.\n", spr->spr_how);
653  result = FALSE;
654  break;
655  }
656  return result;
657 }
658 
660  XDR *xdr,
661  server_owner4 *so)
662 {
663  char *so_major_id = so->so_major_id;
664 
665  if (!xdr_u_hyper(xdr, &so->so_minor_id))
666  return FALSE;
667 
668  return xdr_bytes(xdr, (char **)&so_major_id,
670 }
671 
673  XDR *xdr,
674  nfs_resop4 *resop)
675 {
677  char *server_scope = (char *)res->server_scope;
678 
679  if (unexpected_op(resop->op, OP_EXCHANGE_ID))
680  return FALSE;
681 
682  if (!xdr_u_int32_t(xdr, &res->status))
683  return FALSE;
684 
685  if (res->status != NFS4_OK)
686  return TRUE;
687 
688  if (!xdr_u_hyper(xdr, &res->clientid))
689  return FALSE;
690 
691  if (!xdr_u_int32_t(xdr, &res->sequenceid))
692  return FALSE;
693 
694  if (!xdr_u_int32_t(xdr, &res->flags))
695  return FALSE;
696 
697  if (!xdr_state_protect4_r(xdr, &res->state_protect))
698  return FALSE;
699 
700  if (!xdr_server_owner4(xdr, &res->server_owner))
701  return FALSE;
702 
703  return xdr_bytes(xdr, &server_scope,
704  &res->server_scope_len, NFS4_OPAQUE_LIMIT);
705 }
706 
707 /*
708  * OP_CREATE_SESSION
709  */
711  XDR *xdr,
712  nfs41_channel_attrs *attrs)
713 {
714  uint32_t zero = 0;
715  uint32_t one = 1;
716 
717  /* count4 ca_headerpadsize */
718  if (!xdr_u_int32_t(xdr, &attrs->ca_headerpadsize))
719  return FALSE;
720 
721  /* count4 ca_maxrequestsize */
722  if (!xdr_u_int32_t(xdr, &attrs->ca_maxrequestsize))
723  return FALSE;
724 
725  /* count4 ca_maxresponsesize */
726  if (!xdr_u_int32_t(xdr, &attrs->ca_maxresponsesize))
727  return FALSE;
728 
729  /* count4 ca_maxresponsesize_cached */
730  if (!xdr_u_int32_t(xdr, &attrs->ca_maxresponsesize_cached))
731  return FALSE;
732 
733  /* count4 ca_maxoperations */
734  if (!xdr_u_int32_t(xdr, &attrs->ca_maxoperations))
735  return FALSE;
736 
737  /* count4 ca_maxrequests */
738  if (!xdr_u_int32_t(xdr, &attrs->ca_maxrequests))
739  return FALSE;
740 
741  if (xdr->x_op == XDR_ENCODE) {
742  /* uint32_t ca_rdma_ird<1> */
743  if (attrs->ca_rdma_ird)
744  {
745  if (!xdr_u_int32_t(xdr, &one))
746  return FALSE;
747  return xdr_u_int32_t(xdr, attrs->ca_rdma_ird);
748  }
749  else {
750  return xdr_u_int32_t(xdr, &zero);
751  }
752  }
753  else if (xdr->x_op == XDR_DECODE) {
754 #if 0
756  /* uint32_t ca_rdma_ird<1> */
757  if (!xdr_u_int32_t(xdr, &count))
758  return FALSE;
759  if (count > 1)
760  return FALSE;
761  if (count)
762  return xdr_u_int32_t(xdr, attrs->ca_rdma_ird);
763  else
764 #endif
765  return TRUE;
766  }
767  else {
768  eprintf("%s: xdr->x_op %d not supported.\n",
769  "xdr_channel_attrs4", xdr->x_op);
770  return FALSE;
771  }
772 }
773 
775  XDR *xdr,
777 {
778  uint32_t zero = 0;
779 
780  if (!xdr_u_int32_t(xdr, &args->type))
781  return FALSE;
782 
783  switch (args->type) {
784  case AUTH_NONE: return TRUE;
785  case AUTH_SYS:
786  if (!xdr_u_int32_t(xdr, &args->u.auth_sys.stamp))
787  return FALSE;
788  if (!xdr_string(xdr, &args->u.auth_sys.machinename, NI_MAXHOST))
789  return FALSE;
790  return xdr_u_int32_t(xdr, &zero) && xdr_u_int32_t(xdr, &zero) &&
791  xdr_u_int32_t(xdr, &zero);
792  case RPCSEC_GSS:
793  default:
794  return FALSE;
795  }
796 }
797 
799  XDR *xdr,
800  nfs_argop4 *argop)
801 {
803  nfs41_callback_secparms *cb_secparams = args->csa_cb_secparams;
804  uint32_t cb_count = 2;
805 
807  return FALSE;
808 
809  /* clientid4 csa_clientid */
810  if (!xdr_u_hyper(xdr, &args->csa_clientid))
811  return FALSE;
812 
813  /* sequenceid4 csa_sequence */
814  if (!xdr_u_int32_t(xdr, &args->csa_sequence))
815  return FALSE;
816 
817  /* TODO: uint32_t csa_flags = 0 */
818  if (!xdr_u_int32_t(xdr, &args->csa_flags))
819  return FALSE;
820 
821  /* channel_attrs4 csa_fore_chan_attrs */
822  if (!xdr_channel_attrs4(xdr, &args->csa_fore_chan_attrs))
823  return FALSE;
824 
825  /* channel_attrs4 csa_back_chan_attrs */
826  if (!xdr_channel_attrs4(xdr, &args->csa_back_chan_attrs))
827  return FALSE;
828 
829  /* TODO: uint32_t csa_cb_program = 1234 */
830  if (!xdr_u_int32_t(xdr, &args->csa_cb_program))
831  return FALSE;
832 
833  return xdr_array(xdr, (char **)&cb_secparams, &cb_count,
835 }
836 
838  XDR *xdr,
839  nfs_resop4 *resop)
840 {
841  uint32_t opstatus;
843 
845  return FALSE;
846 
847  if (!xdr_u_int32_t(xdr, &opstatus))
848  return FALSE;
849 
850  if (opstatus != NFS4_OK)
851  return TRUE;
852 
853  if (!xdr_opaque(xdr, (char *)res->csr_sessionid, NFS4_SESSIONID_SIZE))
854  return FALSE;
855 
856  /* sequenceid4 csr_sequence */
857  if (!xdr_u_int32_t(xdr, &res->csr_sequence))
858  return FALSE;
859 
860  /* uint32_t csr_flags */
861  if (!xdr_u_int32_t(xdr, &res->csr_flags))
862  return FALSE;
863 
864  /* channel_attrs4 csr_fore_chan_attrs */
865  if (!xdr_channel_attrs4(xdr, res->csr_fore_chan_attrs))
866  return FALSE;
867 
868  /* channel_attrs4 csr_back_chan_attrs */
869  return xdr_channel_attrs4(xdr, res->csr_back_chan_attrs);
870 }
871 
872 
873 /*
874  * OP_BIND_CONN_TO_SESSION
875  */
877  XDR *xdr,
878  nfs_argop4 *argop)
879 {
880  uint32_t zero = 0;
881 
884 
886  return FALSE;
887 
888  if (!xdr_opaque(xdr, (char *)args->sessionid, NFS4_SESSIONID_SIZE))
889  return FALSE;
890 
891  if (!xdr_enum(xdr, (enum_t *)&args->dir))
892  return FALSE;
893 
894  return xdr_u_int32_t(xdr, &zero); /* bctsa_use_conn_in_rdma_mode = false */
895 }
896 
898  XDR *xdr,
899  nfs_resop4 *resop)
900 {
901  unsigned char sessionid_ignored[NFS4_SESSIONID_SIZE];
904  bool_t use_rdma_ignored;
905 
907  return FALSE;
908 
909  if (!xdr_enum(xdr, (enum_t *)&res->status))
910  return FALSE;
911 
912  if (res->status == NFS4_OK) {
913  if (!xdr_opaque(xdr, (char *)&sessionid_ignored, NFS4_SESSIONID_SIZE))
914  return FALSE;
915 
916  if (!xdr_enum(xdr, (enum_t *)&res->dir))
917  return FALSE;
918 
919  return xdr_bool(xdr, &use_rdma_ignored);
920  }
921  return TRUE;
922 }
923 
924 
925 /*
926  * OP_DESTROY_SESSION
927  */
929  XDR *xdr,
930  nfs_argop4 *argop)
931 {
933 
935  return FALSE;
936 
937  return xdr_opaque(xdr, (char *)args->dsa_sessionid, NFS4_SESSIONID_SIZE);
938 }
939 
941  XDR *xdr,
942  nfs_resop4 *resop)
943 {
945 
947  return FALSE;
948 
949  return xdr_u_int32_t(xdr, &res->dsr_status);
950 }
951 
952 /*
953  * OP_DESTROY_CLIENTID
954  */
956  XDR *xdr,
957  nfs_argop4 *argop)
958 {
960 
962  return FALSE;
963 
964  return xdr_u_hyper(xdr, &args->dca_clientid);
965 }
966 
968  XDR *xdr,
969  nfs_resop4 *resop)
970 {
972 
974  return FALSE;
975 
976  return xdr_u_int32_t(xdr, &res->dcr_status);
977 }
978 
979 
980 /*
981  * OP_SEQUENCE
982  */
984  XDR *xdr,
985  nfs_argop4 *argop)
986 {
988 
989  if (unexpected_op(argop->op, OP_SEQUENCE))
990  return FALSE;
991 
992  if (!xdr_opaque(xdr, (char *)args->sa_sessionid, NFS4_SESSIONID_SIZE))
993  return FALSE;
994 
995  if (!xdr_u_int32_t(xdr, &args->sa_sequenceid))
996  return FALSE;
997 
998  if (!xdr_u_int32_t(xdr, &args->sa_slotid))
999  return FALSE;
1000 
1001  if (!xdr_u_int32_t(xdr, &args->sa_highest_slotid))
1002  return FALSE;
1003 
1004  return xdr_bool(xdr, &args->sa_cachethis);
1005 }
1006 
1008  XDR *xdr,
1010 {
1011  if (!xdr_opaque(xdr, (char *)res->sr_sessionid, NFS4_SESSIONID_SIZE))
1012  return FALSE;
1013 
1014  if (!xdr_u_int32_t(xdr, &res->sr_sequenceid))
1015  return FALSE;
1016 
1017  if (!xdr_u_int32_t(xdr, &res->sr_slotid))
1018  return FALSE;
1019 
1020  if (!xdr_u_int32_t(xdr, &res->sr_highest_slotid))
1021  return FALSE;
1022 
1023  if (!xdr_u_int32_t(xdr, &res->sr_target_highest_slotid))
1024  return FALSE;
1025 
1026  return xdr_u_int32_t(xdr, &res->sr_status_flags);
1027 }
1028 
1030  XDR *xdr,
1031  nfs_resop4 *resop)
1032 {
1034 
1035  if (unexpected_op(resop->op, OP_SEQUENCE))
1036  return FALSE;
1037 
1038  if (!xdr_u_int32_t(xdr, &res->sr_status))
1039  return FALSE;
1040 
1041  if (res->sr_status == NFS4_OK)
1042  return xdr_sequence_res_ok(xdr, &res->sr_resok4);
1043 
1044  return TRUE;
1045 }
1046 
1047 
1048 /*
1049  * OP_RECLAIM_COMPLETE
1050  */
1052  XDR *xdr,
1053  nfs_argop4 *argop)
1054 {
1055  bool_t zero = FALSE;
1056 
1057  if (unexpected_op(argop->op, OP_RECLAIM_COMPLETE))
1058  return FALSE;
1059 
1060  /* rca_one_fs = 0 indicates that the reclaim applies to all filesystems */
1061  return xdr_bool(xdr, &zero);
1062 }
1063 
1065  XDR *xdr,
1066  nfs_resop4 *resop)
1067 {
1069 
1071  return FALSE;
1072 
1073  return xdr_enum(xdr, (enum_t *)&res->status);
1074 }
1075 
1076 
1077 /*
1078  * OP_PUTFH
1079  */
1081  XDR *xdr,
1082  nfs_argop4 *argop)
1083 {
1085 
1086  if (unexpected_op(argop->op, OP_PUTFH))
1087  return FALSE;
1088 
1089  return xdr_fh(xdr, &args->file->fh);
1090 }
1091 
1093  XDR *xdr,
1094  nfs_resop4 *resop)
1095 {
1096  nfs41_putfh_res *res = (nfs41_putfh_res*)resop->res;
1097 
1098  if (unexpected_op(resop->op, OP_PUTFH))
1099  return FALSE;
1100 
1101  return xdr_u_int32_t(xdr, &res->status);
1102 }
1103 
1104 
1105 /*
1106  * OP_PUTROOTFH
1107  */
1109  XDR *xdr,
1110  nfs_argop4* argop)
1111 {
1112  if (unexpected_op(argop->op, OP_PUTROOTFH))
1113  return FALSE;
1114  /* void */
1115  return TRUE;
1116 }
1117 
1119  XDR *xdr,
1120  nfs_resop4 *resop)
1121 {
1123 
1124  if (unexpected_op(resop->op, OP_PUTROOTFH))
1125  return FALSE;
1126 
1127  return xdr_u_int32_t(xdr, &res->status);
1128 }
1129 
1130 
1131 /*
1132  * OP_GETFH
1133  */
1135  XDR *xdr,
1136  nfs_argop4 *argop)
1137 {
1138  if (unexpected_op(argop->op, OP_GETFH))
1139  return FALSE;
1140 
1141  /* void */
1142  return TRUE;
1143 }
1144 
1146  XDR *xdr,
1147  nfs_resop4 *resop)
1148 {
1149  nfs41_getfh_res *res = (nfs41_getfh_res*)resop->res;
1150 
1151  if (unexpected_op(resop->op, OP_GETFH))
1152  return FALSE;
1153 
1154  if (!xdr_u_int32_t(xdr, &res->status))
1155  return FALSE;
1156 
1157  if (res->status == NFS4_OK)
1158  return xdr_fh(xdr, res->fh);
1159 
1160  return TRUE;
1161 }
1162 
1163 
1164 /*
1165  * OP_LOOKUP
1166  */
1168  XDR *xdr,
1169  nfs_argop4 *argop)
1170 {
1172 
1173  if (unexpected_op(argop->op, OP_LOOKUP))
1174  return FALSE;
1175 
1176  return encode_component(xdr, args->name);
1177 }
1178 
1180  XDR *xdr,
1181  nfs_resop4 *resop)
1182 {
1184 
1185  if (unexpected_op(resop->op, OP_LOOKUP))
1186  return FALSE;
1187 
1188  return xdr_u_int32_t(xdr, &res->status);
1189 }
1190 
1191 
1192 /*
1193  * OP_ACCESS
1194  */
1196  XDR *xdr,
1197  nfs_argop4 *argop)
1198 {
1200 
1201  if (unexpected_op(argop->op, OP_ACCESS))
1202  return FALSE;
1203 
1204  return xdr_u_int32_t(xdr, &args->access);
1205 }
1206 
1208  XDR *xdr,
1209  nfs_resop4 *resop)
1210 {
1212 
1213  if (unexpected_op(resop->op, OP_ACCESS))
1214  return FALSE;
1215 
1216  if (!xdr_u_int32_t(xdr, &res->status))
1217  return FALSE;
1218 
1219  if (res->status == NFS4_OK)
1220  {
1221  if (!xdr_u_int32_t(xdr, &res->supported))
1222  return FALSE;
1223 
1224  return xdr_u_int32_t(xdr, &res->access);
1225  }
1226  return TRUE;
1227 }
1228 
1229 
1230 /*
1231  * OP_CLOSE
1232  */
1234  XDR *xdr,
1235  nfs_argop4 *argop)
1236 {
1238  uint32_t zero = 0;
1239 
1240  if (unexpected_op(argop->op, OP_CLOSE))
1241  return FALSE;
1242 
1243  if (!xdr_u_int32_t(xdr, &zero)) // This should be ignored by server
1244  return FALSE;
1245 
1246  return xdr_stateid4(xdr, &args->stateid->stateid);
1247 }
1248 
1250  XDR *xdr,
1251  nfs_resop4 *resop)
1252 {
1253  stateid4 ignored;
1255 
1256  if (unexpected_op(resop->op, OP_CLOSE))
1257  return FALSE;
1258 
1259  if (!xdr_u_int32_t(xdr, &res->status))
1260  return FALSE;
1261 
1262  if (res->status == NFS4_OK)
1263  return xdr_stateid4(xdr, &ignored);
1264 
1265  return TRUE;
1266 }
1267 
1268 
1269 /*
1270  * OP_COMMIT
1271  */
1273  XDR *xdr,
1274  nfs_argop4 *argop)
1275 {
1277 
1278  if (unexpected_op(argop->op, OP_COMMIT))
1279  return FALSE;
1280 
1281  if (!xdr_u_hyper(xdr, &args->offset))
1282  return FALSE;
1283 
1284  return xdr_u_int32_t(xdr, &args->count);
1285 }
1286 
1288  XDR *xdr,
1289  nfs_resop4 *resop)
1290 {
1292 
1293  if (unexpected_op(resop->op, OP_COMMIT))
1294  return FALSE;
1295 
1296  if (!xdr_u_int32_t(xdr, &res->status))
1297  return FALSE;
1298 
1299  if (res->status == NFS4_OK)
1300  return xdr_opaque(xdr, (char *)res->verf->verf, NFS4_VERIFIER_SIZE);
1301 
1302  return TRUE;
1303 }
1304 
1305 
1306 /*
1307  * OP_CREATE
1308  */
1310  XDR *xdr,
1311  createtype4 *ct)
1312 {
1313  bool_t result = TRUE;
1314  const char *linkdata;
1315 
1316  if (!xdr_u_int32_t(xdr, &ct->type))
1317  return FALSE;
1318 
1319  switch (ct->type)
1320  {
1321  case NF4LNK:
1322  linkdata = ct->u.lnk.linkdata;
1323  result = xdr_bytes(xdr, (char**)&linkdata, &ct->u.lnk.linkdata_len,
1325  break;
1326  case NF4BLK:
1327  case NF4CHR:
1328  result = xdr_u_int32_t(xdr, &ct->u.devdata.specdata1);
1329  if (result == TRUE)
1330  result = xdr_u_int32_t(xdr, &ct->u.devdata.specdata2);
1331  break;
1332  default:
1333  // Some types need no further action
1334  break;
1335  }
1336  return result;
1337 }
1338 
1340  XDR *xdr,
1341  nfs41_file_info* createattrs)
1342 {
1343  fattr4 attrs;
1344 
1345  /* encode attribute values from createattrs->info into attrs.attr_vals */
1347  if (!encode_file_attrs(&attrs, createattrs))
1348  return FALSE;
1349 
1350  return xdr_fattr4(xdr, &attrs);
1351 }
1352 
1354  XDR *xdr,
1355  nfs_argop4 *argop)
1356 {
1358 
1359  if (unexpected_op(argop->op, OP_CREATE))
1360  return FALSE;
1361 
1362  if (!encode_createtype4(xdr, &args->objtype))
1363  return FALSE;
1364 
1365  if (!encode_component(xdr, args->name))
1366  return FALSE;
1367 
1368  return encode_createattrs4(xdr, args->createattrs);
1369 }
1370 
1372  XDR *xdr,
1373  change_info4 *cinfo)
1374 {
1375  if (!xdr_bool(xdr, &cinfo->atomic))
1376  return FALSE;
1377 
1378  if (!xdr_u_hyper(xdr, &cinfo->before))
1379  return FALSE;
1380 
1381  return xdr_u_hyper(xdr, &cinfo->after);
1382 }
1383 
1385  XDR *xdr,
1386  nfs_resop4 *resop)
1387 {
1389 
1390  if (unexpected_op(resop->op, OP_CREATE))
1391  return FALSE;
1392 
1393  if (!xdr_u_int32_t(xdr, &res->status))
1394  return FALSE;
1395 
1396  if (res->status == NFS4_OK)
1397  {
1398  if (!xdr_change_info4(xdr, &res->cinfo))
1399  return FALSE;
1400  return xdr_bitmap4(xdr, &res->attrset);
1401  }
1402  return TRUE;
1403 }
1404 
1405 
1406 /*
1407  * OP_LINK
1408  */
1410  XDR *xdr,
1411  nfs_argop4 *argop)
1412 {
1414 
1415  if (unexpected_op(argop->op, OP_LINK))
1416  return FALSE;
1417 
1418  return encode_component(xdr, args->newname);
1419 }
1420 
1422  XDR *xdr,
1423  nfs_resop4 *resop)
1424 {
1425  nfs41_link_res *res = (nfs41_link_res*)resop->res;
1426 
1427  if (unexpected_op(resop->op, OP_LINK))
1428  return FALSE;
1429 
1430  if (!xdr_u_int32_t(xdr, &res->status))
1431  return FALSE;
1432 
1433  if (res->status == NFS4_OK)
1434  return xdr_change_info4(xdr, &res->cinfo);
1435 
1436  return TRUE;
1437 }
1438 
1439 
1440 /*
1441  * OP_LOCK
1442  */
1444  XDR *xdr,
1445  locker4 *locker)
1446 {
1447  if (xdr->x_op != XDR_ENCODE) {
1448  eprintf("%s: xdr->x_op %d is not supported!\n",
1449  "xdr_locker4", xdr->x_op);
1450  return FALSE;
1451  }
1452 
1453  if (!xdr_bool(xdr, &locker->new_lock_owner))
1454  return FALSE;
1455 
1456  if (locker->new_lock_owner) {
1457  /* open_to_lock_owner4 open_owner */
1458  if (!xdr_u_int32_t(xdr, &locker->u.open_owner.open_seqid))
1459  return FALSE;
1460 
1461  if (!xdr_stateid4(xdr, &locker->u.open_owner.open_stateid->stateid))
1462  return FALSE;
1463 
1464  if (!xdr_u_int32_t(xdr, &locker->u.open_owner.lock_seqid))
1465  return FALSE;
1466 
1467  return xdr_state_owner4(xdr, locker->u.open_owner.lock_owner);
1468  } else {
1469  /* exist_lock_owner4 lock_owner */
1470  if (!xdr_stateid4(xdr, &locker->u.lock_owner.lock_stateid->stateid))
1471  return FALSE;
1472 
1473  return xdr_u_int32_t(xdr, &locker->u.lock_owner.lock_seqid);
1474  }
1475 }
1476 
1478  XDR *xdr,
1479  nfs_argop4 *argop)
1480 {
1482 
1483  if (unexpected_op(argop->op, OP_LOCK))
1484  return FALSE;
1485 
1486  if (!xdr_u_int32_t(xdr, &args->locktype))
1487  return FALSE;
1488 
1489  if (!xdr_bool(xdr, &args->reclaim))
1490  return FALSE;
1491 
1492  if (!xdr_u_hyper(xdr, &args->offset))
1493  return FALSE;
1494 
1495  if (!xdr_u_hyper(xdr, &args->length))
1496  return FALSE;
1497 
1498  return xdr_locker4(xdr, &args->locker);
1499 }
1500 
1502  XDR *xdr,
1503  lock_res_denied *denied)
1504 {
1505  if (!xdr_u_hyper(xdr, &denied->offset))
1506  return FALSE;
1507 
1508  if (!xdr_u_hyper(xdr, &denied->length))
1509  return FALSE;
1510 
1511  if (!xdr_u_int32_t(xdr, &denied->locktype))
1512  return FALSE;
1513 
1514  return xdr_state_owner4(xdr, &denied->owner);
1515 }
1516 
1518  XDR *xdr,
1519  nfs_resop4 *resop)
1520 {
1521  nfs41_lock_res *res = (nfs41_lock_res*)resop->res;
1522 
1523  if (unexpected_op(resop->op, OP_LOCK))
1524  return FALSE;
1525 
1526  if (!xdr_u_int32_t(xdr, &res->status))
1527  return FALSE;
1528 
1529  switch (res->status) {
1530  case NFS4_OK:
1531  return xdr_stateid4(xdr, res->u.resok4.lock_stateid);
1532  break;
1533  case NFS4ERR_DENIED:
1534  return decode_lock_res_denied(xdr, &res->u.denied);
1535  break;
1536  default:
1537  break;
1538  }
1539 
1540  return TRUE;
1541 }
1542 
1543 
1544 /*
1545  * OP_LOCKT
1546  */
1548  XDR *xdr,
1549  nfs_argop4 *argop)
1550 {
1552 
1553  if (unexpected_op(argop->op, OP_LOCKT))
1554  return FALSE;
1555 
1556  if (!xdr_u_int32_t(xdr, &args->locktype))
1557  return FALSE;
1558 
1559  if (!xdr_u_hyper(xdr, &args->offset))
1560  return FALSE;
1561 
1562  if (!xdr_u_hyper(xdr, &args->length))
1563  return FALSE;
1564 
1565  return xdr_state_owner4(xdr, args->owner);
1566 }
1567 
1569  XDR *xdr,
1570  nfs_resop4 *resop)
1571 {
1572  nfs41_lockt_res *res = (nfs41_lockt_res*)resop->res;
1573 
1574  if (unexpected_op(resop->op, OP_LOCKT))
1575  return FALSE;
1576 
1577  if (!xdr_u_int32_t(xdr, &res->status))
1578  return FALSE;
1579 
1580  if (res->status == NFS4ERR_DENIED)
1581  return decode_lock_res_denied(xdr, &res->denied);
1582 
1583  return TRUE;
1584 }
1585 
1586 
1587 /*
1588  * OP_LOCKU
1589  */
1591  XDR *xdr,
1592  nfs_argop4 *argop)
1593 {
1595 
1596  if (unexpected_op(argop->op, OP_LOCKU))
1597  return FALSE;
1598 
1599  if (!xdr_u_int32_t(xdr, &args->locktype))
1600  return FALSE;
1601 
1602  if (!xdr_u_int32_t(xdr, &args->seqid))
1603  return FALSE;
1604 
1605  if (!xdr_stateid4(xdr, &args->lock_stateid->stateid))
1606  return FALSE;
1607 
1608  if (!xdr_u_hyper(xdr, &args->offset))
1609  return FALSE;
1610 
1611  return xdr_u_hyper(xdr, &args->length);
1612 }
1613 
1615  XDR *xdr,
1616  nfs_resop4 *resop)
1617 {
1618  nfs41_locku_res *res = (nfs41_locku_res*)resop->res;
1619 
1620  if (unexpected_op(resop->op, OP_LOCKU))
1621  return FALSE;
1622 
1623  if (!xdr_u_int32_t(xdr, &res->status))
1624  return FALSE;
1625 
1626  if (res->status == NFS4_OK)
1627  return xdr_stateid4(xdr, res->lock_stateid);
1628 
1629  return TRUE;
1630 }
1631 
1632 
1633 /*
1634  * OP_DELEGPURGE
1635  */
1637  XDR *xdr,
1638  nfs_argop4 *argop)
1639 {
1640  uint64_t zero = 0;
1641 
1642  if (unexpected_op(argop->op, OP_DELEGPURGE))
1643  return FALSE;
1644 
1645  /* The client SHOULD set the client field to zero,
1646  * and the server MUST ignore the clientid field. */
1647  return xdr_u_int64_t(xdr, &zero);
1648 }
1649 
1651  XDR *xdr,
1652  nfs_resop4 *resop)
1653 {
1655 
1656  if (unexpected_op(resop->op, OP_DELEGPURGE))
1657  return FALSE;
1658 
1659  return xdr_u_int32_t(xdr, &res->status);
1660 }
1661 
1662 
1663 /*
1664  * OP_DELEGRETURN
1665  */
1667  XDR *xdr,
1668  nfs_argop4 *argop)
1669 {
1671 
1672  if (unexpected_op(argop->op, OP_DELEGRETURN))
1673  return FALSE;
1674 
1675  return xdr_stateid4(xdr, &args->stateid->stateid);
1676 }
1677 
1679  XDR *xdr,
1680  nfs_resop4 *resop)
1681 {
1683 
1684  if (unexpected_op(resop->op, OP_DELEGRETURN))
1685  return FALSE;
1686 
1687  return xdr_u_int32_t(xdr, &res->status);
1688 }
1689 
1690 
1691 /*
1692  * OP_GETATTR
1693  */
1695  XDR *xdr,
1696  nfs_argop4 *argop)
1697 {
1699 
1700  if (unexpected_op(argop->op, OP_GETATTR))
1701  return FALSE;
1702 
1703  return xdr_bitmap4(xdr, args->attr_request);
1704 }
1705 
1707  XDR *xdr,
1708  fattr4 *attrs,
1710 {
1711  if (attrs->attrmask.count >= 1) {
1712  if (attrs->attrmask.arr[0] & FATTR4_WORD0_SUPPORTED_ATTRS) {
1713  if (!xdr_bitmap4(xdr, info->supported_attrs))
1714  return FALSE;
1715  }
1716  if (attrs->attrmask.arr[0] & FATTR4_WORD0_TYPE) {
1717  if (!xdr_u_int32_t(xdr, &info->type))
1718  return FALSE;
1719  }
1720  if (attrs->attrmask.arr[0] & FATTR4_WORD0_CHANGE) {
1721  if (!xdr_u_hyper(xdr, &info->change))
1722  return FALSE;
1723  }
1724  if (attrs->attrmask.arr[0] & FATTR4_WORD0_SIZE) {
1725  if (!xdr_u_hyper(xdr, &info->size))
1726  return FALSE;
1727  }
1728  if (attrs->attrmask.arr[0] & FATTR4_WORD0_LINK_SUPPORT) {
1729  if (!xdr_bool(xdr, &info->link_support))
1730  return FALSE;
1731  }
1732  if (attrs->attrmask.arr[0] & FATTR4_WORD0_SYMLINK_SUPPORT) {
1733  if (!xdr_bool(xdr, &info->symlink_support))
1734  return FALSE;
1735  }
1736  if (attrs->attrmask.arr[0] & FATTR4_WORD0_FSID) {
1737  if (!xdr_fsid(xdr, &info->fsid))
1738  return FALSE;
1739  }
1740  if (attrs->attrmask.arr[0] & FATTR4_WORD0_LEASE_TIME) {
1741  if (!xdr_u_int32_t(xdr, &info->lease_time))
1742  return FALSE;
1743  }
1744  if (attrs->attrmask.arr[0] & FATTR4_WORD0_RDATTR_ERROR) {
1745  if (!xdr_u_int32_t(xdr, &info->rdattr_error))
1746  return FALSE;
1747  }
1748  if (attrs->attrmask.arr[0] & FATTR4_WORD0_ACL) {
1749  nfsacl41 *acl = info->acl;
1750  if (!xdr_array(xdr, (char**)&acl->aces, &acl->count,
1751  32, sizeof(nfsace4), (xdrproc_t)xdr_nfsace4))
1752  return FALSE;
1753  }
1754  if (attrs->attrmask.arr[0] & FATTR4_WORD0_ACLSUPPORT) {
1755  if (!xdr_u_int32_t(xdr, &info->aclsupport))
1756  return FALSE;
1757  }
1758  if (attrs->attrmask.arr[0] & FATTR4_WORD0_ARCHIVE) {
1759  if (!xdr_bool(xdr, &info->archive))
1760  return FALSE;
1761  }
1762  if (attrs->attrmask.arr[0] & FATTR4_WORD0_CANSETTIME) {
1763  if (!xdr_bool(xdr, &info->cansettime))
1764  return FALSE;
1765  }
1766  if (attrs->attrmask.arr[0] & FATTR4_WORD0_CASE_INSENSITIVE) {
1767  if (!xdr_bool(xdr, &info->case_insensitive))
1768  return FALSE;
1769  }
1770  if (attrs->attrmask.arr[0] & FATTR4_WORD0_CASE_PRESERVING) {
1771  if (!xdr_bool(xdr, &info->case_preserving))
1772  return FALSE;
1773  }
1774  if (attrs->attrmask.arr[0] & FATTR4_WORD0_FILEID) {
1775  if (!xdr_u_hyper(xdr, &info->fileid))
1776  return FALSE;
1777  }
1778  if (attrs->attrmask.arr[0] & FATTR4_WORD0_FS_LOCATIONS) {
1779  if (!decode_fs_locations4(xdr, info->fs_locations))
1780  return FALSE;
1781  }
1782  if (attrs->attrmask.arr[0] & FATTR4_WORD0_HIDDEN) {
1783  if (!xdr_bool(xdr, &info->hidden))
1784  return FALSE;
1785  }
1786  if (attrs->attrmask.arr[0] & FATTR4_WORD0_MAXREAD) {
1787  if (!xdr_u_hyper(xdr, &info->maxread))
1788  return FALSE;
1789  }
1790  if (attrs->attrmask.arr[0] & FATTR4_WORD0_MAXWRITE) {
1791  if (!xdr_u_hyper(xdr, &info->maxwrite))
1792  return FALSE;
1793  }
1794  }
1795  if (attrs->attrmask.count >= 2) {
1796  if (attrs->attrmask.arr[1] & FATTR4_WORD1_MODE) {
1797  if (!xdr_u_int32_t(xdr, &info->mode))
1798  return FALSE;
1799  }
1800  if (attrs->attrmask.arr[1] & FATTR4_WORD1_NUMLINKS) {
1801  if (!xdr_u_int32_t(xdr, &info->numlinks))
1802  return FALSE;
1803  }
1804  if (attrs->attrmask.arr[1] & FATTR4_WORD1_OWNER) {
1805  char *ptr = &info->owner[0];
1806  uint32_t owner_len;
1807  if (!xdr_bytes(xdr, &ptr, &owner_len,
1809  return FALSE;
1810  info->owner[owner_len] = '\0';
1811  }
1812  if (attrs->attrmask.arr[1] & FATTR4_WORD1_OWNER_GROUP) {
1813  char *ptr = &info->owner_group[0];
1814  uint32_t owner_group_len;
1815  if (!xdr_bytes(xdr, &ptr, &owner_group_len,
1817  return FALSE;
1818  info->owner_group[owner_group_len] = '\0';
1819  }
1820  if (attrs->attrmask.arr[1] & FATTR4_WORD1_SPACE_AVAIL) {
1821  if (!xdr_u_hyper(xdr, &info->space_avail))
1822  return FALSE;
1823  }
1824  if (attrs->attrmask.arr[1] & FATTR4_WORD1_SPACE_FREE) {
1825  if (!xdr_u_hyper(xdr, &info->space_free))
1826  return FALSE;
1827  }
1828  if (attrs->attrmask.arr[1] & FATTR4_WORD1_SPACE_TOTAL) {
1829  if (!xdr_u_hyper(xdr, &info->space_total))
1830  return FALSE;
1831  }
1832  if (attrs->attrmask.arr[1] & FATTR4_WORD1_SYSTEM) {
1833  if (!xdr_bool(xdr, &info->system))
1834  return FALSE;
1835  }
1836  if (attrs->attrmask.arr[1] & FATTR4_WORD1_TIME_ACCESS) {
1837  if (!xdr_nfstime4(xdr, &info->time_access))
1838  return FALSE;
1839  }
1840  if (attrs->attrmask.arr[1] & FATTR4_WORD1_TIME_CREATE) {
1841  if (!xdr_nfstime4(xdr, &info->time_create))
1842  return FALSE;
1843  }
1844  if (attrs->attrmask.arr[1] & FATTR4_WORD1_TIME_DELTA) {
1845  if (!xdr_nfstime4(xdr, info->time_delta))
1846  return FALSE;
1847  }
1848  if (attrs->attrmask.arr[1] & FATTR4_WORD1_TIME_MODIFY) {
1849  if (!xdr_nfstime4(xdr, &info->time_modify))
1850  return FALSE;
1851  }
1852  if (attrs->attrmask.arr[1] & FATTR4_WORD1_DACL) {
1853  if (!xdr_nfsdacl41(xdr, info->acl))
1854  return FALSE;
1855  }
1856  if (attrs->attrmask.arr[1] & FATTR4_WORD1_FS_LAYOUT_TYPE) {
1857  if (!xdr_layout_types(xdr, &info->fs_layout_types))
1858  return FALSE;
1859  }
1860  }
1861  if (attrs->attrmask.count >= 3) {
1862  if (attrs->attrmask.arr[2] & FATTR4_WORD2_MDSTHRESHOLD) {
1863  if (!xdr_mdsthreshold(xdr, &info->mdsthreshold))
1864  return FALSE;
1865  }
1866  if (attrs->attrmask.arr[2] & FATTR4_WORD2_SUPPATTR_EXCLCREAT) {
1867  if (!xdr_bitmap4(xdr, info->suppattr_exclcreat))
1868  return FALSE;
1869  }
1870  }
1871  return TRUE;
1872 }
1873 
1875  XDR *xdr,
1876  nfs_resop4 *resop)
1877 {
1879 
1880  if (unexpected_op(resop->op, OP_GETATTR))
1881  return FALSE;
1882 
1883  if (!xdr_u_int32_t(xdr, &res->status))
1884  return FALSE;
1885 
1886  if (res->status == NFS4_OK)
1887  {
1888  XDR attr_xdr;
1889 
1890  if (!xdr_fattr4(xdr, &res->obj_attributes))
1891  return FALSE;
1892  xdrmem_create(&attr_xdr, (char *)res->obj_attributes.attr_vals, res->obj_attributes.attr_vals_len, XDR_DECODE);
1893  return decode_file_attrs(&attr_xdr, &res->obj_attributes, res->info);
1894  }
1895  return TRUE;
1896 }
1897 
1898 
1899 /*
1900  * OP_OPEN
1901  */
1903  XDR *xdr,
1904  createhow4 *ch)
1905 {
1906  bool_t result = TRUE;
1907 
1908  if (!xdr_u_int32_t(xdr, &ch->mode))
1909  return FALSE;
1910 
1911  switch (ch->mode)
1912  {
1913  case UNCHECKED4:
1914  case GUARDED4:
1916  break;
1917  case EXCLUSIVE4:
1918  result = xdr_opaque(xdr, (char *)ch->createverf, NFS4_VERIFIER_SIZE);
1919  break;
1920  case EXCLUSIVE4_1:
1921  if (!xdr_opaque(xdr, (char *)ch->createverf, NFS4_VERIFIER_SIZE))
1922  return FALSE;
1923  if (!encode_createattrs4(xdr, ch->createattrs))
1924  return FALSE;
1925  break;
1926  }
1927  return result;
1928 }
1929 
1931  XDR *xdr,
1932  openflag4 *of)
1933 {
1934  bool_t result = TRUE;
1935 
1936  if (!xdr_u_int32_t(xdr, &of->opentype))
1937  return FALSE;
1938 
1939  switch (of->opentype)
1940  {
1941  case OPEN4_CREATE:
1942  result = encode_createhow4(xdr, &of->how);
1943  break;
1944  default:
1945  break;
1946  }
1947  return result;
1948 }
1949 
1951  XDR *xdr,
1952  stateid4 *stateid,
1954 {
1955  if (!xdr_stateid4(xdr, stateid))
1956  return FALSE;
1957  return encode_component(xdr, name);
1958 }
1959 
1961  XDR *xdr,
1962  open_claim4 *oc)
1963 {
1964  if (!xdr_u_int32_t(xdr, &oc->claim))
1965  return FALSE;
1966 
1967  switch (oc->claim)
1968  {
1969  case CLAIM_NULL:
1970  return encode_component(xdr, oc->u.null.filename);
1971  case CLAIM_PREVIOUS:
1972  return xdr_u_int32_t(xdr, &oc->u.prev.delegate_type);
1973  case CLAIM_FH:
1974  return TRUE; /* use current file handle */
1975  case CLAIM_DELEGATE_CUR:
1976  return encode_claim_deleg_cur(xdr,
1977  &oc->u.deleg_cur.delegate_stateid->stateid,
1978  oc->u.deleg_cur.name);
1979  case CLAIM_DELEG_CUR_FH:
1980  return xdr_stateid4(xdr,
1981  &oc->u.deleg_cur_fh.delegate_stateid->stateid);
1982  case CLAIM_DELEGATE_PREV:
1983  return encode_component(xdr, oc->u.deleg_prev.filename);
1984  case CLAIM_DELEG_PREV_FH:
1985  return TRUE; /* use current file handle */
1986  default:
1987  eprintf("encode_open_claim4: unsupported claim %d.\n",
1988  oc->claim);
1989  return FALSE;
1990  }
1991 }
1992 
1994  XDR *xdr,
1995  nfs_argop4 *argop)
1996 {
1998 
1999  if (unexpected_op(argop->op, OP_OPEN))
2000  return FALSE;
2001 
2002  if (!xdr_u_int32_t(xdr, &args->seqid))
2003  return FALSE;
2004 
2005  if (!xdr_u_int32_t(xdr, &args->share_access))
2006  return FALSE;
2007 
2008  if (!xdr_u_int32_t(xdr, &args->share_deny))
2009  return FALSE;
2010 
2011  if (!xdr_state_owner4(xdr, args->owner))
2012  return FALSE;
2013 
2014  if (!encode_openflag4(xdr, &args->openhow))
2015  return FALSE;
2016 
2017  return encode_open_claim4(xdr, args->claim);
2018 }
2019 
2021  XDR *xdr,
2022  open_delegation4 *delegation)
2023 {
2024  enum_t why_no_deleg;
2025  bool_t will_signal;
2026 
2027  if (!xdr_enum(xdr, (enum_t*)&why_no_deleg))
2028  return FALSE;
2029 
2030  switch (why_no_deleg)
2031  {
2032  case WND4_CONTENTION:
2033  case WND4_RESOURCE:
2034  return xdr_bool(xdr, &will_signal);
2035  default:
2036  return TRUE;
2037  }
2038 }
2039 
2041  XDR *xdr,
2042  open_delegation4 *delegation)
2043 {
2044  if (!xdr_stateid4(xdr, &delegation->stateid))
2045  return FALSE;
2046 
2047  if (!xdr_bool(xdr, &delegation->recalled))
2048  return FALSE;
2049 
2050  return xdr_nfsace4(xdr, &delegation->permissions);
2051 }
2052 
2054  XDR *xdr,
2055  uint64_t *filesize)
2056 {
2057  uint32_t blocks, bytes_per_block;
2058 
2059  if (!xdr_u_int32_t(xdr, &blocks))
2060  return FALSE;
2061 
2062  if (!xdr_u_int32_t(xdr, &bytes_per_block))
2063  return FALSE;
2064 
2065  *filesize = blocks * bytes_per_block;
2066  return TRUE;
2067 }
2068 
2072 };
2073 
2075  XDR *xdr,
2076  uint64_t *filesize)
2077 {
2078  uint32_t limitby;
2079 
2080  if (!xdr_u_int32_t(xdr, &limitby))
2081  return FALSE;
2082 
2083  switch (limitby)
2084  {
2085  case NFS_LIMIT_SIZE:
2086  return xdr_u_hyper(xdr, filesize);
2087  case NFS_LIMIT_BLOCKS:
2088  return decode_modified_limit4(xdr, filesize);
2089  default:
2090  eprintf("decode_space_limit4: limitby %d invalid\n", limitby);
2091  return FALSE;
2092  }
2093 }
2094 
2096  XDR *xdr,
2097  open_delegation4 *delegation)
2098 {
2100 
2101  if (!xdr_stateid4(xdr, &delegation->stateid))
2102  return FALSE;
2103 
2104  if (!xdr_bool(xdr, &delegation->recalled))
2105  return FALSE;
2106 
2107  if (!decode_space_limit4(xdr, &size_limit))
2108  return FALSE;
2109 
2110  return xdr_nfsace4(xdr, &delegation->permissions);
2111 }
2112 
2114  XDR *xdr,
2116 {
2117  if (!xdr_stateid4(xdr, res->stateid))
2118  return FALSE;
2119 
2120  if (!xdr_change_info4(xdr, &res->cinfo))
2121  return FALSE;
2122 
2123  if (!xdr_u_int32_t(xdr, &res->rflags))
2124  return FALSE;
2125 
2126  if (!xdr_bitmap4(xdr, &res->attrset))
2127  return FALSE;
2128 
2129  if (!xdr_enum(xdr, (enum_t*)&res->delegation->type))
2130  return FALSE;
2131 
2132  switch (res->delegation->type)
2133  {
2134  case OPEN_DELEGATE_NONE:
2135  return TRUE;
2137  return decode_open_none_delegation4(xdr, res->delegation);
2138  case OPEN_DELEGATE_READ:
2139  return decode_open_read_delegation4(xdr, res->delegation);
2140  case OPEN_DELEGATE_WRITE:
2141  return decode_open_write_delegation4(xdr, res->delegation);
2142  default:
2143  eprintf("decode_open_res_ok: delegation type %d not "
2144  "supported.\n", res->delegation->type);
2145  return FALSE;
2146  }
2147 }
2148 
2150  XDR *xdr,
2151  nfs_resop4 *resop)
2152 {
2154 
2155  if (unexpected_op(resop->op, OP_OPEN))
2156  return FALSE;
2157 
2158  if (!xdr_u_int32_t(xdr, &res->status))
2159  return FALSE;
2160 
2161  if (res->status == NFS4_OK)
2162  return decode_open_res_ok(xdr, &res->resok4);
2163 
2164  return TRUE;
2165 }
2166 
2167 
2168 /*
2169  * OP_OPENATTR
2170  */
2172  XDR *xdr,
2173  nfs_argop4 *argop)
2174 {
2176 
2177  if (unexpected_op(argop->op, OP_OPENATTR))
2178  return FALSE;
2179 
2180  return xdr_bool(xdr, &args->createdir);
2181 }
2182 
2184  XDR *xdr,
2185  nfs_resop4 *resop)
2186 {
2188 
2189  if (unexpected_op(resop->op, OP_OPENATTR))
2190  return FALSE;
2191 
2192  return xdr_u_int32_t(xdr, &res->status);
2193 }
2194 
2195 
2196 /*
2197  * OP_READ
2198  */
2200  XDR *xdr,
2201  nfs_argop4 *argop)
2202 {
2204 
2205  if (unexpected_op(argop->op, OP_READ))
2206  return FALSE;
2207 
2208  if (!xdr_stateid4(xdr, &args->stateid->stateid))
2209  return FALSE;
2210 
2211  if (!xdr_u_hyper(xdr, &args->offset))
2212  return FALSE;
2213 
2214  return xdr_u_int32_t(xdr, &args->count);
2215 }
2216 
2218  XDR *xdr,
2220 {
2221  unsigned char *data = res->data;
2222 
2223  if (!xdr_bool(xdr, &res->eof))
2224  return FALSE;
2225 
2226  return xdr_bytes(xdr, (char **)&data, &res->data_len, NFS41_MAX_FILEIO_SIZE);
2227 }
2228 
2230  XDR *xdr,
2231  nfs_resop4 *resop)
2232 {
2233  nfs41_read_res *res = (nfs41_read_res*)resop->res;
2234 
2235  if (unexpected_op(resop->op, OP_READ))
2236  return FALSE;
2237 
2238  if (!xdr_u_int32_t(xdr, &res->status))
2239  return FALSE;
2240 
2241  if (res->status == NFS4_OK)
2242  return decode_read_res_ok(xdr, &res->resok4);
2243 
2244  return TRUE;
2245 }
2246 
2247 
2248 /*
2249  * OP_READDIR
2250  */
2252  XDR *xdr,
2253  nfs_argop4 *argop)
2254 {
2256 
2257  if (unexpected_op(argop->op, OP_READDIR))
2258  return FALSE;
2259 
2260  if (!xdr_u_hyper(xdr, &args->cookie.cookie))
2261  return FALSE;
2262 
2263  if (!xdr_opaque(xdr, (char *)args->cookie.verf, NFS4_VERIFIER_SIZE))
2264  return FALSE;
2265 
2266  if (!xdr_u_int32_t(xdr, &args->dircount))
2267  return FALSE;
2268 
2269  if (!xdr_u_int32_t(xdr, &args->maxcount))
2270  return FALSE;
2271 
2272  return xdr_bitmap4(xdr, args->attr_request);
2273 }
2274 
2276  unsigned char *buf_pos;
2282 
2284  XDR *xdr,
2286 {
2287  uint64_t cookie;
2288  unsigned char name[NFS4_OPAQUE_LIMIT];
2289  unsigned char *nameptr = &name[0];
2290  uint32_t name_len, entry_len;
2291  fattr4 attrs;
2292 
2293  /* decode into temporaries so we can determine if there's enough
2294  * room in the buffer for this entry */
2296  name_len = NFS4_OPAQUE_LIMIT;
2299 
2300  if (!xdr_u_hyper(xdr, &cookie))
2301  return FALSE;
2302 
2303  if (!xdr_bytes(xdr, (char **)&nameptr, &name_len, NFS4_OPAQUE_LIMIT))
2304  return FALSE;
2305 
2306  if (!xdr_fattr4(xdr, &attrs))
2307  return FALSE;
2308 
2309  if (!xdr_bool(xdr, &it->has_next_entry))
2310  return FALSE;
2311 
2312  if (it->ignore_the_rest)
2313  return TRUE;
2314 
2315  name_len += 1; /* account for null terminator */
2316  if (entry_len + name_len <= it->remaining_len)
2317  {
2318  XDR fattr_xdr;
2320  entry->cookie = cookie;
2321  entry->name_len = name_len;
2322 
2323  if (it->has_next_entry)
2324  entry->next_entry_offset = entry_len + name_len;
2325  else
2326  entry->next_entry_offset = 0;
2327 
2328  xdrmem_create(&fattr_xdr, (char *)attrs.attr_vals, attrs.attr_vals_len, XDR_DECODE);
2329  if (!(decode_file_attrs(&fattr_xdr, &attrs, &entry->attr_info)))
2330  entry->attr_info.rdattr_error = NFS4ERR_BADXDR;
2331  StringCchCopyA(entry->name, name_len, (STRSAFE_LPCSTR)name);
2332 
2333  it->buf_pos += entry_len + name_len;
2334  it->remaining_len -= entry_len + name_len;
2335  it->last_entry_offset = &entry->next_entry_offset;
2336  }
2337  else if (it->last_entry_offset)
2338  {
2339  *(it->last_entry_offset) = 0;
2340  it->ignore_the_rest = 1;
2341  }
2342 
2343  return TRUE;
2344 }
2345 
2347  XDR *xdr,
2348  nfs41_readdir_list *dirs)
2349 {
2351  iter.buf_pos = dirs->entries;
2352  iter.remaining_len = dirs->entries_len;
2353  iter.last_entry_offset = NULL;
2354  iter.ignore_the_rest = 0;
2355  iter.has_next_entry = 0;
2356 
2357  if (!xdr_bool(xdr, &dirs->has_entries))
2358  return FALSE;
2359 
2360  if (dirs->has_entries)
2361  {
2362  do {
2363  if (!decode_readdir_entry(xdr, &iter))
2364  return FALSE;
2365 
2366  } while (iter.has_next_entry);
2367  }
2368  dirs->entries_len -= iter.remaining_len;
2369 
2370  if (!xdr_bool(xdr, &dirs->eof))
2371  return FALSE;
2372 
2373  /* reset eof if we couldn't fit everything in the buffer */
2374  if (iter.ignore_the_rest)
2375  dirs->eof = 0;
2376  return TRUE;
2377 }
2378 
2380  XDR *xdr,
2381  nfs_resop4 *resop)
2382 {
2384 
2385  if (unexpected_op(resop->op, OP_READDIR))
2386  return FALSE;
2387 
2388  if (!xdr_u_int32_t(xdr, &res->status))
2389  return FALSE;
2390 
2391  if (res->status == NFS4_OK) {
2392  if (!xdr_opaque(xdr, (char *)res->cookieverf, NFS4_VERIFIER_SIZE))
2393  return FALSE;
2394  return decode_readdir_list(xdr, &res->reply);
2395  }
2396  return TRUE;
2397 }
2398 
2399 
2400 /*
2401  * OP_READLINK
2402  */
2404  XDR *xdr,
2405  nfs_argop4 *argop)
2406 {
2407  if (unexpected_op(argop->op, OP_READLINK))
2408  return FALSE;
2409 
2410  /* void */
2411  return TRUE;
2412 }
2413 
2415  XDR *xdr,
2416  nfs_resop4 *resop)
2417 {
2419 
2420  if (unexpected_op(resop->op, OP_READLINK))
2421  return FALSE;
2422 
2423  if (!xdr_u_int32_t(xdr, &res->status))
2424  return FALSE;
2425 
2426  if (res->status == NFS4_OK) {
2427  char *link = res->link;
2428  return xdr_bytes(xdr, &link, &res->link_len, res->link_len);
2429  }
2430 
2431  return TRUE;
2432 }
2433 
2434 
2435 /*
2436  * OP_REMOVE
2437  */
2439  XDR *xdr,
2440  nfs_argop4 *argop)
2441 {
2443 
2444  if (unexpected_op(argop->op, OP_REMOVE))
2445  return FALSE;
2446 
2447  return encode_component(xdr, args->target);
2448 }
2449 
2451  XDR *xdr,
2452  nfs_resop4 *resop)
2453 {
2455 
2456  if (unexpected_op(resop->op, OP_REMOVE))
2457  return FALSE;
2458 
2459  if (!xdr_u_int32_t(xdr, &res->status))
2460  return FALSE;
2461 
2462  if (res->status == NFS4_OK)
2463  return xdr_change_info4(xdr, &res->cinfo);
2464 
2465  return TRUE;
2466 }
2467 
2468 
2469 /*
2470  * OP_RENAME
2471  */
2473  XDR *xdr,
2474  nfs_argop4 *argop)
2475 {
2477 
2478  if (unexpected_op(argop->op, OP_RENAME))
2479  return FALSE;
2480 
2481  if (!encode_component(xdr, args->oldname))
2482  return FALSE;
2483 
2484  return encode_component(xdr, args->newname);
2485 }
2486 
2488  XDR *xdr,
2489  nfs_resop4 *resop)
2490 {
2492 
2493  if (unexpected_op(resop->op, OP_RENAME))
2494  return FALSE;
2495 
2496  if (!xdr_u_int32_t(xdr, &res->status))
2497  return FALSE;
2498 
2499  if (res->status == NFS4_OK)
2500  {
2501  if (!xdr_change_info4(xdr, &res->source_cinfo))
2502  return FALSE;
2503  return xdr_change_info4(xdr, &res->target_cinfo);
2504  }
2505  return TRUE;
2506 }
2507 
2508 
2509 /*
2510  * OP_RESTOREFH
2511  */
2513  XDR *xdr,
2514  nfs_argop4 *argop)
2515 {
2516  if (unexpected_op(argop->op, OP_RESTOREFH))
2517  return FALSE;
2518 
2519  /* void */
2520  return TRUE;
2521 }
2522 
2524  XDR *xdr,
2525  nfs_resop4 *resop)
2526 {
2528 
2529  if (unexpected_op(resop->op, OP_RESTOREFH))
2530  return FALSE;
2531 
2532  return xdr_u_int32_t(xdr, &res->status);
2533 }
2534 
2535 
2536 /*
2537  * OP_SAVEFH
2538  */
2540  XDR *xdr,
2541  nfs_argop4 *argop)
2542 {
2543  if (unexpected_op(argop->op, OP_SAVEFH))
2544  return FALSE;
2545 
2546  /* void */
2547  return TRUE;
2548 }
2549 
2551  XDR *xdr,
2552  nfs_resop4 *resop)
2553 {
2555 
2556  if (unexpected_op(resop->op, OP_SAVEFH))
2557  return FALSE;
2558 
2559  return xdr_u_int32_t(xdr, &res->status);
2560 }
2561 
2562 
2563 /*
2564  * OP_SETATTR
2565  */
2567  fattr4 *attrs,
2569 {
2570  uint32_t i;
2571  XDR localxdr;
2572 
2573  xdrmem_create(&localxdr, (char *)attrs->attr_vals, NFS4_OPAQUE_LIMIT, XDR_ENCODE);
2574 
2575  attrs->attr_vals_len = 0;
2576  ZeroMemory(&attrs->attrmask, sizeof(bitmap4));
2577  attrs->attrmask.count = info->attrmask.count;
2578 
2579  if (info->attrmask.count > 0) {
2580  if (info->attrmask.arr[0] & FATTR4_WORD0_SIZE) {
2581  if (!xdr_u_hyper(&localxdr, &info->size))
2582  return FALSE;
2583  attrs->attrmask.arr[0] |= FATTR4_WORD0_SIZE;
2584  }
2585  if (info->attrmask.arr[0] & FATTR4_WORD0_ACL) {
2586  if (!xdr_nfsacl41(&localxdr, info->acl))
2587  return FALSE;
2588  attrs->attrmask.arr[0] |= FATTR4_WORD0_ACL;
2589  }
2590  if (info->attrmask.arr[0] & FATTR4_WORD0_ARCHIVE) {
2591  if (!xdr_bool(&localxdr, &info->archive))
2592  return FALSE;
2593  attrs->attrmask.arr[0] |= FATTR4_WORD0_ARCHIVE;
2594  }
2595  if (info->attrmask.arr[0] & FATTR4_WORD0_HIDDEN) {
2596  if (!xdr_bool(&localxdr, &info->hidden))
2597  return FALSE;
2598  attrs->attrmask.arr[0] |= FATTR4_WORD0_HIDDEN;
2599  }
2600  }
2601  if (info->attrmask.count > 1) {
2602  if (info->attrmask.arr[1] & FATTR4_WORD1_MODE) {
2603  if (!xdr_u_int32_t(&localxdr, &info->mode))
2604  return FALSE;
2605  attrs->attrmask.arr[1] |= FATTR4_WORD1_MODE;
2606  }
2607  if (info->attrmask.arr[1] & FATTR4_WORD1_SYSTEM) {
2608  if (!xdr_bool(&localxdr, &info->system))
2609  return FALSE;
2610  attrs->attrmask.arr[1] |= FATTR4_WORD1_SYSTEM;
2611  }
2612  if (info->attrmask.arr[1] & FATTR4_WORD1_TIME_ACCESS_SET) {
2613  if (!xdr_settime4(&localxdr, &info->time_access, info->time_delta))
2614  return FALSE;
2616  }
2617  if (info->attrmask.arr[1] & FATTR4_WORD1_TIME_CREATE) {
2618  if (!xdr_nfstime4(&localxdr, &info->time_create))
2619  return FALSE;
2620  attrs->attrmask.arr[1] |= FATTR4_WORD1_TIME_CREATE;
2621  }
2622  if (info->attrmask.arr[1] & FATTR4_WORD1_TIME_MODIFY_SET) {
2623  if (!xdr_settime4(&localxdr, &info->time_modify, info->time_delta))
2624  return FALSE;
2626  }
2627  if (info->attrmask.arr[1] & FATTR4_WORD1_OWNER) {
2628  char *ptr = &info->owner[0];
2629  uint32_t owner_len = (uint32_t)strlen(info->owner);
2630  if (!xdr_bytes(&localxdr, &ptr, &owner_len,
2632  return FALSE;
2633  attrs->attrmask.arr[1] |= FATTR4_WORD1_OWNER;
2634  }
2635  if (info->attrmask.arr[1] & FATTR4_WORD1_OWNER_GROUP) {
2636  char *ptr = &info->owner_group[0];
2637  uint32_t owner_group_len = (uint32_t)strlen(info->owner_group);
2638  if (!xdr_bytes(&localxdr, &ptr, &owner_group_len,
2640  return FALSE;
2641  attrs->attrmask.arr[1] |= FATTR4_WORD1_OWNER_GROUP;
2642  }
2643  }
2644  if (info->attrmask.count > 2) {
2645  if (info->attrmask.arr[2] & FATTR4_WORD2_MODE_SET_MASKED) {
2646  if (!xdr_u_int32_t(&localxdr, &info->mode))
2647  return FALSE;
2648  if (!xdr_u_int32_t(&localxdr, &info->mode_mask))
2649  return FALSE;
2651  }
2652  }
2653 
2654  /* warn if we try to set attributes that aren't handled */
2655  for (i = 0; i < info->attrmask.count; i++)
2656  if (attrs->attrmask.arr[i] != info->attrmask.arr[i])
2657  eprintf("encode_file_attrs() attempted to encode extra "
2658  "attributes in arr[%d]: encoded %d, but wanted %d.\n",
2659  i, attrs->attrmask.arr[i], info->attrmask.arr[i]);
2660 
2661  attrs->attr_vals_len = xdr_getpos(&localxdr);
2662  return TRUE;
2663 }
2664 
2666  XDR *xdr,
2667  nfs_argop4 *argop)
2668 {
2670  fattr4 attrs;
2671 
2672  if (unexpected_op(argop->op, OP_SETATTR))
2673  return FALSE;
2674 
2675  if (!xdr_stateid4(xdr, &args->stateid->stateid))
2676  return FALSE;
2677 
2678  /* encode attribute values from args->info into attrs.attr_vals */
2679  attrs.attr_vals_len = NFS4_OPAQUE_LIMIT;
2680  if (!encode_file_attrs(&attrs, args->info))
2681  return FALSE;
2682 
2683  return xdr_fattr4(xdr, &attrs);
2684 }
2685 
2687  XDR *xdr,
2688  nfs_resop4 *resop)
2689 {
2691 
2692  if (unexpected_op(resop->op, OP_SETATTR))
2693  return FALSE;
2694 
2695  if (!xdr_u_int32_t(xdr, &res->status))
2696  return FALSE;
2697 
2698  if (res->status == NFS4_OK)
2699  return xdr_bitmap4(xdr, &res->attrsset);
2700 
2701  return TRUE;
2702 }
2703 
2704 
2705 /*
2706  * OP_WANT_DELEGATION
2707  */
2709  XDR *xdr,
2710  nfs_argop4 *argop)
2711 {
2713 
2715  return FALSE;
2716 
2717  if (!xdr_u_int32_t(xdr, &args->want))
2718  return FALSE;
2719 
2720  if (!xdr_u_int32_t(xdr, &args->claim->claim))
2721  return FALSE;
2722 
2723  return args->claim->claim != CLAIM_PREVIOUS ||
2724  xdr_u_int32_t(xdr, &args->claim->prev_delegate_type);
2725 }
2726 
2728  XDR *xdr,
2729  nfs_resop4 *resop)
2730 {
2732 
2734  return FALSE;
2735 
2736  if (!xdr_u_int32_t(xdr, &res->status))
2737  return FALSE;
2738 
2739  if (res->status)
2740  return TRUE;
2741 
2742  if (!xdr_enum(xdr, (enum_t*)&res->delegation->type))
2743  return FALSE;
2744 
2745  switch (res->delegation->type)
2746  {
2747  case OPEN_DELEGATE_NONE:
2748  return TRUE;
2750  return decode_open_none_delegation4(xdr, res->delegation);
2751  case OPEN_DELEGATE_READ:
2752  return decode_open_read_delegation4(xdr, res->delegation);
2753  case OPEN_DELEGATE_WRITE:
2754  return decode_open_write_delegation4(xdr, res->delegation);
2755  default:
2756  eprintf("decode_open_res_ok: delegation type %d not "
2757  "supported.\n", res->delegation->type);
2758  return FALSE;
2759  }
2760 }
2761 
2762 
2763 /*
2764  * OP_FREE_STATEID
2765  */
2767  XDR *xdr,
2768  nfs_argop4 *argop)
2769 {
2771 
2772  if (unexpected_op(argop->op, OP_FREE_STATEID))
2773  return FALSE;
2774 
2775  return xdr_stateid4(xdr, args->stateid);
2776 }
2777 
2779  XDR *xdr,
2780  nfs_resop4 *resop)
2781 {
2783 
2784  if (unexpected_op(resop->op, OP_FREE_STATEID))
2785  return FALSE;
2786 
2787  return xdr_u_int32_t(xdr, &res->status);
2788 }
2789 
2790 
2791 /*
2792  * OP_TEST_STATEID
2793  */
2795  XDR *xdr,
2796  nfs_argop4 *argop)
2797 {
2799 
2800  if (unexpected_op(argop->op, OP_TEST_STATEID))
2801  return FALSE;
2802 
2803  return xdr_array(xdr, (char**)&args->stateids, &args->count,
2804  args->count, sizeof(stateid_arg), (xdrproc_t)xdr_stateid4);
2805 }
2806 
2808  XDR *xdr,
2809  nfs_resop4 *resop)
2810 {
2812 
2813  if (unexpected_op(resop->op, OP_TEST_STATEID))
2814  return FALSE;
2815 
2816  if (!xdr_u_int32_t(xdr, &res->status))
2817  return FALSE;
2818 
2819  if (res->status == NFS4_OK) {
2820  return xdr_array(xdr, (char**)&res->resok.status, &res->resok.count,
2821  res->resok.count, sizeof(uint32_t), (xdrproc_t)xdr_u_int32_t);
2822  }
2823  return TRUE;
2824 }
2825 
2826 
2827 /*
2828  * OP_WRITE
2829  */
2831  XDR *xdr,
2832  nfs_argop4 *argop)
2833 {
2835  unsigned char *data = args->data;
2836 
2837  if (unexpected_op(argop->op, OP_WRITE))
2838  return FALSE;
2839 
2840  if (!xdr_stateid4(xdr, &args->stateid->stateid))
2841  return FALSE;
2842 
2843  if (!xdr_u_hyper(xdr, &args->offset))
2844  return FALSE;
2845 
2846  if (!xdr_u_int32_t(xdr, &args->stable))
2847  return FALSE;
2848 
2849  return xdr_bytes(xdr, (char **)&data, &args->data_len, NFS41_MAX_FILEIO_SIZE);
2850 }
2851 
2853  XDR *xdr,
2854  nfs41_write_verf *verf)
2855 {
2856  if (!xdr_enum(xdr, (enum_t *)&verf->committed))
2857  return FALSE;
2858 
2859  return xdr_opaque(xdr, (char *)verf->verf, NFS4_VERIFIER_SIZE);
2860 }
2861 
2863  XDR *xdr,
2865 {
2866  if (!xdr_u_int32_t(xdr, &res->count))
2867  return FALSE;
2868 
2869  return xdr_write_verf(xdr, res->verf);
2870 }
2871 
2873  XDR *xdr,
2874  nfs_resop4 *resop)
2875 {
2876  nfs41_write_res *res = (nfs41_write_res*)resop->res;
2877 
2878  if (unexpected_op(resop->op, OP_WRITE))
2879  return FALSE;
2880 
2881  if (!xdr_u_int32_t(xdr, &res->status))
2882  return FALSE;
2883 
2884  if (res->status == NFS4_OK)
2885  return xdr_write_res_ok(xdr, &res->resok4);
2886 
2887  return TRUE;
2888 }
2889 
2890 /*
2891  * OP_SECINFO_NO_NAME
2892  */
2894  XDR *xdr,
2895  nfs41_secinfo_info *secinfo)
2896 {
2897  if (!xdr_u_int32_t(xdr, &secinfo->sec_flavor))
2898  return FALSE;
2899  if (secinfo->sec_flavor == RPCSEC_GSS) {
2900  char *p = secinfo->oid;
2901  if (!xdr_bytes(xdr, (char **)&p, &secinfo->oid_len, MAX_OID_LEN))
2902  return FALSE;
2903  if (!xdr_u_int32_t(xdr, &secinfo->qop))
2904  return FALSE;
2905  if (!xdr_enum(xdr, (enum_t *)&secinfo->type))
2906  return FALSE;
2907  }
2908  return TRUE;
2909 }
2910 
2912  XDR *xdr,
2913  nfs_argop4 *argop)
2914 {
2916 
2918  return FALSE;
2919 
2920  if (!xdr_enum(xdr, (enum_t *)&args->type))
2921  return FALSE;
2922 
2923  return TRUE;
2924 }
2925 
2927  XDR *xdr,
2928  nfs_resop4 *resop)
2929 {
2931  nfs41_secinfo_info *secinfo = res->secinfo;
2933  return FALSE;
2934 
2935  if (!xdr_u_int32_t(xdr, &res->status))
2936  return FALSE;
2937 
2938  if (res->status == NFS4_OK)
2939  return xdr_array(xdr, (char**)&secinfo, &res->count,
2941 
2942  return TRUE;
2943 }
2944 
2945 /*
2946  * OP_SECINFO
2947  */
2949  XDR *xdr,
2950  nfs_argop4 *argop)
2951 {
2953 
2954  if (unexpected_op(argop->op, OP_SECINFO))
2955  return FALSE;
2956 
2957  if (!encode_component(xdr, args->name))
2958  return FALSE;
2959 
2960  return TRUE;
2961 }
2962 
2964  XDR *xdr,
2965  nfs_resop4 *resop)
2966 {
2968  nfs41_secinfo_info *secinfo = res->secinfo;
2969 
2970  if (unexpected_op(resop->op, OP_SECINFO))
2971  return FALSE;
2972 
2973  if (!xdr_u_int32_t(xdr, &res->status))
2974  return FALSE;
2975 
2976  if (res->status == NFS4_OK)
2977  return xdr_array(xdr, (char**)&secinfo, &res->count,
2979 
2980  return TRUE;
2981 }
2982 /*
2983  * OP_GETDEVICEINFO
2984  */
2986  XDR *xdr,
2987  nfs_argop4 *argop)
2988 {
2990 
2991  if (unexpected_op(argop->op, OP_GETDEVICEINFO))
2992  return FALSE;
2993 
2994  if (!xdr_opaque(xdr, (char *)args->deviceid, PNFS_DEVICEID_SIZE))
2995  return FALSE;
2996 
2997  if (!xdr_enum(xdr, (enum_t *)&args->layout_type))
2998  return FALSE;
2999 
3000  if (!xdr_u_int32_t(xdr, &args->maxcount))
3001  return FALSE;
3002 
3003  return xdr_bitmap4(xdr, &args->notify_types);
3004 }
3005 
3007  XDR *xdr,
3009 {
3010  uint32_t i, count;
3011 
3012  if (!xdr_u_int32_t(xdr, &count))
3013  return FALSE;
3014 
3015  if (count && count != indices->count) {
3016  uint32_t *tmp;
3017  tmp = realloc(indices->arr, count * sizeof(uint32_t));
3018  if (tmp == NULL)
3019  return FALSE;
3020  indices->arr = tmp;
3021  ZeroMemory(indices->arr, count * sizeof(uint32_t));
3022  indices->count = count;
3023  }
3024 
3025  for (i = 0; i < indices->count; i++) {
3026  if (!xdr_u_int32_t(xdr, &indices->arr[i]))
3027  return FALSE;
3028  }
3029  return TRUE;
3030 }
3031 
3033  XDR *xdr,
3034  netaddr4 *addr)
3035 {
3036  uint32_t len;
3037  char *netid = addr->netid;
3038  char *uaddr = addr->uaddr;
3039 
3040  if (xdr->x_op == XDR_ENCODE)
3041  len = sizeof(addr->netid);
3042  if (!xdr_bytes(xdr, &netid, &len, NFS41_NETWORK_ID_LEN))
3043  return FALSE;
3044 
3045  if (xdr->x_op == XDR_DECODE) {
3046  if (len < NFS41_NETWORK_ID_LEN)
3047  addr->netid[len] = 0;
3048  else
3049  addr->netid[NFS41_NETWORK_ID_LEN] = 0;
3050  }
3051 
3052  if (xdr->x_op == XDR_ENCODE)
3053  len = sizeof(addr->uaddr);
3054  if (!xdr_bytes(xdr, &uaddr, &len, NFS41_UNIVERSAL_ADDR_LEN))
3055  return FALSE;
3056 
3057  if (xdr->x_op == XDR_DECODE){
3059  addr->uaddr[len] = 0;
3060  else
3061  addr->uaddr[NFS41_UNIVERSAL_ADDR_LEN] = 0;
3062  }
3063 
3064  return TRUE;
3065 }
3066 
3068  XDR *xdr,
3069  multi_addr4 *list)
3070 {
3071  netaddr4 dummy, *dest;
3072  uint32_t i;
3073 
3074  if (!xdr_u_int32_t(xdr, &list->count))
3075  return FALSE;
3076 
3077  for (i = 0; i < list->count; i++) {
3078  /* if there are too many addrs, decode the extras into 'dummy' */
3079  dest = i < NFS41_ADDRS_PER_SERVER ? &list->arr[i] : &dummy;
3080 
3081  if (!xdr_pnfs_addr(xdr, dest))
3082  return FALSE;
3083  }
3084  return TRUE;
3085 }
3086 
3088  XDR *xdr,
3089  pnfs_data_server_list *servers)
3090 {
3091  uint32_t i, count;
3092 
3093  if (!xdr_u_int32_t(xdr, &count))
3094  return FALSE;
3095 
3096  if (count && count != servers->count) {
3097  pnfs_data_server *tmp;
3098  /* clear data server clients; they're still cached with nfs41_root,
3099  * so pnfs_data_server_client() will look them up again */
3100  for (i = 0; i < servers->count; i++)
3101  servers->arr[i].client = NULL;
3102 
3103  tmp = realloc(servers->arr, count * sizeof(pnfs_data_server));
3104  if (tmp == NULL)
3105  return FALSE;
3106  servers->arr = tmp;
3107  ZeroMemory(servers->arr, count * sizeof(pnfs_data_server));
3108  for (i = servers->count; i < count; i++) /* initialize new elements */
3109  InitializeSRWLock(&servers->arr[i].lock);
3110  servers->count = count;
3111  }
3112 
3113  for (i = 0; i < servers->count; i++) {
3114  if (!xdr_multi_addr(xdr, &servers->arr[i].addrs))
3115  return FALSE;
3116  }
3117  return TRUE;
3118 }
3119 
3121  XDR *xdr,
3123 {
3124  if (!xdr_stripe_indices(xdr, &device->stripes))
3125  return FALSE;
3126 
3127  return xdr_data_server_list(xdr, &device->servers);
3128 }
3129 
3131  XDR *xdr,
3132  pnfs_getdeviceinfo_res_ok *res_ok)
3133 {
3134  u_int32_t len_ignored;
3135 
3136  if (!xdr_enum(xdr, (enum_t *)&res_ok->device->device.type))
3137  return FALSE;
3138 
3139  if (res_ok->device->device.type != PNFS_LAYOUTTYPE_FILE)
3140  return FALSE;
3141 
3142  if (!xdr_u_int32_t(xdr, &len_ignored))
3143  return FALSE;
3144 
3145  if (!xdr_file_device(xdr, res_ok->device))
3146  return FALSE;
3147 
3148  return xdr_bitmap4(xdr, &res_ok->notification);
3149 }
3150 
3152  XDR *xdr,
3153  nfs_resop4 *resop)
3154 {
3156 
3157  if (unexpected_op(resop->op, OP_GETDEVICEINFO))
3158  return FALSE;
3159 
3160  if (!xdr_u_int32_t(xdr, (uint32_t *)&res->status))
3161  return FALSE;
3162 
3163  switch (res->status) {
3164  case NFS4_OK:
3165  return decode_getdeviceinfo_ok(xdr, &res->u.res_ok);
3166  break;
3167  case NFS4ERR_TOOSMALL:
3168  {
3169  uint32_t ignored;
3170  return xdr_u_int32_t(xdr, &ignored);
3171  }
3172  break;
3173  }
3174  return TRUE;
3175 }
3176 
3177 
3178 /*
3179  * OP_LAYOUTCOMMIT
3180  */
3182  XDR *xdr,
3183  nfs_argop4 *argop)
3184 {
3186  bool_t false_bool = FALSE;
3187  bool_t true_bool = TRUE;
3189  uint32_t zero = 0;
3190 
3191  if (unexpected_op(argop->op, OP_LAYOUTCOMMIT))
3192  return FALSE;
3193 
3194  if (!xdr_u_hyper(xdr, &args->offset))
3195  return FALSE;
3196 
3197  if (!xdr_u_hyper(xdr, &args->length))
3198  return FALSE;
3199 
3200  if (!xdr_bool(xdr, &false_bool)) /* loca_reclaim = 0 */
3201  return FALSE;
3202 
3203  if (!xdr_stateid4(xdr, args->stateid))
3204  return FALSE;
3205 
3206  /* loca_last_write_offset */
3207  if (args->new_offset) {
3208  if (!xdr_bool(xdr, &true_bool))
3209  return FALSE;
3210 
3211  if (!xdr_u_hyper(xdr, args->new_offset))
3212  return FALSE;
3213  } else {
3214  if (!xdr_bool(xdr, &false_bool))
3215  return FALSE;
3216  }
3217 
3218  /* loca_time_modify */
3219  if (args->new_time) {
3220  if (!xdr_bool(xdr, &true_bool))
3221  return FALSE;
3222 
3223  if (!xdr_nfstime4(xdr, args->new_time))
3224  return FALSE;
3225  } else {
3226  if (!xdr_bool(xdr, &false_bool))
3227  return FALSE;
3228  }
3229 
3230  /* loca_layoutupdate */
3231  if (!xdr_enum(xdr, &pnfs_layout))
3232  return FALSE;
3233 
3234  return xdr_u_int32_t(xdr, &zero);
3235 }
3236 
3238  XDR *xdr,
3239  nfs_resop4 *resop)
3240 {
3242 
3243  if (unexpected_op(resop->op, OP_LAYOUTCOMMIT))
3244  return FALSE;
3245 
3246  if (!xdr_u_int32_t(xdr, &res->status))
3247  return FALSE;
3248 
3249  if (res->status == NFS4_OK) {
3250  if (!xdr_bool(xdr, &res->has_new_size))
3251  return FALSE;
3252 
3253  if (res->has_new_size)
3254  if (!xdr_u_hyper(xdr, &res->new_size))
3255  return FALSE;
3256  }
3257  return TRUE;
3258 }
3259 
3260 /*
3261  * OP_LAYOUTGET
3262  */
3264  XDR *xdr,
3265  nfs_argop4 *argop)
3266 {
3268 
3269  if (unexpected_op(argop->op, OP_LAYOUTGET))
3270  return FALSE;
3271 
3272  if (!xdr_bool(xdr, &args->signal_layout_avail))
3273  return FALSE;
3274 
3275  if (!xdr_u_int32_t(xdr, (u_int32_t *)&args->layout_type))
3276  return FALSE;
3277 
3278  if (!xdr_u_int32_t(xdr, (u_int32_t *)&args->iomode))
3279  return FALSE;
3280 
3281  if (!xdr_u_hyper(xdr, &args->offset))
3282  return FALSE;
3283 
3284  if (!xdr_u_hyper(xdr, &args->length))
3285  return FALSE;
3286 
3287  if (!xdr_u_hyper(xdr, &args->minlength))
3288  return FALSE;
3289 
3290  if (!xdr_stateid4(xdr, &args->stateid->stateid))
3291  return FALSE;
3292 
3293  return xdr_u_int32_t(xdr, &args->maxcount);
3294 }
3295 
3297  XDR *xdr,
3299 {
3300  uint32_t i, count;
3301 
3302  if (!xdr_u_int32_t(xdr, &count))
3303  return FALSE;
3304 
3305  if (count && count != handles->count) {
3306  nfs41_path_fh *tmp;
3307  tmp = realloc(handles->arr, count * sizeof(nfs41_path_fh));
3308  if (tmp == NULL)
3309  return FALSE;
3310  handles->arr = tmp;
3311  ZeroMemory(handles->arr, count * sizeof(nfs41_path_fh));
3312  handles->count = count;
3313  }
3314 
3315  for (i = 0; i < handles->count; i++) {
3316  if (!xdr_fh(xdr, &handles->arr[i].fh))
3317  return FALSE;
3318  }
3319  return TRUE;
3320 }
3321 
3323  XDR *xdr,
3324  struct list_entry *list,
3325  pnfs_layout *base)
3326 {
3328  u_int32_t len_ignored;
3329 
3330  if (!xdr_u_int32_t(xdr, &len_ignored))
3331  return FALSE;
3332 
3333  layout = calloc(1, sizeof(pnfs_file_layout));
3334  if (layout == NULL)
3335  return FALSE;
3336 
3337  layout->layout.offset = base->offset;
3338  layout->layout.length = base->length;
3339  layout->layout.iomode = base->iomode;
3340  layout->layout.type = base->type;
3341  list_init(&layout->layout.entry);
3342 
3343  if (!xdr_opaque(xdr, (char *)layout->deviceid, PNFS_DEVICEID_SIZE))
3344  goto out_error;
3345 
3346  if (!xdr_u_int32_t(xdr, &layout->util))
3347  goto out_error;
3348 
3349  if (!xdr_u_int32_t(xdr, &layout->first_index))
3350  goto out_error;
3351 
3352  if (!xdr_u_hyper(xdr, &layout->pattern_offset))
3353  goto out_error;
3354 
3355  if (!decode_file_layout_handles(xdr, &layout->filehandles))
3356  goto out_error;
3357 
3358  list_add_tail(list, &layout->layout.entry);
3359  return TRUE;
3360 
3361 out_error:
3362  free(layout);
3363  return FALSE;
3364 }
3365 
3367  XDR *xdr,
3368  struct list_entry *list)
3369 {
3371 
3372  if (!xdr_u_hyper(xdr, &layout.offset))
3373  return FALSE;
3374 
3375  if (!xdr_u_hyper(xdr, &layout.length))
3376  return FALSE;
3377 
3378  if (!xdr_enum(xdr, (enum_t *)&layout.iomode))
3379  return FALSE;
3380 
3381  if (!xdr_enum(xdr, (enum_t *)&layout.type))
3382  return FALSE;
3383 
3384  switch (layout.type) {
3385  case PNFS_LAYOUTTYPE_FILE:
3386  return decode_file_layout(xdr, list, &layout);
3387 
3388  default:
3389  eprintf("%s: received non-FILE layout type, %d\n",
3390  "decode_file_layout", layout.type);
3391  }
3392  return FALSE;
3393 }
3394 
3396  XDR *xdr,
3398 {
3399  uint32_t i;
3400 
3401  if (!xdr_bool(xdr, &res->return_on_close))
3402  return FALSE;
3403 
3404  if (!xdr_stateid4(xdr, &res->stateid))
3405  return FALSE;
3406 
3407  if (!xdr_u_int32_t(xdr, &res->count))
3408  return FALSE;
3409 
3410  for (i = 0; i < res->count; i++)
3411  if (!decode_layout(xdr, &res->layouts))
3412  return FALSE;
3413  return TRUE;
3414 }
3415 
3417  XDR *xdr,
3418  nfs_resop4 *resop)
3419 {
3421 
3422  if (unexpected_op(resop->op, OP_LAYOUTGET))
3423  return FALSE;
3424 
3425  if (!xdr_u_int32_t(xdr, (uint32_t *)&res->status))
3426  return FALSE;
3427 
3428  switch (res->status) {
3429  case NFS4_OK:
3430  return decode_layout_res_ok(xdr, res->u.res_ok);
3432  return xdr_bool(xdr, &res->u.will_signal_layout_avail);
3433  }
3434  return TRUE;
3435 }
3436 
3437 
3438 /*
3439  * OP_LAYOUTRETURN
3440  */
3442  XDR *xdr,
3443  nfs_argop4 *argop)
3444 {
3446 
3447  if (unexpected_op(argop->op, OP_LAYOUTRETURN))
3448  return FALSE;
3449 
3450  if (!xdr_bool(xdr, &args->reclaim))
3451  return FALSE;
3452 
3453  if (!xdr_enum(xdr, (enum_t *)&args->type))
3454  return FALSE;
3455 
3456  if (!xdr_enum(xdr, (enum_t *)&args->iomode))
3457  return FALSE;
3458 
3459  if (!xdr_enum(xdr, (enum_t *)&args->return_type))
3460  return FALSE;
3461 
3462  if (args->return_type == PNFS_RETURN_FILE) {
3463  u_int32_t zero = 0;
3464 
3465  if (!xdr_u_hyper(xdr, &args->offset))
3466  return FALSE;
3467 
3468  if (!xdr_u_hyper(xdr, &args->length))
3469  return FALSE;
3470 
3471  if (!xdr_stateid4(xdr, args->stateid))
3472  return FALSE;
3473 
3474  return xdr_u_int32_t(xdr, &zero); /* size of lrf_body is 0 */
3475  } else {
3476  eprintf("%s: layout type (%d) is not PNFS_RETURN_FILE!\n",
3477  "encode_op_layoutreturn", args->return_type);
3478  return FALSE;
3479  }
3480 }
3481 
3483  XDR *xdr,
3484  nfs_resop4 *resop)
3485 {
3487 
3488  if (unexpected_op(resop->op, OP_LAYOUTRETURN))
3489  return FALSE;
3490 
3491  if (!xdr_u_int32_t(xdr, (uint32_t *)&res->status))
3492  return FALSE;
3493 
3494  if (res->status == NFS4_OK) {
3495  if (!xdr_bool(xdr, &res->stateid_present))
3496  return FALSE;
3497 
3498  if (res->stateid_present)
3499  return xdr_stateid4(xdr, &res->stateid);
3500  }
3501  return TRUE;
3502 }
3503 
3504 
3505 /* op encode/decode table */
3508 
3509 typedef struct __op_table_entry {
3512 } op_table_entry;
3513 
3514 /* table of encode/decode functions, indexed by operation number */
3515 static const op_table_entry g_op_table[] = {
3516  { NULL, NULL }, /* 0 unused */
3517  { NULL, NULL }, /* 1 unused */
3518  { NULL, NULL }, /* 2 unused */
3519  { encode_op_access, decode_op_access }, /* OP_ACCESS = 3 */
3520  { encode_op_close, decode_op_close }, /* OP_CLOSE = 4 */
3521  { encode_op_commit, decode_op_commit }, /* OP_COMMIT = 5 */
3522  { encode_op_create, decode_op_create }, /* OP_CREATE = 6 */
3523  { encode_op_delegpurge, decode_op_delegpurge }, /* OP_DELEGPURGE = 7 */
3524  { encode_op_delegreturn, decode_op_delegreturn }, /* OP_DELEGRETURN = 8 */
3525  { encode_op_getattr, decode_op_getattr }, /* OP_GETATTR = 9 */
3526  { encode_op_getfh, decode_op_getfh }, /* OP_GETFH = 10 */
3527  { encode_op_link, decode_op_link }, /* OP_LINK = 11 */
3528  { encode_op_lock, decode_op_lock }, /* OP_LOCK = 12 */
3529  { encode_op_lockt, decode_op_lockt }, /* OP_LOCKT = 13 */
3530  { encode_op_locku, decode_op_locku }, /* OP_LOCKU = 14 */
3531  { encode_op_lookup, decode_op_lookup }, /* OP_LOOKUP = 15 */
3532  { NULL, NULL }, /* OP_LOOKUPP = 16 */
3533  { NULL, NULL }, /* OP_NVERIFY = 17 */
3534  { encode_op_open, decode_op_open }, /* OP_OPEN = 18 */
3535  { encode_op_openattr, decode_op_openattr }, /* OP_OPENATTR = 19 */
3536  { NULL, NULL }, /* OP_OPEN_CONFIRM = 20 */
3537  { NULL, NULL }, /* OP_OPEN_DOWNGRADE = 21 */
3538  { encode_op_putfh, decode_op_putfh }, /* OP_PUTFH = 22 */
3539  { NULL, NULL }, /* OP_PUTPUBFH = 23 */
3540  { encode_op_putrootfh, decode_op_putrootfh }, /* OP_PUTROOTFH = 24 */
3541  { encode_op_read, decode_op_read }, /* OP_READ = 25 */
3542  { encode_op_readdir, decode_op_readdir }, /* OP_READDIR = 26 */
3543  { encode_op_readlink, decode_op_readlink }, /* OP_READLINK = 27 */
3544  { encode_op_remove, decode_op_remove }, /* OP_REMOVE = 28 */
3545  { encode_op_rename, decode_op_rename }, /* OP_RENAME = 29 */
3546  { NULL, NULL }, /* OP_RENEW = 30 */
3547  { encode_op_restorefh, decode_op_restorefh }, /* OP_RESTOREFH = 31 */
3548  { encode_op_savefh, decode_op_savefh }, /* OP_SAVEFH = 32 */
3549  { encode_op_secinfo, decode_op_secinfo }, /* OP_SECINFO = 33 */
3550  { encode_op_setattr, decode_op_setattr }, /* OP_SETATTR = 34 */
3551  { NULL, NULL }, /* OP_SETCLIENTID = 35 */
3552  { NULL, NULL }, /* OP_SETCLIENTID_CONFIRM = 36 */
3553  { NULL, NULL }, /* OP_VERIFY = 37 */
3554  { encode_op_write, decode_op_write }, /* OP_WRITE = 38 */
3555  { NULL, NULL }, /* OP_RELEASE_LOCKOWNER = 39 */
3556  { NULL, NULL }, /* OP_BACKCHANNEL_CTL = 40 */
3557  { encode_op_bind_conn_to_session, decode_op_bind_conn_to_session }, /* OP_BIND_CONN_TO_SESSION = 41 */
3558  { encode_op_exchange_id, decode_op_exchange_id }, /* OP_EXCHANGE_ID = 42 */
3559  { encode_op_create_session, decode_op_create_session }, /* OP_CREATE_SESSION = 43 */
3560  { encode_op_destroy_session, decode_op_destroy_session }, /* OP_DESTROY_SESSION = 44 */
3561  { encode_op_free_stateid, decode_op_free_stateid }, /* OP_FREE_STATEID = 45 */
3562  { NULL, NULL }, /* OP_GET_DIR_DELEGATION = 46 */
3563  { encode_op_getdeviceinfo, decode_op_getdeviceinfo }, /* OP_GETDEVICEINFO = 47 */
3564  { NULL, NULL }, /* OP_GETDEVICELIST = 48 */
3565  { encode_op_layoutcommit, decode_op_layoutcommit }, /* OP_LAYOUTCOMMIT = 49 */
3566  { encode_op_layoutget, decode_op_layoutget }, /* OP_LAYOUTGET = 50 */
3567  { encode_op_layoutreturn, decode_op_layoutreturn }, /* OP_LAYOUTRETURN = 51 */
3568  { encode_op_secinfo_noname, decode_op_secinfo_noname }, /* OP_SECINFO_NO_NAME = 52 */
3569  { encode_op_sequence, decode_op_sequence }, /* OP_SEQUENCE = 53 */
3570  { NULL, NULL }, /* OP_SET_SSV = 54 */
3571  { encode_op_test_stateid, decode_op_test_stateid }, /* OP_TEST_STATEID = 55 */
3572  { encode_op_want_delegation, decode_op_want_delegation }, /* OP_WANT_DELEGATION = 56 */
3573  { encode_op_destroy_clientid, decode_op_destroy_clientid }, /* OP_DESTROY_CLIENTID = 57 */
3574  { encode_op_reclaim_complete, decode_op_reclaim_complete }, /* OP_RECLAIM_COMPLETE = 58 */
3575 };
3576 #ifdef __REACTOS__
3577 static const uint32_t g_op_table_size = (sizeof(g_op_table) / sizeof(g_op_table[0]));
3578 #else
3580 #endif
3581 
3583 {
3584  return op >= g_op_table_size ? NULL : &g_op_table[op];
3585 }
3586 
3587 
3588 /*
3589  * COMPOUND
3590  */
3592  XDR *xdr,
3593  caddr_t *pargs)
3594 {
3595  unsigned char *tag;
3596 
3598  uint32_t i;
3599  const op_table_entry *entry;
3600 
3601  tag = args->tag;
3602  if (!xdr_bytes(xdr, (char **)&tag, &args->tag_len, NFS4_OPAQUE_LIMIT))
3603  return FALSE;
3604 
3605  if (!xdr_u_int32_t(xdr, &args->minorversion))
3606  return FALSE;
3607 
3608  if (!xdr_u_int32_t(xdr, &args->argarray_count))
3609  return FALSE;
3610 
3611  for (i = 0; i < args->argarray_count; i++)
3612  {
3613  entry = op_table_find(args->argarray[i].op);
3614  if (entry == NULL || entry->encode == NULL)
3615  return FALSE;
3616 
3617  if (!xdr_u_int32_t(xdr, &args->argarray[i].op))
3618  return FALSE;
3619  if (!entry->encode(xdr, &args->argarray[i]))
3620  return FALSE;
3621  }
3622  return TRUE;
3623 }
3624 
3626  XDR *xdr,
3627  caddr_t *pres)
3628 {
3630  uint32_t i, expected_count, expected_op;
3631  const op_table_entry *entry;
3632  unsigned char *tag = res->tag;
3633 
3634  if (!xdr_u_int32_t(xdr, &res->status))
3635  return FALSE;
3636 
3637  if (!xdr_bytes(xdr, (char **)&tag, &res->tag_len, NFS4_OPAQUE_LIMIT))
3638  return FALSE;
3639 
3640  expected_count = res->resarray_count;
3641  if (!xdr_u_int32_t(xdr, &res->resarray_count))
3642  return FALSE;
3643 
3644  /* validate the number of operations against what we sent */
3645  if (res->resarray_count > expected_count) {
3646  eprintf("reply with %u operations, only sent %u!\n",
3647  res->resarray_count, expected_count);
3648  return FALSE;
3649  } else if (res->resarray_count < expected_count &&
3650  res->status == NFS4_OK) {
3651  /* illegal for a server to reply with less operations,
3652  * unless one of them fails */
3653  eprintf("successful reply with only %u operations, sent %u!\n",
3654  res->resarray_count, expected_count);
3655  return FALSE;
3656  }
3657 
3658  for (i = 0; i < res->resarray_count; i++)
3659  {
3660  expected_op = res->resarray[i].op;
3661  if (!xdr_u_int32_t(xdr, &res->resarray[i].op))
3662  return FALSE;
3663 
3664  /* validate each operation number against what we sent */
3665  if (res->resarray[i].op != expected_op) {
3666  eprintf("reply with %s in operation %u, expected %s!\n",
3667  nfs_opnum_to_string(res->resarray[i].op), i+1,
3668  nfs_opnum_to_string(expected_op));
3669  return FALSE;
3670  }
3671 
3672  entry = op_table_find(res->resarray[i].op);
3673  if (entry == NULL || entry->decode == NULL)
3674  return FALSE;
3675  if (!entry->decode(xdr, &res->resarray[i]))
3676  return FALSE;
3677  }
3678  return TRUE;
3679 }
static bool_t decode_file_attrs(XDR *xdr, fattr4 *attrs, nfs41_file_info *info)
Definition: nfs41_xdr.c:1706
#define realloc
Definition: debug_ros.c:6
#define xdr_getpos(xdrs)
Definition: xdr.h:201
static bool_t decode_file_layout_handles(XDR *xdr, pnfs_file_layout_handles *handles)
Definition: nfs41_xdr.c:3296
bool_t xdr_array(XDR *xdrs, caddr_t *addrp, u_int *sizep, u_int maxsize, u_int elsize, xdrproc_t elproc)
Definition: xdr_array.c:61
static bool_t xdr_change_info4(XDR *xdr, change_info4 *cinfo)
Definition: nfs41_xdr.c:1371
static bool_t xdr_state_protect4_r(XDR *xdr, state_protect4_r *spr)
Definition: nfs41_xdr.c:629
static bool_t xdr_threshold_item(XDR *xdr, threshold_item4 *item)
Definition: nfs41_xdr.c:248
unsigned char * entries
Definition: nfs41_ops.h:721
static bool_t xdr_nfsace4(XDR *xdr, nfsace4 *ace)
Definition: nfs41_xdr.c:294
GLuint GLuint GLsizei GLenum const GLvoid * indices
Definition: gl.h:1545
static bool_t decode_layout_res_ok(XDR *xdr, pnfs_layoutget_res_ok *res)
Definition: nfs41_xdr.c:3395
static bool_t decode_op_remove(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:2450
static bool_t encode_op_create(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:1353
static bool_t encode_op_getfh(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:1134
static bool_t encode_op_read(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:2199
static bool_t xdr_pnfs_addr(XDR *xdr, netaddr4 *addr)
Definition: nfs41_xdr.c:3032
#define TRUE
Definition: types.h:120
static bool_t decode_open_none_delegation4(XDR *xdr, open_delegation4 *delegation)
Definition: nfs41_xdr.c:2020
static bool_t encode_op_link(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:1409
static bool_t decode_op_test_stateid(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:2807
static bool_t encode_op_delegpurge(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:1636
static uint32_t settime_how(nfstime4 *newtime, const nfstime4 *time_delta)
Definition: nfs41_xdr.c:98
static bool_t decode_op_readlink(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:2414
bool_t xdr_u_hyper(XDR *xdrs, u_longlong_t *ullp)
Definition: xdr.c:878
uint32_t acemask
Definition: nfs41_types.h:133
static bool_t xdr_layout_types(XDR *xdr, uint32_t *layout_type)
Definition: nfs41_xdr.c:222
static bool_t decode_op_rename(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:2487
static bool_t decode_op_create(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:1384
Definition: nfs41_ops.h:710
#define NFS4_SESSIONID_SIZE
Definition: nfs41_const.h:32
static bool_t encode_claim_deleg_cur(XDR *xdr, stateid4 *stateid, nfs41_component *name)
Definition: nfs41_xdr.c:1950
static bool_t decode_op_putfh(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:1092
void nfsacl41_free(nfsacl41 *acl)
Definition: nfs41_xdr.c:335
unsigned char attr_vals[NFS4_OPAQUE_LIMIT]
Definition: nfs41_types.h:162
union __locker4::@38 u
uint32_t ca_maxoperations
Definition: nfs41.h:235
bool_t(* nfs_op_encode_proc)(XDR *, nfs_argop4 *)
Definition: nfs41_xdr.c:3506
struct __op_table_entry op_table_entry
unsigned char other[NFS4_STATEID_OTHER]
Definition: nfs41_types.h:145
static bool_t xdr_sequence_res_ok(XDR *xdr, nfs41_sequence_res_ok *res)
Definition: nfs41_xdr.c:1007
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
uint32_t nii_domain_len
Definition: nfs41_types.h:123
static bool_t encode_op_putrootfh(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:1108
int32_t bool_t
Definition: types.h:101
char address[NFS41_HOSTNAME_LEN+1]
Definition: nfs41_types.h:174
unsigned char * nii_domain
Definition: nfs41_types.h:124
uint32_t type
Definition: nfs41_ops.h:343
static bool_t encode_op_secinfo_noname(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:2911
nfs_op_decode_proc decode
Definition: nfs41_xdr.c:3511
char who[NFS4_OPAQUE_LIMIT]
Definition: nfs41_types.h:134
GLuint GLuint GLsizei count
Definition: gl.h:1545
bool_t(* nfs_op_decode_proc)(XDR *, nfs_resop4 *)
Definition: nfs41_xdr.c:3507
static bool_t encode_op_create_session(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:798
#define free
Definition: debug_ros.c:5
static bool_t decode_lock_res_denied(XDR *xdr, lock_res_denied *denied)
Definition: nfs41_xdr.c:1501
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG x1
Definition: winddi.h:3706
uint32_t co_ownerid_len
Definition: nfs41_types.h:107
nfstime4 nii_date
Definition: nfs41_types.h:127
static bool_t encode_op_open(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:1993
struct __open_claim4::@40::__open_claim_deleg_cur deleg_cur
struct __nfs41_client * client
Definition: pnfs.h:129
static bool_t encode_op_restorefh(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:2512
static bool_t decode_op_bind_conn_to_session(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:897
static const uint32_t g_op_table_size
Definition: nfs41_xdr.c:3579
static bool_t xdr_settime4(XDR *xdr, nfstime4 *nt, const nfstime4 *time_delta)
Definition: nfs41_xdr.c:113
static bool_t encode_createtype4(XDR *xdr, createtype4 *ct)
Definition: nfs41_xdr.c:1309
#define PNFS_DEVICEID_SIZE
Definition: pnfs.h:111
struct __createtype4::@37::__create_type_lnk lnk
#define ARRAYSIZE(array)
Definition: filtermapper.c:47
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
bool_t xdr_string(XDR *xdrs, char **cpp, u_int maxsize)
Definition: xdr.c:678
static bool_t encode_op_getdeviceinfo(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:2985
Definition: ecma_167.h:138
#define ZeroMemory
Definition: winbase.h:1635
void eprintf(LPCSTR format,...)
Definition: daemon_debug.c:86
static bool_t encode_open_claim4(XDR *xdr, open_claim4 *oc)
Definition: nfs41_xdr.c:1960
#define NFS4_STATEID_OTHER
Definition: nfs41_const.h:33
static bool_t encode_openflag4(XDR *xdr, openflag4 *of)
Definition: nfs41_xdr.c:1930
uint64_t so_minor_id
Definition: nfs41_types.h:112
threshold_item4 items[MAX_MDSTHRESHOLD_ITEMS]
Definition: nfs41_types.h:205
uint64_t offset
Definition: nfs41_ops.h:436
static bool_t decode_op_locku(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:1614
static const op_table_entry * op_table_find(uint32_t op)
Definition: nfs41_xdr.c:3582
const char * STRSAFE_LPCSTR
Definition: ntstrsafe.h:62
struct __open_claim4::@40::__open_claim_deleg_cur_fh deleg_cur_fh
static bool_t encode_op_lockt(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:1547
specdata4 devdata
Definition: nfs41_ops.h:351
static bool_t encode_op_remove(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:2438
unsigned char co_verifier[NFS4_VERIFIER_SIZE]
Definition: nfs41_types.h:106
state_owner4 * lock_owner
Definition: nfs41_ops.h:409
static bool_t xdr_fsid(XDR *xdr, nfs41_fsid *fsid)
Definition: nfs41_xdr.c:166
unsigned char createverf[NFS4_VERIFIER_SIZE]
Definition: nfs41_ops.h:549
static bool_t decode_read_res_ok(XDR *xdr, nfs41_read_res_ok *res)
Definition: nfs41_xdr.c:2217
uint64_t after
Definition: nfs41_types.h:168
static bool_t xdr_nfstime4(XDR *xdr, nfstime4 *nt)
Definition: nfs41_xdr.c:86
static bool_t decode_op_layoutreturn(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:3482
uint32_t arr[3]
Definition: nfs41_types.h:97
Definition: match.c:390
char * caddr_t
Definition: rosdhcp.h:36
Definition: xdr.h:103
static bool_t decode_op_secinfo(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:2963
uint32_t seqid
Definition: nfs41_types.h:144
static __inline void nfstime_abs(IN const nfstime4 *nt, OUT nfstime4 *result)
Definition: util.h:158
#define AUTH_NONE
Definition: auth.h:401
static bool_t encode_op_locku(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:1590
bitmap4 attrmask
Definition: nfs41_types.h:160
uint64_t minor
Definition: nfs41_types.h:67
static bool_t encode_op_delegreturn(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:1666
IMAGE_NT_HEADERS nt
Definition: module.c:50
unsigned int count
Definition: notification.c:64
static bool_t decode_op_free_stateid(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:2778
static bool_t decode_layout(XDR *xdr, struct list_entry *list)
Definition: nfs41_xdr.c:3366
#define NFS4_VERIFIER_SIZE
Definition: nfs41_const.h:30
unsigned char owner[NFS4_OPAQUE_LIMIT]
Definition: nfs41_types.h:119
static double one
Definition: j0_y0.c:80
Definition: fatfs.h:133
__WINE_SERVER_LIST_INLINE void list_add_tail(struct list *list, struct list *elem)
Definition: list.h:102
static bool_t xdr_stateid4(XDR *xdr, stateid4 *si)
Definition: nfs41_xdr.c:133
#define NFS41_MAX_PATH_LEN
Definition: nfs41_const.h:46
static bool_t decode_op_link(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:1421
unsigned short(__cdecl typeof(TIFFCurrentDirectory))(struct tiff *)
Definition: typeof.h:93
stateid_arg * lock_stateid
Definition: nfs41_ops.h:413
bool_t(* xdrproc_t)(XDR *,...)
Definition: xdr.h:144
static bool_t encode_op_getattr(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:1694
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
unsigned char co_ownerid[NFS4_OPAQUE_LIMIT]
Definition: nfs41_types.h:108
limit_by4
Definition: nfs41_xdr.c:2069
static bool_t encode_component(XDR *xdr, const nfs41_component *component)
Definition: nfs41_xdr.c:178
UINT64 u_quad_t
Definition: types.h:86
static bool_t encode_op_setattr(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:2665
static bool_t decode_op_lockt(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:1568
uint64_t before
Definition: nfs41_types.h:167
Definition: devices.h:37
static bool_t encode_backchannel_sec_parms(XDR *xdr, nfs41_callback_secparms *args)
Definition: nfs41_xdr.c:774
#define NFS41_HOSTNAME_LEN
Definition: nfs41_const.h:48
unsigned char verf[NFS4_VERIFIER_SIZE]
Definition: nfs41_types.h:76
static bool_t encode_op_want_delegation(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:2708
uint32_t * last_entry_offset
Definition: nfs41_xdr.c:2278
static bool_t decode_op_delegreturn(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:1678
static bool_t encode_op_destroy_session(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:928
int length
Definition: match.c:394
uint32_t count
Definition: nfs41_types.h:96
static PVOID ptr
Definition: dispmode.c:27
uint32_t specdata1
Definition: nfs41_ops.h:338
static bool_t encode_op_test_stateid(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:2794
static bool_t encode_op_close(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:1233
static bool_t encode_op_readdir(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:2251
#define NFS4_OPAQUE_LIMIT
Definition: nfs41_const.h:31
nfs41_file_info * createattrs
Definition: nfs41_ops.h:548
static bool_t decode_op_close(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:1249
smooth NULL
Definition: ftsmooth.c:416
bool_t ignore_the_rest
Definition: nfs41_xdr.c:2279
static bool_t xdr_client_owner4(XDR *xdr, client_owner4 *co)
Definition: nfs41_xdr.c:460
static bool_t encode_op_reclaim_complete(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:1051
Definition: nfs41_xdr.c:2275
unsigned char * buf_pos
Definition: nfs41_xdr.c:2276
static bool_t decode_fs_location4(XDR *xdr, fs_location4 *location)
Definition: nfs41_xdr.c:377
state_owner4 owner
Definition: nfs41_ops.h:439
uint32_t specdata2
Definition: nfs41_ops.h:339
uint32_t len
Definition: nfs41_types.h:54
static bool_t encode_op_layoutcommit(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:3181
static bool_t decode_readdir_entry(XDR *xdr, readdir_entry_iterator *it)
Definition: nfs41_xdr.c:2283
static bool_t decode_space_limit4(XDR *xdr, uint64_t *filesize)
Definition: nfs41_xdr.c:2074
static int blocks
Definition: mkdosfs.c:527
uint32_t remaining_len
Definition: nfs41_xdr.c:2277
static bool_t decode_op_lock(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:1517
pnfs_data_server * arr
Definition: pnfs.h:136
static bool_t xdr_secinfo(XDR *xdr, nfs41_secinfo_info *secinfo)
Definition: nfs41_xdr.c:2893
static bool_t decode_op_sequence(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:1029
uint32_t owner_len
Definition: nfs41_types.h:118
multi_addr4 addrs
Definition: pnfs.h:130
union __createtype4::@37 u
static bool_t decode_op_setattr(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:2686
pnfs_device device
Definition: pnfs.h:140
static bool_t encode_op_commit(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:1272
Definition: uimain.c:88
static bool_t encode_file_attrs(fattr4 *attrs, nfs41_file_info *info)
Definition: nfs41_xdr.c:2566
static bool_t decode_fs_locations4(XDR *xdr, fs_locations4 *locations)
Definition: nfs41_xdr.c:419
uint32_t ca_maxrequests
Definition: nfs41.h:236
open_to_lock_owner4 open_owner
Definition: nfs41_ops.h:421
static bool_t xdr_nfsacl41(XDR *xdr, nfsacl41 *acl)
Definition: nfs41_xdr.c:327
static bool_t decode_op_savefh(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:2550
char oid[MAX_OID_LEN]
Definition: nfs41_ops.h:870
static bool_t xdr_state_owner4(XDR *xdr, state_owner4 *so)
Definition: nfs41_xdr.c:200
uint32_t acetype
Definition: nfs41_types.h:131
static object_header_t ** handles
Definition: handle.c:46
bool_t xdr_enum(XDR *xdrs, enum_t *ep)
Definition: xdr.c:458
const char * name
Definition: nfs41_types.h:48
bool_t xdr_bitmap4(XDR *xdr, bitmap4 *bitmap)
Definition: nfs41_xdr.c:48
char so_major_id[NFS4_OPAQUE_LIMIT]
Definition: nfs41_types.h:114
static bool_t decode_open_read_delegation4(XDR *xdr, open_delegation4 *delegation)
Definition: nfs41_xdr.c:2040
if(!(yy_init))
Definition: macro.lex.yy.c:714
static bool_t decode_op_want_delegation(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:2727
nfsace4 * aces
Definition: nfs41_types.h:139
static WORD cb_count
Definition: loader.c:52
bool_t nfs_decode_compound(XDR *xdr, caddr_t *pres)
Definition: nfs41_xdr.c:3625
#define MAX_SECINFOS
Definition: nfs41_ops.h:881
#define MAX_MDSTHRESHOLD_ITEMS
Definition: nfs41_types.h:202
static bool_t xdr_stripe_indices(XDR *xdr, pnfs_stripe_indices *indices)
Definition: nfs41_xdr.c:3006
pnfs_file_device * device
Definition: nfs41_ops.h:983
static bool_t encode_op_free_stateid(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:2766
static bool_t xdr_server_owner4(XDR *xdr, server_owner4 *so)
Definition: nfs41_xdr.c:659
static bool_t xdr_nfsdacl41(XDR *xdr, nfsacl41 *acl)
Definition: nfs41_xdr.c:316
#define NFS41_ADDRS_PER_SERVER
Definition: nfs41_const.h:49
enum xdr_op x_op
Definition: xdr.h:104
static bool_t xdr_locker4(XDR *xdr, locker4 *locker)
Definition: nfs41_xdr.c:1443
uint32_t nii_name_len
Definition: nfs41_types.h:125
#define for
Definition: utility.h:88
GLuint address
Definition: glext.h:9393
static bool_t encode_op_putfh(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:1080
static bool_t decode_op_destroy_session(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:940
static bool_t encode_op_openattr(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:2171
uint32_t attr_vals_len
Definition: nfs41_types.h:161
struct __readdir_entry_iterator readdir_entry_iterator
static bool_t decode_op_readdir(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:2379
union __open_claim4::@40 u
static bool_t decode_op_layoutcommit(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:3237
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
createhow4 how
Definition: nfs41_ops.h:560
#define NI_MAXHOST
Definition: ws2def.h:359
static bool_t decode_op_getfh(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:1145
#define NFS41_UNIVERSAL_ADDR_LEN
Definition: nfs41_const.h:53
static bool_t decode_op_create_session(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:837
static bool_t decode_op_access(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:1207
static bool_t decode_getdeviceinfo_ok(XDR *xdr, pnfs_getdeviceinfo_res_ok *res_ok)
Definition: nfs41_xdr.c:3130
static bool_t decode_open_res_ok(XDR *xdr, nfs41_op_open_res_ok *res)
Definition: nfs41_xdr.c:2113
static bool_t decode_op_openattr(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:2183
SRWLOCK lock
Definition: pnfs.h:131
uint32_t entries_len
Definition: nfs41_ops.h:720
static double zero
Definition: j0_y0.c:96
int32_t enum_t
Definition: types.h:102
static __inline int unexpected_op(uint32_t op, uint32_t expected)
Definition: nfs41_xdr.c:36
static bool_t xdr_fh(XDR *xdr, nfs41_fh *fh)
Definition: nfs41_xdr.c:157
static bool_t decode_op_open(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:2149
enum sec_flavor type
Definition: nfs41_ops.h:874
enum pnfs_layout_type type
Definition: pnfs.h:117
static bool_t decode_op_reclaim_complete(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:1064
GLenum const GLvoid * addr
Definition: glext.h:9621
bool_t new_lock_owner
Definition: nfs41_ops.h:418
uint32_t count
Definition: nfs41_types.h:204
bool_t xdr_opaque(XDR *xdrs, caddr_t cp, u_int cnt)
Definition: xdr.c:484
bool_t xdr_fattr4(XDR *xdr, fattr4 *fattr)
Definition: nfs41_xdr.c:144
Definition: xdr.h:85
static DWORD layout
Definition: bitmap.c:46
uint32_t entry
Definition: isohybrid.c:63
uint32_t count
Definition: nfs41_types.h:140
GLenum GLsizei len
Definition: glext.h:6722
unsigned int u_int32_t
Definition: rosdhcp.h:35
static bool_t encode_createhow4(XDR *xdr, createhow4 *ch)
Definition: nfs41_xdr.c:1902
GLsizei const GLint * locations
Definition: glext.h:10542
Definition: _list.h:228
static bool_t xdr_mdsthreshold(XDR *xdr, mdsthreshold4 *mdsthreshold)
Definition: nfs41_xdr.c:276
enum stable_how4 committed
Definition: nfs41_types.h:81
VOID WINAPI InitializeSRWLock(PSRWLOCK Lock)
Definition: sync.c:75
static bool_t decode_op_layoutget(XDR *xdr, nfs_resop4 *resop)
Definition: nfs41_xdr.c:3416
static bool_t decode_readdir_list(XDR *xdr, nfs41_readdir_list *dirs)
Definition: nfs41_xdr.c:2346
uint32_t ca_maxresponsesize
Definition: nfs41.h:233
static bool_t encode_createattrs4(XDR *xdr, nfs41_file_info *createattrs)
Definition: nfs41_xdr.c:1339
static bool_t decode_modified_limit4(XDR *xdr, uint64_t *filesize)
Definition: nfs41_xdr.c:2053
static bool_t encode_op_destroy_clientid(XDR *xdr, nfs_argop4 *argop)
Definition: nfs41_xdr.c:955