?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge commit 'crater/master'
[dragonfly.git] / contrib / tcpdump / print-nfs.c
blobfb09e30843e6861cd8ca29f331c02bc55afc4232
1 /*
2 * Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997
3 * The Regents of the University of California. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that: (1) source code distributions
7 * retain the above copyright notice and this paragraph in its entirety, (2)
8 * distributions including binary code include the above copyright notice and
9 * this paragraph in its entirety in the documentation or other materials
10 * provided with the distribution, and (3) all advertising materials mentioning
11 * features or use of this software display the following acknowledgement:
12 * ``This product includes software developed by the University of California,
13 * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
14 * the University nor the names of its contributors may be used to endorse
15 * or promote products derived from this software without specific prior
16 * written permission.
17 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
18 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
19 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
20 */
21
22 #ifndef lint
23 static const char rcsid[] _U_ =
24 "@(#) $Header: /tcpdump/master/tcpdump/print-nfs.c,v 1.110.2.1 2007-12-22 03:08:45 guy Exp $ (LBL)";
25 #endif
26
27 #ifdef HAVE_CONFIG_H
28 #include "config.h"
29 #endif
30
31 #include <tcpdump-stdinc.h>
32
33 #include <pcap.h>
34 #include <stdio.h>
35 #include <string.h>
36
37 #include "interface.h"
38 #include "addrtoname.h"
39 #include "extract.h"
40
41 #include "nfs.h"
42 #include "nfsfh.h"
43
44 #include "ip.h"
45 #ifdef INET6
46 #include "ip6.h"
47 #endif
48 #include "rpc_auth.h"
49 #include "rpc_msg.h"
50
51 static void nfs_printfh(const u_int32_t *, const u_int);
52 static int xid_map_enter(const struct sunrpc_msg *, const u_char *);
53 static int32_t xid_map_find(const struct sunrpc_msg *, const u_char *,
54 u_int32_t *, u_int32_t *);
55 static void interp_reply(const struct sunrpc_msg *, u_int32_t, u_int32_t, int);
56 static const u_int32_t *parse_post_op_attr(const u_int32_t *, int);
57 static void print_sattr3(const struct nfsv3_sattr *sa3, int verbose);
58 static void print_nfsaddr(const u_char *, const char *, const char *);
59
60 /*
61 * Mapping of old NFS Version 2 RPC numbers to generic numbers.
62 */
63 u_int32_t nfsv3_procid[NFS_NPROCS] = {
64 NFSPROC_NULL,
65 NFSPROC_GETATTR,
66 NFSPROC_SETATTR,
67 NFSPROC_NOOP,
68 NFSPROC_LOOKUP,
69 NFSPROC_READLINK,
70 NFSPROC_READ,
71 NFSPROC_NOOP,
72 NFSPROC_WRITE,
73 NFSPROC_CREATE,
74 NFSPROC_REMOVE,
75 NFSPROC_RENAME,
76 NFSPROC_LINK,
77 NFSPROC_SYMLINK,
78 NFSPROC_MKDIR,
79 NFSPROC_RMDIR,
80 NFSPROC_READDIR,
81 NFSPROC_FSSTAT,
82 NFSPROC_NOOP,
83 NFSPROC_NOOP,
84 NFSPROC_NOOP,
85 NFSPROC_NOOP,
86 NFSPROC_NOOP,
87 NFSPROC_NOOP,
88 NFSPROC_NOOP,
89 NFSPROC_NOOP
90 };
91
92 /*
93 * NFS V2 and V3 status values.
94 *
95 * Some of these come from the RFCs for NFS V2 and V3, with the message
96 * strings taken from the FreeBSD C library "errlst.c".
97 *
98 * Others are errors that are not in the RFC but that I suspect some
99 * NFS servers could return; the values are FreeBSD errno values, as
100 * the first NFS server was the SunOS 2.0 one, and until 5.0 SunOS
101 * was primarily BSD-derived.
102 */
103 static struct tok status2str[] = {
104 { 1, "Operation not permitted" }, /* EPERM */
105 { 2, "No such file or directory" }, /* ENOENT */
106 { 5, "Input/output error" }, /* EIO */
107 { 6, "Device not configured" }, /* ENXIO */
108 { 11, "Resource deadlock avoided" }, /* EDEADLK */
109 { 12, "Cannot allocate memory" }, /* ENOMEM */
110 { 13, "Permission denied" }, /* EACCES */
111 { 17, "File exists" }, /* EEXIST */
112 { 18, "Cross-device link" }, /* EXDEV */
113 { 19, "Operation not supported by device" }, /* ENODEV */
114 { 20, "Not a directory" }, /* ENOTDIR */
115 { 21, "Is a directory" }, /* EISDIR */
116 { 22, "Invalid argument" }, /* EINVAL */
117 { 26, "Text file busy" }, /* ETXTBSY */
118 { 27, "File too large" }, /* EFBIG */
119 { 28, "No space left on device" }, /* ENOSPC */
120 { 30, "Read-only file system" }, /* EROFS */
121 { 31, "Too many links" }, /* EMLINK */
122 { 45, "Operation not supported" }, /* EOPNOTSUPP */
123 { 62, "Too many levels of symbolic links" }, /* ELOOP */
124 { 63, "File name too long" }, /* ENAMETOOLONG */
125 { 66, "Directory not empty" }, /* ENOTEMPTY */
126 { 69, "Disc quota exceeded" }, /* EDQUOT */
127 { 70, "Stale NFS file handle" }, /* ESTALE */
128 { 71, "Too many levels of remote in path" }, /* EREMOTE */
129 { 99, "Write cache flushed to disk" }, /* NFSERR_WFLUSH (not used) */
130 { 10001, "Illegal NFS file handle" }, /* NFS3ERR_BADHANDLE */
131 { 10002, "Update synchronization mismatch" }, /* NFS3ERR_NOT_SYNC */
132 { 10003, "READDIR/READDIRPLUS cookie is stale" }, /* NFS3ERR_BAD_COOKIE */
133 { 10004, "Operation not supported" }, /* NFS3ERR_NOTSUPP */
134 { 10005, "Buffer or request is too small" }, /* NFS3ERR_TOOSMALL */
135 { 10006, "Unspecified error on server" }, /* NFS3ERR_SERVERFAULT */
136 { 10007, "Object of that type not supported" }, /* NFS3ERR_BADTYPE */
137 { 10008, "Request couldn't be completed in time" }, /* NFS3ERR_JUKEBOX */
138 { 0, NULL }
139 };
140
141 static struct tok nfsv3_writemodes[] = {
142 { 0, "unstable" },
143 { 1, "datasync" },
144 { 2, "filesync" },
145 { 0, NULL }
146 };
147
148 static struct tok type2str[] = {
149 { NFNON, "NON" },
150 { NFREG, "REG" },
151 { NFDIR, "DIR" },
152 { NFBLK, "BLK" },
153 { NFCHR, "CHR" },
154 { NFLNK, "LNK" },
155 { NFFIFO, "FIFO" },
156 { 0, NULL }
157 };
158
159 static void
160 print_nfsaddr(const u_char *bp, const char *s, const char *d)
161 {
162 struct ip *ip;
163 #ifdef INET6
164 struct ip6_hdr *ip6;
165 char srcaddr[INET6_ADDRSTRLEN], dstaddr[INET6_ADDRSTRLEN];
166 #else
167 #ifndef INET_ADDRSTRLEN
168 #define INET_ADDRSTRLEN 16
169 #endif
170 char srcaddr[INET_ADDRSTRLEN], dstaddr[INET_ADDRSTRLEN];
171 #endif
172
173 srcaddr[0] = dstaddr[0] = '\0';
174 switch (IP_V((struct ip *)bp)) {
175 case 4:
176 ip = (struct ip *)bp;
177 strlcpy(srcaddr, ipaddr_string(&ip->ip_src), sizeof(srcaddr));
178 strlcpy(dstaddr, ipaddr_string(&ip->ip_dst), sizeof(dstaddr));
179 break;
180 #ifdef INET6
181 case 6:
182 ip6 = (struct ip6_hdr *)bp;
183 strlcpy(srcaddr, ip6addr_string(&ip6->ip6_src),
184 sizeof(srcaddr));
185 strlcpy(dstaddr, ip6addr_string(&ip6->ip6_dst),
186 sizeof(dstaddr));
187 break;
188 #endif
189 default:
190 strlcpy(srcaddr, "?", sizeof(srcaddr));
191 strlcpy(dstaddr, "?", sizeof(dstaddr));
192 break;
193 }
194
195 (void)printf("%s.%s > %s.%s: ", srcaddr, s, dstaddr, d);
196 }
197
198 static const u_int32_t *
199 parse_sattr3(const u_int32_t *dp, struct nfsv3_sattr *sa3)
200 {
201 TCHECK(dp[0]);
202 sa3->sa_modeset = EXTRACT_32BITS(dp);
203 dp++;
204 if (sa3->sa_modeset) {
205 TCHECK(dp[0]);
206 sa3->sa_mode = EXTRACT_32BITS(dp);
207 dp++;
208 }
209
210 TCHECK(dp[0]);
211 sa3->sa_uidset = EXTRACT_32BITS(dp);
212 dp++;
213 if (sa3->sa_uidset) {
214 TCHECK(dp[0]);
215 sa3->sa_uid = EXTRACT_32BITS(dp);
216 dp++;
217 }
218
219 TCHECK(dp[0]);
220 sa3->sa_gidset = EXTRACT_32BITS(dp);
221 dp++;
222 if (sa3->sa_gidset) {
223 TCHECK(dp[0]);
224 sa3->sa_gid = EXTRACT_32BITS(dp);
225 dp++;
226 }
227
228 TCHECK(dp[0]);
229 sa3->sa_sizeset = EXTRACT_32BITS(dp);
230 dp++;
231 if (sa3->sa_sizeset) {
232 TCHECK(dp[0]);
233 sa3->sa_size = EXTRACT_32BITS(dp);
234 dp++;
235 }
236
237 TCHECK(dp[0]);
238 sa3->sa_atimetype = EXTRACT_32BITS(dp);
239 dp++;
240 if (sa3->sa_atimetype == NFSV3SATTRTIME_TOCLIENT) {
241 TCHECK(dp[1]);
242 sa3->sa_atime.nfsv3_sec = EXTRACT_32BITS(dp);
243 dp++;
244 sa3->sa_atime.nfsv3_nsec = EXTRACT_32BITS(dp);
245 dp++;
246 }
247
248 TCHECK(dp[0]);
249 sa3->sa_mtimetype = EXTRACT_32BITS(dp);
250 dp++;
251 if (sa3->sa_mtimetype == NFSV3SATTRTIME_TOCLIENT) {
252 TCHECK(dp[1]);
253 sa3->sa_mtime.nfsv3_sec = EXTRACT_32BITS(dp);
254 dp++;
255 sa3->sa_mtime.nfsv3_nsec = EXTRACT_32BITS(dp);
256 dp++;
257 }
258
259 return dp;
260 trunc:
261 return NULL;
262 }
263
264 static int nfserr; /* true if we error rather than trunc */
265
266 static void
267 print_sattr3(const struct nfsv3_sattr *sa3, int verbose)
268 {
269 if (sa3->sa_modeset)
270 printf(" mode %o", sa3->sa_mode);
271 if (sa3->sa_uidset)
272 printf(" uid %u", sa3->sa_uid);
273 if (sa3->sa_gidset)
274 printf(" gid %u", sa3->sa_gid);
275 if (verbose > 1) {
276 if (sa3->sa_atimetype == NFSV3SATTRTIME_TOCLIENT)
277 printf(" atime %u.%06u", sa3->sa_atime.nfsv3_sec,
278 sa3->sa_atime.nfsv3_nsec);
279 if (sa3->sa_mtimetype == NFSV3SATTRTIME_TOCLIENT)
280 printf(" mtime %u.%06u", sa3->sa_mtime.nfsv3_sec,
281 sa3->sa_mtime.nfsv3_nsec);
282 }
283 }
284
285 void
286 nfsreply_print(register const u_char *bp, u_int length,
287 register const u_char *bp2)
288 {
289 register const struct sunrpc_msg *rp;
290 u_int32_t proc, vers, reply_stat;
291 char srcid[20], dstid[20]; /*fits 32bit*/
292 enum sunrpc_reject_stat rstat;
293 u_int32_t rlow;
294 u_int32_t rhigh;
295 enum sunrpc_auth_stat rwhy;
296
297 nfserr = 0; /* assume no error */
298 rp = (const struct sunrpc_msg *)bp;
299
300 TCHECK(rp->rm_xid);
301 if (!nflag) {
302 strlcpy(srcid, "nfs", sizeof(srcid));
303 snprintf(dstid, sizeof(dstid), "%u",
304 EXTRACT_32BITS(&rp->rm_xid));
305 } else {
306 snprintf(srcid, sizeof(srcid), "%u", NFS_PORT);
307 snprintf(dstid, sizeof(dstid), "%u",
308 EXTRACT_32BITS(&rp->rm_xid));
309 }
310 print_nfsaddr(bp2, srcid, dstid);
311 TCHECK(rp->rm_reply.rp_stat);
312 reply_stat = EXTRACT_32BITS(&rp->rm_reply.rp_stat);
313 switch (reply_stat) {
314
315 case SUNRPC_MSG_ACCEPTED:
316 (void)printf("reply ok %u", length);
317 if (xid_map_find(rp, bp2, &proc, &vers) >= 0)
318 interp_reply(rp, proc, vers, length);
319 break;
320
321 case SUNRPC_MSG_DENIED:
322 (void)printf("reply ERR %u: ", length);
323 TCHECK(rp->rm_reply.rp_reject.rj_stat);
324 rstat = EXTRACT_32BITS(&rp->rm_reply.rp_reject.rj_stat);
325 switch (rstat) {
326
327 case SUNRPC_RPC_MISMATCH:
328 TCHECK(rp->rm_reply.rp_reject.rj_vers.high);
329 rlow = EXTRACT_32BITS(&rp->rm_reply.rp_reject.rj_vers.low);
330 rhigh = EXTRACT_32BITS(&rp->rm_reply.rp_reject.rj_vers.high);
331 (void)printf("RPC Version mismatch (%u-%u)",
332 rlow, rhigh);
333 break;
334
335 case SUNRPC_AUTH_ERROR:
336 TCHECK(rp->rm_reply.rp_reject.rj_why);
337 rwhy = EXTRACT_32BITS(&rp->rm_reply.rp_reject.rj_why);
338 (void)printf("Auth ");
339 switch (rwhy) {
340
341 case SUNRPC_AUTH_OK:
342 (void)printf("OK");
343 break;
344
345 case SUNRPC_AUTH_BADCRED:
346 (void)printf("Bogus Credentials (seal broken)");
347 break;
348
349 case SUNRPC_AUTH_REJECTEDCRED:
350 (void)printf("Rejected Credentials (client should begin new session)");
351 break;
352
353 case SUNRPC_AUTH_BADVERF:
354 (void)printf("Bogus Verifier (seal broken)");
355 break;
356
357 case SUNRPC_AUTH_REJECTEDVERF:
358 (void)printf("Verifier expired or was replayed");
359 break;
360
361 case SUNRPC_AUTH_TOOWEAK:
362 (void)printf("Credentials are too weak");
363 break;
364
365 case SUNRPC_AUTH_INVALIDRESP:
366 (void)printf("Bogus response verifier");
367 break;
368
369 case SUNRPC_AUTH_FAILED:
370 (void)printf("Unknown failure");
371 break;
372
373 default:
374 (void)printf("Invalid failure code %u",
375 (unsigned int)rwhy);
376 break;
377 }
378 break;
379
380 default:
381 (void)printf("Unknown reason for rejecting rpc message %u",
382 (unsigned int)rstat);
383 break;
384 }
385 break;
386
387 default:
388 (void)printf("reply Unknown rpc response code=%u %u",
389 reply_stat, length);
390 break;
391 }
392 return;
393
394 trunc:
395 if (!nfserr)
396 fputs(" [|nfs]", stdout);
397 }
398
399 /*
400 * Return a pointer to the first file handle in the packet.
401 * If the packet was truncated, return 0.
402 */
403 static const u_int32_t *
404 parsereq(register const struct sunrpc_msg *rp, register u_int length)
405 {
406 register const u_int32_t *dp;
407 register u_int len;
408
409 /*
410 * find the start of the req data (if we captured it)
411 */
412 dp = (u_int32_t *)&rp->rm_call.cb_cred;
413 TCHECK(dp[1]);
414 len = EXTRACT_32BITS(&dp[1]);
415 if (len < length) {
416 dp += (len + (2 * sizeof(*dp) + 3)) / sizeof(*dp);
417 TCHECK(dp[1]);
418 len = EXTRACT_32BITS(&dp[1]);
419 if (len < length) {
420 dp += (len + (2 * sizeof(*dp) + 3)) / sizeof(*dp);
421 TCHECK2(dp[0], 0);
422 return (dp);
423 }
424 }
425 trunc:
426 return (NULL);
427 }
428
429 /*
430 * Print out an NFS file handle and return a pointer to following word.
431 * If packet was truncated, return 0.
432 */
433 static const u_int32_t *
434 parsefh(register const u_int32_t *dp, int v3)
435 {
436 u_int len;
437
438 if (v3) {
439 TCHECK(dp[0]);
440 len = EXTRACT_32BITS(dp) / 4;
441 dp++;
442 } else
443 len = NFSX_V2FH / 4;
444
445 if (TTEST2(*dp, len * sizeof(*dp))) {
446 nfs_printfh(dp, len);
447 return (dp + len);
448 }
449 trunc:
450 return (NULL);
451 }
452
453 /*
454 * Print out a file name and return pointer to 32-bit word past it.
455 * If packet was truncated, return 0.
456 */
457 static const u_int32_t *
458 parsefn(register const u_int32_t *dp)
459 {
460 register u_int32_t len;
461 register const u_char *cp;
462
463 /* Bail if we don't have the string length */
464 TCHECK(*dp);
465
466 /* Fetch string length; convert to host order */
467 len = *dp++;
468 NTOHL(len);
469
470 TCHECK2(*dp, ((len + 3) & ~3));
471
472 cp = (u_char *)dp;
473 /* Update 32-bit pointer (NFS filenames padded to 32-bit boundaries) */
474 dp += ((len + 3) & ~3) / sizeof(*dp);
475 putchar('"');
476 if (fn_printn(cp, len, snapend)) {
477 putchar('"');
478 goto trunc;
479 }
480 putchar('"');
481
482 return (dp);
483 trunc:
484 return NULL;
485 }
486
487 /*
488 * Print out file handle and file name.
489 * Return pointer to 32-bit word past file name.
490 * If packet was truncated (or there was some other error), return 0.
491 */
492 static const u_int32_t *
493 parsefhn(register const u_int32_t *dp, int v3)
494 {
495 dp = parsefh(dp, v3);
496 if (dp == NULL)
497 return (NULL);
498 putchar(' ');
499 return (parsefn(dp));
500 }
501
502 void
503 nfsreq_print(register const u_char *bp, u_int length,
504 register const u_char *bp2)
505 {
506 register const struct sunrpc_msg *rp;
507 register const u_int32_t *dp;
508 nfs_type type;
509 int v3;
510 u_int32_t proc;
511 struct nfsv3_sattr sa3;
512 char srcid[20], dstid[20]; /*fits 32bit*/
513
514 nfserr = 0; /* assume no error */
515 rp = (const struct sunrpc_msg *)bp;
516
517 TCHECK(rp->rm_xid);
518 if (!nflag) {
519 snprintf(srcid, sizeof(srcid), "%u",
520 EXTRACT_32BITS(&rp->rm_xid));
521 strlcpy(dstid, "nfs", sizeof(dstid));
522 } else {
523 snprintf(srcid, sizeof(srcid), "%u",
524 EXTRACT_32BITS(&rp->rm_xid));
525 snprintf(dstid, sizeof(dstid), "%u", NFS_PORT);
526 }
527 print_nfsaddr(bp2, srcid, dstid);
528 (void)printf("%d", length);
529
530 if (!xid_map_enter(rp, bp2)) /* record proc number for later on */
531 goto trunc;
532
533 v3 = (EXTRACT_32BITS(&rp->rm_call.cb_vers) == NFS_VER3);
534 proc = EXTRACT_32BITS(&rp->rm_call.cb_proc);
535
536 if (!v3 && proc < NFS_NPROCS)
537 proc = nfsv3_procid[proc];
538
539 switch (proc) {
540 case NFSPROC_NOOP:
541 printf(" nop");
542 return;
543 case NFSPROC_NULL:
544 printf(" null");
545 return;
546
547 case NFSPROC_GETATTR:
548 printf(" getattr");
549 if ((dp = parsereq(rp, length)) != NULL &&
550 parsefh(dp, v3) != NULL)
551 return;
552 break;
553
554 case NFSPROC_SETATTR:
555 printf(" setattr");
556 if ((dp = parsereq(rp, length)) != NULL &&
557 parsefh(dp, v3) != NULL)
558 return;
559 break;
560
561 case NFSPROC_LOOKUP:
562 printf(" lookup");
563 if ((dp = parsereq(rp, length)) != NULL &&
564 parsefhn(dp, v3) != NULL)
565 return;
566 break;
567
568 case NFSPROC_ACCESS:
569 printf(" access");
570 if ((dp = parsereq(rp, length)) != NULL &&
571 (dp = parsefh(dp, v3)) != NULL) {
572 TCHECK(dp[0]);
573 printf(" %04x", EXTRACT_32BITS(&dp[0]));
574 return;
575 }
576 break;
577
578 case NFSPROC_READLINK:
579 printf(" readlink");
580 if ((dp = parsereq(rp, length)) != NULL &&
581 parsefh(dp, v3) != NULL)
582 return;
583 break;
584
585 case NFSPROC_READ:
586 printf(" read");
587 if ((dp = parsereq(rp, length)) != NULL &&
588 (dp = parsefh(dp, v3)) != NULL) {
589 if (v3) {
590 TCHECK(dp[2]);
591 printf(" %u bytes @ %" PRIu64,
592 EXTRACT_32BITS(&dp[2]),
593 EXTRACT_64BITS(&dp[0]));
594 } else {
595 TCHECK(dp[1]);
596 printf(" %u bytes @ %u",
597 EXTRACT_32BITS(&dp[1]),
598 EXTRACT_32BITS(&dp[0]));
599 }
600 return;
601 }
602 break;
603
604 case NFSPROC_WRITE:
605 printf(" write");
606 if ((dp = parsereq(rp, length)) != NULL &&
607 (dp = parsefh(dp, v3)) != NULL) {
608 if (v3) {
609 TCHECK(dp[2]);
610 printf(" %u (%u) bytes @ %" PRIu64,
611 EXTRACT_32BITS(&dp[4]),
612 EXTRACT_32BITS(&dp[2]),
613 EXTRACT_64BITS(&dp[0]));
614 if (vflag) {
615 dp += 3;
616 TCHECK(dp[0]);
617 printf(" <%s>",
618 tok2str(nfsv3_writemodes,
619 NULL, EXTRACT_32BITS(dp)));
620 }
621 } else {
622 TCHECK(dp[3]);
623 printf(" %u (%u) bytes @ %u (%u)",
624 EXTRACT_32BITS(&dp[3]),
625 EXTRACT_32BITS(&dp[2]),
626 EXTRACT_32BITS(&dp[1]),
627 EXTRACT_32BITS(&dp[0]));
628 }
629 return;
630 }
631 break;
632
633 case NFSPROC_CREATE:
634 printf(" create");
635 if ((dp = parsereq(rp, length)) != NULL &&
636 parsefhn(dp, v3) != NULL)
637 return;
638 break;
639
640 case NFSPROC_MKDIR:
641 printf(" mkdir");
642 if ((dp = parsereq(rp, length)) != 0 && parsefhn(dp, v3) != 0)
643 return;
644 break;
645
646 case NFSPROC_SYMLINK:
647 printf(" symlink");
648 if ((dp = parsereq(rp, length)) != 0 &&
649 (dp = parsefhn(dp, v3)) != 0) {
650 fputs(" ->", stdout);
651 if (v3 && (dp = parse_sattr3(dp, &sa3)) == 0)
652 break;
653 if (parsefn(dp) == 0)
654 break;
655 if (v3 && vflag)
656 print_sattr3(&sa3, vflag);
657 return;
658 }
659 break;
660
661 case NFSPROC_MKNOD:
662 printf(" mknod");
663 if ((dp = parsereq(rp, length)) != 0 &&
664 (dp = parsefhn(dp, v3)) != 0) {
665 TCHECK(*dp);
666 type = (nfs_type)EXTRACT_32BITS(dp);
667 dp++;
668 if ((dp = parse_sattr3(dp, &sa3)) == 0)
669 break;
670 printf(" %s", tok2str(type2str, "unk-ft %d", type));
671 if (vflag && (type == NFCHR || type == NFBLK)) {
672 TCHECK(dp[1]);
673 printf(" %u/%u",
674 EXTRACT_32BITS(&dp[0]),
675 EXTRACT_32BITS(&dp[1]));
676 dp += 2;
677 }
678 if (vflag)
679 print_sattr3(&sa3, vflag);
680 return;
681 }
682 break;
683
684 case NFSPROC_REMOVE:
685 printf(" remove");
686 if ((dp = parsereq(rp, length)) != NULL &&
687 parsefhn(dp, v3) != NULL)
688 return;
689 break;
690
691 case NFSPROC_RMDIR:
692 printf(" rmdir");
693 if ((dp = parsereq(rp, length)) != NULL &&
694 parsefhn(dp, v3) != NULL)
695 return;
696 break;
697
698 case NFSPROC_RENAME:
699 printf(" rename");
700 if ((dp = parsereq(rp, length)) != NULL &&
701 (dp = parsefhn(dp, v3)) != NULL) {
702 fputs(" ->", stdout);
703 if (parsefhn(dp, v3) != NULL)
704 return;
705 }
706 break;
707
708 case NFSPROC_LINK:
709 printf(" link");
710 if ((dp = parsereq(rp, length)) != NULL &&
711 (dp = parsefh(dp, v3)) != NULL) {
712 fputs(" ->", stdout);
713 if (parsefhn(dp, v3) != NULL)
714 return;
715 }
716 break;
717
718 case NFSPROC_READDIR:
719 printf(" readdir");
720 if ((dp = parsereq(rp, length)) != NULL &&
721 (dp = parsefh(dp, v3)) != NULL) {
722 if (v3) {
723 TCHECK(dp[4]);
724 /*
725 * We shouldn't really try to interpret the
726 * offset cookie here.
727 */
728 printf(" %u bytes @ %" PRId64,
729 EXTRACT_32BITS(&dp[4]),
730 EXTRACT_64BITS(&dp[0]));
731 if (vflag)
732 printf(" verf %08x%08x", dp[2],
733 dp[3]);
734 } else {
735 TCHECK(dp[1]);
736 /*
737 * Print the offset as signed, since -1 is
738 * common, but offsets > 2^31 aren't.
739 */
740 printf(" %u bytes @ %d",
741 EXTRACT_32BITS(&dp[1]),
742 EXTRACT_32BITS(&dp[0]));
743 }
744 return;
745 }
746 break;
747
748 case NFSPROC_READDIRPLUS:
749 printf(" readdirplus");
750 if ((dp = parsereq(rp, length)) != NULL &&
751 (dp = parsefh(dp, v3)) != NULL) {
752 TCHECK(dp[4]);
753 /*
754 * We don't try to interpret the offset
755 * cookie here.
756 */
757 printf(" %u bytes @ %" PRId64,
758 EXTRACT_32BITS(&dp[4]),
759 EXTRACT_64BITS(&dp[0]));
760 if (vflag) {
761 TCHECK(dp[5]);
762 printf(" max %u verf %08x%08x",
763 EXTRACT_32BITS(&dp[5]), dp[2], dp[3]);
764 }
765 return;
766 }
767 break;
768
769 case NFSPROC_FSSTAT:
770 printf(" fsstat");
771 if ((dp = parsereq(rp, length)) != NULL &&
772 parsefh(dp, v3) != NULL)
773 return;
774 break;
775
776 case NFSPROC_FSINFO:
777 printf(" fsinfo");
778 if ((dp = parsereq(rp, length)) != NULL &&
779 parsefh(dp, v3) != NULL)
780 return;
781 break;
782
783 case NFSPROC_PATHCONF:
784 printf(" pathconf");
785 if ((dp = parsereq(rp, length)) != NULL &&
786 parsefh(dp, v3) != NULL)
787 return;
788 break;
789
790 case NFSPROC_COMMIT:
791 printf(" commit");
792 if ((dp = parsereq(rp, length)) != NULL &&
793 (dp = parsefh(dp, v3)) != NULL) {
794 TCHECK(dp[2]);
795 printf(" %u bytes @ %" PRIu64,
796 EXTRACT_32BITS(&dp[2]),
797 EXTRACT_64BITS(&dp[0]));
798 return;
799 }
800 break;
801
802 default:
803 printf(" proc-%u", EXTRACT_32BITS(&rp->rm_call.cb_proc));
804 return;
805 }
806
807 trunc:
808 if (!nfserr)
809 fputs(" [|nfs]", stdout);
810 }
811
812 /*
813 * Print out an NFS file handle.
814 * We assume packet was not truncated before the end of the
815 * file handle pointed to by dp.
816 *
817 * Note: new version (using portable file-handle parser) doesn't produce
818 * generation number. It probably could be made to do that, with some
819 * additional hacking on the parser code.
820 */
821 static void
822 nfs_printfh(register const u_int32_t *dp, const u_int len)
823 {
824 my_fsid fsid;
825 ino_t ino;
826 const char *sfsname = NULL;
827 char *spacep;
828
829 if (uflag) {
830 u_int i;
831 char const *sep = "";
832
833 printf(" fh[");
834 for (i=0; i<len; i++) {
835 (void)printf("%s%x", sep, dp[i]);
836 sep = ":";
837 }
838 printf("]");
839 return;
840 }
841
842 Parse_fh((const u_char *)dp, len, &fsid, &ino, NULL, &sfsname, 0);
843
844 if (sfsname) {
845 /* file system ID is ASCII, not numeric, for this server OS */
846 static char temp[NFSX_V3FHMAX+1];
847
848 /* Make sure string is null-terminated */
849 strncpy(temp, sfsname, NFSX_V3FHMAX);
850 temp[sizeof(temp) - 1] = '\0';
851 /* Remove trailing spaces */
852 spacep = strchr(temp, ' ');
853 if (spacep)
854 *spacep = '\0';
855
856 (void)printf(" fh %s/", temp);
857 } else {
858 (void)printf(" fh %d,%d/",
859 fsid.Fsid_dev.Major, fsid.Fsid_dev.Minor);
860 }
861
862 if(fsid.Fsid_dev.Minor == 257)
863 /* Print the undecoded handle */
864 (void)printf("%s", fsid.Opaque_Handle);
865 else
866 (void)printf("%ld", (long) ino);
867 }
868
869 /*
870 * Maintain a small cache of recent client.XID.server/proc pairs, to allow
871 * us to match up replies with requests and thus to know how to parse
872 * the reply.
873 */
874
875 struct xid_map_entry {
876 u_int32_t xid; /* transaction ID (net order) */
877 int ipver; /* IP version (4 or 6) */
878 #ifdef INET6
879 struct in6_addr client; /* client IP address (net order) */
880 struct in6_addr server; /* server IP address (net order) */
881 #else
882 struct in_addr client; /* client IP address (net order) */
883 struct in_addr server; /* server IP address (net order) */
884 #endif
885 u_int32_t proc; /* call proc number (host order) */
886 u_int32_t vers; /* program version (host order) */
887 };
888
889 /*
890 * Map entries are kept in an array that we manage as a ring;
891 * new entries are always added at the tail of the ring. Initially,
892 * all the entries are zero and hence don't match anything.
893 */
894
895 #define XIDMAPSIZE 64
896
897 struct xid_map_entry xid_map[XIDMAPSIZE];
898
899 int xid_map_next = 0;
900 int xid_map_hint = 0;
901
902 static int
903 xid_map_enter(const struct sunrpc_msg *rp, const u_char *bp)
904 {
905 struct ip *ip = NULL;
906 #ifdef INET6
907 struct ip6_hdr *ip6 = NULL;
908 #endif
909 struct xid_map_entry *xmep;
910
911 if (!TTEST(rp->rm_call.cb_vers))
912 return (0);
913 switch (IP_V((struct ip *)bp)) {
914 case 4:
915 ip = (struct ip *)bp;
916 break;
917 #ifdef INET6
918 case 6:
919 ip6 = (struct ip6_hdr *)bp;
920 break;
921 #endif
922 default:
923 return (1);
924 }
925
926 xmep = &xid_map[xid_map_next];
927
928 if (++xid_map_next >= XIDMAPSIZE)
929 xid_map_next = 0;
930
931 xmep->xid = rp->rm_xid;
932 if (ip) {
933 xmep->ipver = 4;
934 memcpy(&xmep->client, &ip->ip_src, sizeof(ip->ip_src));
935 memcpy(&xmep->server, &ip->ip_dst, sizeof(ip->ip_dst));
936 }
937 #ifdef INET6
938 else if (ip6) {
939 xmep->ipver = 6;
940 memcpy(&xmep->client, &ip6->ip6_src, sizeof(ip6->ip6_src));
941 memcpy(&xmep->server, &ip6->ip6_dst, sizeof(ip6->ip6_dst));
942 }
943 #endif
944 xmep->proc = EXTRACT_32BITS(&rp->rm_call.cb_proc);
945 xmep->vers = EXTRACT_32BITS(&rp->rm_call.cb_vers);
946 return (1);
947 }
948
949 /*
950 * Returns 0 and puts NFSPROC_xxx in proc return and
951 * version in vers return, or returns -1 on failure
952 */
953 static int
954 xid_map_find(const struct sunrpc_msg *rp, const u_char *bp, u_int32_t *proc,
955 u_int32_t *vers)
956 {
957 int i;
958 struct xid_map_entry *xmep;
959 u_int32_t xid = rp->rm_xid;
960 struct ip *ip = (struct ip *)bp;
961 #ifdef INET6
962 struct ip6_hdr *ip6 = (struct ip6_hdr *)bp;
963 #endif
964 int cmp;
965
966 /* Start searching from where we last left off */
967 i = xid_map_hint;
968 do {
969 xmep = &xid_map[i];
970 cmp = 1;
971 if (xmep->ipver != IP_V(ip) || xmep->xid != xid)
972 goto nextitem;
973 switch (xmep->ipver) {
974 case 4:
975 if (memcmp(&ip->ip_src, &xmep->server,
976 sizeof(ip->ip_src)) != 0 ||
977 memcmp(&ip->ip_dst, &xmep->client,
978 sizeof(ip->ip_dst)) != 0) {
979 cmp = 0;
980 }
981 break;
982 #ifdef INET6
983 case 6:
984 if (memcmp(&ip6->ip6_src, &xmep->server,
985 sizeof(ip6->ip6_src)) != 0 ||
986 memcmp(&ip6->ip6_dst, &xmep->client,
987 sizeof(ip6->ip6_dst)) != 0) {
988 cmp = 0;
989 }
990 break;
991 #endif
992 default:
993 cmp = 0;
994 break;
995 }
996 if (cmp) {
997 /* match */
998 xid_map_hint = i;
999 *proc = xmep->proc;
1000 *vers = xmep->vers;
1001 return 0;
1002 }
1003 nextitem:
1004 if (++i >= XIDMAPSIZE)
1005 i = 0;
1006 } while (i != xid_map_hint);
1007
1008 /* search failed */
1009 return (-1);
1010 }
1011
1012 /*
1013 * Routines for parsing reply packets
1014 */
1015
1016 /*
1017 * Return a pointer to the beginning of the actual results.
1018 * If the packet was truncated, return 0.
1019 */
1020 static const u_int32_t *
1021 parserep(register const struct sunrpc_msg *rp, register u_int length)
1022 {
1023 register const u_int32_t *dp;
1024 u_int len;
1025 enum sunrpc_accept_stat astat;
1026
1027 /*
1028 * Portability note:
1029 * Here we find the address of the ar_verf credentials.
1030 * Originally, this calculation was
1031 * dp = (u_int32_t *)&rp->rm_reply.rp_acpt.ar_verf
1032 * On the wire, the rp_acpt field starts immediately after
1033 * the (32 bit) rp_stat field. However, rp_acpt (which is a
1034 * "struct accepted_reply") contains a "struct opaque_auth",
1035 * whose internal representation contains a pointer, so on a
1036 * 64-bit machine the compiler inserts 32 bits of padding
1037 * before rp->rm_reply.rp_acpt.ar_verf. So, we cannot use
1038 * the internal representation to parse the on-the-wire
1039 * representation. Instead, we skip past the rp_stat field,
1040 * which is an "enum" and so occupies one 32-bit word.
1041 */
1042 dp = ((const u_int32_t *)&rp->rm_reply) + 1;
1043 TCHECK(dp[1]);
1044 len = EXTRACT_32BITS(&dp[1]);
1045 if (len >= length)
1046 return (NULL);
1047 /*
1048 * skip past the ar_verf credentials.
1049 */
1050 dp += (len + (2*sizeof(u_int32_t) + 3)) / sizeof(u_int32_t);
1051 TCHECK2(dp[0], 0);
1052
1053 /*
1054 * now we can check the ar_stat field
1055 */
1056 astat = (enum sunrpc_accept_stat) EXTRACT_32BITS(dp);
1057 switch (astat) {
1058
1059 case SUNRPC_SUCCESS:
1060 break;
1061
1062 case SUNRPC_PROG_UNAVAIL:
1063 printf(" PROG_UNAVAIL");
1064 nfserr = 1; /* suppress trunc string */
1065 return (NULL);
1066
1067 case SUNRPC_PROG_MISMATCH:
1068 printf(" PROG_MISMATCH");
1069 nfserr = 1; /* suppress trunc string */
1070 return (NULL);
1071
1072 case SUNRPC_PROC_UNAVAIL:
1073 printf(" PROC_UNAVAIL");
1074 nfserr = 1; /* suppress trunc string */
1075 return (NULL);
1076
1077 case SUNRPC_GARBAGE_ARGS:
1078 printf(" GARBAGE_ARGS");
1079 nfserr = 1; /* suppress trunc string */
1080 return (NULL);
1081
1082 case SUNRPC_SYSTEM_ERR:
1083 printf(" SYSTEM_ERR");
1084 nfserr = 1; /* suppress trunc string */
1085 return (NULL);
1086
1087 default:
1088 printf(" ar_stat %d", astat);
1089 nfserr = 1; /* suppress trunc string */
1090 return (NULL);
1091 }
1092 /* successful return */
1093 TCHECK2(*dp, sizeof(astat));
1094 return ((u_int32_t *) (sizeof(astat) + ((char *)dp)));
1095 trunc:
1096 return (0);
1097 }
1098
1099 static const u_int32_t *
1100 parsestatus(const u_int32_t *dp, int *er)
1101 {
1102 int errnum;
1103
1104 TCHECK(dp[0]);
1105
1106 errnum = EXTRACT_32BITS(&dp[0]);
1107 if (er)
1108 *er = errnum;
1109 if (errnum != 0) {
1110 if (!qflag)
1111 printf(" ERROR: %s",
1112 tok2str(status2str, "unk %d", errnum));
1113 nfserr = 1;
1114 }
1115 return (dp + 1);
1116 trunc:
1117 return NULL;
1118 }
1119
1120 static const u_int32_t *
1121 parsefattr(const u_int32_t *dp, int verbose, int v3)
1122 {
1123 const struct nfs_fattr *fap;
1124
1125 fap = (const struct nfs_fattr *)dp;
1126 TCHECK(fap->fa_gid);
1127 if (verbose) {
1128 printf(" %s %o ids %d/%d",
1129 tok2str(type2str, "unk-ft %d ",
1130 EXTRACT_32BITS(&fap->fa_type)),
1131 EXTRACT_32BITS(&fap->fa_mode),
1132 EXTRACT_32BITS(&fap->fa_uid),
1133 EXTRACT_32BITS(&fap->fa_gid));
1134 if (v3) {
1135 TCHECK(fap->fa3_size);
1136 printf(" sz %" PRIu64,
1137 EXTRACT_64BITS((u_int32_t *)&fap->fa3_size));
1138 } else {
1139 TCHECK(fap->fa2_size);
1140 printf(" sz %d", EXTRACT_32BITS(&fap->fa2_size));
1141 }
1142 }
1143 /* print lots more stuff */
1144 if (verbose > 1) {
1145 if (v3) {
1146 TCHECK(fap->fa3_ctime);
1147 printf(" nlink %d rdev %d/%d",
1148 EXTRACT_32BITS(&fap->fa_nlink),
1149 EXTRACT_32BITS(&fap->fa3_rdev.specdata1),
1150 EXTRACT_32BITS(&fap->fa3_rdev.specdata2));
1151 printf(" fsid %" PRIx64,
1152 EXTRACT_64BITS((u_int32_t *)&fap->fa3_fsid));
1153 printf(" fileid %" PRIx64,
1154 EXTRACT_64BITS((u_int32_t *)&fap->fa3_fileid));
1155 printf(" a/m/ctime %u.%06u",
1156 EXTRACT_32BITS(&fap->fa3_atime.nfsv3_sec),
1157 EXTRACT_32BITS(&fap->fa3_atime.nfsv3_nsec));
1158 printf(" %u.%06u",
1159 EXTRACT_32BITS(&fap->fa3_mtime.nfsv3_sec),
1160 EXTRACT_32BITS(&fap->fa3_mtime.nfsv3_nsec));
1161 printf(" %u.%06u",
1162 EXTRACT_32BITS(&fap->fa3_ctime.nfsv3_sec),
1163 EXTRACT_32BITS(&fap->fa3_ctime.nfsv3_nsec));
1164 } else {
1165 TCHECK(fap->fa2_ctime);
1166 printf(" nlink %d rdev %x fsid %x nodeid %x a/m/ctime",
1167 EXTRACT_32BITS(&fap->fa_nlink),
1168 EXTRACT_32BITS(&fap->fa2_rdev),
1169 EXTRACT_32BITS(&fap->fa2_fsid),
1170 EXTRACT_32BITS(&fap->fa2_fileid));
1171 printf(" %u.%06u",
1172 EXTRACT_32BITS(&fap->fa2_atime.nfsv2_sec),
1173 EXTRACT_32BITS(&fap->fa2_atime.nfsv2_usec));
1174 printf(" %u.%06u",
1175 EXTRACT_32BITS(&fap->fa2_mtime.nfsv2_sec),
1176 EXTRACT_32BITS(&fap->fa2_mtime.nfsv2_usec));
1177 printf(" %u.%06u",
1178 EXTRACT_32BITS(&fap->fa2_ctime.nfsv2_sec),
1179 EXTRACT_32BITS(&fap->fa2_ctime.nfsv2_usec));
1180 }
1181 }
1182 return ((const u_int32_t *)((unsigned char *)dp +
1183 (v3 ? NFSX_V3FATTR : NFSX_V2FATTR)));
1184 trunc:
1185 return (NULL);
1186 }
1187
1188 static int
1189 parseattrstat(const u_int32_t *dp, int verbose, int v3)
1190 {
1191 int er;
1192
1193 dp = parsestatus(dp, &er);
1194 if (dp == NULL)
1195 return (0);
1196 if (er)
1197 return (1);
1198
1199 return (parsefattr(dp, verbose, v3) != NULL);
1200 }
1201
1202 static int
1203 parsediropres(const u_int32_t *dp)
1204 {
1205 int er;
1206
1207 if (!(dp = parsestatus(dp, &er)))
1208 return (0);
1209 if (er)
1210 return (1);
1211
1212 dp = parsefh(dp, 0);
1213 if (dp == NULL)
1214 return (0);
1215
1216 return (parsefattr(dp, vflag, 0) != NULL);
1217 }
1218
1219 static int
1220 parselinkres(const u_int32_t *dp, int v3)
1221 {
1222 int er;
1223
1224 dp = parsestatus(dp, &er);
1225 if (dp == NULL)
1226 return(0);
1227 if (er)
1228 return(1);
1229 if (v3 && !(dp = parse_post_op_attr(dp, vflag)))
1230 return (0);
1231 putchar(' ');
1232 return (parsefn(dp) != NULL);
1233 }
1234
1235 static int
1236 parsestatfs(const u_int32_t *dp, int v3)
1237 {
1238 const struct nfs_statfs *sfsp;
1239 int er;
1240
1241 dp = parsestatus(dp, &er);
1242 if (dp == NULL)
1243 return (0);
1244 if (!v3 && er)
1245 return (1);
1246
1247 if (qflag)
1248 return(1);
1249
1250 if (v3) {
1251 if (vflag)
1252 printf(" POST:");
1253 if (!(dp = parse_post_op_attr(dp, vflag)))
1254 return (0);
1255 }
1256
1257 TCHECK2(*dp, (v3 ? NFSX_V3STATFS : NFSX_V2STATFS));
1258
1259 sfsp = (const struct nfs_statfs *)dp;
1260
1261 if (v3) {
1262 printf(" tbytes %" PRIu64 " fbytes %" PRIu64 " abytes %" PRIu64,
1263 EXTRACT_64BITS((u_int32_t *)&sfsp->sf_tbytes),
1264 EXTRACT_64BITS((u_int32_t *)&sfsp->sf_fbytes),
1265 EXTRACT_64BITS((u_int32_t *)&sfsp->sf_abytes));
1266 if (vflag) {
1267 printf(" tfiles %" PRIu64 " ffiles %" PRIu64 " afiles %" PRIu64 " invar %u",
1268 EXTRACT_64BITS((u_int32_t *)&sfsp->sf_tfiles),
1269 EXTRACT_64BITS((u_int32_t *)&sfsp->sf_ffiles),
1270 EXTRACT_64BITS((u_int32_t *)&sfsp->sf_afiles),
1271 EXTRACT_32BITS(&sfsp->sf_invarsec));
1272 }
1273 } else {
1274 printf(" tsize %d bsize %d blocks %d bfree %d bavail %d",
1275 EXTRACT_32BITS(&sfsp->sf_tsize),
1276 EXTRACT_32BITS(&sfsp->sf_bsize),
1277 EXTRACT_32BITS(&sfsp->sf_blocks),
1278 EXTRACT_32BITS(&sfsp->sf_bfree),
1279 EXTRACT_32BITS(&sfsp->sf_bavail));
1280 }
1281
1282 return (1);
1283 trunc:
1284 return (0);
1285 }
1286
1287 static int
1288 parserddires(const u_int32_t *dp)
1289 {
1290 int er;
1291
1292 dp = parsestatus(dp, &er);
1293 if (dp == NULL)
1294 return (0);
1295 if (er)
1296 return (1);
1297 if (qflag)
1298 return (1);
1299
1300 TCHECK(dp[2]);
1301 printf(" offset %x size %d ",
1302 EXTRACT_32BITS(&dp[0]), EXTRACT_32BITS(&dp[1]));
1303 if (dp[2] != 0)
1304 printf(" eof");
1305
1306 return (1);
1307 trunc:
1308 return (0);
1309 }
1310
1311 static const u_int32_t *
1312 parse_wcc_attr(const u_int32_t *dp)
1313 {
1314 printf(" sz %" PRIu64, EXTRACT_64BITS(&dp[0]));
1315 printf(" mtime %u.%06u ctime %u.%06u",
1316 EXTRACT_32BITS(&dp[2]), EXTRACT_32BITS(&dp[3]),
1317 EXTRACT_32BITS(&dp[4]), EXTRACT_32BITS(&dp[5]));
1318 return (dp + 6);
1319 }
1320
1321 /*
1322 * Pre operation attributes. Print only if vflag > 1.
1323 */
1324 static const u_int32_t *
1325 parse_pre_op_attr(const u_int32_t *dp, int verbose)
1326 {
1327 TCHECK(dp[0]);
1328 if (!EXTRACT_32BITS(&dp[0]))
1329 return (dp + 1);
1330 dp++;
1331 TCHECK2(*dp, 24);
1332 if (verbose > 1) {
1333 return parse_wcc_attr(dp);
1334 } else {
1335 /* If not verbose enough, just skip over wcc_attr */
1336 return (dp + 6);
1337 }
1338 trunc:
1339 return (NULL);
1340 }
1341
1342 /*
1343 * Post operation attributes are printed if vflag >= 1
1344 */
1345 static const u_int32_t *
1346 parse_post_op_attr(const u_int32_t *dp, int verbose)
1347 {
1348 TCHECK(dp[0]);
1349 if (!EXTRACT_32BITS(&dp[0]))
1350 return (dp + 1);
1351 dp++;
1352 if (verbose) {
1353 return parsefattr(dp, verbose, 1);
1354 } else
1355 return (dp + (NFSX_V3FATTR / sizeof (u_int32_t)));
1356 trunc:
1357 return (NULL);
1358 }
1359
1360 static const u_int32_t *
1361 parse_wcc_data(const u_int32_t *dp, int verbose)
1362 {
1363 if (verbose > 1)
1364 printf(" PRE:");
1365 if (!(dp = parse_pre_op_attr(dp, verbose)))
1366 return (0);
1367
1368 if (verbose)
1369 printf(" POST:");
1370 return parse_post_op_attr(dp, verbose);
1371 }
1372
1373 static const u_int32_t *
1374 parsecreateopres(const u_int32_t *dp, int verbose)
1375 {
1376 int er;
1377
1378 if (!(dp = parsestatus(dp, &er)))
1379 return (0);
1380 if (er)
1381 dp = parse_wcc_data(dp, verbose);
1382 else {
1383 TCHECK(dp[0]);
1384 if (!EXTRACT_32BITS(&dp[0]))
1385 return (dp + 1);
1386 dp++;
1387 if (!(dp = parsefh(dp, 1)))
1388 return (0);
1389 if (verbose) {
1390 if (!(dp = parse_post_op_attr(dp, verbose)))
1391 return (0);
1392 if (vflag > 1) {
1393 printf(" dir attr:");
1394 dp = parse_wcc_data(dp, verbose);
1395 }
1396 }
1397 }
1398 return (dp);
1399 trunc:
1400 return (NULL);
1401 }
1402
1403 static int
1404 parsewccres(const u_int32_t *dp, int verbose)
1405 {
1406 int er;
1407
1408 if (!(dp = parsestatus(dp, &er)))
1409 return (0);
1410 return parse_wcc_data(dp, verbose) != 0;
1411 }
1412
1413 static const u_int32_t *
1414 parsev3rddirres(const u_int32_t *dp, int verbose)
1415 {
1416 int er;
1417
1418 if (!(dp = parsestatus(dp, &er)))
1419 return (0);
1420 if (vflag)
1421 printf(" POST:");
1422 if (!(dp = parse_post_op_attr(dp, verbose)))
1423 return (0);
1424 if (er)
1425 return dp;
1426 if (vflag) {
1427 TCHECK(dp[1]);
1428 printf(" verf %08x%08x", dp[0], dp[1]);
1429 dp += 2;
1430 }
1431 return dp;
1432 trunc:
1433 return (NULL);
1434 }
1435
1436 static int
1437 parsefsinfo(const u_int32_t *dp)
1438 {
1439 struct nfsv3_fsinfo *sfp;
1440 int er;
1441
1442 if (!(dp = parsestatus(dp, &er)))
1443 return (0);
1444 if (vflag)
1445 printf(" POST:");
1446 if (!(dp = parse_post_op_attr(dp, vflag)))
1447 return (0);
1448 if (er)
1449 return (1);
1450
1451 sfp = (struct nfsv3_fsinfo *)dp;
1452 TCHECK(*sfp);
1453 printf(" rtmax %u rtpref %u wtmax %u wtpref %u dtpref %u",
1454 EXTRACT_32BITS(&sfp->fs_rtmax),
1455 EXTRACT_32BITS(&sfp->fs_rtpref),
1456 EXTRACT_32BITS(&sfp->fs_wtmax),
1457 EXTRACT_32BITS(&sfp->fs_wtpref),
1458 EXTRACT_32BITS(&sfp->fs_dtpref));
1459 if (vflag) {
1460 printf(" rtmult %u wtmult %u maxfsz %" PRIu64,
1461 EXTRACT_32BITS(&sfp->fs_rtmult),
1462 EXTRACT_32BITS(&sfp->fs_wtmult),
1463 EXTRACT_64BITS((u_int32_t *)&sfp->fs_maxfilesize));
1464 printf(" delta %u.%06u ",
1465 EXTRACT_32BITS(&sfp->fs_timedelta.nfsv3_sec),
1466 EXTRACT_32BITS(&sfp->fs_timedelta.nfsv3_nsec));
1467 }
1468 return (1);
1469 trunc:
1470 return (0);
1471 }
1472
1473 static int
1474 parsepathconf(const u_int32_t *dp)
1475 {
1476 int er;
1477 struct nfsv3_pathconf *spp;
1478
1479 if (!(dp = parsestatus(dp, &er)))
1480 return (0);
1481 if (vflag)
1482 printf(" POST:");
1483 if (!(dp = parse_post_op_attr(dp, vflag)))
1484 return (0);
1485 if (er)
1486 return (1);
1487
1488 spp = (struct nfsv3_pathconf *)dp;
1489 TCHECK(*spp);
1490
1491 printf(" linkmax %u namemax %u %s %s %s %s",
1492 EXTRACT_32BITS(&spp->pc_linkmax),
1493 EXTRACT_32BITS(&spp->pc_namemax),
1494 EXTRACT_32BITS(&spp->pc_notrunc) ? "notrunc" : "",
1495 EXTRACT_32BITS(&spp->pc_chownrestricted) ? "chownres" : "",
1496 EXTRACT_32BITS(&spp->pc_caseinsensitive) ? "igncase" : "",
1497 EXTRACT_32BITS(&spp->pc_casepreserving) ? "keepcase" : "");
1498 return (1);
1499 trunc:
1500 return (0);
1501 }
1502
1503 static void
1504 interp_reply(const struct sunrpc_msg *rp, u_int32_t proc, u_int32_t vers, int length)
1505 {
1506 register const u_int32_t *dp;
1507 register int v3;
1508 int er;
1509
1510 v3 = (vers == NFS_VER3);
1511
1512 if (!v3 && proc < NFS_NPROCS)
1513 proc = nfsv3_procid[proc];
1514
1515 switch (proc) {
1516
1517 case NFSPROC_NOOP:
1518 printf(" nop");
1519 return;
1520
1521 case NFSPROC_NULL:
1522 printf(" null");
1523 return;
1524
1525 case NFSPROC_GETATTR:
1526 printf(" getattr");
1527 dp = parserep(rp, length);
1528 if (dp != NULL && parseattrstat(dp, !qflag, v3) != 0)
1529 return;
1530 break;
1531
1532 case NFSPROC_SETATTR:
1533 printf(" setattr");
1534 if (!(dp = parserep(rp, length)))
1535 return;
1536 if (v3) {
1537 if (parsewccres(dp, vflag))
1538 return;
1539 } else {
1540 if (parseattrstat(dp, !qflag, 0) != 0)
1541 return;
1542 }
1543 break;
1544
1545 case NFSPROC_LOOKUP:
1546 printf(" lookup");
1547 if (!(dp = parserep(rp, length)))
1548 break;
1549 if (v3) {
1550 if (!(dp = parsestatus(dp, &er)))
1551 break;
1552 if (er) {
1553 if (vflag > 1) {
1554 printf(" post dattr:");
1555 dp = parse_post_op_attr(dp, vflag);
1556 }
1557 } else {
1558 if (!(dp = parsefh(dp, v3)))
1559 break;
1560 if ((dp = parse_post_op_attr(dp, vflag)) &&
1561 vflag > 1) {
1562 printf(" post dattr:");
1563 dp = parse_post_op_attr(dp, vflag);
1564 }
1565 }
1566 if (dp)
1567 return;
1568 } else {
1569 if (parsediropres(dp) != 0)
1570 return;
1571 }
1572 break;
1573
1574 case NFSPROC_ACCESS:
1575 printf(" access");
1576 if (!(dp = parserep(rp, length)))
1577 break;
1578 if (!(dp = parsestatus(dp, &er)))
1579 break;
1580 if (vflag)
1581 printf(" attr:");
1582 if (!(dp = parse_post_op_attr(dp, vflag)))
1583 break;
1584 if (!er)
1585 printf(" c %04x", EXTRACT_32BITS(&dp[0]));
1586 return;
1587
1588 case NFSPROC_READLINK:
1589 printf(" readlink");
1590 dp = parserep(rp, length);
1591 if (dp != NULL && parselinkres(dp, v3) != 0)
1592 return;
1593 break;
1594
1595 case NFSPROC_READ:
1596 printf(" read");
1597 if (!(dp = parserep(rp, length)))
1598 break;
1599 if (v3) {
1600 if (!(dp = parsestatus(dp, &er)))
1601 break;
1602 if (!(dp = parse_post_op_attr(dp, vflag)))
1603 break;
1604 if (er)
1605 return;
1606 if (vflag) {
1607 TCHECK(dp[1]);
1608 printf(" %u bytes", EXTRACT_32BITS(&dp[0]));
1609 if (EXTRACT_32BITS(&dp[1]))
1610 printf(" EOF");
1611 }
1612 return;
1613 } else {
1614 if (parseattrstat(dp, vflag, 0) != 0)
1615 return;
1616 }
1617 break;
1618
1619 case NFSPROC_WRITE:
1620 printf(" write");
1621 if (!(dp = parserep(rp, length)))
1622 break;
1623 if (v3) {
1624 if (!(dp = parsestatus(dp, &er)))
1625 break;
1626 if (!(dp = parse_wcc_data(dp, vflag)))
1627 break;
1628 if (er)
1629 return;
1630 if (vflag) {
1631 TCHECK(dp[0]);
1632 printf(" %u bytes", EXTRACT_32BITS(&dp[0]));
1633 if (vflag > 1) {
1634 TCHECK(dp[1]);
1635 printf(" <%s>",
1636 tok2str(nfsv3_writemodes,
1637 NULL, EXTRACT_32BITS(&dp[1])));
1638 }
1639 return;
1640 }
1641 } else {
1642 if (parseattrstat(dp, vflag, v3) != 0)
1643 return;
1644 }
1645 break;
1646
1647 case NFSPROC_CREATE:
1648 printf(" create");
1649 if (!(dp = parserep(rp, length)))
1650 break;
1651 if (v3) {
1652 if (parsecreateopres(dp, vflag) != 0)
1653 return;
1654 } else {
1655 if (parsediropres(dp) != 0)
1656 return;
1657 }
1658 break;
1659
1660 case NFSPROC_MKDIR:
1661 printf(" mkdir");
1662 if (!(dp = parserep(rp, length)))
1663 break;
1664 if (v3) {
1665 if (parsecreateopres(dp, vflag) != 0)
1666 return;
1667 } else {
1668 if (parsediropres(dp) != 0)
1669 return;
1670 }
1671 break;
1672
1673 case NFSPROC_SYMLINK:
1674 printf(" symlink");
1675 if (!(dp = parserep(rp, length)))
1676 break;
1677 if (v3) {
1678 if (parsecreateopres(dp, vflag) != 0)
1679 return;
1680 } else {
1681 if (parsestatus(dp, &er) != 0)
1682 return;
1683 }
1684 break;
1685
1686 case NFSPROC_MKNOD:
1687 printf(" mknod");
1688 if (!(dp = parserep(rp, length)))
1689 break;
1690 if (parsecreateopres(dp, vflag) != 0)
1691 return;
1692 break;
1693
1694 case NFSPROC_REMOVE:
1695 printf(" remove");
1696 if (!(dp = parserep(rp, length)))
1697 break;
1698 if (v3) {
1699 if (parsewccres(dp, vflag))
1700 return;
1701 } else {
1702 if (parsestatus(dp, &er) != 0)
1703 return;
1704 }
1705 break;
1706
1707 case NFSPROC_RMDIR:
1708 printf(" rmdir");
1709 if (!(dp = parserep(rp, length)))
1710 break;
1711 if (v3) {
1712 if (parsewccres(dp, vflag))
1713 return;
1714 } else {
1715 if (parsestatus(dp, &er) != 0)
1716 return;
1717 }
1718 break;
1719
1720 case NFSPROC_RENAME:
1721 printf(" rename");
1722 if (!(dp = parserep(rp, length)))
1723 break;
1724 if (v3) {
1725 if (!(dp = parsestatus(dp, &er)))
1726 break;
1727 if (vflag) {
1728 printf(" from:");
1729 if (!(dp = parse_wcc_data(dp, vflag)))
1730 break;
1731 printf(" to:");
1732 if (!(dp = parse_wcc_data(dp, vflag)))
1733 break;
1734 }
1735 return;
1736 } else {
1737 if (parsestatus(dp, &er) != 0)
1738 return;
1739 }
1740 break;
1741
1742 case NFSPROC_LINK:
1743 printf(" link");
1744 if (!(dp = parserep(rp, length)))
1745 break;
1746 if (v3) {
1747 if (!(dp = parsestatus(dp, &er)))
1748 break;
1749 if (vflag) {
1750 printf(" file POST:");
1751 if (!(dp = parse_post_op_attr(dp, vflag)))
1752 break;
1753 printf(" dir:");
1754 if (!(dp = parse_wcc_data(dp, vflag)))
1755 break;
1756 return;
1757 }
1758 } else {
1759 if (parsestatus(dp, &er) != 0)
1760 return;
1761 }
1762 break;
1763
1764 case NFSPROC_READDIR:
1765 printf(" readdir");
1766 if (!(dp = parserep(rp, length)))
1767 break;
1768 if (v3) {
1769 if (parsev3rddirres(dp, vflag))
1770 return;
1771 } else {
1772 if (parserddires(dp) != 0)
1773 return;
1774 }
1775 break;
1776
1777 case NFSPROC_READDIRPLUS:
1778 printf(" readdirplus");
1779 if (!(dp = parserep(rp, length)))
1780 break;
1781 if (parsev3rddirres(dp, vflag))
1782 return;
1783 break;
1784
1785 case NFSPROC_FSSTAT:
1786 printf(" fsstat");
1787 dp = parserep(rp, length);
1788 if (dp != NULL && parsestatfs(dp, v3) != 0)
1789 return;
1790 break;
1791
1792 case NFSPROC_FSINFO:
1793 printf(" fsinfo");
1794 dp = parserep(rp, length);
1795 if (dp != NULL && parsefsinfo(dp) != 0)
1796 return;
1797 break;
1798
1799 case NFSPROC_PATHCONF:
1800 printf(" pathconf");
1801 dp = parserep(rp, length);
1802 if (dp != NULL && parsepathconf(dp) != 0)
1803 return;
1804 break;
1805
1806 case NFSPROC_COMMIT:
1807 printf(" commit");
1808 dp = parserep(rp, length);
1809 if (dp != NULL && parsewccres(dp, vflag) != 0)
1810 return;
1811 break;
1812
1813 default:
1814 printf(" proc-%u", proc);
1815 return;
1816 }
1817 trunc:
1818 if (!nfserr)
1819 fputs(" [|nfs]", stdout);
1820 }
DragonFly BSD