X-Git-Url: https://git.tcpdump.org/tcpdump/blobdiff_plain/5d19d3c0ac649a19d1693db14d0d16526c23e052..refs/pull/433/head:/print-rx.c

diff --git a/print-rx.c b/print-rx.c
index 1d1ae50f..8a9babbc 100644
--- a/print-rx.c
+++ b/print-rx.c
@@ -1,3 +1,25 @@
+/*
+ * Copyright: (c) 2000 United States Government as represented by the
+ *	Secretary of the Navy. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   1. Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *   2. Redistributions in binary form must reproduce the above copyright
+ *      notice, this list of conditions and the following disclaimer in
+ *      the documentation and/or other materials provided with the
+ *      distribution.
+ *   3. The names of the authors may not be used to endorse or promote
+ *      products derived from this software without specific prior
+ *      written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
 /*
  * This code unmangles RX packets.  RX is the mutant form of RPC that AFS
  * uses to communicate between clients and servers.
@@ -8,32 +30,105 @@
  * Bah.  If I never look at rx_packet.h again, it will be too soon.
  *
  * Ken Hornstein <kenh@cmf.nrl.navy.mil>
- *
  */
 
-#ifndef lint
-static char rcsid[] =
-    "@(#) $Id: print-rx.c,v 1.1 1999-11-17 05:45:58 assar Exp $";
+#define NETDISSECT_REWORKED
+#ifdef HAVE_CONFIG_H
+#include "config.h"
 #endif
 
-#include <sys/param.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/socket.h>
 #include <stdio.h>
-#include <netinet/in.h>
-#include <netinet/in_systm.h>
-#include <netinet/ip.h>
+#include <stdlib.h>
+#include <string.h>
+#include <tcpdump-stdinc.h>
 
 #include "interface.h"
 #include "addrtoname.h"
+#include "extract.h"
+
+#include "ip.h"
+
+#define FS_RX_PORT	7000
+#define CB_RX_PORT	7001
+#define PROT_RX_PORT	7002
+#define VLDB_RX_PORT	7003
+#define KAUTH_RX_PORT	7004
+#define VOL_RX_PORT	7005
+#define ERROR_RX_PORT	7006		/* Doesn't seem to be used */
+#define BOS_RX_PORT	7007
+
+#define AFSNAMEMAX 256
+#define AFSOPAQUEMAX 1024
+#define PRNAMEMAX 64
+#define VLNAMEMAX 65
+#define KANAMEMAX 64
+#define BOSNAMEMAX 256
+
+#define	PRSFS_READ		1 /* Read files */
+#define	PRSFS_WRITE		2 /* Write files */
+#define	PRSFS_INSERT		4 /* Insert files into a directory */
+#define	PRSFS_LOOKUP		8 /* Lookup files into a directory */
+#define	PRSFS_DELETE		16 /* Delete files */
+#define	PRSFS_LOCK		32 /* Lock files */
+#define	PRSFS_ADMINISTER	64 /* Change ACL's */
+
+struct rx_header {
+	uint32_t epoch;
+	uint32_t cid;
+	uint32_t callNumber;
+	uint32_t seq;
+	uint32_t serial;
+	uint8_t type;
+#define RX_PACKET_TYPE_DATA		1
+#define RX_PACKET_TYPE_ACK		2
+#define RX_PACKET_TYPE_BUSY		3
+#define RX_PACKET_TYPE_ABORT		4
+#define RX_PACKET_TYPE_ACKALL		5
+#define RX_PACKET_TYPE_CHALLENGE	6
+#define RX_PACKET_TYPE_RESPONSE		7
+#define RX_PACKET_TYPE_DEBUG		8
+#define RX_PACKET_TYPE_PARAMS		9
+#define RX_PACKET_TYPE_VERSION		13
+	uint8_t flags;
+#define RX_CLIENT_INITIATED	1
+#define RX_REQUEST_ACK		2
+#define RX_LAST_PACKET		4
+#define RX_MORE_PACKETS		8
+#define RX_FREE_PACKET		16
+#define RX_SLOW_START_OK	32
+#define RX_JUMBO_PACKET		32
+	uint8_t userStatus;
+	uint8_t securityIndex;
+	uint16_t spare;		/* How clever: even though the AFS */
+	uint16_t serviceId;		/* header files indicate that the */
+};					/* serviceId is first, it's really */
+					/* encoded _after_ the spare field */
+					/* I wasted a day figuring that out! */
+
+#define NUM_RX_FLAGS 7
+
+#define RX_MAXACKS 255
+
+struct rx_ackPacket {
+	uint16_t bufferSpace;		/* Number of packet buffers available */
+	uint16_t maxSkew;		/* Max diff between ack'd packet and */
+					/* highest packet received */
+	uint32_t firstPacket;		/* The first packet in ack list */
+	uint32_t previousPacket;	/* Previous packet recv'd (obsolete) */
+	uint32_t serial;		/* # of packet that prompted the ack */
+	uint8_t reason;		/* Reason for acknowledgement */
+	uint8_t nAcks;			/* Number of acknowledgements */
+	uint8_t acks[RX_MAXACKS];	/* Up to RX_MAXACKS acknowledgements */
+};
 
-#undef NOERROR					/* Solaris sucks */
-#include <arpa/nameser.h>
+/*
+ * Values for the acks array
+ */
 
-#include "rx.h"
+#define RX_ACK_TYPE_NACK	0	/* Don't have this packet */
+#define RX_ACK_TYPE_ACK		1	/* I have this packet */
 
-static struct tok rx_types[] = {
+static const struct tok rx_types[] = {
 	{ RX_PACKET_TYPE_DATA,		"data" },
 	{ RX_PACKET_TYPE_ACK,		"ack" },
 	{ RX_PACKET_TYPE_BUSY,		"busy" },
@@ -47,15 +142,21 @@ static struct tok rx_types[] = {
 	{ 0,				NULL },
 };
 
-static struct tok rx_flags[] = {
-	{ RX_CLIENT_INITIATED,	"client-init" },
-	{ RX_REQUEST_ACK,	"req-ack" },
-	{ RX_LAST_PACKET,	"last-pckt" },
-	{ RX_MORE_PACKETS,	"more-pckts" },
-	{ RX_FREE_PACKET,	"free-pckt" }
+static const struct double_tok {
+	int flag;		/* Rx flag */
+	int packetType;		/* Packet type */
+	const char *s;		/* Flag string */
+} rx_flags[] = {
+	{ RX_CLIENT_INITIATED,	0,			"client-init" },
+	{ RX_REQUEST_ACK,	0,			"req-ack" },
+	{ RX_LAST_PACKET,	0,			"last-pckt" },
+	{ RX_MORE_PACKETS,	0,			"more-pckts" },
+	{ RX_FREE_PACKET,	0,			"free-pckt" },
+	{ RX_SLOW_START_OK,	RX_PACKET_TYPE_ACK,	"slow-start" },
+	{ RX_JUMBO_PACKET,	RX_PACKET_TYPE_DATA,	"jumbogram" }
 };
 
-static struct tok fs_req[] = {
+static const struct tok fs_req[] = {
 	{ 130,		"fetch-data" },
 	{ 131,		"fetch-acl" },
 	{ 132,		"fetch-status" },
@@ -90,10 +191,17 @@ static struct tok fs_req[] = {
 	{ 161,		"dfs-lookup" },
 	{ 162,		"dfs-flushcps" },
 	{ 163,		"dfs-symlink" },
+	{ 220,		"residency" },
+	{ 65536,        "inline-bulk-status" },
+	{ 65537,        "fetch-data-64" },
+	{ 65538,        "store-data-64" },
+	{ 65539,        "give-up-all-cbs" },
+	{ 65540,        "get-caps" },
+	{ 65541,        "cb-rx-conn-addr" },
 	{ 0,		NULL },
 };
 
-static struct tok cb_req[] = {
+static const struct tok cb_req[] = {
 	{ 204,		"callback" },
 	{ 205,		"initcb" },
 	{ 206,		"probe" },
@@ -105,10 +213,17 @@ static struct tok cb_req[] = {
 	{ 212,		"whoareyou" },
 	{ 213,		"initcb3" },
 	{ 214,		"probeuuid" },
+	{ 215,		"getsrvprefs" },
+	{ 216,		"getcellservdb" },
+	{ 217,		"getlocalcell" },
+	{ 218,		"getcacheconf" },
+	{ 65536,        "getce64" },
+	{ 65537,        "getcellbynum" },
+	{ 65538,        "tellmeaboutyourself" },
 	{ 0,		NULL },
 };
 
-static struct tok pt_req[] = {
+static const struct tok pt_req[] = {
 	{ 500,		"new-user" },
 	{ 501,		"where-is-it" },
 	{ 502,		"dump-entry" },
@@ -130,10 +245,12 @@ static struct tok pt_req[] = {
 	{ 518,		"get-cps2" },
 	{ 519,		"get-host-cps" },
 	{ 520,		"update-entry" },
+	{ 521,		"list-entries" },
+	{ 530,		"list-super-groups" },
 	{ 0,		NULL },
 };
 
-static struct tok vldb_req[] = {
+static const struct tok vldb_req[] = {
 	{ 501,		"create-entry" },
 	{ 502,		"delete-entry" },
 	{ 503,		"get-entry-by-id" },
@@ -167,10 +284,11 @@ static struct tok vldb_req[] = {
 	{ 531,		"linked-list-u" },
 	{ 532,		"regaddr" },
 	{ 533,		"get-addrs-u" },
+	{ 534,		"list-attrib-n2" },
 	{ 0,		NULL },
 };
 
-static struct tok kauth_req[] = {
+static const struct tok kauth_req[] = {
 	{ 1,		"auth-old" },
 	{ 21,		"authenticate" },
 	{ 22,		"authenticate-v2" },
@@ -192,7 +310,7 @@ static struct tok kauth_req[] = {
 	{ 0,		NULL },
 };
 
-static struct tok vol_req[] = {
+static const struct tok vol_req[] = {
 	{ 100,		"create-volume" },
 	{ 101,		"delete-volume" },
 	{ 102,		"restore" },
@@ -222,10 +340,13 @@ static struct tok vol_req[] = {
 	{ 126,		"set-info" },
 	{ 127,		"x-list-partitions" },
 	{ 128,		"forward-multiple" },
+	{ 65536,	"convert-ro" },
+	{ 65537,	"get-size" },
+	{ 65538,	"dump-v2" },
 	{ 0,		NULL },
 };
 
-static struct tok bos_req[] = {
+static const struct tok bos_req[] = {
 	{ 80,		"create-bnode" },
 	{ 81,		"delete-bnode" },
 	{ 82,		"set-status" },
@@ -261,16 +382,20 @@ static struct tok bos_req[] = {
 	{ 112,		"start-bozo-log" },
 	{ 113,		"wait-all" },
 	{ 114,		"get-instance-strings" },
+	{ 115,		"get-restricted" },
+	{ 116,		"set-restricted" },
 	{ 0,		NULL },
 };
 
-static struct tok ubik_req[] = {
+static const struct tok ubik_req[] = {
 	{ 10000,	"vote-beacon" },
 	{ 10001,	"vote-debug-old" },
 	{ 10002,	"vote-sdebug-old" },
 	{ 10003,	"vote-getsyncsite" },
 	{ 10004,	"vote-debug" },
 	{ 10005,	"vote-sdebug" },
+	{ 10006,	"vote-xdebug" },
+	{ 10007,	"vote-xsdebug" },
 	{ 20000,	"disk-begin" },
 	{ 20001,	"disk-commit" },
 	{ 20002,	"disk-lock" },
@@ -289,25 +414,59 @@ static struct tok ubik_req[] = {
 };
 
 #define VOTE_LOW	10000
-#define VOTE_HIGH	10005
+#define VOTE_HIGH	10007
 #define DISK_LOW	20000
 #define DISK_HIGH	20013
 
-static struct tok cb_types[] = {
+static const struct tok cb_types[] = {
 	{ 1,		"exclusive" },
 	{ 2,		"shared" },
 	{ 3,		"dropped" },
 	{ 0,		NULL },
 };
 
-static struct tok ubik_lock_types[] = {
+static const struct tok ubik_lock_types[] = {
 	{ 1,		"read" },
 	{ 2,		"write" },
 	{ 3,		"wait" },
 	{ 0,		NULL },
 };
 
-static char *voltype[] = { "read-write", "read-only", "backup" };
+static const char *voltype[] = { "read-write", "read-only", "backup" };
+
+static const struct tok afs_fs_errors[] = {
+	{ 101,		"salvage volume" },
+	{ 102, 		"no such vnode" },
+	{ 103, 		"no such volume" },
+	{ 104, 		"volume exist" },
+	{ 105, 		"no service" },
+	{ 106, 		"volume offline" },
+	{ 107, 		"voline online" },
+	{ 108, 		"diskfull" },
+	{ 109, 		"diskquota exceeded" },
+	{ 110, 		"volume busy" },
+	{ 111, 		"volume moved" },
+	{ 112, 		"AFS IO error" },
+	{ 0xffffff9c,	"restarting fileserver" }, /* -100, sic! */
+	{ 0,		NULL }
+};
+
+/*
+ * Reasons for acknowledging a packet
+ */
+
+static const struct tok rx_ack_reasons[] = {
+	{ 1,		"ack requested" },
+	{ 2,		"duplicate packet" },
+	{ 3,		"out of sequence" },
+	{ 4,		"exceeds window" },
+	{ 5,		"no buffer space" },
+	{ 6,		"ping" },
+	{ 7,		"ping response" },
+	{ 8,		"delay" },
+	{ 9,		"idle" },
+	{ 0,		NULL },
+};
 
 /*
  * Cache entries we keep around so we can figure out the RX opcode
@@ -315,12 +474,12 @@ static char *voltype[] = { "read-write", "read-only", "backup" };
  */
 
 struct rx_cache_entry {
-	u_int32_t	callnum;	/* Call number (net order) */
+	uint32_t	callnum;	/* Call number (net order) */
 	struct in_addr	client;		/* client IP address (net order) */
 	struct in_addr	server;		/* server IP address (net order) */
 	int		dport;		/* server port (host order) */
 	u_short		serviceId;	/* Service identifier (net order) */
-	u_int32_t	opcode;		/* RX opcode (host order) */
+	uint32_t	opcode;		/* RX opcode (host order) */
 };
 
 #define RX_CACHE_SIZE	64
@@ -329,29 +488,31 @@ static struct rx_cache_entry	rx_cache[RX_CACHE_SIZE];
 
 static int	rx_cache_next = 0;
 static int	rx_cache_hint = 0;
-static void	rx_cache_insert(const u_char *, const struct ip *, int, int);
+static void	rx_cache_insert(netdissect_options *, const u_char *, const struct ip *, int);
 static int	rx_cache_find(const struct rx_header *, const struct ip *,
 			      int, int32_t *);
 
-static void fs_print(const u_char *, int);
-static void fs_reply_print(const u_char *, int, int32_t);
-static void acl_print(u_char *, u_char *);
-static void cb_print(const u_char *, int);
-static void cb_reply_print(const u_char *, int, int32_t);
-static void prot_print(const u_char *, int);
-static void prot_reply_print(const u_char *, int, int32_t);
-static void vldb_print(const u_char *, int);
-static void vldb_reply_print(const u_char *, int, int32_t);
-static void kauth_print(const u_char *, int);
-static void kauth_reply_print(const u_char *, int, int32_t);
-static void vol_print(const u_char *, int);
-static void vol_reply_print(const u_char *, int, int32_t);
-static void bos_print(const u_char *, int);
-static void bos_reply_print(const u_char *, int, int32_t);
-static void ubik_print(const u_char *, int);
-static void ubik_reply_print(const u_char *, int, int32_t);
-
-static int is_ubik(u_int32_t);
+static void fs_print(netdissect_options *, const u_char *, int);
+static void fs_reply_print(netdissect_options *, const u_char *, int, int32_t);
+static void acl_print(netdissect_options *, u_char *, int, u_char *);
+static void cb_print(netdissect_options *, const u_char *, int);
+static void cb_reply_print(netdissect_options *, const u_char *, int, int32_t);
+static void prot_print(netdissect_options *, const u_char *, int);
+static void prot_reply_print(netdissect_options *, const u_char *, int, int32_t);
+static void vldb_print(netdissect_options *, const u_char *, int);
+static void vldb_reply_print(netdissect_options *, const u_char *, int, int32_t);
+static void kauth_print(netdissect_options *, const u_char *, int);
+static void kauth_reply_print(netdissect_options *, const u_char *, int, int32_t);
+static void vol_print(netdissect_options *, const u_char *, int);
+static void vol_reply_print(netdissect_options *, const u_char *, int, int32_t);
+static void bos_print(netdissect_options *, const u_char *, int);
+static void bos_reply_print(netdissect_options *, const u_char *, int, int32_t);
+static void ubik_print(netdissect_options *, const u_char *);
+static void ubik_reply_print(netdissect_options *, const u_char *, int, int32_t);
+
+static void rx_ack_print(netdissect_options *, const u_char *, int);
+
+static int is_ubik(uint32_t);
 
 /*
  * Handle the rx-level packet.  See if we know what port it's going to so
@@ -359,44 +520,54 @@ static int is_ubik(u_int32_t);
  */
 
 void
-rx_print(register const u_char *bp, int length, int sport, int dport,
-	 u_char *bp2)
+rx_print(netdissect_options *ndo,
+         register const u_char *bp, int length, int sport, int dport,
+         u_char *bp2)
 {
 	register struct rx_header *rxh;
 	int i;
 	int32_t opcode;
 
-	if (snapend - bp < sizeof (struct rx_header)) {
-		printf(" [|rx] (%d)", length);
+	if (ndo->ndo_snapend - bp < (int)sizeof (struct rx_header)) {
+		ND_PRINT((ndo, " [|rx] (%d)", length));
 		return;
 	}
 
 	rxh = (struct rx_header *) bp;
 
-	printf(" rx %s", tok2str(rx_types, "type %d", rxh->type));
+	ND_PRINT((ndo, " rx %s", tok2str(rx_types, "type %d", rxh->type)));
 
-	if (vflag > 1) {
+	if (ndo->ndo_vflag) {
 		int firstflag = 0;
-		printf(" cid %08x call# %d seq %d ser %d",
-		       (int) ntohl(rxh->cid),
-		       (int) ntohl(rxh->callNumber),
-		       (int) ntohl(rxh->seq),
-		       (int) ntohl(rxh->serial));
-		if (vflag > 2)
-			printf(" secindex %d serviceid %hu",
+
+		if (ndo->ndo_vflag > 1)
+			ND_PRINT((ndo, " cid %08x call# %d",
+			       (int) EXTRACT_32BITS(&rxh->cid),
+			       (int) EXTRACT_32BITS(&rxh->callNumber)));
+
+		ND_PRINT((ndo, " seq %d ser %d",
+		       (int) EXTRACT_32BITS(&rxh->seq),
+		       (int) EXTRACT_32BITS(&rxh->serial)));
+
+		if (ndo->ndo_vflag > 2)
+			ND_PRINT((ndo, " secindex %d serviceid %hu",
 				(int) rxh->securityIndex,
-				ntohs(rxh->serviceId));
-		for (i = 0; i < NUM_RX_FLAGS; i++) {
-			if (rxh->flags & rx_flags[i].v) {
-				if (!firstflag) {
-					firstflag = 1;
-					printf(" ");
-				} else {
-					printf(",");
+				EXTRACT_16BITS(&rxh->serviceId)));
+
+		if (ndo->ndo_vflag > 1)
+			for (i = 0; i < NUM_RX_FLAGS; i++) {
+				if (rxh->flags & rx_flags[i].flag &&
+				    (!rx_flags[i].packetType ||
+				     rxh->type == rx_flags[i].packetType)) {
+					if (!firstflag) {
+						firstflag = 1;
+						ND_PRINT((ndo, " "));
+					} else {
+						ND_PRINT((ndo, ","));
+					}
+					ND_PRINT((ndo, "<%s>", rx_flags[i].s));
 				}
-				printf("<%s>", rx_flags[i].s);
 			}
-		}
 	}
 
 	/*
@@ -408,7 +579,8 @@ rx_print(register const u_char *bp, int length, int sport, int dport,
 	 * as well.
 	 */
 
-	if (rxh->type == RX_PACKET_TYPE_DATA && ntohl(rxh->seq) == 1 &&
+	if (rxh->type == RX_PACKET_TYPE_DATA &&
+	    EXTRACT_32BITS(&rxh->seq) == 1 &&
 	    rxh->flags & RX_CLIENT_INITIATED) {
 
 		/*
@@ -416,34 +588,34 @@ rx_print(register const u_char *bp, int length, int sport, int dport,
 		 * have a chance to print out replies
 		 */
 
-		rx_cache_insert(bp, (const struct ip *) bp2, dport, length);
+		rx_cache_insert(ndo, bp, (const struct ip *) bp2, dport);
 
 		switch (dport) {
 			case FS_RX_PORT:	/* AFS file service */
-				fs_print(bp, length);
+				fs_print(ndo, bp, length);
 				break;
 			case CB_RX_PORT:	/* AFS callback service */
-				cb_print(bp, length);
+				cb_print(ndo, bp, length);
 				break;
 			case PROT_RX_PORT:	/* AFS protection service */
-				prot_print(bp, length);
+				prot_print(ndo, bp, length);
 				break;
 			case VLDB_RX_PORT:	/* AFS VLDB service */
-				vldb_print(bp, length);
+				vldb_print(ndo, bp, length);
 				break;
 			case KAUTH_RX_PORT:	/* AFS Kerberos auth service */
-				kauth_print(bp, length);
+				kauth_print(ndo, bp, length);
 				break;
 			case VOL_RX_PORT:	/* AFS Volume service */
-				vol_print(bp, length);
+				vol_print(ndo, bp, length);
 				break;
 			case BOS_RX_PORT:	/* AFS BOS service */
-				bos_print(bp, length);
+				bos_print(ndo, bp, length);
 				break;
 			default:
 				;
 		}
-	
+
 	/*
 	 * If it's a reply (client-init is _not_ set, but seq is one)
 	 * then look it up in the cache.  If we find it, call the reply
@@ -452,7 +624,7 @@ rx_print(register const u_char *bp, int length, int sport, int dport,
 	 */
 
 	} else if (((rxh->type == RX_PACKET_TYPE_DATA &&
-						ntohl(rxh->seq) == 1) ||
+					EXTRACT_32BITS(&rxh->seq) == 1) ||
 		    rxh->type == RX_PACKET_TYPE_ABORT) &&
 		   (rxh->flags & RX_CLIENT_INITIATED) == 0 &&
 		   rx_cache_find(rxh, (const struct ip *) bp2,
@@ -460,33 +632,41 @@ rx_print(register const u_char *bp, int length, int sport, int dport,
 
 		switch (sport) {
 			case FS_RX_PORT:	/* AFS file service */
-				fs_reply_print(bp, length, opcode);
+				fs_reply_print(ndo, bp, length, opcode);
 				break;
 			case CB_RX_PORT:	/* AFS callback service */
-				cb_reply_print(bp, length, opcode);
+				cb_reply_print(ndo, bp, length, opcode);
 				break;
 			case PROT_RX_PORT:	/* AFS PT service */
-				prot_reply_print(bp, length, opcode);
+				prot_reply_print(ndo, bp, length, opcode);
 				break;
 			case VLDB_RX_PORT:	/* AFS VLDB service */
-				vldb_reply_print(bp, length, opcode);
+				vldb_reply_print(ndo, bp, length, opcode);
 				break;
 			case KAUTH_RX_PORT:	/* AFS Kerberos auth service */
-				kauth_reply_print(bp, length, opcode);
+				kauth_reply_print(ndo, bp, length, opcode);
 				break;
 			case VOL_RX_PORT:	/* AFS Volume service */
-				vol_reply_print(bp, length, opcode);
+				vol_reply_print(ndo, bp, length, opcode);
 				break;
 			case BOS_RX_PORT:	/* AFS BOS service */
-				bos_reply_print(bp, length, opcode);
+				bos_reply_print(ndo, bp, length, opcode);
 				break;
 			default:
 				;
 		}
-	}
+
+	/*
+	 * If it's an RX ack packet, then use the appropriate ack decoding
+	 * function (there isn't any service-specific information in the
+	 * ack packet, so we can use one for all AFS services)
+	 */
+
+	} else if (rxh->type == RX_PACKET_TYPE_ACK)
+		rx_ack_print(ndo, bp, length);
 
 
-	printf(" (%d)", length);
+	ND_PRINT((ndo, " (%d)", length));
 }
 
 /*
@@ -494,26 +674,26 @@ rx_print(register const u_char *bp, int length, int sport, int dport,
  */
 
 static void
-rx_cache_insert(const u_char *bp, const struct ip *ip, int dport,
-		int length)
+rx_cache_insert(netdissect_options *ndo,
+                const u_char *bp, const struct ip *ip, int dport)
 {
 	struct rx_cache_entry *rxent;
 	const struct rx_header *rxh = (const struct rx_header *) bp;
 
-	if (snapend - bp + 1 <= sizeof(struct rx_header) + sizeof(int32_t))
+	if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t)))
 		return;
 
 	rxent = &rx_cache[rx_cache_next];
 
 	if (++rx_cache_next >= RX_CACHE_SIZE)
 		rx_cache_next = 0;
-	
+
 	rxent->callnum = rxh->callNumber;
 	rxent->client = ip->ip_src;
 	rxent->server = ip->ip_dst;
 	rxent->dport = dport;
 	rxent->serviceId = rxh->serviceId;
-	rxent->opcode = ntohl(*((int *) (bp + sizeof(struct rx_header))));
+	rxent->opcode = EXTRACT_32BITS(bp + sizeof(struct rx_header));
 }
 
 /*
@@ -529,8 +709,8 @@ rx_cache_find(const struct rx_header *rxh, const struct ip *ip, int sport,
 {
 	int i;
 	struct rx_cache_entry *rxent;
-	u_int32_t clip = ip->ip_dst.s_addr;
-	u_int32_t sip = ip->ip_src.s_addr;
+	uint32_t clip = ip->ip_dst.s_addr;
+	uint32_t sip = ip->ip_src.s_addr;
 
 	/* Start the search where we last left off */
 
@@ -539,7 +719,7 @@ rx_cache_find(const struct rx_header *rxh, const struct ip *ip, int sport,
 		rxent = &rx_cache[i];
 		if (rxent->callnum == rxh->callNumber &&
 		    rxent->client.s_addr == clip &&
-		    rxent->server.s_addr == sip && 
+		    rxent->server.s_addr == sip &&
 		    rxent->serviceId == rxh->serviceId &&
 		    rxent->dport == sport) {
 
@@ -549,7 +729,7 @@ rx_cache_find(const struct rx_header *rxh, const struct ip *ip, int sport,
 			*opcode = rxent->opcode;
 			return(1);
 		}
-		if (++i > RX_CACHE_SIZE)
+		if (++i >= RX_CACHE_SIZE)
 			i = 0;
 	} while (i != rx_cache_hint);
 
@@ -561,76 +741,102 @@ rx_cache_find(const struct rx_header *rxh, const struct ip *ip, int sport,
  * These extrememly grody macros handle the printing of various AFS stuff.
  */
 
-#define TRUNC(n) if (snapend - bp + 1 <= n) goto trunc;
 #define FIDOUT() { unsigned long n1, n2, n3; \
-			TRUNC(sizeof(int32_t) * 3); \
-			n1 = ntohl(*((int *) bp)); \
+			ND_TCHECK2(bp[0], sizeof(int32_t) * 3); \
+			n1 = EXTRACT_32BITS(bp); \
 			bp += sizeof(int32_t); \
-			n2 = ntohl(*((int *) bp)); \
+			n2 = EXTRACT_32BITS(bp); \
 			bp += sizeof(int32_t); \
-			n3 = ntohl(*((int *) bp)); \
+			n3 = EXTRACT_32BITS(bp); \
 			bp += sizeof(int32_t); \
-			printf(" fid %d/%d/%d", (int) n1, (int) n2, (int) n3); \
+			ND_PRINT((ndo, " fid %d/%d/%d", (int) n1, (int) n2, (int) n3)); \
 		}
 
-#define STROUT(MAX) { int i; \
-			TRUNC(sizeof(int32_t)); \
-			i = (int) ntohl(*((int *) bp)); \
+#define STROUT(MAX) { unsigned int i; \
+			ND_TCHECK2(bp[0], sizeof(int32_t)); \
+			i = EXTRACT_32BITS(bp); \
+			if (i > (MAX)) \
+				goto trunc; \
 			bp += sizeof(int32_t); \
-			TRUNC(i); \
-			strncpy(s, bp, min(MAX, i)); \
-			s[i] = '\0'; \
-			printf(" \"%s\"", s); \
+			ND_PRINT((ndo, " \"")); \
+			if (fn_printn(ndo, bp, i, ndo->ndo_snapend)) \
+				goto trunc; \
+			ND_PRINT((ndo, "\"")); \
 			bp += ((i + sizeof(int32_t) - 1) / sizeof(int32_t)) * sizeof(int32_t); \
 		}
 
 #define INTOUT() { int i; \
-			TRUNC(sizeof(int32_t)); \
-			i = (int) ntohl(*((int *) bp)); \
+			ND_TCHECK2(bp[0], sizeof(int32_t)); \
+			i = (int) EXTRACT_32BITS(bp); \
 			bp += sizeof(int32_t); \
-			printf(" %d", i); \
+			ND_PRINT((ndo, " %d", i)); \
 		}
 
 #define UINTOUT() { unsigned long i; \
-			TRUNC(sizeof(int32_t)); \
-			i = ntohl(*((int *) bp)); \
+			ND_TCHECK2(bp[0], sizeof(int32_t)); \
+			i = EXTRACT_32BITS(bp); \
 			bp += sizeof(int32_t); \
-			printf(" %lu", i); \
+			ND_PRINT((ndo, " %lu", i)); \
+		}
+
+#define UINT64OUT() { uint64_t i; \
+			ND_TCHECK2(bp[0], sizeof(uint64_t)); \
+			i = EXTRACT_64BITS(bp); \
+			bp += sizeof(uint64_t); \
+			ND_PRINT((ndo, " %" PRIu64, i)); \
 		}
 
 #define DATEOUT() { time_t t; struct tm *tm; char str[256]; \
-			TRUNC(sizeof(int32_t)); \
-			t = (time_t) ntohl(*((int *) bp)); \
+			ND_TCHECK2(bp[0], sizeof(int32_t)); \
+			t = (time_t) EXTRACT_32BITS(bp); \
 			bp += sizeof(int32_t); \
 			tm = localtime(&t); \
-			strftime(str, 256, "%D %T", tm); \
-			printf(" %s", str); \
+			strftime(str, 256, "%Y/%m/%d %T", tm); \
+			ND_PRINT((ndo, " %s", str)); \
+		}
+
+#define STOREATTROUT() { unsigned long mask, i; \
+			ND_TCHECK2(bp[0], (sizeof(int32_t)*6)); \
+			mask = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
+			if (mask) ND_PRINT((ndo, " StoreStatus")); \
+		        if (mask & 1) { ND_PRINT((ndo, " date")); DATEOUT(); } \
+			else bp += sizeof(int32_t); \
+			i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
+		        if (mask & 2) ND_PRINT((ndo, " owner %lu", i));  \
+			i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
+		        if (mask & 4) ND_PRINT((ndo, " group %lu", i)); \
+			i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
+		        if (mask & 8) ND_PRINT((ndo, " mode %lo", i & 07777)); \
+			i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
+		        if (mask & 16) ND_PRINT((ndo, " segsize %lu", i)); \
+			/* undocumented in 3.3 docu */ \
+		        if (mask & 1024) ND_PRINT((ndo, " fsync"));  \
 		}
 
 #define UBIK_VERSIONOUT() {int32_t epoch; int32_t counter; \
-			TRUNC(sizeof(int32_t) * 2); \
-			epoch = ntohl(*((int *) bp)); \
+			ND_TCHECK2(bp[0], sizeof(int32_t) * 2); \
+			epoch = EXTRACT_32BITS(bp); \
 			bp += sizeof(int32_t); \
-			counter = ntohl(*((int *) bp)); \
+			counter = EXTRACT_32BITS(bp); \
 			bp += sizeof(int32_t); \
-			printf(" %d.%d", epoch, counter); \
+			ND_PRINT((ndo, " %d.%d", epoch, counter)); \
 		}
 
-#define AFSUUIDOUT() {u_int32_t temp; int i; \
-			TRUNC(11*sizeof(u_int32_t)); \
-			temp = ntohl(*((int *) bp)); \
-			bp += sizeof(u_int32_t); \
-			printf(" %08x", temp); \
-			temp = ntohl(*((int *) bp)); \
-			bp += sizeof(u_int32_t); \
-			printf("%04x", temp); \
-			temp = ntohl(*((int *) bp)); \
-			bp += sizeof(u_int32_t); \
-			printf("%04x", temp); \
+#define AFSUUIDOUT() {uint32_t temp; int i; \
+			ND_TCHECK2(bp[0], 11*sizeof(uint32_t)); \
+			temp = EXTRACT_32BITS(bp); \
+			bp += sizeof(uint32_t); \
+			ND_PRINT((ndo, " %08x", temp)); \
+			temp = EXTRACT_32BITS(bp); \
+			bp += sizeof(uint32_t); \
+			ND_PRINT((ndo, "%04x", temp)); \
+			temp = EXTRACT_32BITS(bp); \
+			bp += sizeof(uint32_t); \
+			ND_PRINT((ndo, "%04x", temp)); \
 			for (i = 0; i < 8; i++) { \
-				temp = ntohl(*((int *) bp)); \
-				bp += sizeof(u_int32_t); \
-				printf("%02x", (unsigned char) temp); \
+				temp = EXTRACT_32BITS(bp); \
+				bp += sizeof(uint32_t); \
+				ND_PRINT((ndo, "%02x", (unsigned char) temp)); \
 			} \
 		}
 
@@ -638,33 +844,49 @@ rx_cache_find(const struct rx_header *rxh, const struct ip *ip, int sport,
  * This is the sickest one of all
  */
 
-#define VECOUT(MAX) { char *sp; \
+#define VECOUT(MAX) { u_char *sp; \
+			u_char s[AFSNAMEMAX]; \
 			int k; \
-			TRUNC(MAX * sizeof(int32_t)); \
+			if ((MAX) + 1 > sizeof(s)) \
+				goto trunc; \
+			ND_TCHECK2(bp[0], (MAX) * sizeof(int32_t)); \
 			sp = s; \
-			for (k = 0; k < MAX; k++) { \
-				*sp++ = (char) ntohl(*((int *) bp)); \
+			for (k = 0; k < (MAX); k++) { \
+				*sp++ = (u_char) EXTRACT_32BITS(bp); \
 				bp += sizeof(int32_t); \
 			} \
-			s[MAX] = '\0'; \
-			printf(" \"%s\"", s); \
+			s[(MAX)] = '\0'; \
+			ND_PRINT((ndo, " \"")); \
+			fn_print(ndo, s, NULL); \
+			ND_PRINT((ndo, "\"")); \
+		}
+
+#define DESTSERVEROUT() { unsigned long n1, n2, n3; \
+			ND_TCHECK2(bp[0], sizeof(int32_t) * 3); \
+			n1 = EXTRACT_32BITS(bp); \
+			bp += sizeof(int32_t); \
+			n2 = EXTRACT_32BITS(bp); \
+			bp += sizeof(int32_t); \
+			n3 = EXTRACT_32BITS(bp); \
+			bp += sizeof(int32_t); \
+			ND_PRINT((ndo, " server %d:%d:%d", (int) n1, (int) n2, (int) n3)); \
 		}
 
 /*
  * Handle calls to the AFS file service (fs)
  */
 
-void
-fs_print(register const u_char *bp, int length)
+static void
+fs_print(netdissect_options *ndo,
+         register const u_char *bp, int length)
 {
 	int fs_op;
 	unsigned long i;
-	char s[AFSNAMEMAX];
 
-	if (length <= sizeof(struct rx_header))
+	if (length <= (int)sizeof(struct rx_header))
 		return;
 
-	if (snapend - bp + 1 <= sizeof(struct rx_header) + sizeof(int32_t)) {
+	if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
 		goto trunc;
 	}
 
@@ -673,9 +895,9 @@ fs_print(register const u_char *bp, int length)
 	 * gleaned from fsint/afsint.xg
 	 */
 
-	fs_op = ntohl(*((int *) (bp + sizeof(struct rx_header))));
+	fs_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
 
-	printf(" fs call %s", tok2str(fs_req, "op#%d", fs_op));
+	ND_PRINT((ndo, " fs call %s", tok2str(fs_req, "op#%d", fs_op)));
 
 	/*
 	 * Print out arguments to some of the AFS calls.  This stuff is
@@ -691,14 +913,13 @@ fs_print(register const u_char *bp, int length)
 	switch (fs_op) {
 		case 130:	/* Fetch data */
 			FIDOUT();
-			printf(" offset");
+			ND_PRINT((ndo, " offset"));
 			UINTOUT();
-			printf(" length");
+			ND_PRINT((ndo, " length"));
 			UINTOUT();
 			break;
 		case 131:	/* Fetch ACL */
 		case 132:	/* Fetch Status */
-		case 135:	/* Store status */
 		case 143:	/* Old set lock */
 		case 144:	/* Old extend lock */
 		case 145:	/* Old release lock */
@@ -707,55 +928,63 @@ fs_print(register const u_char *bp, int length)
 		case 158:	/* Release lock */
 			FIDOUT();
 			break;
+		case 135:	/* Store status */
+			FIDOUT();
+			STOREATTROUT();
+			break;
 		case 133:	/* Store data */
 			FIDOUT();
-			TRUNC(sizeof(int32_t)*6); /* Skip past this */
-			bp += sizeof(int32_t) * 6;
-			printf(" offset");
+			STOREATTROUT();
+			ND_PRINT((ndo, " offset"));
 			UINTOUT();
-			printf(" length");
+			ND_PRINT((ndo, " length"));
 			UINTOUT();
-			printf(" flen");
+			ND_PRINT((ndo, " flen"));
 			UINTOUT();
 			break;
 		case 134:	/* Store ACL */
 		{
-			int a[AFSOPAQUEMAX];
+			char a[AFSOPAQUEMAX+1];
 			FIDOUT();
-			TRUNC(4);
-			i = ntohl(*((int *) bp));
+			ND_TCHECK2(bp[0], 4);
+			i = EXTRACT_32BITS(bp);
 			bp += sizeof(int32_t);
-			TRUNC(i);
-			strncpy(a, bp, min(AFSOPAQUEMAX, i));
+			ND_TCHECK2(bp[0], i);
+			i = min(AFSOPAQUEMAX, i);
+			strncpy(a, (char *) bp, i);
 			a[i] = '\0';
-			acl_print((u_char *) a, (u_char *) a + i);
+			acl_print(ndo, (u_char *) a, sizeof(a), (u_char *) a + i);
 			break;
 		}
-		case 136:	/* Remove file */
 		case 137:	/* Create file */
 		case 141:	/* MakeDir */
+			FIDOUT();
+			STROUT(AFSNAMEMAX);
+			STOREATTROUT();
+			break;
+		case 136:	/* Remove file */
 		case 142:	/* Remove directory */
 			FIDOUT();
 			STROUT(AFSNAMEMAX);
 			break;
 		case 138:	/* Rename file */
-			printf(" old");
+			ND_PRINT((ndo, " old"));
 			FIDOUT();
 			STROUT(AFSNAMEMAX);
-			printf(" new");
+			ND_PRINT((ndo, " new"));
 			FIDOUT();
 			STROUT(AFSNAMEMAX);
 			break;
 		case 139:	/* Symlink */
 			FIDOUT();
 			STROUT(AFSNAMEMAX);
-			printf(" link to");
+			ND_PRINT((ndo, " link to"));
 			STROUT(AFSNAMEMAX);
 			break;
 		case 140:	/* Link */
 			FIDOUT();
 			STROUT(AFSNAMEMAX);
-			printf(" link to");
+			ND_PRINT((ndo, " link to"));
 			FIDOUT();
 			break;
 		case 148:	/* Get volume info */
@@ -763,28 +992,49 @@ fs_print(register const u_char *bp, int length)
 			break;
 		case 149:	/* Get volume stats */
 		case 150:	/* Set volume stats */
-			printf(" volid");
+			ND_PRINT((ndo, " volid"));
 			UINTOUT();
 			break;
 		case 154:	/* New get volume info */
-			printf(" volname");
+			ND_PRINT((ndo, " volname"));
 			STROUT(AFSNAMEMAX);
 			break;
 		case 155:	/* Bulk stat */
+		case 65536:     /* Inline bulk stat */
 		{
 			unsigned long j;
-			TRUNC(4);
-			j = ntohl(*((int *) bp));
+			ND_TCHECK2(bp[0], 4);
+			j = EXTRACT_32BITS(bp);
 			bp += sizeof(int32_t);
 
 			for (i = 0; i < j; i++) {
 				FIDOUT();
 				if (i != j - 1)
-					printf(",");
+					ND_PRINT((ndo, ","));
 			}
 			if (j == 0)
-				printf(" <none!>");
+				ND_PRINT((ndo, " <none!>"));
 		}
+		case 65537:	/* Fetch data 64 */
+			FIDOUT();
+			ND_PRINT((ndo, " offset"));
+			UINT64OUT();
+			ND_PRINT((ndo, " length"));
+			UINT64OUT();
+			break;
+		case 65538:	/* Store data 64 */
+			FIDOUT();
+			STOREATTROUT();
+			ND_PRINT((ndo, " offset"));
+			UINT64OUT();
+			ND_PRINT((ndo, " length"));
+			UINT64OUT();
+			ND_PRINT((ndo, " flen"));
+			UINT64OUT();
+			break;
+		case 65541:    /* CallBack rx conn address */
+			ND_PRINT((ndo, " addr"));
+			UINTOUT();
 		default:
 			;
 	}
@@ -792,7 +1042,7 @@ fs_print(register const u_char *bp, int length)
 	return;
 
 trunc:
-	printf(" [|fs]");
+	ND_PRINT((ndo, " [|fs]"));
 }
 
 /*
@@ -800,13 +1050,13 @@ trunc:
  */
 
 static void
-fs_reply_print(register const u_char *bp, int length, int32_t opcode)
+fs_reply_print(netdissect_options *ndo,
+               register const u_char *bp, int length, int32_t opcode)
 {
 	unsigned long i;
-	char s[AFSNAMEMAX];
 	struct rx_header *rxh;
 
-	if (length <= sizeof(struct rx_header))
+	if (length <= (int)sizeof(struct rx_header))
 		return;
 
 	rxh = (struct rx_header *) bp;
@@ -816,7 +1066,7 @@ fs_reply_print(register const u_char *bp, int length, int32_t opcode)
 	 * gleaned from fsint/afsint.xg
 	 */
 
-	printf(" fs reply %s", tok2str(fs_req, "op#%d", opcode));
+	ND_PRINT((ndo, " fs reply %s", tok2str(fs_req, "op#%d", opcode)));
 
 	bp += sizeof(struct rx_header);
 
@@ -824,27 +1074,28 @@ fs_reply_print(register const u_char *bp, int length, int32_t opcode)
 	 * If it was a data packet, interpret the response
 	 */
 
-	if (rxh->type == RX_PACKET_TYPE_DATA)
+	if (rxh->type == RX_PACKET_TYPE_DATA) {
 		switch (opcode) {
 		case 131:	/* Fetch ACL */
 		{
-			int a[AFSOPAQUEMAX];
-			TRUNC(4);
-			i = ntohl(*((int *) bp));
+			char a[AFSOPAQUEMAX+1];
+			ND_TCHECK2(bp[0], 4);
+			i = EXTRACT_32BITS(bp);
 			bp += sizeof(int32_t);
-			TRUNC(i);
-			strncpy(a, bp, min(AFSOPAQUEMAX, i));
+			ND_TCHECK2(bp[0], i);
+			i = min(AFSOPAQUEMAX, i);
+			strncpy(a, (char *) bp, i);
 			a[i] = '\0';
-			acl_print((u_char *) a, (u_char *) a + i);
+			acl_print(ndo, (u_char *) a, sizeof(a), (u_char *) a + i);
 			break;
 		}
 		case 137:	/* Create file */
 		case 141:	/* MakeDir */
-			printf(" new");
+			ND_PRINT((ndo, " new"));
 			FIDOUT();
 			break;
 		case 151:	/* Get root volume */
-			printf(" root volume");
+			ND_PRINT((ndo, " root volume"));
 			STROUT(AFSNAMEMAX);
 			break;
 		case 153:	/* Get time */
@@ -853,18 +1104,25 @@ fs_reply_print(register const u_char *bp, int length, int32_t opcode)
 		default:
 			;
 		}
-	else {
+	} else if (rxh->type == RX_PACKET_TYPE_ABORT) {
+		int i;
+
 		/*
 		 * Otherwise, just print out the return code
 		 */
-		printf(" errcode");
-		INTOUT();
+		ND_TCHECK2(bp[0], sizeof(int32_t));
+		i = (int) EXTRACT_32BITS(bp);
+		bp += sizeof(int32_t);
+
+		ND_PRINT((ndo, " error %s", tok2str(afs_fs_errors, "#%d", i)));
+	} else {
+		ND_PRINT((ndo, " strange fs reply of type %d", rxh->type));
 	}
 
 	return;
 
 trunc:
-	printf(" [|fs]");
+	ND_PRINT((ndo, " [|fs]"));
 }
 
 /*
@@ -874,7 +1132,7 @@ trunc:
  * <positive> <negative>
  * <uid1> <aclbits1>
  * ....
- * 
+ *
  * "positive" and "negative" are integers which contain the number of
  * positive and negative ACL's in the string.  The uid/aclbits pair are
  * ASCII strings containing the UID/PTS record and and a ascii number
@@ -882,61 +1140,70 @@ trunc:
  */
 
 static void
-acl_print(u_char *s, u_char *end)
+acl_print(netdissect_options *ndo,
+          u_char *s, int maxsize, u_char *end)
 {
 	int pos, neg, acl;
 	int n, i;
-	char user[128];
+	char *user;
+	char fmt[1024];
 
-	if (sscanf((char *) s, "%d %d\n%n", &pos, &neg, &n) != 2)
+	if ((user = (char *)malloc(maxsize)) == NULL)
 		return;
-	
+
+	if (sscanf((char *) s, "%d %d\n%n", &pos, &neg, &n) != 2)
+		goto finish;
+
 	s += n;
 
 	if (s > end)
-		return;
+		goto finish;
 
 	/*
 	 * This wacky order preserves the order used by the "fs" command
 	 */
 
 #define ACLOUT(acl) \
-	if (acl & PRSFS_READ) \
-		printf("r"); \
-	if (acl & PRSFS_LOOKUP) \
-		printf("l"); \
-	if (acl & PRSFS_INSERT) \
-		printf("i"); \
-	if (acl & PRSFS_DELETE) \
-		printf("d"); \
-	if (acl & PRSFS_WRITE) \
-		printf("w"); \
-	if (acl & PRSFS_LOCK) \
-		printf("k"); \
-	if (acl & PRSFS_ADMINISTER) \
-		printf("a");
+	ND_PRINT((ndo, "%s%s%s%s%s%s%s", \
+	          acl & PRSFS_READ       ? "r" : "", \
+	          acl & PRSFS_LOOKUP     ? "l" : "", \
+	          acl & PRSFS_INSERT     ? "i" : "", \
+	          acl & PRSFS_DELETE     ? "d" : "", \
+	          acl & PRSFS_WRITE      ? "w" : "", \
+	          acl & PRSFS_LOCK       ? "k" : "", \
+	          acl & PRSFS_ADMINISTER ? "a" : ""));
 
 	for (i = 0; i < pos; i++) {
-		if (sscanf((char *) s, "%s %d\n%n", user, &acl, &n) != 2)
-			return;
+		snprintf(fmt, sizeof(fmt), "%%%ds %%d\n%%n", maxsize - 1);
+		if (sscanf((char *) s, fmt, user, &acl, &n) != 2)
+			goto finish;
 		s += n;
-		printf(" +{%s ", user);
+		ND_PRINT((ndo, " +{"));
+		fn_print(ndo, (u_char *)user, NULL);
+		ND_PRINT((ndo, " "));
 		ACLOUT(acl);
-		printf("}");
+		ND_PRINT((ndo, "}"));
 		if (s > end)
-			return;
+			goto finish;
 	}
 
 	for (i = 0; i < neg; i++) {
-		if (sscanf((char *) s, "%s %d\n%n", user, &acl, &n) != 2)
-			return;
+		snprintf(fmt, sizeof(fmt), "%%%ds %%d\n%%n", maxsize - 1);
+		if (sscanf((char *) s, fmt, user, &acl, &n) != 2)
+			goto finish;
 		s += n;
-		printf(" -{%s ", user);
+		ND_PRINT((ndo, " -{"));
+		fn_print(ndo, (u_char *)user, NULL);
+		ND_PRINT((ndo, " "));
 		ACLOUT(acl);
-		printf("}");
+		ND_PRINT((ndo, "}"));
 		if (s > end)
-			return;
+			goto finish;
 	}
+
+finish:
+	free(user);
+	return;
 }
 
 #undef ACLOUT
@@ -946,15 +1213,16 @@ acl_print(u_char *s, u_char *end)
  */
 
 static void
-cb_print(register const u_char *bp, int length)
+cb_print(netdissect_options *ndo,
+         register const u_char *bp, int length)
 {
 	int cb_op;
 	unsigned long i;
 
-	if (length <= sizeof(struct rx_header))
+	if (length <= (int)sizeof(struct rx_header))
 		return;
 
-	if (snapend - bp + 1 <= sizeof(struct rx_header) + sizeof(int32_t)) {
+	if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
 		goto trunc;
 	}
 
@@ -963,9 +1231,9 @@ cb_print(register const u_char *bp, int length)
 	 * gleaned from fsint/afscbint.xg
 	 */
 
-	cb_op = ntohl(*((int *) (bp + sizeof(struct rx_header))));
+	cb_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
 
-	printf(" cb call %s", tok2str(cb_req, "op#%d", cb_op));
+	ND_PRINT((ndo, " cb call %s", tok2str(cb_req, "op#%d", cb_op)));
 
 	bp += sizeof(struct rx_header) + 4;
 
@@ -978,36 +1246,41 @@ cb_print(register const u_char *bp, int length)
 		case 204:		/* Callback */
 		{
 			unsigned long j, t;
-			TRUNC(4);
-			j = ntohl(*((int *) bp));
+			ND_TCHECK2(bp[0], 4);
+			j = EXTRACT_32BITS(bp);
 			bp += sizeof(int32_t);
 
 			for (i = 0; i < j; i++) {
 				FIDOUT();
 				if (i != j - 1)
-					printf(",");
+					ND_PRINT((ndo, ","));
 			}
 
 			if (j == 0)
-				printf(" <none!>");
+				ND_PRINT((ndo, " <none!>"));
 
-			j = ntohl(*((int *) bp));
+			j = EXTRACT_32BITS(bp);
 			bp += sizeof(int32_t);
 
 			if (j != 0)
-				printf(";");
+				ND_PRINT((ndo, ";"));
 
 			for (i = 0; i < j; i++) {
-				printf(" ver");
+				ND_PRINT((ndo, " ver"));
 				INTOUT();
-				printf(" expires");
+				ND_PRINT((ndo, " expires"));
 				DATEOUT();
-				TRUNC(4);
-				t = ntohl(*((int *) bp));
+				ND_TCHECK2(bp[0], 4);
+				t = EXTRACT_32BITS(bp);
 				bp += sizeof(int32_t);
 				tok2str(cb_types, "type %d", t);
 			}
 		}
+		case 214: {
+			ND_PRINT((ndo, " afsuuid"));
+			AFSUUIDOUT();
+			break;
+		}
 		default:
 			;
 	}
@@ -1015,7 +1288,7 @@ cb_print(register const u_char *bp, int length)
 	return;
 
 trunc:
-	printf(" [|cb]");
+	ND_PRINT((ndo, " [|cb]"));
 }
 
 /*
@@ -1023,13 +1296,12 @@ trunc:
  */
 
 static void
-cb_reply_print(register const u_char *bp, int length, int32_t opcode)
+cb_reply_print(netdissect_options *ndo,
+               register const u_char *bp, int length, int32_t opcode)
 {
-	unsigned long i;
-	char s[AFSNAMEMAX];
 	struct rx_header *rxh;
 
-	if (length <= sizeof(struct rx_header))
+	if (length <= (int)sizeof(struct rx_header))
 		return;
 
 	rxh = (struct rx_header *) bp;
@@ -1038,8 +1310,8 @@ cb_reply_print(register const u_char *bp, int length, int32_t opcode)
 	 * Print out the afs call we're invoking.  The table used here was
 	 * gleaned from fsint/afscbint.xg
 	 */
-	
-	printf(" cb reply %s", tok2str(cb_req, "op#%d", opcode));
+
+	ND_PRINT((ndo, " cb reply %s", tok2str(cb_req, "op#%d", opcode)));
 
 	bp += sizeof(struct rx_header);
 
@@ -1048,20 +1320,25 @@ cb_reply_print(register const u_char *bp, int length, int32_t opcode)
 	 */
 
 	if (rxh->type == RX_PACKET_TYPE_DATA)
-		/* Well, no, not really.  Leave this for later */
+		switch (opcode) {
+		case 213:	/* InitCallBackState3 */
+			AFSUUIDOUT();
+			break;
+		default:
 		;
+		}
 	else {
 		/*
 		 * Otherwise, just print out the return code
 		 */
-		printf(" errcode");
+		ND_PRINT((ndo, " errcode"));
 		INTOUT();
 	}
 
 	return;
 
 trunc:
-	printf(" [|cb]");
+	ND_PRINT((ndo, " [|cb]"));
 }
 
 /*
@@ -1069,16 +1346,16 @@ trunc:
  */
 
 static void
-prot_print(register const u_char *bp, int length)
+prot_print(netdissect_options *ndo,
+           register const u_char *bp, int length)
 {
-	int pt_op;
 	unsigned long i;
-	char s[AFSNAMEMAX];
+	int pt_op;
 
-	if (length <= sizeof(struct rx_header))
+	if (length <= (int)sizeof(struct rx_header))
 		return;
 
-	if (snapend - bp + 1 <= sizeof(struct rx_header) + sizeof(int32_t)) {
+	if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
 		goto trunc;
 	}
 
@@ -1087,16 +1364,16 @@ prot_print(register const u_char *bp, int length)
 	 * gleaned from ptserver/ptint.xg
 	 */
 
-	pt_op = ntohl(*((int *) (bp + sizeof(struct rx_header))));
+	pt_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
 
-	printf(" pt");
+	ND_PRINT((ndo, " pt"));
 
 	if (is_ubik(pt_op)) {
-		ubik_print(bp, length);
+		ubik_print(ndo, bp);
 		return;
 	}
 
-	printf(" call %s", tok2str(pt_req, "op#%d", pt_op));
+	ND_PRINT((ndo, " call %s", tok2str(pt_req, "op#%d", pt_op)));
 
 	/*
 	 * Decode some of the arguments to the PT calls
@@ -1107,9 +1384,9 @@ prot_print(register const u_char *bp, int length)
 	switch (pt_op) {
 		case 500:	/* I New User */
 			STROUT(PRNAMEMAX);
-			printf(" id");
+			ND_PRINT((ndo, " id"));
 			INTOUT();
-			printf(" oldid");
+			ND_PRINT((ndo, " oldid"));
 			INTOUT();
 			break;
 		case 501:	/* Where is it */
@@ -1120,26 +1397,27 @@ prot_print(register const u_char *bp, int length)
 		case 517:	/* List owned */
 		case 518:	/* Get CPS2 */
 		case 519:	/* Get host CPS */
-			printf(" id");
+		case 530:	/* List super groups */
+			ND_PRINT((ndo, " id"));
 			INTOUT();
 			break;
 		case 502:	/* Dump entry */
-			printf(" pos");
+			ND_PRINT((ndo, " pos"));
 			INTOUT();
 			break;
 		case 503:	/* Add to group */
 		case 507:	/* Remove from group */
 		case 515:	/* Is a member of? */
-			printf(" uid");
+			ND_PRINT((ndo, " uid"));
 			INTOUT();
-			printf(" gid");
+			ND_PRINT((ndo, " gid"));
 			INTOUT();
 			break;
 		case 504:	/* Name to ID */
 		{
 			unsigned long j;
-			TRUNC(4);
-			j = ntohl(*((int *) bp));
+			ND_TCHECK2(bp[0], 4);
+			j = EXTRACT_32BITS(bp);
 			bp += sizeof(int32_t);
 
 			/*
@@ -1153,46 +1431,46 @@ prot_print(register const u_char *bp, int length)
 				VECOUT(PRNAMEMAX);
 			}
 			if (j == 0)
-				printf(" <none!>");
+				ND_PRINT((ndo, " <none!>"));
 		}
 			break;
 		case 505:	/* Id to name */
 		{
 			unsigned long j;
-			printf(" ids:");
-			TRUNC(4);
-			i = ntohl(*((int *) bp));
+			ND_PRINT((ndo, " ids:"));
+			ND_TCHECK2(bp[0], 4);
+			i = EXTRACT_32BITS(bp);
 			bp += sizeof(int32_t);
 			for (j = 0; j < i; j++)
 				INTOUT();
 			if (j == 0)
-				printf(" <none!>");
+				ND_PRINT((ndo, " <none!>"));
 		}
 			break;
 		case 509:	/* New entry */
 			STROUT(PRNAMEMAX);
-			printf(" flag");
+			ND_PRINT((ndo, " flag"));
 			INTOUT();
-			printf(" oid");
+			ND_PRINT((ndo, " oid"));
 			INTOUT();
 			break;
 		case 511:	/* Set max */
-			printf(" id");
+			ND_PRINT((ndo, " id"));
 			INTOUT();
-			printf(" gflag");
+			ND_PRINT((ndo, " gflag"));
 			INTOUT();
 			break;
 		case 513:	/* Change entry */
-			printf(" id");
+			ND_PRINT((ndo, " id"));
 			INTOUT();
 			STROUT(PRNAMEMAX);
-			printf(" oldid");
+			ND_PRINT((ndo, " oldid"));
 			INTOUT();
-			printf(" newid");
+			ND_PRINT((ndo, " newid"));
 			INTOUT();
 			break;
 		case 520:	/* Update entry */
-			printf(" id");
+			ND_PRINT((ndo, " id"));
 			INTOUT();
 			STROUT(PRNAMEMAX);
 			break;
@@ -1204,7 +1482,7 @@ prot_print(register const u_char *bp, int length)
 	return;
 
 trunc:
-	printf(" [|pt]");
+	ND_PRINT((ndo, " [|pt]"));
 }
 
 /*
@@ -1212,13 +1490,13 @@ trunc:
  */
 
 static void
-prot_reply_print(register const u_char *bp, int length, int32_t opcode)
+prot_reply_print(netdissect_options *ndo,
+                 register const u_char *bp, int length, int32_t opcode)
 {
 	struct rx_header *rxh;
 	unsigned long i;
-	char s[AFSNAMEMAX];
 
-	if (length < sizeof(struct rx_header))
+	if (length < (int)sizeof(struct rx_header))
 		return;
 
 	rxh = (struct rx_header *) bp;
@@ -1229,14 +1507,14 @@ prot_reply_print(register const u_char *bp, int length, int32_t opcode)
 	 * Ubik call, however.
 	 */
 
-	printf(" pt");
+	ND_PRINT((ndo, " pt"));
 
 	if (is_ubik(opcode)) {
-		ubik_reply_print(bp, length, opcode);
+		ubik_reply_print(ndo, bp, length, opcode);
 		return;
 	}
 
-	printf(" reply %s", tok2str(pt_req, "op#%d", opcode));
+	ND_PRINT((ndo, " reply %s", tok2str(pt_req, "op#%d", opcode)));
 
 	bp += sizeof(struct rx_header);
 
@@ -1249,21 +1527,21 @@ prot_reply_print(register const u_char *bp, int length, int32_t opcode)
 		case 504:		/* Name to ID */
 		{
 			unsigned long j;
-			printf(" ids:");
-			TRUNC(4);
-			i = ntohl(*((int *) bp));
+			ND_PRINT((ndo, " ids:"));
+			ND_TCHECK2(bp[0], 4);
+			i = EXTRACT_32BITS(bp);
 			bp += sizeof(int32_t);
 			for (j = 0; j < i; j++)
 				INTOUT();
 			if (j == 0)
-				printf(" <none!>");
+				ND_PRINT((ndo, " <none!>"));
 		}
 			break;
 		case 505:		/* ID to name */
 		{
 			unsigned long j;
-			TRUNC(4);
-			j = ntohl(*((int *) bp));
+			ND_TCHECK2(bp[0], 4);
+			j = EXTRACT_32BITS(bp);
 			bp += sizeof(int32_t);
 
 			/*
@@ -1277,7 +1555,7 @@ prot_reply_print(register const u_char *bp, int length, int32_t opcode)
 				VECOUT(PRNAMEMAX);
 			}
 			if (j == 0)
-				printf(" <none!>");
+				ND_PRINT((ndo, " <none!>"));
 		}
 			break;
 		case 508:		/* Get CPS */
@@ -1287,20 +1565,20 @@ prot_reply_print(register const u_char *bp, int length, int32_t opcode)
 		case 519:		/* Get host CPS */
 		{
 			unsigned long j;
-			TRUNC(4);
-			j = ntohl(*((int *) bp));
+			ND_TCHECK2(bp[0], 4);
+			j = EXTRACT_32BITS(bp);
 			bp += sizeof(int32_t);
 			for (i = 0; i < j; i++) {
 				INTOUT();
 			}
 			if (j == 0)
-				printf(" <none!>");
+				ND_PRINT((ndo, " <none!>"));
 		}
 			break;
 		case 510:		/* List max */
-			printf(" maxuid");
+			ND_PRINT((ndo, " maxuid"));
 			INTOUT();
-			printf(" maxgid");
+			ND_PRINT((ndo, " maxgid"));
 			INTOUT();
 			break;
 		default:
@@ -1310,14 +1588,14 @@ prot_reply_print(register const u_char *bp, int length, int32_t opcode)
 		/*
 		 * Otherwise, just print out the return code
 		 */
-		printf(" errcode");
+		ND_PRINT((ndo, " errcode"));
 		INTOUT();
 	}
 
 	return;
 
 trunc:
-	printf(" [|pt]");
+	ND_PRINT((ndo, " [|pt]"));
 }
 
 /*
@@ -1325,16 +1603,16 @@ trunc:
  */
 
 static void
-vldb_print(register const u_char *bp, int length)
+vldb_print(netdissect_options *ndo,
+           register const u_char *bp, int length)
 {
 	int vldb_op;
 	unsigned long i;
-	char s[AFSNAMEMAX];
 
-	if (length <= sizeof(struct rx_header))
+	if (length <= (int)sizeof(struct rx_header))
 		return;
 
-	if (snapend - bp + 1 <= sizeof(struct rx_header) + sizeof(int32_t)) {
+	if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
 		goto trunc;
 	}
 
@@ -1343,15 +1621,15 @@ vldb_print(register const u_char *bp, int length)
 	 * gleaned from vlserver/vldbint.xg
 	 */
 
-	vldb_op = ntohl(*((int *) (bp + sizeof(struct rx_header))));
+	vldb_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
 
-	printf(" vldb");
+	ND_PRINT((ndo, " vldb"));
 
 	if (is_ubik(vldb_op)) {
-		ubik_print(bp, length);
+		ubik_print(ndo, bp);
 		return;
 	}
-	printf(" call %s", tok2str(vldb_req, "op#%d", vldb_op));
+	ND_PRINT((ndo, " call %s", tok2str(vldb_req, "op#%d", vldb_op)));
 
 	/*
 	 * Decode some of the arguments to the VLDB calls
@@ -1370,13 +1648,13 @@ vldb_print(register const u_char *bp, int length)
 		case 508:	/* Set lock */
 		case 509:	/* Release lock */
 		case 518:	/* Get entry by ID N */
-			printf(" volid");
+			ND_PRINT((ndo, " volid"));
 			INTOUT();
-			TRUNC(sizeof(int32_t));
-			i = ntohl(*((int *) bp));
+			ND_TCHECK2(bp[0], sizeof(int32_t));
+			i = EXTRACT_32BITS(bp);
 			bp += sizeof(int32_t);
 			if (i <= 2)
-				printf(" type %s", voltype[i]);
+				ND_PRINT((ndo, " type %s", voltype[i]));
 			break;
 		case 504:	/* Get entry by name */
 		case 519:	/* Get entry by name N */
@@ -1385,23 +1663,23 @@ vldb_print(register const u_char *bp, int length)
 			STROUT(VLNAMEMAX);
 			break;
 		case 505:	/* Get new vol id */
-			printf(" bump");
+			ND_PRINT((ndo, " bump"));
 			INTOUT();
 			break;
 		case 506:	/* Replace entry */
 		case 520:	/* Replace entry N */
-			printf(" volid");
+			ND_PRINT((ndo, " volid"));
 			INTOUT();
-			TRUNC(sizeof(int32_t));
-			i = ntohl(*((int *) bp));
+			ND_TCHECK2(bp[0], sizeof(int32_t));
+			i = EXTRACT_32BITS(bp);
 			bp += sizeof(int32_t);
 			if (i <= 2)
-				printf(" type %s", voltype[i]);
+				ND_PRINT((ndo, " type %s", voltype[i]));
 			VECOUT(VLNAMEMAX);
 			break;
 		case 510:	/* List entry */
 		case 521:	/* List entry N */
-			printf(" index");
+			ND_PRINT((ndo, " index"));
 			INTOUT();
 			break;
 		default:
@@ -1411,7 +1689,7 @@ vldb_print(register const u_char *bp, int length)
 	return;
 
 trunc:
-	printf(" [|vldb]");
+	ND_PRINT((ndo, " [|vldb]"));
 }
 
 /*
@@ -1419,13 +1697,13 @@ trunc:
  */
 
 static void
-vldb_reply_print(register const u_char *bp, int length, int32_t opcode)
+vldb_reply_print(netdissect_options *ndo,
+                 register const u_char *bp, int length, int32_t opcode)
 {
 	struct rx_header *rxh;
 	unsigned long i;
-	char s[AFSNAMEMAX];
 
-	if (length < sizeof(struct rx_header))
+	if (length < (int)sizeof(struct rx_header))
 		return;
 
 	rxh = (struct rx_header *) bp;
@@ -1436,14 +1714,14 @@ vldb_reply_print(register const u_char *bp, int length, int32_t opcode)
 	 * Ubik call, however.
 	 */
 
-	printf(" vldb");
+	ND_PRINT((ndo, " vldb"));
 
 	if (is_ubik(opcode)) {
-		ubik_reply_print(bp, length, opcode);
+		ubik_reply_print(ndo, bp, length, opcode);
 		return;
 	}
 
-	printf(" reply %s", tok2str(vldb_req, "op#%d", opcode));
+	ND_PRINT((ndo, " reply %s", tok2str(vldb_req, "op#%d", opcode)));
 
 	bp += sizeof(struct rx_header);
 
@@ -1454,93 +1732,93 @@ vldb_reply_print(register const u_char *bp, int length, int32_t opcode)
 	if (rxh->type == RX_PACKET_TYPE_DATA)
 		switch (opcode) {
 		case 510:	/* List entry */
-			printf(" count");
+			ND_PRINT((ndo, " count"));
 			INTOUT();
-			printf(" nextindex");
+			ND_PRINT((ndo, " nextindex"));
 			INTOUT();
 		case 503:	/* Get entry by id */
 		case 504:	/* Get entry by name */
 		{	unsigned long nservers, j;
 			VECOUT(VLNAMEMAX);
-			TRUNC(sizeof(int32_t));
+			ND_TCHECK2(bp[0], sizeof(int32_t));
 			bp += sizeof(int32_t);
-			printf(" numservers");
-			TRUNC(sizeof(int32_t));
-			nservers = ntohl(*((int *) bp));
+			ND_PRINT((ndo, " numservers"));
+			ND_TCHECK2(bp[0], sizeof(int32_t));
+			nservers = EXTRACT_32BITS(bp);
 			bp += sizeof(int32_t);
-			printf(" %d", nservers);
-			printf(" servers");
+			ND_PRINT((ndo, " %lu", nservers));
+			ND_PRINT((ndo, " servers"));
 			for (i = 0; i < 8; i++) {
-				TRUNC(sizeof(int32_t));
+				ND_TCHECK2(bp[0], sizeof(int32_t));
 				if (i < nservers)
-					printf(" %s",
-					   inet_ntoa(*((struct in_addr *) bp)));
+					ND_PRINT((ndo, " %s",
+					   intoa(((struct in_addr *) bp)->s_addr)));
 				bp += sizeof(int32_t);
 			}
-			printf(" partitions");
+			ND_PRINT((ndo, " partitions"));
 			for (i = 0; i < 8; i++) {
-				TRUNC(sizeof(int32_t));
-				j = ntohl(*((int *) bp));
+				ND_TCHECK2(bp[0], sizeof(int32_t));
+				j = EXTRACT_32BITS(bp);
 				if (i < nservers && j <= 26)
-					printf(" %c", 'a' + j);
+					ND_PRINT((ndo, " %c", 'a' + (int)j));
 				else if (i < nservers)
-					printf(" %d", j);
+					ND_PRINT((ndo, " %lu", j));
 				bp += sizeof(int32_t);
 			}
-			TRUNC(8 * sizeof(int32_t));
+			ND_TCHECK2(bp[0], 8 * sizeof(int32_t));
 			bp += 8 * sizeof(int32_t);
-			printf(" rwvol");
+			ND_PRINT((ndo, " rwvol"));
 			UINTOUT();
-			printf(" rovol");
+			ND_PRINT((ndo, " rovol"));
 			UINTOUT();
-			printf(" backup");
+			ND_PRINT((ndo, " backup"));
 			UINTOUT();
 		}
 			break;
 		case 505:	/* Get new volume ID */
-			printf(" newvol");
+			ND_PRINT((ndo, " newvol"));
 			UINTOUT();
 			break;
 		case 521:	/* List entry */
 		case 529:	/* List entry U */
-			printf(" count");
+			ND_PRINT((ndo, " count"));
 			INTOUT();
-			printf(" nextindex");
+			ND_PRINT((ndo, " nextindex"));
 			INTOUT();
 		case 518:	/* Get entry by ID N */
 		case 519:	/* Get entry by name N */
 		{	unsigned long nservers, j;
 			VECOUT(VLNAMEMAX);
-			printf(" numservers");
-			TRUNC(sizeof(int32_t));
-			nservers = ntohl(*((int *) bp));
+			ND_PRINT((ndo, " numservers"));
+			ND_TCHECK2(bp[0], sizeof(int32_t));
+			nservers = EXTRACT_32BITS(bp);
 			bp += sizeof(int32_t);
-			printf(" %d", nservers);
-			printf(" servers");
+			ND_PRINT((ndo, " %lu", nservers));
+			ND_PRINT((ndo, " servers"));
 			for (i = 0; i < 13; i++) {
-				TRUNC(sizeof(int32_t));
+				ND_TCHECK2(bp[0], sizeof(int32_t));
 				if (i < nservers)
-					printf(" %s",
-					   inet_ntoa(*((struct in_addr *) bp)));
+					ND_PRINT((ndo, " %s",
+					   intoa(((struct in_addr *) bp)->s_addr)));
 				bp += sizeof(int32_t);
 			}
-			printf(" partitions");
+			ND_PRINT((ndo, " partitions"));
 			for (i = 0; i < 13; i++) {
-				TRUNC(sizeof(int32_t));
-				j = ntohl(*((int *) bp));
+				ND_TCHECK2(bp[0], sizeof(int32_t));
+				j = EXTRACT_32BITS(bp);
 				if (i < nservers && j <= 26)
-					printf(" %c", 'a' + j);
+					ND_PRINT((ndo, " %c", 'a' + (int)j));
 				else if (i < nservers)
-					printf(" %d", j);
+					ND_PRINT((ndo, " %lu", j));
 				bp += sizeof(int32_t);
 			}
-			TRUNC(13 * sizeof(int32_t));
+			ND_TCHECK2(bp[0], 13 * sizeof(int32_t));
 			bp += 13 * sizeof(int32_t);
-			printf(" rwvol");
+			ND_PRINT((ndo, " rwvol"));
 			UINTOUT();
-			printf(" rovol");
+			ND_PRINT((ndo, " rovol"));
 			UINTOUT();
-			printf(" backup");
+			ND_PRINT((ndo, " backup"));
 			UINTOUT();
 		}
 			break;
@@ -1548,58 +1826,58 @@ vldb_reply_print(register const u_char *bp, int length, int32_t opcode)
 		case 527:	/* Get entry by name U */
 		{	unsigned long nservers, j;
 			VECOUT(VLNAMEMAX);
-			printf(" numservers");
-			TRUNC(sizeof(int32_t));
-			nservers = ntohl(*((int *) bp));
+			ND_PRINT((ndo, " numservers"));
+			ND_TCHECK2(bp[0], sizeof(int32_t));
+			nservers = EXTRACT_32BITS(bp);
 			bp += sizeof(int32_t);
-			printf(" %d", nservers);
-			printf(" servers");
+			ND_PRINT((ndo, " %lu", nservers));
+			ND_PRINT((ndo, " servers"));
 			for (i = 0; i < 13; i++) {
 				if (i < nservers) {
-					printf(" afsuuid");
+					ND_PRINT((ndo, " afsuuid"));
 					AFSUUIDOUT();
 				} else {
-					TRUNC(44);
+					ND_TCHECK2(bp[0], 44);
 					bp += 44;
 				}
 			}
-			TRUNC(4 * 13);
+			ND_TCHECK2(bp[0], 4 * 13);
 			bp += 4 * 13;
-			printf(" partitions");
+			ND_PRINT((ndo, " partitions"));
 			for (i = 0; i < 13; i++) {
-				TRUNC(sizeof(int32_t));
-				j = ntohl(*((int *) bp));
+				ND_TCHECK2(bp[0], sizeof(int32_t));
+				j = EXTRACT_32BITS(bp);
 				if (i < nservers && j <= 26)
-					printf(" %c", 'a' + j);
+					ND_PRINT((ndo, " %c", 'a' + (int)j));
 				else if (i < nservers)
-					printf(" %d", j);
+					ND_PRINT((ndo, " %lu", j));
 				bp += sizeof(int32_t);
 			}
-			TRUNC(13 * sizeof(int32_t));
+			ND_TCHECK2(bp[0], 13 * sizeof(int32_t));
 			bp += 13 * sizeof(int32_t);
-			printf(" rwvol");
+			ND_PRINT((ndo, " rwvol"));
 			UINTOUT();
-			printf(" rovol");
+			ND_PRINT((ndo, " rovol"));
 			UINTOUT();
-			printf(" backup");
+			ND_PRINT((ndo, " backup"));
 			UINTOUT();
 		}
 		default:
 			;
 		}
-			
+
 	else {
 		/*
 		 * Otherwise, just print out the return code
 		 */
-		printf(" errcode");
+		ND_PRINT((ndo, " errcode"));
 		INTOUT();
 	}
 
 	return;
 
 trunc:
-	printf(" [|vldb]");
+	ND_PRINT((ndo, " [|vldb]"));
 }
 
 /*
@@ -1607,15 +1885,15 @@ trunc:
  */
 
 static void
-kauth_print(register const u_char *bp, int length)
+kauth_print(netdissect_options *ndo,
+            register const u_char *bp, int length)
 {
 	int kauth_op;
-	char s[AFSNAMEMAX];
 
-	if (length <= sizeof(struct rx_header))
+	if (length <= (int)sizeof(struct rx_header))
 		return;
 
-	if (snapend - bp + 1 <= sizeof(struct rx_header) + sizeof(int32_t)) {
+	if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
 		goto trunc;
 	}
 
@@ -1624,17 +1902,17 @@ kauth_print(register const u_char *bp, int length)
 	 * gleaned from kauth/kauth.rg
 	 */
 
-	kauth_op = ntohl(*((int *) (bp + sizeof(struct rx_header))));
+	kauth_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
 
-	printf(" kauth");
+	ND_PRINT((ndo, " kauth"));
 
 	if (is_ubik(kauth_op)) {
-		ubik_print(bp, length);
+		ubik_print(ndo, bp);
 		return;
 	}
 
 
-	printf(" call %s", tok2str(kauth_req, "op#%d", kauth_op));
+	ND_PRINT((ndo, " call %s", tok2str(kauth_req, "op#%d", kauth_op)));
 
 	/*
 	 * Decode some of the arguments to the KA calls
@@ -1653,7 +1931,7 @@ kauth_print(register const u_char *bp, int length)
 		case 8:		/* Get entry */
 		case 14:	/* Unlock */
 		case 15:	/* Lock status */
-			printf(" principal");
+			ND_PRINT((ndo, " principal"));
 			STROUT(KANAMEMAX);
 			STROUT(KANAMEMAX);
 			break;
@@ -1661,29 +1939,29 @@ kauth_print(register const u_char *bp, int length)
 		case 23:	/* GetTicket */
 		{
 			int i;
-			printf(" kvno");
+			ND_PRINT((ndo, " kvno"));
 			INTOUT();
-			printf(" domain");
+			ND_PRINT((ndo, " domain"));
 			STROUT(KANAMEMAX);
-			TRUNC(sizeof(int32_t));
-			i = (int) ntohl(*((int *) bp));
+			ND_TCHECK2(bp[0], sizeof(int32_t));
+			i = (int) EXTRACT_32BITS(bp);
 			bp += sizeof(int32_t);
-			TRUNC(i);
+			ND_TCHECK2(bp[0], i);
 			bp += i;
-			printf(" principal");
+			ND_PRINT((ndo, " principal"));
 			STROUT(KANAMEMAX);
 			STROUT(KANAMEMAX);
 			break;
 		}
 		case 4:		/* Set Password */
-			printf(" principal");
+			ND_PRINT((ndo, " principal"));
 			STROUT(KANAMEMAX);
 			STROUT(KANAMEMAX);
-			printf(" kvno");
+			ND_PRINT((ndo, " kvno"));
 			INTOUT();
 			break;
 		case 12:	/* Get password */
-			printf(" name");
+			ND_PRINT((ndo, " name"));
 			STROUT(KANAMEMAX);
 			break;
 		default:
@@ -1693,7 +1971,7 @@ kauth_print(register const u_char *bp, int length)
 	return;
 
 trunc:
-	printf(" [|kauth]");
+	ND_PRINT((ndo, " [|kauth]"));
 }
 
 /*
@@ -1701,13 +1979,12 @@ trunc:
  */
 
 static void
-kauth_reply_print(register const u_char *bp, int length, int32_t opcode)
+kauth_reply_print(netdissect_options *ndo,
+                  register const u_char *bp, int length, int32_t opcode)
 {
-	unsigned long i;
-	char s[AFSNAMEMAX];
 	struct rx_header *rxh;
 
-	if (length <= sizeof(struct rx_header))
+	if (length <= (int)sizeof(struct rx_header))
 		return;
 
 	rxh = (struct rx_header *) bp;
@@ -1716,15 +1993,15 @@ kauth_reply_print(register const u_char *bp, int length, int32_t opcode)
 	 * Print out the afs call we're invoking.  The table used here was
 	 * gleaned from kauth/kauth.rg
 	 */
-	
-	printf(" kauth");
+
+	ND_PRINT((ndo, " kauth"));
 
 	if (is_ubik(opcode)) {
-		ubik_reply_print(bp, length, opcode);
+		ubik_reply_print(ndo, bp, length, opcode);
 		return;
 	}
 
-	printf(" reply %s", tok2str(kauth_req, "op#%d", opcode));
+	ND_PRINT((ndo, " reply %s", tok2str(kauth_req, "op#%d", opcode)));
 
 	bp += sizeof(struct rx_header);
 
@@ -1739,14 +2016,14 @@ kauth_reply_print(register const u_char *bp, int length, int32_t opcode)
 		/*
 		 * Otherwise, just print out the return code
 		 */
-		printf(" errcode");
+		ND_PRINT((ndo, " errcode"));
 		INTOUT();
 	}
 
 	return;
 
 trunc:
-	printf(" [|kauth]");
+	ND_PRINT((ndo, " [|kauth]"));
 }
 
 /*
@@ -1754,14 +2031,15 @@ trunc:
  */
 
 static void
-vol_print(register const u_char *bp, int length)
+vol_print(netdissect_options *ndo,
+          register const u_char *bp, int length)
 {
 	int vol_op;
 
-	if (length <= sizeof(struct rx_header))
+	if (length <= (int)sizeof(struct rx_header))
 		return;
 
-	if (snapend - bp + 1 <= sizeof(struct rx_header) + sizeof(int32_t)) {
+	if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
 		goto trunc;
 	}
 
@@ -1770,21 +2048,184 @@ vol_print(register const u_char *bp, int length)
 	 * gleaned from volser/volint.xg
 	 */
 
-	vol_op = ntohl(*((int *) (bp + sizeof(struct rx_header))));
+	vol_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
 
-	printf(" vol call %s", tok2str(vol_req, "op#%d", vol_op));
+	ND_PRINT((ndo, " vol call %s", tok2str(vol_req, "op#%d", vol_op)));
 
-	/*
-	 * Normally there would be a switch statement here to decode the
-	 * arguments to the AFS call, but since I don't have access to
-	 * an AFS server (yet) and I'm not an AFS admin, I can't
-	 * test any of these calls.  Leave this blank for now.
-	 */
+	bp += sizeof(struct rx_header) + 4;
 
+	switch (vol_op) {
+		case 100:	/* Create volume */
+			ND_PRINT((ndo, " partition"));
+			UINTOUT();
+			ND_PRINT((ndo, " name"));
+			STROUT(AFSNAMEMAX);
+			ND_PRINT((ndo, " type"));
+			UINTOUT();
+			ND_PRINT((ndo, " parent"));
+			UINTOUT();
+			break;
+		case 101:	/* Delete volume */
+		case 107:	/* Get flags */
+			ND_PRINT((ndo, " trans"));
+			UINTOUT();
+			break;
+		case 102:	/* Restore */
+			ND_PRINT((ndo, " totrans"));
+			UINTOUT();
+			ND_PRINT((ndo, " flags"));
+			UINTOUT();
+			break;
+		case 103:	/* Forward */
+			ND_PRINT((ndo, " fromtrans"));
+			UINTOUT();
+			ND_PRINT((ndo, " fromdate"));
+			DATEOUT();
+			DESTSERVEROUT();
+			ND_PRINT((ndo, " desttrans"));
+			INTOUT();
+			break;
+		case 104:	/* End trans */
+			ND_PRINT((ndo, " trans"));
+			UINTOUT();
+			break;
+		case 105:	/* Clone */
+			ND_PRINT((ndo, " trans"));
+			UINTOUT();
+			ND_PRINT((ndo, " purgevol"));
+			UINTOUT();
+			ND_PRINT((ndo, " newtype"));
+			UINTOUT();
+			ND_PRINT((ndo, " newname"));
+			STROUT(AFSNAMEMAX);
+			break;
+		case 106:	/* Set flags */
+			ND_PRINT((ndo, " trans"));
+			UINTOUT();
+			ND_PRINT((ndo, " flags"));
+			UINTOUT();
+			break;
+		case 108:	/* Trans create */
+			ND_PRINT((ndo, " vol"));
+			UINTOUT();
+			ND_PRINT((ndo, " partition"));
+			UINTOUT();
+			ND_PRINT((ndo, " flags"));
+			UINTOUT();
+			break;
+		case 109:	/* Dump */
+		case 655537:	/* Get size */
+			ND_PRINT((ndo, " fromtrans"));
+			UINTOUT();
+			ND_PRINT((ndo, " fromdate"));
+			DATEOUT();
+			break;
+		case 110:	/* Get n-th volume */
+			ND_PRINT((ndo, " index"));
+			UINTOUT();
+			break;
+		case 111:	/* Set forwarding */
+			ND_PRINT((ndo, " tid"));
+			UINTOUT();
+			ND_PRINT((ndo, " newsite"));
+			UINTOUT();
+			break;
+		case 112:	/* Get name */
+		case 113:	/* Get status */
+			ND_PRINT((ndo, " tid"));
+			break;
+		case 114:	/* Signal restore */
+			ND_PRINT((ndo, " name"));
+			STROUT(AFSNAMEMAX);
+			ND_PRINT((ndo, " type"));
+			UINTOUT();
+			ND_PRINT((ndo, " pid"));
+			UINTOUT();
+			ND_PRINT((ndo, " cloneid"));
+			UINTOUT();
+			break;
+		case 116:	/* List volumes */
+			ND_PRINT((ndo, " partition"));
+			UINTOUT();
+			ND_PRINT((ndo, " flags"));
+			UINTOUT();
+			break;
+		case 117:	/* Set id types */
+			ND_PRINT((ndo, " tid"));
+			UINTOUT();
+			ND_PRINT((ndo, " name"));
+			STROUT(AFSNAMEMAX);
+			ND_PRINT((ndo, " type"));
+			UINTOUT();
+			ND_PRINT((ndo, " pid"));
+			UINTOUT();
+			ND_PRINT((ndo, " clone"));
+			UINTOUT();
+			ND_PRINT((ndo, " backup"));
+			UINTOUT();
+			break;
+		case 119:	/* Partition info */
+			ND_PRINT((ndo, " name"));
+			STROUT(AFSNAMEMAX);
+			break;
+		case 120:	/* Reclone */
+			ND_PRINT((ndo, " tid"));
+			UINTOUT();
+			break;
+		case 121:	/* List one volume */
+		case 122:	/* Nuke volume */
+		case 124:	/* Extended List volumes */
+		case 125:	/* Extended List one volume */
+		case 65536:	/* Convert RO to RW volume */
+			ND_PRINT((ndo, " partid"));
+			UINTOUT();
+			ND_PRINT((ndo, " volid"));
+			UINTOUT();
+			break;
+		case 123:	/* Set date */
+			ND_PRINT((ndo, " tid"));
+			UINTOUT();
+			ND_PRINT((ndo, " date"));
+			DATEOUT();
+			break;
+		case 126:	/* Set info */
+			ND_PRINT((ndo, " tid"));
+			UINTOUT();
+			break;
+		case 128:	/* Forward multiple */
+			ND_PRINT((ndo, " fromtrans"));
+			UINTOUT();
+			ND_PRINT((ndo, " fromdate"));
+			DATEOUT();
+			{
+				unsigned long i, j;
+				ND_TCHECK2(bp[0], 4);
+				j = EXTRACT_32BITS(bp);
+				bp += sizeof(int32_t);
+				for (i = 0; i < j; i++) {
+					DESTSERVEROUT();
+					if (i != j - 1)
+						ND_PRINT((ndo, ","));
+				}
+				if (j == 0)
+					ND_PRINT((ndo, " <none!>"));
+			}
+			break;
+		case 65538:	/* Dump version 2 */
+			ND_PRINT((ndo, " fromtrans"));
+			UINTOUT();
+			ND_PRINT((ndo, " fromdate"));
+			DATEOUT();
+			ND_PRINT((ndo, " flags"));
+			UINTOUT();
+			break;
+		default:
+			;
+	}
 	return;
 
 trunc:
-	printf(" [|vol]");
+	ND_PRINT((ndo, " [|vol]"));
 }
 
 /*
@@ -1792,13 +2233,12 @@ trunc:
  */
 
 static void
-vol_reply_print(register const u_char *bp, int length, int32_t opcode)
+vol_reply_print(netdissect_options *ndo,
+                register const u_char *bp, int length, int32_t opcode)
 {
-	unsigned long i;
-	char s[AFSNAMEMAX];
 	struct rx_header *rxh;
 
-	if (length <= sizeof(struct rx_header))
+	if (length <= (int)sizeof(struct rx_header))
 		return;
 
 	rxh = (struct rx_header *) bp;
@@ -1807,8 +2247,8 @@ vol_reply_print(register const u_char *bp, int length, int32_t opcode)
 	 * Print out the afs call we're invoking.  The table used here was
 	 * gleaned from volser/volint.xg
 	 */
-	
-	printf(" vol reply %s", tok2str(vol_req, "op#%d", opcode));
+
+	ND_PRINT((ndo, " vol reply %s", tok2str(vol_req, "op#%d", opcode)));
 
 	bp += sizeof(struct rx_header);
 
@@ -1816,21 +2256,111 @@ vol_reply_print(register const u_char *bp, int length, int32_t opcode)
 	 * If it was a data packet, interpret the response.
 	 */
 
-	if (rxh->type == RX_PACKET_TYPE_DATA)
-		/* Well, no, not really.  Leave this for later */
-		;
-	else {
+	if (rxh->type == RX_PACKET_TYPE_DATA) {
+		switch (opcode) {
+			case 100:	/* Create volume */
+				ND_PRINT((ndo, " volid"));
+				UINTOUT();
+				ND_PRINT((ndo, " trans"));
+				UINTOUT();
+				break;
+			case 104:	/* End transaction */
+				UINTOUT();
+				break;
+			case 105:	/* Clone */
+				ND_PRINT((ndo, " newvol"));
+				UINTOUT();
+				break;
+			case 107:	/* Get flags */
+				UINTOUT();
+				break;
+			case 108:	/* Transaction create */
+				ND_PRINT((ndo, " trans"));
+				UINTOUT();
+				break;
+			case 110:	/* Get n-th volume */
+				ND_PRINT((ndo, " volume"));
+				UINTOUT();
+				ND_PRINT((ndo, " partition"));
+				UINTOUT();
+				break;
+			case 112:	/* Get name */
+				STROUT(AFSNAMEMAX);
+				break;
+			case 113:	/* Get status */
+				ND_PRINT((ndo, " volid"));
+				UINTOUT();
+				ND_PRINT((ndo, " nextuniq"));
+				UINTOUT();
+				ND_PRINT((ndo, " type"));
+				UINTOUT();
+				ND_PRINT((ndo, " parentid"));
+				UINTOUT();
+				ND_PRINT((ndo, " clone"));
+				UINTOUT();
+				ND_PRINT((ndo, " backup"));
+				UINTOUT();
+				ND_PRINT((ndo, " restore"));
+				UINTOUT();
+				ND_PRINT((ndo, " maxquota"));
+				UINTOUT();
+				ND_PRINT((ndo, " minquota"));
+				UINTOUT();
+				ND_PRINT((ndo, " owner"));
+				UINTOUT();
+				ND_PRINT((ndo, " create"));
+				DATEOUT();
+				ND_PRINT((ndo, " access"));
+				DATEOUT();
+				ND_PRINT((ndo, " update"));
+				DATEOUT();
+				ND_PRINT((ndo, " expire"));
+				DATEOUT();
+				ND_PRINT((ndo, " backup"));
+				DATEOUT();
+				ND_PRINT((ndo, " copy"));
+				DATEOUT();
+				break;
+			case 115:	/* Old list partitions */
+				break;
+			case 116:	/* List volumes */
+			case 121:	/* List one volume */
+				{
+					unsigned long i, j;
+					ND_TCHECK2(bp[0], 4);
+					j = EXTRACT_32BITS(bp);
+					bp += sizeof(int32_t);
+					for (i = 0; i < j; i++) {
+						ND_PRINT((ndo, " name"));
+						VECOUT(32);
+						ND_PRINT((ndo, " volid"));
+						UINTOUT();
+						ND_PRINT((ndo, " type"));
+						bp += sizeof(int32_t) * 21;
+						if (i != j - 1)
+							ND_PRINT((ndo, ","));
+					}
+					if (j == 0)
+						ND_PRINT((ndo, " <none!>"));
+				}
+				break;
+
+
+			default:
+				;
+		}
+	} else {
 		/*
 		 * Otherwise, just print out the return code
 		 */
-		printf(" errcode");
+		ND_PRINT((ndo, " errcode"));
 		INTOUT();
 	}
 
 	return;
 
 trunc:
-	printf(" [|vol]");
+	ND_PRINT((ndo, " [|vol]"));
 }
 
 /*
@@ -1838,15 +2368,15 @@ trunc:
  */
 
 static void
-bos_print(register const u_char *bp, int length)
+bos_print(netdissect_options *ndo,
+          register const u_char *bp, int length)
 {
 	int bos_op;
-	char s[BOSNAMEMAX];
 
-	if (length <= sizeof(struct rx_header))
+	if (length <= (int)sizeof(struct rx_header))
 		return;
 
-	if (snapend - bp + 1 <= sizeof(struct rx_header) + sizeof(int32_t)) {
+	if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
 		goto trunc;
 	}
 
@@ -1855,9 +2385,9 @@ bos_print(register const u_char *bp, int length)
 	 * gleaned from bozo/bosint.xg
 	 */
 
-	bos_op = ntohl(*((int *) (bp + sizeof(struct rx_header))));
+	bos_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
 
-	printf(" bos call %s", tok2str(bos_req, "op#%d", bos_op));
+	ND_PRINT((ndo, " bos call %s", tok2str(bos_req, "op#%d", bos_op)));
 
 	/*
 	 * Decode some of the arguments to the BOS calls
@@ -1867,9 +2397,9 @@ bos_print(register const u_char *bp, int length)
 
 	switch (bos_op) {
 		case 80:	/* Create B node */
-			printf(" type");
+			ND_PRINT((ndo, " type"));
 			STROUT(BOSNAMEMAX);
-			printf(" instance");
+			ND_PRINT((ndo, " instance"));
 			STROUT(BOSNAMEMAX);
 			break;
 		case 81:	/* Delete B node */
@@ -1890,12 +2420,12 @@ bos_print(register const u_char *bp, int length)
 		case 82:	/* Set status */
 		case 98:	/* Set T status */
 			STROUT(BOSNAMEMAX);
-			printf(" status");
+			ND_PRINT((ndo, " status"));
 			INTOUT();
 			break;
 		case 86:	/* Get instance parm */
 			STROUT(BOSNAMEMAX);
-			printf(" num");
+			ND_PRINT((ndo, " num"));
 			INTOUT();
 			break;
 		case 84:	/* Enumerate instance */
@@ -1908,11 +2438,11 @@ bos_print(register const u_char *bp, int length)
 			break;
 		case 105:	/* Install */
 			STROUT(BOSNAMEMAX);
-			printf(" size");
+			ND_PRINT((ndo, " size"));
 			INTOUT();
-			printf(" flags");
+			ND_PRINT((ndo, " flags"));
 			INTOUT();
-			printf(" date");
+			ND_PRINT((ndo, " date"));
 			INTOUT();
 			break;
 		default:
@@ -1922,7 +2452,7 @@ bos_print(register const u_char *bp, int length)
 	return;
 
 trunc:
-	printf(" [|bos]");
+	ND_PRINT((ndo, " [|bos]"));
 }
 
 /*
@@ -1930,13 +2460,12 @@ trunc:
  */
 
 static void
-bos_reply_print(register const u_char *bp, int length, int32_t opcode)
+bos_reply_print(netdissect_options *ndo,
+                register const u_char *bp, int length, int32_t opcode)
 {
-	unsigned long i;
-	char s[AFSNAMEMAX];
 	struct rx_header *rxh;
 
-	if (length <= sizeof(struct rx_header))
+	if (length <= (int)sizeof(struct rx_header))
 		return;
 
 	rxh = (struct rx_header *) bp;
@@ -1945,8 +2474,8 @@ bos_reply_print(register const u_char *bp, int length, int32_t opcode)
 	 * Print out the afs call we're invoking.  The table used here was
 	 * gleaned from volser/volint.xg
 	 */
-	
-	printf(" bos reply %s", tok2str(bos_req, "op#%d", opcode));
+
+	ND_PRINT((ndo, " bos reply %s", tok2str(bos_req, "op#%d", opcode)));
 
 	bp += sizeof(struct rx_header);
 
@@ -1961,14 +2490,14 @@ bos_reply_print(register const u_char *bp, int length, int32_t opcode)
 		/*
 		 * Otherwise, just print out the return code
 		 */
-		printf(" errcode");
+		ND_PRINT((ndo, " errcode"));
 		INTOUT();
 	}
 
 	return;
 
 trunc:
-	printf(" [|bos]");
+	ND_PRINT((ndo, " [|bos]"));
 }
 
 /*
@@ -1976,7 +2505,7 @@ trunc:
  */
 
 static int
-is_ubik(u_int32_t opcode)
+is_ubik(uint32_t opcode)
 {
 	if ((opcode >= VOTE_LOW && opcode <= VOTE_HIGH) ||
 	    (opcode >= DISK_LOW && opcode <= DISK_HIGH))
@@ -1990,7 +2519,8 @@ is_ubik(u_int32_t opcode)
  */
 
 static void
-ubik_print(register const u_char *bp, int length)
+ubik_print(netdissect_options *ndo,
+           register const u_char *bp)
 {
 	int ubik_op;
 	int32_t temp;
@@ -2000,9 +2530,9 @@ ubik_print(register const u_char *bp, int length)
 	 * gleaned from ubik/ubik_int.xg
 	 */
 
-	ubik_op = ntohl(*((int *) (bp + sizeof(struct rx_header))));
+	ubik_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
 
-	printf(" ubik call %s", tok2str(ubik_req, "op#%d", ubik_op));
+	ND_PRINT((ndo, " ubik call %s", tok2str(ubik_req, "op#%d", ubik_op)));
 
 	/*
 	 * Decode some of the arguments to the Ubik calls
@@ -2012,19 +2542,19 @@ ubik_print(register const u_char *bp, int length)
 
 	switch (ubik_op) {
 		case 10000:		/* Beacon */
-			TRUNC(4);
-			temp = ntohl(*((int *) bp));
+			ND_TCHECK2(bp[0], 4);
+			temp = EXTRACT_32BITS(bp);
 			bp += sizeof(int32_t);
-			printf(" syncsite %s", temp ? "yes" : "no");
-			printf(" votestart");
+			ND_PRINT((ndo, " syncsite %s", temp ? "yes" : "no"));
+			ND_PRINT((ndo, " votestart"));
 			DATEOUT();
-			printf(" dbversion");
+			ND_PRINT((ndo, " dbversion"));
 			UBIK_VERSIONOUT();
-			printf(" tid");
+			ND_PRINT((ndo, " tid"));
 			UBIK_VERSIONOUT();
 			break;
 		case 10003:		/* Get sync site */
-			printf(" site");
+			ND_PRINT((ndo, " site"));
 			UINTOUT();
 			break;
 		case 20000:		/* Begin */
@@ -2032,56 +2562,56 @@ ubik_print(register const u_char *bp, int length)
 		case 20007:		/* Abort */
 		case 20008:		/* Release locks */
 		case 20010:		/* Writev */
-			printf(" tid");
+			ND_PRINT((ndo, " tid"));
 			UBIK_VERSIONOUT();
 			break;
 		case 20002:		/* Lock */
-			printf(" tid");
+			ND_PRINT((ndo, " tid"));
 			UBIK_VERSIONOUT();
-			printf(" file");
+			ND_PRINT((ndo, " file"));
 			INTOUT();
-			printf(" pos");
+			ND_PRINT((ndo, " pos"));
 			INTOUT();
-			printf(" length");
+			ND_PRINT((ndo, " length"));
 			INTOUT();
-			temp = ntohl(*((int *) bp));
+			temp = EXTRACT_32BITS(bp);
 			bp += sizeof(int32_t);
 			tok2str(ubik_lock_types, "type %d", temp);
 			break;
 		case 20003:		/* Write */
-			printf(" tid");
+			ND_PRINT((ndo, " tid"));
 			UBIK_VERSIONOUT();
-			printf(" file");
+			ND_PRINT((ndo, " file"));
 			INTOUT();
-			printf(" pos");
+			ND_PRINT((ndo, " pos"));
 			INTOUT();
 			break;
 		case 20005:		/* Get file */
-			printf(" file");
+			ND_PRINT((ndo, " file"));
 			INTOUT();
 			break;
 		case 20006:		/* Send file */
-			printf(" file");
+			ND_PRINT((ndo, " file"));
 			INTOUT();
-			printf(" length");
+			ND_PRINT((ndo, " length"));
 			INTOUT();
-			printf(" dbversion");
+			ND_PRINT((ndo, " dbversion"));
 			UBIK_VERSIONOUT();
 			break;
 		case 20009:		/* Truncate */
-			printf(" tid");
+			ND_PRINT((ndo, " tid"));
 			UBIK_VERSIONOUT();
-			printf(" file");
+			ND_PRINT((ndo, " file"));
 			INTOUT();
-			printf(" length");
+			ND_PRINT((ndo, " length"));
 			INTOUT();
 			break;
 		case 20012:		/* Set version */
-			printf(" tid");
+			ND_PRINT((ndo, " tid"));
 			UBIK_VERSIONOUT();
-			printf(" oldversion");
+			ND_PRINT((ndo, " oldversion"));
 			UBIK_VERSIONOUT();
-			printf(" newversion");
+			ND_PRINT((ndo, " newversion"));
 			UBIK_VERSIONOUT();
 			break;
 		default:
@@ -2091,7 +2621,7 @@ ubik_print(register const u_char *bp, int length)
 	return;
 
 trunc:
-	printf(" [|ubik]");
+	ND_PRINT((ndo, " [|ubik]"));
 }
 
 /*
@@ -2099,11 +2629,12 @@ trunc:
  */
 
 static void
-ubik_reply_print(register const u_char *bp, int length, int32_t opcode)
+ubik_reply_print(netdissect_options *ndo,
+                 register const u_char *bp, int length, int32_t opcode)
 {
 	struct rx_header *rxh;
 
-	if (length < sizeof(struct rx_header))
+	if (length < (int)sizeof(struct rx_header))
 		return;
 
 	rxh = (struct rx_header *) bp;
@@ -2113,27 +2644,27 @@ ubik_reply_print(register const u_char *bp, int length, int32_t opcode)
 	 * from ubik/ubik_int.xg
 	 */
 
-	printf(" ubik reply %s", tok2str(ubik_req, "op#%d", opcode));
+	ND_PRINT((ndo, " ubik reply %s", tok2str(ubik_req, "op#%d", opcode)));
 
 	bp += sizeof(struct rx_header);
 
 	/*
 	 * If it was a data packet, print out the arguments to the Ubik calls
 	 */
-	
+
 	if (rxh->type == RX_PACKET_TYPE_DATA)
 		switch (opcode) {
 		case 10000:		/* Beacon */
-			printf(" vote no");
+			ND_PRINT((ndo, " vote no"));
 			break;
 		case 20004:		/* Get version */
-			printf(" dbversion");
+			ND_PRINT((ndo, " dbversion"));
 			UBIK_VERSIONOUT();
 			break;
 		default:
 			;
 		}
-	
+
 	/*
 	 * Otherwise, print out "yes" it it was a beacon packet (because
 	 * that's how yes votes are returned, go figure), otherwise
@@ -2143,16 +2674,211 @@ ubik_reply_print(register const u_char *bp, int length, int32_t opcode)
 	else
 		switch (opcode) {
 		case 10000:		/* Beacon */
-			printf(" vote yes until");
+			ND_PRINT((ndo, " vote yes until"));
 			DATEOUT();
 			break;
 		default:
-			printf(" errcode");
+			ND_PRINT((ndo, " errcode"));
 			INTOUT();
 		}
 
 	return;
 
 trunc:
-	printf(" [|ubik]");
+	ND_PRINT((ndo, " [|ubik]"));
+}
+
+/*
+ * Handle RX ACK packets.
+ */
+
+static void
+rx_ack_print(netdissect_options *ndo,
+             register const u_char *bp, int length)
+{
+	struct rx_ackPacket *rxa;
+	int i, start, last;
+	uint32_t firstPacket;
+
+	if (length < (int)sizeof(struct rx_header))
+		return;
+
+	bp += sizeof(struct rx_header);
+
+	/*
+	 * This may seem a little odd .... the rx_ackPacket structure
+	 * contains an array of individual packet acknowledgements
+	 * (used for selective ack/nack), but since it's variable in size,
+	 * we don't want to truncate based on the size of the whole
+	 * rx_ackPacket structure.
+	 */
+
+	ND_TCHECK2(bp[0], sizeof(struct rx_ackPacket) - RX_MAXACKS);
+
+	rxa = (struct rx_ackPacket *) bp;
+	bp += (sizeof(struct rx_ackPacket) - RX_MAXACKS);
+
+	/*
+	 * Print out a few useful things from the ack packet structure
+	 */
+
+	if (ndo->ndo_vflag > 2)
+		ND_PRINT((ndo, " bufspace %d maxskew %d",
+		       (int) EXTRACT_16BITS(&rxa->bufferSpace),
+		       (int) EXTRACT_16BITS(&rxa->maxSkew)));
+
+	firstPacket = EXTRACT_32BITS(&rxa->firstPacket);
+	ND_PRINT((ndo, " first %d serial %d reason %s",
+	       firstPacket, EXTRACT_32BITS(&rxa->serial),
+	       tok2str(rx_ack_reasons, "#%d", (int) rxa->reason)));
+
+	/*
+	 * Okay, now we print out the ack array.  The way _this_ works
+	 * is that we start at "first", and step through the ack array.
+	 * If we have a contiguous range of acks/nacks, try to
+	 * collapse them into a range.
+	 *
+	 * If you're really clever, you might have noticed that this
+	 * doesn't seem quite correct.  Specifically, due to structure
+	 * padding, sizeof(struct rx_ackPacket) - RX_MAXACKS won't actually
+	 * yield the start of the ack array (because RX_MAXACKS is 255
+	 * and the structure will likely get padded to a 2 or 4 byte
+	 * boundary).  However, this is the way it's implemented inside
+	 * of AFS - the start of the extra fields are at
+	 * sizeof(struct rx_ackPacket) - RX_MAXACKS + nAcks, which _isn't_
+	 * the exact start of the ack array.  Sigh.  That's why we aren't
+	 * using bp, but instead use rxa->acks[].  But nAcks gets added
+	 * to bp after this, so bp ends up at the right spot.  Go figure.
+	 */
+
+	if (rxa->nAcks != 0) {
+
+		ND_TCHECK2(bp[0], rxa->nAcks);
+
+		/*
+		 * Sigh, this is gross, but it seems to work to collapse
+		 * ranges correctly.
+		 */
+
+		for (i = 0, start = last = -2; i < rxa->nAcks; i++)
+			if (rxa->acks[i] == RX_ACK_TYPE_ACK) {
+
+				/*
+				 * I figured this deserved _some_ explanation.
+				 * First, print "acked" and the packet seq
+				 * number if this is the first time we've
+				 * seen an acked packet.
+				 */
+
+				if (last == -2) {
+					ND_PRINT((ndo, " acked %d", firstPacket + i));
+					start = i;
+				}
+
+				/*
+				 * Otherwise, if there is a skip in
+				 * the range (such as an nacked packet in
+				 * the middle of some acked packets),
+				 * then print the current packet number
+				 * seperated from the last number by
+				 * a comma.
+				 */
+
+				else if (last != i - 1) {
+					ND_PRINT((ndo, ",%d", firstPacket + i));
+					start = i;
+				}
+
+				/*
+				 * We always set last to the value of
+				 * the last ack we saw.  Conversely, start
+				 * is set to the value of the first ack
+				 * we saw in a range.
+				 */
+
+				last = i;
+
+				/*
+				 * Okay, this bit a code gets executed when
+				 * we hit a nack ... in _this_ case we
+				 * want to print out the range of packets
+				 * that were acked, so we need to print
+				 * the _previous_ packet number seperated
+				 * from the first by a dash (-).  Since we
+				 * already printed the first packet above,
+				 * just print the final packet.  Don't
+				 * do this if there will be a single-length
+				 * range.
+				 */
+			} else if (last == i - 1 && start != last)
+				ND_PRINT((ndo, "-%d", firstPacket + i - 1));
+
+		/*
+		 * So, what's going on here?  We ran off the end of the
+		 * ack list, and if we got a range we need to finish it up.
+		 * So we need to determine if the last packet in the list
+		 * was an ack (if so, then last will be set to it) and
+		 * we need to see if the last range didn't start with the
+		 * last packet (because if it _did_, then that would mean
+		 * that the packet number has already been printed and
+		 * we don't need to print it again).
+		 */
+
+		if (last == i - 1 && start != last)
+			ND_PRINT((ndo, "-%d", firstPacket + i - 1));
+
+		/*
+		 * Same as above, just without comments
+		 */
+
+		for (i = 0, start = last = -2; i < rxa->nAcks; i++)
+			if (rxa->acks[i] == RX_ACK_TYPE_NACK) {
+				if (last == -2) {
+					ND_PRINT((ndo, " nacked %d", firstPacket + i));
+					start = i;
+				} else if (last != i - 1) {
+					ND_PRINT((ndo, ",%d", firstPacket + i));
+					start = i;
+				}
+				last = i;
+			} else if (last == i - 1 && start != last)
+				ND_PRINT((ndo, "-%d", firstPacket + i - 1));
+
+		if (last == i - 1 && start != last)
+			ND_PRINT((ndo, "-%d", firstPacket + i - 1));
+
+		bp += rxa->nAcks;
+	}
+
+
+	/*
+	 * These are optional fields; depending on your version of AFS,
+	 * you may or may not see them
+	 */
+
+#define TRUNCRET(n)	if (ndo->ndo_snapend - bp + 1 <= n) return;
+
+	if (ndo->ndo_vflag > 1) {
+		TRUNCRET(4);
+		ND_PRINT((ndo, " ifmtu"));
+		INTOUT();
+
+		TRUNCRET(4);
+		ND_PRINT((ndo, " maxmtu"));
+		INTOUT();
+
+		TRUNCRET(4);
+		ND_PRINT((ndo, " rwind"));
+		INTOUT();
+
+		TRUNCRET(4);
+		ND_PRINT((ndo, " maxpackets"));
+		INTOUT();
+	}
+
+	return;
+
+trunc:
+	ND_PRINT((ndo, " [|ack]"));
 }
+#undef TRUNCRET