The Tcpdump Group git mirrors - tcpdump/blobdiff

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

* 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

* 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

* 3. The names of the authors may not be used to endorse or promote

* products derived from this software without specific prior

* written permission.

* 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 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.

* Ken Hornstein <[email protected]>

*/

* Ken Hornstein <[email protected]>

*/

-#ifndef lint

-static const char rcsid[] =

- "@(#) $Header: /tcpdump/master/tcpdump/print-rx.c,v 1.28 2002-04-20 09:42:57 guy Exp $";

-#endif

-

+#define NETDISSECT_REWORKED

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

-#ifdef TIME_WITH_SYS_TIME

-#include <time.h>

-#endif

-#include <sys/param.h>

-#include <sys/time.h>

-#include <sys/types.h>

-#include <sys/socket.h>

-#include <netinet/in.h>

-#include <arpa/inet.h>

+#include <tcpdump-stdinc.h>

#include "interface.h"

#include "addrtoname.h"

#include "extract.h"

#include "interface.h"

#include "addrtoname.h"

#include "extract.h"

-#include "rx.h"

-

#include "ip.h"

-static struct tok rx_types[] = {

+#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 */

+};

+

+/*

+ * Values for the acks array

+ */

+

+#define RX_ACK_TYPE_NACK 0 /* Don't have this packet */

+#define RX_ACK_TYPE_ACK 1 /* I have this packet */

+

+static const struct tok rx_types[] = {

{ RX_PACKET_TYPE_DATA, "data" },

{ RX_PACKET_TYPE_ACK, "ack" },

{ RX_PACKET_TYPE_BUSY, "busy" },

{ RX_PACKET_TYPE_DATA, "data" },

{ RX_PACKET_TYPE_ACK, "ack" },

{ RX_PACKET_TYPE_BUSY, "busy" },

{ 0, NULL },

};

{ 0, NULL },

};

-static struct double_tok {

+static const struct double_tok {

int flag; /* Rx flag */

int packetType; /* Packet type */

int flag; /* Rx flag */

int packetType; /* Packet type */

- char *s; /* Flag string */

+ const char *s; /* Flag string */

} rx_flags[] = {

{ RX_CLIENT_INITIATED, 0, "client-init" },

{ RX_REQUEST_ACK, 0, "req-ack" },

} rx_flags[] = {

{ RX_CLIENT_INITIATED, 0, "client-init" },

{ RX_REQUEST_ACK, 0, "req-ack" },

{ RX_JUMBO_PACKET, RX_PACKET_TYPE_DATA, "jumbogram" }

};

{ 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" },

{ 130, "fetch-data" },

{ 131, "fetch-acl" },

{ 132, "fetch-status" },

{ 162, "dfs-flushcps" },

{ 163, "dfs-symlink" },

{ 220, "residency" },

{ 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 },

};

{ 0, NULL },

};

-static struct tok cb_req[] = {

+static const struct tok cb_req[] = {

{ 204, "callback" },

{ 205, "initcb" },

{ 206, "probe" },

{ 204, "callback" },

{ 205, "initcb" },

{ 206, "probe" },

{ 216, "getcellservdb" },

{ 217, "getlocalcell" },

{ 218, "getcacheconf" },

{ 216, "getcellservdb" },

{ 217, "getlocalcell" },

{ 218, "getcacheconf" },

+ { 65536, "getce64" },

+ { 65537, "getcellbynum" },

+ { 65538, "tellmeaboutyourself" },

{ 0, NULL },

};

{ 0, NULL },

};

-static struct tok pt_req[] = {

+static const struct tok pt_req[] = {

{ 500, "new-user" },

{ 501, "where-is-it" },

{ 502, "dump-entry" },

{ 500, "new-user" },

{ 501, "where-is-it" },

{ 502, "dump-entry" },

{ 519, "get-host-cps" },

{ 520, "update-entry" },

{ 521, "list-entries" },

{ 519, "get-host-cps" },

{ 520, "update-entry" },

{ 521, "list-entries" },

+ { 530, "list-super-groups" },

{ 0, NULL },

};

{ 0, NULL },

};

-static struct tok vldb_req[] = {

+static const struct tok vldb_req[] = {

{ 501, "create-entry" },

{ 502, "delete-entry" },

{ 503, "get-entry-by-id" },

{ 501, "create-entry" },

{ 502, "delete-entry" },

{ 503, "get-entry-by-id" },

{ 0, NULL },

};

{ 0, NULL },

};

-static struct tok kauth_req[] = {

+static const struct tok kauth_req[] = {

{ 1, "auth-old" },

{ 21, "authenticate" },

{ 22, "authenticate-v2" },

{ 1, "auth-old" },

{ 21, "authenticate" },

{ 22, "authenticate-v2" },

{ 0, NULL },

};

{ 0, NULL },

};

-static struct tok vol_req[] = {

+static const struct tok vol_req[] = {

{ 100, "create-volume" },

{ 101, "delete-volume" },

{ 102, "restore" },

{ 100, "create-volume" },

{ 101, "delete-volume" },

{ 102, "restore" },

{ 126, "set-info" },

{ 127, "x-list-partitions" },

{ 128, "forward-multiple" },

{ 126, "set-info" },

{ 127, "x-list-partitions" },

{ 128, "forward-multiple" },

+ { 65536, "convert-ro" },

+ { 65537, "get-size" },

+ { 65538, "dump-v2" },

{ 0, NULL },

};

{ 0, NULL },

};

-static struct tok bos_req[] = {

+static const struct tok bos_req[] = {

{ 80, "create-bnode" },

{ 81, "delete-bnode" },

{ 82, "set-status" },

{ 80, "create-bnode" },

{ 81, "delete-bnode" },

{ 82, "set-status" },

{ 0, NULL },

};

{ 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" },

{ 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" },

{ 20000, "disk-begin" },

{ 20001, "disk-commit" },

{ 20002, "disk-lock" },

};

#define VOTE_LOW 10000

};

#define VOTE_LOW 10000

-#define VOTE_HIGH 10005

+#define VOTE_HIGH 10007

#define DISK_LOW 20000

#define DISK_HIGH 20013

#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 },

};

{ 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 },

};

{ 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 struct tok afs_fs_errors[] = {

+static const struct tok afs_fs_errors[] = {

{ 101, "salvage volume" },

{ 102, "no such vnode" },

{ 103, "no such volume" },

{ 101, "salvage volume" },

{ 102, "no such vnode" },

{ 103, "no such volume" },

{ 110, "volume busy" },

{ 111, "volume moved" },

{ 112, "AFS IO error" },

{ 110, "volume busy" },

{ 111, "volume moved" },

{ 112, "AFS IO error" },

- { -100, "restarting fileserver" },

+ { 0xffffff9c, "restarting fileserver" }, /* -100, sic! */

{ 0, NULL }

};

{ 0, NULL }

};

* Reasons for acknowledging a packet

*/

* Reasons for acknowledging a packet

*/

-static struct tok rx_ack_reasons[] = {

+static const struct tok rx_ack_reasons[] = {

{ 1, "ack requested" },

{ 2, "duplicate packet" },

{ 3, "out of sequence" },

{ 1, "ack requested" },

{ 2, "duplicate packet" },

{ 3, "out of sequence" },

{ 6, "ping" },

{ 7, "ping response" },

{ 8, "delay" },

{ 6, "ping" },

{ 7, "ping response" },

{ 8, "delay" },

+ { 9, "idle" },

{ 0, NULL },

};

{ 0, NULL },

};

*/

struct rx_cache_entry {

*/

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) */

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

};

#define RX_CACHE_SIZE 64

static int rx_cache_next = 0;

static int rx_cache_hint = 0;

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 int rx_cache_find(const struct rx_header *, const struct ip *,

int, int32_t *);

-static void ack_print(const u_char *, int);

-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 *, int, 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 void rx_ack_print(const u_char *, int);

-

-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

/*

* Handle the rx-level packet. See if we know what port it's going to so

*/

void

*/

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;

{

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;

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) {

+ if (ndo->ndo_vflag) {

int firstflag = 0;

- if (vflag > 1)

- printf(" cid %08x call# %d",

+ if (ndo->ndo_vflag > 1)

+ ND_PRINT((ndo, " cid %08x call# %d",

(int) EXTRACT_32BITS(&rxh->cid),

- (int) EXTRACT_32BITS(&rxh->callNumber));

+ (int) EXTRACT_32BITS(&rxh->callNumber)));

- printf(" seq %d ser %d",

+ ND_PRINT((ndo, " seq %d ser %d",

(int) EXTRACT_32BITS(&rxh->seq),

- (int) EXTRACT_32BITS(&rxh->serial));

+ (int) EXTRACT_32BITS(&rxh->serial)));

- if (vflag > 2)

- printf(" secindex %d serviceid %hu",

+ if (ndo->ndo_vflag > 2)

+ ND_PRINT((ndo, " secindex %d serviceid %hu",

(int) rxh->securityIndex,

- EXTRACT_16BITS(&rxh->serviceId));

+ EXTRACT_16BITS(&rxh->serviceId)));

- if (vflag > 1)

+ 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;

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;

- printf(" ");

+ ND_PRINT((ndo, " "));

} else {

- printf(",");

+ ND_PRINT((ndo, ","));

}

- printf("<%s>", rx_flags[i].s);

+ ND_PRINT((ndo, "<%s>", rx_flags[i].s));

}

* as well.

*/

* as well.

*/

- if (rxh->type == RX_PACKET_TYPE_ACK)

- ack_print(bp, length);

- else if (rxh->type == RX_PACKET_TYPE_DATA &&

+ if (rxh->type == RX_PACKET_TYPE_DATA &&

EXTRACT_32BITS(&rxh->seq) == 1 &&

rxh->flags & RX_CLIENT_INITIATED) {

EXTRACT_32BITS(&rxh->seq) == 1 &&

rxh->flags & RX_CLIENT_INITIATED) {

* have a chance to print out replies

*/

* 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 */

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 */

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 */

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 */

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 */

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 */

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 */

break;

case BOS_RX_PORT: /* AFS BOS service */

- bos_print(bp, length);

+ bos_print(ndo, bp, length);

break;

default:

;

}

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

/*

* 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

switch (sport) {

case FS_RX_PORT: /* AFS file service */

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 */

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 */

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 */

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 */

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 */

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 */

break;

case BOS_RX_PORT: /* AFS BOS service */

- bos_reply_print(bp, length, opcode);

+ bos_reply_print(ndo, bp, length, opcode);

break;

default:

;

break;

default:

;

*/

} else if (rxh->type == RX_PACKET_TYPE_ACK)

*/

} else if (rxh->type == RX_PACKET_TYPE_ACK)

- rx_ack_print(bp, length);

+ rx_ack_print(ndo, bp, length);

- printf(" (%d)", length);

+ ND_PRINT((ndo, " (%d)", length));

}

/*

}

/*

*/

static void

*/

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;

{

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;

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->callnum = rxh->callNumber;

rxent->client = ip->ip_src;

rxent->server = ip->ip_dst;

{

int i;

struct rx_cache_entry *rxent;

{

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 */

rxent = &rx_cache[i];

if (rxent->callnum == rxh->callNumber &&

rxent->client.s_addr == clip &&

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) {

rxent->serviceId == rxh->serviceId &&

rxent->dport == sport) {

*opcode = rxent->opcode;

return(1);

}

*opcode = rxent->opcode;

return(1);

}

- if (++i > RX_CACHE_SIZE)

+ if (++i >= RX_CACHE_SIZE)

i = 0;

} while (i != rx_cache_hint);

i = 0;

} while (i != rx_cache_hint);

*/

#define FIDOUT() { unsigned long n1, n2, n3; \

*/

#define FIDOUT() { unsigned long n1, n2, n3; \

- TCHECK2(bp[0], sizeof(int32_t) * 3); \

+ 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); \

n1 = EXTRACT_32BITS(bp); \

bp += sizeof(int32_t); \

n2 = EXTRACT_32BITS(bp); \

bp += sizeof(int32_t); \

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) { unsigned int i; \

}

#define STROUT(MAX) { unsigned int i; \

- TCHECK2(bp[0], sizeof(int32_t)); \

+ ND_TCHECK2(bp[0], sizeof(int32_t)); \

i = EXTRACT_32BITS(bp); \

if (i > (MAX)) \

goto trunc; \

bp += sizeof(int32_t); \

i = EXTRACT_32BITS(bp); \

if (i > (MAX)) \

goto trunc; \

bp += sizeof(int32_t); \

- printf(" \""); \

- if (fn_printn(bp, i, snapend)) \

+ ND_PRINT((ndo, " \"")); \

+ if (fn_printn(ndo, bp, i, ndo->ndo_snapend)) \

goto trunc; \

- printf("\""); \

+ ND_PRINT((ndo, "\"")); \

bp += ((i + sizeof(int32_t) - 1) / sizeof(int32_t)) * sizeof(int32_t); \

}

#define INTOUT() { int i; \

bp += ((i + sizeof(int32_t) - 1) / sizeof(int32_t)) * sizeof(int32_t); \

}

#define INTOUT() { int i; \

- TCHECK2(bp[0], sizeof(int32_t)); \

+ ND_TCHECK2(bp[0], sizeof(int32_t)); \

i = (int) EXTRACT_32BITS(bp); \

bp += 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; \

}

#define UINTOUT() { unsigned long i; \

- TCHECK2(bp[0], sizeof(int32_t)); \

+ ND_TCHECK2(bp[0], sizeof(int32_t)); \

i = EXTRACT_32BITS(bp); \

bp += 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]; \

}

#define DATEOUT() { time_t t; struct tm *tm; char str[256]; \

- TCHECK2(bp[0], sizeof(int32_t)); \

+ ND_TCHECK2(bp[0], sizeof(int32_t)); \

t = (time_t) EXTRACT_32BITS(bp); \

bp += sizeof(int32_t); \

tm = localtime(&t); \

strftime(str, 256, "%Y/%m/%d %T", tm); \

t = (time_t) EXTRACT_32BITS(bp); \

bp += sizeof(int32_t); \

tm = localtime(&t); \

strftime(str, 256, "%Y/%m/%d %T", tm); \

- printf(" %s", str); \

+ ND_PRINT((ndo, " %s", str)); \

}

#define STOREATTROUT() { unsigned long mask, i; \

}

#define STOREATTROUT() { unsigned long mask, i; \

- TCHECK2(bp[0], (sizeof(int32_t)*6)); \

+ ND_TCHECK2(bp[0], (sizeof(int32_t)*6)); \

mask = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \

- if (mask) printf (" StoreStatus"); \

- if (mask & 1) { printf(" date"); DATEOUT(); } \

+ 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); \

else bp += sizeof(int32_t); \

i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \

- if (mask & 2) printf(" owner %lu", i); \

+ if (mask & 2) ND_PRINT((ndo, " owner %lu", i)); \

i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \

- if (mask & 4) printf(" group %lu", i); \

+ if (mask & 4) ND_PRINT((ndo, " group %lu", i)); \

i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \

- if (mask & 8) printf(" mode %lo", i & 07777); \

+ if (mask & 8) ND_PRINT((ndo, " mode %lo", i & 07777)); \

i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \

- if (mask & 16) printf(" segsize %lu", i); \

+ if (mask & 16) ND_PRINT((ndo, " segsize %lu", i)); \

/* undocumented in 3.3 docu */ \

- if (mask & 1024) printf(" fsync"); \

+ if (mask & 1024) ND_PRINT((ndo, " fsync")); \

}

#define UBIK_VERSIONOUT() {int32_t epoch; int32_t counter; \

}

#define UBIK_VERSIONOUT() {int32_t epoch; int32_t counter; \

- TCHECK2(bp[0], sizeof(int32_t) * 2); \

+ ND_TCHECK2(bp[0], sizeof(int32_t) * 2); \

epoch = EXTRACT_32BITS(bp); \

bp += sizeof(int32_t); \

counter = EXTRACT_32BITS(bp); \

bp += sizeof(int32_t); \

epoch = EXTRACT_32BITS(bp); \

bp += sizeof(int32_t); \

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; \

- TCHECK2(bp[0], 11*sizeof(u_int32_t)); \

+#define AFSUUIDOUT() {uint32_t temp; int i; \

+ ND_TCHECK2(bp[0], 11*sizeof(uint32_t)); \

temp = EXTRACT_32BITS(bp); \

- bp += sizeof(u_int32_t); \

- printf(" %08x", temp); \

+ bp += sizeof(uint32_t); \

+ ND_PRINT((ndo, " %08x", temp)); \

temp = EXTRACT_32BITS(bp); \

- bp += sizeof(u_int32_t); \

- printf("%04x", temp); \

+ bp += sizeof(uint32_t); \

+ ND_PRINT((ndo, "%04x", temp)); \

temp = EXTRACT_32BITS(bp); \

- bp += sizeof(u_int32_t); \

- printf("%04x", temp); \

+ bp += sizeof(uint32_t); \

+ ND_PRINT((ndo, "%04x", temp)); \

for (i = 0; i < 8; i++) { \

temp = EXTRACT_32BITS(bp); \

for (i = 0; i < 8; i++) { \

temp = EXTRACT_32BITS(bp); \

- bp += sizeof(u_int32_t); \

- printf("%02x", (unsigned char) temp); \

+ bp += sizeof(uint32_t); \

+ ND_PRINT((ndo, "%02x", (unsigned char) temp)); \

} \

}

} \

}

* This is the sickest one of all

*/

* This is the sickest one of all

*/

-#define VECOUT(MAX) { char *sp; \

- char s[AFSNAMEMAX]; \

+#define VECOUT(MAX) { u_char *sp; \

+ u_char s[AFSNAMEMAX]; \

int k; \

if ((MAX) + 1 > sizeof(s)) \

goto trunc; \

int k; \

if ((MAX) + 1 > sizeof(s)) \

goto trunc; \

- TCHECK2(bp[0], (MAX) * sizeof(int32_t)); \

+ ND_TCHECK2(bp[0], (MAX) * sizeof(int32_t)); \

sp = s; \

for (k = 0; k < (MAX); k++) { \

sp = s; \

for (k = 0; k < (MAX); k++) { \

- *sp++ = (char) EXTRACT_32BITS(bp); \

+ *sp++ = (u_char) EXTRACT_32BITS(bp); \

bp += sizeof(int32_t); \

} \

s[(MAX)] = '\0'; \

bp += sizeof(int32_t); \

} \

s[(MAX)] = '\0'; \

- printf(" \""); \

- fn_print(s, NULL); \

- printf("\""); \

+ ND_PRINT((ndo, " \"")); \

+ fn_print(ndo, s, NULL); \

+ ND_PRINT((ndo, "\"")); \

}

-static void

-ack_print(register const u_char *bp, int length)

-{

- u_char nAcks;

- int i;

-

- if (vflag <= 1)

- return;

-

- if (length <= sizeof(struct rx_header))

- return;

-

- bp += sizeof(struct rx_header);

-

- /*

- * Packets < firstPacket are implicitly acknowledged and may

- * be discarded by the sender.

- *

- * Packets >= firstPacket+nAcks are implicitly NOT acknowledged.

- *

- * No packets with sequence numbers >= firstPacket should be

- * discarded by the sender (they may thrown out at any time by

- * the receiver)

- */

-#define RX_ACK_REASONS "RDOXSprn"

- /* Requested, Duplicate, Out_of_sequence, eXceeds_window, no_Space,

- * Ping, ping_Response, No_{progress, particular_reason}.

- */

-#if 0

- struct rx_ackPacket {

- u_short bufferSpace; /* Skip! */

- u_short maxSkew; /* Skip! */

- u_long firstPacket;

- u_long previousPacket; /* Obsolete! */

- u_long serial; /* Serial that prompted the ack, */

- u_char reason; /* and the reason why. */

- u_char nAcks;

- u_char acks[RX_MAXACKS]; /* Selective acks (not a bitmap). */

- };

-#endif

-#define RX_ACK_TYPE_NACK 0

-

- TCHECK2(bp[0], 8); /* bufferSpace and maxSkew */

- bp += 4;

- printf(" fir %u", (unsigned)EXTRACT_32BITS(bp));

- bp += 4;

- TCHECK2(bp[0], 8); /* previousPacket and serial */

- bp += 4;

- printf(" %u", (unsigned)EXTRACT_32BITS(bp));

- bp += 4;

- TCHECK2(bp[0], 1);

- printf("%c", RX_ACK_REASONS[(*bp - 1) & 07u]);

- bp += 1; /* reason */

- TCHECK2(bp[0], 1);

- nAcks = *bp;

- bp += 1; /* nAcks */

-

- for (i = 0; i < nAcks; i++) {

- TCHECK2(bp[0], 1);

- putchar(*bp == RX_ACK_TYPE_NACK? '-' : '*');

- bp += 1;

- }

-

- return;

-

-trunc:

- printf(" [|ack]");

-}

+#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)

*/

static void

/*

* Handle calls to the AFS file service (fs)

*/

static void

-fs_print(register const u_char *bp, int length)

+fs_print(netdissect_options *ndo,

+ register const u_char *bp, int length)

{

int fs_op;

unsigned long i;

{

int fs_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;

}

goto trunc;

}

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

/*

* Print out arguments to some of the AFS calls. This stuff is

switch (fs_op) {

case 130: /* Fetch data */

FIDOUT();

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 */

UINTOUT();

break;

case 131: /* Fetch ACL */

case 133: /* Store data */

FIDOUT();

STOREATTROUT();

case 133: /* Store data */

FIDOUT();

STOREATTROUT();

- printf(" offset");

+ ND_PRINT((ndo, " offset"));

UINTOUT();

- printf(" length");

+ ND_PRINT((ndo, " length"));

UINTOUT();

- printf(" flen");

+ ND_PRINT((ndo, " flen"));

UINTOUT();

break;

case 134: /* Store ACL */

{

char a[AFSOPAQUEMAX+1];

FIDOUT();

UINTOUT();

break;

case 134: /* Store ACL */

{

char a[AFSOPAQUEMAX+1];

FIDOUT();

- TCHECK2(bp[0], 4);

+ ND_TCHECK2(bp[0], 4);

i = EXTRACT_32BITS(bp);

bp += sizeof(int32_t);

i = EXTRACT_32BITS(bp);

bp += sizeof(int32_t);

- TCHECK2(bp[0], i);

+ ND_TCHECK2(bp[0], i);

i = min(AFSOPAQUEMAX, i);

strncpy(a, (char *) bp, i);

a[i] = '\0';

i = min(AFSOPAQUEMAX, i);

strncpy(a, (char *) bp, i);

a[i] = '\0';

- acl_print((u_char *) a, sizeof(a), (u_char *) a + i);

+ acl_print(ndo, (u_char *) a, sizeof(a), (u_char *) a + i);

break;

}

case 137: /* Create file */

break;

}

case 137: /* Create file */

STROUT(AFSNAMEMAX);

break;

case 138: /* Rename file */

STROUT(AFSNAMEMAX);

break;

case 138: /* Rename file */

- printf(" old");

+ ND_PRINT((ndo, " old"));

FIDOUT();

STROUT(AFSNAMEMAX);

FIDOUT();

STROUT(AFSNAMEMAX);

- printf(" new");

+ ND_PRINT((ndo, " new"));

FIDOUT();

STROUT(AFSNAMEMAX);

break;

case 139: /* Symlink */

FIDOUT();

STROUT(AFSNAMEMAX);

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);

break;

case 140: /* Link */

FIDOUT();

STROUT(AFSNAMEMAX);

- printf(" link to");

+ ND_PRINT((ndo, " link to"));

FIDOUT();

break;

case 148: /* Get volume info */

FIDOUT();

break;

case 148: /* Get volume info */

break;

case 149: /* Get volume stats */

case 150: /* Set volume stats */

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 */

UINTOUT();

break;

case 154: /* New get volume info */

- printf(" volname");

+ ND_PRINT((ndo, " volname"));

STROUT(AFSNAMEMAX);

break;

case 155: /* Bulk stat */

STROUT(AFSNAMEMAX);

break;

case 155: /* Bulk stat */

+ case 65536: /* Inline bulk stat */

{

unsigned long j;

{

unsigned long j;

- TCHECK2(bp[0], 4);

+ ND_TCHECK2(bp[0], 4);

j = EXTRACT_32BITS(bp);

bp += sizeof(int32_t);

for (i = 0; i < j; i++) {

FIDOUT();

if (i != j - 1)

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)

}

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:

;

}

default:

;

}

return;

trunc:

return;

trunc:

- printf(" [|fs]");

+ ND_PRINT((ndo, " [|fs]"));

}

/*

}

/*

*/

static void

*/

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;

struct rx_header *rxh;

{

unsigned long i;

struct rx_header *rxh;

- if (length <= sizeof(struct rx_header))

+ if (length <= (int)sizeof(struct rx_header))

return;

rxh = (struct rx_header *) bp;

return;

rxh = (struct rx_header *) bp;

* gleaned from fsint/afsint.xg

*/

* 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);

case 131: /* Fetch ACL */

{

char a[AFSOPAQUEMAX+1];

case 131: /* Fetch ACL */

{

char a[AFSOPAQUEMAX+1];

- TCHECK2(bp[0], 4);

+ ND_TCHECK2(bp[0], 4);

i = EXTRACT_32BITS(bp);

bp += sizeof(int32_t);

i = EXTRACT_32BITS(bp);

bp += sizeof(int32_t);

- TCHECK2(bp[0], i);

+ ND_TCHECK2(bp[0], i);

i = min(AFSOPAQUEMAX, i);

strncpy(a, (char *) bp, i);

a[i] = '\0';

i = min(AFSOPAQUEMAX, i);

strncpy(a, (char *) bp, i);

a[i] = '\0';

- acl_print((u_char *) a, sizeof(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 */

break;

}

case 137: /* Create file */

case 141: /* MakeDir */

- printf(" new");

+ ND_PRINT((ndo, " new"));

FIDOUT();

break;

case 151: /* Get root volume */

FIDOUT();

break;

case 151: /* Get root volume */

- printf(" root volume");

+ ND_PRINT((ndo, " root volume"));

STROUT(AFSNAMEMAX);

break;

case 153: /* Get time */

STROUT(AFSNAMEMAX);

break;

case 153: /* Get time */

} else if (rxh->type == RX_PACKET_TYPE_ABORT) {

int i;

} else if (rxh->type == RX_PACKET_TYPE_ABORT) {

int i;

- /*

- * Otherwise, just print out the return code

- */

- TCHECK2(bp[0], sizeof(int32_t));

- i = (int) EXTRACT_32BITS(bp);

- bp += sizeof(int32_t);

+ /*

+ * Otherwise, just print out the return code

+ */

+ ND_TCHECK2(bp[0], sizeof(int32_t));

+ i = (int) EXTRACT_32BITS(bp);

+ bp += sizeof(int32_t);

- printf(" error %s", tok2str(afs_fs_errors, "#%d", i));

+ ND_PRINT((ndo, " error %s", tok2str(afs_fs_errors, "#%d", i)));

} else {

- printf(" strange fs reply of type %d", rxh->type);

+ ND_PRINT((ndo, " strange fs reply of type %d", rxh->type));

}

return;

trunc:

}

return;

trunc:

- printf(" [|fs]");

+ ND_PRINT((ndo, " [|fs]"));

}

/*

}

/*

* <positive> <negative>

* <uid1> <aclbits1>

* ....

* <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

* "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

*/

static void

*/

static void

-acl_print(u_char *s, int maxsize, 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;

{

int pos, neg, acl;

int n, i;

char *user;

+ char fmt[1024];

if ((user = (char *)malloc(maxsize)) == NULL)

return;

if (sscanf((char *) s, "%d %d\n%n", &pos, &neg, &n) != 2)

goto finish;

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)

s += n;

if (s > end)

*/

#define ACLOUT(acl) \

*/

#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)

+ snprintf(fmt, sizeof(fmt), "%%%ds %%d\n%%n", maxsize - 1);

+ if (sscanf((char *) s, fmt, user, &acl, &n) != 2)

goto finish;

s += n;

goto finish;

s += n;

- printf(" +{");

- fn_print(user, NULL);

- printf(" ");

+ ND_PRINT((ndo, " +{"));

+ fn_print(ndo, (u_char *)user, NULL);

+ ND_PRINT((ndo, " "));

ACLOUT(acl);

- printf("}");

+ ND_PRINT((ndo, "}"));

if (s > end)

goto finish;

}

for (i = 0; i < neg; i++) {

if (s > end)

goto finish;

}

for (i = 0; i < neg; i++) {

- if (sscanf((char *) s, "%s %d\n%n", user, &acl, &n) != 2)

+ snprintf(fmt, sizeof(fmt), "%%%ds %%d\n%%n", maxsize - 1);

+ if (sscanf((char *) s, fmt, user, &acl, &n) != 2)

goto finish;

s += n;

goto finish;

s += n;

- printf(" -{");

- fn_print(user, NULL);

- printf(" ");

+ ND_PRINT((ndo, " -{"));

+ fn_print(ndo, (u_char *)user, NULL);

+ ND_PRINT((ndo, " "));

ACLOUT(acl);

- printf("}");

+ ND_PRINT((ndo, "}"));

if (s > end)

goto finish;

}

if (s > end)

goto finish;

}

*/

static void

*/

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;

{

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;

}

goto trunc;

}

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;

case 204: /* Callback */

{

unsigned long j, t;

case 204: /* Callback */

{

unsigned long j, t;

- TCHECK2(bp[0], 4);

+ ND_TCHECK2(bp[0], 4);

j = EXTRACT_32BITS(bp);

bp += sizeof(int32_t);

for (i = 0; i < j; i++) {

FIDOUT();

if (i != j - 1)

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)

}

if (j == 0)

- printf(" <none!>");

+ ND_PRINT((ndo, " <none!>"));

j = EXTRACT_32BITS(bp);

bp += sizeof(int32_t);

if (j != 0)

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();

- TCHECK2(bp[0], 4);

+ ND_TCHECK2(bp[0], 4);

t = EXTRACT_32BITS(bp);

bp += sizeof(int32_t);

tok2str(cb_types, "type %d", t);

}

case 214: {

t = EXTRACT_32BITS(bp);

bp += sizeof(int32_t);

tok2str(cb_types, "type %d", t);

}

case 214: {

- printf(" afsuuid");

+ ND_PRINT((ndo, " afsuuid"));

AFSUUIDOUT();

break;

}

AFSUUIDOUT();

break;

}

return;

trunc:

return;

trunc:

- printf(" [|cb]");

+ ND_PRINT((ndo, " [|cb]"));

}

/*

}

/*

*/

static void

*/

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)

{

struct rx_header *rxh;

{

struct rx_header *rxh;

- if (length <= sizeof(struct rx_header))

+ if (length <= (int)sizeof(struct rx_header))

return;

rxh = (struct rx_header *) bp;

return;

rxh = (struct rx_header *) bp;

* Print out the afs call we're invoking. The table used here was

* gleaned from fsint/afscbint.xg

*/

* 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);

/*

* Otherwise, just print out the return code

*/

/*

* Otherwise, just print out the return code

*/

- printf(" errcode");

+ ND_PRINT((ndo, " errcode"));

INTOUT();

}

return;

trunc:

INTOUT();

}

return;

trunc:

- printf(" [|cb]");

+ ND_PRINT((ndo, " [|cb]"));

}

/*

}

/*

*/

static void

*/

static void

-prot_print(register const u_char *bp, int length)

+prot_print(netdissect_options *ndo,

+ register const u_char *bp, int length)

{

unsigned long i;

int pt_op;

{

unsigned long i;

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;

}

goto trunc;

}

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;

}

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

/*

* Decode some of the arguments to the PT calls

switch (pt_op) {

case 500: /* I New User */

STROUT(PRNAMEMAX);

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 */

INTOUT();

break;

case 501: /* Where is it */

case 517: /* List owned */

case 518: /* Get CPS2 */

case 519: /* Get host CPS */

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 */

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? */

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;

INTOUT();

break;

case 504: /* Name to ID */

{

unsigned long j;

- TCHECK2(bp[0], 4);

+ ND_TCHECK2(bp[0], 4);

j = EXTRACT_32BITS(bp);

bp += sizeof(int32_t);

j = EXTRACT_32BITS(bp);

bp += sizeof(int32_t);

VECOUT(PRNAMEMAX);

}

if (j == 0)

VECOUT(PRNAMEMAX);

}

if (j == 0)

- printf(" <none!>");

+ ND_PRINT((ndo, " <none!>"));

}

break;

case 505: /* Id to name */

{

unsigned long j;

}

break;

case 505: /* Id to name */

{

unsigned long j;

- printf(" ids:");

- TCHECK2(bp[0], 4);

+ 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)

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);

}

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 */

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 */

INTOUT();

break;

case 513: /* Change entry */

- printf(" id");

+ ND_PRINT((ndo, " id"));

INTOUT();

STROUT(PRNAMEMAX);

INTOUT();

STROUT(PRNAMEMAX);

- printf(" oldid");

+ ND_PRINT((ndo, " oldid"));

INTOUT();

- printf(" newid");

+ ND_PRINT((ndo, " newid"));

INTOUT();

break;

case 520: /* Update entry */

INTOUT();

break;

case 520: /* Update entry */

- printf(" id");

+ ND_PRINT((ndo, " id"));

INTOUT();

STROUT(PRNAMEMAX);

break;

INTOUT();

STROUT(PRNAMEMAX);

break;

return;

trunc:

return;

trunc:

- printf(" [|pt]");

+ ND_PRINT((ndo, " [|pt]"));

}

/*

}

/*

*/

static void

*/

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;

{

struct rx_header *rxh;

unsigned long i;

- if (length < sizeof(struct rx_header))

+ if (length < (int)sizeof(struct rx_header))

return;

rxh = (struct rx_header *) bp;

return;

rxh = (struct rx_header *) bp;

* Ubik call, however.

*/

* 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;

}

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);

case 504: /* Name to ID */

{

unsigned long j;

case 504: /* Name to ID */

{

unsigned long j;

- printf(" ids:");

- TCHECK2(bp[0], 4);

+ 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)

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;

}

break;

case 505: /* ID to name */

{

unsigned long j;

- TCHECK2(bp[0], 4);

+ ND_TCHECK2(bp[0], 4);

j = EXTRACT_32BITS(bp);

bp += sizeof(int32_t);

j = EXTRACT_32BITS(bp);

bp += sizeof(int32_t);

VECOUT(PRNAMEMAX);

}

if (j == 0)

VECOUT(PRNAMEMAX);

}

if (j == 0)

- printf(" <none!>");

+ ND_PRINT((ndo, " <none!>"));

}

break;

case 508: /* Get CPS */

}

break;

case 508: /* Get CPS */

case 519: /* Get host CPS */

{

unsigned long j;

case 519: /* Get host CPS */

{

unsigned long j;

- TCHECK2(bp[0], 4);

+ ND_TCHECK2(bp[0], 4);

j = EXTRACT_32BITS(bp);

bp += sizeof(int32_t);

for (i = 0; i < j; i++) {

INTOUT();

}

if (j == 0)

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 */

}

break;

case 510: /* List max */

- printf(" maxuid");

+ ND_PRINT((ndo, " maxuid"));

INTOUT();

- printf(" maxgid");

+ ND_PRINT((ndo, " maxgid"));

INTOUT();

break;

default:

INTOUT();

break;

default:

/*

* Otherwise, just print out the return code

*/

/*

* Otherwise, just print out the return code

*/

- printf(" errcode");

+ ND_PRINT((ndo, " errcode"));

INTOUT();

}

return;

trunc:

INTOUT();

}

return;

trunc:

- printf(" [|pt]");

+ ND_PRINT((ndo, " [|pt]"));

}

/*

}

/*

*/

static void

*/

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;

{

int vldb_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;

}

goto trunc;

}

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;

}

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

/*

* Decode some of the arguments to the VLDB calls

case 508: /* Set lock */

case 509: /* Release lock */

case 518: /* Get entry by ID N */

case 508: /* Set lock */

case 509: /* Release lock */

case 518: /* Get entry by ID N */

- printf(" volid");

+ ND_PRINT((ndo, " volid"));

INTOUT();

- TCHECK2(bp[0], sizeof(int32_t));

+ ND_TCHECK2(bp[0], sizeof(int32_t));

i = EXTRACT_32BITS(bp);

bp += sizeof(int32_t);

if (i <= 2)

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 */

break;

case 504: /* Get entry by name */

case 519: /* Get entry by name N */

STROUT(VLNAMEMAX);

break;

case 505: /* Get new vol id */

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 */

INTOUT();

break;

case 506: /* Replace entry */

case 520: /* Replace entry N */

- printf(" volid");

+ ND_PRINT((ndo, " volid"));

INTOUT();

- TCHECK2(bp[0], sizeof(int32_t));

+ ND_TCHECK2(bp[0], sizeof(int32_t));

i = EXTRACT_32BITS(bp);

bp += sizeof(int32_t);

if (i <= 2)

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 */

VECOUT(VLNAMEMAX);

break;

case 510: /* List entry */

case 521: /* List entry N */

- printf(" index");

+ ND_PRINT((ndo, " index"));

INTOUT();

break;

default:

INTOUT();

break;

default:

return;

trunc:

return;

trunc:

- printf(" [|vldb]");

+ ND_PRINT((ndo, " [|vldb]"));

}

/*

}

/*

*/

static void

*/

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;

{

struct rx_header *rxh;

unsigned long i;

- if (length < sizeof(struct rx_header))

+ if (length < (int)sizeof(struct rx_header))

return;

rxh = (struct rx_header *) bp;

return;

rxh = (struct rx_header *) bp;

* Ubik call, however.

*/

* 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;

}

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);

if (rxh->type == RX_PACKET_TYPE_DATA)

switch (opcode) {

case 510: /* List entry */

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);

INTOUT();

case 503: /* Get entry by id */

case 504: /* Get entry by name */

{ unsigned long nservers, j;

VECOUT(VLNAMEMAX);

- TCHECK2(bp[0], sizeof(int32_t));

+ ND_TCHECK2(bp[0], sizeof(int32_t));

bp += sizeof(int32_t);

- printf(" numservers");

- TCHECK2(bp[0], sizeof(int32_t));

+ ND_PRINT((ndo, " numservers"));

+ ND_TCHECK2(bp[0], sizeof(int32_t));

nservers = EXTRACT_32BITS(bp);

bp += sizeof(int32_t);

nservers = EXTRACT_32BITS(bp);

bp += sizeof(int32_t);

- printf(" %lu", nservers);

- printf(" servers");

+ ND_PRINT((ndo, " %lu", nservers));

+ ND_PRINT((ndo, " servers"));

for (i = 0; i < 8; i++) {

- TCHECK2(bp[0], 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);

}

bp += sizeof(int32_t);

}

- printf(" partitions");

+ ND_PRINT((ndo, " partitions"));

for (i = 0; i < 8; i++) {

- TCHECK2(bp[0], sizeof(int32_t));

+ ND_TCHECK2(bp[0], sizeof(int32_t));

j = EXTRACT_32BITS(bp);

if (i < nservers && j <= 26)

j = EXTRACT_32BITS(bp);

if (i < nservers && j <= 26)

- printf(" %c", 'a' + (int)j);

+ ND_PRINT((ndo, " %c", 'a' + (int)j));

else if (i < nservers)

- printf(" %lu", j);

+ ND_PRINT((ndo, " %lu", j));

bp += sizeof(int32_t);

}

bp += sizeof(int32_t);

}

- TCHECK2(bp[0], 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 */

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 */

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);

INTOUT();

case 518: /* Get entry by ID N */

case 519: /* Get entry by name N */

{ unsigned long nservers, j;

VECOUT(VLNAMEMAX);

- printf(" numservers");

- TCHECK2(bp[0], sizeof(int32_t));

+ ND_PRINT((ndo, " numservers"));

+ ND_TCHECK2(bp[0], sizeof(int32_t));

nservers = EXTRACT_32BITS(bp);

bp += sizeof(int32_t);

nservers = EXTRACT_32BITS(bp);

bp += sizeof(int32_t);

- printf(" %lu", nservers);

- printf(" servers");

+ ND_PRINT((ndo, " %lu", nservers));

+ ND_PRINT((ndo, " servers"));

for (i = 0; i < 13; i++) {

- TCHECK2(bp[0], 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);

}

bp += sizeof(int32_t);

}

- printf(" partitions");

+ ND_PRINT((ndo, " partitions"));

for (i = 0; i < 13; i++) {

- TCHECK2(bp[0], sizeof(int32_t));

+ ND_TCHECK2(bp[0], sizeof(int32_t));

j = EXTRACT_32BITS(bp);

if (i < nservers && j <= 26)

j = EXTRACT_32BITS(bp);

if (i < nservers && j <= 26)

- printf(" %c", 'a' + (int)j);

+ ND_PRINT((ndo, " %c", 'a' + (int)j));

else if (i < nservers)

- printf(" %lu", j);

+ ND_PRINT((ndo, " %lu", j));

bp += sizeof(int32_t);

}

bp += sizeof(int32_t);

}

- TCHECK2(bp[0], 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;

UINTOUT();

}

break;

case 527: /* Get entry by name U */

{ unsigned long nservers, j;

VECOUT(VLNAMEMAX);

case 527: /* Get entry by name U */

{ unsigned long nservers, j;

VECOUT(VLNAMEMAX);

- printf(" numservers");

- TCHECK2(bp[0], sizeof(int32_t));

+ ND_PRINT((ndo, " numservers"));

+ ND_TCHECK2(bp[0], sizeof(int32_t));

nservers = EXTRACT_32BITS(bp);

bp += sizeof(int32_t);

nservers = EXTRACT_32BITS(bp);

bp += sizeof(int32_t);

- printf(" %lu", nservers);

- printf(" servers");

+ ND_PRINT((ndo, " %lu", nservers));

+ ND_PRINT((ndo, " servers"));

for (i = 0; i < 13; i++) {

if (i < nservers) {

for (i = 0; i < 13; i++) {

if (i < nservers) {

- printf(" afsuuid");

+ ND_PRINT((ndo, " afsuuid"));

AFSUUIDOUT();

} else {

AFSUUIDOUT();

} else {

- TCHECK2(bp[0], 44);

+ ND_TCHECK2(bp[0], 44);

bp += 44;

}

bp += 44;

}

- TCHECK2(bp[0], 4 * 13);

+ ND_TCHECK2(bp[0], 4 * 13);

bp += 4 * 13;

- printf(" partitions");

+ ND_PRINT((ndo, " partitions"));

for (i = 0; i < 13; i++) {

- TCHECK2(bp[0], sizeof(int32_t));

+ ND_TCHECK2(bp[0], sizeof(int32_t));

j = EXTRACT_32BITS(bp);

if (i < nservers && j <= 26)

j = EXTRACT_32BITS(bp);

if (i < nservers && j <= 26)

- printf(" %c", 'a' + (int)j);

+ ND_PRINT((ndo, " %c", 'a' + (int)j));

else if (i < nservers)

- printf(" %lu", j);

+ ND_PRINT((ndo, " %lu", j));

bp += sizeof(int32_t);

}

bp += sizeof(int32_t);

}

- TCHECK2(bp[0], 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:

;

}

UINTOUT();

}

default:

;

}

-

+

else {

/*

* Otherwise, just print out the return code

*/

else {

/*

* Otherwise, just print out the return code

*/

- printf(" errcode");

+ ND_PRINT((ndo, " errcode"));

INTOUT();

}

return;

trunc:

INTOUT();

}

return;

trunc:

- printf(" [|vldb]");

+ ND_PRINT((ndo, " [|vldb]"));

}

/*

}

/*

*/

static void

*/

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;

{

int kauth_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;

}

goto trunc;

}

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;

}

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

/*

* Decode some of the arguments to the KA calls

case 8: /* Get entry */

case 14: /* Unlock */

case 15: /* Lock status */

case 8: /* Get entry */

case 14: /* Unlock */

case 15: /* Lock status */

- printf(" principal");

+ ND_PRINT((ndo, " principal"));

STROUT(KANAMEMAX);

break;

STROUT(KANAMEMAX);

break;

case 23: /* GetTicket */

{

int i;

case 23: /* GetTicket */

{

int i;

- printf(" kvno");

+ ND_PRINT((ndo, " kvno"));

INTOUT();

- printf(" domain");

+ ND_PRINT((ndo, " domain"));

STROUT(KANAMEMAX);

- TCHECK2(bp[0], sizeof(int32_t));

+ ND_TCHECK2(bp[0], sizeof(int32_t));

i = (int) EXTRACT_32BITS(bp);

bp += sizeof(int32_t);

i = (int) EXTRACT_32BITS(bp);

bp += sizeof(int32_t);

- TCHECK2(bp[0], i);

+ ND_TCHECK2(bp[0], i);

bp += i;

- printf(" principal");

+ ND_PRINT((ndo, " principal"));

STROUT(KANAMEMAX);

break;

}

case 4: /* Set Password */

STROUT(KANAMEMAX);

break;

}

case 4: /* Set Password */

- printf(" principal");

+ ND_PRINT((ndo, " principal"));

STROUT(KANAMEMAX);

- printf(" kvno");

+ ND_PRINT((ndo, " kvno"));

INTOUT();

break;

case 12: /* Get password */

INTOUT();

break;

case 12: /* Get password */

- printf(" name");

+ ND_PRINT((ndo, " name"));

STROUT(KANAMEMAX);

break;

default:

STROUT(KANAMEMAX);

break;

default:

return;

trunc:

return;

trunc:

- printf(" [|kauth]");

+ ND_PRINT((ndo, " [|kauth]"));

}

/*

}

/*

*/

static void

*/

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)

{

struct rx_header *rxh;

{

struct rx_header *rxh;

- if (length <= sizeof(struct rx_header))

+ if (length <= (int)sizeof(struct rx_header))

return;

rxh = (struct rx_header *) bp;

return;

rxh = (struct rx_header *) bp;

* Print out the afs call we're invoking. The table used here was

* gleaned from kauth/kauth.rg

*/

* 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;

}

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);

/*

* Otherwise, just print out the return code

*/

/*

* Otherwise, just print out the return code

*/

- printf(" errcode");

+ ND_PRINT((ndo, " errcode"));

INTOUT();

}

return;

trunc:

INTOUT();

}

return;

trunc:

- printf(" [|kauth]");

+ ND_PRINT((ndo, " [|kauth]"));

}

/*

}

/*

*/

static void

*/

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;

{

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;

}

goto trunc;

}

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:

return;

trunc:

- printf(" [|vol]");

+ ND_PRINT((ndo, " [|vol]"));

}

/*

}

/*

*/

static void

*/

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)

{

struct rx_header *rxh;

{

struct rx_header *rxh;

- if (length <= sizeof(struct rx_header))

+ if (length <= (int)sizeof(struct rx_header))

return;

rxh = (struct rx_header *) bp;

return;

rxh = (struct rx_header *) bp;

* Print out the afs call we're invoking. The table used here was

* gleaned from volser/volint.xg

*/

* 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);

* If it was a data packet, interpret the response.

*/

* 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

*/

/*

* Otherwise, just print out the return code

*/

- printf(" errcode");

+ ND_PRINT((ndo, " errcode"));

INTOUT();

}

return;

trunc:

INTOUT();

}

return;

trunc:

- printf(" [|vol]");

+ ND_PRINT((ndo, " [|vol]"));

}

/*

}

/*

*/

static void

*/

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;

{

int bos_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;

}

goto trunc;

}

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

/*

* Decode some of the arguments to the BOS calls

switch (bos_op) {

case 80: /* Create B node */

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 */

STROUT(BOSNAMEMAX);

break;

case 81: /* Delete B node */

case 82: /* Set status */

case 98: /* Set T status */

STROUT(BOSNAMEMAX);

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);

INTOUT();

break;

case 86: /* Get instance parm */

STROUT(BOSNAMEMAX);

- printf(" num");

+ ND_PRINT((ndo, " num"));

INTOUT();

break;

case 84: /* Enumerate instance */

INTOUT();

break;

case 84: /* Enumerate instance */

break;

case 105: /* Install */

STROUT(BOSNAMEMAX);

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:

INTOUT();

break;

default:

return;

trunc:

return;

trunc:

- printf(" [|bos]");

+ ND_PRINT((ndo, " [|bos]"));

}

/*

}

/*

*/

static void

*/

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)

{

struct rx_header *rxh;

{

struct rx_header *rxh;

- if (length <= sizeof(struct rx_header))

+ if (length <= (int)sizeof(struct rx_header))

return;

rxh = (struct rx_header *) bp;

return;

rxh = (struct rx_header *) bp;

* Print out the afs call we're invoking. The table used here was

* gleaned from volser/volint.xg

*/

* 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);

/*

* Otherwise, just print out the return code

*/

/*

* Otherwise, just print out the return code

*/

- printf(" errcode");

+ ND_PRINT((ndo, " errcode"));

INTOUT();

}

return;

trunc:

INTOUT();

}

return;

trunc:

- printf(" [|bos]");

+ ND_PRINT((ndo, " [|bos]"));

}

/*

}

/*

*/

static int

*/

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))

{

if ((opcode >= VOTE_LOW && opcode <= VOTE_HIGH) ||

(opcode >= DISK_LOW && opcode <= DISK_HIGH))

*/

static void

*/

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;

{

int ubik_op;

int32_t temp;

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

/*

* Decode some of the arguments to the Ubik calls

switch (ubik_op) {

case 10000: /* Beacon */

switch (ubik_op) {

case 10000: /* Beacon */

- TCHECK2(bp[0], 4);

+ ND_TCHECK2(bp[0], 4);

temp = EXTRACT_32BITS(bp);

bp += sizeof(int32_t);

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 */

UBIK_VERSIONOUT();

break;

case 10003: /* Get sync site */

- printf(" site");

+ ND_PRINT((ndo, " site"));

UINTOUT();

break;

case 20000: /* Begin */

UINTOUT();

break;

case 20000: /* Begin */

case 20007: /* Abort */

case 20008: /* Release locks */

case 20010: /* Writev */

case 20007: /* Abort */

case 20008: /* Release locks */

case 20010: /* Writev */

- printf(" tid");

+ ND_PRINT((ndo, " tid"));

UBIK_VERSIONOUT();

break;

case 20002: /* Lock */

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 = EXTRACT_32BITS(bp);

bp += sizeof(int32_t);

tok2str(ubik_lock_types, "type %d", temp);

break;

case 20003: /* Write */

INTOUT();

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 */

INTOUT();

break;

case 20005: /* Get file */

- printf(" file");

+ ND_PRINT((ndo, " file"));

INTOUT();

break;

case 20006: /* Send 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 */

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 */

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:

UBIK_VERSIONOUT();

break;

default:

return;

trunc:

return;

trunc:

- printf(" [|ubik]");

+ ND_PRINT((ndo, " [|ubik]"));

}

/*

}

/*

*/

static void

*/

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;

{

struct rx_header *rxh;

- if (length < sizeof(struct rx_header))

+ if (length < (int)sizeof(struct rx_header))

return;

rxh = (struct rx_header *) bp;

return;

rxh = (struct rx_header *) bp;

* from ubik/ubik_int.xg

*/

* 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

*/

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 */

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 */

break;

case 20004: /* Get version */

- printf(" dbversion");

+ ND_PRINT((ndo, " dbversion"));

UBIK_VERSIONOUT();

break;

default:

;

}

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

/*

* Otherwise, print out "yes" it it was a beacon packet (because

* that's how yes votes are returned, go figure), otherwise

else

switch (opcode) {

case 10000: /* Beacon */

else

switch (opcode) {

case 10000: /* Beacon */

- printf(" vote yes until");

+ ND_PRINT((ndo, " vote yes until"));

DATEOUT();

break;

default:

DATEOUT();

break;

default:

- printf(" errcode");

+ ND_PRINT((ndo, " errcode"));

INTOUT();

}

return;

trunc:

INTOUT();

}

return;

trunc:

- printf(" [|ubik]");

+ ND_PRINT((ndo, " [|ubik]"));

}

/*

}

/*

*/

static void

*/

static void

-rx_ack_print(register const u_char *bp, int length)

+rx_ack_print(netdissect_options *ndo,

+ register const u_char *bp, int length)

{

struct rx_ackPacket *rxa;

int i, start, last;

{

struct rx_ackPacket *rxa;

int i, start, last;

+ uint32_t firstPacket;

- if (length < sizeof(struct rx_header))

+ if (length < (int)sizeof(struct rx_header))

return;

bp += sizeof(struct rx_header);

return;

bp += sizeof(struct rx_header);

* rx_ackPacket structure.

*/

* rx_ackPacket structure.

*/

- TCHECK2(bp[0], sizeof(struct rx_ackPacket) - RX_MAXACKS);

+ ND_TCHECK2(bp[0], sizeof(struct rx_ackPacket) - RX_MAXACKS);

rxa = (struct rx_ackPacket *) bp;

bp += (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

*/

* Print out a few useful things from the ack packet structure

*/

- if (vflag > 2)

- printf(" bufspace %d maxskew %d",

+ if (ndo->ndo_vflag > 2)

+ ND_PRINT((ndo, " bufspace %d maxskew %d",

(int) EXTRACT_16BITS(&rxa->bufferSpace),

- (int) EXTRACT_16BITS(&rxa->maxSkew));

-

- printf(" first %d serial %d reason %s",

- EXTRACT_32BITS(&rxa->firstPacket), EXTRACT_32BITS(&rxa->serial),

- tok2str(rx_ack_reasons, "#%d", (int) rxa->reason));

-

+ (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.

/*

* Okay, now we print out the ack array. The way _this_ works

* is that we start at "first", and step through the ack array.

* 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

* 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

+ * 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

* 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

if (rxa->nAcks != 0) {

- TCHECK2(bp[0], rxa->nAcks);

+ ND_TCHECK2(bp[0], rxa->nAcks);

/*

* Sigh, this is gross, but it seems to work to collapse

/*

* Sigh, this is gross, but it seems to work to collapse

*/

if (last == -2) {

*/

if (last == -2) {

- printf(" acked %d",

- rxa->firstPacket + i);

+ ND_PRINT((ndo, " acked %d", firstPacket + i));

start = i;

}

/*

start = i;

}

/*

- * Otherwise, if the there is a skip in

+ * 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

* the range (such as an nacked packet in

* the middle of some acked packets),

* then print the current packet number

*/

else if (last != i - 1) {

*/

else if (last != i - 1) {

- printf(",%d", rxa->firstPacket + i);

+ ND_PRINT((ndo, ",%d", firstPacket + i));

start = i;

}

start = i;

}

* range.

*/

} else if (last == i - 1 && start != last)

* range.

*/

} else if (last == i - 1 && start != last)

- printf("-%d", rxa->firstPacket + i - 1);

-

+ 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, 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.

*/

if (last == i - 1 && start != last)

*/

if (last == i - 1 && start != last)

- printf("-%d", rxa->firstPacket + i - 1);

+ ND_PRINT((ndo, "-%d", firstPacket + i - 1));

/*

* Same as above, just without comments

*/

/*

* 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) {

for (i = 0, start = last = -2; i < rxa->nAcks; i++)

if (rxa->acks[i] == RX_ACK_TYPE_NACK) {

if (last == -2) {

- printf(" nacked %d",

- rxa->firstPacket + i);

+ ND_PRINT((ndo, " nacked %d", firstPacket + i));

start = i;

} else if (last != i - 1) {

start = i;

} else if (last != i - 1) {

- printf(",%d", rxa->firstPacket + i);

+ ND_PRINT((ndo, ",%d", firstPacket + i));

start = i;

}

last = i;

} else if (last == i - 1 && start != last)

start = i;

}

last = i;

} else if (last == i - 1 && start != last)

- printf("-%d", rxa->firstPacket + i - 1);

-

+ ND_PRINT((ndo, "-%d", firstPacket + i - 1));

+

if (last == i - 1 && start != last)

- printf("-%d", rxa->firstPacket + i - 1);

+ ND_PRINT((ndo, "-%d", firstPacket + i - 1));

bp += rxa->nAcks;

}

bp += rxa->nAcks;

}

* you may or may not see them

*/

* you may or may not see them

*/

-#define TRUNCRET(n) if (snapend - bp + 1 <= n) return;

+#define TRUNCRET(n) if (ndo->ndo_snapend - bp + 1 <= n) return;

- if (vflag > 1) {

+ if (ndo->ndo_vflag > 1) {

TRUNCRET(4);

- printf(" ifmtu");

+ ND_PRINT((ndo, " ifmtu"));

INTOUT();

TRUNCRET(4);

INTOUT();

TRUNCRET(4);

- printf(" maxmtu");

+ ND_PRINT((ndo, " maxmtu"));

INTOUT();

TRUNCRET(4);

INTOUT();

TRUNCRET(4);

- printf(" rwind");

+ ND_PRINT((ndo, " rwind"));

INTOUT();

TRUNCRET(4);

INTOUT();

TRUNCRET(4);

- printf(" maxpackets");

+ ND_PRINT((ndo, " maxpackets"));

INTOUT();

}

return;

trunc:

INTOUT();

}

return;

trunc:

- printf(" [|ack]");

+ ND_PRINT((ndo, " [|ack]"));

}

#undef TRUNCRET

}

#undef TRUNCRET