osmith
/
wireshark
forked from osmocom/wireshark
1
0
Fork 0
Code Pull Requests Releases Wiki Activity

RX and AFS dissectors tvbuffified, and bugs fixed, by Ronnie Sahlberg. 

svn path=/trunk/; revision=3454
This commit is contained in:
Guy Harris 2001-05-27 01:48:25 +00:00
parent b2cbb503a3
commit d2ef0cf51a
7 changed files with 844 additions and 626 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
AUTHORS
View File

@ -516,6 +516,7 @@ Ronnie Sahlberg <rsahlber@bigpond.net.au> {
XDR array support
NIS+ support
Rewritten IGMP dissector
Tvbuffified and bug-fixed RX and AFS dissectors
}
Borosa Tomislav <tomislav.borosa@SIEMENS.HR> {

11
epan/packet_info.h
View File

@ -1,7 +1,7 @@
/* packet_info.h
* Definitions for packet info structures and routines
*
* $Id: packet_info.h,v 1.1 2001/04/01 04:50:42 hagbard Exp $
* $Id: packet_info.h,v 1.2 2001/05/27 01:48:25 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -92,6 +92,15 @@ typedef struct _packet_info {
int iplen;
int iphdrlen;
int p2p_dir;
union {
struct {
guint8 type;
guint8 flags;
guint16 serviceid;
guint32 callnumber;
guint32 seq;
} rx; /* fields specific for RX protocol */
} ps; /* protocol specific data */
} packet_info;
void blank_packetinfo(void);

194
packet-afs-macros.h
View File

@ -8,7 +8,7 @@
* Portions based on information/specs retrieved from the OpenAFS sources at
* www.openafs.org, Copyright IBM.
*
* $Id: packet-afs-macros.h,v 1.7 2001/03/26 15:27:55 nneul Exp $
* $Id: packet-afs-macros.h,v 1.8 2001/05/27 01:48:23 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -37,81 +37,59 @@
* Macros for helper dissection routines
*
* The macros are here to save on coding. They assume that
* the current offset is in 'curoffset', and that the offset
* the current offset is in 'offset', and that the offset
* should be incremented after performing the macro's operation.
*/
/* Get the next available integer, be sure and call TRUNC beforehand */
#define GETINT() (pntohl(&pd[curoffset]))
/* Check if enough bytes are present, if not, return to caller
after adding a 'Truncated' message to tree */
#define TRUNC(bytes) \
if(!BYTES_ARE_IN_FRAME(curoffset,(bytes))) \
{ \
proto_tree_add_text(tree, NullTVB,curoffset, \
END_OF_FRAME,"Truncated"); \
/* not sure why, but this didn't work */ \
/* if (check_col(fd, COL_INFO)) */ \
/* col_append_fstr(fd, COL_INFO, " (TRUNCATED)"); */ \
return; \
}
/* Output a unsigned integer, stored into field 'field'
Assumes it is in network byte order, converts to host before using */
#define OUT_UINT(field) \
TRUNC(sizeof(guint32)) \
proto_tree_add_uint(tree,field, NullTVB,curoffset,sizeof(guint32), GETINT()); \
curoffset += 4;
proto_tree_add_uint(tree, field, tvb, offset, sizeof(guint32), tvb_get_ntohl(tvb, offset)); \
offset += 4;
/* Output a unsigned integer, stored into field 'field'
Assumes it is in network byte order, converts to host before using */
#define OUT_INT(field) \
TRUNC(sizeof(guint32)) \
proto_tree_add_int(tree,field, NullTVB,curoffset,sizeof(gint32), GETINT()); \
curoffset += 4;
proto_tree_add_int(tree, field, tvb, offset, sizeof(gint32), tvb_get_ntohl(tvb, offset)); \
offset += 4;
/* Output a unsigned integer, stored into field 'field'
Assumes it is in network byte order, converts to host before using,
Note - does not increment offset, so can be used repeatedly for bitfields */
#define DISP_UINT(field) \
TRUNC(sizeof(guint32)) \
proto_tree_add_uint(tree,field, NullTVB,curoffset,sizeof(guint32), GETINT());
proto_tree_add_uint(tree,field,tvb,offset,sizeof(guint32),tvb_get_ntohl(tvb, offset));
/* Output an IPv4 address, stored into field 'field' */
#define OUT_IP(field) \
TRUNC(sizeof(gint32)) \
proto_tree_add_ipv4(tree,field, NullTVB,curoffset,sizeof(gint32),\
*((int*)&pd[curoffset]));\
curoffset += 4;
proto_tree_add_ipv4(tree,field,tvb,offset,sizeof(gint32),\
tvb_get_letohl(tvb, offset));\
offset += 4;
/* Output a UNIX seconds/microseconds timestamp, after converting to a timeval */
#define OUT_TIMESTAMP(field) \
{ struct timeval tv; \
TRUNC(2*sizeof(guint32)); \
tv.tv_sec = GETINT(); \
tv.tv_usec = GETINT(); \
proto_tree_add_time(tree,field, NullTVB,curoffset,2*sizeof(guint32),&tv); \
curoffset += 8; \
tv.tv_sec = tvb_get_ntohl(tvb, offset); \
tv.tv_usec = tvb_get_ntohl(tvb, offset); \
proto_tree_add_time(tree,field, tvb,offset,2*sizeof(guint32),&tv); \
offset += 8; \
}
/* Output a UNIX seconds-only timestamp, after converting to a timeval */
#define OUT_DATE(field) \
{ struct timeval tv; \
TRUNC(sizeof(guint32)); \
tv.tv_sec = GETINT(); \
tv.tv_sec = tvb_get_ntohl(tvb, offset); \
tv.tv_usec = 0; \
proto_tree_add_time(tree,field, NullTVB,curoffset,sizeof(guint32),&tv); \
curoffset += 4; \
proto_tree_add_time(tree,field, tvb,offset,sizeof(guint32),&tv); \
offset += 4; \
}
/* Output a callback */
#define OUT_FS_AFSCallBack() \
{ proto_tree *save, *ti; \
ti = proto_tree_add_text(tree, NullTVB, curoffset, 3*4, "Callback"); \
ti = proto_tree_add_text(tree, tvb, offset, 3*4, "Callback"); \
save = tree; \
tree = proto_item_add_subtree(ti, ett_afs_callback); \
TRUNC(3*sizeof(guint32)); \
OUT_UINT(hf_afs_fs_callback_version); \
OUT_DATE(hf_afs_fs_callback_expires); \
OUT_UINT(hf_afs_fs_callback_type); \
@ -121,10 +99,9 @@
/* Output a callback */
#define OUT_CB_AFSCallBack() \
{ proto_tree *save, *ti; \
ti = proto_tree_add_text(tree, NullTVB, curoffset, 3*4, "Callback"); \
ti = proto_tree_add_text(tree, tvb, offset, 3*4, "Callback"); \
save = tree; \
tree = proto_item_add_subtree(ti, ett_afs_callback); \
TRUNC(3*sizeof(guint32)); \
OUT_UINT(hf_afs_cb_callback_version); \
OUT_DATE(hf_afs_cb_callback_expires); \
OUT_UINT(hf_afs_cb_callback_type); \
@ -135,7 +112,7 @@
/* Output a File ID */
#define OUT_FS_AFSFid(label) \
{ proto_tree *save, *ti; \
ti = proto_tree_add_text(tree, NullTVB, curoffset, 3*4, \
ti = proto_tree_add_text(tree, tvb, offset, 3*4, \
"FileID (%s)", label); \
save = tree; \
tree = proto_item_add_subtree(ti, ett_afs_fid); \
@ -149,32 +126,31 @@
#define OUT_FS_STATUSMASK() \
{ proto_tree *save, *ti; \
guint32 mask; \
TRUNC(sizeof(guint32)); \
mask = GETINT(); \
ti = proto_tree_add_uint(tree, hf_afs_fs_status_mask, NullTVB, curoffset, \
mask = tvb_get_ntohl(tvb, offset); \
ti = proto_tree_add_uint(tree, hf_afs_fs_status_mask, tvb, offset, \
sizeof(guint32), mask); \
save = tree; \
tree = proto_item_add_subtree(ti, ett_afs_status_mask); \
proto_tree_add_uint(tree, hf_afs_fs_status_mask_setmodtime, \
NullTVB,curoffset,sizeof(guint32), mask); \
tvb,offset,sizeof(guint32), mask); \
proto_tree_add_uint(tree, hf_afs_fs_status_mask_setowner, \
NullTVB,curoffset,sizeof(guint32), mask); \
tvb,offset,sizeof(guint32), mask); \
proto_tree_add_uint(tree, hf_afs_fs_status_mask_setgroup, \
NullTVB,curoffset,sizeof(guint32), mask); \
tvb,offset,sizeof(guint32), mask); \
proto_tree_add_uint(tree, hf_afs_fs_status_mask_setmode, \
NullTVB,curoffset,sizeof(guint32), mask); \
tvb,offset,sizeof(guint32), mask); \
proto_tree_add_uint(tree, hf_afs_fs_status_mask_setsegsize, \
NullTVB,curoffset,sizeof(guint32), mask); \
tvb,offset,sizeof(guint32), mask); \
proto_tree_add_uint(tree, hf_afs_fs_status_mask_fsync, \
NullTVB,curoffset,sizeof(guint32), mask); \
curoffset += 4; \
tvb,offset,sizeof(guint32), mask); \
offset += 4; \
tree = save; \
}
/* Output a File ID */
#define OUT_CB_AFSFid(label) \
{ proto_tree *save, *ti; \
ti = proto_tree_add_text(tree, NullTVB, curoffset, 3*4, \
ti = proto_tree_add_text(tree, tvb, offset, 3*4, \
"FileID (%s)", label); \
save = tree; \
tree = proto_item_add_subtree(ti, ett_afs_fid); \
@ -187,7 +163,7 @@
/* Output a StoreStatus */
#define OUT_FS_AFSStoreStatus(label) \
{ proto_tree *save, *ti; \
ti = proto_tree_add_text(tree, NullTVB, curoffset, 6*4, \
ti = proto_tree_add_text(tree, tvb, offset, 6*4, \
label); \
save = tree; \
tree = proto_item_add_subtree(ti, ett_afs_status); \
@ -203,7 +179,7 @@
/* Output a FetchStatus */
#define OUT_FS_AFSFetchStatus(label) \
{ proto_tree *save, *ti; \
ti = proto_tree_add_text(tree, NullTVB, curoffset, 21*4, \
ti = proto_tree_add_text(tree, tvb, offset, 21*4, \
label); \
save = tree; \
tree = proto_item_add_subtree(ti, ett_afs_status); \
@ -234,7 +210,7 @@
/* Output a VolSync */
#define OUT_FS_AFSVolSync() \
{ proto_tree *save, *ti; \
ti = proto_tree_add_text(tree, NullTVB, curoffset, 6*4, \
ti = proto_tree_add_text(tree, tvb, offset, 6*4, \
"VolSync"); \
save = tree; \
tree = proto_item_add_subtree(ti, ett_afs_volsync); \
@ -251,9 +227,8 @@
#define OUT_FS_AFSCBFids() \
{ \
unsigned int j,i; \
TRUNC(1); \
j = pntohl(&pd[curoffset]); \
curoffset += 1; \
j = tvb_get_guint8(tvb, offset); \
offset += 1; \
for (i=0; i<j; i++) { \
OUT_FS_AFSFid("Target"); \
} \
@ -263,9 +238,8 @@
#define OUT_FS_ViceIds() \
{ \
unsigned int j,i; \
TRUNC(1); \
j = pntohl(&pd[curoffset]); \
curoffset += 1; \
j = tvb_get_guint8(tvb,offset); \
offset += 1; \
for (i=0; i<j; i++) { \
OUT_UINT(hf_afs_fs_viceid); \
} \
@ -275,9 +249,8 @@
#define OUT_FS_IPAddrs() \
{ \
unsigned int j,i; \
TRUNC(1); \
j = pntohl(&pd[curoffset]); \
curoffset += 1; \
j = tvb_get_guint8(tvb, offset); \
offset += 1; \
for (i=0; i<j; i++) { \
OUT_IP(hf_afs_fs_ipaddr); \
} \
@ -287,9 +260,8 @@
#define OUT_FS_AFSCBs() \
{ \
unsigned int j,i; \
TRUNC(1); \
j = pntohl(&pd[curoffset]); \
curoffset += 1; \
j = tvb_get_guint8(tvb,offset); \
offset += 1; \
for (i=0; i<j; i++) { \
OUT_FS_AFSCallBack(); \
} \
@ -300,9 +272,8 @@
#define OUT_FS_AFSBulkStats() \
{ \
unsigned int j,i; \
TRUNC(1); \
j = pntohl(&pd[curoffset]); \
curoffset += 1; \
j = tvb_get_guint8(tvb,offset); \
offset += 1; \
for (i=0; i<j; i++) { \
OUT_FS_AFSFetchStatus("Status"); \
} \
@ -340,21 +311,21 @@
if ( acl & PRSFS_WRITE ) strcat(tmp, "w"); \
if ( acl & PRSFS_LOCK ) strcat(tmp, "k"); \
if ( acl & PRSFS_ADMINISTER ) strcat(tmp, "a"); \
ti = proto_tree_add_text(tree, NullTVB, curoffset, bytes, \
ti = proto_tree_add_text(tree, tvb, offset, bytes, \
"ACL: %s %s%s", \
who, tmp, positive ? "" : " (negative)"); \
save = tree; \
tree = proto_item_add_subtree(ti, ett_afs_acl); \
proto_tree_add_string(tree,hf_afs_fs_acl_entity, NullTVB,curoffset,strlen(who), who);\
tmpoffset = curoffset + strlen(who) + 1; \
proto_tree_add_string(tree,hf_afs_fs_acl_entity, tvb,offset,strlen(who), who);\
tmpoffset = offset + strlen(who) + 1; \
acllen = bytes - strlen(who) - 1; \
proto_tree_add_uint(tree,hf_afs_fs_acl_r, NullTVB,tmpoffset,acllen,acl);\
proto_tree_add_uint(tree,hf_afs_fs_acl_l, NullTVB,tmpoffset,acllen,acl);\
proto_tree_add_uint(tree,hf_afs_fs_acl_i, NullTVB,tmpoffset,acllen,acl);\
proto_tree_add_uint(tree,hf_afs_fs_acl_d, NullTVB,tmpoffset,acllen,acl);\
proto_tree_add_uint(tree,hf_afs_fs_acl_w, NullTVB,tmpoffset,acllen,acl);\
proto_tree_add_uint(tree,hf_afs_fs_acl_k, NullTVB,tmpoffset,acllen,acl);\
proto_tree_add_uint(tree,hf_afs_fs_acl_a, NullTVB,tmpoffset,acllen,acl);\
proto_tree_add_uint(tree,hf_afs_fs_acl_r, tvb,tmpoffset,acllen,acl);\
proto_tree_add_uint(tree,hf_afs_fs_acl_l, tvb,tmpoffset,acllen,acl);\
proto_tree_add_uint(tree,hf_afs_fs_acl_i, tvb,tmpoffset,acllen,acl);\
proto_tree_add_uint(tree,hf_afs_fs_acl_d, tvb,tmpoffset,acllen,acl);\
proto_tree_add_uint(tree,hf_afs_fs_acl_w, tvb,tmpoffset,acllen,acl);\
proto_tree_add_uint(tree,hf_afs_fs_acl_k, tvb,tmpoffset,acllen,acl);\
proto_tree_add_uint(tree,hf_afs_fs_acl_a, tvb,tmpoffset,acllen,acl);\
tree = save; \
}
@ -381,18 +352,17 @@
{ \
unsigned int i,j,seen_null=0; \
for (i=0; i<255; i++) { \
j = GETINT(); \
j = tvb_get_ntohl(tvb, offset); \
if ( j != 0 ) { \
OUT_IP(hf_afs_ubik_interface); \
seen_null = 0; \
} else { \
if ( ! seen_null ) { \
TRUNC(4); \
proto_tree_add_text(tree, NullTVB,curoffset,END_OF_FRAME, \
proto_tree_add_text(tree, tvb,offset,END_OF_FRAME, \
"Null Interface Addresses"); \
seen_null = 1; \
} \
curoffset += 4; \
offset += 4; \
}\
} \
}
@ -440,55 +410,50 @@
/* Skip a certain number of bytes */
#define SKIP(bytes) \
TRUNC(bytes) \
curoffset += bytes;
offset += bytes;
/* Raw data - to end of frame */
#define OUT_BYTES_ALL(field) OUT_BYTES(field, offset+END_OF_FRAME-curoffset)
#define OUT_BYTES_ALL(field) OUT_BYTES(field, tvb_length_remaining(tvb,offset))
/* Raw data */
#define OUT_BYTES(field, bytes) \
TRUNC(bytes); \
proto_tree_add_bytes(tree,field, NullTVB,curoffset,bytes,\
(void *)&pd[curoffset]); \
curoffset += bytes;
proto_tree_add_bytes(tree,field, tvb,offset,bytes,\
tvb_get_ptr(tvb,offset,bytes)); \
offset += bytes;
/* Output a rx style string, up to a maximum length first
4 bytes - length, then char data */
#define OUT_STRING(field) \
{ int i; \
TRUNC(4); \
i = GETINT(); \
curoffset += 4; \
i = tvb_get_ntohl(tvb, offset); \
offset += 4; \
if ( i > 0 ) { \
char *tmp; \
TRUNC(i); \
tmp = g_malloc(i+1); \
memcpy(tmp, &pd[curoffset], i); \
memcpy(tmp, tvb_get_ptr(tvb,offset,i), i); \
tmp[i] = '\0'; \
proto_tree_add_string(tree, field, NullTVB, curoffset-4, i+4, \
proto_tree_add_string(tree, field, tvb, offset-4, i+4, \
(void *)tmp); \
g_free(tmp); \
} else { \
proto_tree_add_string(tree, field, NullTVB, curoffset-4, 4, \
proto_tree_add_string(tree, field, tvb, offset-4, 4, \
""); \
} \
curoffset += i; \
offset += i; \
}
/* Output a fixed length vectorized string (each char is a 32 bit int) */
#define VECOUT(field, length) \
{ char tmp[length+1]; \
int i,soff; \
soff = curoffset;\
TRUNC(length * sizeof(guint32));\
soff = offset;\
for (i=0; i<length; i++)\
{\
tmp[i] = (char) GETINT();\
curoffset += sizeof(guint32);\
tmp[i] = (char) tvb_get_ntohl(tvb, offset);\
offset += sizeof(guint32);\
}\
tmp[length] = '\0';\
proto_tree_add_string(tree, field, NullTVB, soff, length, tmp);\
proto_tree_add_string(tree, field, tvb, soff, length, tmp);\
}
/* Skip the opcode */
@ -502,24 +467,23 @@
{ proto_tree *save, *ti; \
unsigned int epoch,counter; \
struct timeval tv; \
TRUNC(8); \
epoch = GETINT(); \
curoffset += 4; \
counter = GETINT(); \
curoffset += 4; \
epoch = tvb_get_ntohl(tvb, offset); \
offset += 4; \
counter = tvb_get_ntohl(tvb, offset); \
offset += 4; \
tv.tv_sec = epoch; \
tv.tv_usec = 0; \
ti = proto_tree_add_text(tree, NullTVB, curoffset-8, 8, \
ti = proto_tree_add_text(tree, tvb, offset-8, 8, \
"UBIK Version (%s): %u.%u", label, epoch, counter ); \
save = tree; \
tree = proto_item_add_subtree(ti, ett_afs_ubikver); \
if ( epoch != 0 ) \
proto_tree_add_time(tree,hf_afs_ubik_version_epoch, NullTVB,curoffset-8, \
proto_tree_add_time(tree,hf_afs_ubik_version_epoch, tvb,offset-8, \
sizeof(guint32),&tv); \
else \
proto_tree_add_text(tree, NullTVB, curoffset-8, \
proto_tree_add_text(tree, tvb, offset-8, \
sizeof(guint32),"Epoch: 0"); \
proto_tree_add_uint(tree,hf_afs_ubik_version_counter, NullTVB,curoffset-4, \
proto_tree_add_uint(tree,hf_afs_ubik_version_counter, tvb,offset-4, \
sizeof(guint32),counter); \
tree = save; \
}

633
packet-afs.c
View File

File diff suppressed because it is too large Load Diff

4
packet-afs.h
View File

@ -1,7 +1,7 @@
/* packet-afs.h
* Definitions for packet disassembly structures and routines
*
* $Id: packet-afs.h,v 1.5 2001/04/17 00:46:03 guy Exp $
* $Id: packet-afs.h,v 1.6 2001/05/27 01:48:23 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -26,7 +26,7 @@
#ifndef PACKET_AFS_H
#define PACKET_AFS_H
void dissect_afs(const u_char *, int, frame_data *, proto_tree *);
void dissect_afs(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
#define AFS_PORT_FS 7000
#define AFS_PORT_CB 7001

594
packet-rx.c
View File

@ -4,7 +4,7 @@
* Based on routines from tcpdump patches by
* Ken Hornstein <kenh@cmf.nrl.navy.mil>
*
* $Id: packet-rx.c,v 1.19 2001/03/26 15:27:55 nneul Exp $
* $Id: packet-rx.c,v 1.20 2001/05/27 01:48:24 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -75,8 +75,25 @@ static const value_string rx_flags[] = {
{ 0, NULL }
};
static int proto_rx = -1;
static const value_string rx_reason[] = {
{ RX_ACK_REQUESTED, "Ack Requested" },
{ RX_ACK_DUPLICATE, "Duplicate Packet" },
{ RX_ACK_OUT_OF_SEQUENCE, "Out Of Sequence" },
{ RX_ACK_EXEEDS_WINDOW, "Exceeds Window" },
{ RX_ACK_NOSPACE, "No Space" },
{ RX_ACK_PING, "Ping" },
{ RX_ACK_PING_RESPONSE, "Ping Response" },
{ RX_ACK_DELAY, "Delay" },
{ 0, NULL }
};
static const value_string rx_ack_type[] = {
{ RX_ACK_TYPE_NACK, "NACK" },
{ RX_ACK_TYPE_ACK, "ACK" },
{ 0, NULL }
};
static int proto_rx = -1;
static int hf_rx_epoch = -1;
static int hf_rx_cid = -1;
static int hf_rx_seq = -1;
@ -93,99 +110,418 @@ static int hf_rx_userstatus = -1;
static int hf_rx_securityindex = -1;
static int hf_rx_spare = -1;
static int hf_rx_serviceid = -1;
static int hf_rx_bufferspace = -1;
static int hf_rx_maxskew = -1;
static int hf_rx_first_packet = -1;
static int hf_rx_prev_packet = -1;
static int hf_rx_reason = -1;
static int hf_rx_numacks = -1;
static int hf_rx_ack_type = -1;
static int hf_rx_ack = -1;
static int hf_rx_challenge = -1;
static int hf_rx_version = -1;
static int hf_rx_nonce = -1;
static int hf_rx_inc_nonce = -1;
static int hf_rx_min_level = -1;
static int hf_rx_level = -1;
static int hf_rx_response = -1;
static int hf_rx_encrypted = -1;
static int hf_rx_kvno = -1;
static int hf_rx_ticket_len = -1;
static int hf_rx_ticket = -1;
static gint ett_rx = -1;
static gint ett_rx_flags = -1;
static gint ett_rx_ack = -1;
static gint ett_rx_challenge = -1;
static gint ett_rx_response = -1;
static gint ett_rx_encrypted = -1;
static void
dissect_rx(const u_char *pd, int offset, frame_data *fd, proto_tree *tree)
static int
dissect_rx_response_encrypted(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, int offset)
{
proto_tree *rx_tree, *rx_tree_flags, *rx_flags, *ti;
struct rx_header *rxh;
int reply;
proto_tree *tree;
proto_item *item;
int old_offset=offset;
int i;
guint32 callnumber;
OLD_CHECK_DISPLAY_AS_DATA(proto_rx, pd, offset, fd, tree);
item = proto_tree_add_item(parent_tree, hf_rx_encrypted, tvb, offset, 0, FALSE);
tree = proto_item_add_subtree(item, ett_rx_encrypted);
rxh = (struct rx_header *) &pd[offset];
/* get at least a full packet structure */
if ( !BYTES_ARE_IN_FRAME(offset, sizeof(struct rx_header)) )
return;
if (check_col(fd, COL_PROTOCOL))
col_set_str(fd, COL_PROTOCOL, "RX");
if (tree) {
ti = proto_tree_add_protocol_format(tree, proto_rx, NullTVB, offset,
sizeof(struct rx_header), "RX Protocol");
rx_tree = proto_item_add_subtree(ti, ett_rx);
{
struct timeval tv;
tv.tv_sec = pntohl(&rxh->epoch);
tv.tv_usec = 0;
/* epoch : 4 bytes */
{
struct timeval tv;
tv.tv_sec = tvb_get_ntohl(tvb, offset);
tv.tv_usec = 0;
proto_tree_add_time(rx_tree,hf_rx_epoch, NullTVB,
offset,sizeof(guint32),&tv);
}
proto_tree_add_uint(rx_tree, hf_rx_cid, NullTVB,
offset+4, 4, pntohl(&rxh->cid));
proto_tree_add_uint(rx_tree, hf_rx_callnumber, NullTVB,
offset+8, 4, pntohl(&rxh->callNumber));
proto_tree_add_uint(rx_tree, hf_rx_seq, NullTVB,
offset+12, 4, pntohl(&rxh->seq));
proto_tree_add_uint(rx_tree, hf_rx_serial, NullTVB,
offset+16, 4, pntohl(&rxh->serial));
proto_tree_add_uint(rx_tree, hf_rx_type, NullTVB,
offset+20, 1, rxh->type);
rx_flags = proto_tree_add_uint(rx_tree, hf_rx_flags, NullTVB,
offset+21, 1, rxh->flags);
rx_tree_flags = proto_item_add_subtree(rx_flags, ett_rx_flags);
proto_tree_add_uint(rx_tree_flags, hf_rx_flags_free_packet, NullTVB,
offset+21, 1, rxh->flags);
proto_tree_add_uint(rx_tree_flags, hf_rx_flags_more_packets, NullTVB,
offset+21, 1, rxh->flags);
proto_tree_add_uint(rx_tree_flags, hf_rx_flags_last_packet, NullTVB,
offset+21, 1, rxh->flags);
proto_tree_add_uint(rx_tree_flags, hf_rx_flags_request_ack, NullTVB,
offset+21, 1, rxh->flags);
proto_tree_add_uint(rx_tree_flags, hf_rx_flags_clientinit, NullTVB,
offset+21, 1, rxh->flags);
proto_tree_add_uint(rx_tree, hf_rx_userstatus, NullTVB,
offset+22, 1, rxh->userStatus);
proto_tree_add_uint(rx_tree, hf_rx_securityindex, NullTVB,
offset+23, 1, rxh->securityIndex);
proto_tree_add_uint(rx_tree, hf_rx_spare, NullTVB,
offset+24, 2, pntohs(&rxh->spare));
proto_tree_add_uint(rx_tree, hf_rx_serviceid, NullTVB,
offset+26, 2, pntohs(&rxh->serviceId));
proto_tree_add_time(tree, hf_rx_epoch, tvb,
offset, 4, &tv);
offset += 4;
}
if (check_col(fd, COL_INFO))
col_add_fstr(fd, COL_INFO,
"Type: %s "
/* cid : 4 bytes */
proto_tree_add_uint(tree, hf_rx_cid, tvb,
offset, 4, tvb_get_ntohl(tvb, offset));
offset += 4;
/*FIXME dont know how to handle this checksum, skipping it */
offset += 4;
/* sequrityindex : 1 byte */
proto_tree_add_uint(tree, hf_rx_securityindex, tvb,
offset, 1, tvb_get_guint8(tvb, offset));
offset += 4;
for (i=0; i<RX_MAXCALLS; i++) {
/* callnumber : 4 bytes */
callnumber = tvb_get_ntohl(tvb, offset);
proto_tree_add_uint(tree, hf_rx_callnumber, tvb,
offset, 4, callnumber);
offset += 4;
}
/* inc nonce : 4 bytes */
proto_tree_add_uint(tree, hf_rx_inc_nonce, tvb,
offset, 4, tvb_get_ntohl(tvb, offset));
offset += 4;
/* level : 4 bytes */
proto_tree_add_uint(tree, hf_rx_level, tvb,
offset, 4, tvb_get_ntohl(tvb, offset));
offset += 4;
proto_item_set_len(item, offset-old_offset);
return offset;
}
static int
dissect_rx_response(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, int offset, guint32 seq, guint32 callnumber)
{
proto_tree *tree;
proto_item *item;
guint32 version, tl;
int old_offset=offset;
if (check_col(pinfo->fd, COL_INFO)) {
col_add_fstr(pinfo->fd, COL_INFO,
"RESPONSE "
"Seq: %lu "
"Call: %lu "
"Source Port: %s "
"Destination Port: %s ",
val_to_str(rxh->type, rx_types, "%d"),
(unsigned long)pntohl(&rxh->seq),
(unsigned long)pntohl(&rxh->callNumber),
get_udp_port(pi.srcport),
get_udp_port(pi.destport)
(unsigned long)seq,
(unsigned long)callnumber,
get_udp_port(pinfo->srcport),
get_udp_port(pinfo->destport)
);
reply = (rxh->flags & RX_CLIENT_INITIATED) == 0;
if ( (rxh->type == RX_PACKET_TYPE_ABORT && reply) ||
rxh->type == RX_PACKET_TYPE_DATA )
{
dissect_afs(pd,offset,fd,tree);
}
item = proto_tree_add_item(parent_tree, hf_rx_response, tvb, offset, 0, FALSE);
tree = proto_item_add_subtree(item, ett_rx_response);
version = tvb_get_ntohl(tvb, offset);
proto_tree_add_uint(tree, hf_rx_version, tvb,
offset, 4, version);
offset += 4;
if (version==2) {
/* skip unused */
offset += 4;
/* encrypted : struct */
offset = dissect_rx_response_encrypted(tvb, pinfo, tree, offset);
/* kvno */
proto_tree_add_uint(tree, hf_rx_kvno, tvb,
offset, 4, tvb_get_ntohl(tvb, offset));
offset += 4;
/* ticket_len */
tl = tvb_get_ntohl(tvb, offset);
proto_tree_add_uint(tree, hf_rx_ticket_len, tvb,
offset, 4, tl);
offset += 4;
proto_tree_add_item(tree, hf_rx_ticket, tvb, offset, tl, FALSE);
offset += tl;
}
proto_item_set_len(item, offset-old_offset);
return offset;
}
static int
dissect_rx_challenge(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, int offset, guint32 seq, guint32 callnumber)
{
proto_tree *tree;
proto_item *item;
guint32 version;
int old_offset=offset;
if (check_col(pinfo->fd, COL_INFO)) {
col_add_fstr(pinfo->fd, COL_INFO,
"CHALLENGE "
"Seq: %lu "
"Call: %lu "
"Source Port: %s "
"Destination Port: %s ",
(unsigned long)seq,
(unsigned long)callnumber,
get_udp_port(pinfo->srcport),
get_udp_port(pinfo->destport)
);
}
item = proto_tree_add_item(parent_tree, hf_rx_challenge, tvb, offset, 0, FALSE);
tree = proto_item_add_subtree(item, ett_rx_challenge);
version = tvb_get_ntohl(tvb, offset);
proto_tree_add_uint(tree, hf_rx_version, tvb,
offset, 4, version);
offset += 4;
if (version==2) {
proto_tree_add_uint(tree, hf_rx_nonce, tvb,
offset, 4, tvb_get_ntohl(tvb, offset));
offset += 4;
proto_tree_add_uint(tree, hf_rx_min_level, tvb,
offset, 4, tvb_get_ntohl(tvb, offset));
offset += 4;
}
proto_item_set_len(item, offset-old_offset);
return offset;
}
static int
dissect_rx_acks(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, int offset, guint32 seq, guint32 callnumber)
{
proto_tree *tree;
proto_item *item;
guint8 num;
int old_offset = offset;
if (check_col(pinfo->fd, COL_INFO)) {
col_add_fstr(pinfo->fd, COL_INFO,
"ACK "
"Seq: %lu "
"Call: %lu "
"Source Port: %s "
"Destination Port: %s ",
(unsigned long)seq,
(unsigned long)callnumber,
get_udp_port(pinfo->srcport),
get_udp_port(pinfo->destport)
);
}
item = proto_tree_add_item(parent_tree, hf_rx_ack, tvb, offset, 0, FALSE);
tree = proto_item_add_subtree(item, ett_rx_ack);
/* bufferspace: 2 bytes*/
proto_tree_add_uint(tree, hf_rx_bufferspace, tvb,
offset, 2, tvb_get_ntohs(tvb, offset));
offset += 2;
/* maxskew: 2 bytes*/
proto_tree_add_uint(tree, hf_rx_maxskew, tvb,
offset, 2, tvb_get_ntohs(tvb, offset));
offset += 2;
/* first packet: 4 bytes*/
proto_tree_add_uint(tree, hf_rx_first_packet, tvb,
offset, 4, tvb_get_ntohl(tvb, offset));
offset += 4;
/* prev packet: 4 bytes*/
proto_tree_add_uint(tree, hf_rx_prev_packet, tvb,
offset, 4, tvb_get_ntohl(tvb, offset));
offset += 4;
/* serial : 4 bytes */
proto_tree_add_uint(tree, hf_rx_serial, tvb,
offset, 4, tvb_get_ntohl(tvb, offset) );
offset += 4;
/* reason : 1 byte */
proto_tree_add_uint(tree, hf_rx_reason, tvb,
offset, 1, tvb_get_guint8(tvb, offset) );
offset += 1;
/* nACKs */
num = tvb_get_guint8(tvb, offset);
proto_tree_add_uint(tree, hf_rx_numacks, tvb,
offset, 1, tvb_get_guint8(tvb, offset) );
offset += 1;
while(num--){
proto_tree_add_uint(tree, hf_rx_ack_type, tvb,
offset, 1, tvb_get_guint8(tvb, offset) );
offset += 1;
}
proto_item_set_len(item, offset-old_offset);
return offset;
}
static int
dissect_rx_flags(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, int offset)
{
proto_tree *tree;
proto_item *item;
guint8 flags;
flags = tvb_get_guint8(tvb, offset);
pinfo->ps.rx.flags = flags;
item = proto_tree_add_uint(parent_tree, hf_rx_flags, tvb,
offset, 1, flags);
tree = proto_item_add_subtree(item, ett_rx_flags);
proto_tree_add_uint(tree, hf_rx_flags_free_packet, tvb,
offset, 1, flags);
proto_tree_add_uint(tree, hf_rx_flags_more_packets, tvb,
offset, 1, flags);
proto_tree_add_uint(tree, hf_rx_flags_last_packet, tvb,
offset, 1, flags);
proto_tree_add_uint(tree, hf_rx_flags_request_ack, tvb,
offset, 1, flags);
proto_tree_add_uint(tree, hf_rx_flags_clientinit, tvb,
offset, 1, flags);
offset += 1;
return offset;
}
static void
dissect_rx(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree)
{
proto_tree *tree;
proto_item *item;
int offset = 0;
guint8 type;
guint32 seq, callnumber;
guint16 serviceid;
if (check_col(pinfo->fd, COL_PROTOCOL))
col_set_str(pinfo->fd, COL_PROTOCOL, "RX");
if (check_col(pinfo->fd, COL_INFO))
col_clear(pinfo->fd, COL_INFO);
item = proto_tree_add_protocol_format(parent_tree, proto_rx, tvb,
offset, 28, "RX Protocol");
tree = proto_item_add_subtree(item, ett_rx);
/* epoch : 4 bytes */
{
struct timeval tv;
tv.tv_sec = tvb_get_ntohl(tvb, offset);
tv.tv_usec = 0;
proto_tree_add_time(tree, hf_rx_epoch, tvb,
offset, 4, &tv);
offset += 4;
}
/* cid : 4 bytes */
proto_tree_add_uint(tree, hf_rx_cid, tvb,
offset, 4, tvb_get_ntohl(tvb, offset));
offset += 4;
/* callnumber : 4 bytes */
callnumber = tvb_get_ntohl(tvb, offset);
proto_tree_add_uint(tree, hf_rx_callnumber, tvb,
offset, 4, callnumber);
offset += 4;
pinfo->ps.rx.callnumber = callnumber;
/* seq : 4 bytes */
seq = tvb_get_ntohl(tvb, offset);
proto_tree_add_uint(tree, hf_rx_seq, tvb,
offset, 4, seq);
offset += 4;
pinfo->ps.rx.seq = seq;
/* serial : 4 bytes */
proto_tree_add_uint(tree, hf_rx_serial, tvb,
offset, 4, tvb_get_ntohl(tvb, offset));
offset += 4;
/* type : 1 byte */
type = tvb_get_guint8(tvb, offset);
proto_tree_add_uint(tree, hf_rx_type, tvb,
offset, 1, type);
offset += 1;
pinfo->ps.rx.type = type;
/* flags : 1 byte */
offset = dissect_rx_flags(tvb, pinfo, tree, offset);
/* userstatus : 1 byte */
proto_tree_add_uint(tree, hf_rx_userstatus, tvb,
offset, 1, tvb_get_guint8(tvb, offset));
offset += 1;
/* sequrityindex : 1 byte */
proto_tree_add_uint(tree, hf_rx_securityindex, tvb,
offset, 1, tvb_get_guint8(tvb, offset));
offset += 1;
/* spare */
proto_tree_add_uint(tree, hf_rx_spare, tvb,
offset, 2, tvb_get_ntohs(tvb, offset));
offset += 2;
/* service id : 2 bytes */
serviceid = tvb_get_ntohs(tvb, offset);
proto_tree_add_uint(tree, hf_rx_serviceid, tvb,
offset, 2, serviceid);
offset += 2;
pinfo->ps.rx.serviceid = serviceid;
switch (type) {
case RX_PACKET_TYPE_ACK:
/*dissect_rx_acks(tvb, pinfo, parent_tree, offset,
cant create it in a parallell tree, then ett seasrch
wont work */
dissect_rx_acks(tvb, pinfo, tree, offset,
seq, callnumber);
break;
case RX_PACKET_TYPE_ACKALL:
/* does not contain any payload */
if (check_col(pinfo->fd, COL_INFO)) {
col_add_fstr(pinfo->fd, COL_INFO,
"ACKALL "
"Seq: %lu "
"Call: %lu "
"Source Port: %s "
"Destination Port: %s ",
(unsigned long)seq,
(unsigned long)callnumber,
get_udp_port(pinfo->srcport),
get_udp_port(pinfo->destport)
);
}
break;
case RX_PACKET_TYPE_CHALLENGE:
dissect_rx_challenge(tvb, pinfo, tree, offset, seq, callnumber);
break;
case RX_PACKET_TYPE_RESPONSE:
dissect_rx_response(tvb, pinfo, tree, offset, seq, callnumber);
break;
case RX_PACKET_TYPE_DATA: {
tvbuff_t *next_tvb;
next_tvb = tvb_new_subset(tvb, offset, -1, -1);
dissect_afs(next_tvb, pinfo, parent_tree);
};
break;
}
}
void
@ -195,55 +531,151 @@ proto_register_rx(void)
{ &hf_rx_epoch, {
"Epoch", "rx.epoch", FT_ABSOLUTE_TIME, BASE_DEC,
NULL, 0, "Epoch" }},
{ &hf_rx_cid, {
"CID", "rx.cid", FT_UINT32, BASE_DEC,
NULL, 0, "CID" }},
{ &hf_rx_callnumber, {
"Call Number", "rx.callnumber", FT_UINT32, BASE_DEC,
NULL, 0, "Call Number" }},
{ &hf_rx_seq, {
"Sequence Number", "rx.seq", FT_UINT32, BASE_DEC,
NULL, 0, "Sequence Number" }},
{ &hf_rx_serial, {
"Serial", "rx.serial", FT_UINT32, BASE_DEC,
NULL, 0, "Serial" }},
{ &hf_rx_type, {
"Type", "rx.type", FT_UINT8, BASE_DEC,
VALS(rx_types), 0, "Type" }},
{ &hf_rx_flags, {
"Flags", "rx.flags", FT_UINT8, BASE_HEX,
NULL, 0, "Flags" }},
{ &hf_rx_flags_clientinit, {
"Client Initiated", "rx.flags.client_init", FT_UINT8, BASE_BIN,
NULL, RX_CLIENT_INITIATED, "Client Initiated" }},
{ &hf_rx_flags_request_ack, {
"Request Ack", "rx.flags.request_ack", FT_UINT8, BASE_BIN,
NULL, RX_REQUEST_ACK, "Request Ack" }},
{ &hf_rx_flags_last_packet, {
"Last Packet", "rx.flags.last_packet", FT_UINT8, BASE_BIN,
NULL, RX_LAST_PACKET, "Last Packet" }},
{ &hf_rx_flags_more_packets, {
"More Packets", "rx.flags.more_packets", FT_UINT8, BASE_BIN,
NULL, RX_MORE_PACKETS, "More Packets" }},
{ &hf_rx_flags_free_packet, {
"Free Packet", "rx.flags.free_packet", FT_UINT8, BASE_BIN,
NULL, RX_FREE_PACKET, "Free Packet" }},
{ &hf_rx_userstatus, {
"User Status", "rx.userstatus", FT_UINT32, BASE_DEC,
NULL, 0, "User Status" }},
{ &hf_rx_securityindex, {
"Security Index", "rx.securityindex", FT_UINT32, BASE_DEC,
NULL, 0, "Security Index" }},
{ &hf_rx_spare, {
"Spare/Checksum", "rx.spare", FT_UINT16, BASE_DEC,
NULL, 0, "Spare/Checksum" }},
{ &hf_rx_serviceid, {
"Service ID", "rx.serviceid", FT_UINT16, BASE_DEC,
NULL, 0, "Service ID" }},
{ &hf_rx_bufferspace, {
"Bufferspace", "rx.bufferspace", FT_UINT16, BASE_DEC,
NULL, 0, "Number Of Packets Available" }},
{ &hf_rx_maxskew, {
"Max Skew", "rx.maxskew", FT_UINT16, BASE_DEC,
NULL, 0, "Max Skew" }},
{ &hf_rx_first_packet, {
"First Packet", "rx.first", FT_UINT32, BASE_DEC,
NULL, 0, "First Packet" }},
{ &hf_rx_prev_packet, {
"Prev Packet", "rx.prev", FT_UINT32, BASE_DEC,
NULL, 0, "Previous Packet" }},
{ &hf_rx_reason, {
"Reason", "rx.reason", FT_UINT8, BASE_DEC,
VALS(rx_reason), 0, "Reason For This ACK" }},
{ &hf_rx_numacks, {
"Num ACKs", "rx.num_acks", FT_UINT8, BASE_DEC,
NULL, 0, "Number Of ACKs" }},
{ &hf_rx_ack_type, {
"ACK Type", "rx.ack_type", FT_UINT8, BASE_DEC,
VALS(rx_ack_type), 0, "Type Of ACKs" }},
{ &hf_rx_ack, {
"ACK Packet", "rx.ack", FT_NONE, BASE_NONE,
NULL, 0, "ACK Packet" }},
{ &hf_rx_challenge, {
"CHALLENGE Packet", "rx.challenge", FT_NONE, BASE_NONE,
NULL, 0, "CHALLENGE Packet" }},
{ &hf_rx_version, {
"Version", "rx.version", FT_UINT32, BASE_DEC,
NULL, 0, "Version Of Challenge/Response" }},
{ &hf_rx_nonce, {
"Nonce", "rx.nonce", FT_UINT32, BASE_HEX,
NULL, 0, "Nonce" }},
{ &hf_rx_inc_nonce, {
"Inc Nonce", "rx.inc_nonce", FT_UINT32, BASE_HEX,
NULL, 0, "Incremented Nonce" }},
{ &hf_rx_min_level, {
"Min Level", "rx.min_level", FT_UINT32, BASE_DEC,
NULL, 0, "Min Level" }},
{ &hf_rx_level, {
"Level", "rx.level", FT_UINT32, BASE_DEC,
NULL, 0, "Level" }},
{ &hf_rx_response, {
"RESPONSE Packet", "rx.response", FT_NONE, BASE_NONE,
NULL, 0, "RESPONSE Packet" }},
{ &hf_rx_encrypted, {
"Encrypted", "rx.encrypted", FT_NONE, BASE_NONE,
NULL, 0, "Encrypted part of response packet" }},
{ &hf_rx_kvno, {
"kvno", "rx.kvno", FT_UINT32, BASE_DEC,
NULL, 0, "kvno" }},
{ &hf_rx_ticket_len, {
"Ticket len", "rx.ticket_len", FT_UINT32, BASE_DEC,
NULL, 0, "Ticket Length" }},
{ &hf_rx_ticket, {
"ticket", "rx.ticket", FT_BYTES, BASE_HEX,
NULL, 0, "Ticket" }},
};
static gint *ett[] = {
&ett_rx,
&ett_rx_flags,
&ett_rx_ack,
&ett_rx_challenge,
&ett_rx_response,
&ett_rx_encrypted,
};
proto_rx = proto_register_protocol("RX Protocol", "RX", "rx");
@ -259,7 +691,7 @@ proto_reg_handoff_rx(void)
/* Ports in the range UDP_PORT_RX_LOW to UDP_PORT_RX_HIGH
are all used for various AFS services. */
for (port = UDP_PORT_RX_LOW; port <= UDP_PORT_RX_HIGH; port++)
old_dissector_add("udp.port", port, dissect_rx, proto_rx);
old_dissector_add("udp.port", UDP_PORT_RX_AFS_BACKUPS, dissect_rx,
dissector_add("udp.port", port, dissect_rx, proto_rx);
dissector_add("udp.port", UDP_PORT_RX_AFS_BACKUPS, dissect_rx,
proto_rx);
}

33
packet-rx.h
View File

@ -1,7 +1,7 @@
/* packet-rx.h
* Definitions for packet disassembly structures and routines
*
* $Id: packet-rx.h,v 1.4 2001/04/17 00:46:03 guy Exp $
* $Id: packet-rx.h,v 1.5 2001/05/27 01:48:24 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -56,7 +56,7 @@ struct rx_header {
}; /* serviceId is first, it's really */
/* encoded _after_ the spare field */
/* I wasted a day figuring that out! */
#define RX_MAXACKS 255
struct rx_ack_header {
guint16 bufferspace; /* # of packet buffers available */
guint16 maxskew;
@ -64,7 +64,8 @@ struct rx_ack_header {
guint32 prevpacket;
guint32 serial; /* Packet that prompted this one */
u_char reason; /* rx_ack_reason */
/* some other stuff I think */
u_char nAcks; /* number of acks*/
u_char acks[RX_MAXACKS];
};
#define RX_ACK_TYPE_NACK 0
@ -79,5 +80,31 @@ struct rx_ack_header {
#define RX_ACK_PING_RESPONSE 7
#define RX_ACK_DELAY 8
struct rxkad_challenge {
guint32 version;
guint32 nonce;
guint32 min_level;
guint32 unused;
};
#define RX_MAXCALLS 4
struct rxkad_response {
guint32 version;
guint32 unused;
struct {
guint32 epoch;
guint32 cid;
guint32 cksum;
guint32 security_index;
guint32 call_numbers[RX_MAXCALLS];
guint32 inc_nonce;
guint32 level;
} encrypted;
guint32 kvno;
guint32 ticket_len;
u_char the_ticket[0];
};
#endif