?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel: Replace the remaining __amd64__ with __x86_64__ for consistency.
[dragonfly.git] / contrib / tcpdump / print-nfs.c
blob4d17757f311457e72a5e12eb7847c67fdc52229f
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.111 2007-12-22 03:08:04 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 u_int32_t access_flags;
512 struct nfsv3_sattr sa3;
513 char srcid[20], dstid[20]; /*fits 32bit*/
514
515 nfserr = 0; /* assume no error */
516 rp = (const struct sunrpc_msg *)bp;
517
518 TCHECK(rp->rm_xid);
519 if (!nflag) {
520 snprintf(srcid, sizeof(srcid), "%u",
521 EXTRACT_32BITS(&rp->rm_xid));
522 strlcpy(dstid, "nfs", sizeof(dstid));
523 } else {
524 snprintf(srcid, sizeof(srcid), "%u",
525 EXTRACT_32BITS(&rp->rm_xid));
526 snprintf(dstid, sizeof(dstid), "%u", NFS_PORT);
527 }
528 print_nfsaddr(bp2, srcid, dstid);
529 (void)printf("%d", length);
530
531 if (!xid_map_enter(rp, bp2)) /* record proc number for later on */
532 goto trunc;
533
534 v3 = (EXTRACT_32BITS(&rp->rm_call.cb_vers) == NFS_VER3);
535 proc = EXTRACT_32BITS(&rp->rm_call.cb_proc);
536
537 if (!v3 && proc < NFS_NPROCS)
538 proc = nfsv3_procid[proc];
539
540 switch (proc) {
541 case NFSPROC_NOOP:
542 printf(" nop");
543 return;
544 case NFSPROC_NULL:
545 printf(" null");
546 return;
547
548 case NFSPROC_GETATTR:
549 printf(" getattr");
550 if ((dp = parsereq(rp, length)) != NULL &&
551 parsefh(dp, v3) != NULL)
552 return;
553 break;
554
555 case NFSPROC_SETATTR:
556 printf(" setattr");
557 if ((dp = parsereq(rp, length)) != NULL &&
558 parsefh(dp, v3) != NULL)
559 return;
560 break;
561
562 case NFSPROC_LOOKUP:
563 printf(" lookup");
564 if ((dp = parsereq(rp, length)) != NULL &&
565 parsefhn(dp, v3) != NULL)
566 return;
567 break;
568
569 case NFSPROC_ACCESS:
570 printf(" access");
571 if ((dp = parsereq(rp, length)) != NULL &&
572 (dp = parsefh(dp, v3)) != NULL) {
573 TCHECK(dp[0]);
574 access_flags = EXTRACT_32BITS(&dp[0]);
575 if (access_flags & ~NFSV3ACCESS_FULL) {
576 /* NFSV3ACCESS definitions aren't up to date */
577 printf(" %04x", access_flags);
578 } else if ((access_flags & NFSV3ACCESS_FULL) == NFSV3ACCESS_FULL) {
579 printf(" NFS_ACCESS_FULL");
580 } else {
581 char separator = ' ';
582 if (access_flags & NFSV3ACCESS_READ) {
583 printf(" NFS_ACCESS_READ");
584 separator = '|';
585 }
586 if (access_flags & NFSV3ACCESS_LOOKUP) {
587 printf("%cNFS_ACCESS_LOOKUP", separator);
588 separator = '|';
589 }
590 if (access_flags & NFSV3ACCESS_MODIFY) {
591 printf("%cNFS_ACCESS_MODIFY", separator);
592 separator = '|';
593 }
594 if (access_flags & NFSV3ACCESS_EXTEND) {
595 printf("%cNFS_ACCESS_EXTEND", separator);
596 separator = '|';
597 }
598 if (access_flags & NFSV3ACCESS_DELETE) {
599 printf("%cNFS_ACCESS_DELETE", separator);
600 separator = '|';
601 }
602 if (access_flags & NFSV3ACCESS_EXECUTE)
603 printf("%cNFS_ACCESS_EXECUTE", separator);
604 }
605 return;
606 }
607 break;
608
609 case NFSPROC_READLINK:
610 printf(" readlink");
611 if ((dp = parsereq(rp, length)) != NULL &&
612 parsefh(dp, v3) != NULL)
613 return;
614 break;
615
616 case NFSPROC_READ:
617 printf(" read");
618 if ((dp = parsereq(rp, length)) != NULL &&
619 (dp = parsefh(dp, v3)) != NULL) {
620 if (v3) {
621 TCHECK(dp[2]);
622 printf(" %u bytes @ %" PRIu64,
623 EXTRACT_32BITS(&dp[2]),
624 EXTRACT_64BITS(&dp[0]));
625 } else {
626 TCHECK(dp[1]);
627 printf(" %u bytes @ %u",
628 EXTRACT_32BITS(&dp[1]),
629 EXTRACT_32BITS(&dp[0]));
630 }
631 return;
632 }
633 break;
634
635 case NFSPROC_WRITE:
636 printf(" write");
637 if ((dp = parsereq(rp, length)) != NULL &&
638 (dp = parsefh(dp, v3)) != NULL) {
639 if (v3) {
640 TCHECK(dp[2]);
641 printf(" %u (%u) bytes @ %" PRIu64,
642 EXTRACT_32BITS(&dp[4]),
643 EXTRACT_32BITS(&dp[2]),
644 EXTRACT_64BITS(&dp[0]));
645 if (vflag) {
646 dp += 3;
647 TCHECK(dp[0]);
648 printf(" <%s>",
649 tok2str(nfsv3_writemodes,
650 NULL, EXTRACT_32BITS(dp)));
651 }
652 } else {
653 TCHECK(dp[3]);
654 printf(" %u (%u) bytes @ %u (%u)",
655 EXTRACT_32BITS(&dp[3]),
656 EXTRACT_32BITS(&dp[2]),
657 EXTRACT_32BITS(&dp[1]),
658 EXTRACT_32BITS(&dp[0]));
659 }
660 return;
661 }
662 break;
663
664 case NFSPROC_CREATE:
665 printf(" create");
666 if ((dp = parsereq(rp, length)) != NULL &&
667 parsefhn(dp, v3) != NULL)
668 return;
669 break;
670
671 case NFSPROC_MKDIR:
672 printf(" mkdir");
673 if ((dp = parsereq(rp, length)) != 0 && parsefhn(dp, v3) != 0)
674 return;
675 break;
676
677 case NFSPROC_SYMLINK:
678 printf(" symlink");
679 if ((dp = parsereq(rp, length)) != 0 &&
680 (dp = parsefhn(dp, v3)) != 0) {
681 fputs(" ->", stdout);
682 if (v3 && (dp = parse_sattr3(dp, &sa3)) == 0)
683 break;
684 if (parsefn(dp) == 0)
685 break;
686 if (v3 && vflag)
687 print_sattr3(&sa3, vflag);
688 return;
689 }
690 break;
691
692 case NFSPROC_MKNOD:
693 printf(" mknod");
694 if ((dp = parsereq(rp, length)) != 0 &&
695 (dp = parsefhn(dp, v3)) != 0) {
696 TCHECK(*dp);
697 type = (nfs_type)EXTRACT_32BITS(dp);
698 dp++;
699 if ((dp = parse_sattr3(dp, &sa3)) == 0)
700 break;
701 printf(" %s", tok2str(type2str, "unk-ft %d", type));
702 if (vflag && (type == NFCHR || type == NFBLK)) {
703 TCHECK(dp[1]);
704 printf(" %u/%u",
705 EXTRACT_32BITS(&dp[0]),
706 EXTRACT_32BITS(&dp[1]));
707 dp += 2;
708 }
709 if (vflag)
710 print_sattr3(&sa3, vflag);
711 return;
712 }
713 break;
714
715 case NFSPROC_REMOVE:
716 printf(" remove");
717 if ((dp = parsereq(rp, length)) != NULL &&
718 parsefhn(dp, v3) != NULL)
719 return;
720 break;
721
722 case NFSPROC_RMDIR:
723 printf(" rmdir");
724 if ((dp = parsereq(rp, length)) != NULL &&
725 parsefhn(dp, v3) != NULL)
726 return;
727 break;
728
729 case NFSPROC_RENAME:
730 printf(" rename");
731 if ((dp = parsereq(rp, length)) != NULL &&
732 (dp = parsefhn(dp, v3)) != NULL) {
733 fputs(" ->", stdout);
734 if (parsefhn(dp, v3) != NULL)
735 return;
736 }
737 break;
738
739 case NFSPROC_LINK:
740 printf(" link");
741 if ((dp = parsereq(rp, length)) != NULL &&
742 (dp = parsefh(dp, v3)) != NULL) {
743 fputs(" ->", stdout);
744 if (parsefhn(dp, v3) != NULL)
745 return;
746 }
747 break;
748
749 case NFSPROC_READDIR:
750 printf(" readdir");
751 if ((dp = parsereq(rp, length)) != NULL &&
752 (dp = parsefh(dp, v3)) != NULL) {
753 if (v3) {
754 TCHECK(dp[4]);
755 /*
756 * We shouldn't really try to interpret the
757 * offset cookie here.
758 */
759 printf(" %u bytes @ %" PRId64,
760 EXTRACT_32BITS(&dp[4]),
761 EXTRACT_64BITS(&dp[0]));
762 if (vflag)
763 printf(" verf %08x%08x", dp[2],
764 dp[3]);
765 } else {
766 TCHECK(dp[1]);
767 /*
768 * Print the offset as signed, since -1 is
769 * common, but offsets > 2^31 aren't.
770 */
771 printf(" %u bytes @ %d",
772 EXTRACT_32BITS(&dp[1]),
773 EXTRACT_32BITS(&dp[0]));
774 }
775 return;
776 }
777 break;
778
779 case NFSPROC_READDIRPLUS:
780 printf(" readdirplus");
781 if ((dp = parsereq(rp, length)) != NULL &&
782 (dp = parsefh(dp, v3)) != NULL) {
783 TCHECK(dp[4]);
784 /*
785 * We don't try to interpret the offset
786 * cookie here.
787 */
788 printf(" %u bytes @ %" PRId64,
789 EXTRACT_32BITS(&dp[4]),
790 EXTRACT_64BITS(&dp[0]));
791 if (vflag) {
792 TCHECK(dp[5]);
793 printf(" max %u verf %08x%08x",
794 EXTRACT_32BITS(&dp[5]), dp[2], dp[3]);
795 }
796 return;
797 }
798 break;
799
800 case NFSPROC_FSSTAT:
801 printf(" fsstat");
802 if ((dp = parsereq(rp, length)) != NULL &&
803 parsefh(dp, v3) != NULL)
804 return;
805 break;
806
807 case NFSPROC_FSINFO:
808 printf(" fsinfo");
809 if ((dp = parsereq(rp, length)) != NULL &&
810 parsefh(dp, v3) != NULL)
811 return;
812 break;
813
814 case NFSPROC_PATHCONF:
815 printf(" pathconf");
816 if ((dp = parsereq(rp, length)) != NULL &&
817 parsefh(dp, v3) != NULL)
818 return;
819 break;
820
821 case NFSPROC_COMMIT:
822 printf(" commit");
823 if ((dp = parsereq(rp, length)) != NULL &&
824 (dp = parsefh(dp, v3)) != NULL) {
825 TCHECK(dp[2]);
826 printf(" %u bytes @ %" PRIu64,
827 EXTRACT_32BITS(&dp[2]),
828 EXTRACT_64BITS(&dp[0]));
829 return;
830 }
831 break;
832
833 default:
834 printf(" proc-%u", EXTRACT_32BITS(&rp->rm_call.cb_proc));
835 return;
836 }
837
838 trunc:
839 if (!nfserr)
840 fputs(" [|nfs]", stdout);
841 }
842
843 /*
844 * Print out an NFS file handle.
845 * We assume packet was not truncated before the end of the
846 * file handle pointed to by dp.
847 *
848 * Note: new version (using portable file-handle parser) doesn't produce
849 * generation number. It probably could be made to do that, with some
850 * additional hacking on the parser code.
851 */
852 static void
853 nfs_printfh(register const u_int32_t *dp, const u_int len)
854 {
855 my_fsid fsid;
856 ino_t ino;
857 const char *sfsname = NULL;
858 char *spacep;
859
860 if (uflag) {
861 u_int i;
862 char const *sep = "";
863
864 printf(" fh[");
865 for (i=0; i<len; i++) {
866 (void)printf("%s%x", sep, dp[i]);
867 sep = ":";
868 }
869 printf("]");
870 return;
871 }
872
873 Parse_fh((const u_char *)dp, len, &fsid, &ino, NULL, &sfsname, 0);
874
875 if (sfsname) {
876 /* file system ID is ASCII, not numeric, for this server OS */
877 static char temp[NFSX_V3FHMAX+1];
878
879 /* Make sure string is null-terminated */
880 strncpy(temp, sfsname, NFSX_V3FHMAX);
881 temp[sizeof(temp) - 1] = '\0';
882 /* Remove trailing spaces */
883 spacep = strchr(temp, ' ');
884 if (spacep)
885 *spacep = '\0';
886
887 (void)printf(" fh %s/", temp);
888 } else {
889 (void)printf(" fh %d,%d/",
890 fsid.Fsid_dev.Major, fsid.Fsid_dev.Minor);
891 }
892
893 if(fsid.Fsid_dev.Minor == 257)
894 /* Print the undecoded handle */
895 (void)printf("%s", fsid.Opaque_Handle);
896 else
897 (void)printf("%ld", (long) ino);
898 }
899
900 /*
901 * Maintain a small cache of recent client.XID.server/proc pairs, to allow
902 * us to match up replies with requests and thus to know how to parse
903 * the reply.
904 */
905
906 struct xid_map_entry {
907 u_int32_t xid; /* transaction ID (net order) */
908 int ipver; /* IP version (4 or 6) */
909 #ifdef INET6
910 struct in6_addr client; /* client IP address (net order) */
911 struct in6_addr server; /* server IP address (net order) */
912 #else
913 struct in_addr client; /* client IP address (net order) */
914 struct in_addr server; /* server IP address (net order) */
915 #endif
916 u_int32_t proc; /* call proc number (host order) */
917 u_int32_t vers; /* program version (host order) */
918 };
919
920 /*
921 * Map entries are kept in an array that we manage as a ring;
922 * new entries are always added at the tail of the ring. Initially,
923 * all the entries are zero and hence don't match anything.
924 */
925
926 #define XIDMAPSIZE 64
927
928 struct xid_map_entry xid_map[XIDMAPSIZE];
929
930 int xid_map_next = 0;
931 int xid_map_hint = 0;
932
933 static int
934 xid_map_enter(const struct sunrpc_msg *rp, const u_char *bp)
935 {
936 struct ip *ip = NULL;
937 #ifdef INET6
938 struct ip6_hdr *ip6 = NULL;
939 #endif
940 struct xid_map_entry *xmep;
941
942 if (!TTEST(rp->rm_call.cb_vers))
943 return (0);
944 switch (IP_V((struct ip *)bp)) {
945 case 4:
946 ip = (struct ip *)bp;
947 break;
948 #ifdef INET6
949 case 6:
950 ip6 = (struct ip6_hdr *)bp;
951 break;
952 #endif
953 default:
954 return (1);
955 }
956
957 xmep = &xid_map[xid_map_next];
958
959 if (++xid_map_next >= XIDMAPSIZE)
960 xid_map_next = 0;
961
962 xmep->xid = rp->rm_xid;
963 if (ip) {
964 xmep->ipver = 4;
965 memcpy(&xmep->client, &ip->ip_src, sizeof(ip->ip_src));
966 memcpy(&xmep->server, &ip->ip_dst, sizeof(ip->ip_dst));
967 }
968 #ifdef INET6
969 else if (ip6) {
970 xmep->ipver = 6;
971 memcpy(&xmep->client, &ip6->ip6_src, sizeof(ip6->ip6_src));
972 memcpy(&xmep->server, &ip6->ip6_dst, sizeof(ip6->ip6_dst));
973 }
974 #endif
975 xmep->proc = EXTRACT_32BITS(&rp->rm_call.cb_proc);
976 xmep->vers = EXTRACT_32BITS(&rp->rm_call.cb_vers);
977 return (1);
978 }
979
980 /*
981 * Returns 0 and puts NFSPROC_xxx in proc return and
982 * version in vers return, or returns -1 on failure
983 */
984 static int
985 xid_map_find(const struct sunrpc_msg *rp, const u_char *bp, u_int32_t *proc,
986 u_int32_t *vers)
987 {
988 int i;
989 struct xid_map_entry *xmep;
990 u_int32_t xid = rp->rm_xid;
991 struct ip *ip = (struct ip *)bp;
992 #ifdef INET6
993 struct ip6_hdr *ip6 = (struct ip6_hdr *)bp;
994 #endif
995 int cmp;
996
997 /* Start searching from where we last left off */
998 i = xid_map_hint;
999 do {
1000 xmep = &xid_map[i];
1001 cmp = 1;
1002 if (xmep->ipver != IP_V(ip) || xmep->xid != xid)
1003 goto nextitem;
1004 switch (xmep->ipver) {
1005 case 4:
1006 if (memcmp(&ip->ip_src, &xmep->server,
1007 sizeof(ip->ip_src)) != 0 ||
1008 memcmp(&ip->ip_dst, &xmep->client,
1009 sizeof(ip->ip_dst)) != 0) {
1010 cmp = 0;
1011 }
1012 break;
1013 #ifdef INET6
1014 case 6:
1015 if (memcmp(&ip6->ip6_src, &xmep->server,
1016 sizeof(ip6->ip6_src)) != 0 ||
1017 memcmp(&ip6->ip6_dst, &xmep->client,
1018 sizeof(ip6->ip6_dst)) != 0) {
1019 cmp = 0;
1020 }
1021 break;
1022 #endif
1023 default:
1024 cmp = 0;
1025 break;
1026 }
1027 if (cmp) {
1028 /* match */
1029 xid_map_hint = i;
1030 *proc = xmep->proc;
1031 *vers = xmep->vers;
1032 return 0;
1033 }
1034 nextitem:
1035 if (++i >= XIDMAPSIZE)
1036 i = 0;
1037 } while (i != xid_map_hint);
1038
1039 /* search failed */
1040 return (-1);
1041 }
1042
1043 /*
1044 * Routines for parsing reply packets
1045 */
1046
1047 /*
1048 * Return a pointer to the beginning of the actual results.
1049 * If the packet was truncated, return 0.
1050 */
1051 static const u_int32_t *
1052 parserep(register const struct sunrpc_msg *rp, register u_int length)
1053 {
1054 register const u_int32_t *dp;
1055 u_int len;
1056 enum sunrpc_accept_stat astat;
1057
1058 /*
1059 * Portability note:
1060 * Here we find the address of the ar_verf credentials.
1061 * Originally, this calculation was
1062 * dp = (u_int32_t *)&rp->rm_reply.rp_acpt.ar_verf
1063 * On the wire, the rp_acpt field starts immediately after
1064 * the (32 bit) rp_stat field. However, rp_acpt (which is a
1065 * "struct accepted_reply") contains a "struct opaque_auth",
1066 * whose internal representation contains a pointer, so on a
1067 * 64-bit machine the compiler inserts 32 bits of padding
1068 * before rp->rm_reply.rp_acpt.ar_verf. So, we cannot use
1069 * the internal representation to parse the on-the-wire
1070 * representation. Instead, we skip past the rp_stat field,
1071 * which is an "enum" and so occupies one 32-bit word.
1072 */
1073 dp = ((const u_int32_t *)&rp->rm_reply) + 1;
1074 TCHECK(dp[1]);
1075 len = EXTRACT_32BITS(&dp[1]);
1076 if (len >= length)
1077 return (NULL);
1078 /*
1079 * skip past the ar_verf credentials.
1080 */
1081 dp += (len + (2*sizeof(u_int32_t) + 3)) / sizeof(u_int32_t);
1082 TCHECK2(dp[0], 0);
1083
1084 /*
1085 * now we can check the ar_stat field
1086 */
1087 astat = (enum sunrpc_accept_stat) EXTRACT_32BITS(dp);
1088 switch (astat) {
1089
1090 case SUNRPC_SUCCESS:
1091 break;
1092
1093 case SUNRPC_PROG_UNAVAIL:
1094 printf(" PROG_UNAVAIL");
1095 nfserr = 1; /* suppress trunc string */
1096 return (NULL);
1097
1098 case SUNRPC_PROG_MISMATCH:
1099 printf(" PROG_MISMATCH");
1100 nfserr = 1; /* suppress trunc string */
1101 return (NULL);
1102
1103 case SUNRPC_PROC_UNAVAIL:
1104 printf(" PROC_UNAVAIL");
1105 nfserr = 1; /* suppress trunc string */
1106 return (NULL);
1107
1108 case SUNRPC_GARBAGE_ARGS:
1109 printf(" GARBAGE_ARGS");
1110 nfserr = 1; /* suppress trunc string */
1111 return (NULL);
1112
1113 case SUNRPC_SYSTEM_ERR:
1114 printf(" SYSTEM_ERR");
1115 nfserr = 1; /* suppress trunc string */
1116 return (NULL);
1117
1118 default:
1119 printf(" ar_stat %d", astat);
1120 nfserr = 1; /* suppress trunc string */
1121 return (NULL);
1122 }
1123 /* successful return */
1124 TCHECK2(*dp, sizeof(astat));
1125 return ((u_int32_t *) (sizeof(astat) + ((char *)dp)));
1126 trunc:
1127 return (0);
1128 }
1129
1130 static const u_int32_t *
1131 parsestatus(const u_int32_t *dp, int *er)
1132 {
1133 int errnum;
1134
1135 TCHECK(dp[0]);
1136
1137 errnum = EXTRACT_32BITS(&dp[0]);
1138 if (er)
1139 *er = errnum;
1140 if (errnum != 0) {
1141 if (!qflag)
1142 printf(" ERROR: %s",
1143 tok2str(status2str, "unk %d", errnum));
1144 nfserr = 1;
1145 }
1146 return (dp + 1);
1147 trunc:
1148 return NULL;
1149 }
1150
1151 static const u_int32_t *
1152 parsefattr(const u_int32_t *dp, int verbose, int v3)
1153 {
1154 const struct nfs_fattr *fap;
1155
1156 fap = (const struct nfs_fattr *)dp;
1157 TCHECK(fap->fa_gid);
1158 if (verbose) {
1159 printf(" %s %o ids %d/%d",
1160 tok2str(type2str, "unk-ft %d ",
1161 EXTRACT_32BITS(&fap->fa_type)),
1162 EXTRACT_32BITS(&fap->fa_mode),
1163 EXTRACT_32BITS(&fap->fa_uid),
1164 EXTRACT_32BITS(&fap->fa_gid));
1165 if (v3) {
1166 TCHECK(fap->fa3_size);
1167 printf(" sz %" PRIu64,
1168 EXTRACT_64BITS((u_int32_t *)&fap->fa3_size));
1169 } else {
1170 TCHECK(fap->fa2_size);
1171 printf(" sz %d", EXTRACT_32BITS(&fap->fa2_size));
1172 }
1173 }
1174 /* print lots more stuff */
1175 if (verbose > 1) {
1176 if (v3) {
1177 TCHECK(fap->fa3_ctime);
1178 printf(" nlink %d rdev %d/%d",
1179 EXTRACT_32BITS(&fap->fa_nlink),
1180 EXTRACT_32BITS(&fap->fa3_rdev.specdata1),
1181 EXTRACT_32BITS(&fap->fa3_rdev.specdata2));
1182 printf(" fsid %" PRIx64,
1183 EXTRACT_64BITS((u_int32_t *)&fap->fa3_fsid));
1184 printf(" fileid %" PRIx64,
1185 EXTRACT_64BITS((u_int32_t *)&fap->fa3_fileid));
1186 printf(" a/m/ctime %u.%06u",
1187 EXTRACT_32BITS(&fap->fa3_atime.nfsv3_sec),
1188 EXTRACT_32BITS(&fap->fa3_atime.nfsv3_nsec));
1189 printf(" %u.%06u",
1190 EXTRACT_32BITS(&fap->fa3_mtime.nfsv3_sec),
1191 EXTRACT_32BITS(&fap->fa3_mtime.nfsv3_nsec));
1192 printf(" %u.%06u",
1193 EXTRACT_32BITS(&fap->fa3_ctime.nfsv3_sec),
1194 EXTRACT_32BITS(&fap->fa3_ctime.nfsv3_nsec));
1195 } else {
1196 TCHECK(fap->fa2_ctime);
1197 printf(" nlink %d rdev %x fsid %x nodeid %x a/m/ctime",
1198 EXTRACT_32BITS(&fap->fa_nlink),
1199 EXTRACT_32BITS(&fap->fa2_rdev),
1200 EXTRACT_32BITS(&fap->fa2_fsid),
1201 EXTRACT_32BITS(&fap->fa2_fileid));
1202 printf(" %u.%06u",
1203 EXTRACT_32BITS(&fap->fa2_atime.nfsv2_sec),
1204 EXTRACT_32BITS(&fap->fa2_atime.nfsv2_usec));
1205 printf(" %u.%06u",
1206 EXTRACT_32BITS(&fap->fa2_mtime.nfsv2_sec),
1207 EXTRACT_32BITS(&fap->fa2_mtime.nfsv2_usec));
1208 printf(" %u.%06u",
1209 EXTRACT_32BITS(&fap->fa2_ctime.nfsv2_sec),
1210 EXTRACT_32BITS(&fap->fa2_ctime.nfsv2_usec));
1211 }
1212 }
1213 return ((const u_int32_t *)((unsigned char *)dp +
1214 (v3 ? NFSX_V3FATTR : NFSX_V2FATTR)));
1215 trunc:
1216 return (NULL);
1217 }
1218
1219 static int
1220 parseattrstat(const u_int32_t *dp, int verbose, 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
1230 return (parsefattr(dp, verbose, v3) != NULL);
1231 }
1232
1233 static int
1234 parsediropres(const u_int32_t *dp)
1235 {
1236 int er;
1237
1238 if (!(dp = parsestatus(dp, &er)))
1239 return (0);
1240 if (er)
1241 return (1);
1242
1243 dp = parsefh(dp, 0);
1244 if (dp == NULL)
1245 return (0);
1246
1247 return (parsefattr(dp, vflag, 0) != NULL);
1248 }
1249
1250 static int
1251 parselinkres(const u_int32_t *dp, int v3)
1252 {
1253 int er;
1254
1255 dp = parsestatus(dp, &er);
1256 if (dp == NULL)
1257 return(0);
1258 if (er)
1259 return(1);
1260 if (v3 && !(dp = parse_post_op_attr(dp, vflag)))
1261 return (0);
1262 putchar(' ');
1263 return (parsefn(dp) != NULL);
1264 }
1265
1266 static int
1267 parsestatfs(const u_int32_t *dp, int v3)
1268 {
1269 const struct nfs_statfs *sfsp;
1270 int er;
1271
1272 dp = parsestatus(dp, &er);
1273 if (dp == NULL)
1274 return (0);
1275 if (!v3 && er)
1276 return (1);
1277
1278 if (qflag)
1279 return(1);
1280
1281 if (v3) {
1282 if (vflag)
1283 printf(" POST:");
1284 if (!(dp = parse_post_op_attr(dp, vflag)))
1285 return (0);
1286 }
1287
1288 TCHECK2(*dp, (v3 ? NFSX_V3STATFS : NFSX_V2STATFS));
1289
1290 sfsp = (const struct nfs_statfs *)dp;
1291
1292 if (v3) {
1293 printf(" tbytes %" PRIu64 " fbytes %" PRIu64 " abytes %" PRIu64,
1294 EXTRACT_64BITS((u_int32_t *)&sfsp->sf_tbytes),
1295 EXTRACT_64BITS((u_int32_t *)&sfsp->sf_fbytes),
1296 EXTRACT_64BITS((u_int32_t *)&sfsp->sf_abytes));
1297 if (vflag) {
1298 printf(" tfiles %" PRIu64 " ffiles %" PRIu64 " afiles %" PRIu64 " invar %u",
1299 EXTRACT_64BITS((u_int32_t *)&sfsp->sf_tfiles),
1300 EXTRACT_64BITS((u_int32_t *)&sfsp->sf_ffiles),
1301 EXTRACT_64BITS((u_int32_t *)&sfsp->sf_afiles),
1302 EXTRACT_32BITS(&sfsp->sf_invarsec));
1303 }
1304 } else {
1305 printf(" tsize %d bsize %d blocks %d bfree %d bavail %d",
1306 EXTRACT_32BITS(&sfsp->sf_tsize),
1307 EXTRACT_32BITS(&sfsp->sf_bsize),
1308 EXTRACT_32BITS(&sfsp->sf_blocks),
1309 EXTRACT_32BITS(&sfsp->sf_bfree),
1310 EXTRACT_32BITS(&sfsp->sf_bavail));
1311 }
1312
1313 return (1);
1314 trunc:
1315 return (0);
1316 }
1317
1318 static int
1319 parserddires(const u_int32_t *dp)
1320 {
1321 int er;
1322
1323 dp = parsestatus(dp, &er);
1324 if (dp == NULL)
1325 return (0);
1326 if (er)
1327 return (1);
1328 if (qflag)
1329 return (1);
1330
1331 TCHECK(dp[2]);
1332 printf(" offset %x size %d ",
1333 EXTRACT_32BITS(&dp[0]), EXTRACT_32BITS(&dp[1]));
1334 if (dp[2] != 0)
1335 printf(" eof");
1336
1337 return (1);
1338 trunc:
1339 return (0);
1340 }
1341
1342 static const u_int32_t *
1343 parse_wcc_attr(const u_int32_t *dp)
1344 {
1345 printf(" sz %" PRIu64, EXTRACT_64BITS(&dp[0]));
1346 printf(" mtime %u.%06u ctime %u.%06u",
1347 EXTRACT_32BITS(&dp[2]), EXTRACT_32BITS(&dp[3]),
1348 EXTRACT_32BITS(&dp[4]), EXTRACT_32BITS(&dp[5]));
1349 return (dp + 6);
1350 }
1351
1352 /*
1353 * Pre operation attributes. Print only if vflag > 1.
1354 */
1355 static const u_int32_t *
1356 parse_pre_op_attr(const u_int32_t *dp, int verbose)
1357 {
1358 TCHECK(dp[0]);
1359 if (!EXTRACT_32BITS(&dp[0]))
1360 return (dp + 1);
1361 dp++;
1362 TCHECK2(*dp, 24);
1363 if (verbose > 1) {
1364 return parse_wcc_attr(dp);
1365 } else {
1366 /* If not verbose enough, just skip over wcc_attr */
1367 return (dp + 6);
1368 }
1369 trunc:
1370 return (NULL);
1371 }
1372
1373 /*
1374 * Post operation attributes are printed if vflag >= 1
1375 */
1376 static const u_int32_t *
1377 parse_post_op_attr(const u_int32_t *dp, int verbose)
1378 {
1379 TCHECK(dp[0]);
1380 if (!EXTRACT_32BITS(&dp[0]))
1381 return (dp + 1);
1382 dp++;
1383 if (verbose) {
1384 return parsefattr(dp, verbose, 1);
1385 } else
1386 return (dp + (NFSX_V3FATTR / sizeof (u_int32_t)));
1387 trunc:
1388 return (NULL);
1389 }
1390
1391 static const u_int32_t *
1392 parse_wcc_data(const u_int32_t *dp, int verbose)
1393 {
1394 if (verbose > 1)
1395 printf(" PRE:");
1396 if (!(dp = parse_pre_op_attr(dp, verbose)))
1397 return (0);
1398
1399 if (verbose)
1400 printf(" POST:");
1401 return parse_post_op_attr(dp, verbose);
1402 }
1403
1404 static const u_int32_t *
1405 parsecreateopres(const u_int32_t *dp, int verbose)
1406 {
1407 int er;
1408
1409 if (!(dp = parsestatus(dp, &er)))
1410 return (0);
1411 if (er)
1412 dp = parse_wcc_data(dp, verbose);
1413 else {
1414 TCHECK(dp[0]);
1415 if (!EXTRACT_32BITS(&dp[0]))
1416 return (dp + 1);
1417 dp++;
1418 if (!(dp = parsefh(dp, 1)))
1419 return (0);
1420 if (verbose) {
1421 if (!(dp = parse_post_op_attr(dp, verbose)))
1422 return (0);
1423 if (vflag > 1) {
1424 printf(" dir attr:");
1425 dp = parse_wcc_data(dp, verbose);
1426 }
1427 }
1428 }
1429 return (dp);
1430 trunc:
1431 return (NULL);
1432 }
1433
1434 static int
1435 parsewccres(const u_int32_t *dp, int verbose)
1436 {
1437 int er;
1438
1439 if (!(dp = parsestatus(dp, &er)))
1440 return (0);
1441 return parse_wcc_data(dp, verbose) != 0;
1442 }
1443
1444 static const u_int32_t *
1445 parsev3rddirres(const u_int32_t *dp, int verbose)
1446 {
1447 int er;
1448
1449 if (!(dp = parsestatus(dp, &er)))
1450 return (0);
1451 if (vflag)
1452 printf(" POST:");
1453 if (!(dp = parse_post_op_attr(dp, verbose)))
1454 return (0);
1455 if (er)
1456 return dp;
1457 if (vflag) {
1458 TCHECK(dp[1]);
1459 printf(" verf %08x%08x", dp[0], dp[1]);
1460 dp += 2;
1461 }
1462 return dp;
1463 trunc:
1464 return (NULL);
1465 }
1466
1467 static int
1468 parsefsinfo(const u_int32_t *dp)
1469 {
1470 struct nfsv3_fsinfo *sfp;
1471 int er;
1472
1473 if (!(dp = parsestatus(dp, &er)))
1474 return (0);
1475 if (vflag)
1476 printf(" POST:");
1477 if (!(dp = parse_post_op_attr(dp, vflag)))
1478 return (0);
1479 if (er)
1480 return (1);
1481
1482 sfp = (struct nfsv3_fsinfo *)dp;
1483 TCHECK(*sfp);
1484 printf(" rtmax %u rtpref %u wtmax %u wtpref %u dtpref %u",
1485 EXTRACT_32BITS(&sfp->fs_rtmax),
1486 EXTRACT_32BITS(&sfp->fs_rtpref),
1487 EXTRACT_32BITS(&sfp->fs_wtmax),
1488 EXTRACT_32BITS(&sfp->fs_wtpref),
1489 EXTRACT_32BITS(&sfp->fs_dtpref));
1490 if (vflag) {
1491 printf(" rtmult %u wtmult %u maxfsz %" PRIu64,
1492 EXTRACT_32BITS(&sfp->fs_rtmult),
1493 EXTRACT_32BITS(&sfp->fs_wtmult),
1494 EXTRACT_64BITS((u_int32_t *)&sfp->fs_maxfilesize));
1495 printf(" delta %u.%06u ",
1496 EXTRACT_32BITS(&sfp->fs_timedelta.nfsv3_sec),
1497 EXTRACT_32BITS(&sfp->fs_timedelta.nfsv3_nsec));
1498 }
1499 return (1);
1500 trunc:
1501 return (0);
1502 }
1503
1504 static int
1505 parsepathconf(const u_int32_t *dp)
1506 {
1507 int er;
1508 struct nfsv3_pathconf *spp;
1509
1510 if (!(dp = parsestatus(dp, &er)))
1511 return (0);
1512 if (vflag)
1513 printf(" POST:");
1514 if (!(dp = parse_post_op_attr(dp, vflag)))
1515 return (0);
1516 if (er)
1517 return (1);
1518
1519 spp = (struct nfsv3_pathconf *)dp;
1520 TCHECK(*spp);
1521
1522 printf(" linkmax %u namemax %u %s %s %s %s",
1523 EXTRACT_32BITS(&spp->pc_linkmax),
1524 EXTRACT_32BITS(&spp->pc_namemax),
1525 EXTRACT_32BITS(&spp->pc_notrunc) ? "notrunc" : "",
1526 EXTRACT_32BITS(&spp->pc_chownrestricted) ? "chownres" : "",
1527 EXTRACT_32BITS(&spp->pc_caseinsensitive) ? "igncase" : "",
1528 EXTRACT_32BITS(&spp->pc_casepreserving) ? "keepcase" : "");
1529 return (1);
1530 trunc:
1531 return (0);
1532 }
1533
1534 static void
1535 interp_reply(const struct sunrpc_msg *rp, u_int32_t proc, u_int32_t vers, int length)
1536 {
1537 register const u_int32_t *dp;
1538 register int v3;
1539 int er;
1540
1541 v3 = (vers == NFS_VER3);
1542
1543 if (!v3 && proc < NFS_NPROCS)
1544 proc = nfsv3_procid[proc];
1545
1546 switch (proc) {
1547
1548 case NFSPROC_NOOP:
1549 printf(" nop");
1550 return;
1551
1552 case NFSPROC_NULL:
1553 printf(" null");
1554 return;
1555
1556 case NFSPROC_GETATTR:
1557 printf(" getattr");
1558 dp = parserep(rp, length);
1559 if (dp != NULL && parseattrstat(dp, !qflag, v3) != 0)
1560 return;
1561 break;
1562
1563 case NFSPROC_SETATTR:
1564 printf(" setattr");
1565 if (!(dp = parserep(rp, length)))
1566 return;
1567 if (v3) {
1568 if (parsewccres(dp, vflag))
1569 return;
1570 } else {
1571 if (parseattrstat(dp, !qflag, 0) != 0)
1572 return;
1573 }
1574 break;
1575
1576 case NFSPROC_LOOKUP:
1577 printf(" lookup");
1578 if (!(dp = parserep(rp, length)))
1579 break;
1580 if (v3) {
1581 if (!(dp = parsestatus(dp, &er)))
1582 break;
1583 if (er) {
1584 if (vflag > 1) {
1585 printf(" post dattr:");
1586 dp = parse_post_op_attr(dp, vflag);
1587 }
1588 } else {
1589 if (!(dp = parsefh(dp, v3)))
1590 break;
1591 if ((dp = parse_post_op_attr(dp, vflag)) &&
1592 vflag > 1) {
1593 printf(" post dattr:");
1594 dp = parse_post_op_attr(dp, vflag);
1595 }
1596 }
1597 if (dp)
1598 return;
1599 } else {
1600 if (parsediropres(dp) != 0)
1601 return;
1602 }
1603 break;
1604
1605 case NFSPROC_ACCESS:
1606 printf(" access");
1607 if (!(dp = parserep(rp, length)))
1608 break;
1609 if (!(dp = parsestatus(dp, &er)))
1610 break;
1611 if (vflag)
1612 printf(" attr:");
1613 if (!(dp = parse_post_op_attr(dp, vflag)))
1614 break;
1615 if (!er)
1616 printf(" c %04x", EXTRACT_32BITS(&dp[0]));
1617 return;
1618
1619 case NFSPROC_READLINK:
1620 printf(" readlink");
1621 dp = parserep(rp, length);
1622 if (dp != NULL && parselinkres(dp, v3) != 0)
1623 return;
1624 break;
1625
1626 case NFSPROC_READ:
1627 printf(" read");
1628 if (!(dp = parserep(rp, length)))
1629 break;
1630 if (v3) {
1631 if (!(dp = parsestatus(dp, &er)))
1632 break;
1633 if (!(dp = parse_post_op_attr(dp, vflag)))
1634 break;
1635 if (er)
1636 return;
1637 if (vflag) {
1638 TCHECK(dp[1]);
1639 printf(" %u bytes", EXTRACT_32BITS(&dp[0]));
1640 if (EXTRACT_32BITS(&dp[1]))
1641 printf(" EOF");
1642 }
1643 return;
1644 } else {
1645 if (parseattrstat(dp, vflag, 0) != 0)
1646 return;
1647 }
1648 break;
1649
1650 case NFSPROC_WRITE:
1651 printf(" write");
1652 if (!(dp = parserep(rp, length)))
1653 break;
1654 if (v3) {
1655 if (!(dp = parsestatus(dp, &er)))
1656 break;
1657 if (!(dp = parse_wcc_data(dp, vflag)))
1658 break;
1659 if (er)
1660 return;
1661 if (vflag) {
1662 TCHECK(dp[0]);
1663 printf(" %u bytes", EXTRACT_32BITS(&dp[0]));
1664 if (vflag > 1) {
1665 TCHECK(dp[1]);
1666 printf(" <%s>",
1667 tok2str(nfsv3_writemodes,
1668 NULL, EXTRACT_32BITS(&dp[1])));
1669 }
1670 return;
1671 }
1672 } else {
1673 if (parseattrstat(dp, vflag, v3) != 0)
1674 return;
1675 }
1676 break;
1677
1678 case NFSPROC_CREATE:
1679 printf(" create");
1680 if (!(dp = parserep(rp, length)))
1681 break;
1682 if (v3) {
1683 if (parsecreateopres(dp, vflag) != 0)
1684 return;
1685 } else {
1686 if (parsediropres(dp) != 0)
1687 return;
1688 }
1689 break;
1690
1691 case NFSPROC_MKDIR:
1692 printf(" mkdir");
1693 if (!(dp = parserep(rp, length)))
1694 break;
1695 if (v3) {
1696 if (parsecreateopres(dp, vflag) != 0)
1697 return;
1698 } else {
1699 if (parsediropres(dp) != 0)
1700 return;
1701 }
1702 break;
1703
1704 case NFSPROC_SYMLINK:
1705 printf(" symlink");
1706 if (!(dp = parserep(rp, length)))
1707 break;
1708 if (v3) {
1709 if (parsecreateopres(dp, vflag) != 0)
1710 return;
1711 } else {
1712 if (parsestatus(dp, &er) != 0)
1713 return;
1714 }
1715 break;
1716
1717 case NFSPROC_MKNOD:
1718 printf(" mknod");
1719 if (!(dp = parserep(rp, length)))
1720 break;
1721 if (parsecreateopres(dp, vflag) != 0)
1722 return;
1723 break;
1724
1725 case NFSPROC_REMOVE:
1726 printf(" remove");
1727 if (!(dp = parserep(rp, length)))
1728 break;
1729 if (v3) {
1730 if (parsewccres(dp, vflag))
1731 return;
1732 } else {
1733 if (parsestatus(dp, &er) != 0)
1734 return;
1735 }
1736 break;
1737
1738 case NFSPROC_RMDIR:
1739 printf(" rmdir");
1740 if (!(dp = parserep(rp, length)))
1741 break;
1742 if (v3) {
1743 if (parsewccres(dp, vflag))
1744 return;
1745 } else {
1746 if (parsestatus(dp, &er) != 0)
1747 return;
1748 }
1749 break;
1750
1751 case NFSPROC_RENAME:
1752 printf(" rename");
1753 if (!(dp = parserep(rp, length)))
1754 break;
1755 if (v3) {
1756 if (!(dp = parsestatus(dp, &er)))
1757 break;
1758 if (vflag) {
1759 printf(" from:");
1760 if (!(dp = parse_wcc_data(dp, vflag)))
1761 break;
1762 printf(" to:");
1763 if (!(dp = parse_wcc_data(dp, vflag)))
1764 break;
1765 }
1766 return;
1767 } else {
1768 if (parsestatus(dp, &er) != 0)
1769 return;
1770 }
1771 break;
1772
1773 case NFSPROC_LINK:
1774 printf(" link");
1775 if (!(dp = parserep(rp, length)))
1776 break;
1777 if (v3) {
1778 if (!(dp = parsestatus(dp, &er)))
1779 break;
1780 if (vflag) {
1781 printf(" file POST:");
1782 if (!(dp = parse_post_op_attr(dp, vflag)))
1783 break;
1784 printf(" dir:");
1785 if (!(dp = parse_wcc_data(dp, vflag)))
1786 break;
1787 return;
1788 }
1789 } else {
1790 if (parsestatus(dp, &er) != 0)
1791 return;
1792 }
1793 break;
1794
1795 case NFSPROC_READDIR:
1796 printf(" readdir");
1797 if (!(dp = parserep(rp, length)))
1798 break;
1799 if (v3) {
1800 if (parsev3rddirres(dp, vflag))
1801 return;
1802 } else {
1803 if (parserddires(dp) != 0)
1804 return;
1805 }
1806 break;
1807
1808 case NFSPROC_READDIRPLUS:
1809 printf(" readdirplus");
1810 if (!(dp = parserep(rp, length)))
1811 break;
1812 if (parsev3rddirres(dp, vflag))
1813 return;
1814 break;
1815
1816 case NFSPROC_FSSTAT:
1817 printf(" fsstat");
1818 dp = parserep(rp, length);
1819 if (dp != NULL && parsestatfs(dp, v3) != 0)
1820 return;
1821 break;
1822
1823 case NFSPROC_FSINFO:
1824 printf(" fsinfo");
1825 dp = parserep(rp, length);
1826 if (dp != NULL && parsefsinfo(dp) != 0)
1827 return;
1828 break;
1829
1830 case NFSPROC_PATHCONF:
1831 printf(" pathconf");
1832 dp = parserep(rp, length);
1833 if (dp != NULL && parsepathconf(dp) != 0)
1834 return;
1835 break;
1836
1837 case NFSPROC_COMMIT:
1838 printf(" commit");
1839 dp = parserep(rp, length);
1840 if (dp != NULL && parsewccres(dp, vflag) != 0)
1841 return;
1842 break;
1843
1844 default:
1845 printf(" proc-%u", proc);
1846 return;
1847 }
1848 trunc:
1849 if (!nfserr)
1850 fputs(" [|nfs]", stdout);
1851 }
DragonFly BSD