1 /* 2 * Copyright: (c) 2000 United States Government as represented by the 3 * Secretary of the Navy. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in 13 * the documentation and/or other materials provided with the 14 * distribution. 15 * 3. The names of the authors may not be used to endorse or promote 16 * products derived from this software without specific prior 17 * written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR 20 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED 21 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. 22 */ 23 /* 24 * This code unmangles RX packets. RX is the mutant form of RPC that AFS 25 * uses to communicate between clients and servers. 26 * 27 * In this code, I mainly concern myself with decoding the AFS calls, not 28 * with the guts of RX, per se. 29 * 30 * Bah. If I never look at rx_packet.h again, it will be too soon. 31 * 32 * Ken Hornstein <kenh@cmf.nrl.navy.mil> 33 */ 34 35 #define NETDISSECT_REWORKED 36 #ifdef HAVE_CONFIG_H 37 #include "config.h" 38 #endif 39 40 #include <stdio.h> 41 #include <stdlib.h> 42 #include <string.h> 43 #include <tcpdump-stdinc.h> 44 45 #include "interface.h" 46 #include "addrtoname.h" 47 #include "extract.h" 48 49 #include "ip.h" 50 51 #define FS_RX_PORT 7000 52 #define CB_RX_PORT 7001 53 #define PROT_RX_PORT 7002 54 #define VLDB_RX_PORT 7003 55 #define KAUTH_RX_PORT 7004 56 #define VOL_RX_PORT 7005 57 #define ERROR_RX_PORT 7006 /* Doesn't seem to be used */ 58 #define BOS_RX_PORT 7007 59 60 #define AFSNAMEMAX 256 61 #define AFSOPAQUEMAX 1024 62 #define PRNAMEMAX 64 63 #define VLNAMEMAX 65 64 #define KANAMEMAX 64 65 #define BOSNAMEMAX 256 66 67 #define PRSFS_READ 1 /* Read files */ 68 #define PRSFS_WRITE 2 /* Write files */ 69 #define PRSFS_INSERT 4 /* Insert files into a directory */ 70 #define PRSFS_LOOKUP 8 /* Lookup files into a directory */ 71 #define PRSFS_DELETE 16 /* Delete files */ 72 #define PRSFS_LOCK 32 /* Lock files */ 73 #define PRSFS_ADMINISTER 64 /* Change ACL's */ 74 75 struct rx_header { 76 uint32_t epoch; 77 uint32_t cid; 78 uint32_t callNumber; 79 uint32_t seq; 80 uint32_t serial; 81 uint8_t type; 82 #define RX_PACKET_TYPE_DATA 1 83 #define RX_PACKET_TYPE_ACK 2 84 #define RX_PACKET_TYPE_BUSY 3 85 #define RX_PACKET_TYPE_ABORT 4 86 #define RX_PACKET_TYPE_ACKALL 5 87 #define RX_PACKET_TYPE_CHALLENGE 6 88 #define RX_PACKET_TYPE_RESPONSE 7 89 #define RX_PACKET_TYPE_DEBUG 8 90 #define RX_PACKET_TYPE_PARAMS 9 91 #define RX_PACKET_TYPE_VERSION 13 92 uint8_t flags; 93 #define RX_CLIENT_INITIATED 1 94 #define RX_REQUEST_ACK 2 95 #define RX_LAST_PACKET 4 96 #define RX_MORE_PACKETS 8 97 #define RX_FREE_PACKET 16 98 #define RX_SLOW_START_OK 32 99 #define RX_JUMBO_PACKET 32 100 uint8_t userStatus; 101 uint8_t securityIndex; 102 uint16_t spare; /* How clever: even though the AFS */ 103 uint16_t serviceId; /* header files indicate that the */ 104 }; /* serviceId is first, it's really */ 105 /* encoded _after_ the spare field */ 106 /* I wasted a day figuring that out! */ 107 108 #define NUM_RX_FLAGS 7 109 110 #define RX_MAXACKS 255 111 112 struct rx_ackPacket { 113 uint16_t bufferSpace; /* Number of packet buffers available */ 114 uint16_t maxSkew; /* Max diff between ack'd packet and */ 115 /* highest packet received */ 116 uint32_t firstPacket; /* The first packet in ack list */ 117 uint32_t previousPacket; /* Previous packet recv'd (obsolete) */ 118 uint32_t serial; /* # of packet that prompted the ack */ 119 uint8_t reason; /* Reason for acknowledgement */ 120 uint8_t nAcks; /* Number of acknowledgements */ 121 uint8_t acks[RX_MAXACKS]; /* Up to RX_MAXACKS acknowledgements */ 122 }; 123 124 /* 125 * Values for the acks array 126 */ 127 128 #define RX_ACK_TYPE_NACK 0 /* Don't have this packet */ 129 #define RX_ACK_TYPE_ACK 1 /* I have this packet */ 130 131 static const struct tok rx_types[] = { 132 { RX_PACKET_TYPE_DATA, "data" }, 133 { RX_PACKET_TYPE_ACK, "ack" }, 134 { RX_PACKET_TYPE_BUSY, "busy" }, 135 { RX_PACKET_TYPE_ABORT, "abort" }, 136 { RX_PACKET_TYPE_ACKALL, "ackall" }, 137 { RX_PACKET_TYPE_CHALLENGE, "challenge" }, 138 { RX_PACKET_TYPE_RESPONSE, "response" }, 139 { RX_PACKET_TYPE_DEBUG, "debug" }, 140 { RX_PACKET_TYPE_PARAMS, "params" }, 141 { RX_PACKET_TYPE_VERSION, "version" }, 142 { 0, NULL }, 143 }; 144 145 static const struct double_tok { 146 int flag; /* Rx flag */ 147 int packetType; /* Packet type */ 148 const char *s; /* Flag string */ 149 } rx_flags[] = { 150 { RX_CLIENT_INITIATED, 0, "client-init" }, 151 { RX_REQUEST_ACK, 0, "req-ack" }, 152 { RX_LAST_PACKET, 0, "last-pckt" }, 153 { RX_MORE_PACKETS, 0, "more-pckts" }, 154 { RX_FREE_PACKET, 0, "free-pckt" }, 155 { RX_SLOW_START_OK, RX_PACKET_TYPE_ACK, "slow-start" }, 156 { RX_JUMBO_PACKET, RX_PACKET_TYPE_DATA, "jumbogram" } 157 }; 158 159 static const struct tok fs_req[] = { 160 { 130, "fetch-data" }, 161 { 131, "fetch-acl" }, 162 { 132, "fetch-status" }, 163 { 133, "store-data" }, 164 { 134, "store-acl" }, 165 { 135, "store-status" }, 166 { 136, "remove-file" }, 167 { 137, "create-file" }, 168 { 138, "rename" }, 169 { 139, "symlink" }, 170 { 140, "link" }, 171 { 141, "makedir" }, 172 { 142, "rmdir" }, 173 { 143, "oldsetlock" }, 174 { 144, "oldextlock" }, 175 { 145, "oldrellock" }, 176 { 146, "get-stats" }, 177 { 147, "give-cbs" }, 178 { 148, "get-vlinfo" }, 179 { 149, "get-vlstats" }, 180 { 150, "set-vlstats" }, 181 { 151, "get-rootvl" }, 182 { 152, "check-token" }, 183 { 153, "get-time" }, 184 { 154, "nget-vlinfo" }, 185 { 155, "bulk-stat" }, 186 { 156, "setlock" }, 187 { 157, "extlock" }, 188 { 158, "rellock" }, 189 { 159, "xstat-ver" }, 190 { 160, "get-xstat" }, 191 { 161, "dfs-lookup" }, 192 { 162, "dfs-flushcps" }, 193 { 163, "dfs-symlink" }, 194 { 220, "residency" }, 195 { 65536, "inline-bulk-status" }, 196 { 65537, "fetch-data-64" }, 197 { 65538, "store-data-64" }, 198 { 65539, "give-up-all-cbs" }, 199 { 65540, "get-caps" }, 200 { 65541, "cb-rx-conn-addr" }, 201 { 0, NULL }, 202 }; 203 204 static const struct tok cb_req[] = { 205 { 204, "callback" }, 206 { 205, "initcb" }, 207 { 206, "probe" }, 208 { 207, "getlock" }, 209 { 208, "getce" }, 210 { 209, "xstatver" }, 211 { 210, "getxstat" }, 212 { 211, "initcb2" }, 213 { 212, "whoareyou" }, 214 { 213, "initcb3" }, 215 { 214, "probeuuid" }, 216 { 215, "getsrvprefs" }, 217 { 216, "getcellservdb" }, 218 { 217, "getlocalcell" }, 219 { 218, "getcacheconf" }, 220 { 65536, "getce64" }, 221 { 65537, "getcellbynum" }, 222 { 65538, "tellmeaboutyourself" }, 223 { 0, NULL }, 224 }; 225 226 static const struct tok pt_req[] = { 227 { 500, "new-user" }, 228 { 501, "where-is-it" }, 229 { 502, "dump-entry" }, 230 { 503, "add-to-group" }, 231 { 504, "name-to-id" }, 232 { 505, "id-to-name" }, 233 { 506, "delete" }, 234 { 507, "remove-from-group" }, 235 { 508, "get-cps" }, 236 { 509, "new-entry" }, 237 { 510, "list-max" }, 238 { 511, "set-max" }, 239 { 512, "list-entry" }, 240 { 513, "change-entry" }, 241 { 514, "list-elements" }, 242 { 515, "same-mbr-of" }, 243 { 516, "set-fld-sentry" }, 244 { 517, "list-owned" }, 245 { 518, "get-cps2" }, 246 { 519, "get-host-cps" }, 247 { 520, "update-entry" }, 248 { 521, "list-entries" }, 249 { 530, "list-super-groups" }, 250 { 0, NULL }, 251 }; 252 253 static const struct tok vldb_req[] = { 254 { 501, "create-entry" }, 255 { 502, "delete-entry" }, 256 { 503, "get-entry-by-id" }, 257 { 504, "get-entry-by-name" }, 258 { 505, "get-new-volume-id" }, 259 { 506, "replace-entry" }, 260 { 507, "update-entry" }, 261 { 508, "setlock" }, 262 { 509, "releaselock" }, 263 { 510, "list-entry" }, 264 { 511, "list-attrib" }, 265 { 512, "linked-list" }, 266 { 513, "get-stats" }, 267 { 514, "probe" }, 268 { 515, "get-addrs" }, 269 { 516, "change-addr" }, 270 { 517, "create-entry-n" }, 271 { 518, "get-entry-by-id-n" }, 272 { 519, "get-entry-by-name-n" }, 273 { 520, "replace-entry-n" }, 274 { 521, "list-entry-n" }, 275 { 522, "list-attrib-n" }, 276 { 523, "linked-list-n" }, 277 { 524, "update-entry-by-name" }, 278 { 525, "create-entry-u" }, 279 { 526, "get-entry-by-id-u" }, 280 { 527, "get-entry-by-name-u" }, 281 { 528, "replace-entry-u" }, 282 { 529, "list-entry-u" }, 283 { 530, "list-attrib-u" }, 284 { 531, "linked-list-u" }, 285 { 532, "regaddr" }, 286 { 533, "get-addrs-u" }, 287 { 534, "list-attrib-n2" }, 288 { 0, NULL }, 289 }; 290 291 static const struct tok kauth_req[] = { 292 { 1, "auth-old" }, 293 { 21, "authenticate" }, 294 { 22, "authenticate-v2" }, 295 { 2, "change-pw" }, 296 { 3, "get-ticket-old" }, 297 { 23, "get-ticket" }, 298 { 4, "set-pw" }, 299 { 5, "set-fields" }, 300 { 6, "create-user" }, 301 { 7, "delete-user" }, 302 { 8, "get-entry" }, 303 { 9, "list-entry" }, 304 { 10, "get-stats" }, 305 { 11, "debug" }, 306 { 12, "get-pw" }, 307 { 13, "get-random-key" }, 308 { 14, "unlock" }, 309 { 15, "lock-status" }, 310 { 0, NULL }, 311 }; 312 313 static const struct tok vol_req[] = { 314 { 100, "create-volume" }, 315 { 101, "delete-volume" }, 316 { 102, "restore" }, 317 { 103, "forward" }, 318 { 104, "end-trans" }, 319 { 105, "clone" }, 320 { 106, "set-flags" }, 321 { 107, "get-flags" }, 322 { 108, "trans-create" }, 323 { 109, "dump" }, 324 { 110, "get-nth-volume" }, 325 { 111, "set-forwarding" }, 326 { 112, "get-name" }, 327 { 113, "get-status" }, 328 { 114, "sig-restore" }, 329 { 115, "list-partitions" }, 330 { 116, "list-volumes" }, 331 { 117, "set-id-types" }, 332 { 118, "monitor" }, 333 { 119, "partition-info" }, 334 { 120, "reclone" }, 335 { 121, "list-one-volume" }, 336 { 122, "nuke" }, 337 { 123, "set-date" }, 338 { 124, "x-list-volumes" }, 339 { 125, "x-list-one-volume" }, 340 { 126, "set-info" }, 341 { 127, "x-list-partitions" }, 342 { 128, "forward-multiple" }, 343 { 65536, "convert-ro" }, 344 { 65537, "get-size" }, 345 { 65538, "dump-v2" }, 346 { 0, NULL }, 347 }; 348 349 static const struct tok bos_req[] = { 350 { 80, "create-bnode" }, 351 { 81, "delete-bnode" }, 352 { 82, "set-status" }, 353 { 83, "get-status" }, 354 { 84, "enumerate-instance" }, 355 { 85, "get-instance-info" }, 356 { 86, "get-instance-parm" }, 357 { 87, "add-superuser" }, 358 { 88, "delete-superuser" }, 359 { 89, "list-superusers" }, 360 { 90, "list-keys" }, 361 { 91, "add-key" }, 362 { 92, "delete-key" }, 363 { 93, "set-cell-name" }, 364 { 94, "get-cell-name" }, 365 { 95, "get-cell-host" }, 366 { 96, "add-cell-host" }, 367 { 97, "delete-cell-host" }, 368 { 98, "set-t-status" }, 369 { 99, "shutdown-all" }, 370 { 100, "restart-all" }, 371 { 101, "startup-all" }, 372 { 102, "set-noauth-flag" }, 373 { 103, "re-bozo" }, 374 { 104, "restart" }, 375 { 105, "start-bozo-install" }, 376 { 106, "uninstall" }, 377 { 107, "get-dates" }, 378 { 108, "exec" }, 379 { 109, "prune" }, 380 { 110, "set-restart-time" }, 381 { 111, "get-restart-time" }, 382 { 112, "start-bozo-log" }, 383 { 113, "wait-all" }, 384 { 114, "get-instance-strings" }, 385 { 115, "get-restricted" }, 386 { 116, "set-restricted" }, 387 { 0, NULL }, 388 }; 389 390 static const struct tok ubik_req[] = { 391 { 10000, "vote-beacon" }, 392 { 10001, "vote-debug-old" }, 393 { 10002, "vote-sdebug-old" }, 394 { 10003, "vote-getsyncsite" }, 395 { 10004, "vote-debug" }, 396 { 10005, "vote-sdebug" }, 397 { 10006, "vote-xdebug" }, 398 { 10007, "vote-xsdebug" }, 399 { 20000, "disk-begin" }, 400 { 20001, "disk-commit" }, 401 { 20002, "disk-lock" }, 402 { 20003, "disk-write" }, 403 { 20004, "disk-getversion" }, 404 { 20005, "disk-getfile" }, 405 { 20006, "disk-sendfile" }, 406 { 20007, "disk-abort" }, 407 { 20008, "disk-releaselocks" }, 408 { 20009, "disk-truncate" }, 409 { 20010, "disk-probe" }, 410 { 20011, "disk-writev" }, 411 { 20012, "disk-interfaceaddr" }, 412 { 20013, "disk-setversion" }, 413 { 0, NULL }, 414 }; 415 416 #define VOTE_LOW 10000 417 #define VOTE_HIGH 10007 418 #define DISK_LOW 20000 419 #define DISK_HIGH 20013 420 421 static const struct tok cb_types[] = { 422 { 1, "exclusive" }, 423 { 2, "shared" }, 424 { 3, "dropped" }, 425 { 0, NULL }, 426 }; 427 428 static const struct tok ubik_lock_types[] = { 429 { 1, "read" }, 430 { 2, "write" }, 431 { 3, "wait" }, 432 { 0, NULL }, 433 }; 434 435 static const char *voltype[] = { "read-write", "read-only", "backup" }; 436 437 static const struct tok afs_fs_errors[] = { 438 { 101, "salvage volume" }, 439 { 102, "no such vnode" }, 440 { 103, "no such volume" }, 441 { 104, "volume exist" }, 442 { 105, "no service" }, 443 { 106, "volume offline" }, 444 { 107, "voline online" }, 445 { 108, "diskfull" }, 446 { 109, "diskquota exceeded" }, 447 { 110, "volume busy" }, 448 { 111, "volume moved" }, 449 { 112, "AFS IO error" }, 450 { 0xffffff9c, "restarting fileserver" }, /* -100, sic! */ 451 { 0, NULL } 452 }; 453 454 /* 455 * Reasons for acknowledging a packet 456 */ 457 458 static const struct tok rx_ack_reasons[] = { 459 { 1, "ack requested" }, 460 { 2, "duplicate packet" }, 461 { 3, "out of sequence" }, 462 { 4, "exceeds window" }, 463 { 5, "no buffer space" }, 464 { 6, "ping" }, 465 { 7, "ping response" }, 466 { 8, "delay" }, 467 { 9, "idle" }, 468 { 0, NULL }, 469 }; 470 471 /* 472 * Cache entries we keep around so we can figure out the RX opcode 473 * numbers for replies. This allows us to make sense of RX reply packets. 474 */ 475 476 struct rx_cache_entry { 477 uint32_t callnum; /* Call number (net order) */ 478 struct in_addr client; /* client IP address (net order) */ 479 struct in_addr server; /* server IP address (net order) */ 480 int dport; /* server port (host order) */ 481 u_short serviceId; /* Service identifier (net order) */ 482 uint32_t opcode; /* RX opcode (host order) */ 483 }; 484 485 #define RX_CACHE_SIZE 64 486 487 static struct rx_cache_entry rx_cache[RX_CACHE_SIZE]; 488 489 static int rx_cache_next = 0; 490 static int rx_cache_hint = 0; 491 static void rx_cache_insert(netdissect_options *, const u_char *, const struct ip *, int); 492 static int rx_cache_find(const struct rx_header *, const struct ip *, 493 int, int32_t *); 494 495 static void fs_print(netdissect_options *, const u_char *, int); 496 static void fs_reply_print(netdissect_options *, const u_char *, int, int32_t); 497 static void acl_print(netdissect_options *, u_char *, int, u_char *); 498 static void cb_print(netdissect_options *, const u_char *, int); 499 static void cb_reply_print(netdissect_options *, const u_char *, int, int32_t); 500 static void prot_print(netdissect_options *, const u_char *, int); 501 static void prot_reply_print(netdissect_options *, const u_char *, int, int32_t); 502 static void vldb_print(netdissect_options *, const u_char *, int); 503 static void vldb_reply_print(netdissect_options *, const u_char *, int, int32_t); 504 static void kauth_print(netdissect_options *, const u_char *, int); 505 static void kauth_reply_print(netdissect_options *, const u_char *, int, int32_t); 506 static void vol_print(netdissect_options *, const u_char *, int); 507 static void vol_reply_print(netdissect_options *, const u_char *, int, int32_t); 508 static void bos_print(netdissect_options *, const u_char *, int); 509 static void bos_reply_print(netdissect_options *, const u_char *, int, int32_t); 510 static void ubik_print(netdissect_options *, const u_char *); 511 static void ubik_reply_print(netdissect_options *, const u_char *, int, int32_t); 512 513 static void rx_ack_print(netdissect_options *, const u_char *, int); 514 515 static int is_ubik(uint32_t); 516 517 /* 518 * Handle the rx-level packet. See if we know what port it's going to so 519 * we can peek at the afs call inside 520 */ 521 522 void 523 rx_print(netdissect_options *ndo, 524 register const u_char *bp, int length, int sport, int dport, 525 u_char *bp2) 526 { 527 register struct rx_header *rxh; 528 int i; 529 int32_t opcode; 530 531 if (ndo->ndo_snapend - bp < (int)sizeof (struct rx_header)) { 532 ND_PRINT((ndo, " [|rx] (%d)", length)); 533 return; 534 } 535 536 rxh = (struct rx_header *) bp; 537 538 ND_PRINT((ndo, " rx %s", tok2str(rx_types, "type %d", rxh->type))); 539 540 if (ndo->ndo_vflag) { 541 int firstflag = 0; 542 543 if (ndo->ndo_vflag > 1) 544 ND_PRINT((ndo, " cid %08x call# %d", 545 (int) EXTRACT_32BITS(&rxh->cid), 546 (int) EXTRACT_32BITS(&rxh->callNumber))); 547 548 ND_PRINT((ndo, " seq %d ser %d", 549 (int) EXTRACT_32BITS(&rxh->seq), 550 (int) EXTRACT_32BITS(&rxh->serial))); 551 552 if (ndo->ndo_vflag > 2) 553 ND_PRINT((ndo, " secindex %d serviceid %hu", 554 (int) rxh->securityIndex, 555 EXTRACT_16BITS(&rxh->serviceId))); 556 557 if (ndo->ndo_vflag > 1) 558 for (i = 0; i < NUM_RX_FLAGS; i++) { 559 if (rxh->flags & rx_flags[i].flag && 560 (!rx_flags[i].packetType || 561 rxh->type == rx_flags[i].packetType)) { 562 if (!firstflag) { 563 firstflag = 1; 564 ND_PRINT((ndo, " ")); 565 } else { 566 ND_PRINT((ndo, ",")); 567 } 568 ND_PRINT((ndo, "<%s>", rx_flags[i].s)); 569 } 570 } 571 } 572 573 /* 574 * Try to handle AFS calls that we know about. Check the destination 575 * port and make sure it's a data packet. Also, make sure the 576 * seq number is 1 (because otherwise it's a continuation packet, 577 * and we can't interpret that). Also, seems that reply packets 578 * do not have the client-init flag set, so we check for that 579 * as well. 580 */ 581 582 if (rxh->type == RX_PACKET_TYPE_DATA && 583 EXTRACT_32BITS(&rxh->seq) == 1 && 584 rxh->flags & RX_CLIENT_INITIATED) { 585 586 /* 587 * Insert this call into the call cache table, so we 588 * have a chance to print out replies 589 */ 590 591 rx_cache_insert(ndo, bp, (const struct ip *) bp2, dport); 592 593 switch (dport) { 594 case FS_RX_PORT: /* AFS file service */ 595 fs_print(ndo, bp, length); 596 break; 597 case CB_RX_PORT: /* AFS callback service */ 598 cb_print(ndo, bp, length); 599 break; 600 case PROT_RX_PORT: /* AFS protection service */ 601 prot_print(ndo, bp, length); 602 break; 603 case VLDB_RX_PORT: /* AFS VLDB service */ 604 vldb_print(ndo, bp, length); 605 break; 606 case KAUTH_RX_PORT: /* AFS Kerberos auth service */ 607 kauth_print(ndo, bp, length); 608 break; 609 case VOL_RX_PORT: /* AFS Volume service */ 610 vol_print(ndo, bp, length); 611 break; 612 case BOS_RX_PORT: /* AFS BOS service */ 613 bos_print(ndo, bp, length); 614 break; 615 default: 616 ; 617 } 618 619 /* 620 * If it's a reply (client-init is _not_ set, but seq is one) 621 * then look it up in the cache. If we find it, call the reply 622 * printing functions Note that we handle abort packets here, 623 * because printing out the return code can be useful at times. 624 */ 625 626 } else if (((rxh->type == RX_PACKET_TYPE_DATA && 627 EXTRACT_32BITS(&rxh->seq) == 1) || 628 rxh->type == RX_PACKET_TYPE_ABORT) && 629 (rxh->flags & RX_CLIENT_INITIATED) == 0 && 630 rx_cache_find(rxh, (const struct ip *) bp2, 631 sport, &opcode)) { 632 633 switch (sport) { 634 case FS_RX_PORT: /* AFS file service */ 635 fs_reply_print(ndo, bp, length, opcode); 636 break; 637 case CB_RX_PORT: /* AFS callback service */ 638 cb_reply_print(ndo, bp, length, opcode); 639 break; 640 case PROT_RX_PORT: /* AFS PT service */ 641 prot_reply_print(ndo, bp, length, opcode); 642 break; 643 case VLDB_RX_PORT: /* AFS VLDB service */ 644 vldb_reply_print(ndo, bp, length, opcode); 645 break; 646 case KAUTH_RX_PORT: /* AFS Kerberos auth service */ 647 kauth_reply_print(ndo, bp, length, opcode); 648 break; 649 case VOL_RX_PORT: /* AFS Volume service */ 650 vol_reply_print(ndo, bp, length, opcode); 651 break; 652 case BOS_RX_PORT: /* AFS BOS service */ 653 bos_reply_print(ndo, bp, length, opcode); 654 break; 655 default: 656 ; 657 } 658 659 /* 660 * If it's an RX ack packet, then use the appropriate ack decoding 661 * function (there isn't any service-specific information in the 662 * ack packet, so we can use one for all AFS services) 663 */ 664 665 } else if (rxh->type == RX_PACKET_TYPE_ACK) 666 rx_ack_print(ndo, bp, length); 667 668 669 ND_PRINT((ndo, " (%d)", length)); 670 } 671 672 /* 673 * Insert an entry into the cache. Taken from print-nfs.c 674 */ 675 676 static void 677 rx_cache_insert(netdissect_options *ndo, 678 const u_char *bp, const struct ip *ip, int dport) 679 { 680 struct rx_cache_entry *rxent; 681 const struct rx_header *rxh = (const struct rx_header *) bp; 682 683 if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) 684 return; 685 686 rxent = &rx_cache[rx_cache_next]; 687 688 if (++rx_cache_next >= RX_CACHE_SIZE) 689 rx_cache_next = 0; 690 691 rxent->callnum = rxh->callNumber; 692 rxent->client = ip->ip_src; 693 rxent->server = ip->ip_dst; 694 rxent->dport = dport; 695 rxent->serviceId = rxh->serviceId; 696 rxent->opcode = EXTRACT_32BITS(bp + sizeof(struct rx_header)); 697 } 698 699 /* 700 * Lookup an entry in the cache. Also taken from print-nfs.c 701 * 702 * Note that because this is a reply, we're looking at the _source_ 703 * port. 704 */ 705 706 static int 707 rx_cache_find(const struct rx_header *rxh, const struct ip *ip, int sport, 708 int32_t *opcode) 709 { 710 int i; 711 struct rx_cache_entry *rxent; 712 uint32_t clip = ip->ip_dst.s_addr; 713 uint32_t sip = ip->ip_src.s_addr; 714 715 /* Start the search where we last left off */ 716 717 i = rx_cache_hint; 718 do { 719 rxent = &rx_cache[i]; 720 if (rxent->callnum == rxh->callNumber && 721 rxent->client.s_addr == clip && 722 rxent->server.s_addr == sip && 723 rxent->serviceId == rxh->serviceId && 724 rxent->dport == sport) { 725 726 /* We got a match! */ 727 728 rx_cache_hint = i; 729 *opcode = rxent->opcode; 730 return(1); 731 } 732 if (++i >= RX_CACHE_SIZE) 733 i = 0; 734 } while (i != rx_cache_hint); 735 736 /* Our search failed */ 737 return(0); 738 } 739 740 /* 741 * These extrememly grody macros handle the printing of various AFS stuff. 742 */ 743 744 #define FIDOUT() { unsigned long n1, n2, n3; \ 745 ND_TCHECK2(bp[0], sizeof(int32_t) * 3); \ 746 n1 = EXTRACT_32BITS(bp); \ 747 bp += sizeof(int32_t); \ 748 n2 = EXTRACT_32BITS(bp); \ 749 bp += sizeof(int32_t); \ 750 n3 = EXTRACT_32BITS(bp); \ 751 bp += sizeof(int32_t); \ 752 ND_PRINT((ndo, " fid %d/%d/%d", (int) n1, (int) n2, (int) n3)); \ 753 } 754 755 #define STROUT(MAX) { unsigned int i; \ 756 ND_TCHECK2(bp[0], sizeof(int32_t)); \ 757 i = EXTRACT_32BITS(bp); \ 758 if (i > (MAX)) \ 759 goto trunc; \ 760 bp += sizeof(int32_t); \ 761 ND_PRINT((ndo, " \"")); \ 762 if (fn_printn(ndo, bp, i, ndo->ndo_snapend)) \ 763 goto trunc; \ 764 ND_PRINT((ndo, "\"")); \ 765 bp += ((i + sizeof(int32_t) - 1) / sizeof(int32_t)) * sizeof(int32_t); \ 766 } 767 768 #define INTOUT() { int i; \ 769 ND_TCHECK2(bp[0], sizeof(int32_t)); \ 770 i = (int) EXTRACT_32BITS(bp); \ 771 bp += sizeof(int32_t); \ 772 ND_PRINT((ndo, " %d", i)); \ 773 } 774 775 #define UINTOUT() { unsigned long i; \ 776 ND_TCHECK2(bp[0], sizeof(int32_t)); \ 777 i = EXTRACT_32BITS(bp); \ 778 bp += sizeof(int32_t); \ 779 ND_PRINT((ndo, " %lu", i)); \ 780 } 781 782 #define UINT64OUT() { uint64_t i; \ 783 ND_TCHECK2(bp[0], sizeof(uint64_t)); \ 784 i = EXTRACT_64BITS(bp); \ 785 bp += sizeof(uint64_t); \ 786 ND_PRINT((ndo, " %" PRIu64, i)); \ 787 } 788 789 #define DATEOUT() { time_t t; struct tm *tm; char str[256]; \ 790 ND_TCHECK2(bp[0], sizeof(int32_t)); \ 791 t = (time_t) EXTRACT_32BITS(bp); \ 792 bp += sizeof(int32_t); \ 793 tm = localtime(&t); \ 794 strftime(str, 256, "%Y/%m/%d %T", tm); \ 795 ND_PRINT((ndo, " %s", str)); \ 796 } 797 798 #define STOREATTROUT() { unsigned long mask, i; \ 799 ND_TCHECK2(bp[0], (sizeof(int32_t)*6)); \ 800 mask = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \ 801 if (mask) ND_PRINT((ndo, " StoreStatus")); \ 802 if (mask & 1) { ND_PRINT((ndo, " date")); DATEOUT(); } \ 803 else bp += sizeof(int32_t); \ 804 i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \ 805 if (mask & 2) ND_PRINT((ndo, " owner %lu", i)); \ 806 i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \ 807 if (mask & 4) ND_PRINT((ndo, " group %lu", i)); \ 808 i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \ 809 if (mask & 8) ND_PRINT((ndo, " mode %lo", i & 07777)); \ 810 i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \ 811 if (mask & 16) ND_PRINT((ndo, " segsize %lu", i)); \ 812 /* undocumented in 3.3 docu */ \ 813 if (mask & 1024) ND_PRINT((ndo, " fsync")); \ 814 } 815 816 #define UBIK_VERSIONOUT() {int32_t epoch; int32_t counter; \ 817 ND_TCHECK2(bp[0], sizeof(int32_t) * 2); \ 818 epoch = EXTRACT_32BITS(bp); \ 819 bp += sizeof(int32_t); \ 820 counter = EXTRACT_32BITS(bp); \ 821 bp += sizeof(int32_t); \ 822 ND_PRINT((ndo, " %d.%d", epoch, counter)); \ 823 } 824 825 #define AFSUUIDOUT() {uint32_t temp; int i; \ 826 ND_TCHECK2(bp[0], 11*sizeof(uint32_t)); \ 827 temp = EXTRACT_32BITS(bp); \ 828 bp += sizeof(uint32_t); \ 829 ND_PRINT((ndo, " %08x", temp)); \ 830 temp = EXTRACT_32BITS(bp); \ 831 bp += sizeof(uint32_t); \ 832 ND_PRINT((ndo, "%04x", temp)); \ 833 temp = EXTRACT_32BITS(bp); \ 834 bp += sizeof(uint32_t); \ 835 ND_PRINT((ndo, "%04x", temp)); \ 836 for (i = 0; i < 8; i++) { \ 837 temp = EXTRACT_32BITS(bp); \ 838 bp += sizeof(uint32_t); \ 839 ND_PRINT((ndo, "%02x", (unsigned char) temp)); \ 840 } \ 841 } 842 843 /* 844 * This is the sickest one of all 845 */ 846 847 #define VECOUT(MAX) { u_char *sp; \ 848 u_char s[AFSNAMEMAX]; \ 849 int k; \ 850 if ((MAX) + 1 > sizeof(s)) \ 851 goto trunc; \ 852 ND_TCHECK2(bp[0], (MAX) * sizeof(int32_t)); \ 853 sp = s; \ 854 for (k = 0; k < (MAX); k++) { \ 855 *sp++ = (u_char) EXTRACT_32BITS(bp); \ 856 bp += sizeof(int32_t); \ 857 } \ 858 s[(MAX)] = '\0'; \ 859 ND_PRINT((ndo, " \"")); \ 860 fn_print(ndo, s, NULL); \ 861 ND_PRINT((ndo, "\"")); \ 862 } 863 864 #define DESTSERVEROUT() { unsigned long n1, n2, n3; \ 865 ND_TCHECK2(bp[0], sizeof(int32_t) * 3); \ 866 n1 = EXTRACT_32BITS(bp); \ 867 bp += sizeof(int32_t); \ 868 n2 = EXTRACT_32BITS(bp); \ 869 bp += sizeof(int32_t); \ 870 n3 = EXTRACT_32BITS(bp); \ 871 bp += sizeof(int32_t); \ 872 ND_PRINT((ndo, " server %d:%d:%d", (int) n1, (int) n2, (int) n3)); \ 873 } 874 875 /* 876 * Handle calls to the AFS file service (fs) 877 */ 878 879 static void 880 fs_print(netdissect_options *ndo, 881 register const u_char *bp, int length) 882 { 883 int fs_op; 884 unsigned long i; 885 886 if (length <= (int)sizeof(struct rx_header)) 887 return; 888 889 if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) { 890 goto trunc; 891 } 892 893 /* 894 * Print out the afs call we're invoking. The table used here was 895 * gleaned from fsint/afsint.xg 896 */ 897 898 fs_op = EXTRACT_32BITS(bp + sizeof(struct rx_header)); 899 900 ND_PRINT((ndo, " fs call %s", tok2str(fs_req, "op#%d", fs_op))); 901 902 /* 903 * Print out arguments to some of the AFS calls. This stuff is 904 * all from afsint.xg 905 */ 906 907 bp += sizeof(struct rx_header) + 4; 908 909 /* 910 * Sigh. This is gross. Ritchie forgive me. 911 */ 912 913 switch (fs_op) { 914 case 130: /* Fetch data */ 915 FIDOUT(); 916 ND_PRINT((ndo, " offset")); 917 UINTOUT(); 918 ND_PRINT((ndo, " length")); 919 UINTOUT(); 920 break; 921 case 131: /* Fetch ACL */ 922 case 132: /* Fetch Status */ 923 case 143: /* Old set lock */ 924 case 144: /* Old extend lock */ 925 case 145: /* Old release lock */ 926 case 156: /* Set lock */ 927 case 157: /* Extend lock */ 928 case 158: /* Release lock */ 929 FIDOUT(); 930 break; 931 case 135: /* Store status */ 932 FIDOUT(); 933 STOREATTROUT(); 934 break; 935 case 133: /* Store data */ 936 FIDOUT(); 937 STOREATTROUT(); 938 ND_PRINT((ndo, " offset")); 939 UINTOUT(); 940 ND_PRINT((ndo, " length")); 941 UINTOUT(); 942 ND_PRINT((ndo, " flen")); 943 UINTOUT(); 944 break; 945 case 134: /* Store ACL */ 946 { 947 char a[AFSOPAQUEMAX+1]; 948 FIDOUT(); 949 ND_TCHECK2(bp[0], 4); 950 i = EXTRACT_32BITS(bp); 951 bp += sizeof(int32_t); 952 ND_TCHECK2(bp[0], i); 953 i = min(AFSOPAQUEMAX, i); 954 strncpy(a, (char *) bp, i); 955 a[i] = '\0'; 956 acl_print(ndo, (u_char *) a, sizeof(a), (u_char *) a + i); 957 break; 958 } 959 case 137: /* Create file */ 960 case 141: /* MakeDir */ 961 FIDOUT(); 962 STROUT(AFSNAMEMAX); 963 STOREATTROUT(); 964 break; 965 case 136: /* Remove file */ 966 case 142: /* Remove directory */ 967 FIDOUT(); 968 STROUT(AFSNAMEMAX); 969 break; 970 case 138: /* Rename file */ 971 ND_PRINT((ndo, " old")); 972 FIDOUT(); 973 STROUT(AFSNAMEMAX); 974 ND_PRINT((ndo, " new")); 975 FIDOUT(); 976 STROUT(AFSNAMEMAX); 977 break; 978 case 139: /* Symlink */ 979 FIDOUT(); 980 STROUT(AFSNAMEMAX); 981 ND_PRINT((ndo, " link to")); 982 STROUT(AFSNAMEMAX); 983 break; 984 case 140: /* Link */ 985 FIDOUT(); 986 STROUT(AFSNAMEMAX); 987 ND_PRINT((ndo, " link to")); 988 FIDOUT(); 989 break; 990 case 148: /* Get volume info */ 991 STROUT(AFSNAMEMAX); 992 break; 993 case 149: /* Get volume stats */ 994 case 150: /* Set volume stats */ 995 ND_PRINT((ndo, " volid")); 996 UINTOUT(); 997 break; 998 case 154: /* New get volume info */ 999 ND_PRINT((ndo, " volname")); 1000 STROUT(AFSNAMEMAX); 1001 break; 1002 case 155: /* Bulk stat */ 1003 case 65536: /* Inline bulk stat */ 1004 { 1005 unsigned long j; 1006 ND_TCHECK2(bp[0], 4); 1007 j = EXTRACT_32BITS(bp); 1008 bp += sizeof(int32_t); 1009 1010 for (i = 0; i < j; i++) { 1011 FIDOUT(); 1012 if (i != j - 1) 1013 ND_PRINT((ndo, ",")); 1014 } 1015 if (j == 0) 1016 ND_PRINT((ndo, " <none!>")); 1017 } 1018 case 65537: /* Fetch data 64 */ 1019 FIDOUT(); 1020 ND_PRINT((ndo, " offset")); 1021 UINT64OUT(); 1022 ND_PRINT((ndo, " length")); 1023 UINT64OUT(); 1024 break; 1025 case 65538: /* Store data 64 */ 1026 FIDOUT(); 1027 STOREATTROUT(); 1028 ND_PRINT((ndo, " offset")); 1029 UINT64OUT(); 1030 ND_PRINT((ndo, " length")); 1031 UINT64OUT(); 1032 ND_PRINT((ndo, " flen")); 1033 UINT64OUT(); 1034 break; 1035 case 65541: /* CallBack rx conn address */ 1036 ND_PRINT((ndo, " addr")); 1037 UINTOUT(); 1038 default: 1039 ; 1040 } 1041 1042 return; 1043 1044 trunc: 1045 ND_PRINT((ndo, " [|fs]")); 1046 } 1047 1048 /* 1049 * Handle replies to the AFS file service 1050 */ 1051 1052 static void 1053 fs_reply_print(netdissect_options *ndo, 1054 register const u_char *bp, int length, int32_t opcode) 1055 { 1056 unsigned long i; 1057 struct rx_header *rxh; 1058 1059 if (length <= (int)sizeof(struct rx_header)) 1060 return; 1061 1062 rxh = (struct rx_header *) bp; 1063 1064 /* 1065 * Print out the afs call we're invoking. The table used here was 1066 * gleaned from fsint/afsint.xg 1067 */ 1068 1069 ND_PRINT((ndo, " fs reply %s", tok2str(fs_req, "op#%d", opcode))); 1070 1071 bp += sizeof(struct rx_header); 1072 1073 /* 1074 * If it was a data packet, interpret the response 1075 */ 1076 1077 if (rxh->type == RX_PACKET_TYPE_DATA) { 1078 switch (opcode) { 1079 case 131: /* Fetch ACL */ 1080 { 1081 char a[AFSOPAQUEMAX+1]; 1082 ND_TCHECK2(bp[0], 4); 1083 i = EXTRACT_32BITS(bp); 1084 bp += sizeof(int32_t); 1085 ND_TCHECK2(bp[0], i); 1086 i = min(AFSOPAQUEMAX, i); 1087 strncpy(a, (char *) bp, i); 1088 a[i] = '\0'; 1089 acl_print(ndo, (u_char *) a, sizeof(a), (u_char *) a + i); 1090 break; 1091 } 1092 case 137: /* Create file */ 1093 case 141: /* MakeDir */ 1094 ND_PRINT((ndo, " new")); 1095 FIDOUT(); 1096 break; 1097 case 151: /* Get root volume */ 1098 ND_PRINT((ndo, " root volume")); 1099 STROUT(AFSNAMEMAX); 1100 break; 1101 case 153: /* Get time */ 1102 DATEOUT(); 1103 break; 1104 default: 1105 ; 1106 } 1107 } else if (rxh->type == RX_PACKET_TYPE_ABORT) { 1108 int i; 1109 1110 /* 1111 * Otherwise, just print out the return code 1112 */ 1113 ND_TCHECK2(bp[0], sizeof(int32_t)); 1114 i = (int) EXTRACT_32BITS(bp); 1115 bp += sizeof(int32_t); 1116 1117 ND_PRINT((ndo, " error %s", tok2str(afs_fs_errors, "#%d", i))); 1118 } else { 1119 ND_PRINT((ndo, " strange fs reply of type %d", rxh->type)); 1120 } 1121 1122 return; 1123 1124 trunc: 1125 ND_PRINT((ndo, " [|fs]")); 1126 } 1127 1128 /* 1129 * Print out an AFS ACL string. An AFS ACL is a string that has the 1130 * following format: 1131 * 1132 * <positive> <negative> 1133 * <uid1> <aclbits1> 1134 * .... 1135 * 1136 * "positive" and "negative" are integers which contain the number of 1137 * positive and negative ACL's in the string. The uid/aclbits pair are 1138 * ASCII strings containing the UID/PTS record and and a ascii number 1139 * representing a logical OR of all the ACL permission bits 1140 */ 1141 1142 static void 1143 acl_print(netdissect_options *ndo, 1144 u_char *s, int maxsize, u_char *end) 1145 { 1146 int pos, neg, acl; 1147 int n, i; 1148 char *user; 1149 char fmt[1024]; 1150 1151 if ((user = (char *)malloc(maxsize)) == NULL) 1152 return; 1153 1154 if (sscanf((char *) s, "%d %d\n%n", &pos, &neg, &n) != 2) 1155 goto finish; 1156 1157 s += n; 1158 1159 if (s > end) 1160 goto finish; 1161 1162 /* 1163 * This wacky order preserves the order used by the "fs" command 1164 */ 1165 1166 #define ACLOUT(acl) \ 1167 ND_PRINT((ndo, "%s%s%s%s%s%s%s", \ 1168 acl & PRSFS_READ ? "r" : "", \ 1169 acl & PRSFS_LOOKUP ? "l" : "", \ 1170 acl & PRSFS_INSERT ? "i" : "", \ 1171 acl & PRSFS_DELETE ? "d" : "", \ 1172 acl & PRSFS_WRITE ? "w" : "", \ 1173 acl & PRSFS_LOCK ? "k" : "", \ 1174 acl & PRSFS_ADMINISTER ? "a" : "")); 1175 1176 for (i = 0; i < pos; i++) { 1177 snprintf(fmt, sizeof(fmt), "%%%ds %%d\n%%n", maxsize - 1); 1178 if (sscanf((char *) s, fmt, user, &acl, &n) != 2) 1179 goto finish; 1180 s += n; 1181 ND_PRINT((ndo, " +{")); 1182 fn_print(ndo, (u_char *)user, NULL); 1183 ND_PRINT((ndo, " ")); 1184 ACLOUT(acl); 1185 ND_PRINT((ndo, "}")); 1186 if (s > end) 1187 goto finish; 1188 } 1189 1190 for (i = 0; i < neg; i++) { 1191 snprintf(fmt, sizeof(fmt), "%%%ds %%d\n%%n", maxsize - 1); 1192 if (sscanf((char *) s, fmt, user, &acl, &n) != 2) 1193 goto finish; 1194 s += n; 1195 ND_PRINT((ndo, " -{")); 1196 fn_print(ndo, (u_char *)user, NULL); 1197 ND_PRINT((ndo, " ")); 1198 ACLOUT(acl); 1199 ND_PRINT((ndo, "}")); 1200 if (s > end) 1201 goto finish; 1202 } 1203 1204 finish: 1205 free(user); 1206 return; 1207 } 1208 1209 #undef ACLOUT 1210 1211 /* 1212 * Handle calls to the AFS callback service 1213 */ 1214 1215 static void 1216 cb_print(netdissect_options *ndo, 1217 register const u_char *bp, int length) 1218 { 1219 int cb_op; 1220 unsigned long i; 1221 1222 if (length <= (int)sizeof(struct rx_header)) 1223 return; 1224 1225 if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) { 1226 goto trunc; 1227 } 1228 1229 /* 1230 * Print out the afs call we're invoking. The table used here was 1231 * gleaned from fsint/afscbint.xg 1232 */ 1233 1234 cb_op = EXTRACT_32BITS(bp + sizeof(struct rx_header)); 1235 1236 ND_PRINT((ndo, " cb call %s", tok2str(cb_req, "op#%d", cb_op))); 1237 1238 bp += sizeof(struct rx_header) + 4; 1239 1240 /* 1241 * Print out the afs call we're invoking. The table used here was 1242 * gleaned from fsint/afscbint.xg 1243 */ 1244 1245 switch (cb_op) { 1246 case 204: /* Callback */ 1247 { 1248 unsigned long j, t; 1249 ND_TCHECK2(bp[0], 4); 1250 j = EXTRACT_32BITS(bp); 1251 bp += sizeof(int32_t); 1252 1253 for (i = 0; i < j; i++) { 1254 FIDOUT(); 1255 if (i != j - 1) 1256 ND_PRINT((ndo, ",")); 1257 } 1258 1259 if (j == 0) 1260 ND_PRINT((ndo, " <none!>")); 1261 1262 j = EXTRACT_32BITS(bp); 1263 bp += sizeof(int32_t); 1264 1265 if (j != 0) 1266 ND_PRINT((ndo, ";")); 1267 1268 for (i = 0; i < j; i++) { 1269 ND_PRINT((ndo, " ver")); 1270 INTOUT(); 1271 ND_PRINT((ndo, " expires")); 1272 DATEOUT(); 1273 ND_TCHECK2(bp[0], 4); 1274 t = EXTRACT_32BITS(bp); 1275 bp += sizeof(int32_t); 1276 tok2str(cb_types, "type %d", t); 1277 } 1278 } 1279 case 214: { 1280 ND_PRINT((ndo, " afsuuid")); 1281 AFSUUIDOUT(); 1282 break; 1283 } 1284 default: 1285 ; 1286 } 1287 1288 return; 1289 1290 trunc: 1291 ND_PRINT((ndo, " [|cb]")); 1292 } 1293 1294 /* 1295 * Handle replies to the AFS Callback Service 1296 */ 1297 1298 static void 1299 cb_reply_print(netdissect_options *ndo, 1300 register const u_char *bp, int length, int32_t opcode) 1301 { 1302 struct rx_header *rxh; 1303 1304 if (length <= (int)sizeof(struct rx_header)) 1305 return; 1306 1307 rxh = (struct rx_header *) bp; 1308 1309 /* 1310 * Print out the afs call we're invoking. The table used here was 1311 * gleaned from fsint/afscbint.xg 1312 */ 1313 1314 ND_PRINT((ndo, " cb reply %s", tok2str(cb_req, "op#%d", opcode))); 1315 1316 bp += sizeof(struct rx_header); 1317 1318 /* 1319 * If it was a data packet, interpret the response. 1320 */ 1321 1322 if (rxh->type == RX_PACKET_TYPE_DATA) 1323 switch (opcode) { 1324 case 213: /* InitCallBackState3 */ 1325 AFSUUIDOUT(); 1326 break; 1327 default: 1328 ; 1329 } 1330 else { 1331 /* 1332 * Otherwise, just print out the return code 1333 */ 1334 ND_PRINT((ndo, " errcode")); 1335 INTOUT(); 1336 } 1337 1338 return; 1339 1340 trunc: 1341 ND_PRINT((ndo, " [|cb]")); 1342 } 1343 1344 /* 1345 * Handle calls to the AFS protection database server 1346 */ 1347 1348 static void 1349 prot_print(netdissect_options *ndo, 1350 register const u_char *bp, int length) 1351 { 1352 unsigned long i; 1353 int pt_op; 1354 1355 if (length <= (int)sizeof(struct rx_header)) 1356 return; 1357 1358 if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) { 1359 goto trunc; 1360 } 1361 1362 /* 1363 * Print out the afs call we're invoking. The table used here was 1364 * gleaned from ptserver/ptint.xg 1365 */ 1366 1367 pt_op = EXTRACT_32BITS(bp + sizeof(struct rx_header)); 1368 1369 ND_PRINT((ndo, " pt")); 1370 1371 if (is_ubik(pt_op)) { 1372 ubik_print(ndo, bp); 1373 return; 1374 } 1375 1376 ND_PRINT((ndo, " call %s", tok2str(pt_req, "op#%d", pt_op))); 1377 1378 /* 1379 * Decode some of the arguments to the PT calls 1380 */ 1381 1382 bp += sizeof(struct rx_header) + 4; 1383 1384 switch (pt_op) { 1385 case 500: /* I New User */ 1386 STROUT(PRNAMEMAX); 1387 ND_PRINT((ndo, " id")); 1388 INTOUT(); 1389 ND_PRINT((ndo, " oldid")); 1390 INTOUT(); 1391 break; 1392 case 501: /* Where is it */ 1393 case 506: /* Delete */ 1394 case 508: /* Get CPS */ 1395 case 512: /* List entry */ 1396 case 514: /* List elements */ 1397 case 517: /* List owned */ 1398 case 518: /* Get CPS2 */ 1399 case 519: /* Get host CPS */ 1400 case 530: /* List super groups */ 1401 ND_PRINT((ndo, " id")); 1402 INTOUT(); 1403 break; 1404 case 502: /* Dump entry */ 1405 ND_PRINT((ndo, " pos")); 1406 INTOUT(); 1407 break; 1408 case 503: /* Add to group */ 1409 case 507: /* Remove from group */ 1410 case 515: /* Is a member of? */ 1411 ND_PRINT((ndo, " uid")); 1412 INTOUT(); 1413 ND_PRINT((ndo, " gid")); 1414 INTOUT(); 1415 break; 1416 case 504: /* Name to ID */ 1417 { 1418 unsigned long j; 1419 ND_TCHECK2(bp[0], 4); 1420 j = EXTRACT_32BITS(bp); 1421 bp += sizeof(int32_t); 1422 1423 /* 1424 * Who designed this chicken-shit protocol? 1425 * 1426 * Each character is stored as a 32-bit 1427 * integer! 1428 */ 1429 1430 for (i = 0; i < j; i++) { 1431 VECOUT(PRNAMEMAX); 1432 } 1433 if (j == 0) 1434 ND_PRINT((ndo, " <none!>")); 1435 } 1436 break; 1437 case 505: /* Id to name */ 1438 { 1439 unsigned long j; 1440 ND_PRINT((ndo, " ids:")); 1441 ND_TCHECK2(bp[0], 4); 1442 i = EXTRACT_32BITS(bp); 1443 bp += sizeof(int32_t); 1444 for (j = 0; j < i; j++) 1445 INTOUT(); 1446 if (j == 0) 1447 ND_PRINT((ndo, " <none!>")); 1448 } 1449 break; 1450 case 509: /* New entry */ 1451 STROUT(PRNAMEMAX); 1452 ND_PRINT((ndo, " flag")); 1453 INTOUT(); 1454 ND_PRINT((ndo, " oid")); 1455 INTOUT(); 1456 break; 1457 case 511: /* Set max */ 1458 ND_PRINT((ndo, " id")); 1459 INTOUT(); 1460 ND_PRINT((ndo, " gflag")); 1461 INTOUT(); 1462 break; 1463 case 513: /* Change entry */ 1464 ND_PRINT((ndo, " id")); 1465 INTOUT(); 1466 STROUT(PRNAMEMAX); 1467 ND_PRINT((ndo, " oldid")); 1468 INTOUT(); 1469 ND_PRINT((ndo, " newid")); 1470 INTOUT(); 1471 break; 1472 case 520: /* Update entry */ 1473 ND_PRINT((ndo, " id")); 1474 INTOUT(); 1475 STROUT(PRNAMEMAX); 1476 break; 1477 default: 1478 ; 1479 } 1480 1481 1482 return; 1483 1484 trunc: 1485 ND_PRINT((ndo, " [|pt]")); 1486 } 1487 1488 /* 1489 * Handle replies to the AFS protection service 1490 */ 1491 1492 static void 1493 prot_reply_print(netdissect_options *ndo, 1494 register const u_char *bp, int length, int32_t opcode) 1495 { 1496 struct rx_header *rxh; 1497 unsigned long i; 1498 1499 if (length < (int)sizeof(struct rx_header)) 1500 return; 1501 1502 rxh = (struct rx_header *) bp; 1503 1504 /* 1505 * Print out the afs call we're invoking. The table used here was 1506 * gleaned from ptserver/ptint.xg. Check to see if it's a 1507 * Ubik call, however. 1508 */ 1509 1510 ND_PRINT((ndo, " pt")); 1511 1512 if (is_ubik(opcode)) { 1513 ubik_reply_print(ndo, bp, length, opcode); 1514 return; 1515 } 1516 1517 ND_PRINT((ndo, " reply %s", tok2str(pt_req, "op#%d", opcode))); 1518 1519 bp += sizeof(struct rx_header); 1520 1521 /* 1522 * If it was a data packet, interpret the response 1523 */ 1524 1525 if (rxh->type == RX_PACKET_TYPE_DATA) 1526 switch (opcode) { 1527 case 504: /* Name to ID */ 1528 { 1529 unsigned long j; 1530 ND_PRINT((ndo, " ids:")); 1531 ND_TCHECK2(bp[0], 4); 1532 i = EXTRACT_32BITS(bp); 1533 bp += sizeof(int32_t); 1534 for (j = 0; j < i; j++) 1535 INTOUT(); 1536 if (j == 0) 1537 ND_PRINT((ndo, " <none!>")); 1538 } 1539 break; 1540 case 505: /* ID to name */ 1541 { 1542 unsigned long j; 1543 ND_TCHECK2(bp[0], 4); 1544 j = EXTRACT_32BITS(bp); 1545 bp += sizeof(int32_t); 1546 1547 /* 1548 * Who designed this chicken-shit protocol? 1549 * 1550 * Each character is stored as a 32-bit 1551 * integer! 1552 */ 1553 1554 for (i = 0; i < j; i++) { 1555 VECOUT(PRNAMEMAX); 1556 } 1557 if (j == 0) 1558 ND_PRINT((ndo, " <none!>")); 1559 } 1560 break; 1561 case 508: /* Get CPS */ 1562 case 514: /* List elements */ 1563 case 517: /* List owned */ 1564 case 518: /* Get CPS2 */ 1565 case 519: /* Get host CPS */ 1566 { 1567 unsigned long j; 1568 ND_TCHECK2(bp[0], 4); 1569 j = EXTRACT_32BITS(bp); 1570 bp += sizeof(int32_t); 1571 for (i = 0; i < j; i++) { 1572 INTOUT(); 1573 } 1574 if (j == 0) 1575 ND_PRINT((ndo, " <none!>")); 1576 } 1577 break; 1578 case 510: /* List max */ 1579 ND_PRINT((ndo, " maxuid")); 1580 INTOUT(); 1581 ND_PRINT((ndo, " maxgid")); 1582 INTOUT(); 1583 break; 1584 default: 1585 ; 1586 } 1587 else { 1588 /* 1589 * Otherwise, just print out the return code 1590 */ 1591 ND_PRINT((ndo, " errcode")); 1592 INTOUT(); 1593 } 1594 1595 return; 1596 1597 trunc: 1598 ND_PRINT((ndo, " [|pt]")); 1599 } 1600 1601 /* 1602 * Handle calls to the AFS volume location database service 1603 */ 1604 1605 static void 1606 vldb_print(netdissect_options *ndo, 1607 register const u_char *bp, int length) 1608 { 1609 int vldb_op; 1610 unsigned long i; 1611 1612 if (length <= (int)sizeof(struct rx_header)) 1613 return; 1614 1615 if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) { 1616 goto trunc; 1617 } 1618 1619 /* 1620 * Print out the afs call we're invoking. The table used here was 1621 * gleaned from vlserver/vldbint.xg 1622 */ 1623 1624 vldb_op = EXTRACT_32BITS(bp + sizeof(struct rx_header)); 1625 1626 ND_PRINT((ndo, " vldb")); 1627 1628 if (is_ubik(vldb_op)) { 1629 ubik_print(ndo, bp); 1630 return; 1631 } 1632 ND_PRINT((ndo, " call %s", tok2str(vldb_req, "op#%d", vldb_op))); 1633 1634 /* 1635 * Decode some of the arguments to the VLDB calls 1636 */ 1637 1638 bp += sizeof(struct rx_header) + 4; 1639 1640 switch (vldb_op) { 1641 case 501: /* Create new volume */ 1642 case 517: /* Create entry N */ 1643 VECOUT(VLNAMEMAX); 1644 break; 1645 case 502: /* Delete entry */ 1646 case 503: /* Get entry by ID */ 1647 case 507: /* Update entry */ 1648 case 508: /* Set lock */ 1649 case 509: /* Release lock */ 1650 case 518: /* Get entry by ID N */ 1651 ND_PRINT((ndo, " volid")); 1652 INTOUT(); 1653 ND_TCHECK2(bp[0], sizeof(int32_t)); 1654 i = EXTRACT_32BITS(bp); 1655 bp += sizeof(int32_t); 1656 if (i <= 2) 1657 ND_PRINT((ndo, " type %s", voltype[i])); 1658 break; 1659 case 504: /* Get entry by name */ 1660 case 519: /* Get entry by name N */ 1661 case 524: /* Update entry by name */ 1662 case 527: /* Get entry by name U */ 1663 STROUT(VLNAMEMAX); 1664 break; 1665 case 505: /* Get new vol id */ 1666 ND_PRINT((ndo, " bump")); 1667 INTOUT(); 1668 break; 1669 case 506: /* Replace entry */ 1670 case 520: /* Replace entry N */ 1671 ND_PRINT((ndo, " volid")); 1672 INTOUT(); 1673 ND_TCHECK2(bp[0], sizeof(int32_t)); 1674 i = EXTRACT_32BITS(bp); 1675 bp += sizeof(int32_t); 1676 if (i <= 2) 1677 ND_PRINT((ndo, " type %s", voltype[i])); 1678 VECOUT(VLNAMEMAX); 1679 break; 1680 case 510: /* List entry */ 1681 case 521: /* List entry N */ 1682 ND_PRINT((ndo, " index")); 1683 INTOUT(); 1684 break; 1685 default: 1686 ; 1687 } 1688 1689 return; 1690 1691 trunc: 1692 ND_PRINT((ndo, " [|vldb]")); 1693 } 1694 1695 /* 1696 * Handle replies to the AFS volume location database service 1697 */ 1698 1699 static void 1700 vldb_reply_print(netdissect_options *ndo, 1701 register const u_char *bp, int length, int32_t opcode) 1702 { 1703 struct rx_header *rxh; 1704 unsigned long i; 1705 1706 if (length < (int)sizeof(struct rx_header)) 1707 return; 1708 1709 rxh = (struct rx_header *) bp; 1710 1711 /* 1712 * Print out the afs call we're invoking. The table used here was 1713 * gleaned from vlserver/vldbint.xg. Check to see if it's a 1714 * Ubik call, however. 1715 */ 1716 1717 ND_PRINT((ndo, " vldb")); 1718 1719 if (is_ubik(opcode)) { 1720 ubik_reply_print(ndo, bp, length, opcode); 1721 return; 1722 } 1723 1724 ND_PRINT((ndo, " reply %s", tok2str(vldb_req, "op#%d", opcode))); 1725 1726 bp += sizeof(struct rx_header); 1727 1728 /* 1729 * If it was a data packet, interpret the response 1730 */ 1731 1732 if (rxh->type == RX_PACKET_TYPE_DATA) 1733 switch (opcode) { 1734 case 510: /* List entry */ 1735 ND_PRINT((ndo, " count")); 1736 INTOUT(); 1737 ND_PRINT((ndo, " nextindex")); 1738 INTOUT(); 1739 case 503: /* Get entry by id */ 1740 case 504: /* Get entry by name */ 1741 { unsigned long nservers, j; 1742 VECOUT(VLNAMEMAX); 1743 ND_TCHECK2(bp[0], sizeof(int32_t)); 1744 bp += sizeof(int32_t); 1745 ND_PRINT((ndo, " numservers")); 1746 ND_TCHECK2(bp[0], sizeof(int32_t)); 1747 nservers = EXTRACT_32BITS(bp); 1748 bp += sizeof(int32_t); 1749 ND_PRINT((ndo, " %lu", nservers)); 1750 ND_PRINT((ndo, " servers")); 1751 for (i = 0; i < 8; i++) { 1752 ND_TCHECK2(bp[0], sizeof(int32_t)); 1753 if (i < nservers) 1754 ND_PRINT((ndo, " %s", 1755 intoa(((struct in_addr *) bp)->s_addr))); 1756 bp += sizeof(int32_t); 1757 } 1758 ND_PRINT((ndo, " partitions")); 1759 for (i = 0; i < 8; i++) { 1760 ND_TCHECK2(bp[0], sizeof(int32_t)); 1761 j = EXTRACT_32BITS(bp); 1762 if (i < nservers && j <= 26) 1763 ND_PRINT((ndo, " %c", 'a' + (int)j)); 1764 else if (i < nservers) 1765 ND_PRINT((ndo, " %lu", j)); 1766 bp += sizeof(int32_t); 1767 } 1768 ND_TCHECK2(bp[0], 8 * sizeof(int32_t)); 1769 bp += 8 * sizeof(int32_t); 1770 ND_PRINT((ndo, " rwvol")); 1771 UINTOUT(); 1772 ND_PRINT((ndo, " rovol")); 1773 UINTOUT(); 1774 ND_PRINT((ndo, " backup")); 1775 UINTOUT(); 1776 } 1777 break; 1778 case 505: /* Get new volume ID */ 1779 ND_PRINT((ndo, " newvol")); 1780 UINTOUT(); 1781 break; 1782 case 521: /* List entry */ 1783 case 529: /* List entry U */ 1784 ND_PRINT((ndo, " count")); 1785 INTOUT(); 1786 ND_PRINT((ndo, " nextindex")); 1787 INTOUT(); 1788 case 518: /* Get entry by ID N */ 1789 case 519: /* Get entry by name N */ 1790 { unsigned long nservers, j; 1791 VECOUT(VLNAMEMAX); 1792 ND_PRINT((ndo, " numservers")); 1793 ND_TCHECK2(bp[0], sizeof(int32_t)); 1794 nservers = EXTRACT_32BITS(bp); 1795 bp += sizeof(int32_t); 1796 ND_PRINT((ndo, " %lu", nservers)); 1797 ND_PRINT((ndo, " servers")); 1798 for (i = 0; i < 13; i++) { 1799 ND_TCHECK2(bp[0], sizeof(int32_t)); 1800 if (i < nservers) 1801 ND_PRINT((ndo, " %s", 1802 intoa(((struct in_addr *) bp)->s_addr))); 1803 bp += sizeof(int32_t); 1804 } 1805 ND_PRINT((ndo, " partitions")); 1806 for (i = 0; i < 13; i++) { 1807 ND_TCHECK2(bp[0], sizeof(int32_t)); 1808 j = EXTRACT_32BITS(bp); 1809 if (i < nservers && j <= 26) 1810 ND_PRINT((ndo, " %c", 'a' + (int)j)); 1811 else if (i < nservers) 1812 ND_PRINT((ndo, " %lu", j)); 1813 bp += sizeof(int32_t); 1814 } 1815 ND_TCHECK2(bp[0], 13 * sizeof(int32_t)); 1816 bp += 13 * sizeof(int32_t); 1817 ND_PRINT((ndo, " rwvol")); 1818 UINTOUT(); 1819 ND_PRINT((ndo, " rovol")); 1820 UINTOUT(); 1821 ND_PRINT((ndo, " backup")); 1822 UINTOUT(); 1823 } 1824 break; 1825 case 526: /* Get entry by ID U */ 1826 case 527: /* Get entry by name U */ 1827 { unsigned long nservers, j; 1828 VECOUT(VLNAMEMAX); 1829 ND_PRINT((ndo, " numservers")); 1830 ND_TCHECK2(bp[0], sizeof(int32_t)); 1831 nservers = EXTRACT_32BITS(bp); 1832 bp += sizeof(int32_t); 1833 ND_PRINT((ndo, " %lu", nservers)); 1834 ND_PRINT((ndo, " servers")); 1835 for (i = 0; i < 13; i++) { 1836 if (i < nservers) { 1837 ND_PRINT((ndo, " afsuuid")); 1838 AFSUUIDOUT(); 1839 } else { 1840 ND_TCHECK2(bp[0], 44); 1841 bp += 44; 1842 } 1843 } 1844 ND_TCHECK2(bp[0], 4 * 13); 1845 bp += 4 * 13; 1846 ND_PRINT((ndo, " partitions")); 1847 for (i = 0; i < 13; i++) { 1848 ND_TCHECK2(bp[0], sizeof(int32_t)); 1849 j = EXTRACT_32BITS(bp); 1850 if (i < nservers && j <= 26) 1851 ND_PRINT((ndo, " %c", 'a' + (int)j)); 1852 else if (i < nservers) 1853 ND_PRINT((ndo, " %lu", j)); 1854 bp += sizeof(int32_t); 1855 } 1856 ND_TCHECK2(bp[0], 13 * sizeof(int32_t)); 1857 bp += 13 * sizeof(int32_t); 1858 ND_PRINT((ndo, " rwvol")); 1859 UINTOUT(); 1860 ND_PRINT((ndo, " rovol")); 1861 UINTOUT(); 1862 ND_PRINT((ndo, " backup")); 1863 UINTOUT(); 1864 } 1865 default: 1866 ; 1867 } 1868 1869 else { 1870 /* 1871 * Otherwise, just print out the return code 1872 */ 1873 ND_PRINT((ndo, " errcode")); 1874 INTOUT(); 1875 } 1876 1877 return; 1878 1879 trunc: 1880 ND_PRINT((ndo, " [|vldb]")); 1881 } 1882 1883 /* 1884 * Handle calls to the AFS Kerberos Authentication service 1885 */ 1886 1887 static void 1888 kauth_print(netdissect_options *ndo, 1889 register const u_char *bp, int length) 1890 { 1891 int kauth_op; 1892 1893 if (length <= (int)sizeof(struct rx_header)) 1894 return; 1895 1896 if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) { 1897 goto trunc; 1898 } 1899 1900 /* 1901 * Print out the afs call we're invoking. The table used here was 1902 * gleaned from kauth/kauth.rg 1903 */ 1904 1905 kauth_op = EXTRACT_32BITS(bp + sizeof(struct rx_header)); 1906 1907 ND_PRINT((ndo, " kauth")); 1908 1909 if (is_ubik(kauth_op)) { 1910 ubik_print(ndo, bp); 1911 return; 1912 } 1913 1914 1915 ND_PRINT((ndo, " call %s", tok2str(kauth_req, "op#%d", kauth_op))); 1916 1917 /* 1918 * Decode some of the arguments to the KA calls 1919 */ 1920 1921 bp += sizeof(struct rx_header) + 4; 1922 1923 switch (kauth_op) { 1924 case 1: /* Authenticate old */; 1925 case 21: /* Authenticate */ 1926 case 22: /* Authenticate-V2 */ 1927 case 2: /* Change PW */ 1928 case 5: /* Set fields */ 1929 case 6: /* Create user */ 1930 case 7: /* Delete user */ 1931 case 8: /* Get entry */ 1932 case 14: /* Unlock */ 1933 case 15: /* Lock status */ 1934 ND_PRINT((ndo, " principal")); 1935 STROUT(KANAMEMAX); 1936 STROUT(KANAMEMAX); 1937 break; 1938 case 3: /* GetTicket-old */ 1939 case 23: /* GetTicket */ 1940 { 1941 int i; 1942 ND_PRINT((ndo, " kvno")); 1943 INTOUT(); 1944 ND_PRINT((ndo, " domain")); 1945 STROUT(KANAMEMAX); 1946 ND_TCHECK2(bp[0], sizeof(int32_t)); 1947 i = (int) EXTRACT_32BITS(bp); 1948 bp += sizeof(int32_t); 1949 ND_TCHECK2(bp[0], i); 1950 bp += i; 1951 ND_PRINT((ndo, " principal")); 1952 STROUT(KANAMEMAX); 1953 STROUT(KANAMEMAX); 1954 break; 1955 } 1956 case 4: /* Set Password */ 1957 ND_PRINT((ndo, " principal")); 1958 STROUT(KANAMEMAX); 1959 STROUT(KANAMEMAX); 1960 ND_PRINT((ndo, " kvno")); 1961 INTOUT(); 1962 break; 1963 case 12: /* Get password */ 1964 ND_PRINT((ndo, " name")); 1965 STROUT(KANAMEMAX); 1966 break; 1967 default: 1968 ; 1969 } 1970 1971 return; 1972 1973 trunc: 1974 ND_PRINT((ndo, " [|kauth]")); 1975 } 1976 1977 /* 1978 * Handle replies to the AFS Kerberos Authentication Service 1979 */ 1980 1981 static void 1982 kauth_reply_print(netdissect_options *ndo, 1983 register const u_char *bp, int length, int32_t opcode) 1984 { 1985 struct rx_header *rxh; 1986 1987 if (length <= (int)sizeof(struct rx_header)) 1988 return; 1989 1990 rxh = (struct rx_header *) bp; 1991 1992 /* 1993 * Print out the afs call we're invoking. The table used here was 1994 * gleaned from kauth/kauth.rg 1995 */ 1996 1997 ND_PRINT((ndo, " kauth")); 1998 1999 if (is_ubik(opcode)) { 2000 ubik_reply_print(ndo, bp, length, opcode); 2001 return; 2002 } 2003 2004 ND_PRINT((ndo, " reply %s", tok2str(kauth_req, "op#%d", opcode))); 2005 2006 bp += sizeof(struct rx_header); 2007 2008 /* 2009 * If it was a data packet, interpret the response. 2010 */ 2011 2012 if (rxh->type == RX_PACKET_TYPE_DATA) 2013 /* Well, no, not really. Leave this for later */ 2014 ; 2015 else { 2016 /* 2017 * Otherwise, just print out the return code 2018 */ 2019 ND_PRINT((ndo, " errcode")); 2020 INTOUT(); 2021 } 2022 2023 return; 2024 2025 trunc: 2026 ND_PRINT((ndo, " [|kauth]")); 2027 } 2028 2029 /* 2030 * Handle calls to the AFS Volume location service 2031 */ 2032 2033 static void 2034 vol_print(netdissect_options *ndo, 2035 register const u_char *bp, int length) 2036 { 2037 int vol_op; 2038 2039 if (length <= (int)sizeof(struct rx_header)) 2040 return; 2041 2042 if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) { 2043 goto trunc; 2044 } 2045 2046 /* 2047 * Print out the afs call we're invoking. The table used here was 2048 * gleaned from volser/volint.xg 2049 */ 2050 2051 vol_op = EXTRACT_32BITS(bp + sizeof(struct rx_header)); 2052 2053 ND_PRINT((ndo, " vol call %s", tok2str(vol_req, "op#%d", vol_op))); 2054 2055 bp += sizeof(struct rx_header) + 4; 2056 2057 switch (vol_op) { 2058 case 100: /* Create volume */ 2059 ND_PRINT((ndo, " partition")); 2060 UINTOUT(); 2061 ND_PRINT((ndo, " name")); 2062 STROUT(AFSNAMEMAX); 2063 ND_PRINT((ndo, " type")); 2064 UINTOUT(); 2065 ND_PRINT((ndo, " parent")); 2066 UINTOUT(); 2067 break; 2068 case 101: /* Delete volume */ 2069 case 107: /* Get flags */ 2070 ND_PRINT((ndo, " trans")); 2071 UINTOUT(); 2072 break; 2073 case 102: /* Restore */ 2074 ND_PRINT((ndo, " totrans")); 2075 UINTOUT(); 2076 ND_PRINT((ndo, " flags")); 2077 UINTOUT(); 2078 break; 2079 case 103: /* Forward */ 2080 ND_PRINT((ndo, " fromtrans")); 2081 UINTOUT(); 2082 ND_PRINT((ndo, " fromdate")); 2083 DATEOUT(); 2084 DESTSERVEROUT(); 2085 ND_PRINT((ndo, " desttrans")); 2086 INTOUT(); 2087 break; 2088 case 104: /* End trans */ 2089 ND_PRINT((ndo, " trans")); 2090 UINTOUT(); 2091 break; 2092 case 105: /* Clone */ 2093 ND_PRINT((ndo, " trans")); 2094 UINTOUT(); 2095 ND_PRINT((ndo, " purgevol")); 2096 UINTOUT(); 2097 ND_PRINT((ndo, " newtype")); 2098 UINTOUT(); 2099 ND_PRINT((ndo, " newname")); 2100 STROUT(AFSNAMEMAX); 2101 break; 2102 case 106: /* Set flags */ 2103 ND_PRINT((ndo, " trans")); 2104 UINTOUT(); 2105 ND_PRINT((ndo, " flags")); 2106 UINTOUT(); 2107 break; 2108 case 108: /* Trans create */ 2109 ND_PRINT((ndo, " vol")); 2110 UINTOUT(); 2111 ND_PRINT((ndo, " partition")); 2112 UINTOUT(); 2113 ND_PRINT((ndo, " flags")); 2114 UINTOUT(); 2115 break; 2116 case 109: /* Dump */ 2117 case 655537: /* Get size */ 2118 ND_PRINT((ndo, " fromtrans")); 2119 UINTOUT(); 2120 ND_PRINT((ndo, " fromdate")); 2121 DATEOUT(); 2122 break; 2123 case 110: /* Get n-th volume */ 2124 ND_PRINT((ndo, " index")); 2125 UINTOUT(); 2126 break; 2127 case 111: /* Set forwarding */ 2128 ND_PRINT((ndo, " tid")); 2129 UINTOUT(); 2130 ND_PRINT((ndo, " newsite")); 2131 UINTOUT(); 2132 break; 2133 case 112: /* Get name */ 2134 case 113: /* Get status */ 2135 ND_PRINT((ndo, " tid")); 2136 break; 2137 case 114: /* Signal restore */ 2138 ND_PRINT((ndo, " name")); 2139 STROUT(AFSNAMEMAX); 2140 ND_PRINT((ndo, " type")); 2141 UINTOUT(); 2142 ND_PRINT((ndo, " pid")); 2143 UINTOUT(); 2144 ND_PRINT((ndo, " cloneid")); 2145 UINTOUT(); 2146 break; 2147 case 116: /* List volumes */ 2148 ND_PRINT((ndo, " partition")); 2149 UINTOUT(); 2150 ND_PRINT((ndo, " flags")); 2151 UINTOUT(); 2152 break; 2153 case 117: /* Set id types */ 2154 ND_PRINT((ndo, " tid")); 2155 UINTOUT(); 2156 ND_PRINT((ndo, " name")); 2157 STROUT(AFSNAMEMAX); 2158 ND_PRINT((ndo, " type")); 2159 UINTOUT(); 2160 ND_PRINT((ndo, " pid")); 2161 UINTOUT(); 2162 ND_PRINT((ndo, " clone")); 2163 UINTOUT(); 2164 ND_PRINT((ndo, " backup")); 2165 UINTOUT(); 2166 break; 2167 case 119: /* Partition info */ 2168 ND_PRINT((ndo, " name")); 2169 STROUT(AFSNAMEMAX); 2170 break; 2171 case 120: /* Reclone */ 2172 ND_PRINT((ndo, " tid")); 2173 UINTOUT(); 2174 break; 2175 case 121: /* List one volume */ 2176 case 122: /* Nuke volume */ 2177 case 124: /* Extended List volumes */ 2178 case 125: /* Extended List one volume */ 2179 case 65536: /* Convert RO to RW volume */ 2180 ND_PRINT((ndo, " partid")); 2181 UINTOUT(); 2182 ND_PRINT((ndo, " volid")); 2183 UINTOUT(); 2184 break; 2185 case 123: /* Set date */ 2186 ND_PRINT((ndo, " tid")); 2187 UINTOUT(); 2188 ND_PRINT((ndo, " date")); 2189 DATEOUT(); 2190 break; 2191 case 126: /* Set info */ 2192 ND_PRINT((ndo, " tid")); 2193 UINTOUT(); 2194 break; 2195 case 128: /* Forward multiple */ 2196 ND_PRINT((ndo, " fromtrans")); 2197 UINTOUT(); 2198 ND_PRINT((ndo, " fromdate")); 2199 DATEOUT(); 2200 { 2201 unsigned long i, j; 2202 ND_TCHECK2(bp[0], 4); 2203 j = EXTRACT_32BITS(bp); 2204 bp += sizeof(int32_t); 2205 for (i = 0; i < j; i++) { 2206 DESTSERVEROUT(); 2207 if (i != j - 1) 2208 ND_PRINT((ndo, ",")); 2209 } 2210 if (j == 0) 2211 ND_PRINT((ndo, " <none!>")); 2212 } 2213 break; 2214 case 65538: /* Dump version 2 */ 2215 ND_PRINT((ndo, " fromtrans")); 2216 UINTOUT(); 2217 ND_PRINT((ndo, " fromdate")); 2218 DATEOUT(); 2219 ND_PRINT((ndo, " flags")); 2220 UINTOUT(); 2221 break; 2222 default: 2223 ; 2224 } 2225 return; 2226 2227 trunc: 2228 ND_PRINT((ndo, " [|vol]")); 2229 } 2230 2231 /* 2232 * Handle replies to the AFS Volume Service 2233 */ 2234 2235 static void 2236 vol_reply_print(netdissect_options *ndo, 2237 register const u_char *bp, int length, int32_t opcode) 2238 { 2239 struct rx_header *rxh; 2240 2241 if (length <= (int)sizeof(struct rx_header)) 2242 return; 2243 2244 rxh = (struct rx_header *) bp; 2245 2246 /* 2247 * Print out the afs call we're invoking. The table used here was 2248 * gleaned from volser/volint.xg 2249 */ 2250 2251 ND_PRINT((ndo, " vol reply %s", tok2str(vol_req, "op#%d", opcode))); 2252 2253 bp += sizeof(struct rx_header); 2254 2255 /* 2256 * If it was a data packet, interpret the response. 2257 */ 2258 2259 if (rxh->type == RX_PACKET_TYPE_DATA) { 2260 switch (opcode) { 2261 case 100: /* Create volume */ 2262 ND_PRINT((ndo, " volid")); 2263 UINTOUT(); 2264 ND_PRINT((ndo, " trans")); 2265 UINTOUT(); 2266 break; 2267 case 104: /* End transaction */ 2268 UINTOUT(); 2269 break; 2270 case 105: /* Clone */ 2271 ND_PRINT((ndo, " newvol")); 2272 UINTOUT(); 2273 break; 2274 case 107: /* Get flags */ 2275 UINTOUT(); 2276 break; 2277 case 108: /* Transaction create */ 2278 ND_PRINT((ndo, " trans")); 2279 UINTOUT(); 2280 break; 2281 case 110: /* Get n-th volume */ 2282 ND_PRINT((ndo, " volume")); 2283 UINTOUT(); 2284 ND_PRINT((ndo, " partition")); 2285 UINTOUT(); 2286 break; 2287 case 112: /* Get name */ 2288 STROUT(AFSNAMEMAX); 2289 break; 2290 case 113: /* Get status */ 2291 ND_PRINT((ndo, " volid")); 2292 UINTOUT(); 2293 ND_PRINT((ndo, " nextuniq")); 2294 UINTOUT(); 2295 ND_PRINT((ndo, " type")); 2296 UINTOUT(); 2297 ND_PRINT((ndo, " parentid")); 2298 UINTOUT(); 2299 ND_PRINT((ndo, " clone")); 2300 UINTOUT(); 2301 ND_PRINT((ndo, " backup")); 2302 UINTOUT(); 2303 ND_PRINT((ndo, " restore")); 2304 UINTOUT(); 2305 ND_PRINT((ndo, " maxquota")); 2306 UINTOUT(); 2307 ND_PRINT((ndo, " minquota")); 2308 UINTOUT(); 2309 ND_PRINT((ndo, " owner")); 2310 UINTOUT(); 2311 ND_PRINT((ndo, " create")); 2312 DATEOUT(); 2313 ND_PRINT((ndo, " access")); 2314 DATEOUT(); 2315 ND_PRINT((ndo, " update")); 2316 DATEOUT(); 2317 ND_PRINT((ndo, " expire")); 2318 DATEOUT(); 2319 ND_PRINT((ndo, " backup")); 2320 DATEOUT(); 2321 ND_PRINT((ndo, " copy")); 2322 DATEOUT(); 2323 break; 2324 case 115: /* Old list partitions */ 2325 break; 2326 case 116: /* List volumes */ 2327 case 121: /* List one volume */ 2328 { 2329 unsigned long i, j; 2330 ND_TCHECK2(bp[0], 4); 2331 j = EXTRACT_32BITS(bp); 2332 bp += sizeof(int32_t); 2333 for (i = 0; i < j; i++) { 2334 ND_PRINT((ndo, " name")); 2335 VECOUT(32); 2336 ND_PRINT((ndo, " volid")); 2337 UINTOUT(); 2338 ND_PRINT((ndo, " type")); 2339 bp += sizeof(int32_t) * 21; 2340 if (i != j - 1) 2341 ND_PRINT((ndo, ",")); 2342 } 2343 if (j == 0) 2344 ND_PRINT((ndo, " <none!>")); 2345 } 2346 break; 2347 2348 2349 default: 2350 ; 2351 } 2352 } else { 2353 /* 2354 * Otherwise, just print out the return code 2355 */ 2356 ND_PRINT((ndo, " errcode")); 2357 INTOUT(); 2358 } 2359 2360 return; 2361 2362 trunc: 2363 ND_PRINT((ndo, " [|vol]")); 2364 } 2365 2366 /* 2367 * Handle calls to the AFS BOS service 2368 */ 2369 2370 static void 2371 bos_print(netdissect_options *ndo, 2372 register const u_char *bp, int length) 2373 { 2374 int bos_op; 2375 2376 if (length <= (int)sizeof(struct rx_header)) 2377 return; 2378 2379 if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) { 2380 goto trunc; 2381 } 2382 2383 /* 2384 * Print out the afs call we're invoking. The table used here was 2385 * gleaned from bozo/bosint.xg 2386 */ 2387 2388 bos_op = EXTRACT_32BITS(bp + sizeof(struct rx_header)); 2389 2390 ND_PRINT((ndo, " bos call %s", tok2str(bos_req, "op#%d", bos_op))); 2391 2392 /* 2393 * Decode some of the arguments to the BOS calls 2394 */ 2395 2396 bp += sizeof(struct rx_header) + 4; 2397 2398 switch (bos_op) { 2399 case 80: /* Create B node */ 2400 ND_PRINT((ndo, " type")); 2401 STROUT(BOSNAMEMAX); 2402 ND_PRINT((ndo, " instance")); 2403 STROUT(BOSNAMEMAX); 2404 break; 2405 case 81: /* Delete B node */ 2406 case 83: /* Get status */ 2407 case 85: /* Get instance info */ 2408 case 87: /* Add super user */ 2409 case 88: /* Delete super user */ 2410 case 93: /* Set cell name */ 2411 case 96: /* Add cell host */ 2412 case 97: /* Delete cell host */ 2413 case 104: /* Restart */ 2414 case 106: /* Uninstall */ 2415 case 108: /* Exec */ 2416 case 112: /* Getlog */ 2417 case 114: /* Get instance strings */ 2418 STROUT(BOSNAMEMAX); 2419 break; 2420 case 82: /* Set status */ 2421 case 98: /* Set T status */ 2422 STROUT(BOSNAMEMAX); 2423 ND_PRINT((ndo, " status")); 2424 INTOUT(); 2425 break; 2426 case 86: /* Get instance parm */ 2427 STROUT(BOSNAMEMAX); 2428 ND_PRINT((ndo, " num")); 2429 INTOUT(); 2430 break; 2431 case 84: /* Enumerate instance */ 2432 case 89: /* List super users */ 2433 case 90: /* List keys */ 2434 case 91: /* Add key */ 2435 case 92: /* Delete key */ 2436 case 95: /* Get cell host */ 2437 INTOUT(); 2438 break; 2439 case 105: /* Install */ 2440 STROUT(BOSNAMEMAX); 2441 ND_PRINT((ndo, " size")); 2442 INTOUT(); 2443 ND_PRINT((ndo, " flags")); 2444 INTOUT(); 2445 ND_PRINT((ndo, " date")); 2446 INTOUT(); 2447 break; 2448 default: 2449 ; 2450 } 2451 2452 return; 2453 2454 trunc: 2455 ND_PRINT((ndo, " [|bos]")); 2456 } 2457 2458 /* 2459 * Handle replies to the AFS BOS Service 2460 */ 2461 2462 static void 2463 bos_reply_print(netdissect_options *ndo, 2464 register const u_char *bp, int length, int32_t opcode) 2465 { 2466 struct rx_header *rxh; 2467 2468 if (length <= (int)sizeof(struct rx_header)) 2469 return; 2470 2471 rxh = (struct rx_header *) bp; 2472 2473 /* 2474 * Print out the afs call we're invoking. The table used here was 2475 * gleaned from volser/volint.xg 2476 */ 2477 2478 ND_PRINT((ndo, " bos reply %s", tok2str(bos_req, "op#%d", opcode))); 2479 2480 bp += sizeof(struct rx_header); 2481 2482 /* 2483 * If it was a data packet, interpret the response. 2484 */ 2485 2486 if (rxh->type == RX_PACKET_TYPE_DATA) 2487 /* Well, no, not really. Leave this for later */ 2488 ; 2489 else { 2490 /* 2491 * Otherwise, just print out the return code 2492 */ 2493 ND_PRINT((ndo, " errcode")); 2494 INTOUT(); 2495 } 2496 2497 return; 2498 2499 trunc: 2500 ND_PRINT((ndo, " [|bos]")); 2501 } 2502 2503 /* 2504 * Check to see if this is a Ubik opcode. 2505 */ 2506 2507 static int 2508 is_ubik(uint32_t opcode) 2509 { 2510 if ((opcode >= VOTE_LOW && opcode <= VOTE_HIGH) || 2511 (opcode >= DISK_LOW && opcode <= DISK_HIGH)) 2512 return(1); 2513 else 2514 return(0); 2515 } 2516 2517 /* 2518 * Handle Ubik opcodes to any one of the replicated database services 2519 */ 2520 2521 static void 2522 ubik_print(netdissect_options *ndo, 2523 register const u_char *bp) 2524 { 2525 int ubik_op; 2526 int32_t temp; 2527 2528 /* 2529 * Print out the afs call we're invoking. The table used here was 2530 * gleaned from ubik/ubik_int.xg 2531 */ 2532 2533 ubik_op = EXTRACT_32BITS(bp + sizeof(struct rx_header)); 2534 2535 ND_PRINT((ndo, " ubik call %s", tok2str(ubik_req, "op#%d", ubik_op))); 2536 2537 /* 2538 * Decode some of the arguments to the Ubik calls 2539 */ 2540 2541 bp += sizeof(struct rx_header) + 4; 2542 2543 switch (ubik_op) { 2544 case 10000: /* Beacon */ 2545 ND_TCHECK2(bp[0], 4); 2546 temp = EXTRACT_32BITS(bp); 2547 bp += sizeof(int32_t); 2548 ND_PRINT((ndo, " syncsite %s", temp ? "yes" : "no")); 2549 ND_PRINT((ndo, " votestart")); 2550 DATEOUT(); 2551 ND_PRINT((ndo, " dbversion")); 2552 UBIK_VERSIONOUT(); 2553 ND_PRINT((ndo, " tid")); 2554 UBIK_VERSIONOUT(); 2555 break; 2556 case 10003: /* Get sync site */ 2557 ND_PRINT((ndo, " site")); 2558 UINTOUT(); 2559 break; 2560 case 20000: /* Begin */ 2561 case 20001: /* Commit */ 2562 case 20007: /* Abort */ 2563 case 20008: /* Release locks */ 2564 case 20010: /* Writev */ 2565 ND_PRINT((ndo, " tid")); 2566 UBIK_VERSIONOUT(); 2567 break; 2568 case 20002: /* Lock */ 2569 ND_PRINT((ndo, " tid")); 2570 UBIK_VERSIONOUT(); 2571 ND_PRINT((ndo, " file")); 2572 INTOUT(); 2573 ND_PRINT((ndo, " pos")); 2574 INTOUT(); 2575 ND_PRINT((ndo, " length")); 2576 INTOUT(); 2577 temp = EXTRACT_32BITS(bp); 2578 bp += sizeof(int32_t); 2579 tok2str(ubik_lock_types, "type %d", temp); 2580 break; 2581 case 20003: /* Write */ 2582 ND_PRINT((ndo, " tid")); 2583 UBIK_VERSIONOUT(); 2584 ND_PRINT((ndo, " file")); 2585 INTOUT(); 2586 ND_PRINT((ndo, " pos")); 2587 INTOUT(); 2588 break; 2589 case 20005: /* Get file */ 2590 ND_PRINT((ndo, " file")); 2591 INTOUT(); 2592 break; 2593 case 20006: /* Send file */ 2594 ND_PRINT((ndo, " file")); 2595 INTOUT(); 2596 ND_PRINT((ndo, " length")); 2597 INTOUT(); 2598 ND_PRINT((ndo, " dbversion")); 2599 UBIK_VERSIONOUT(); 2600 break; 2601 case 20009: /* Truncate */ 2602 ND_PRINT((ndo, " tid")); 2603 UBIK_VERSIONOUT(); 2604 ND_PRINT((ndo, " file")); 2605 INTOUT(); 2606 ND_PRINT((ndo, " length")); 2607 INTOUT(); 2608 break; 2609 case 20012: /* Set version */ 2610 ND_PRINT((ndo, " tid")); 2611 UBIK_VERSIONOUT(); 2612 ND_PRINT((ndo, " oldversion")); 2613 UBIK_VERSIONOUT(); 2614 ND_PRINT((ndo, " newversion")); 2615 UBIK_VERSIONOUT(); 2616 break; 2617 default: 2618 ; 2619 } 2620 2621 return; 2622 2623 trunc: 2624 ND_PRINT((ndo, " [|ubik]")); 2625 } 2626 2627 /* 2628 * Handle Ubik replies to any one of the replicated database services 2629 */ 2630 2631 static void 2632 ubik_reply_print(netdissect_options *ndo, 2633 register const u_char *bp, int length, int32_t opcode) 2634 { 2635 struct rx_header *rxh; 2636 2637 if (length < (int)sizeof(struct rx_header)) 2638 return; 2639 2640 rxh = (struct rx_header *) bp; 2641 2642 /* 2643 * Print out the ubik call we're invoking. This table was gleaned 2644 * from ubik/ubik_int.xg 2645 */ 2646 2647 ND_PRINT((ndo, " ubik reply %s", tok2str(ubik_req, "op#%d", opcode))); 2648 2649 bp += sizeof(struct rx_header); 2650 2651 /* 2652 * If it was a data packet, print out the arguments to the Ubik calls 2653 */ 2654 2655 if (rxh->type == RX_PACKET_TYPE_DATA) 2656 switch (opcode) { 2657 case 10000: /* Beacon */ 2658 ND_PRINT((ndo, " vote no")); 2659 break; 2660 case 20004: /* Get version */ 2661 ND_PRINT((ndo, " dbversion")); 2662 UBIK_VERSIONOUT(); 2663 break; 2664 default: 2665 ; 2666 } 2667 2668 /* 2669 * Otherwise, print out "yes" it it was a beacon packet (because 2670 * that's how yes votes are returned, go figure), otherwise 2671 * just print out the error code. 2672 */ 2673 2674 else 2675 switch (opcode) { 2676 case 10000: /* Beacon */ 2677 ND_PRINT((ndo, " vote yes until")); 2678 DATEOUT(); 2679 break; 2680 default: 2681 ND_PRINT((ndo, " errcode")); 2682 INTOUT(); 2683 } 2684 2685 return; 2686 2687 trunc: 2688 ND_PRINT((ndo, " [|ubik]")); 2689 } 2690 2691 /* 2692 * Handle RX ACK packets. 2693 */ 2694 2695 static void 2696 rx_ack_print(netdissect_options *ndo, 2697 register const u_char *bp, int length) 2698 { 2699 struct rx_ackPacket *rxa; 2700 int i, start, last; 2701 uint32_t firstPacket; 2702 2703 if (length < (int)sizeof(struct rx_header)) 2704 return; 2705 2706 bp += sizeof(struct rx_header); 2707 2708 /* 2709 * This may seem a little odd .... the rx_ackPacket structure 2710 * contains an array of individual packet acknowledgements 2711 * (used for selective ack/nack), but since it's variable in size, 2712 * we don't want to truncate based on the size of the whole 2713 * rx_ackPacket structure. 2714 */ 2715 2716 ND_TCHECK2(bp[0], sizeof(struct rx_ackPacket) - RX_MAXACKS); 2717 2718 rxa = (struct rx_ackPacket *) bp; 2719 bp += (sizeof(struct rx_ackPacket) - RX_MAXACKS); 2720 2721 /* 2722 * Print out a few useful things from the ack packet structure 2723 */ 2724 2725 if (ndo->ndo_vflag > 2) 2726 ND_PRINT((ndo, " bufspace %d maxskew %d", 2727 (int) EXTRACT_16BITS(&rxa->bufferSpace), 2728 (int) EXTRACT_16BITS(&rxa->maxSkew))); 2729 2730 firstPacket = EXTRACT_32BITS(&rxa->firstPacket); 2731 ND_PRINT((ndo, " first %d serial %d reason %s", 2732 firstPacket, EXTRACT_32BITS(&rxa->serial), 2733 tok2str(rx_ack_reasons, "#%d", (int) rxa->reason))); 2734 2735 /* 2736 * Okay, now we print out the ack array. The way _this_ works 2737 * is that we start at "first", and step through the ack array. 2738 * If we have a contiguous range of acks/nacks, try to 2739 * collapse them into a range. 2740 * 2741 * If you're really clever, you might have noticed that this 2742 * doesn't seem quite correct. Specifically, due to structure 2743 * padding, sizeof(struct rx_ackPacket) - RX_MAXACKS won't actually 2744 * yield the start of the ack array (because RX_MAXACKS is 255 2745 * and the structure will likely get padded to a 2 or 4 byte 2746 * boundary). However, this is the way it's implemented inside 2747 * of AFS - the start of the extra fields are at 2748 * sizeof(struct rx_ackPacket) - RX_MAXACKS + nAcks, which _isn't_ 2749 * the exact start of the ack array. Sigh. That's why we aren't 2750 * using bp, but instead use rxa->acks[]. But nAcks gets added 2751 * to bp after this, so bp ends up at the right spot. Go figure. 2752 */ 2753 2754 if (rxa->nAcks != 0) { 2755 2756 ND_TCHECK2(bp[0], rxa->nAcks); 2757 2758 /* 2759 * Sigh, this is gross, but it seems to work to collapse 2760 * ranges correctly. 2761 */ 2762 2763 for (i = 0, start = last = -2; i < rxa->nAcks; i++) 2764 if (rxa->acks[i] == RX_ACK_TYPE_ACK) { 2765 2766 /* 2767 * I figured this deserved _some_ explanation. 2768 * First, print "acked" and the packet seq 2769 * number if this is the first time we've 2770 * seen an acked packet. 2771 */ 2772 2773 if (last == -2) { 2774 ND_PRINT((ndo, " acked %d", firstPacket + i)); 2775 start = i; 2776 } 2777 2778 /* 2779 * Otherwise, if there is a skip in 2780 * the range (such as an nacked packet in 2781 * the middle of some acked packets), 2782 * then print the current packet number 2783 * seperated from the last number by 2784 * a comma. 2785 */ 2786 2787 else if (last != i - 1) { 2788 ND_PRINT((ndo, ",%d", firstPacket + i)); 2789 start = i; 2790 } 2791 2792 /* 2793 * We always set last to the value of 2794 * the last ack we saw. Conversely, start 2795 * is set to the value of the first ack 2796 * we saw in a range. 2797 */ 2798 2799 last = i; 2800 2801 /* 2802 * Okay, this bit a code gets executed when 2803 * we hit a nack ... in _this_ case we 2804 * want to print out the range of packets 2805 * that were acked, so we need to print 2806 * the _previous_ packet number seperated 2807 * from the first by a dash (-). Since we 2808 * already printed the first packet above, 2809 * just print the final packet. Don't 2810 * do this if there will be a single-length 2811 * range. 2812 */ 2813 } else if (last == i - 1 && start != last) 2814 ND_PRINT((ndo, "-%d", firstPacket + i - 1)); 2815 2816 /* 2817 * So, what's going on here? We ran off the end of the 2818 * ack list, and if we got a range we need to finish it up. 2819 * So we need to determine if the last packet in the list 2820 * was an ack (if so, then last will be set to it) and 2821 * we need to see if the last range didn't start with the 2822 * last packet (because if it _did_, then that would mean 2823 * that the packet number has already been printed and 2824 * we don't need to print it again). 2825 */ 2826 2827 if (last == i - 1 && start != last) 2828 ND_PRINT((ndo, "-%d", firstPacket + i - 1)); 2829 2830 /* 2831 * Same as above, just without comments 2832 */ 2833 2834 for (i = 0, start = last = -2; i < rxa->nAcks; i++) 2835 if (rxa->acks[i] == RX_ACK_TYPE_NACK) { 2836 if (last == -2) { 2837 ND_PRINT((ndo, " nacked %d", firstPacket + i)); 2838 start = i; 2839 } else if (last != i - 1) { 2840 ND_PRINT((ndo, ",%d", firstPacket + i)); 2841 start = i; 2842 } 2843 last = i; 2844 } else if (last == i - 1 && start != last) 2845 ND_PRINT((ndo, "-%d", firstPacket + i - 1)); 2846 2847 if (last == i - 1 && start != last) 2848 ND_PRINT((ndo, "-%d", firstPacket + i - 1)); 2849 2850 bp += rxa->nAcks; 2851 } 2852 2853 2854 /* 2855 * These are optional fields; depending on your version of AFS, 2856 * you may or may not see them 2857 */ 2858 2859 #define TRUNCRET(n) if (ndo->ndo_snapend - bp + 1 <= n) return; 2860 2861 if (ndo->ndo_vflag > 1) { 2862 TRUNCRET(4); 2863 ND_PRINT((ndo, " ifmtu")); 2864 INTOUT(); 2865 2866 TRUNCRET(4); 2867 ND_PRINT((ndo, " maxmtu")); 2868 INTOUT(); 2869 2870 TRUNCRET(4); 2871 ND_PRINT((ndo, " rwind")); 2872 INTOUT(); 2873 2874 TRUNCRET(4); 2875 ND_PRINT((ndo, " maxpackets")); 2876 INTOUT(); 2877 } 2878 2879 return; 2880 2881 trunc: 2882 ND_PRINT((ndo, " [|ack]")); 2883 } 2884 #undef TRUNCRET 2885