* Portions based on information/specs retrieved from the OpenAFS sources at
* www.openafs.org, Copyright IBM.
*
- * $Id: packet-afs.c,v 1.22 2000/11/03 22:11:36 nneul Exp $
+ * $Id: packet-afs.c,v 1.43 2002/02/08 22:36:21 nneul Exp $
*
* Ethereal - Network traffic analyzer
- * By Gerald Combs <gerald@zing.org>
+ * By Gerald Combs <gerald@ethereal.com>
* Copyright 1998 Gerald Combs
*
* Copied from packet-tftp.c
#include <string.h>
#include <glib.h>
-#include "packet.h"
-#include "conversation.h"
-#include "resolv.h"
+#include <epan/packet.h>
+#include <epan/conversation.h>
+#include <epan/resolv.h>
#include "packet-rx.h"
#include "packet-afs.h"
#include "packet-afs-defs.h"
#include "packet-afs-macros.h"
+#define GETSTR tvb_get_ptr(tvb,offset,tvb_ensure_length_remaining(tvb,offset))
+
+#define VALID_OPCODE(opcode) ((opcode >= OPCODE_LOW && opcode <= OPCODE_HIGH) || \
+ (opcode >= VOTE_LOW && opcode <= VOTE_HIGH) || \
+ (opcode >= DISK_LOW && opcode <= DISK_HIGH))
int afs_packet_init_count = 100;
/*
* Dissector prototypes
*/
-static void dissect_fs_request(const u_char *pd,
- int offset, frame_data *fd, proto_tree *tree, int opcode);
-static void dissect_fs_reply(const u_char *pd,
- int offset, frame_data *fd, proto_tree *tree, int opcode);
-static void dissect_cb_request(const u_char *pd,
- int offset, frame_data *fd, proto_tree *tree, int opcode);
-static void dissect_cb_reply(const u_char *pd,
- int offset, frame_data *fd, proto_tree *tree, int opcode);
-static void dissect_bos_request(const u_char *pd,
- int offset, frame_data *fd, proto_tree *tree, int opcode);
-static void dissect_bos_reply(const u_char *pd,
- int offset, frame_data *fd, proto_tree *tree, int opcode);
-static void dissect_vol_request(const u_char *pd,
- int offset, frame_data *fd, proto_tree *tree, int opcode);
-static void dissect_vol_reply(const u_char *pd,
- int offset, frame_data *fd, proto_tree *tree, int opcode);
-static void dissect_ubik_request(const u_char *pd,
- int offset, frame_data *fd, proto_tree *tree, int opcode);
-static void dissect_ubik_reply(const u_char *pd,
- int offset, frame_data *fd, proto_tree *tree, int opcode);
-static void dissect_kauth_request(const u_char *pd,
- int offset, frame_data *fd, proto_tree *tree, int opcode);
-static void dissect_kauth_reply(const u_char *pd,
- int offset, frame_data *fd, proto_tree *tree, int opcode);
-static void dissect_prot_request(const u_char *pd,
- int offset, frame_data *fd, proto_tree *tree, int opcode);
-static void dissect_prot_reply(const u_char *pd,
- int offset, frame_data *fd, proto_tree *tree, int opcode);
-static void dissect_vldb_request(const u_char *pd,
- int offset, frame_data *fd, proto_tree *tree, int opcode);
-static void dissect_vldb_reply(const u_char *pd,
- int offset, frame_data *fd, proto_tree *tree, int opcode);
-static void dissect_backup_request(const u_char *pd,
- int offset, frame_data *fd, proto_tree *tree, int opcode);
-static void dissect_backup_reply(const u_char *pd,
- int offset, frame_data *fd, proto_tree *tree, int opcode);
-
+static int dissect_acl(tvbuff_t *tvb, struct rxinfo *rxinfo,
+ proto_tree *tree, int offset);
+static void dissect_fs_reply(tvbuff_t *tvb, struct rxinfo *rxinfo,
+ proto_tree *tree, int offset, int opcode);
+static void dissect_fs_request(tvbuff_t *tvb, struct rxinfo *rxinfo,
+ proto_tree *tree, int offset, int opcode);
+static void dissect_bos_reply(tvbuff_t *tvb, struct rxinfo *rxinfo,
+ proto_tree *tree, int offset, int opcode);
+static void dissect_bos_request(tvbuff_t *tvb, struct rxinfo *rxinfo,
+ proto_tree *tree, int offset, int opcode);
+static void dissect_vol_reply(tvbuff_t *tvb, struct rxinfo *rxinfo,
+ proto_tree *tree, int offset, int opcode);
+static void dissect_vol_request(tvbuff_t *tvb, struct rxinfo *rxinfo,
+ proto_tree *tree, int offset, int opcode);
+static void dissect_kauth_reply(tvbuff_t *tvb, struct rxinfo *rxinfo,
+ proto_tree *tree, int offset, int opcode);
+static void dissect_kauth_request(tvbuff_t *tvb, struct rxinfo *rxinfo,
+ proto_tree *tree, int offset, int opcode);
+static void dissect_cb_reply(tvbuff_t *tvb, struct rxinfo *rxinfo,
+ proto_tree *tree, int offset, int opcode);
+static void dissect_cb_request(tvbuff_t *tvb, struct rxinfo *rxinfo,
+ proto_tree *tree, int offset, int opcode);
+static void dissect_prot_reply(tvbuff_t *tvb, struct rxinfo *rxinfo,
+ proto_tree *tree, int offset, int opcode);
+static void dissect_prot_request(tvbuff_t *tvb, struct rxinfo *rxinfo,
+ proto_tree *tree, int offset, int opcode);
+static void dissect_vldb_reply(tvbuff_t *tvb, struct rxinfo *rxinfo,
+ proto_tree *tree, int offset, int opcode);
+static void dissect_vldb_request(tvbuff_t *tvb, struct rxinfo *rxinfo,
+ proto_tree *tree, int offset, int opcode);
+static void dissect_ubik_reply(tvbuff_t *tvb, struct rxinfo *rxinfo,
+ proto_tree *tree, int offset, int opcode);
+static void dissect_ubik_request(tvbuff_t *tvb, struct rxinfo *rxinfo,
+ proto_tree *tree, int offset, int opcode);
+static void dissect_backup_reply(tvbuff_t *tvb, struct rxinfo *rxinfo,
+ proto_tree *tree, int offset, int opcode);
+static void dissect_backup_request(tvbuff_t *tvb, struct rxinfo *rxinfo,
+ proto_tree *tree, int offset, int opcode);
/*
* Hash Functions
* Dissection routines
*/
-void
-dissect_afs(const u_char *pd, int offset, frame_data *fd, proto_tree *tree)
+static void
+dissect_afs(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
- proto_tree *afs_tree, *afs_op_tree, *ti;
- struct rx_header *rxh;
- struct afs_header *afsh;
- int port, node, typenode, opcode;
- value_string const *vals;
+ struct rxinfo *rxinfo = pinfo->private_data;
int reply = 0;
- int doffset = 0;
conversation_t *conversation;
struct afs_request_key request_key, *new_request_key;
struct afs_request_val *request_val;
- void (*dissector)(const u_char *pd, int offset,
- frame_data *fd, proto_tree *tree, int opcode);
-
- OLD_CHECK_DISPLAY_AS_DATA(proto_afs, pd, offset, fd, tree);
-
- /* get at least a full packet structure */
- if ( !BYTES_ARE_IN_FRAME(offset, sizeof(struct rx_header)) )
- return;
+ proto_tree *afs_tree, *afs_op_tree, *ti;
+ int port, node, typenode, opcode;
+ value_string const *vals;
+ int offset = 0;
+ void (*dissector)(tvbuff_t *tvb, struct rxinfo *rxinfo, proto_tree *tree, int offset, int opcode);
- if (check_col(fd, COL_PROTOCOL))
- col_add_str(fd, COL_PROTOCOL, "AFS (RX)");
- rxh = (struct rx_header *) &pd[offset];
- doffset = offset + sizeof(struct rx_header);
- afsh = (struct afs_header *) &pd[doffset];
+ if (check_col(pinfo->cinfo, COL_PROTOCOL)) {
+ col_set_str(pinfo->cinfo, COL_PROTOCOL, "AFS (RX)");
+ }
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_clear(pinfo->cinfo, COL_INFO);
+ }
- reply = (rxh->flags & RX_CLIENT_INITIATED) == 0;
- port = ((reply == 0) ? pi.destport : pi.srcport );
+ reply = (rxinfo->flags & RX_CLIENT_INITIATED) == 0;
+ port = ((reply == 0) ? pinfo->destport : pinfo->srcport );
/*
* Find out what conversation this packet is part of.
* packets from A:X to B:Y as being part of the same conversation as
* packets from B:Y to A:X.
*/
- conversation = find_conversation(&pi.src, &pi.dst, pi.ptype,
- pi.srcport, pi.destport, 0);
+ conversation = find_conversation(&pinfo->src, &pinfo->dst, pinfo->ptype,
+ pinfo->srcport, pinfo->destport, 0);
if (conversation == NULL) {
/* It's not part of any conversation - create a new one. */
- conversation = conversation_new(&pi.src, &pi.dst, pi.ptype,
- pi.srcport, pi.destport, NULL, 0);
+ conversation = conversation_new(&pinfo->src, &pinfo->dst,
+ pinfo->ptype, pinfo->srcport, pinfo->destport, 0);
}
request_key.conversation = conversation->index;
- request_key.service = pntohs(&rxh->serviceId);
- request_key.callnumber = pntohl(&rxh->callNumber);
+ request_key.service = rxinfo->serviceid;
+ request_key.callnumber = rxinfo->callnumber;
request_val = (struct afs_request_val *) g_hash_table_lookup(
afs_request_hash, &request_key);
/* only allocate a new hash element when it's a request */
opcode = 0;
- if ( !request_val && !reply)
- {
+ if ( !request_val && !reply) {
new_request_key = g_mem_chunk_alloc(afs_request_keys);
*new_request_key = request_key;
request_val = g_mem_chunk_alloc(afs_request_vals);
- request_val -> opcode = pntohl(&afsh->opcode);
+ request_val -> opcode = tvb_get_ntohl(tvb, offset);
g_hash_table_insert(afs_request_hash, new_request_key,
request_val);
}
- if ( request_val )
- {
+ if ( request_val ) {
opcode = request_val->opcode;
}
-
-
node = 0;
typenode = 0;
vals = NULL;
dissector = NULL;
- switch (port)
- {
+ switch (port) {
case AFS_PORT_FS:
typenode = hf_afs_fs;
node = hf_afs_fs_opcode;
dissector = reply ? dissect_backup_reply : dissect_backup_request;
break;
}
+
if ( (opcode >= VOTE_LOW && opcode <= VOTE_HIGH) ||
- (opcode >= DISK_LOW && opcode <= DISK_HIGH) )
- {
+ (opcode >= DISK_LOW && opcode <= DISK_HIGH) ) {
typenode = hf_afs_ubik;
node = hf_afs_ubik_opcode;
vals = ubik_req;
dissector = reply ? dissect_ubik_reply : dissect_ubik_request;
}
- if ( vals )
- {
- if (check_col(fd, COL_INFO))
- col_add_fstr(fd, COL_INFO, "%s %s: %s (%d)",
- val_to_str(port, port_types_short, "Unknown(%d)"),
- reply ? "Reply" : "Request",
- val_to_str(opcode, vals, "Unknown(%d)"), opcode);
- }
- else
- {
- if (check_col(fd, COL_INFO))
- col_add_fstr(fd, COL_INFO, "%s %s: Unknown(%d)",
+
+ if ( VALID_OPCODE(opcode) ) {
+ if ( vals ) {
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_add_fstr(pinfo->cinfo, COL_INFO, "%s%s %s: %s (%d)",
+ typenode == hf_afs_ubik ? "UBIK-" : "",
+ val_to_str(port, port_types_short, "Unknown(%d)"),
+ reply ? "Reply" : "Request",
+ val_to_str(opcode, vals, "Unknown(%d)"), opcode);
+ } else {
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_add_fstr(pinfo->cinfo, COL_INFO, "%s%s %s: Unknown(%d)",
+ typenode == hf_afs_ubik ? "UBIK-" : "",
+ val_to_str(port, port_types_short, "Unknown(%d)"),
+ reply ? "Reply" : "Request",
+ opcode);
+ }
+ } else {
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_add_fstr(pinfo->cinfo, COL_INFO, "Encrypted %s %s",
val_to_str(port, port_types_short, "Unknown(%d)"),
- reply ? "Reply" : "Request",
- opcode);
+ reply ? "Reply" : "Request"
+ );
}
if (tree) {
- ti = proto_tree_add_item(tree, proto_afs, NullTVB, doffset, END_OF_FRAME, FALSE);
+ ti = proto_tree_add_item(tree, proto_afs, tvb, offset, -1,
+ FALSE);
afs_tree = proto_item_add_subtree(ti, ett_afs);
- if ( !BYTES_ARE_IN_FRAME(offset, sizeof(struct rx_header) +
- sizeof(struct afs_header)) )
- {
- proto_tree_add_text(afs_tree, NullTVB, doffset, END_OF_FRAME,
- "Service: %s %s (Truncated)",
- val_to_str(port, port_types, "Unknown(%d)"),
- reply ? "Reply" : "Request");
- return;
- }
- else
- {
- proto_tree_add_text(afs_tree, NullTVB, doffset, END_OF_FRAME,
- "Service: %s %s",
- val_to_str(port, port_types, "Unknown(%d)"),
- reply ? "Reply" : "Request");
- }
-
- /* until we do cache, can't handle replies */
- ti = NULL;
- if ( !reply && node != 0 )
- {
- ti = proto_tree_add_uint(afs_tree,
- node, NullTVB, doffset, 4, opcode);
- }
- else if ( reply && node != 0 )
- {
- /* the opcode isn't in this packet */
- ti = proto_tree_add_uint(afs_tree,
- node, NullTVB, doffset, 0, opcode);
- }
- else
- {
- ti = proto_tree_add_text(afs_tree, NullTVB,
- doffset, 0, "Operation: Unknown");
- }
-
- /* Add the subtree for this particular service */
- afs_op_tree = proto_item_add_subtree(ti, ett_afs_op);
-
- if ( typenode != 0 )
- {
- /* indicate the type of request */
- proto_tree_add_boolean_hidden(afs_tree, typenode, NullTVB, doffset, 0, 1);
- }
-
- /* Process the packet according to what service it is */
- if ( dissector )
- {
- (*dissector)(pd,offset,fd,afs_op_tree,opcode);
+ proto_tree_add_text(afs_tree, tvb,
+ offset, -1,
+ "Service: %s%s%s %s",
+ VALID_OPCODE(opcode) ? "" : "Encrypted ",
+ typenode == hf_afs_ubik ? "UBIK - " : "",
+ val_to_str(port, port_types, "Unknown(%d)"),
+ reply ? "Reply" : "Request");
+
+ if ( VALID_OPCODE(opcode) ) {
+ /* until we do cache, can't handle replies */
+ ti = NULL;
+ if ( !reply && node != 0 ) {
+ if ( rxinfo->seq == 1 )
+ {
+ ti = proto_tree_add_uint(afs_tree,
+ node, tvb, offset, 4, opcode);
+ } else {
+ ti = proto_tree_add_uint(afs_tree,
+ node, tvb, offset, 0, opcode);
+ }
+ } else if ( reply && node != 0 ) {
+ /* the opcode isn't in this packet */
+ ti = proto_tree_add_uint(afs_tree,
+ node, tvb, offset, 0, opcode);
+ } else {
+ ti = proto_tree_add_text(afs_tree, tvb,
+ offset, 0, "Operation: Unknown");
+ }
+
+ /* Add the subtree for this particular service */
+ afs_op_tree = proto_item_add_subtree(ti, ett_afs_op);
+
+ if ( typenode != 0 ) {
+ /* indicate the type of request */
+ proto_tree_add_boolean_hidden(afs_tree, typenode, tvb, offset, 0, 1);
+ }
+
+ /* Process the packet according to what service it is */
+ if ( dissector ) {
+ (*dissector)(tvb, rxinfo, afs_op_tree, offset, opcode);
+ }
}
}
/* if it's the last packet, and it's a reply, remove opcode
from hash */
/* ignoring for now, I'm not sure how the chunk deallocation works */
- if ( rxh->flags & RX_LAST_PACKET && reply )
- {
+ if ( rxinfo->flags & RX_LAST_PACKET && reply ){
}
}
* ASCII strings containing the UID/PTS record and and a ascii number
* representing a logical OR of all the ACL permission bits
*/
-
-static void dissect_acl(const u_char *pd, int offset, frame_data *fd, proto_tree *tree)
+/* FIXME: sscanf is probably quite dangerous if we run outside the packet. */
+static int
+dissect_acl(tvbuff_t *tvb, struct rxinfo *rxinfo, proto_tree *tree, int offset)
{
- int pos, neg, acl;
- int n, i, bytes;
- u_char const *s;
- u_char const *end;
- char user[128];
- int curoffset;
- int soff,eoff;
-
- curoffset = offset;
-
- TRUNC(sizeof(guint32));
- bytes = pntohl(&pd[curoffset]);
- OUT_UINT(hf_afs_fs_acl_datasize);
-
- TRUNC(bytes);
+ int old_offset;
+ gint32 bytes;
+ int i, n, pos, neg, acl;
+ char user[128]; /* Be sure to adjust sscanf()s below if length is changed... */
- soff = curoffset;
- eoff = curoffset+bytes;
+ old_offset = offset;
+ bytes = tvb_get_ntohl(tvb, offset);
+ OUT_UINT(hf_afs_fs_acl_datasize);
- s = &pd[soff];
- end = &pd[eoff];
- if (sscanf((char *) s, "%d %n", &pos, &n) != 1)
- return;
- s += n;
- TRUNC(1);
- proto_tree_add_uint(tree, hf_afs_fs_acl_count_positive, NullTVB, curoffset, n, pos);
- curoffset += n;
+ if (sscanf((char *) GETSTR, "%d %n", &pos, &n) != 1) {
+ /* does not matter what we return, if this fails,
+ * we cant dissect anything else in the packet either.
+ */
+ return offset;
+ }
+ proto_tree_add_uint(tree, hf_afs_fs_acl_count_positive, tvb,
+ offset, n, pos);
+ offset += n;
- if (sscanf((char *) s, "%d %n", &neg, &n) != 1)
- return;
- s += n;
- TRUNC(1);
- proto_tree_add_uint(tree, hf_afs_fs_acl_count_negative, NullTVB, curoffset, n, neg);
- curoffset += n;
+ if (sscanf((char *) GETSTR, "%d %n", &neg, &n) != 1) {
+ return offset;
+ }
+ proto_tree_add_uint(tree, hf_afs_fs_acl_count_negative, tvb,
+ offset, n, neg);
+ offset += n;
/*
* This wacky order preserves the order used by the "fs" command
*/
-
for (i = 0; i < pos; i++) {
- if (sscanf((char *) s, "%s %d %n", user, &acl, &n) != 2)
- return;
- s += n;
+ if (sscanf((char *) GETSTR,
+ "%127s %d %n", user, &acl, &n) != 2) {
+ return offset;
+ }
ACLOUT(user,1,acl,n);
- curoffset += n;
- TRUNC(1);
+ offset += n;
}
-
for (i = 0; i < neg; i++) {
- if (sscanf((char *) s, "%s %d %n", user, &acl, &n) != 2)
- return;
- s += n;
+ if (sscanf((char *) GETSTR,
+ "%127s %d %n", user, &acl, &n) != 2) {
+ return offset;
+ }
ACLOUT(user,0,acl,n);
- curoffset += n;
- if (s > end)
- return;
+ offset += n;
+ if (offset >= old_offset+bytes ) {
+ return offset;
+ }
}
+
+ return offset;
}
/*
*/
static void
-dissect_fs_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+dissect_fs_reply(tvbuff_t *tvb, struct rxinfo *rxinfo, proto_tree *tree, int offset, int opcode)
{
- struct rx_header *rxh;
- unsigned char *data;
- int doffset, curoffset;
- int seq;
-
- rxh = (struct rx_header *) &pd[offset];
- data = (char *)rxh + sizeof(struct rx_header);
- doffset = offset + sizeof(struct rx_header);
- curoffset = doffset;
-
- seq = pntohl(&rxh->seq);
-
- if ( rxh->type == RX_PACKET_TYPE_DATA )
+ if ( rxinfo->type == RX_PACKET_TYPE_DATA )
{
switch ( opcode )
{
case 130: /* fetch data */
- if ( seq == 1 ) /* only on first packet */
+ /* only on first packet */
+ if ( rxinfo->seq == 1 )
{
OUT_FS_AFSFetchStatus("Status");
OUT_FS_AFSCallBack();
OUT_BYTES_ALL(hf_afs_fs_data);
break;
case 131: /* fetch acl */
- dissect_acl(pd,curoffset,fd,tree);
+ offset = dissect_acl(tvb, rxinfo, tree, offset);
OUT_FS_AFSFetchStatus("Status");
OUT_FS_AFSVolSync();
break;
OUT_FS_AFSVolSync();
break;
case 133: /* Store data */
- OUT_FS_AFSFetchStatus("Status");
- OUT_FS_AFSVolSync();
- break;
case 134: /* Store ACL */
- OUT_FS_AFSFetchStatus("Status");
- OUT_FS_AFSVolSync();
- break;
case 135: /* Store status */
- OUT_FS_AFSFetchStatus("Status");
- OUT_FS_AFSVolSync();
- break;
case 136: /* Remove file */
OUT_FS_AFSFetchStatus("Status");
OUT_FS_AFSVolSync();
break;
case 137: /* create file */
- OUT_FS_AFSFid("New File");
+ case 141: /* make dir */
+ case 161: /* lookup */
+ case 163: /* dfs symlink */
+ OUT_FS_AFSFid((opcode == 137)? "New File" : ((opcode == 141)? "New Directory" : "File"));
OUT_FS_AFSFetchStatus("File Status");
OUT_FS_AFSFetchStatus("Directory Status");
OUT_FS_AFSCallBack();
break;
case 139: /* symlink */
OUT_FS_AFSFid("Symlink");
- OUT_FS_AFSFetchStatus("Symlink Status");
- OUT_FS_AFSFetchStatus("Directory Status");
- OUT_FS_AFSVolSync();
- break;
case 140: /* link */
OUT_FS_AFSFetchStatus("Symlink Status");
- OUT_FS_AFSFetchStatus("Directory Status");
- OUT_FS_AFSVolSync();
- break;
- case 141: /* make dir */
- OUT_FS_AFSFid("New Directory");
- OUT_FS_AFSFetchStatus("File Status");
- OUT_FS_AFSFetchStatus("Directory Status");
- OUT_FS_AFSCallBack();
- OUT_FS_AFSVolSync();
- break;
case 142: /* rmdir */
OUT_FS_AFSFetchStatus("Directory Status");
OUT_FS_AFSVolSync();
break;
case 143: /* old set lock */
- /* nothing returned */
- break;
case 144: /* old extend lock */
- /* nothing returned */
- break;
case 145: /* old release lock */
+ case 147: /* give up callbacks */
+ case 150: /* set volume status */
+ case 152: /* check token */
/* nothing returned */
break;
case 146: /* get statistics */
OUT_FS_ViceStatistics();
break;
- case 147: /* give up callbacks */
- /* nothing returned */
- break;
case 148: /* get volume info */
+ case 154: /* n-get-volume-info */
OUT_FS_VolumeInfo();
break;
case 149: /* get volume status */
OUT_FS_AFSFetchVolumeStatus();
- OUT_STRING(hf_afs_fs_volname);
- OUT_STRING(hf_afs_fs_offlinemsg);
- OUT_STRING(hf_afs_fs_motd);
- break;
- case 150: /* set volume status */
- /* nothing returned */
+ OUT_RXString(hf_afs_fs_volname);
+ OUT_RXString(hf_afs_fs_offlinemsg);
+ OUT_RXString(hf_afs_fs_motd);
break;
case 151: /* root volume */
- OUT_STRING(hf_afs_fs_volname);
- break;
- case 152: /* check token */
- /* nothing returned */
+ OUT_RXString(hf_afs_fs_volname);
break;
case 153: /* get time */
OUT_TIMESTAMP(hf_afs_fs_timestamp);
break;
- case 154: /* n-get-volume-info */
- OUT_FS_VolumeInfo();
- break;
case 155: /* bulk status */
OUT_FS_AFSBulkStats();
+ SKIP(4);
OUT_FS_AFSCBs();
OUT_FS_AFSVolSync();
break;
case 156: /* set lock */
- OUT_FS_AFSVolSync();
- break;
case 157: /* extend lock */
- OUT_FS_AFSVolSync();
- break;
case 158: /* release lock */
OUT_FS_AFSVolSync();
break;
OUT_DATE(hf_afs_fs_xstats_timestamp);
OUT_FS_AFS_CollData();
break;
- case 161: /* lookup */
- OUT_FS_AFSFid("File");
- OUT_FS_AFSFetchStatus("File Status");
- OUT_FS_AFSFetchStatus("Directory Status");
- OUT_FS_AFSCallBack();
- OUT_FS_AFSVolSync();
- break;
case 162: /* flush cps */
OUT_UINT(hf_afs_fs_cps_spare2);
OUT_UINT(hf_afs_fs_cps_spare3);
break;
- case 163: /* dfs symlink */
- OUT_FS_AFSFid("File");
- OUT_FS_AFSFetchStatus("File Status");
- OUT_FS_AFSFetchStatus("Directory Status");
- OUT_FS_AFSCallBack();
- OUT_FS_AFSVolSync();
- break;
}
}
- else if ( rxh->type == RX_PACKET_TYPE_ABORT )
+ else if ( rxinfo->type == RX_PACKET_TYPE_ABORT )
{
OUT_UINT(hf_afs_fs_errcode);
}
}
static void
-dissect_fs_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+dissect_fs_request(tvbuff_t *tvb, struct rxinfo *rxinfo, proto_tree *tree, int offset, int opcode)
{
- struct rx_header *rxh;
- unsigned char *data;
- int doffset, curoffset;
-
- rxh = (struct rx_header *) &pd[offset];
- data = (char *)rxh + sizeof(struct rx_header);
- doffset = offset + sizeof(struct rx_header);
- curoffset = doffset;
-
- SKIP_OPCODE();
+ /* skip the opcode if this is the first packet in the stream */
+ if ( rxinfo->seq == 1 )
+ {
+ offset += 4; /* skip the opcode */
+ }
switch ( opcode )
{
OUT_FS_AFSFid("Target");
break;
case 133: /* Store Data */
- OUT_FS_AFSFid("Destination");
- OUT_FS_AFSStoreStatus("Status");
- OUT_UINT(hf_afs_fs_offset);
- OUT_UINT(hf_afs_fs_length);
- OUT_UINT(hf_afs_fs_flength);
+ if ( rxinfo->seq == 1 )
+ {
+ OUT_FS_AFSFid("Destination");
+ OUT_FS_AFSStoreStatus("Status");
+ OUT_UINT(hf_afs_fs_offset);
+ OUT_UINT(hf_afs_fs_length);
+ OUT_UINT(hf_afs_fs_flength);
+ }
+ OUT_BYTES_ALL(hf_afs_fs_data);
break;
case 134: /* Store ACL */
OUT_FS_AFSFid("Target");
- dissect_acl(pd,curoffset,fd,tree);
+ offset = dissect_acl(tvb, rxinfo, tree, offset);
break;
case 135: /* Store Status */
OUT_FS_AFSFid("Target");
break;
case 136: /* Remove File */
OUT_FS_AFSFid("Remove File");
- OUT_STRING(hf_afs_fs_name);
+ OUT_RXString(hf_afs_fs_name);
break;
case 137: /* Create File */
OUT_FS_AFSFid("Target");
- OUT_STRING(hf_afs_fs_name);
+ OUT_RXString(hf_afs_fs_name);
OUT_FS_AFSStoreStatus("Status");
break;
case 138: /* Rename file */
OUT_FS_AFSFid("Old");
- OUT_STRING(hf_afs_fs_oldname);
+ OUT_RXString(hf_afs_fs_oldname);
OUT_FS_AFSFid("New");
- OUT_STRING(hf_afs_fs_newname);
+ OUT_RXString(hf_afs_fs_newname);
break;
case 139: /* Symlink */
OUT_FS_AFSFid("File");
- OUT_STRING(hf_afs_fs_symlink_name);
- OUT_STRING(hf_afs_fs_symlink_content);
+ OUT_RXString(hf_afs_fs_symlink_name);
+ OUT_RXString(hf_afs_fs_symlink_content);
OUT_FS_AFSStoreStatus("Status");
break;
case 140: /* Link */
OUT_FS_AFSFid("Link To (New File)");
- OUT_STRING(hf_afs_fs_name);
+ OUT_RXString(hf_afs_fs_name);
OUT_FS_AFSFid("Link From (Old File)");
break;
case 141: /* Make dir */
OUT_FS_AFSFid("Target");
- OUT_STRING(hf_afs_fs_name);
+ OUT_RXString(hf_afs_fs_name);
OUT_FS_AFSStoreStatus("Status");
break;
case 142: /* Remove dir */
OUT_FS_AFSFid("Target");
- OUT_STRING(hf_afs_fs_name);
+ OUT_RXString(hf_afs_fs_name);
break;
case 143: /* Old Set Lock */
OUT_FS_AFSFid("Target");
OUT_FS_AFSCBs();
break;
case 148: /* Get vol info */
- OUT_STRING(hf_afs_fs_volname);
+ OUT_RXString(hf_afs_fs_volname);
break;
case 149: /* Get vol stats */
OUT_UINT(hf_afs_fs_volid);
case 150: /* Set vol stats */
OUT_UINT(hf_afs_fs_volid);
OUT_FS_AFSStoreVolumeStatus();
- OUT_STRING(hf_afs_fs_volname);
- OUT_STRING(hf_afs_fs_offlinemsg);
- OUT_STRING(hf_afs_fs_motd);
+ OUT_RXString(hf_afs_fs_volname);
+ OUT_RXString(hf_afs_fs_offlinemsg);
+ OUT_RXString(hf_afs_fs_motd);
break;
case 151: /* get root volume */
/* no params */
/* no params */
break;
case 154: /* new get vol info */
- OUT_STRING(hf_afs_fs_volname);
+ OUT_RXString(hf_afs_fs_volname);
break;
case 155: /* bulk stat */
OUT_FS_AFSCBFids();
break;
case 161: /* lookup */
OUT_FS_AFSFid("Target");
- OUT_STRING(hf_afs_fs_name);
+ OUT_RXString(hf_afs_fs_name);
break;
case 162: /* flush cps */
OUT_FS_ViceIds();
break;
case 163: /* dfs symlink */
OUT_FS_AFSFid("Target");
- OUT_STRING(hf_afs_fs_symlink_name);
- OUT_STRING(hf_afs_fs_symlink_content);
+ OUT_RXString(hf_afs_fs_symlink_name);
+ OUT_RXString(hf_afs_fs_symlink_content);
OUT_FS_AFSStoreStatus("Symlink Status");
break;
}
* BOS Helpers
*/
static void
-dissect_bos_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+dissect_bos_reply(tvbuff_t *tvb, struct rxinfo *rxinfo, proto_tree *tree, int offset, int opcode)
{
- struct rx_header *rxh;
- unsigned char *data;
- int doffset, curoffset;
-
- rxh = (struct rx_header *) &pd[offset];
- data = (char *)rxh + sizeof(struct rx_header);
- doffset = offset + sizeof(struct rx_header);
- curoffset = doffset;
-
- if ( rxh->type == RX_PACKET_TYPE_DATA )
+ if ( rxinfo->type == RX_PACKET_TYPE_DATA )
{
switch ( opcode )
{
break;
case 83: /* get status */
OUT_INT(hf_afs_bos_status);
- OUT_STRING(hf_afs_bos_statusdesc);
+ OUT_RXString(hf_afs_bos_statusdesc);
break;
case 84: /* enumerate instance */
- OUT_STRING(hf_afs_bos_instance);
+ OUT_RXString(hf_afs_bos_instance);
break;
case 85: /* get instance info */
- OUT_STRING(hf_afs_bos_type);
+ OUT_RXString(hf_afs_bos_type);
OUT_BOS_STATUS();
break;
case 86: /* get instance parm */
- OUT_STRING(hf_afs_bos_parm);
+ OUT_RXString(hf_afs_bos_parm);
break;
case 87: /* add siperuser */
/* no output */
/* no output */
break;
case 89: /* list superusers */
- OUT_STRING(hf_afs_bos_user);
+ OUT_RXString(hf_afs_bos_user);
break;
case 90: /* list keys */
OUT_UINT(hf_afs_bos_kvno);
/* no output */
break;
case 94: /* get cell name */
- OUT_STRING(hf_afs_bos_cell);
+ OUT_RXString(hf_afs_bos_cell);
break;
case 95: /* get cell host */
- OUT_STRING(hf_afs_bos_host);
+ OUT_RXString(hf_afs_bos_host);
break;
case 96: /* add cell host */
/* no output */
/* no output */
break;
case 114: /* get instance strings */
- OUT_STRING(hf_afs_bos_error);
- OUT_STRING(hf_afs_bos_spare1);
- OUT_STRING(hf_afs_bos_spare2);
- OUT_STRING(hf_afs_bos_spare3);
+ OUT_RXString(hf_afs_bos_error);
+ OUT_RXString(hf_afs_bos_spare1);
+ OUT_RXString(hf_afs_bos_spare2);
+ OUT_RXString(hf_afs_bos_spare3);
break;
}
}
- else if ( rxh->type == RX_PACKET_TYPE_ABORT )
+ else if ( rxinfo->type == RX_PACKET_TYPE_ABORT )
{
OUT_UINT(hf_afs_bos_errcode);
}
}
static void
-dissect_bos_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+dissect_bos_request(tvbuff_t *tvb, struct rxinfo *rxinfo, proto_tree *tree, int offset, int opcode)
{
- struct rx_header *rxh;
- unsigned char *data;
- int doffset, curoffset;
-
- rxh = (struct rx_header *) &pd[offset];
- data = (char *)rxh + sizeof(struct rx_header);
- doffset = offset + sizeof(struct rx_header);
- curoffset = doffset;
+ offset += 4; /* skip the opcode */
- SKIP_OPCODE();
-
switch ( opcode )
{
case 80: /* create b node */
- OUT_STRING(hf_afs_bos_type);
- OUT_STRING(hf_afs_bos_instance);
- OUT_STRING(hf_afs_bos_parm);
- OUT_STRING(hf_afs_bos_parm);
- OUT_STRING(hf_afs_bos_parm);
- OUT_STRING(hf_afs_bos_parm);
- OUT_STRING(hf_afs_bos_parm);
- OUT_STRING(hf_afs_bos_parm);
+ OUT_RXString(hf_afs_bos_type);
+ OUT_RXString(hf_afs_bos_instance);
+ OUT_RXString(hf_afs_bos_parm);
+ OUT_RXString(hf_afs_bos_parm);
+ OUT_RXString(hf_afs_bos_parm);
+ OUT_RXString(hf_afs_bos_parm);
+ OUT_RXString(hf_afs_bos_parm);
+ OUT_RXString(hf_afs_bos_parm);
break;
case 81: /* delete b node */
- OUT_STRING(hf_afs_bos_instance);
+ OUT_RXString(hf_afs_bos_instance);
break;
case 82: /* set status */
- OUT_STRING(hf_afs_bos_instance);
+ OUT_RXString(hf_afs_bos_instance);
OUT_UINT(hf_afs_bos_status);
break;
case 83: /* get status */
- OUT_STRING(hf_afs_bos_instance);
+ OUT_RXString(hf_afs_bos_instance);
break;
case 84: /* enumerate instance */
OUT_UINT(hf_afs_bos_num);
break;
case 85: /* get instance info */
- OUT_STRING(hf_afs_bos_instance);
+ OUT_RXString(hf_afs_bos_instance);
break;
case 86: /* get instance parm */
- OUT_STRING(hf_afs_bos_instance);
+ OUT_RXString(hf_afs_bos_instance);
OUT_UINT(hf_afs_bos_num);
break;
case 87: /* add super user */
- OUT_STRING(hf_afs_bos_user);
+ OUT_RXString(hf_afs_bos_user);
break;
case 88: /* delete super user */
- OUT_STRING(hf_afs_bos_user);
+ OUT_RXString(hf_afs_bos_user);
break;
case 89: /* list super users */
OUT_UINT(hf_afs_bos_num);
OUT_UINT(hf_afs_bos_num);
break;
case 93: /* set cell name */
- OUT_STRING(hf_afs_bos_content);
+ OUT_RXString(hf_afs_bos_content);
break;
case 95: /* set cell host */
OUT_UINT(hf_afs_bos_num);
break;
case 96: /* add cell host */
- OUT_STRING(hf_afs_bos_content);
+ OUT_RXString(hf_afs_bos_content);
break;
case 97: /* delete cell host */
- OUT_STRING(hf_afs_bos_content);
+ OUT_RXString(hf_afs_bos_content);
break;
case 98: /* set t status */
- OUT_STRING(hf_afs_bos_content);
+ OUT_RXString(hf_afs_bos_content);
OUT_UINT(hf_afs_bos_status);
break;
case 99: /* shutdown all */
/* no params */
break;
case 104: /* restart */
- OUT_STRING(hf_afs_bos_instance);
+ OUT_RXString(hf_afs_bos_instance);
break;
case 105: /* install */
- OUT_STRING(hf_afs_bos_path);
+ OUT_RXString(hf_afs_bos_path);
OUT_UINT(hf_afs_bos_size);
OUT_UINT(hf_afs_bos_flags);
OUT_UINT(hf_afs_bos_date);
break;
case 106: /* uninstall */
- OUT_STRING(hf_afs_bos_path);
+ OUT_RXString(hf_afs_bos_path);
break;
case 107: /* get dates */
- OUT_STRING(hf_afs_bos_path);
+ OUT_RXString(hf_afs_bos_path);
break;
case 108: /* exec */
- OUT_STRING(hf_afs_bos_cmd);
+ OUT_RXString(hf_afs_bos_cmd);
break;
case 109: /* prune */
OUT_UINT(hf_afs_bos_flags);
OUT_UINT(hf_afs_bos_num);
break;
case 112: /* get log */
- OUT_STRING(hf_afs_bos_file);
+ OUT_RXString(hf_afs_bos_file);
break;
case 113: /* wait all */
/* no params */
break;
case 114: /* get instance strings */
- OUT_STRING(hf_afs_bos_content);
+ OUT_RXString(hf_afs_bos_content);
break;
}
}
* VOL Helpers
*/
static void
-dissect_vol_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+dissect_vol_reply(tvbuff_t *tvb, struct rxinfo *rxinfo, proto_tree *tree, int offset, int opcode)
{
- struct rx_header *rxh;
- unsigned char *data;
- int doffset, curoffset;
-
- rxh = (struct rx_header *) &pd[offset];
- data = (char *)rxh + sizeof(struct rx_header);
- doffset = offset + sizeof(struct rx_header);
- curoffset = doffset;
-
- if ( rxh->type == RX_PACKET_TYPE_DATA )
+ if ( rxinfo->type == RX_PACKET_TYPE_DATA )
{
switch ( opcode )
{
case 121:
/* should loop here maybe */
OUT_UINT(hf_afs_vol_count);
- VECOUT(hf_afs_vol_name, 32); /* not sure on */
+ OUT_RXStringV(hf_afs_vol_name, 32); /* not sure on */
break;
}
}
- else if ( rxh->type == RX_PACKET_TYPE_ABORT )
+ else if ( rxinfo->type == RX_PACKET_TYPE_ABORT )
{
OUT_UINT(hf_afs_vol_errcode);
}
}
static void
-dissect_vol_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+dissect_vol_request(tvbuff_t *tvb, struct rxinfo *rxinfo, proto_tree *tree, int offset, int opcode)
{
- struct rx_header *rxh;
- unsigned char *data;
- int doffset, curoffset;
-
- rxh = (struct rx_header *) &pd[offset];
- data = (char *)rxh + sizeof(struct rx_header);
- doffset = offset + sizeof(struct rx_header);
- curoffset = doffset;
-
- SKIP_OPCODE();
+ offset += 4; /* skip the opcode */
switch ( opcode )
{
* KAUTH Helpers
*/
static void
-dissect_kauth_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+dissect_kauth_reply(tvbuff_t *tvb, struct rxinfo *rxinfo, proto_tree *tree, int offset, int opcode)
{
- struct rx_header *rxh;
- unsigned char *data;
- int doffset, curoffset;
-
- rxh = (struct rx_header *) &pd[offset];
- data = (char *)rxh + sizeof(struct rx_header);
- doffset = offset + sizeof(struct rx_header);
- curoffset = doffset;
-
- if ( rxh->type == RX_PACKET_TYPE_DATA )
+ if ( rxinfo->type == RX_PACKET_TYPE_DATA )
{
switch ( opcode )
{
}
}
- else if ( rxh->type == RX_PACKET_TYPE_ABORT )
+ else if ( rxinfo->type == RX_PACKET_TYPE_ABORT )
{
OUT_UINT(hf_afs_kauth_errcode);
}
}
static void
-dissect_kauth_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+dissect_kauth_request(tvbuff_t *tvb, struct rxinfo *rxinfo, proto_tree *tree, int offset, int opcode)
{
- struct rx_header *rxh;
- unsigned char *data;
- int doffset, curoffset;
-
- rxh = (struct rx_header *) &pd[offset];
- data = (char *)rxh + sizeof(struct rx_header);
- doffset = offset + sizeof(struct rx_header);
- curoffset = doffset;
-
- SKIP_OPCODE();
+ offset += 4; /* skip the opcode */
switch ( opcode )
{
case 8: /* get entry */
case 14: /* unlock */
case 15: /* lock status */
- OUT_STRING(hf_afs_kauth_princ);
- OUT_STRING(hf_afs_kauth_realm);
+ OUT_RXString(hf_afs_kauth_princ);
+ OUT_RXString(hf_afs_kauth_realm);
OUT_BYTES_ALL(hf_afs_kauth_data);
break;
case 3: /* getticket-old */
case 23: /* getticket */
OUT_UINT(hf_afs_kauth_kvno);
- OUT_STRING(hf_afs_kauth_domain);
- OUT_STRING(hf_afs_kauth_data);
- OUT_STRING(hf_afs_kauth_princ);
- OUT_STRING(hf_afs_kauth_realm);
+ OUT_RXString(hf_afs_kauth_domain);
+ OUT_RXString(hf_afs_kauth_data);
+ OUT_RXString(hf_afs_kauth_princ);
+ OUT_RXString(hf_afs_kauth_realm);
break;
case 4: /* set pass */
- OUT_STRING(hf_afs_kauth_princ);
- OUT_STRING(hf_afs_kauth_realm);
+ OUT_RXString(hf_afs_kauth_princ);
+ OUT_RXString(hf_afs_kauth_realm);
OUT_UINT(hf_afs_kauth_kvno);
break;
case 12: /* get pass */
- OUT_STRING(hf_afs_kauth_name);
+ OUT_RXString(hf_afs_kauth_name);
break;
}
}
* CB Helpers
*/
static void
-dissect_cb_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+dissect_cb_reply(tvbuff_t *tvb, struct rxinfo *rxinfo, proto_tree *tree, int offset, int opcode)
{
- struct rx_header *rxh;
- unsigned char *data;
- int doffset, curoffset;
-
- rxh = (struct rx_header *) &pd[offset];
- data = (char *)rxh + sizeof(struct rx_header);
- doffset = offset + sizeof(struct rx_header);
- curoffset = doffset;
-
- if ( rxh->type == RX_PACKET_TYPE_DATA )
+ if ( rxinfo->type == RX_PACKET_TYPE_DATA )
{
switch ( opcode )
{
}
}
- else if ( rxh->type == RX_PACKET_TYPE_ABORT )
+ else if ( rxinfo->type == RX_PACKET_TYPE_ABORT )
{
OUT_UINT(hf_afs_cb_errcode);
}
}
static void
-dissect_cb_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+dissect_cb_request(tvbuff_t *tvb, struct rxinfo *rxinfo, proto_tree *tree, int offset, int opcode)
{
- struct rx_header *rxh;
- unsigned char *data;
- int doffset, curoffset;
-
- rxh = (struct rx_header *) &pd[offset];
- data = (char *)rxh + sizeof(struct rx_header);
- doffset = offset + sizeof(struct rx_header);
- curoffset = doffset;
-
- SKIP_OPCODE();
+ offset += 4; /* skip the opcode */
switch ( opcode )
{
{
unsigned int i,j;
- TRUNC(4);
- j = GETINT();
+ j = tvb_get_ntohl(tvb, offset);
+ offset += 4;
for (i=0; i<j; i++)
{
OUT_CB_AFSFid("Target");
}
- TRUNC(4);
- j = GETINT();
+ j = tvb_get_ntohl(tvb, offset);
+ offset += 4;
for (i=0; i<j; i++)
{
OUT_CB_AFSCallBack();
* PROT Helpers
*/
static void
-dissect_prot_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+dissect_prot_reply(tvbuff_t *tvb, struct rxinfo *rxinfo, proto_tree *tree, int offset, int opcode)
{
- struct rx_header *rxh;
- unsigned char *data;
- int doffset, curoffset;
-
- rxh = (struct rx_header *) &pd[offset];
- data = (char *)rxh + sizeof(struct rx_header);
- doffset = offset + sizeof(struct rx_header);
- curoffset = doffset;
-
- if ( rxh->type == RX_PACKET_TYPE_DATA )
+ if ( rxinfo->type == RX_PACKET_TYPE_DATA )
{
switch ( opcode )
{
{
unsigned int i, j;
- TRUNC(4);
- j = GETINT();
+ j = tvb_get_ntohl(tvb, offset);
OUT_UINT(hf_afs_prot_count);
for (i=0; i<j; i++)
{
unsigned int i, j;
- TRUNC(4);
- j = GETINT();
+ j = tvb_get_ntohl(tvb, offset);
OUT_UINT(hf_afs_prot_count);
for (i=0; i<j; i++)
{
- VECOUT(hf_afs_prot_name, PRNAMEMAX);
+ OUT_RXStringV(hf_afs_prot_name, PRNAMEMAX);
}
}
break;
{
unsigned int i, j;
- TRUNC(4);
- j = GETINT();
+ j = tvb_get_ntohl(tvb, offset);
OUT_UINT(hf_afs_prot_count);
for (i=0; i<j; i++)
break;
}
}
- else if ( rxh->type == RX_PACKET_TYPE_ABORT )
+ else if ( rxinfo->type == RX_PACKET_TYPE_ABORT )
{
OUT_UINT(hf_afs_prot_errcode);
}
}
static void
-dissect_prot_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+dissect_prot_request(tvbuff_t *tvb, struct rxinfo *rxinfo, proto_tree *tree, int offset, int opcode)
{
- struct rx_header *rxh;
- unsigned char *data;
- int doffset, curoffset;
-
- rxh = (struct rx_header *) &pd[offset];
- data = (char *)rxh + sizeof(struct rx_header);
- doffset = offset + sizeof(struct rx_header);
- curoffset = doffset;
-
- SKIP_OPCODE();
+ offset += 4; /* skip the opcode */
switch ( opcode )
{
case 500: /* new user */
- OUT_STRING(hf_afs_prot_name);
+ OUT_RXString(hf_afs_prot_name);
OUT_UINT(hf_afs_prot_id);
OUT_UINT(hf_afs_prot_oldid);
break;
{
unsigned int i, j;
- TRUNC(4);
- j = GETINT();
+ j = tvb_get_ntohl(tvb, offset);
OUT_UINT(hf_afs_prot_count);
for (i=0; i<j; i++)
{
- VECOUT(hf_afs_prot_name,PRNAMEMAX);
+ OUT_RXStringV(hf_afs_prot_name,PRNAMEMAX);
}
}
break;
{
unsigned int i, j;
- TRUNC(4);
- j = GETINT();
+ j = tvb_get_ntohl(tvb, offset);
OUT_UINT(hf_afs_prot_count);
for (i=0; i<j; i++)
}
break;
case 509: /* new entry */
- OUT_STRING(hf_afs_prot_name);
+ OUT_RXString(hf_afs_prot_name);
OUT_UINT(hf_afs_prot_flag);
OUT_UINT(hf_afs_prot_oldid);
break;
break;
case 513: /* change entry */
OUT_UINT(hf_afs_prot_id);
- OUT_STRING(hf_afs_prot_name);
+ OUT_RXString(hf_afs_prot_name);
OUT_UINT(hf_afs_prot_oldid);
OUT_UINT(hf_afs_prot_newid);
break;
case 520: /* update entry */
OUT_UINT(hf_afs_prot_id);
- OUT_STRING(hf_afs_prot_name);
+ OUT_RXString(hf_afs_prot_name);
break;
}
}
* VLDB Helpers
*/
static void
-dissect_vldb_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+dissect_vldb_reply(tvbuff_t *tvb, struct rxinfo *rxinfo, proto_tree *tree, int offset, int opcode)
{
- struct rx_header *rxh;
- unsigned char *data;
- int doffset, curoffset;
-
- rxh = (struct rx_header *) &pd[offset];
- data = (char *)rxh + sizeof(struct rx_header);
- doffset = offset + sizeof(struct rx_header);
- curoffset = doffset;
-
- if ( rxh->type == RX_PACKET_TYPE_DATA )
+ if ( rxinfo->type == RX_PACKET_TYPE_DATA )
{
switch ( opcode )
{
case 504: /* get entry by name */
{
int nservers,i,j;
- VECOUT(hf_afs_vldb_name, VLNAMEMAX);
- TRUNC(4);
- nservers = GETINT();
+ OUT_RXStringV(hf_afs_vldb_name, VLNAMEMAX);
+ SKIP(4);
+ nservers = tvb_get_ntohl(tvb, offset);
OUT_UINT(hf_afs_vldb_numservers);
for (i=0; i<8; i++)
{
for (i=0; i<8; i++)
{
char part[8];
- TRUNC(4);
- j = GETINT();
+ j = tvb_get_ntohl(tvb, offset);
strcpy(part, "/vicepa");
if ( i<nservers && j<=25 )
{
part[6] = 'a' + (char) j;
- proto_tree_add_string(tree, hf_afs_vldb_partition, NullTVB,
- curoffset, 4, part);
+ proto_tree_add_string(tree, hf_afs_vldb_partition, tvb,
+ offset, 4, part);
}
SKIP(4);
}
OUT_UINT(hf_afs_vldb_rwvol);
OUT_UINT(hf_afs_vldb_rovol);
OUT_UINT(hf_afs_vldb_bkvol);
+ OUT_UINT(hf_afs_vldb_clonevol);
+ OUT_VLDB_Flags();
}
break;
case 505: /* get new volume id */
case 519: /* get entry by name N */
{
int nservers,i,j;
- VECOUT(hf_afs_vldb_name, VLNAMEMAX);
- TRUNC(4);
- nservers = GETINT();
+ OUT_RXStringV(hf_afs_vldb_name, VLNAMEMAX);
+ nservers = tvb_get_ntohl(tvb, offset);
OUT_UINT(hf_afs_vldb_numservers);
for (i=0; i<13; i++)
{
for (i=0; i<13; i++)
{
char part[8];
- TRUNC(4);
- j = GETINT();
+ j = tvb_get_ntohl(tvb, offset);
strcpy(part, "/vicepa");
if ( i<nservers && j<=25 )
{
part[6] = 'a' + (char) j;
- proto_tree_add_string(tree, hf_afs_vldb_partition, NullTVB,
- curoffset, 4, part);
+ proto_tree_add_string(tree, hf_afs_vldb_partition, tvb,
+ offset, 4, part);
}
SKIP(4);
}
case 527: /* get entry by name u */
{
int nservers,i,j;
- VECOUT(hf_afs_vldb_name, VLNAMEMAX);
- TRUNC(4);
- nservers = GETINT();
+ OUT_RXStringV(hf_afs_vldb_name, VLNAMEMAX);
+ nservers = tvb_get_ntohl(tvb, offset);
OUT_UINT(hf_afs_vldb_numservers);
for (i=0; i<13; i++)
{
if ( i<nservers )
{
- OUT_BYTES(hf_afs_vldb_serveruuid, 11*sizeof(guint32));
+ OUT_UUID(hf_afs_vldb_serveruuid);
+ }
+ else
+ {
+ SKIP_UUID();
+ }
+ }
+ for (i=0; i<13; i++)
+ {
+ if ( i<nservers )
+ {
+ OUT_UINT(hf_afs_vldb_serveruniq);
}
else
{
- SKIP(11*sizeof(guint32));
+ SKIP(sizeof(guint32));
}
}
for (i=0; i<13; i++)
{
char part[8];
- TRUNC(4);
- j = GETINT();
+ j = tvb_get_ntohl(tvb, offset);
strcpy(part, "/vicepa");
if ( i<nservers && j<=25 )
{
part[6] = 'a' + (char) j;
- proto_tree_add_string(tree, hf_afs_vldb_partition, NullTVB,
- curoffset, 4, part);
+ proto_tree_add_string(tree, hf_afs_vldb_partition, tvb,
+ offset, 4, part);
}
SKIP(4);
}
- SKIP(13 * sizeof(guint32));
+ for (i=0; i<13; i++)
+ {
+ if ( i<nservers )
+ {
+ OUT_UINT(hf_afs_vldb_serverflags);
+ }
+ else
+ {
+ SKIP(sizeof(guint32));
+ }
+ }
OUT_UINT(hf_afs_vldb_rwvol);
OUT_UINT(hf_afs_vldb_rovol);
OUT_UINT(hf_afs_vldb_bkvol);
+ OUT_UINT(hf_afs_vldb_clonevol);
+ OUT_UINT(hf_afs_vldb_flags);
+ OUT_UINT(hf_afs_vldb_spare1);
+ OUT_UINT(hf_afs_vldb_spare2);
+ OUT_UINT(hf_afs_vldb_spare3);
+ OUT_UINT(hf_afs_vldb_spare4);
+ OUT_UINT(hf_afs_vldb_spare5);
+ OUT_UINT(hf_afs_vldb_spare6);
+ OUT_UINT(hf_afs_vldb_spare7);
+ OUT_UINT(hf_afs_vldb_spare8);
+ OUT_UINT(hf_afs_vldb_spare9);
}
break;
}
}
- else if ( rxh->type == RX_PACKET_TYPE_ABORT )
+ else if ( rxinfo->type == RX_PACKET_TYPE_ABORT )
{
OUT_UINT(hf_afs_vldb_errcode);
}
}
static void
-dissect_vldb_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+dissect_vldb_request(tvbuff_t *tvb, struct rxinfo *rxinfo, proto_tree *tree, int offset, int opcode)
{
- struct rx_header *rxh;
- unsigned char *data;
- int doffset, curoffset;
-
- rxh = (struct rx_header *) &pd[offset];
- data = (char *)rxh + sizeof(struct rx_header);
- doffset = offset + sizeof(struct rx_header);
- curoffset = doffset;
-
- SKIP_OPCODE();
+ offset += 4; /* skip the opcode */
switch ( opcode )
{
case 501: /* create new volume */
case 517: /* create entry N */
- VECOUT(hf_afs_vldb_name, VLNAMEMAX);
+ OUT_RXStringV(hf_afs_vldb_name, VLNAMEMAX);
break;
case 502: /* delete entry */
case 503: /* get entry by id */
case 519: /* get entry by name N */
case 524: /* update entry by name */
case 527: /* get entry by name U */
- OUT_STRING(hf_afs_vldb_name);
+ OUT_RXString(hf_afs_vldb_name);
break;
case 505: /* get new vol id */
OUT_UINT(hf_afs_vldb_bump);
case 520: /* replace entry N */
OUT_UINT(hf_afs_vldb_id);
OUT_UINT(hf_afs_vldb_type);
- VECOUT(hf_afs_vldb_name, VLNAMEMAX);
+ OUT_RXStringV(hf_afs_vldb_name, VLNAMEMAX);
break;
case 510: /* list entry */
case 521: /* list entry N */
OUT_UINT(hf_afs_vldb_index);
break;
+ case 532: /* regaddr */
+ OUT_UUID(hf_afs_vldb_serveruuid);
+ OUT_UINT(hf_afs_vldb_spare1);
+ OUT_VLDB_BulkAddr();
+ break;
}
}
* UBIK Helpers
*/
static void
-dissect_ubik_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+dissect_ubik_reply(tvbuff_t *tvb, struct rxinfo *rxinfo, proto_tree *tree, int offset, int opcode)
{
- struct rx_header *rxh;
- unsigned char *data;
- int doffset, curoffset;
-
- rxh = (struct rx_header *) &pd[offset];
- data = (char *)rxh + sizeof(struct rx_header);
- doffset = offset + sizeof(struct rx_header);
- curoffset = doffset;
-
- if ( rxh->type == RX_PACKET_TYPE_DATA )
- {
- switch ( opcode )
- {
- case 10000: /* beacon */
- proto_tree_add_boolean(tree,hf_afs_ubik_votetype, NullTVB,0,0,0);
- break;
- case 20004: /* get version */
- OUT_UBIKVERSION("DB Version");
- break;
- }
- }
- else if ( rxh->type == RX_PACKET_TYPE_ABORT )
+ switch ( opcode )
{
- switch ( opcode )
- {
- case 10000:
- proto_tree_add_boolean(tree,hf_afs_ubik_votetype, NullTVB,0,0,1);
- OUT_DATE(hf_afs_ubik_voteend);
- break;
- default:
- OUT_UINT(hf_afs_ubik_errcode);
- break;
- }
+ case 10000: /* vote-beacon */
+ break;
+ case 10001: /* vote-debug-old */
+ OUT_UBIK_DebugOld();
+ break;
+ case 10002: /* vote-sdebug-old */
+ OUT_UBIK_SDebugOld();
+ break;
+ case 10003: /* vote-get syncsite */
+ break;
+ case 10004: /* vote-debug */
+ OUT_UBIK_DebugOld();
+ OUT_UBIK_InterfaceAddrs();
+ break;
+ case 10005: /* vote-sdebug */
+ OUT_UBIK_SDebugOld();
+ OUT_UBIK_InterfaceAddrs();
+ break;
+ case 10006: /* vote-xdebug */
+ OUT_UBIK_DebugOld();
+ OUT_UBIK_InterfaceAddrs();
+ OUT_UINT(hf_afs_ubik_isclone);
+ break;
+ case 10007: /* vote-xsdebug */
+ OUT_UBIK_SDebugOld();
+ OUT_UBIK_InterfaceAddrs();
+ OUT_UINT(hf_afs_ubik_isclone);
+ break;
+ case 20000: /* disk-begin */
+ break;
+ case 20004: /* get version */
+ OUT_UBIKVERSION("DB Version");
+ break;
+ case 20010: /* disk-probe */
+ break;
+ case 20012: /* disk-interfaceaddr */
+ OUT_UBIK_InterfaceAddrs();
+ break;
}
}
static void
-dissect_ubik_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+dissect_ubik_request(tvbuff_t *tvb, struct rxinfo *rxinfo, proto_tree *tree, int offset, int opcode)
{
- struct rx_header *rxh;
- unsigned char *data;
- int doffset, curoffset;
-
- rxh = (struct rx_header *) &pd[offset];
- data = (char *)rxh + sizeof(struct rx_header);
- doffset = offset + sizeof(struct rx_header);
- curoffset = doffset;
-
- SKIP_OPCODE();
+ offset += 4; /* skip the opcode */
switch ( opcode )
{
- case 10000: /* beacon */
- OUT_UINT(hf_afs_ubik_syncsite);
+ case 10000: /* vote-beacon */
+ OUT_UINT(hf_afs_ubik_state);
OUT_DATE(hf_afs_ubik_votestart);
OUT_UBIKVERSION("DB Version");
OUT_UBIKVERSION("TID");
break;
- case 10003: /* get sync site */
+ case 10001: /* vote-debug-old */
+ break;
+ case 10002: /* vote-sdebug-old */
+ OUT_UINT(hf_afs_ubik_site);
+ break;
+ case 10003: /* vote-get sync site */
OUT_IP(hf_afs_ubik_site);
break;
- case 20000: /* begin */
- case 20001: /* commit */
- case 20007: /* abort */
- case 20008: /* release locks */
- case 20010: /* writev */
+ case 10004: /* vote-debug */
+ case 10005: /* vote-sdebug */
+ OUT_IP(hf_afs_ubik_site);
+ break;
+ case 20000: /* disk-begin */
+ OUT_UBIKVERSION("TID");
+ break;
+ case 20001: /* disk-commit */
OUT_UBIKVERSION("TID");
break;
- case 20002: /* lock */
+ case 20002: /* disk-lock */
OUT_UBIKVERSION("TID");
OUT_UINT(hf_afs_ubik_file);
OUT_UINT(hf_afs_ubik_pos);
OUT_UINT(hf_afs_ubik_length);
OUT_UINT(hf_afs_ubik_locktype);
break;
- case 20003: /* write */
+ case 20003: /* disk-write */
OUT_UBIKVERSION("TID");
OUT_UINT(hf_afs_ubik_file);
OUT_UINT(hf_afs_ubik_pos);
break;
- case 20005: /* get file */
+ case 20004: /* disk-get version */
+ break;
+ case 20005: /* disk-get file */
OUT_UINT(hf_afs_ubik_file);
break;
- case 20006: /* send file */
+ case 20006: /* disk-send file */
OUT_UINT(hf_afs_ubik_file);
OUT_UINT(hf_afs_ubik_length);
OUT_UBIKVERSION("DB Version");
break;
- case 20009: /* truncate */
+ case 20007: /* disk-abort */
+ case 20008: /* disk-release locks */
+ case 20010: /* disk-probe */
+ break;
+ case 20009: /* disk-truncate */
OUT_UBIKVERSION("TID");
OUT_UINT(hf_afs_ubik_file);
OUT_UINT(hf_afs_ubik_length);
break;
- case 20012: /* set version */
+ case 20011: /* disk-writev */
+ OUT_UBIKVERSION("TID");
+ break;
+ case 20012: /* disk-interfaceaddr */
+ OUT_UBIK_InterfaceAddrs();
+ break;
+ case 20013: /* disk-set version */
OUT_UBIKVERSION("TID");
OUT_UBIKVERSION("Old DB Version");
OUT_UBIKVERSION("New DB Version");
* BACKUP Helpers
*/
static void
-dissect_backup_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+dissect_backup_reply(tvbuff_t *tvb, struct rxinfo *rxinfo, proto_tree *tree, int offset, int opcode)
{
- struct rx_header *rxh;
- unsigned char *data;
- int doffset, curoffset;
-
- rxh = (struct rx_header *) &pd[offset];
- data = (char *)rxh + sizeof(struct rx_header);
- doffset = offset + sizeof(struct rx_header);
- curoffset = doffset;
-
- if ( rxh->type == RX_PACKET_TYPE_DATA )
+ if ( rxinfo->type == RX_PACKET_TYPE_DATA )
{
switch ( opcode )
{
}
}
- else if ( rxh->type == RX_PACKET_TYPE_ABORT )
+ else if ( rxinfo->type == RX_PACKET_TYPE_ABORT )
{
OUT_UINT(hf_afs_backup_errcode);
}
}
static void
-dissect_backup_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+dissect_backup_request(tvbuff_t *tvb, struct rxinfo *rxinfo, proto_tree *tree, int offset, int opcode)
{
- struct rx_header *rxh;
- unsigned char *data;
- int doffset, curoffset;
-
- rxh = (struct rx_header *) &pd[offset];
- data = (char *)rxh + sizeof(struct rx_header);
- doffset = offset + sizeof(struct rx_header);
- curoffset = doffset;
-
- SKIP_OPCODE();
+ offset += 4; /* skip the opcode */
switch ( opcode )
{
&ett_afs_volsync,
&ett_afs_volumeinfo,
&ett_afs_vicestat,
+ &ett_afs_vldb_flags,
};
- proto_afs = proto_register_protocol("Andrew File System (AFS)", "afs");
+ proto_afs = proto_register_protocol("Andrew File System (AFS)",
+ "AFS (RX)", "afs");
proto_register_field_array(proto_afs, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
register_init_routine(&afs_init_protocol);
+
+ register_dissector("afs", dissect_afs, proto_afs);
}
git.samba.org / obnox / wireshark / wip.git / blobdiff