]> The Tcpdump Group git mirrors - tcpdump/blob - print-nfs.c
projects / tcpdump / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
(unsigned) casts in printf to make gcc happy
[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.71 2000-05-15 00:40:26 assar 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", (unsigned)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",
536 (unsigned)ntohl(dp[0]),
537 (unsigned)ntohl(dp[1]));
538 dp += 2;
539 }
540 if (vflag)
541 print_sattr3(&sa3, vflag);
542 return;
543 }
544 break;
545
546 case NFSPROC_REMOVE:
547 printf(" remove");
548 if ((dp = parsereq(rp, length)) != NULL &&
549 parsefhn(dp, v3) != NULL)
550 return;
551 break;
552
553 case NFSPROC_RMDIR:
554 printf(" rmdir");
555 if ((dp = parsereq(rp, length)) != NULL &&
556 parsefhn(dp, v3) != NULL)
557 return;
558 break;
559
560 case NFSPROC_RENAME:
561 printf(" rename");
562 if ((dp = parsereq(rp, length)) != NULL &&
563 (dp = parsefhn(dp, v3)) != NULL) {
564 fputs(" ->", stdout);
565 if (parsefhn(dp, v3) != NULL)
566 return;
567 }
568 break;
569
570 case NFSPROC_LINK:
571 printf(" link");
572 if ((dp = parsereq(rp, length)) != NULL &&
573 (dp = parsefh(dp, v3)) != NULL) {
574 fputs(" ->", stdout);
575 if (parsefhn(dp, v3) != NULL)
576 return;
577 }
578 break;
579
580 case NFSPROC_READDIR:
581 printf(" readdir");
582 if ((dp = parsereq(rp, length)) != NULL &&
583 (dp = parsefh(dp, v3)) != NULL) {
584 if (v3) {
585 TCHECK(dp[4]);
586 /*
587 * We shouldn't really try to interpret the
588 * offset cookie here.
589 */
590 printf(" %u bytes @ ",
591 (u_int32_t) ntohl(dp[4]));
592 print_int64(dp, SIGNED);
593 if (vflag)
594 printf(" verf %08x%08x", dp[2],
595 dp[3]);
596 } else {
597 TCHECK(dp[1]);
598 /*
599 * Print the offset as signed, since -1 is
600 * common, but offsets > 2^31 aren't.
601 */
602 printf(" %u bytes @ %d",
603 (u_int32_t)ntohl(dp[1]),
604 (u_int32_t)ntohl(dp[0]));
605 }
606 return;
607 }
608 break;
609
610 case NFSPROC_READDIRPLUS:
611 printf(" readdirplus");
612 if ((dp = parsereq(rp, length)) != NULL &&
613 (dp = parsefh(dp, v3)) != NULL) {
614 TCHECK(dp[4]);
615 /*
616 * We don't try to interpret the offset
617 * cookie here.
618 */
619 printf(" %u bytes @ ", (u_int32_t) ntohl(dp[4]));
620 print_int64(dp, SIGNED);
621 if (vflag)
622 printf(" max %u verf %08x%08x",
623 (u_int32_t) ntohl(dp[5]), dp[2], dp[3]);
624 return;
625 }
626 break;
627
628 case NFSPROC_FSSTAT:
629 printf(" fsstat");
630 if ((dp = parsereq(rp, length)) != NULL &&
631 parsefh(dp, v3) != NULL)
632 return;
633 break;
634
635 case NFSPROC_FSINFO:
636 printf(" fsinfo");
637 break;
638
639 case NFSPROC_PATHCONF:
640 printf(" pathconf");
641 break;
642
643 case NFSPROC_COMMIT:
644 printf(" commit");
645 if ((dp = parsereq(rp, length)) != NULL &&
646 (dp = parsefh(dp, v3)) != NULL) {
647 printf(" %u bytes @ ", (u_int32_t) ntohl(dp[2]));
648 print_int64(dp, UNSIGNED);
649 return;
650 }
651 break;
652
653 default:
654 printf(" proc-%u", (u_int32_t)ntohl(rp->rm_call.cb_proc));
655 return;
656 }
657
658 trunc:
659 if (!nfserr)
660 fputs(" [|nfs]", stdout);
661 }
662
663 /*
664 * Print out an NFS file handle.
665 * We assume packet was not truncated before the end of the
666 * file handle pointed to by dp.
667 *
668 * Note: new version (using portable file-handle parser) doesn't produce
669 * generation number. It probably could be made to do that, with some
670 * additional hacking on the parser code.
671 */
672 static void
673 nfs_printfh(register const u_int32_t *dp, const u_int len)
674 {
675 my_fsid fsid;
676 ino_t ino;
677 char *sfsname = NULL;
678
679 Parse_fh((caddr_t*)dp, len, &fsid, &ino, NULL, &sfsname, 0);
680
681 if (sfsname) {
682 /* file system ID is ASCII, not numeric, for this server OS */
683 static char temp[NFSX_V3FHMAX+1];
684
685 /* Make sure string is null-terminated */
686 strncpy(temp, sfsname, NFSX_V3FHMAX);
687 /* Remove trailing spaces */
688 sfsname = strchr(temp, ' ');
689 if (sfsname)
690 *sfsname = 0;
691
692 (void)printf(" fh %s/%ld", temp, (long) ino);
693 }
694 else {
695 (void)printf(" fh %d,%d/%ld",
696 fsid.Fsid_dev.Major, fsid.Fsid_dev.Minor,
697 (long) ino);
698 }
699 }
700
701 /*
702 * Maintain a small cache of recent client.XID.server/proc pairs, to allow
703 * us to match up replies with requests and thus to know how to parse
704 * the reply.
705 */
706
707 struct xid_map_entry {
708 u_int32_t xid; /* transaction ID (net order) */
709 struct in_addr client; /* client IP address (net order) */
710 struct in_addr server; /* server IP address (net order) */
711 u_int32_t proc; /* call proc number (host order) */
712 u_int32_t vers; /* program version (host order) */
713 };
714
715 /*
716 * Map entries are kept in an array that we manage as a ring;
717 * new entries are always added at the tail of the ring. Initially,
718 * all the entries are zero and hence don't match anything.
719 */
720
721 #define XIDMAPSIZE 64
722
723 struct xid_map_entry xid_map[XIDMAPSIZE];
724
725 int xid_map_next = 0;
726 int xid_map_hint = 0;
727
728 static void
729 xid_map_enter(const struct rpc_msg *rp, const struct ip *ip)
730 {
731 struct xid_map_entry *xmep;
732
733 xmep = &xid_map[xid_map_next];
734
735 if (++xid_map_next >= XIDMAPSIZE)
736 xid_map_next = 0;
737
738 xmep->xid = rp->rm_xid;
739 xmep->client = ip->ip_src;
740 xmep->server = ip->ip_dst;
741 xmep->proc = ntohl(rp->rm_call.cb_proc);
742 xmep->vers = ntohl(rp->rm_call.cb_vers);
743 }
744
745 /*
746 * Returns 0 and puts NFSPROC_xxx in proc return and
747 * version in vers return, or returns -1 on failure
748 */
749 static int
750 xid_map_find(const struct rpc_msg *rp, const struct ip *ip, u_int32_t *proc,
751 u_int32_t *vers)
752 {
753 int i;
754 struct xid_map_entry *xmep;
755 u_int32_t xid = rp->rm_xid;
756 u_int32_t clip = ip->ip_dst.s_addr;
757 u_int32_t sip = ip->ip_src.s_addr;
758
759 /* Start searching from where we last left off */
760 i = xid_map_hint;
761 do {
762 xmep = &xid_map[i];
763 if (xmep->xid == xid && xmep->client.s_addr == clip &&
764 xmep->server.s_addr == sip) {
765 /* match */
766 xid_map_hint = i;
767 *proc = xmep->proc;
768 *vers = xmep->vers;
769 return 0;
770 }
771 if (++i >= XIDMAPSIZE)
772 i = 0;
773 } while (i != xid_map_hint);
774
775 /* search failed */
776 return (-1);
777 }
778
779 /*
780 * Routines for parsing reply packets
781 */
782
783 /*
784 * Return a pointer to the beginning of the actual results.
785 * If the packet was truncated, return 0.
786 */
787 static const u_int32_t *
788 parserep(register const struct rpc_msg *rp, register u_int length)
789 {
790 register const u_int32_t *dp;
791 u_int len;
792 enum accept_stat astat;
793
794 /*
795 * Portability note:
796 * Here we find the address of the ar_verf credentials.
797 * Originally, this calculation was
798 * dp = (u_int32_t *)&rp->rm_reply.rp_acpt.ar_verf
799 * On the wire, the rp_acpt field starts immediately after
800 * the (32 bit) rp_stat field. However, rp_acpt (which is a
801 * "struct accepted_reply") contains a "struct opaque_auth",
802 * whose internal representation contains a pointer, so on a
803 * 64-bit machine the compiler inserts 32 bits of padding
804 * before rp->rm_reply.rp_acpt.ar_verf. So, we cannot use
805 * the internal representation to parse the on-the-wire
806 * representation. Instead, we skip past the rp_stat field,
807 * which is an "enum" and so occupies one 32-bit word.
808 */
809 dp = ((const u_int32_t *)&rp->rm_reply) + 1;
810 TCHECK(dp[1]);
811 len = ntohl(dp[1]);
812 if (len >= length)
813 return (NULL);
814 /*
815 * skip past the ar_verf credentials.
816 */
817 dp += (len + (2*sizeof(u_int32_t) + 3)) / sizeof(u_int32_t);
818 TCHECK2(dp[0], 0);
819
820 /*
821 * now we can check the ar_stat field
822 */
823 astat = ntohl(*(enum accept_stat *)dp);
824 switch (astat) {
825
826 case SUCCESS:
827 break;
828
829 case PROG_UNAVAIL:
830 printf(" PROG_UNAVAIL");
831 nfserr = 1; /* suppress trunc string */
832 return (NULL);
833
834 case PROG_MISMATCH:
835 printf(" PROG_MISMATCH");
836 nfserr = 1; /* suppress trunc string */
837 return (NULL);
838
839 case PROC_UNAVAIL:
840 printf(" PROC_UNAVAIL");
841 nfserr = 1; /* suppress trunc string */
842 return (NULL);
843
844 case GARBAGE_ARGS:
845 printf(" GARBAGE_ARGS");
846 nfserr = 1; /* suppress trunc string */
847 return (NULL);
848
849 case SYSTEM_ERR:
850 printf(" SYSTEM_ERR");
851 nfserr = 1; /* suppress trunc string */
852 return (NULL);
853
854 default:
855 printf(" ar_stat %d", astat);
856 nfserr = 1; /* suppress trunc string */
857 return (NULL);
858 }
859 /* successful return */
860 TCHECK2(*dp, sizeof(astat));
861 return ((u_int32_t *) (sizeof(astat) + ((char *)dp)));
862 trunc:
863 return (0);
864 }
865
866 static const u_int32_t *
867 parsestatus(const u_int32_t *dp, int *er)
868 {
869 int errnum;
870
871 TCHECK(dp[0]);
872
873 errnum = ntohl(dp[0]);
874 if (er)
875 *er = errnum;
876 if (errnum != 0) {
877 if (!qflag)
878 printf(" ERROR: %s", pcap_strerror(errnum));
879 nfserr = 1;
880 return (NULL);
881 }
882 return (dp + 1);
883 trunc:
884 return NULL;
885 }
886
887 static const u_int32_t *
888 parsefattr(const u_int32_t *dp, int verbose, int v3)
889 {
890 const struct nfs_fattr *fap;
891
892 fap = (const struct nfs_fattr *)dp;
893 TCHECK(fap->fa_gid);
894 if (verbose) {
895 printf(" %s %o ids %d/%d",
896 tok2str(type2str, "unk-ft %d ",
897 (u_int32_t)ntohl(fap->fa_type)),
898 (u_int32_t)ntohl(fap->fa_mode),
899 (u_int32_t)ntohl(fap->fa_uid),
900 (u_int32_t) ntohl(fap->fa_gid));
901 if (v3) {
902 TCHECK(fap->fa3_size);
903 printf(" sz ");
904 print_int64((u_int32_t *)&fap->fa3_size, UNSIGNED);
905 putchar(' ');
906 } else {
907 TCHECK(fap->fa2_size);
908 printf(" sz %d ", (u_int32_t) ntohl(fap->fa2_size));
909 }
910 }
911 /* print lots more stuff */
912 if (verbose > 1) {
913 if (v3) {
914 TCHECK(fap->fa3_ctime);
915 printf("nlink %d rdev %d/%d ",
916 (u_int32_t)ntohl(fap->fa_nlink),
917 (u_int32_t) ntohl(fap->fa3_rdev.specdata1),
918 (u_int32_t) ntohl(fap->fa3_rdev.specdata2));
919 printf("fsid ");
920 print_int64((u_int32_t *)&fap->fa2_fsid, HEX);
921 printf(" nodeid ");
922 print_int64((u_int32_t *)&fap->fa2_fileid, HEX);
923 printf(" a/m/ctime %u.%06u ",
924 (u_int32_t) ntohl(fap->fa3_atime.nfsv3_sec),
925 (u_int32_t) ntohl(fap->fa3_atime.nfsv3_nsec));
926 printf("%u.%06u ",
927 (u_int32_t) ntohl(fap->fa3_mtime.nfsv3_sec),
928 (u_int32_t) ntohl(fap->fa3_mtime.nfsv3_nsec));
929 printf("%u.%06u ",
930 (u_int32_t) ntohl(fap->fa3_ctime.nfsv3_sec),
931 (u_int32_t) ntohl(fap->fa3_ctime.nfsv3_nsec));
932 } else {
933 TCHECK(fap->fa2_ctime);
934 printf("nlink %d rdev %x fsid %x nodeid %x a/m/ctime ",
935 (u_int32_t) ntohl(fap->fa_nlink),
936 (u_int32_t) ntohl(fap->fa2_rdev),
937 (u_int32_t) ntohl(fap->fa2_fsid),
938 (u_int32_t) ntohl(fap->fa2_fileid));
939 printf("%u.%06u ",
940 (u_int32_t) ntohl(fap->fa2_atime.nfsv2_sec),
941 (u_int32_t) ntohl(fap->fa2_atime.nfsv2_usec));
942 printf("%u.%06u ",
943 (u_int32_t) ntohl(fap->fa2_mtime.nfsv2_sec),
944 (u_int32_t) ntohl(fap->fa2_mtime.nfsv2_usec));
945 printf("%u.%06u ",
946 (u_int32_t) ntohl(fap->fa2_ctime.nfsv2_sec),
947 (u_int32_t) ntohl(fap->fa2_ctime.nfsv2_usec));
948 }
949 }
950 return ((const u_int32_t *)((unsigned char *)dp +
951 (v3 ? NFSX_V3FATTR : NFSX_V2FATTR)));
952 trunc:
953 return (NULL);
954 }
955
956 static int
957 parseattrstat(const u_int32_t *dp, int verbose, int v3)
958 {
959 int er;
960
961 dp = parsestatus(dp, &er);
962 if (dp == NULL || er)
963 return (0);
964
965 return (parsefattr(dp, verbose, v3) != NULL);
966 }
967
968 static int
969 parsediropres(const u_int32_t *dp)
970 {
971 int er;
972
973 if (!(dp = parsestatus(dp, &er)) || er)
974 return (0);
975
976 dp = parsefh(dp, 0);
977 if (dp == NULL)
978 return (0);
979
980 return (parsefattr(dp, vflag, 0) != NULL);
981 }
982
983 static int
984 parselinkres(const u_int32_t *dp, int v3)
985 {
986 int er;
987
988 dp = parsestatus(dp, &er);
989 if (dp == NULL || er)
990 return(0);
991 if (v3 && !(dp = parse_post_op_attr(dp, vflag)))
992 return (0);
993 putchar(' ');
994 return (parsefn(dp) != NULL);
995 }
996
997 static int
998 parsestatfs(const u_int32_t *dp, int v3)
999 {
1000 const struct nfs_statfs *sfsp;
1001 int er;
1002
1003 dp = parsestatus(dp, &er);
1004 if (dp == NULL || (!v3 && er))
1005 return (0);
1006
1007 if (qflag)
1008 return(1);
1009
1010 if (v3) {
1011 if (vflag)
1012 printf(" POST:");
1013 if (!(dp = parse_post_op_attr(dp, vflag)))
1014 return (0);
1015 }
1016
1017 TCHECK2(dp, (v3 ? NFSX_V3STATFS : NFSX_V2STATFS));
1018
1019 sfsp = (const struct nfs_statfs *)dp;
1020
1021 if (v3) {
1022 printf(" tbytes ");
1023 print_int64((u_int32_t *)&sfsp->sf_tbytes, UNSIGNED);
1024 printf(" fbytes ");
1025 print_int64((u_int32_t *)&sfsp->sf_fbytes, UNSIGNED);
1026 printf(" abytes ");
1027 print_int64((u_int32_t *)&sfsp->sf_abytes, UNSIGNED);
1028 if (vflag) {
1029 printf(" tfiles ");
1030 print_int64((u_int32_t *)&sfsp->sf_tfiles, UNSIGNED);
1031 printf(" ffiles ");
1032 print_int64((u_int32_t *)&sfsp->sf_ffiles, UNSIGNED);
1033 printf(" afiles ");
1034 print_int64((u_int32_t *)&sfsp->sf_afiles, UNSIGNED);
1035 printf(" invar %u",
1036 (u_int32_t) ntohl(sfsp->sf_invarsec));
1037 }
1038 } else {
1039 printf(" tsize %d bsize %d blocks %d bfree %d bavail %d",
1040 (u_int32_t)ntohl(sfsp->sf_tsize),
1041 (u_int32_t)ntohl(sfsp->sf_bsize),
1042 (u_int32_t)ntohl(sfsp->sf_blocks),
1043 (u_int32_t)ntohl(sfsp->sf_bfree),
1044 (u_int32_t)ntohl(sfsp->sf_bavail));
1045 }
1046
1047 return (1);
1048 trunc:
1049 return (0);
1050 }
1051
1052 static int
1053 parserddires(const u_int32_t *dp)
1054 {
1055 int er;
1056
1057 dp = parsestatus(dp, &er);
1058 if (dp == 0 || er)
1059 return (0);
1060 if (qflag)
1061 return (1);
1062
1063 TCHECK(dp[2]);
1064 printf(" offset %x size %d ",
1065 (unsigned)ntohl(dp[0]), (unsigned)ntohl(dp[1]));
1066 if (dp[2] != 0)
1067 printf(" eof");
1068
1069 return (1);
1070 trunc:
1071 return (0);
1072 }
1073
1074 static const u_int32_t *
1075 parse_wcc_attr(const u_int32_t *dp)
1076 {
1077 printf(" sz ");
1078 print_int64(dp, UNSIGNED);
1079 printf(" mtime %u.%06u ctime %u.%06u",
1080 (unsigned)ntohl(dp[2]), (unsigned)ntohl(dp[3]),
1081 (unsigned)ntohl(dp[4]), (unsigned)ntohl(dp[5]));
1082 return (dp + 6);
1083 }
1084
1085 /*
1086 * Pre operation attributes. Print only if vflag > 1.
1087 */
1088 static const u_int32_t *
1089 parse_pre_op_attr(const u_int32_t *dp, int verbose)
1090 {
1091 TCHECK(dp[0]);
1092 if (!ntohl(dp[0]))
1093 return (dp + 1);
1094 dp++;
1095 TCHECK2(dp, 24);
1096 if (verbose > 1) {
1097 return parse_wcc_attr(dp);
1098 } else {
1099 /* If not verbose enough, just skip over wcc_attr */
1100 return (dp + 6);
1101 }
1102 trunc:
1103 return (NULL);
1104 }
1105
1106 /*
1107 * Post operation attributes are printed if vflag >= 1
1108 */
1109 static const u_int32_t *
1110 parse_post_op_attr(const u_int32_t *dp, int verbose)
1111 {
1112 TCHECK(dp[0]);
1113 if (!ntohl(dp[0]))
1114 return (dp + 1);
1115 dp++;
1116 if (verbose) {
1117 return parsefattr(dp, verbose, 1);
1118 } else
1119 return (dp + (NFSX_V3FATTR / sizeof (u_int32_t)));
1120 trunc:
1121 return (NULL);
1122 }
1123
1124 static const u_int32_t *
1125 parse_wcc_data(const u_int32_t *dp, int verbose)
1126 {
1127 if (verbose > 1)
1128 printf(" PRE:");
1129 if (!(dp = parse_pre_op_attr(dp, verbose)))
1130 return (0);
1131
1132 if (verbose)
1133 printf(" POST:");
1134 return parse_post_op_attr(dp, verbose);
1135 }
1136
1137 static const u_int32_t *
1138 parsecreateopres(const u_int32_t *dp, int verbose)
1139 {
1140 int er;
1141
1142 if (!(dp = parsestatus(dp, &er)))
1143 return (0);
1144 if (er)
1145 dp = parse_wcc_data(dp, verbose);
1146 else {
1147 TCHECK(dp[0]);
1148 if (!ntohl(dp[0]))
1149 return (dp + 1);
1150 dp++;
1151 if (!(dp = parsefh(dp, 1)))
1152 return (0);
1153 if (verbose) {
1154 if (!(dp = parse_post_op_attr(dp, verbose)))
1155 return (0);
1156 if (vflag > 1) {
1157 printf("dir attr:");
1158 dp = parse_wcc_data(dp, verbose);
1159 }
1160 }
1161 }
1162 return (dp);
1163 trunc:
1164 return (NULL);
1165 }
1166
1167 static int
1168 parsewccres(const u_int32_t *dp, int verbose)
1169 {
1170 int er;
1171
1172 if (!(dp = parsestatus(dp, &er)))
1173 return (0);
1174 return parse_wcc_data(dp, verbose) != 0;
1175 }
1176
1177 static const u_int32_t *
1178 parsev3rddirres(const u_int32_t *dp, int verbose)
1179 {
1180 int er;
1181
1182 if (!(dp = parsestatus(dp, &er)))
1183 return (0);
1184 if (vflag)
1185 printf(" POST:");
1186 if (!(dp = parse_post_op_attr(dp, verbose)))
1187 return (0);
1188 if (er)
1189 return dp;
1190 if (vflag) {
1191 TCHECK(dp[1]);
1192 printf(" verf %08x%08x", dp[0], dp[1]);
1193 dp += 2;
1194 }
1195 return dp;
1196 trunc:
1197 return (NULL);
1198 }
1199
1200 static int
1201 parsefsinfo(const u_int32_t *dp)
1202 {
1203 struct nfsv3_fsinfo *sfp;
1204 int er;
1205
1206 if (!(dp = parsestatus(dp, &er)))
1207 return (0);
1208 if (vflag)
1209 printf(" POST:");
1210 if (!(dp = parse_post_op_attr(dp, vflag)))
1211 return (0);
1212 if (er)
1213 return (1);
1214
1215 sfp = (struct nfsv3_fsinfo *)dp;
1216 TCHECK(*sfp);
1217 printf(" rtmax %u rtpref %u wtmax %u wtpref %u dtpref %u",
1218 (u_int32_t) ntohl(sfp->fs_rtmax),
1219 (u_int32_t) ntohl(sfp->fs_rtpref),
1220 (u_int32_t) ntohl(sfp->fs_wtmax),
1221 (u_int32_t) ntohl(sfp->fs_wtpref),
1222 (u_int32_t) ntohl(sfp->fs_dtpref));
1223 if (vflag) {
1224 printf(" rtmult %u wtmult %u maxfsz ",
1225 (u_int32_t) ntohl(sfp->fs_rtmult),
1226 (u_int32_t) ntohl(sfp->fs_wtmult));
1227 print_int64((u_int32_t *)&sfp->fs_maxfilesize, UNSIGNED);
1228 printf(" delta %u.%06u ",
1229 (u_int32_t) ntohl(sfp->fs_timedelta.nfsv3_sec),
1230 (u_int32_t) ntohl(sfp->fs_timedelta.nfsv3_nsec));
1231 }
1232 return (0);
1233 trunc:
1234 return (1);
1235 }
1236
1237 static int
1238 parsepathconf(const u_int32_t *dp)
1239 {
1240 int er;
1241 struct nfsv3_pathconf *spp;
1242
1243 if (!(dp = parsestatus(dp, &er)))
1244 return (0);
1245 if (vflag)
1246 printf(" POST:");
1247 if (!(dp = parse_post_op_attr(dp, vflag)))
1248 return (0);
1249 if (er)
1250 return (1);
1251
1252 spp = (struct nfsv3_pathconf *)dp;
1253 TCHECK(*spp);
1254
1255 printf(" linkmax %u namemax %u %s %s %s %s",
1256 (u_int32_t) ntohl(spp->pc_linkmax),
1257 (u_int32_t) ntohl(spp->pc_namemax),
1258 ntohl(spp->pc_notrunc) ? "notrunc" : "",
1259 ntohl(spp->pc_chownrestricted) ? "chownres" : "",
1260 ntohl(spp->pc_caseinsensitive) ? "igncase" : "",
1261 ntohl(spp->pc_casepreserving) ? "keepcase" : "");
1262 return (0);
1263 trunc:
1264 return (1);
1265 }
1266
1267 static void
1268 interp_reply(const struct rpc_msg *rp, u_int32_t proc, u_int32_t vers, int length)
1269 {
1270 register const u_int32_t *dp;
1271 register int v3;
1272 int er;
1273
1274 v3 = (vers == NFS_VER3);
1275
1276 if (!v3 && proc < NFS_NPROCS)
1277 proc = nfsv3_procid[proc];
1278
1279 switch (proc) {
1280
1281 case NFSPROC_NOOP:
1282 printf(" nop");
1283 return;
1284
1285 case NFSPROC_NULL:
1286 printf(" null");
1287 return;
1288
1289 case NFSPROC_GETATTR:
1290 printf(" getattr");
1291 dp = parserep(rp, length);
1292 if (dp != NULL && parseattrstat(dp, !qflag, v3) != 0)
1293 return;
1294 break;
1295
1296 case NFSPROC_SETATTR:
1297 printf(" setattr");
1298 if (!(dp = parserep(rp, length)))
1299 return;
1300 if (v3) {
1301 if (parsewccres(dp, vflag))
1302 return;
1303 } else {
1304 if (parseattrstat(dp, !qflag, 0) != 0)
1305 return;
1306 }
1307 break;
1308
1309 case NFSPROC_LOOKUP:
1310 printf(" lookup");
1311 if (!(dp = parserep(rp, length)))
1312 break;
1313 if (v3) {
1314 if (!(dp = parsestatus(dp, &er)))
1315 break;
1316 if (er) {
1317 if (vflag > 1) {
1318 printf(" post dattr:");
1319 dp = parse_post_op_attr(dp, vflag);
1320 }
1321 } else {
1322 if (!(dp = parsefh(dp, v3)))
1323 break;
1324 if ((dp = parse_post_op_attr(dp, vflag)) &&
1325 vflag > 1) {
1326 printf(" post dattr:");
1327 dp = parse_post_op_attr(dp, vflag);
1328 }
1329 }
1330 if (dp)
1331 return;
1332 } else {
1333 if (parsediropres(dp) != 0)
1334 return;
1335 }
1336 break;
1337
1338 case NFSPROC_ACCESS:
1339 printf(" access");
1340 dp = parserep(rp, length);
1341 if (!(dp = parsestatus(dp, &er)))
1342 break;
1343 if (vflag)
1344 printf(" attr:");
1345 if (!(dp = parse_post_op_attr(dp, vflag)))
1346 break;
1347 if (!er)
1348 printf(" c %04x", (unsigned)ntohl(dp[0]));
1349 return;
1350
1351 case NFSPROC_READLINK:
1352 printf(" readlink");
1353 dp = parserep(rp, length);
1354 if (dp != NULL && parselinkres(dp, v3) != 0)
1355 return;
1356 break;
1357
1358 case NFSPROC_READ:
1359 printf(" read");
1360 if (!(dp = parserep(rp, length)))
1361 break;
1362 if (v3) {
1363 if (!(dp = parsestatus(dp, &er)))
1364 break;
1365 if (!(dp = parse_post_op_attr(dp, vflag)))
1366 break;
1367 if (er)
1368 return;
1369 if (vflag) {
1370 TCHECK(dp[1]);
1371 printf("%u bytes", (u_int32_t) ntohl(dp[0]));
1372 if (ntohl(dp[1]))
1373 printf(" EOF");
1374 }
1375 return;
1376 } else {
1377 if (parseattrstat(dp, vflag, 0) != 0)
1378 return;
1379 }
1380 break;
1381
1382 case NFSPROC_WRITE:
1383 printf(" write");
1384 if (!(dp = parserep(rp, length)))
1385 break;
1386 if (v3) {
1387 if (!(dp = parsestatus(dp, &er)))
1388 break;
1389 if (!(dp = parse_wcc_data(dp, vflag)))
1390 break;
1391 if (er)
1392 return;
1393 if (vflag) {
1394 TCHECK(dp[0]);
1395 printf("%u bytes", (u_int32_t) ntohl(dp[0]));
1396 if (vflag > 1) {
1397 TCHECK(dp[1]);
1398 printf(" <%s>",
1399 tok2str(nfsv3_writemodes,
1400 NULL, ntohl(dp[1])));
1401 }
1402 return;
1403 }
1404 } else {
1405 if (parseattrstat(dp, vflag, v3) != 0)
1406 return;
1407 }
1408 break;
1409
1410 case NFSPROC_CREATE:
1411 printf(" create");
1412 if (!(dp = parserep(rp, length)))
1413 break;
1414 if (v3) {
1415 if (parsecreateopres(dp, vflag) != 0)
1416 return;
1417 } else {
1418 if (parsediropres(dp) != 0)
1419 return;
1420 }
1421 break;
1422
1423 case NFSPROC_MKDIR:
1424 printf(" mkdir");
1425 if (!(dp = parserep(rp, length)))
1426 break;
1427 if (v3) {
1428 if (parsecreateopres(dp, vflag) != 0)
1429 return;
1430 } else {
1431 if (parsediropres(dp) != 0)
1432 return;
1433 }
1434 break;
1435
1436 case NFSPROC_SYMLINK:
1437 printf(" symlink");
1438 if (!(dp = parserep(rp, length)))
1439 break;
1440 if (v3) {
1441 if (parsecreateopres(dp, vflag) != 0)
1442 return;
1443 } else {
1444 if (parsestatus(dp, &er) != 0)
1445 return;
1446 }
1447 break;
1448
1449 case NFSPROC_MKNOD:
1450 printf(" mknod");
1451 if (!(dp = parserep(rp, length)))
1452 break;
1453 if (parsecreateopres(dp, vflag) != 0)
1454 return;
1455 break;
1456
1457 case NFSPROC_REMOVE:
1458 printf(" remove");
1459 if (!(dp = parserep(rp, length)))
1460 break;
1461 if (v3) {
1462 if (parsewccres(dp, vflag))
1463 return;
1464 } else {
1465 if (parsestatus(dp, &er) != 0)
1466 return;
1467 }
1468 break;
1469
1470 case NFSPROC_RMDIR:
1471 printf(" rmdir");
1472 if (!(dp = parserep(rp, length)))
1473 break;
1474 if (v3) {
1475 if (parsewccres(dp, vflag))
1476 return;
1477 } else {
1478 if (parsestatus(dp, &er) != 0)
1479 return;
1480 }
1481 break;
1482
1483 case NFSPROC_RENAME:
1484 printf(" rename");
1485 if (!(dp = parserep(rp, length)))
1486 break;
1487 if (v3) {
1488 if (!(dp = parsestatus(dp, &er)))
1489 break;
1490 if (vflag) {
1491 printf(" from:");
1492 if (!(dp = parse_wcc_data(dp, vflag)))
1493 break;
1494 printf(" to:");
1495 if (!(dp = parse_wcc_data(dp, vflag)))
1496 break;
1497 }
1498 return;
1499 } else {
1500 if (parsestatus(dp, &er) != 0)
1501 return;
1502 }
1503 break;
1504
1505 case NFSPROC_LINK:
1506 printf(" link");
1507 if (!(dp = parserep(rp, length)))
1508 break;
1509 if (v3) {
1510 if (!(dp = parsestatus(dp, &er)))
1511 break;
1512 if (vflag) {
1513 printf(" file POST:");
1514 if (!(dp = parse_post_op_attr(dp, vflag)))
1515 break;
1516 printf(" dir:");
1517 if (!(dp = parse_wcc_data(dp, vflag)))
1518 break;
1519 return;
1520 }
1521 } else {
1522 if (parsestatus(dp, &er) != 0)
1523 return;
1524 }
1525 break;
1526
1527 case NFSPROC_READDIR:
1528 printf(" readdir");
1529 if (!(dp = parserep(rp, length)))
1530 break;
1531 if (v3) {
1532 if (parsev3rddirres(dp, vflag))
1533 return;
1534 } else {
1535 if (parserddires(dp) != 0)
1536 return;
1537 }
1538 break;
1539
1540 case NFSPROC_READDIRPLUS:
1541 printf(" readdirplus");
1542 if (!(dp = parserep(rp, length)))
1543 break;
1544 if (parsev3rddirres(dp, vflag))
1545 return;
1546 break;
1547
1548 case NFSPROC_FSSTAT:
1549 printf(" fsstat");
1550 dp = parserep(rp, length);
1551 if (dp != NULL && parsestatfs(dp, v3) != 0)
1552 return;
1553 break;
1554
1555 case NFSPROC_FSINFO:
1556 printf(" fsinfo");
1557 dp = parserep(rp, length);
1558 if (dp != NULL && parsefsinfo(dp) != 0)
1559 return;
1560 break;
1561
1562 case NFSPROC_PATHCONF:
1563 printf(" pathconf");
1564 dp = parserep(rp, length);
1565 if (dp != NULL && parsepathconf(dp) != 0)
1566 return;
1567 break;
1568
1569 case NFSPROC_COMMIT:
1570 printf(" commit");
1571 dp = parserep(rp, length);
1572 if (dp != NULL && parsewccres(dp, vflag) != 0)
1573 return;
1574 break;
1575
1576 default:
1577 printf(" proc-%u", proc);
1578 return;
1579 }
1580 trunc:
1581 if (!nfserr)
1582 fputs(" [|nfs]", stdout);
1583 }
[mirror] the TCPdump network dissector