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 } 1852