]> The Tcpdump Group git mirrors - tcpdump/blob - print-nfs.c
projects / tcpdump / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
-Wall -Werror clean.
[tcpdump] / print-nfs.c
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[] =
24 "@(#) $Header: /tcpdump/master/tcpdump/print-nfs.c,v 1.70 2000-01-28 00:04:19 fenner Exp $ (LBL)";
25 #endif
26
27 #ifdef HAVE_CONFIG_H
28 #include "config.h"
29 #endif
30
31 #include <sys/param.h>
32 #include <sys/time.h>
33 #include <sys/socket.h>
34
35 #if __STDC__
36 struct mbuf;
37 struct rtentry;
38 #endif
39 #include <net/if.h>
40
41 #include <netinet/in.h>
42 #include <netinet/if_ether.h>
43 #include <netinet/in_systm.h>
44 #include <netinet/ip.h>
45
46 #include <rpc/rpc.h>
47
48 #include <ctype.h>
49 #include <pcap.h>
50 #include <stdio.h>
51 #include <string.h>
52
53 #include "interface.h"
54 #include "addrtoname.h"
55
56 #include "nfs.h"
57 #include "nfsfh.h"
58
59 static void nfs_printfh(const u_int32_t *, const u_int);
60 static void xid_map_enter(const struct rpc_msg *, const struct ip *);
61 static int32_t xid_map_find(const struct rpc_msg *, const struct ip *,
62 u_int32_t *, u_int32_t *);
63 static void interp_reply(const struct rpc_msg *, u_int32_t, u_int32_t, int);
64 static const u_int32_t *parse_post_op_attr(const u_int32_t *, int);
65 static void print_sattr3(const struct nfsv3_sattr *sa3, int verbose);
66 static int print_int64(const u_int32_t *dp, int how);
67
68 /*
69 * Mapping of old NFS Version 2 RPC numbers to generic numbers.
70 */
71 u_int32_t nfsv3_procid[NFS_NPROCS] = {
72 NFSPROC_NULL,
73 NFSPROC_GETATTR,
74 NFSPROC_SETATTR,
75 NFSPROC_NOOP,
76 NFSPROC_LOOKUP,
77 NFSPROC_READLINK,
78 NFSPROC_READ,
79 NFSPROC_NOOP,
80 NFSPROC_WRITE,
81 NFSPROC_CREATE,
82 NFSPROC_REMOVE,
83 NFSPROC_RENAME,
84 NFSPROC_LINK,
85 NFSPROC_SYMLINK,
86 NFSPROC_MKDIR,
87 NFSPROC_RMDIR,
88 NFSPROC_READDIR,
89 NFSPROC_FSSTAT,
90 NFSPROC_NOOP,
91 NFSPROC_NOOP,
92 NFSPROC_NOOP,
93 NFSPROC_NOOP,
94 NFSPROC_NOOP,
95 NFSPROC_NOOP,
96 NFSPROC_NOOP,
97 NFSPROC_NOOP
98 };
99
100 static struct tok nfsv3_writemodes[] = {
101 { 0, "unstable" },
102 { 1, "datasync" },
103 { 2, "filesync" },
104 { 0, NULL }
105 };
106
107 static struct tok type2str[] = {
108 { NFNON, "NON" },
109 { NFREG, "REG" },
110 { NFDIR, "DIR" },
111 { NFBLK, "BLK" },
112 { NFCHR, "CHR" },
113 { NFLNK, "LNK" },
114 { NFFIFO, "FIFO" },
115 { 0, NULL }
116 };
117
118 /*
119 * Print out a 64-bit integer. This appears to be different on each system,
120 * try to make the best of it. The integer stored as 2 consecutive XDR
121 * encoded 32-bit integers, to which a pointer is passed.
122 *
123 * Assume that a system that has INT64_FORMAT defined, has a 64-bit
124 * integer datatype and can print it.
125 */
126
127 #define UNSIGNED 0
128 #define SIGNED 1
129 #define HEX 2
130
131 static int print_int64(const u_int32_t *dp, int how)
132 {
133 #ifdef INT64_FORMAT
134 u_int64_t res;
135
136 res = ((u_int64_t)ntohl(dp[0]) << 32) | (u_int64_t)ntohl(dp[1]);
137 switch (how) {
138 case SIGNED:
139 printf(INT64_FORMAT, res);
140 break;
141 case UNSIGNED:
142 printf(U_INT64_FORMAT, res);
143 break;
144 case HEX:
145 printf(HEX_INT64_FORMAT, res);
146 break;
147 default:
148 return (0);
149 }
150 #else
151 switch (how) {
152 case SIGNED :
153 case UNSIGNED :
154 case HEX :
155 printf ("0x%x%08x", dp[0], dp[1]);
156 break;
157 default :
158 return (0);
159 }
160 #endif
161 return 1;
162 }
163
164 static const u_int32_t *
165 parse_sattr3(const u_int32_t *dp, struct nfsv3_sattr *sa3)
166 {
167 TCHECK(dp[0]);
168 if ((sa3->sa_modeset = ntohl(*dp++))) {
169 TCHECK(dp[0]);
170 sa3->sa_mode = ntohl(*dp++);
171 }
172
173 TCHECK(dp[0]);
174 if ((sa3->sa_uidset = ntohl(*dp++))) {
175 TCHECK(dp[0]);
176 sa3->sa_uid = ntohl(*dp++);
177 }
178
179 TCHECK(dp[0]);
180 if ((sa3->sa_gidset = ntohl(*dp++))) {
181 TCHECK(dp[0]);
182 sa3->sa_gid = ntohl(*dp++);
183 }
184
185 TCHECK(dp[0]);
186 if ((sa3->sa_sizeset = ntohl(*dp++))) {
187 TCHECK(dp[0]);
188 sa3->sa_size = ntohl(*dp++);
189 }
190
191 TCHECK(dp[0]);
192 if ((sa3->sa_atimetype = ntohl(*dp++)) == NFSV3SATTRTIME_TOCLIENT) {
193 TCHECK(dp[1]);
194 sa3->sa_atime.nfsv3_sec = ntohl(*dp++);
195 sa3->sa_atime.nfsv3_nsec = ntohl(*dp++);
196 }
197
198 TCHECK(dp[0]);
199 if ((sa3->sa_mtimetype = ntohl(*dp++)) == NFSV3SATTRTIME_TOCLIENT) {
200 TCHECK(dp[1]);
201 sa3->sa_mtime.nfsv3_sec = ntohl(*dp++);
202 sa3->sa_mtime.nfsv3_nsec = ntohl(*dp++);
203 }
204
205 return dp;
206 trunc:
207 return NULL;
208 }
209
210 static int nfserr; /* true if we error rather than trunc */
211
212 static void
213 print_sattr3(const struct nfsv3_sattr *sa3, int verbose)
214 {
215 if (sa3->sa_modeset)
216 printf(" mode %o", sa3->sa_mode);
217 if (sa3->sa_uidset)
218 printf(" uid %u", sa3->sa_uid);
219 if (sa3->sa_gidset)
220 printf(" gid %u", sa3->sa_gid);
221 if (verbose > 1) {
222 if (sa3->sa_atimetype == NFSV3SATTRTIME_TOCLIENT)
223 printf(" atime %u.%06u", sa3->sa_atime.nfsv3_sec,
224 sa3->sa_atime.nfsv3_nsec);
225 if (sa3->sa_mtimetype == NFSV3SATTRTIME_TOCLIENT)
226 printf(" mtime %u.%06u", sa3->sa_mtime.nfsv3_sec,
227 sa3->sa_mtime.nfsv3_nsec);
228 }
229 }
230
231 void
232 nfsreply_print(register const u_char *bp, u_int length,
233 register const u_char *bp2)
234 {
235 register const struct rpc_msg *rp;
236 register const struct ip *ip;
237 u_int32_t proc, vers;
238
239 nfserr = 0; /* assume no error */
240 rp = (const struct rpc_msg *)bp;
241 ip = (const struct ip *)bp2;
242
243 if (!nflag)
244 (void)printf("%s.nfs > %s.%u: reply %s %d",
245 ipaddr_string(&ip->ip_src),
246 ipaddr_string(&ip->ip_dst),
247 (u_int32_t)ntohl(rp->rm_xid),
248 ntohl(rp->rm_reply.rp_stat) == MSG_ACCEPTED?
249 "ok":"ERR",
250 length);
251 else
252 (void)printf("%s.%u > %s.%u: reply %s %d",
253 ipaddr_string(&ip->ip_src),
254 NFS_PORT,
255 ipaddr_string(&ip->ip_dst),
256 (u_int32_t)ntohl(rp->rm_xid),
257 ntohl(rp->rm_reply.rp_stat) == MSG_ACCEPTED?
258 "ok":"ERR",
259 length);
260
261 if (xid_map_find(rp, ip, &proc, &vers) >= 0)
262 interp_reply(rp, proc, vers, length);
263 }
264
265 /*
266 * Return a pointer to the first file handle in the packet.
267 * If the packet was truncated, return 0.
268 */
269 static const u_int32_t *
270 parsereq(register const struct rpc_msg *rp, register u_int length)
271 {
272 register const u_int32_t *dp;
273 register u_int len;
274
275 /*
276 * find the start of the req data (if we captured it)
277 */
278 dp = (u_int32_t *)&rp->rm_call.cb_cred;
279 TCHECK(dp[1]);
280 len = ntohl(dp[1]);
281 if (len < length) {
282 dp += (len + (2 * sizeof(*dp) + 3)) / sizeof(*dp);
283 TCHECK(dp[1]);
284 len = ntohl(dp[1]);
285 if (len < length) {
286 dp += (len + (2 * sizeof(*dp) + 3)) / sizeof(*dp);
287 TCHECK2(dp[0], 0);
288 return (dp);
289 }
290 }
291 trunc:
292 return (NULL);
293 }
294
295 /*
296 * Print out an NFS file handle and return a pointer to following word.
297 * If packet was truncated, return 0.
298 */
299 static const u_int32_t *
300 parsefh(register const u_int32_t *dp, int v3)
301 {
302 int len;
303
304 if (v3) {
305 TCHECK(dp[0]);
306 len = (int)ntohl(*dp) / 4;
307 dp++;
308 } else
309 len = NFSX_V2FH / 4;
310
311 if (TTEST2(*dp, len * sizeof(*dp))) {
312 nfs_printfh(dp, len);
313 return (dp + len);
314 }
315 trunc:
316 return (NULL);
317 }
318
319 /*
320 * Print out a file name and return pointer to 32-bit word past it.
321 * If packet was truncated, return 0.
322 */
323 static const u_int32_t *
324 parsefn(register const u_int32_t *dp)
325 {
326 register u_int32_t len;
327 register const u_char *cp;
328
329 /* Bail if we don't have the string length */
330 TCHECK(*dp);
331
332 /* Fetch string length; convert to host order */
333 len = *dp++;
334 NTOHL(len);
335
336 TCHECK2(*dp, ((len + 3) & ~3));
337
338 cp = (u_char *)dp;
339 /* Update 32-bit pointer (NFS filenames padded to 32-bit boundaries) */
340 dp += ((len + 3) & ~3) / sizeof(*dp);
341 /* XXX seems like we should be checking the length */
342 putchar('"');
343 (void) fn_printn(cp, len, NULL);
344 putchar('"');
345
346 return (dp);
347 trunc:
348 return NULL;
349 }
350
351 /*
352 * Print out file handle and file name.
353 * Return pointer to 32-bit word past file name.
354 * If packet was truncated (or there was some other error), return 0.
355 */
356 static const u_int32_t *
357 parsefhn(register const u_int32_t *dp, int v3)
358 {
359 dp = parsefh(dp, v3);
360 if (dp == NULL)
361 return (NULL);
362 putchar(' ');
363 return (parsefn(dp));
364 }
365
366 void
367 nfsreq_print(register const u_char *bp, u_int length,
368 register const u_char *bp2)
369 {
370 register const struct rpc_msg *rp;
371 register const struct ip *ip;
372 register const u_int32_t *dp;
373 nfstype type;
374 int v3;
375 u_int32_t proc;
376 struct nfsv3_sattr sa3;
377
378 nfserr = 0; /* assume no error */
379 rp = (const struct rpc_msg *)bp;
380 ip = (const struct ip *)bp2;
381 if (!nflag)
382 (void)printf("%s.%u > %s.nfs: %d",
383 ipaddr_string(&ip->ip_src),
384 (u_int32_t)ntohl(rp->rm_xid),
385 ipaddr_string(&ip->ip_dst),
386 length);
387 else
388 (void)printf("%s.%u > %s.%u: %d",
389 ipaddr_string(&ip->ip_src),
390 (u_int32_t)ntohl(rp->rm_xid),
391 ipaddr_string(&ip->ip_dst),
392 NFS_PORT,
393 length);
394
395 xid_map_enter(rp, ip); /* record proc number for later on */
396
397 v3 = (ntohl(rp->rm_call.cb_vers) == NFS_VER3);
398 proc = ntohl(rp->rm_call.cb_proc);
399
400 if (!v3 && proc < NFS_NPROCS)
401 proc = nfsv3_procid[proc];
402
403 switch (proc) {
404 case NFSPROC_NOOP:
405 printf(" nop");
406 return;
407 case NFSPROC_NULL:
408 printf(" null");
409 return;
410
411 case NFSPROC_GETATTR:
412 printf(" getattr");
413 if ((dp = parsereq(rp, length)) != NULL &&
414 parsefh(dp, v3) != NULL)
415 return;
416 break;
417
418 case NFSPROC_SETATTR:
419 printf(" setattr");
420 if ((dp = parsereq(rp, length)) != NULL &&
421 parsefh(dp, v3) != NULL)
422 return;
423 break;
424
425 case NFSPROC_LOOKUP:
426 printf(" lookup");
427 if ((dp = parsereq(rp, length)) != NULL &&
428 parsefhn(dp, v3) != NULL)
429 return;
430 break;
431
432 case NFSPROC_ACCESS:
433 printf(" access");
434 if ((dp = parsereq(rp, length)) != NULL &&
435 (dp = parsefh(dp, v3)) != NULL) {
436 TCHECK(dp[0]);
437 printf(" %04x", ntohl(dp[0]));
438 return;
439 }
440 break;
441
442 case NFSPROC_READLINK:
443 printf(" readlink");
444 if ((dp = parsereq(rp, length)) != NULL &&
445 parsefh(dp, v3) != NULL)
446 return;
447 break;
448
449 case NFSPROC_READ:
450 printf(" read");
451 if ((dp = parsereq(rp, length)) != NULL &&
452 (dp = parsefh(dp, v3)) != NULL) {
453 if (v3) {
454 TCHECK(dp[2]);
455 printf(" %u bytes @ ",
456 (u_int32_t) ntohl(dp[2]));
457 print_int64(dp, UNSIGNED);
458 } else {
459 TCHECK(dp[1]);
460 printf(" %u bytes @ %u",
461 (u_int32_t)ntohl(dp[1]),
462 (u_int32_t)ntohl(dp[0]));
463 }
464 return;
465 }
466 break;
467
468 case NFSPROC_WRITE:
469 printf(" write");
470 if ((dp = parsereq(rp, length)) != NULL &&
471 (dp = parsefh(dp, v3)) != NULL) {
472 if (v3) {
473 TCHECK(dp[4]);
474 printf(" %u bytes @ ",
475 (u_int32_t) ntohl(dp[4]));
476 print_int64(dp, UNSIGNED);
477 if (vflag) {
478 dp += 3;
479 TCHECK(dp[0]);
480 printf(" <%s>",
481 tok2str(nfsv3_writemodes,
482 NULL, ntohl(*dp)));
483 }
484 } else {
485 TCHECK(dp[3]);
486 printf(" %u (%u) bytes @ %u (%u)",
487 (u_int32_t)ntohl(dp[3]),
488 (u_int32_t)ntohl(dp[2]),
489 (u_int32_t)ntohl(dp[1]),
490 (u_int32_t)ntohl(dp[0]));
491 }
492 return;
493 }
494 break;
495
496 case NFSPROC_CREATE:
497 printf(" create");
498 if ((dp = parsereq(rp, length)) != NULL &&
499 parsefhn(dp, v3) != NULL)
500 return;
501 break;
502
503 case NFSPROC_MKDIR:
504 printf(" mkdir");
505 if ((dp = parsereq(rp, length)) != 0 && parsefhn(dp, v3) != 0)
506 return;
507 break;
508
509 case NFSPROC_SYMLINK:
510 printf(" symlink");
511 if ((dp = parsereq(rp, length)) != 0 &&
512 (dp = parsefhn(dp, v3)) != 0) {
513 fputs(" ->", stdout);
514 if (v3 && (dp = parse_sattr3(dp, &sa3)) == 0)
515 break;
516 if (parsefn(dp) == 0)
517 break;
518 if (v3 && vflag)
519 print_sattr3(&sa3, vflag);
520 return;
521 }
522 break;
523
524 case NFSPROC_MKNOD:
525 printf(" mknod");
526 if ((dp = parsereq(rp, length)) != 0 &&
527 (dp = parsefhn(dp, v3)) != 0) {
528 TCHECK(*dp);
529 type = (nfstype)ntohl(*dp++);
530 if ((dp = parse_sattr3(dp, &sa3)) == 0)
531 break;
532 printf(" %s", tok2str(type2str, "unk-ft %d", type));
533 if (vflag && (type == NFCHR || type == NFBLK)) {
534 TCHECK(dp[1]);
535 printf(" %u/%u", ntohl(dp[0]), ntohl(dp[1]));
536 dp += 2;
537 }
538 if (vflag)
539 print_sattr3(&sa3, vflag);
540 return;
541 }
542 break;
543
544 case NFSPROC_REMOVE:
545 printf(" remove");
546 if ((dp = parsereq(rp, length)) != NULL &&
547 parsefhn(dp, v3) != NULL)
548 return;
549 break;
550
551 case NFSPROC_RMDIR:
552 printf(" rmdir");
553 if ((dp = parsereq(rp, length)) != NULL &&
554 parsefhn(dp, v3) != NULL)
555 return;
556 break;
557
558 case NFSPROC_RENAME:
559 printf(" rename");
560 if ((dp = parsereq(rp, length)) != NULL &&
561 (dp = parsefhn(dp, v3)) != NULL) {
562 fputs(" ->", stdout);
563 if (parsefhn(dp, v3) != NULL)
564 return;
565 }
566 break;
567
568 case NFSPROC_LINK:
569 printf(" link");
570 if ((dp = parsereq(rp, length)) != NULL &&
571 (dp = parsefh(dp, v3)) != NULL) {
572 fputs(" ->", stdout);
573 if (parsefhn(dp, v3) != NULL)
574 return;
575 }
576 break;
577
578 case NFSPROC_READDIR:
579 printf(" readdir");
580 if ((dp = parsereq(rp, length)) != NULL &&
581 (dp = parsefh(dp, v3)) != NULL) {
582 if (v3) {
583 TCHECK(dp[4]);
584 /*
585 * We shouldn't really try to interpret the
586 * offset cookie here.
587 */
588 printf(" %u bytes @ ",
589 (u_int32_t) ntohl(dp[4]));
590 print_int64(dp, SIGNED);
591 if (vflag)
592 printf(" verf %08x%08x", dp[2],
593 dp[3]);
594 } else {
595 TCHECK(dp[1]);
596 /*
597 * Print the offset as signed, since -1 is
598 * common, but offsets > 2^31 aren't.
599 */
600 printf(" %u bytes @ %d",
601 (u_int32_t)ntohl(dp[1]),
602 (u_int32_t)ntohl(dp[0]));
603 }
604 return;
605 }
606 break;
607
608 case NFSPROC_READDIRPLUS:
609 printf(" readdirplus");
610 if ((dp = parsereq(rp, length)) != NULL &&
611 (dp = parsefh(dp, v3)) != NULL) {
612 TCHECK(dp[4]);
613 /*
614 * We don't try to interpret the offset
615 * cookie here.
616 */
617 printf(" %u bytes @ ", (u_int32_t) ntohl(dp[4]));
618 print_int64(dp, SIGNED);
619 if (vflag)
620 printf(" max %u verf %08x%08x",
621 (u_int32_t) ntohl(dp[5]), dp[2], dp[3]);
622 return;
623 }
624 break;
625
626 case NFSPROC_FSSTAT:
627 printf(" fsstat");
628 if ((dp = parsereq(rp, length)) != NULL &&
629 parsefh(dp, v3) != NULL)
630 return;
631 break;
632
633 case NFSPROC_FSINFO:
634 printf(" fsinfo");
635 break;
636
637 case NFSPROC_PATHCONF:
638 printf(" pathconf");
639 break;
640
641 case NFSPROC_COMMIT:
642 printf(" commit");
643 if ((dp = parsereq(rp, length)) != NULL &&
644 (dp = parsefh(dp, v3)) != NULL) {
645 printf(" %u bytes @ ", (u_int32_t) ntohl(dp[2]));
646 print_int64(dp, UNSIGNED);
647 return;
648 }
649 break;
650
651 default:
652 printf(" proc-%u", (u_int32_t)ntohl(rp->rm_call.cb_proc));
653 return;
654 }
655
656 trunc:
657 if (!nfserr)
658 fputs(" [|nfs]", stdout);
659 }
660
661 /*
662 * Print out an NFS file handle.
663 * We assume packet was not truncated before the end of the
664 * file handle pointed to by dp.
665 *
666 * Note: new version (using portable file-handle parser) doesn't produce
667 * generation number. It probably could be made to do that, with some
668 * additional hacking on the parser code.
669 */
670 static void
671 nfs_printfh(register const u_int32_t *dp, const u_int len)
672 {
673 my_fsid fsid;
674 ino_t ino;
675 char *sfsname = NULL;
676
677 Parse_fh((caddr_t*)dp, len, &fsid, &ino, NULL, &sfsname, 0);
678
679 if (sfsname) {
680 /* file system ID is ASCII, not numeric, for this server OS */
681 static char temp[NFSX_V3FHMAX+1];
682
683 /* Make sure string is null-terminated */
684 strncpy(temp, sfsname, NFSX_V3FHMAX);
685 /* Remove trailing spaces */
686 sfsname = strchr(temp, ' ');
687 if (sfsname)
688 *sfsname = 0;
689
690 (void)printf(" fh %s/%ld", temp, (long) ino);
691 }
692 else {
693 (void)printf(" fh %d,%d/%ld",
694 fsid.Fsid_dev.Major, fsid.Fsid_dev.Minor,
695 (long) ino);
696 }
697 }
698
699 /*
700 * Maintain a small cache of recent client.XID.server/proc pairs, to allow
701 * us to match up replies with requests and thus to know how to parse
702 * the reply.
703 */
704
705 struct xid_map_entry {
706 u_int32_t xid; /* transaction ID (net order) */
707 struct in_addr client; /* client IP address (net order) */
708 struct in_addr server; /* server IP address (net order) */
709 u_int32_t proc; /* call proc number (host order) */
710 u_int32_t vers; /* program version (host order) */
711 };
712
713 /*
714 * Map entries are kept in an array that we manage as a ring;
715 * new entries are always added at the tail of the ring. Initially,
716 * all the entries are zero and hence don't match anything.
717 */
718
719 #define XIDMAPSIZE 64
720
721 struct xid_map_entry xid_map[XIDMAPSIZE];
722
723 int xid_map_next = 0;
724 int xid_map_hint = 0;
725
726 static void
727 xid_map_enter(const struct rpc_msg *rp, const struct ip *ip)
728 {
729 struct xid_map_entry *xmep;
730
731 xmep = &xid_map[xid_map_next];
732
733 if (++xid_map_next >= XIDMAPSIZE)
734 xid_map_next = 0;
735
736 xmep->xid = rp->rm_xid;
737 xmep->client = ip->ip_src;
738 xmep->server = ip->ip_dst;
739 xmep->proc = ntohl(rp->rm_call.cb_proc);
740 xmep->vers = ntohl(rp->rm_call.cb_vers);
741 }
742
743 /*
744 * Returns 0 and puts NFSPROC_xxx in proc return and
745 * version in vers return, or returns -1 on failure
746 */
747 static int
748 xid_map_find(const struct rpc_msg *rp, const struct ip *ip, u_int32_t *proc,
749 u_int32_t *vers)
750 {
751 int i;
752 struct xid_map_entry *xmep;
753 u_int32_t xid = rp->rm_xid;
754 u_int32_t clip = ip->ip_dst.s_addr;
755 u_int32_t sip = ip->ip_src.s_addr;
756
757 /* Start searching from where we last left off */
758 i = xid_map_hint;
759 do {
760 xmep = &xid_map[i];
761 if (xmep->xid == xid && xmep->client.s_addr == clip &&
762 xmep->server.s_addr == sip) {
763 /* match */
764 xid_map_hint = i;
765 *proc = xmep->proc;
766 *vers = xmep->vers;
767 return 0;
768 }
769 if (++i >= XIDMAPSIZE)
770 i = 0;
771 } while (i != xid_map_hint);
772
773 /* search failed */
774 return (-1);
775 }
776
777 /*
778 * Routines for parsing reply packets
779 */
780
781 /*
782 * Return a pointer to the beginning of the actual results.
783 * If the packet was truncated, return 0.
784 */
785 static const u_int32_t *
786 parserep(register const struct rpc_msg *rp, register u_int length)
787 {
788 register const u_int32_t *dp;
789 u_int len;
790 enum accept_stat astat;
791
792 /*
793 * Portability note:
794 * Here we find the address of the ar_verf credentials.
795 * Originally, this calculation was
796 * dp = (u_int32_t *)&rp->rm_reply.rp_acpt.ar_verf
797 * On the wire, the rp_acpt field starts immediately after
798 * the (32 bit) rp_stat field. However, rp_acpt (which is a
799 * "struct accepted_reply") contains a "struct opaque_auth",
800 * whose internal representation contains a pointer, so on a
801 * 64-bit machine the compiler inserts 32 bits of padding
802 * before rp->rm_reply.rp_acpt.ar_verf. So, we cannot use
803 * the internal representation to parse the on-the-wire
804 * representation. Instead, we skip past the rp_stat field,
805 * which is an "enum" and so occupies one 32-bit word.
806 */
807 dp = ((const u_int32_t *)&rp->rm_reply) + 1;
808 TCHECK(dp[1]);
809 len = ntohl(dp[1]);
810 if (len >= length)
811 return (NULL);
812 /*
813 * skip past the ar_verf credentials.
814 */
815 dp += (len + (2*sizeof(u_int32_t) + 3)) / sizeof(u_int32_t);
816 TCHECK2(dp[0], 0);
817
818 /*
819 * now we can check the ar_stat field
820 */
821 astat = ntohl(*(enum accept_stat *)dp);
822 switch (astat) {
823
824 case SUCCESS:
825 break;
826
827 case PROG_UNAVAIL:
828 printf(" PROG_UNAVAIL");
829 nfserr = 1; /* suppress trunc string */
830 return (NULL);
831
832 case PROG_MISMATCH:
833 printf(" PROG_MISMATCH");
834 nfserr = 1; /* suppress trunc string */
835 return (NULL);
836
837 case PROC_UNAVAIL:
838 printf(" PROC_UNAVAIL");
839 nfserr = 1; /* suppress trunc string */
840 return (NULL);
841
842 case GARBAGE_ARGS:
843 printf(" GARBAGE_ARGS");
844 nfserr = 1; /* suppress trunc string */
845 return (NULL);
846
847 case SYSTEM_ERR:
848 printf(" SYSTEM_ERR");
849 nfserr = 1; /* suppress trunc string */
850 return (NULL);
851
852 default:
853 printf(" ar_stat %d", astat);
854 nfserr = 1; /* suppress trunc string */
855 return (NULL);
856 }
857 /* successful return */
858 TCHECK2(*dp, sizeof(astat));
859 return ((u_int32_t *) (sizeof(astat) + ((char *)dp)));
860 trunc:
861 return (0);
862 }
863
864 static const u_int32_t *
865 parsestatus(const u_int32_t *dp, int *er)
866 {
867 int errnum;
868
869 TCHECK(dp[0]);
870
871 errnum = ntohl(dp[0]);
872 if (er)
873 *er = errnum;
874 if (errnum != 0) {
875 if (!qflag)
876 printf(" ERROR: %s", pcap_strerror(errnum));
877 nfserr = 1;
878 return (NULL);
879 }
880 return (dp + 1);
881 trunc:
882 return NULL;
883 }
884
885 static const u_int32_t *
886 parsefattr(const u_int32_t *dp, int verbose, int v3)
887 {
888 const struct nfs_fattr *fap;
889
890 fap = (const struct nfs_fattr *)dp;
891 TCHECK(fap->fa_gid);
892 if (verbose) {
893 printf(" %s %o ids %d/%d",
894 tok2str(type2str, "unk-ft %d ",
895 (u_int32_t)ntohl(fap->fa_type)),
896 (u_int32_t)ntohl(fap->fa_mode),
897 (u_int32_t)ntohl(fap->fa_uid),
898 (u_int32_t) ntohl(fap->fa_gid));
899 if (v3) {
900 TCHECK(fap->fa3_size);
901 printf(" sz ");
902 print_int64((u_int32_t *)&fap->fa3_size, UNSIGNED);
903 putchar(' ');
904 } else {
905 TCHECK(fap->fa2_size);
906 printf(" sz %d ", (u_int32_t) ntohl(fap->fa2_size));
907 }
908 }
909 /* print lots more stuff */
910 if (verbose > 1) {
911 if (v3) {
912 TCHECK(fap->fa3_ctime);
913 printf("nlink %d rdev %d/%d ",
914 (u_int32_t)ntohl(fap->fa_nlink),
915 (u_int32_t) ntohl(fap->fa3_rdev.specdata1),
916 (u_int32_t) ntohl(fap->fa3_rdev.specdata2));
917 printf("fsid ");
918 print_int64((u_int32_t *)&fap->fa2_fsid, HEX);
919 printf(" nodeid ");
920 print_int64((u_int32_t *)&fap->fa2_fileid, HEX);
921 printf(" a/m/ctime %u.%06u ",
922 (u_int32_t) ntohl(fap->fa3_atime.nfsv3_sec),
923 (u_int32_t) ntohl(fap->fa3_atime.nfsv3_nsec));
924 printf("%u.%06u ",
925 (u_int32_t) ntohl(fap->fa3_mtime.nfsv3_sec),
926 (u_int32_t) ntohl(fap->fa3_mtime.nfsv3_nsec));
927 printf("%u.%06u ",
928 (u_int32_t) ntohl(fap->fa3_ctime.nfsv3_sec),
929 (u_int32_t) ntohl(fap->fa3_ctime.nfsv3_nsec));
930 } else {
931 TCHECK(fap->fa2_ctime);
932 printf("nlink %d rdev %x fsid %x nodeid %x a/m/ctime ",
933 (u_int32_t) ntohl(fap->fa_nlink),
934 (u_int32_t) ntohl(fap->fa2_rdev),
935 (u_int32_t) ntohl(fap->fa2_fsid),
936 (u_int32_t) ntohl(fap->fa2_fileid));
937 printf("%u.%06u ",
938 (u_int32_t) ntohl(fap->fa2_atime.nfsv2_sec),
939 (u_int32_t) ntohl(fap->fa2_atime.nfsv2_usec));
940 printf("%u.%06u ",
941 (u_int32_t) ntohl(fap->fa2_mtime.nfsv2_sec),
942 (u_int32_t) ntohl(fap->fa2_mtime.nfsv2_usec));
943 printf("%u.%06u ",
944 (u_int32_t) ntohl(fap->fa2_ctime.nfsv2_sec),
945 (u_int32_t) ntohl(fap->fa2_ctime.nfsv2_usec));
946 }
947 }
948 return ((const u_int32_t *)((unsigned char *)dp +
949 (v3 ? NFSX_V3FATTR : NFSX_V2FATTR)));
950 trunc:
951 return (NULL);
952 }
953
954 static int
955 parseattrstat(const u_int32_t *dp, int verbose, int v3)
956 {
957 int er;
958
959 dp = parsestatus(dp, &er);
960 if (dp == NULL || er)
961 return (0);
962
963 return (parsefattr(dp, verbose, v3) != NULL);
964 }
965
966 static int
967 parsediropres(const u_int32_t *dp)
968 {
969 int er;
970
971 if (!(dp = parsestatus(dp, &er)) || er)
972 return (0);
973
974 dp = parsefh(dp, 0);
975 if (dp == NULL)
976 return (0);
977
978 return (parsefattr(dp, vflag, 0) != NULL);
979 }
980
981 static int
982 parselinkres(const u_int32_t *dp, int v3)
983 {
984 int er;
985
986 dp = parsestatus(dp, &er);
987 if (dp == NULL || er)
988 return(0);
989 if (v3 && !(dp = parse_post_op_attr(dp, vflag)))
990 return (0);
991 putchar(' ');
992 return (parsefn(dp) != NULL);
993 }
994
995 static int
996 parsestatfs(const u_int32_t *dp, int v3)
997 {
998 const struct nfs_statfs *sfsp;
999 int er;
1000
1001 dp = parsestatus(dp, &er);
1002 if (dp == NULL || (!v3 && er))
1003 return (0);
1004
1005 if (qflag)
1006 return(1);
1007
1008 if (v3) {
1009 if (vflag)
1010 printf(" POST:");
1011 if (!(dp = parse_post_op_attr(dp, vflag)))
1012 return (0);
1013 }
1014
1015 TCHECK2(dp, (v3 ? NFSX_V3STATFS : NFSX_V2STATFS));
1016
1017 sfsp = (const struct nfs_statfs *)dp;
1018
1019 if (v3) {
1020 printf(" tbytes ");
1021 print_int64((u_int32_t *)&sfsp->sf_tbytes, UNSIGNED);
1022 printf(" fbytes ");
1023 print_int64((u_int32_t *)&sfsp->sf_fbytes, UNSIGNED);
1024 printf(" abytes ");
1025 print_int64((u_int32_t *)&sfsp->sf_abytes, UNSIGNED);
1026 if (vflag) {
1027 printf(" tfiles ");
1028 print_int64((u_int32_t *)&sfsp->sf_tfiles, UNSIGNED);
1029 printf(" ffiles ");
1030 print_int64((u_int32_t *)&sfsp->sf_ffiles, UNSIGNED);
1031 printf(" afiles ");
1032 print_int64((u_int32_t *)&sfsp->sf_afiles, UNSIGNED);
1033 printf(" invar %u",
1034 (u_int32_t) ntohl(sfsp->sf_invarsec));
1035 }
1036 } else {
1037 printf(" tsize %d bsize %d blocks %d bfree %d bavail %d",
1038 (u_int32_t)ntohl(sfsp->sf_tsize),
1039 (u_int32_t)ntohl(sfsp->sf_bsize),
1040 (u_int32_t)ntohl(sfsp->sf_blocks),
1041 (u_int32_t)ntohl(sfsp->sf_bfree),
1042 (u_int32_t)ntohl(sfsp->sf_bavail));
1043 }
1044
1045 return (1);
1046 trunc:
1047 return (0);
1048 }
1049
1050 static int
1051 parserddires(const u_int32_t *dp)
1052 {
1053 int er;
1054
1055 dp = parsestatus(dp, &er);
1056 if (dp == 0 || er)
1057 return (0);
1058 if (qflag)
1059 return (1);
1060
1061 TCHECK(dp[2]);
1062 printf(" offset %x size %d ", ntohl(dp[0]), ntohl(dp[1]));
1063 if (dp[2] != 0)
1064 printf(" eof");
1065
1066 return (1);
1067 trunc:
1068 return (0);
1069 }
1070
1071 static const u_int32_t *
1072 parse_wcc_attr(const u_int32_t *dp)
1073 {
1074 printf(" sz ");
1075 print_int64(dp, UNSIGNED);
1076 printf(" mtime %u.%06u ctime %u.%06u", ntohl(dp[2]), ntohl(dp[3]),
1077 ntohl(dp[4]), ntohl(dp[5]));
1078 return (dp + 6);
1079 }
1080
1081 /*
1082 * Pre operation attributes. Print only if vflag > 1.
1083 */
1084 static const u_int32_t *
1085 parse_pre_op_attr(const u_int32_t *dp, int verbose)
1086 {
1087 TCHECK(dp[0]);
1088 if (!ntohl(dp[0]))
1089 return (dp + 1);
1090 dp++;
1091 TCHECK2(dp, 24);
1092 if (verbose > 1) {
1093 return parse_wcc_attr(dp);
1094 } else {
1095 /* If not verbose enough, just skip over wcc_attr */
1096 return (dp + 6);
1097 }
1098 trunc:
1099 return (NULL);
1100 }
1101
1102 /*
1103 * Post operation attributes are printed if vflag >= 1
1104 */
1105 static const u_int32_t *
1106 parse_post_op_attr(const u_int32_t *dp, int verbose)
1107 {
1108 TCHECK(dp[0]);
1109 if (!ntohl(dp[0]))
1110 return (dp + 1);
1111 dp++;
1112 if (verbose) {
1113 return parsefattr(dp, verbose, 1);
1114 } else
1115 return (dp + (NFSX_V3FATTR / sizeof (u_int32_t)));
1116 trunc:
1117 return (NULL);
1118 }
1119
1120 static const u_int32_t *
1121 parse_wcc_data(const u_int32_t *dp, int verbose)
1122 {
1123 if (verbose > 1)
1124 printf(" PRE:");
1125 if (!(dp = parse_pre_op_attr(dp, verbose)))
1126 return (0);
1127
1128 if (verbose)
1129 printf(" POST:");
1130 return parse_post_op_attr(dp, verbose);
1131 }
1132
1133 static const u_int32_t *
1134 parsecreateopres(const u_int32_t *dp, int verbose)
1135 {
1136 int er;
1137
1138 if (!(dp = parsestatus(dp, &er)))
1139 return (0);
1140 if (er)
1141 dp = parse_wcc_data(dp, verbose);
1142 else {
1143 TCHECK(dp[0]);
1144 if (!ntohl(dp[0]))
1145 return (dp + 1);
1146 dp++;
1147 if (!(dp = parsefh(dp, 1)))
1148 return (0);
1149 if (verbose) {
1150 if (!(dp = parse_post_op_attr(dp, verbose)))
1151 return (0);
1152 if (vflag > 1) {
1153 printf("dir attr:");
1154 dp = parse_wcc_data(dp, verbose);
1155 }
1156 }
1157 }
1158 return (dp);
1159 trunc:
1160 return (NULL);
1161 }
1162
1163 static int
1164 parsewccres(const u_int32_t *dp, int verbose)
1165 {
1166 int er;
1167
1168 if (!(dp = parsestatus(dp, &er)))
1169 return (0);
1170 return parse_wcc_data(dp, verbose) != 0;
1171 }
1172
1173 static const u_int32_t *
1174 parsev3rddirres(const u_int32_t *dp, int verbose)
1175 {
1176 int er;
1177
1178 if (!(dp = parsestatus(dp, &er)))
1179 return (0);
1180 if (vflag)
1181 printf(" POST:");
1182 if (!(dp = parse_post_op_attr(dp, verbose)))
1183 return (0);
1184 if (er)
1185 return dp;
1186 if (vflag) {
1187 TCHECK(dp[1]);
1188 printf(" verf %08x%08x", dp[0], dp[1]);
1189 dp += 2;
1190 }
1191 return dp;
1192 trunc:
1193 return (NULL);
1194 }
1195
1196 static int
1197 parsefsinfo(const u_int32_t *dp)
1198 {
1199 struct nfsv3_fsinfo *sfp;
1200 int er;
1201
1202 if (!(dp = parsestatus(dp, &er)))
1203 return (0);
1204 if (vflag)
1205 printf(" POST:");
1206 if (!(dp = parse_post_op_attr(dp, vflag)))
1207 return (0);
1208 if (er)
1209 return (1);
1210
1211 sfp = (struct nfsv3_fsinfo *)dp;
1212 TCHECK(*sfp);
1213 printf(" rtmax %u rtpref %u wtmax %u wtpref %u dtpref %u",
1214 (u_int32_t) ntohl(sfp->fs_rtmax),
1215 (u_int32_t) ntohl(sfp->fs_rtpref),
1216 (u_int32_t) ntohl(sfp->fs_wtmax),
1217 (u_int32_t) ntohl(sfp->fs_wtpref),
1218 (u_int32_t) ntohl(sfp->fs_dtpref));
1219 if (vflag) {
1220 printf(" rtmult %u wtmult %u maxfsz ",
1221 (u_int32_t) ntohl(sfp->fs_rtmult),
1222 (u_int32_t) ntohl(sfp->fs_wtmult));
1223 print_int64((u_int32_t *)&sfp->fs_maxfilesize, UNSIGNED);
1224 printf(" delta %u.%06u ",
1225 (u_int32_t) ntohl(sfp->fs_timedelta.nfsv3_sec),
1226 (u_int32_t) ntohl(sfp->fs_timedelta.nfsv3_nsec));
1227 }
1228 return (0);
1229 trunc:
1230 return (1);
1231 }
1232
1233 static int
1234 parsepathconf(const u_int32_t *dp)
1235 {
1236 int er;
1237 struct nfsv3_pathconf *spp;
1238
1239 if (!(dp = parsestatus(dp, &er)))
1240 return (0);
1241 if (vflag)
1242 printf(" POST:");
1243 if (!(dp = parse_post_op_attr(dp, vflag)))
1244 return (0);
1245 if (er)
1246 return (1);
1247
1248 spp = (struct nfsv3_pathconf *)dp;
1249 TCHECK(*spp);
1250
1251 printf(" linkmax %u namemax %u %s %s %s %s",
1252 (u_int32_t) ntohl(spp->pc_linkmax),
1253 (u_int32_t) ntohl(spp->pc_namemax),
1254 ntohl(spp->pc_notrunc) ? "notrunc" : "",
1255 ntohl(spp->pc_chownrestricted) ? "chownres" : "",
1256 ntohl(spp->pc_caseinsensitive) ? "igncase" : "",
1257 ntohl(spp->pc_casepreserving) ? "keepcase" : "");
1258 return (0);
1259 trunc:
1260 return (1);
1261 }
1262
1263 static void
1264 interp_reply(const struct rpc_msg *rp, u_int32_t proc, u_int32_t vers, int length)
1265 {
1266 register const u_int32_t *dp;
1267 register int v3;
1268 int er;
1269
1270 v3 = (vers == NFS_VER3);
1271
1272 if (!v3 && proc < NFS_NPROCS)
1273 proc = nfsv3_procid[proc];
1274
1275 switch (proc) {
1276
1277 case NFSPROC_NOOP:
1278 printf(" nop");
1279 return;
1280
1281 case NFSPROC_NULL:
1282 printf(" null");
1283 return;
1284
1285 case NFSPROC_GETATTR:
1286 printf(" getattr");
1287 dp = parserep(rp, length);
1288 if (dp != NULL && parseattrstat(dp, !qflag, v3) != 0)
1289 return;
1290 break;
1291
1292 case NFSPROC_SETATTR:
1293 printf(" setattr");
1294 if (!(dp = parserep(rp, length)))
1295 return;
1296 if (v3) {
1297 if (parsewccres(dp, vflag))
1298 return;
1299 } else {
1300 if (parseattrstat(dp, !qflag, 0) != 0)
1301 return;
1302 }
1303 break;
1304
1305 case NFSPROC_LOOKUP:
1306 printf(" lookup");
1307 if (!(dp = parserep(rp, length)))
1308 break;
1309 if (v3) {
1310 if (!(dp = parsestatus(dp, &er)))
1311 break;
1312 if (er) {
1313 if (vflag > 1) {
1314 printf(" post dattr:");
1315 dp = parse_post_op_attr(dp, vflag);
1316 }
1317 } else {
1318 if (!(dp = parsefh(dp, v3)))
1319 break;
1320 if ((dp = parse_post_op_attr(dp, vflag)) &&
1321 vflag > 1) {
1322 printf(" post dattr:");
1323 dp = parse_post_op_attr(dp, vflag);
1324 }
1325 }
1326 if (dp)
1327 return;
1328 } else {
1329 if (parsediropres(dp) != 0)
1330 return;
1331 }
1332 break;
1333
1334 case NFSPROC_ACCESS:
1335 printf(" access");
1336 dp = parserep(rp, length);
1337 if (!(dp = parsestatus(dp, &er)))
1338 break;
1339 if (vflag)
1340 printf(" attr:");
1341 if (!(dp = parse_post_op_attr(dp, vflag)))
1342 break;
1343 if (!er)
1344 printf(" c %04x", ntohl(dp[0]));
1345 return;
1346
1347 case NFSPROC_READLINK:
1348 printf(" readlink");
1349 dp = parserep(rp, length);
1350 if (dp != NULL && parselinkres(dp, v3) != 0)
1351 return;
1352 break;
1353
1354 case NFSPROC_READ:
1355 printf(" read");
1356 if (!(dp = parserep(rp, length)))
1357 break;
1358 if (v3) {
1359 if (!(dp = parsestatus(dp, &er)))
1360 break;
1361 if (!(dp = parse_post_op_attr(dp, vflag)))
1362 break;
1363 if (er)
1364 return;
1365 if (vflag) {
1366 TCHECK(dp[1]);
1367 printf("%u bytes", (u_int32_t) ntohl(dp[0]));
1368 if (ntohl(dp[1]))
1369 printf(" EOF");
1370 }
1371 return;
1372 } else {
1373 if (parseattrstat(dp, vflag, 0) != 0)
1374 return;
1375 }
1376 break;
1377
1378 case NFSPROC_WRITE:
1379 printf(" write");
1380 if (!(dp = parserep(rp, length)))
1381 break;
1382 if (v3) {
1383 if (!(dp = parsestatus(dp, &er)))
1384 break;
1385 if (!(dp = parse_wcc_data(dp, vflag)))
1386 break;
1387 if (er)
1388 return;
1389 if (vflag) {
1390 TCHECK(dp[0]);
1391 printf("%u bytes", (u_int32_t) ntohl(dp[0]));
1392 if (vflag > 1) {
1393 TCHECK(dp[1]);
1394 printf(" <%s>",
1395 tok2str(nfsv3_writemodes,
1396 NULL, ntohl(dp[1])));
1397 }
1398 return;
1399 }
1400 } else {
1401 if (parseattrstat(dp, vflag, v3) != 0)
1402 return;
1403 }
1404 break;
1405
1406 case NFSPROC_CREATE:
1407 printf(" create");
1408 if (!(dp = parserep(rp, length)))
1409 break;
1410 if (v3) {
1411 if (parsecreateopres(dp, vflag) != 0)
1412 return;
1413 } else {
1414 if (parsediropres(dp) != 0)
1415 return;
1416 }
1417 break;
1418
1419 case NFSPROC_MKDIR:
1420 printf(" mkdir");
1421 if (!(dp = parserep(rp, length)))
1422 break;
1423 if (v3) {
1424 if (parsecreateopres(dp, vflag) != 0)
1425 return;
1426 } else {
1427 if (parsediropres(dp) != 0)
1428 return;
1429 }
1430 break;
1431
1432 case NFSPROC_SYMLINK:
1433 printf(" symlink");
1434 if (!(dp = parserep(rp, length)))
1435 break;
1436 if (v3) {
1437 if (parsecreateopres(dp, vflag) != 0)
1438 return;
1439 } else {
1440 if (parsestatus(dp, &er) != 0)
1441 return;
1442 }
1443 break;
1444
1445 case NFSPROC_MKNOD:
1446 printf(" mknod");
1447 if (!(dp = parserep(rp, length)))
1448 break;
1449 if (parsecreateopres(dp, vflag) != 0)
1450 return;
1451 break;
1452
1453 case NFSPROC_REMOVE:
1454 printf(" remove");
1455 if (!(dp = parserep(rp, length)))
1456 break;
1457 if (v3) {
1458 if (parsewccres(dp, vflag))
1459 return;
1460 } else {
1461 if (parsestatus(dp, &er) != 0)
1462 return;
1463 }
1464 break;
1465
1466 case NFSPROC_RMDIR:
1467 printf(" rmdir");
1468 if (!(dp = parserep(rp, length)))
1469 break;
1470 if (v3) {
1471 if (parsewccres(dp, vflag))
1472 return;
1473 } else {
1474 if (parsestatus(dp, &er) != 0)
1475 return;
1476 }
1477 break;
1478
1479 case NFSPROC_RENAME:
1480 printf(" rename");
1481 if (!(dp = parserep(rp, length)))
1482 break;
1483 if (v3) {
1484 if (!(dp = parsestatus(dp, &er)))
1485 break;
1486 if (vflag) {
1487 printf(" from:");
1488 if (!(dp = parse_wcc_data(dp, vflag)))
1489 break;
1490 printf(" to:");
1491 if (!(dp = parse_wcc_data(dp, vflag)))
1492 break;
1493 }
1494 return;
1495 } else {
1496 if (parsestatus(dp, &er) != 0)
1497 return;
1498 }
1499 break;
1500
1501 case NFSPROC_LINK:
1502 printf(" link");
1503 if (!(dp = parserep(rp, length)))
1504 break;
1505 if (v3) {
1506 if (!(dp = parsestatus(dp, &er)))
1507 break;
1508 if (vflag) {
1509 printf(" file POST:");
1510 if (!(dp = parse_post_op_attr(dp, vflag)))
1511 break;
1512 printf(" dir:");
1513 if (!(dp = parse_wcc_data(dp, vflag)))
1514 break;
1515 return;
1516 }
1517 } else {
1518 if (parsestatus(dp, &er) != 0)
1519 return;
1520 }
1521 break;
1522
1523 case NFSPROC_READDIR:
1524 printf(" readdir");
1525 if (!(dp = parserep(rp, length)))
1526 break;
1527 if (v3) {
1528 if (parsev3rddirres(dp, vflag))
1529 return;
1530 } else {
1531 if (parserddires(dp) != 0)
1532 return;
1533 }
1534 break;
1535
1536 case NFSPROC_READDIRPLUS:
1537 printf(" readdirplus");
1538 if (!(dp = parserep(rp, length)))
1539 break;
1540 if (parsev3rddirres(dp, vflag))
1541 return;
1542 break;
1543
1544 case NFSPROC_FSSTAT:
1545 printf(" fsstat");
1546 dp = parserep(rp, length);
1547 if (dp != NULL && parsestatfs(dp, v3) != 0)
1548 return;
1549 break;
1550
1551 case NFSPROC_FSINFO:
1552 printf(" fsinfo");
1553 dp = parserep(rp, length);
1554 if (dp != NULL && parsefsinfo(dp) != 0)
1555 return;
1556 break;
1557
1558 case NFSPROC_PATHCONF:
1559 printf(" pathconf");
1560 dp = parserep(rp, length);
1561 if (dp != NULL && parsepathconf(dp) != 0)
1562 return;
1563 break;
1564
1565 case NFSPROC_COMMIT:
1566 printf(" commit");
1567 dp = parserep(rp, length);
1568 if (dp != NULL && parsewccres(dp, vflag) != 0)
1569 return;
1570 break;
1571
1572 default:
1573 printf(" proc-%u", proc);
1574 return;
1575 }
1576 trunc:
1577 if (!nfserr)
1578 fputs(" [|nfs]", stdout);
1579 }
[mirror] the TCPdump network dissector