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