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 XDR array support
NIS+ support NIS+ support
Rewritten IGMP dissector Rewritten IGMP dissector
Tvbuffified and bug-fixed RX and AFS dissectors
} }
Borosa Tomislav <tomislav.borosa@SIEMENS.HR> { Borosa Tomislav <tomislav.borosa@SIEMENS.HR> {

11
epan/packet_info.h
View File

@ -1,7 +1,7 @@
/* packet_info.h /* packet_info.h
* Definitions for packet info structures and routines * 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 * Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org> * By Gerald Combs <gerald@zing.org>
@ -92,6 +92,15 @@ typedef struct _packet_info {
int iplen; int iplen;
int iphdrlen; int iphdrlen;
int p2p_dir; 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; } packet_info;
void blank_packetinfo(void); 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 * Portions based on information/specs retrieved from the OpenAFS sources at
* www.openafs.org, Copyright IBM. * 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 * Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org> * By Gerald Combs <gerald@zing.org>
@ -37,81 +37,59 @@
* Macros for helper dissection routines * Macros for helper dissection routines
* *
* The macros are here to save on coding. They assume that * 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. * 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' /* Output a unsigned integer, stored into field 'field'
Assumes it is in network byte order, converts to host before using */ Assumes it is in network byte order, converts to host before using */
#define OUT_UINT(field) \ #define OUT_UINT(field) \
TRUNC(sizeof(guint32)) \ proto_tree_add_uint(tree, field, tvb, offset, sizeof(guint32), tvb_get_ntohl(tvb, offset)); \
proto_tree_add_uint(tree,field, NullTVB,curoffset,sizeof(guint32), GETINT()); \ offset += 4;
curoffset += 4;
/* Output a unsigned integer, stored into field 'field' /* Output a unsigned integer, stored into field 'field'
Assumes it is in network byte order, converts to host before using */ Assumes it is in network byte order, converts to host before using */
#define OUT_INT(field) \ #define OUT_INT(field) \
TRUNC(sizeof(guint32)) \ proto_tree_add_int(tree, field, tvb, offset, sizeof(gint32), tvb_get_ntohl(tvb, offset)); \
proto_tree_add_int(tree,field, NullTVB,curoffset,sizeof(gint32), GETINT()); \ offset += 4;
curoffset += 4;
/* Output a unsigned integer, stored into field 'field' /* Output a unsigned integer, stored into field 'field'
Assumes it is in network byte order, converts to host before using, Assumes it is in network byte order, converts to host before using,
Note - does not increment offset, so can be used repeatedly for bitfields */ Note - does not increment offset, so can be used repeatedly for bitfields */
#define DISP_UINT(field) \ #define DISP_UINT(field) \
TRUNC(sizeof(guint32)) \ proto_tree_add_uint(tree,field,tvb,offset,sizeof(guint32),tvb_get_ntohl(tvb, offset));
proto_tree_add_uint(tree,field, NullTVB,curoffset,sizeof(guint32), GETINT());
/* Output an IPv4 address, stored into field 'field' */ /* Output an IPv4 address, stored into field 'field' */
#define OUT_IP(field) \ #define OUT_IP(field) \
TRUNC(sizeof(gint32)) \ proto_tree_add_ipv4(tree,field,tvb,offset,sizeof(gint32),\
proto_tree_add_ipv4(tree,field, NullTVB,curoffset,sizeof(gint32),\ tvb_get_letohl(tvb, offset));\
*((int*)&pd[curoffset]));\ offset += 4;
curoffset += 4;
/* Output a UNIX seconds/microseconds timestamp, after converting to a timeval */ /* Output a UNIX seconds/microseconds timestamp, after converting to a timeval */
#define OUT_TIMESTAMP(field) \ #define OUT_TIMESTAMP(field) \
{ struct timeval tv; \ { struct timeval tv; \
TRUNC(2*sizeof(guint32)); \ tv.tv_sec = tvb_get_ntohl(tvb, offset); \
tv.tv_sec = GETINT(); \ tv.tv_usec = tvb_get_ntohl(tvb, offset); \
tv.tv_usec = GETINT(); \ proto_tree_add_time(tree,field, tvb,offset,2*sizeof(guint32),&tv); \
proto_tree_add_time(tree,field, NullTVB,curoffset,2*sizeof(guint32),&tv); \ offset += 8; \
curoffset += 8; \
} }
/* Output a UNIX seconds-only timestamp, after converting to a timeval */ /* Output a UNIX seconds-only timestamp, after converting to a timeval */
#define OUT_DATE(field) \ #define OUT_DATE(field) \
{ struct timeval tv; \ { struct timeval tv; \
TRUNC(sizeof(guint32)); \ tv.tv_sec = tvb_get_ntohl(tvb, offset); \
tv.tv_sec = GETINT(); \
tv.tv_usec = 0; \ tv.tv_usec = 0; \
proto_tree_add_time(tree,field, NullTVB,curoffset,sizeof(guint32),&tv); \ proto_tree_add_time(tree,field, tvb,offset,sizeof(guint32),&tv); \
curoffset += 4; \ offset += 4; \
} }
/* Output a callback */ /* Output a callback */
#define OUT_FS_AFSCallBack() \ #define OUT_FS_AFSCallBack() \
{ proto_tree *save, *ti; \ { 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; \ save = tree; \
tree = proto_item_add_subtree(ti, ett_afs_callback); \ tree = proto_item_add_subtree(ti, ett_afs_callback); \
TRUNC(3*sizeof(guint32)); \
OUT_UINT(hf_afs_fs_callback_version); \ OUT_UINT(hf_afs_fs_callback_version); \
OUT_DATE(hf_afs_fs_callback_expires); \ OUT_DATE(hf_afs_fs_callback_expires); \
OUT_UINT(hf_afs_fs_callback_type); \ OUT_UINT(hf_afs_fs_callback_type); \
@ -121,10 +99,9 @@
/* Output a callback */ /* Output a callback */
#define OUT_CB_AFSCallBack() \ #define OUT_CB_AFSCallBack() \
{ proto_tree *save, *ti; \ { 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; \ save = tree; \
tree = proto_item_add_subtree(ti, ett_afs_callback); \ tree = proto_item_add_subtree(ti, ett_afs_callback); \
TRUNC(3*sizeof(guint32)); \
OUT_UINT(hf_afs_cb_callback_version); \ OUT_UINT(hf_afs_cb_callback_version); \
OUT_DATE(hf_afs_cb_callback_expires); \ OUT_DATE(hf_afs_cb_callback_expires); \
OUT_UINT(hf_afs_cb_callback_type); \ OUT_UINT(hf_afs_cb_callback_type); \
@ -135,7 +112,7 @@
/* Output a File ID */ /* Output a File ID */
#define OUT_FS_AFSFid(label) \ #define OUT_FS_AFSFid(label) \
{ proto_tree *save, *ti; \ { 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); \ "FileID (%s)", label); \
save = tree; \ save = tree; \
tree = proto_item_add_subtree(ti, ett_afs_fid); \ tree = proto_item_add_subtree(ti, ett_afs_fid); \
@ -149,32 +126,31 @@
#define OUT_FS_STATUSMASK() \ #define OUT_FS_STATUSMASK() \
{ proto_tree *save, *ti; \ { proto_tree *save, *ti; \
guint32 mask; \ guint32 mask; \
TRUNC(sizeof(guint32)); \ mask = tvb_get_ntohl(tvb, offset); \
mask = GETINT(); \ ti = proto_tree_add_uint(tree, hf_afs_fs_status_mask, tvb, offset, \
ti = proto_tree_add_uint(tree, hf_afs_fs_status_mask, NullTVB, curoffset, \
sizeof(guint32), mask); \ sizeof(guint32), mask); \
save = tree; \ save = tree; \
tree = proto_item_add_subtree(ti, ett_afs_status_mask); \ tree = proto_item_add_subtree(ti, ett_afs_status_mask); \
proto_tree_add_uint(tree, hf_afs_fs_status_mask_setmodtime, \ 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, \ 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, \ 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, \ 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, \ 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, \ proto_tree_add_uint(tree, hf_afs_fs_status_mask_fsync, \
NullTVB,curoffset,sizeof(guint32), mask); \ tvb,offset,sizeof(guint32), mask); \
curoffset += 4; \ offset += 4; \
tree = save; \ tree = save; \
} }
/* Output a File ID */ /* Output a File ID */
#define OUT_CB_AFSFid(label) \ #define OUT_CB_AFSFid(label) \
{ proto_tree *save, *ti; \ { 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); \ "FileID (%s)", label); \
save = tree; \ save = tree; \
tree = proto_item_add_subtree(ti, ett_afs_fid); \ tree = proto_item_add_subtree(ti, ett_afs_fid); \
@ -187,7 +163,7 @@
/* Output a StoreStatus */ /* Output a StoreStatus */
#define OUT_FS_AFSStoreStatus(label) \ #define OUT_FS_AFSStoreStatus(label) \
{ proto_tree *save, *ti; \ { 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); \ label); \
save = tree; \ save = tree; \
tree = proto_item_add_subtree(ti, ett_afs_status); \ tree = proto_item_add_subtree(ti, ett_afs_status); \
@ -203,7 +179,7 @@
/* Output a FetchStatus */ /* Output a FetchStatus */
#define OUT_FS_AFSFetchStatus(label) \ #define OUT_FS_AFSFetchStatus(label) \
{ proto_tree *save, *ti; \ { 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); \ label); \
save = tree; \ save = tree; \
tree = proto_item_add_subtree(ti, ett_afs_status); \ tree = proto_item_add_subtree(ti, ett_afs_status); \
@ -234,7 +210,7 @@
/* Output a VolSync */ /* Output a VolSync */
#define OUT_FS_AFSVolSync() \ #define OUT_FS_AFSVolSync() \
{ proto_tree *save, *ti; \ { 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"); \ "VolSync"); \
save = tree; \ save = tree; \
tree = proto_item_add_subtree(ti, ett_afs_volsync); \ tree = proto_item_add_subtree(ti, ett_afs_volsync); \
@ -251,9 +227,8 @@
#define OUT_FS_AFSCBFids() \ #define OUT_FS_AFSCBFids() \
{ \ { \
unsigned int j,i; \ unsigned int j,i; \
TRUNC(1); \ j = tvb_get_guint8(tvb, offset); \
j = pntohl(&pd[curoffset]); \ offset += 1; \
curoffset += 1; \
for (i=0; i<j; i++) { \ for (i=0; i<j; i++) { \
OUT_FS_AFSFid("Target"); \ OUT_FS_AFSFid("Target"); \
} \ } \
@ -263,9 +238,8 @@
#define OUT_FS_ViceIds() \ #define OUT_FS_ViceIds() \
{ \ { \
unsigned int j,i; \ unsigned int j,i; \
TRUNC(1); \ j = tvb_get_guint8(tvb,offset); \
j = pntohl(&pd[curoffset]); \ offset += 1; \
curoffset += 1; \
for (i=0; i<j; i++) { \ for (i=0; i<j; i++) { \
OUT_UINT(hf_afs_fs_viceid); \ OUT_UINT(hf_afs_fs_viceid); \
} \ } \
@ -275,9 +249,8 @@
#define OUT_FS_IPAddrs() \ #define OUT_FS_IPAddrs() \
{ \ { \
unsigned int j,i; \ unsigned int j,i; \
TRUNC(1); \ j = tvb_get_guint8(tvb, offset); \
j = pntohl(&pd[curoffset]); \ offset += 1; \
curoffset += 1; \
for (i=0; i<j; i++) { \ for (i=0; i<j; i++) { \
OUT_IP(hf_afs_fs_ipaddr); \ OUT_IP(hf_afs_fs_ipaddr); \
} \ } \
@ -287,9 +260,8 @@
#define OUT_FS_AFSCBs() \ #define OUT_FS_AFSCBs() \
{ \ { \
unsigned int j,i; \ unsigned int j,i; \
TRUNC(1); \ j = tvb_get_guint8(tvb,offset); \
j = pntohl(&pd[curoffset]); \ offset += 1; \
curoffset += 1; \
for (i=0; i<j; i++) { \ for (i=0; i<j; i++) { \
OUT_FS_AFSCallBack(); \ OUT_FS_AFSCallBack(); \
} \ } \
@ -300,9 +272,8 @@
#define OUT_FS_AFSBulkStats() \ #define OUT_FS_AFSBulkStats() \
{ \ { \
unsigned int j,i; \ unsigned int j,i; \
TRUNC(1); \ j = tvb_get_guint8(tvb,offset); \
j = pntohl(&pd[curoffset]); \ offset += 1; \
curoffset += 1; \
for (i=0; i<j; i++) { \ for (i=0; i<j; i++) { \
OUT_FS_AFSFetchStatus("Status"); \ OUT_FS_AFSFetchStatus("Status"); \
} \ } \
@ -340,21 +311,21 @@
if ( acl & PRSFS_WRITE ) strcat(tmp, "w"); \ if ( acl & PRSFS_WRITE ) strcat(tmp, "w"); \
if ( acl & PRSFS_LOCK ) strcat(tmp, "k"); \ if ( acl & PRSFS_LOCK ) strcat(tmp, "k"); \
if ( acl & PRSFS_ADMINISTER ) strcat(tmp, "a"); \ 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", \ "ACL: %s %s%s", \
who, tmp, positive ? "" : " (negative)"); \ who, tmp, positive ? "" : " (negative)"); \
save = tree; \ save = tree; \
tree = proto_item_add_subtree(ti, ett_afs_acl); \ tree = proto_item_add_subtree(ti, ett_afs_acl); \
proto_tree_add_string(tree,hf_afs_fs_acl_entity, NullTVB,curoffset,strlen(who), who);\ proto_tree_add_string(tree,hf_afs_fs_acl_entity, tvb,offset,strlen(who), who);\
tmpoffset = curoffset + strlen(who) + 1; \ tmpoffset = offset + strlen(who) + 1; \
acllen = bytes - 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_r, tvb,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_l, tvb,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_i, tvb,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_d, tvb,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_w, tvb,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_k, tvb,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_a, tvb,tmpoffset,acllen,acl);\
tree = save; \ tree = save; \
} }
@ -381,18 +352,17 @@
{ \ { \
unsigned int i,j,seen_null=0; \ unsigned int i,j,seen_null=0; \
for (i=0; i<255; i++) { \ for (i=0; i<255; i++) { \
j = GETINT(); \ j = tvb_get_ntohl(tvb, offset); \
if ( j != 0 ) { \ if ( j != 0 ) { \
OUT_IP(hf_afs_ubik_interface); \ OUT_IP(hf_afs_ubik_interface); \
seen_null = 0; \ seen_null = 0; \
} else { \ } else { \
if ( ! seen_null ) { \ if ( ! seen_null ) { \
TRUNC(4); \ proto_tree_add_text(tree, tvb,offset,END_OF_FRAME, \
proto_tree_add_text(tree, NullTVB,curoffset,END_OF_FRAME, \
"Null Interface Addresses"); \ "Null Interface Addresses"); \
seen_null = 1; \ seen_null = 1; \
} \ } \
curoffset += 4; \ offset += 4; \
}\ }\
} \ } \
} }
@ -440,55 +410,50 @@
/* Skip a certain number of bytes */ /* Skip a certain number of bytes */
#define SKIP(bytes) \ #define SKIP(bytes) \
TRUNC(bytes) \ offset += bytes;
curoffset += bytes;
/* Raw data - to end of frame */ /* 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 */ /* Raw data */
#define OUT_BYTES(field, bytes) \ #define OUT_BYTES(field, bytes) \
TRUNC(bytes); \ proto_tree_add_bytes(tree,field, tvb,offset,bytes,\
proto_tree_add_bytes(tree,field, NullTVB,curoffset,bytes,\ tvb_get_ptr(tvb,offset,bytes)); \
(void *)&pd[curoffset]); \ offset += bytes;
curoffset += bytes;
/* Output a rx style string, up to a maximum length first /* Output a rx style string, up to a maximum length first
4 bytes - length, then char data */ 4 bytes - length, then char data */
#define OUT_STRING(field) \ #define OUT_STRING(field) \
{ int i; \ { int i; \
TRUNC(4); \ i = tvb_get_ntohl(tvb, offset); \
i = GETINT(); \ offset += 4; \
curoffset += 4; \
if ( i > 0 ) { \ if ( i > 0 ) { \
char *tmp; \ char *tmp; \
TRUNC(i); \
tmp = g_malloc(i+1); \ tmp = g_malloc(i+1); \
memcpy(tmp, &pd[curoffset], i); \ memcpy(tmp, tvb_get_ptr(tvb,offset,i), i); \
tmp[i] = '\0'; \ 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); \ (void *)tmp); \
g_free(tmp); \ g_free(tmp); \
} else { \ } 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) */ /* Output a fixed length vectorized string (each char is a 32 bit int) */
#define VECOUT(field, length) \ #define VECOUT(field, length) \
{ char tmp[length+1]; \ { char tmp[length+1]; \
int i,soff; \ int i,soff; \
soff = curoffset;\ soff = offset;\
TRUNC(length * sizeof(guint32));\
for (i=0; i<length; i++)\ for (i=0; i<length; i++)\
{\ {\
tmp[i] = (char) GETINT();\ tmp[i] = (char) tvb_get_ntohl(tvb, offset);\
curoffset += sizeof(guint32);\ offset += sizeof(guint32);\
}\ }\
tmp[length] = '\0';\ 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 */ /* Skip the opcode */
@ -502,24 +467,23 @@
{ proto_tree *save, *ti; \ { proto_tree *save, *ti; \
unsigned int epoch,counter; \ unsigned int epoch,counter; \
struct timeval tv; \ struct timeval tv; \
TRUNC(8); \ epoch = tvb_get_ntohl(tvb, offset); \
epoch = GETINT(); \ offset += 4; \
curoffset += 4; \ counter = tvb_get_ntohl(tvb, offset); \
counter = GETINT(); \ offset += 4; \
curoffset += 4; \
tv.tv_sec = epoch; \ tv.tv_sec = epoch; \
tv.tv_usec = 0; \ 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 ); \ "UBIK Version (%s): %u.%u", label, epoch, counter ); \
save = tree; \ save = tree; \
tree = proto_item_add_subtree(ti, ett_afs_ubikver); \ tree = proto_item_add_subtree(ti, ett_afs_ubikver); \
if ( epoch != 0 ) \ 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); \ sizeof(guint32),&tv); \
else \ else \
proto_tree_add_text(tree, NullTVB, curoffset-8, \ proto_tree_add_text(tree, tvb, offset-8, \
sizeof(guint32),"Epoch: 0"); \ 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); \ sizeof(guint32),counter); \
tree = save; \ 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 /* packet-afs.h
* Definitions for packet disassembly structures and routines * 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 * Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org> * By Gerald Combs <gerald@zing.org>
@ -26,7 +26,7 @@
#ifndef PACKET_AFS_H #ifndef PACKET_AFS_H
#define 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_FS 7000
#define AFS_PORT_CB 7001 #define AFS_PORT_CB 7001

594
packet-rx.c
View File

@ -4,7 +4,7 @@
* Based on routines from tcpdump patches by * Based on routines from tcpdump patches by
* Ken Hornstein <kenh@cmf.nrl.navy.mil> * 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 * Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org> * By Gerald Combs <gerald@zing.org>
@ -75,8 +75,25 @@ static const value_string rx_flags[] = {
{ 0, NULL } { 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_epoch = -1;
static int hf_rx_cid = -1; static int hf_rx_cid = -1;
static int hf_rx_seq = -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_securityindex = -1;
static int hf_rx_spare = -1; static int hf_rx_spare = -1;
static int hf_rx_serviceid = -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 = -1;
static gint ett_rx_flags = -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 static int
dissect_rx(const u_char *pd, int offset, frame_data *fd, proto_tree *tree) 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; proto_tree *tree;
struct rx_header *rxh; proto_item *item;
int reply; 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]; /* epoch : 4 bytes */
{
/* get at least a full packet structure */ struct timeval tv;
if ( !BYTES_ARE_IN_FRAME(offset, sizeof(struct rx_header)) ) tv.tv_sec = tvb_get_ntohl(tvb, offset);
return; tv.tv_usec = 0;
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;
proto_tree_add_time(rx_tree,hf_rx_epoch, NullTVB, proto_tree_add_time(tree, hf_rx_epoch, tvb,
offset,sizeof(guint32),&tv); offset, 4, &tv);
} offset += 4;
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));
} }
if (check_col(fd, COL_INFO)) /* cid : 4 bytes */
col_add_fstr(fd, COL_INFO, proto_tree_add_uint(tree, hf_rx_cid, tvb,
"Type: %s " 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 " "Seq: %lu "
"Call: %lu " "Call: %lu "
"Source Port: %s " "Source Port: %s "
"Destination Port: %s ", "Destination Port: %s ",
val_to_str(rxh->type, rx_types, "%d"), (unsigned long)seq,
(unsigned long)pntohl(&rxh->seq), (unsigned long)callnumber,
(unsigned long)pntohl(&rxh->callNumber), get_udp_port(pinfo->srcport),
get_udp_port(pi.srcport), get_udp_port(pinfo->destport)
get_udp_port(pi.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 void
@ -195,55 +531,151 @@ proto_register_rx(void)
{ &hf_rx_epoch, { { &hf_rx_epoch, {
"Epoch", "rx.epoch", FT_ABSOLUTE_TIME, BASE_DEC, "Epoch", "rx.epoch", FT_ABSOLUTE_TIME, BASE_DEC,
NULL, 0, "Epoch" }}, NULL, 0, "Epoch" }},
{ &hf_rx_cid, { { &hf_rx_cid, {
"CID", "rx.cid", FT_UINT32, BASE_DEC, "CID", "rx.cid", FT_UINT32, BASE_DEC,
NULL, 0, "CID" }}, NULL, 0, "CID" }},
{ &hf_rx_callnumber, { { &hf_rx_callnumber, {
"Call Number", "rx.callnumber", FT_UINT32, BASE_DEC, "Call Number", "rx.callnumber", FT_UINT32, BASE_DEC,
NULL, 0, "Call Number" }}, NULL, 0, "Call Number" }},
{ &hf_rx_seq, { { &hf_rx_seq, {
"Sequence Number", "rx.seq", FT_UINT32, BASE_DEC, "Sequence Number", "rx.seq", FT_UINT32, BASE_DEC,
NULL, 0, "Sequence Number" }}, NULL, 0, "Sequence Number" }},
{ &hf_rx_serial, { { &hf_rx_serial, {
"Serial", "rx.serial", FT_UINT32, BASE_DEC, "Serial", "rx.serial", FT_UINT32, BASE_DEC,
NULL, 0, "Serial" }}, NULL, 0, "Serial" }},
{ &hf_rx_type, { { &hf_rx_type, {
"Type", "rx.type", FT_UINT8, BASE_DEC, "Type", "rx.type", FT_UINT8, BASE_DEC,
VALS(rx_types), 0, "Type" }}, VALS(rx_types), 0, "Type" }},
{ &hf_rx_flags, { { &hf_rx_flags, {
"Flags", "rx.flags", FT_UINT8, BASE_HEX, "Flags", "rx.flags", FT_UINT8, BASE_HEX,
NULL, 0, "Flags" }}, NULL, 0, "Flags" }},
{ &hf_rx_flags_clientinit, { { &hf_rx_flags_clientinit, {
"Client Initiated", "rx.flags.client_init", FT_UINT8, BASE_BIN, "Client Initiated", "rx.flags.client_init", FT_UINT8, BASE_BIN,
NULL, RX_CLIENT_INITIATED, "Client Initiated" }}, NULL, RX_CLIENT_INITIATED, "Client Initiated" }},
{ &hf_rx_flags_request_ack, { { &hf_rx_flags_request_ack, {
"Request Ack", "rx.flags.request_ack", FT_UINT8, BASE_BIN, "Request Ack", "rx.flags.request_ack", FT_UINT8, BASE_BIN,
NULL, RX_REQUEST_ACK, "Request Ack" }}, NULL, RX_REQUEST_ACK, "Request Ack" }},
{ &hf_rx_flags_last_packet, { { &hf_rx_flags_last_packet, {
"Last Packet", "rx.flags.last_packet", FT_UINT8, BASE_BIN, "Last Packet", "rx.flags.last_packet", FT_UINT8, BASE_BIN,
NULL, RX_LAST_PACKET, "Last Packet" }}, NULL, RX_LAST_PACKET, "Last Packet" }},
{ &hf_rx_flags_more_packets, { { &hf_rx_flags_more_packets, {
"More Packets", "rx.flags.more_packets", FT_UINT8, BASE_BIN, "More Packets", "rx.flags.more_packets", FT_UINT8, BASE_BIN,
NULL, RX_MORE_PACKETS, "More Packets" }}, NULL, RX_MORE_PACKETS, "More Packets" }},
{ &hf_rx_flags_free_packet, { { &hf_rx_flags_free_packet, {
"Free Packet", "rx.flags.free_packet", FT_UINT8, BASE_BIN, "Free Packet", "rx.flags.free_packet", FT_UINT8, BASE_BIN,
NULL, RX_FREE_PACKET, "Free Packet" }}, NULL, RX_FREE_PACKET, "Free Packet" }},
{ &hf_rx_userstatus, { { &hf_rx_userstatus, {
"User Status", "rx.userstatus", FT_UINT32, BASE_DEC, "User Status", "rx.userstatus", FT_UINT32, BASE_DEC,
NULL, 0, "User Status" }}, NULL, 0, "User Status" }},
{ &hf_rx_securityindex, { { &hf_rx_securityindex, {
"Security Index", "rx.securityindex", FT_UINT32, BASE_DEC, "Security Index", "rx.securityindex", FT_UINT32, BASE_DEC,
NULL, 0, "Security Index" }}, NULL, 0, "Security Index" }},
{ &hf_rx_spare, { { &hf_rx_spare, {
"Spare/Checksum", "rx.spare", FT_UINT16, BASE_DEC, "Spare/Checksum", "rx.spare", FT_UINT16, BASE_DEC,
NULL, 0, "Spare/Checksum" }}, NULL, 0, "Spare/Checksum" }},
{ &hf_rx_serviceid, { { &hf_rx_serviceid, {
"Service ID", "rx.serviceid", FT_UINT16, BASE_DEC, "Service ID", "rx.serviceid", FT_UINT16, BASE_DEC,
NULL, 0, "Service ID" }}, 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[] = { static gint *ett[] = {
&ett_rx, &ett_rx,
&ett_rx_flags, &ett_rx_flags,
&ett_rx_ack,
&ett_rx_challenge,
&ett_rx_response,
&ett_rx_encrypted,
}; };
proto_rx = proto_register_protocol("RX Protocol", "RX", "rx"); 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 /* Ports in the range UDP_PORT_RX_LOW to UDP_PORT_RX_HIGH
are all used for various AFS services. */ are all used for various AFS services. */
for (port = UDP_PORT_RX_LOW; port <= UDP_PORT_RX_HIGH; port++) for (port = UDP_PORT_RX_LOW; port <= UDP_PORT_RX_HIGH; port++)
old_dissector_add("udp.port", port, dissect_rx, proto_rx); 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", UDP_PORT_RX_AFS_BACKUPS, dissect_rx,
proto_rx); proto_rx);
} }

33
packet-rx.h
View File

@ -1,7 +1,7 @@
/* packet-rx.h /* packet-rx.h
* Definitions for packet disassembly structures and routines * 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 * Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org> * By Gerald Combs <gerald@zing.org>
@ -56,7 +56,7 @@ struct rx_header {
}; /* serviceId is first, it's really */ }; /* serviceId is first, it's really */
/* encoded _after_ the spare field */ /* encoded _after_ the spare field */
/* I wasted a day figuring that out! */ /* I wasted a day figuring that out! */
#define RX_MAXACKS 255
struct rx_ack_header { struct rx_ack_header {
guint16 bufferspace; /* # of packet buffers available */ guint16 bufferspace; /* # of packet buffers available */
guint16 maxskew; guint16 maxskew;
@ -64,7 +64,8 @@ struct rx_ack_header {
guint32 prevpacket; guint32 prevpacket;
guint32 serial; /* Packet that prompted this one */ guint32 serial; /* Packet that prompted this one */
u_char reason; /* rx_ack_reason */ 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 #define RX_ACK_TYPE_NACK 0
@ -79,5 +80,31 @@ struct rx_ack_header {
#define RX_ACK_PING_RESPONSE 7 #define RX_ACK_PING_RESPONSE 7
#define RX_ACK_DELAY 8 #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 #endif