osmocom
/
wireshark
11
0
Fork 1
Code Issues Pull Requests Projects Releases Wiki Activity

New proto_tree header_field_info stuff. Header_field_infos now contain 

the base for numbers to be displayed in, bitmasks for bitfields, and blurbs
(which are one or two sentences describing the field).

proto_tree_add*() routines now automatically handle bitfields. You tell
it which header field you are adding, and just pass it the value of the
entire field, and the proto_tree routines will do the masking and shifting
for you.

This means that bitfields are more naturally filtered via dfilter now.

Added Phil Techau's support for signed integers in dfilters/proto_tree.

Added the beginning of the SNA dissector. It's not complete, but I'm
committing it now because it has example after example of how to use
bitfields with the new header_field_info struct and proto_tree routines.
It was the impetus to change how header_field_info works.

svn path=/trunk/; revision=815
This commit is contained in:
Gilbert Ramirez 1999-10-12 06:21:15 +00:00
parent 10c4bab8e1
commit bacb9d5bae
39 changed files with 1917 additions and 539 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Makefile.am
View File

@ -1,7 +1,7 @@
# Makefile.am
# Automake file for Ethereal
#
# $Id: Makefile.am,v 1.79 1999/10/11 07:38:21 guy Exp $
# $Id: Makefile.am,v 1.80 1999/10/12 06:19:58 gram Exp $
#
# Ethereal - Network traffic analyzer
# By Gerald Combs <gerald@zing.org>
@ -109,6 +109,7 @@ ethereal_SOURCES = \
packet-rtsp.c \
packet-sdp.c \
packet-smb.c \
packet-sna.c \
packet-tcp.c \
packet-telnet.c\
packet-tftp.c \

11
dfilter-grammar.y
View File

@ -3,7 +3,7 @@
/* dfilter-grammar.y
* Parser for display filters
*
* $Id: dfilter-grammar.y,v 1.28 1999/10/12 05:21:07 gram Exp $
* $Id: dfilter-grammar.y,v 1.29 1999/10/12 06:19:58 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -140,6 +140,9 @@ dfilter *global_df = NULL;
%token <variable> T_FT_UINT8
%token <variable> T_FT_UINT16
%token <variable> T_FT_UINT32
%token <variable> T_FT_INT8
%token <variable> T_FT_INT16
%token <variable> T_FT_INT32
%token <variable> T_FT_ETHER
%token <variable> T_FT_IPv4
%token <variable> T_FT_IPv6
@ -381,6 +384,9 @@ bytes_value: T_VAL_BYTE_STRING
numeric_variable: T_FT_UINT8 { $$ = dfilter_mknode_numeric_variable($1.id); }
| T_FT_UINT16 { $$ = dfilter_mknode_numeric_variable($1.id); }
| T_FT_UINT32 { $$ = dfilter_mknode_numeric_variable($1.id); }
| T_FT_INT8 { $$ = dfilter_mknode_numeric_variable($1.id); }
| T_FT_INT16 { $$ = dfilter_mknode_numeric_variable($1.id); }
| T_FT_INT32 { $$ = dfilter_mknode_numeric_variable($1.id); }
;
ether_variable: T_FT_ETHER { $$ = dfilter_mknode_ether_variable($1.id); }
@ -421,6 +427,9 @@ bytes_variable: any_variable_type T_VAL_BYTE_RANGE
any_variable_type: T_FT_UINT8 { $$ = $1; }
| T_FT_UINT16 { $$ = $1; }
| T_FT_UINT32 { $$ = $1; }
| T_FT_INT8 { $$ = $1; }
| T_FT_INT16 { $$ = $1; }
| T_FT_INT32 { $$ = $1; }
| T_FT_ETHER { $$ = $1; }
| T_FT_IPv4 { $$ = $1; }
| T_FT_IPv6 { $$ = $1; }

19
dfilter-scanner.l
View File

@ -3,7 +3,7 @@
/* dfilter-scanner.l
* Scanner for display filters
*
* $Id: dfilter-scanner.l,v 1.19 1999/10/12 04:21:10 gram Exp $
* $Id: dfilter-scanner.l,v 1.20 1999/10/12 06:19:59 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -88,6 +88,7 @@ static char *in_buffer;
whitespace [\t ]
hex [A-Fa-f0-9]{1,2}
hexsep [-:\.]
minus [-]
%%
@ -177,18 +178,23 @@ le|\<\= { dfilter_lval.operand = TOK_LE; return TOK_LE; }
retval = T_FT_BOOLEAN;
break;
case FT_UINT8:
case FT_VALS_UINT8:
retval = T_FT_UINT8;
break;
case FT_UINT16:
case FT_VALS_UINT16:
retval = T_FT_UINT16;
break;
case FT_UINT32:
case FT_VALS_UINT32:
case FT_VALS_UINT24:
retval = T_FT_UINT32;
break;
case FT_INT8:
retval = T_FT_INT8;
break;
case FT_INT16:
retval = T_FT_INT16;
break;
case FT_INT32:
retval = T_FT_INT32;
break;
case FT_DOUBLE:
dfilter_fail("Sorry, you can't filter on field \"%s\", as we don't yet support filtering on floating-point values.",
yytext);
@ -225,6 +231,7 @@ le|\<\= { dfilter_lval.operand = TOK_LE; return TOK_LE; }
retval = T_FT_IPXNET;
break;
default:
printf("ftype for %s is %d\n", yytext, ftype);
g_assert_not_reached();
retval = 0;
break;
@ -233,7 +240,7 @@ le|\<\= { dfilter_lval.operand = TOK_LE; return TOK_LE; }
return retval;
}
[0-9]+ { /* decimal or octal values */
{minus}?[0-9]+ { /* decimal or octal values */
dfilter_lval.string = g_strdup(yytext);
return T_VAL_NUMBER_STRING;
}

11
doc/dfilter2pod.in
View File

@ -9,14 +9,19 @@
# will be replaced by the pod-formatted glossary
# STDOUT is the output
#
# $Id: dfilter2pod.in,v 1.3 1999/08/03 15:04:33 gram Exp $
# $Id: dfilter2pod.in,v 1.4 1999/10/12 06:21:15 gram Exp $
%ftenum_names = (
'FT_NONE', 'No value',
'FT_BOOLEAN', 'Boolean',
'FT_UINT8', 'Unsigned 8-bit integer',
'FT_UINT16', 'Unsigned 16-bit integer',
'FT_UINT24', 'Unsigned 24-bit integer',
'FT_UINT32', 'Unsigned 32-bit integer',
'FT_INT8', 'Signed 8-bit integer',
'FT_INT16', 'Signed 16-bit integer',
'FT_INT24', 'Signed 24-bit integer',
'FT_INT32', 'Signed 32-bit integer',
'FT_ABSOLUTE_TIME', 'Date/Time stamp',
'FT_RELATIVE_TIME', 'Time duration',
'FT_STRING', 'String',
@ -25,10 +30,6 @@
'FT_IPv4', 'IPv4 address',
'FT_IPv6', 'IPv6 address',
'FT_IPXNET', 'IPX network or server name',
'FT_VALS_UINT8', 'Unsigned 8-bit integer',
'FT_VALS_UINT16', 'Unsigned 16-bit integer',
'FT_VALS_UINT24', 'Unsigned 24-bit integer',
'FT_VALS_UINT32', 'Unsigned 32-bit integer',
'FT_TEXT_ONLY', 'Text-only. Not filterable'
);

385
doc/proto_tree
View File

@ -1,58 +1,56 @@
$Id: proto_tree,v 1.4 1999/08/27 19:27:22 gram Exp $
$Id: proto_tree,v 1.5 1999/10/12 06:21:15 gram Exp $
The Ethereal Protocol Tree
==========================
Up until version 0.6.3 of ethereal, the protocol tree that is displayed
in the middle pane of the ethereal GUI had been created by having the
protocol dissection routines add strings to a GTK+ tree. This GUI
container was not easily manipulated; the print routines had to reach
inside what should be an opaque structure and pull out the data. The
tree of strings also did not lend itself to filtering on the data
available in the tree.
Up until version 0.6.3 of Ethereal, the protocol tree that is displayed
in the middle pane of the Ethereal GUI had been created by having
the protocol dissection routines add strings to a GTK+ tree. This
GUI container was not easily manipulated; the print routines had to
reach inside what should be an opaque GUI structure and pull out the
data. The tree of strings also did not lend itself to filtering on the
data available in the tree.
Mostly to solve the display filter problem, I decided to have the
protocol dissection routines put their data into a logical tree instead
of a GUI tree. This tree structure would provide a generic way for
multiple routines, like the dissection routines, the display filter
routines, and the print routines, to retrieve data about the protocol
fields. The GUI routines would then be modified to draw the GUI tree
based on the data in the logical tree. By structuring this logical tree
well, with well-defined field types, ethereal can have a very powerful
display filter option. No longer would display filters be limited to the
ability of the BPF compiler (libpcap or wiretap), but would have access to the
full range of C field types available within ethereal.
Mostly to solve the display filter problem, I decided to have the protocol
dissection routines put their data into a logical tree instead of a
GUI tree. This tree structure would provide a generic way for multiple
routines, like the dissection routines, the display filter routines,
and the print routines, to retrieve data about the protocol fields. The
GUI routines would then be modified to draw the GUI tree based on the
data in the logical tree. By structuring this logical tree well, with
well-defined field types, Ethereal can have a very powerful display
filter option. No longer would display filters be limited to the ability
of the BPF compiler (libpcap or wiretap), but would have access to the
full range of C field types available within Ethereal.
The dissection routines are still passed a proto_tree pointer, but a
proto_tree is no longer the same as a GtkTree. Now a proto_tree is a
GNode, the N-way tree structure available within GLIB. Of course the
protocol dissectors don't care what a proto_tree really is; they just
pass the proto_tree pointer as an argument to the routines which allow
them to add items and new branches to the tree.
In Ethereal 0.7.6, I decided to extend the information that the
programmer must provide about each field. I was frustrated by the way
in which the original proto_tree code handled bitfields. By providing
a small amount of extra info, bitfields can now be added very easily
to the proto_tree. In addition, filtering on bitfields now works
more naturally.
In packet_list_select_cb() you'll now find this:
The protocol tree, or proto_tree, is a GNode, the N-way tree structure
available within GLIB. Of course the protocol dissectors don't care
what a proto_tree really is; they just pass the proto_tree pointer as an
argument to the routines which allow them to add items and new branches
to the tree.
if (protocol_tree)
proto_tree_free(protocol_tree);
protocol_tree = proto_tree_create_root();
dissect_packet(cf.pd, fd, protocol_tree);
proto_tree_draw(protocol_tree, tree_view);
When a packet is selected in the packet-list pane, a new logical
protocol tree (proto_tree) is created. The pointer to the proto_tree (in
this case, 'protocol tree'), is passed to the top-level protocol
dissector, and then the GUI tree is drawn via proto_tree_draw().
When a packet is selected in the packet-list pane, a new logical protocol
tree (proto_tree) is created. The pointer to the proto_tree (in this
case, 'protocol tree'), is passed to the top-level protocol dissector,
and then to all subsequent protocol dissectors for that packet, and then
the GUI tree is drawn via proto_tree_draw().
Programming for the proto_tree
==============================
The logical proto_tree now needs to know detail information about the
The logical proto_tree needs to know detailed information about the
protocols and fields about which information will be collected from the
dissection routines. No longer will is the data just a bunch of strings.
Now the data will be typed so that searching and filtering on protocol
header fields will be possible. This means that the for every protocol
and field (which I also call "header fields", since they are fields in
the protocol headers) which might be attached to a tree, some
information is needed.
dissection routines. By strictly defining (or "typing") the data that can
be attached to a proto tree, searching and filtering becomes possible.
This means that the for every protocol and field (which I also call
"header fields", since they are fields in the protocol headers) which
might be attached to a tree, some information is needed.
Every dissector routine will need to register its protocols and fields
with the central protocol routines (in proto.c). At first I thought I
@ -89,101 +87,189 @@ Here is how the frame "protocol" is registered.
A header field is also registered with its name and abbreviation, but
information about the its data type is needed. Some fields will use
value_strings to represent their values, so the value_string
is also passed. And of course the parent protocol for the field is indicated
during registration.
information about the its data type is needed. It helps to look at
the header_field_info struct to see what information is expected:
int hf_frame_arrival_time;
struct header_field_info {
char *name;
char *abbrev;
enum ftenum type;
int display;
void *strings;
guint bitmask;
char *blurb;
hf_frame_arrival_time = proto_register_field (
/* name */ "Arrival Time",
/* abbrev */ "frame.time",
/* ftype */ FT_ABSOLUTE_TIME,
/* parent */ proto_frame,
/* vals[] */ NULL );
int id; /* calculated */
int parent;
int bitshift; /* calculated */
};
Groups of header fields can be registered with one call to
proto_register_field_array(). A static array of hf_register_info
structs is declared, then passed to proto_register_field_array, along
with a count of the number of records. Be sure that your array
of hf_register_info structs is declared 'static', since the
proto_register_field_array() function does not create a copy of
the information in the array... it uses that static copy of the
information that the compiler created inside your array. Here's
the layout of the hf_register_info struct:
name
----
A string representing the name of the field. This is the name
that will appear in the graphical protocol tree.
typedef struct hf_register_info {
int *p_id; /* pointer to parent variable */
header_field_info hfinfo;
} hf_register_info;
abbrev
------
A string with an abbreviation of the field. We concatenate the
abbreviation of the parent protocol with an abbreviation for the field,
using a period as a separator. For example, the "src" field in an IP packet
would have "ip.addr" as an abbreviation. It is acceptable to have
multiple levels of periods if, for example, you have fields in your
protocol that are then subdivided into subfields. For example, TRMAC
has multiple error fields, so the abbreviations follow this pattern:
"trmac.errors.iso", "trmac.errors.noniso", etc.
You can use the handy array_length() macro found in packet.h
to have the compiler compute the array length for you at compile time:
The abbreviation is the identifier used in a display filter.
type
----
The type of value this field holds. The current field types are:
FT_NONE,
FT_BOOLEAN,
FT_UINT8,
FT_UINT16,
FT_UINT24,
FT_UINT32,
FT_INT8,
FT_INT16,
FT_INT24,
FT_INT32,
FT_DOUBLE,
FT_ABSOLUTE_TIME,
FT_RELATIVE_TIME,
FT_STRING,
FT_ETHER,
FT_BYTES,
FT_IPv4,
FT_IPv6,
FT_IPXNET
Some of these field types are still not handled in the display filter
routines, but the most common ones are. The FT_UINT* variables all
represent unsigned integers; the number on the end represent how many
bits are used to represent the number.
display
-------
The display field has a couple of overloaded uses. This is unfortunate,
but since we're C as an application programming language, this sometimes
makes for cleaner programs. Right now I still think that overloading
this variable was okay.
For integer fields (FT_UINT*), this variable represents the base in
which you would like the value displayed. The acceptable bases are:
BASE_DEC,
BASE_HEX,
BASE_OCT,
BASE_BIN
For FT_BOOLEAN fields that are also bitfields, 'display' is used
to tell the proto_tree how wide the parent bitfield is. With integers
this is not needed since the type of integer itself (FT_UINT8, FT_UINT16,
FT_UINT24, FT_UINT32) tells the proto_tree how wide the parent bitfield is.
Additionally, BASE_NONE is used for 'display' as a NULL-value. That is,
for non-integers and non-bitfield FT_BOOLEANs, you'll want to use BASE_NONE
in the 'display' field.
It is possible that in the future we will record the endianness of
integers. If so, it is likely that we'll use a bitmask on the display field
so that integers would be represented as BEND|BASE_DEC or LEND|BASE_HEX.
But that has not happened yet.
strings
-------
Some integer fields need labels to represent the true value of a field.
A value_string structure is a way to map values to strings.
typedef struct _value_string {
guint32 value;
gchar *strptr;
} value_string;
For FT_UINT* fields, the 'string' field is a pointer to an array of
such value_string structs. (Note: before Ethereal 0.7.6, we had
separate field types like FT_VALS_UINT8 which denoted the use of value_strings.
Now, the non-NULLness of the pointer lets the proto_tree know that
a value_string is meant for this field).
FT_BOOLEANS have a default map of 0 = "False", 1 (or anything else) = "True".
Sometimes it is useful to change the labels for boolean values (e.g.,
to "Yes"/"No", "Fast"/"Slow", etc.). For these mappings, a struct called
true_false_string is used. (This struct is new as of Ethereal 0.7.6).
typedef struct true_false_string {
char *true_string;
char *false_string;
} true_false_string;
It's two fields are pointers to the string representing truth, and
the string representing falsehood. For FT_BOOLEAN fields that need a
true_false_string struct, the 'strings' field is a pointer to that struct.
bitmask
-------
If the field is not a bitfield, then bitmask should be set to 0.
If it is a bitfield, then the bitmask is the mask which will
leave only the bits needed to make the field when ANDed with a value.
The proto_tree routines will calculate 'bitshift' automatically
from 'bitmask', by finding the first set bit in the bitmask.
blurb
-----
This is a string giving a sentence or two description of the field.
It is meant to provide a more detailed description of the field than the
name alone provides. This information will be used in the man page, and
in a future GUI display-filter creation tool. We might also add tooltips
to the labels in the GUI protocol tree, in which case the blurb would
be used as the tooltip text.
Field Registration
------------------
Protocol registration is handled by creating an instance of the
header_field_info struct (or an arry of such structs), and
calling the registration function along with the registration ID of
the protocol that is the parent of the fields. Here is a complete example:
int proto_eg = -1;
int hf_field_a = -1;
int hf_field_b = -1;
static hf_register_info hf[] = {
{ &hf_field_a,
{ "Field A", "proto.field_a", FT_UINT8, NULL }},
{ "Field A", "proto.field_a", FT_UINT8, BASE_HEX, NULL,
0xf0, "Field A represents Apples" }},
{ &hf_field_b,
{ "Field B", "proto.field_a", FT_VALS_UINT16, VALS(vs) }}
{ "Field B", "proto.field_a", FT_UINT16, BASE_DEC, VALS(vs),
0x0, "Field B represents Bananas" }}
};
proto_tr = proto_register_protocol("Token-Ring", "tr");
proto_register_field_array(proto_tr, hf, array_length(hf));
proto_eg = proto_register_protocol("Example Protocol", "proto");
proto_register_field_array(proto_eg, hf, array_length(hf));
The name can be used in any type of display, either in the GUI tree, or
in a display filter UI. The abbreviation is used when representing a
display filter as a string. For example, the following strings could be a
valid display filter, depending upon the implementation of the display
filter parser and engine.
Be sure that your array of hf_register_info structs is declared 'static',
since the proto_register_field_array() function does not create a copy
of the information in the array... it uses that static copy of the
information that the compiler created inside your array. Here's the
layout of the hf_register_info struct:
frame[20:1] = 0x0a
frame.time > 'May 21, 1999 13:15:00'
typedef struct hf_register_info {
int *p_id; /* pointer to parent variable */
header_field_info hfinfo;
} hf_register_info;
The field type come from an enum. Currently, enum ftenum is comprised
of:
Also be sure to use the handy array_length() macro found in packet.h
to have the compiler compute the array length for you at compile time.
/* field types */
enum ftenum {
FT_NONE, /* used for protocol labels (thus no field type) */
FT_UINT8,
FT_UINT16,
FT_UINT32,
FT_BOOLEAN,
FT_ABSOLUTE_TIME,
FT_RELATIVE_TIME,
FT_STRING,
FT_ETHER,
FT_BYTES,
FT_IPv4,
FT_IPv6,
FT_IPXSERVER,
FT_VALS_UINT8,
FT_VALS_UINT16,
FT_VALS_UINT24,
FT_VALS_UINT32,
FT_TEXT_ONLY, /* used internally, but should be used by dissectors */
NUM_FIELD_TYPES /* last item number plus one */
};
Previously, the sequence needed within a dissector to add a new branch
to the GUI tree was this:
item = proto_tree_add_item(....);
new_tree = proto_tree_new();
proto_item_add_subtree(item, new_tree, tree_type);
With the new system, the call to proto_tree_new() is no longer needed,
as proto_item_add_subtree creates the new tree for you. The change was
necessary so that the proto_tree routines could maintain the
parent/child relationship within the logical tree. But it has a nice
side-effect of cleaning up the dissector code. The new method is like
this:
Adding Items and Values to the Protocol Tree
--------------------------------------------
A protocol item is added to an existing protocol tree with one of a
handful of proto_tree_add_item*() funtions. Subtrees can be made
with the proto_item_add_subtree() function:
item = proto_tree_add_item(....);
new_tree = proto_item_add_subtree(item, tree_type);
@ -204,18 +290,73 @@ protocol or field labels to the proto_tree:
proto_item*
proto_tree_add_text(tree, start, length, format, ...);
proto_tree_add_item()
---------------------
The first function, proto_tree_add_item, is used when you wish to do no
special formatting. The item added to the GUI tree will contain the name
(as passed in the proto_register_*() function) and any value. If your
field does have a value, it is passed after the length variable (notice
the ellipsis in the function prototype).
The second function, proto_tree_add_free_format(), is used when the
Now that the proto_tree has detailed information about bitfield fields,
you an use proto_tree_add_item() with no extra processing to add bitfield
values to your tree. Here's an example. Take the Format Identifer (FID)
field in the Tranmission Header (TH) portion of the SNA protocol. The
FID is the high nibble of the first byte of the TH. The FID would be
registered like this:
name = "Format Identifer"
abbrev = "sna.th.fid"
type = FT_UINT8
display = BASE_HEX
strings = sna_th_fid_vals
bitmask = 0xf0
The bitmask contains the value which would leave only the FID if bitwise-ANDed
against the parent field, the first byte of the TH.
The code to add the FID to the tree would be;
guint8 th_0 = pd[offset];
proto_tree_add_item(bf_tree, hf_sna_th_fid, offset, 1, th_0);
Note: we do not do *any* manipulation of th_0 in order to ge the FID value.
We just pass it to proto_tree_add_item(). The proto_tree already has
the information about bitmasking and bitshifting, so it does the work
of masking and shifting for us! This also means that you no longer
have to crate value_string structs with the values bitshifted. The
value_string for FID looks like this, even though the FID value is
actually contained in the high nibble. (You'd expect the values to be
0x0, 0x10, 0x20, etc.)
/* Format Identifier */
static const value_string sna_th_fid_vals[] = {
{ 0x0, "SNA device <--> Non-SNA Device" },
{ 0x1, "Subarea Node <--> Subarea Node" },
{ 0x2, "Subarea Node <--> PU2" },
{ 0x3, "Subarea Node or SNA host <--> Subarea Node" },
{ 0x4, "?" },
{ 0x5, "?" },
{ 0xf, "Adjaced Subarea Nodes" },
{ 0, NULL }
};
The final implication of this is that display filters work the way you'd
naturally expect them to. You'd type "sna.th.fid == 0xf" to find Adjacent
Subarea Nodes. The user does not have to shift the value of the FID to
the high nibble of the byte ("sna.th.fid == 0xf0") as was necessary
before Ethereal 0.7.6.
proto_tree_add_item_format()
----------------------------
The second function, proto_tree_add_item_format(), is used when the
dissector routines wants complete control over how the field and value
will be represented on the GUI tree. The caller must pass include the
name of the protocol or field; it is not added automatically as in
proto_tree_add_item().
proto_tree_add_item_hidden()
----------------------------
The third function is used to add fields and values to a tree, but not
show them on a GUI tree. The caller may want a value to be included in a
tree so that the packet can be filtered on this field, but the
@ -262,11 +403,13 @@ filter is then possible:
tr.rif_ring eq 0x013
proto_tree_add_text()
---------------------
The fourth function, proto_tree_add_text(), is used to add a label to the GUI tree.
It will contain no value, so it is not searchable in the display filter process.
This function was needed in the transition from the old-style proto_tree to this
new-style proto_tree so that ethereal would still decode all protocols w/o being
new-style proto_tree so that Ethereal would still decode all protocols w/o being
able to filter on all protocols and fields. Otherwise we would have had to
cripple ethereal's functionality while we converted all the old-style proto_tree
cripple Ethereal's functionality while we converted all the old-style proto_tree
calls to the new-style proto_tree calls.

37
packet-aarp.c
View File

@ -1,7 +1,7 @@
/* packet-aarp.c
* Routines for Appletalk ARP packet disassembly
*
* $Id: packet-aarp.c,v 1.10 1999/10/03 15:21:11 deniel Exp $
* $Id: packet-aarp.c,v 1.11 1999/10/12 06:20:00 gram Exp $
*
* Simon Wilkinson <sxw@dcs.ed.ac.uk>
*
@ -183,23 +183,40 @@ proto_register_aarp(void)
{
static hf_register_info hf[] = {
{ &hf_aarp_hard_type,
{ "Hardware type", "aarp.hard.type", FT_UINT16, NULL }},
{ "Hardware type", "aarp.hard.type", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_aarp_proto_type,
{ "Protocol type", "aarp.proto.type", FT_UINT16, NULL }},
{ "Protocol type", "aarp.proto.type", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_aarp_hard_size,
{ "Hardware size", "aarp.hard.size", FT_UINT8, NULL }},
{ "Hardware size", "aarp.hard.size", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_aarp_proto_size,
{ "Protocol size", "aarp.proto.size", FT_UINT8, NULL }},
{ "Protocol size", "aarp.proto.size", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_aarp_opcode,
{ "Opcode", "aarp.opcode", FT_UINT16, NULL }},
{ "Opcode", "aarp.opcode", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_aarp_src_ether,
{ "Sender ether", "aarp.src.ether", FT_ETHER, NULL }},
{ "Sender ether", "aarp.src.ether", FT_ETHER, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_aarp_src_id,
{ "Sender ID", "aarp.src.id", FT_UINT32, NULL }},
{ "Sender ID", "aarp.src.id", FT_UINT32, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_aarp_dst_ether,
{ "Target ether", "aarp.dst.ether", FT_ETHER, NULL }},
{ "Target ether", "aarp.dst.ether", FT_ETHER, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_aarp_dst_id,
{ "Target ID", "aarp.dst.id", FT_UINT32, NULL }}
{ "Target ID", "aarp.dst.id", FT_UINT32, BASE_HEX, NULL, 0x0,
"" }},
};
proto_aarp = proto_register_protocol("Appletalk Address Resolution Protocol",

37
packet-arp.c
View File

@ -1,7 +1,7 @@
/* packet-arp.c
* Routines for ARP packet disassembly
*
* $Id: packet-arp.c,v 1.18 1999/10/03 17:12:15 deniel Exp $
* $Id: packet-arp.c,v 1.19 1999/10/12 06:20:01 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -297,23 +297,40 @@ proto_register_arp(void)
{
static hf_register_info hf[] = {
{ &hf_arp_hard_type,
{ "Hardware type", "arp.hw.type", FT_UINT16, NULL }},
{ "Hardware type", "arp.hw.type", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_arp_proto_type,
{ "Protocol type", "arp.proto.type",FT_UINT16, NULL }},
{ "Protocol type", "arp.proto.type",FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_arp_hard_size,
{ "Hardware size", "arp.hw.size", FT_UINT8, NULL }},
{ "Hardware size", "arp.hw.size", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_arp_proto_size,
{ "Protocol size", "arp.proto.size",FT_UINT8, NULL }},
{ "Protocol size", "arp.proto.size",FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_arp_opcode,
{ "Opcode", "arp.opcode", FT_UINT16, NULL }},
{ "Opcode", "arp.opcode", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_arp_src_ether,
{ "Sender hardware address", "arp.src.hw", FT_BYTES, NULL }},
{ "Sender hardware address", "arp.src.hw", FT_BYTES, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_arp_src_proto,
{ "Sender protocol address", "arp.src.proto", FT_BYTES, NULL }},
{ "Sender protocol address", "arp.src.proto", FT_BYTES, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_arp_dst_ether,
{ "Target hardware address", "arp.dst.hw", FT_BYTES, NULL }},
{ "Target hardware address", "arp.dst.hw", FT_BYTES, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_arp_dst_proto,
{ "Target protocol address", "arp.dst.proto", FT_BYTES, NULL }}
{ "Target protocol address", "arp.dst.proto", FT_BYTES, BASE_NONE, NULL, 0x0,
"" }}
};
proto_arp = proto_register_protocol("Address Resolution Protocol", "arp");

11
packet-ascend.c
View File

@ -1,7 +1,7 @@
/* packet-ascend.c
* Routines for decoding Lucent/Ascend packet traces
*
* $Id: packet-ascend.c,v 1.4 1999/09/13 03:48:58 gerald Exp $
* $Id: packet-ascend.c,v 1.5 1999/10/12 06:20:01 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -110,13 +110,16 @@ proto_register_ascend(void)
{
static hf_register_info hf[] = {
{ &hf_session_id,
{ "Session ID", "ascend.sess", FT_UINT32, NULL }},
{ "Session ID", "ascend.sess", FT_UINT32, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_chunk,
{ "WDD Chunk", "ascend.chunk", FT_UINT32, NULL }},
{ "WDD Chunk", "ascend.chunk", FT_UINT32, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_task,
{ "Task", "ascend.task", FT_UINT32, NULL }}
{ "Task", "ascend.task", FT_UINT32, BASE_DEC, NULL, 0x0,
"" }},
};
proto_ascend = proto_register_protocol("Lucent/Ascend debug output", "ascend");

41
packet-atalk.c
View File

@ -1,7 +1,7 @@
/* packet-ddp.c
* Routines for DDP packet disassembly.
*
* $Id: packet-atalk.c,v 1.14 1999/10/07 17:11:11 deniel Exp $
* $Id: packet-atalk.c,v 1.15 1999/10/12 06:20:02 gram Exp $
*
* Simon Wilkinson <sxw@dcs.ed.ac.uk>
*
@ -135,25 +135,44 @@ proto_register_atalk(void)
{
static hf_register_info hf[] = {
{ &hf_ddp_hopcount,
{ "Hop count", "ddp.hopcount", FT_UINT8, NULL }},
{ "Hop count", "ddp.hopcount", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_ddp_len,
{ "Datagram length", "ddp.len", FT_UINT16, NULL }},
{ "Datagram length", "ddp.len", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_ddp_checksum,
{ "Checksum", "ddp.checksum", FT_UINT16, NULL }},
{ "Checksum", "ddp.checksum", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_ddp_dst_net,
{ "Destination Net", "ddp.dst.net", FT_UINT16, NULL }},
{ "Destination Net", "ddp.dst.net", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_ddp_src_net,
{ "Source Net", "ddp.src.net", FT_UINT16, NULL }},
{ "Source Net", "ddp.src.net", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_ddp_dst_node,
{ "Destination Node", "ddp.dst.node", FT_UINT8, NULL }},
{ "Destination Node", "ddp.dst.node", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_ddp_src_node,
{ "Source Node", "ddp.src.node", FT_UINT8, NULL }},
{ "Source Node", "ddp.src.node", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_ddp_dst_socket,
{ "Destination Socket", "ddp.dst.socket", FT_UINT8, NULL }},
{ "Destination Socket", "ddp.dst.socket", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_ddp_src_socket,
{ "Source Socket", "ddp.src.socket", FT_UINT8, NULL }},
{ "Source Socket", "ddp.src.socket", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_ddp_type,
{ "Protocol type", "ddp.type", FT_UINT8, NULL }}
{ "Protocol type", "ddp.type", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
};
proto_ddp = proto_register_protocol("Datagram Delivery Protocol", "ddp");

68
packet-bootp.c
View File

@ -2,7 +2,7 @@
* Routines for BOOTP/DHCP packet disassembly
* Gilbert Ramirez <gram@verdict.uthscsa.edu>
*
* $Id: packet-bootp.c,v 1.20 1999/10/08 13:57:31 deniel Exp $
* $Id: packet-bootp.c,v 1.21 1999/10/12 06:20:02 gram Exp $
*
* The information used comes from:
* RFC 2132: DHCP Options and BOOTP Vendor Extensions
@ -488,11 +488,8 @@ dissect_bootp(const u_char *pd, int offset, frame_data *fd, proto_tree *tree)
offset + 2, 1, pd[offset+2]);
proto_tree_add_item(bp_tree, hf_bootp_hops,
offset + 3, 1, pd[offset+3]);
proto_tree_add_item_format(bp_tree, hf_bootp_id,
offset + 4, 4,
pntohl(&pd[offset+4]),
"Transaction ID: 0x%08x",
pntohl(&pd[offset+4]));
proto_tree_add_item(bp_tree, hf_bootp_id,
offset + 4, 4, pntohl(&pd[offset+4]));
proto_tree_add_item(bp_tree, hf_bootp_secs,
offset + 8, 2, pntohs(&pd[offset+8]));
proto_tree_add_item(bp_tree, hf_bootp_flag,
@ -574,35 +571,64 @@ proto_register_bootp(void)
{
static hf_register_info hf[] = {
{ &hf_bootp_type,
{ "Message type", "bootp.type", FT_UINT8, NULL }},
{ "Message type", "bootp.type", FT_UINT8, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_bootp_hw_type,
{ "Hardware type", "bootp.hw.type", FT_UINT8, NULL }},
{ "Hardware type", "bootp.hw.type", FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_bootp_hw_len,
{ "Hardware address length", "bootp.hw.len", FT_UINT8, NULL }},
{ "Hardware address length", "bootp.hw.len", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_bootp_hops,
{ "Hops", "bootp.hops", FT_UINT8, NULL }},
{ "Hops", "bootp.hops", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_bootp_id,
{ "Transaction ID", "bootp.id", FT_UINT32, NULL }},
{ "Transaction ID", "bootp.id", FT_UINT32, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_bootp_secs,
{ "Seconds elapsed", "bootp.secs", FT_UINT16, NULL }},
{ "Seconds elapsed", "bootp.secs", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_bootp_flag,
{ "Broadcast flag", "bootp.flag", FT_UINT16, NULL }},
{ "Broadcast flag", "bootp.flag", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_bootp_ip_client,
{ "Client IP address", "bootp.ip.client",FT_IPv4, NULL }},
{ "Client IP address", "bootp.ip.client",FT_IPv4, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_bootp_ip_your,
{ "Your (client) IP address", "bootp.ip.your", FT_IPv4, NULL }},
{ "Your (client) IP address", "bootp.ip.your", FT_IPv4, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_bootp_ip_server,
{ "Next server IP address", "bootp.ip.server",FT_IPv4, NULL }},
{ "Next server IP address", "bootp.ip.server",FT_IPv4, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_bootp_ip_relay,
{ "Relay agent IP address", "bootp.ip.relay", FT_IPv4, NULL }},
{ "Relay agent IP address", "bootp.ip.relay", FT_IPv4, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_bootp_hw_addr,
{ "Client hardware address", "bootp.hw.addr", FT_BYTES, NULL }},
{ "Client hardware address", "bootp.hw.addr", FT_BYTES, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_bootp_server,
{ "Server host name", "bootp.server", FT_STRING, NULL }},
{ "Server host name", "bootp.server", FT_STRING, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_bootp_file,
{ "Boot file name", "bootp.file", FT_STRING, NULL }},
{ "Boot file name", "bootp.file", FT_STRING, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_bootp_cookie,
{ "Magic cookie", "bootp.cookie", FT_IPv4, NULL }}
{ "Magic cookie", "bootp.cookie", FT_IPv4, BASE_NONE, NULL, 0x0,
"" }},
};
proto_bootp = proto_register_protocol("Bootstrap Protocol", "bootp");

38
packet-bpdu.c
View File

@ -1,7 +1,7 @@
/* packet-bpdu.c
* Routines for BPDU (Spanning Tree Protocol) disassembly
*
* $Id: packet-bpdu.c,v 1.3 1999/10/09 13:05:55 deniel Exp $
* $Id: packet-bpdu.c,v 1.4 1999/10/12 06:20:03 gram Exp $
*
* Copyright 1999 Christophe Tronche <ch.tronche@computer.org>
*
@ -212,29 +212,41 @@ proto_register_bpdu(void)
static hf_register_info hf[] = {
{ &hf_bpdu_proto_id,
{ "Protocol Identifier", "stp.protocol", FT_UINT16, NULL }},
{ "Protocol Identifier", "stp.protocol", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_bpdu_version_id,
{ "Protocol Version Identifier", "stp.version", FT_UINT8, NULL }},
{ "Protocol Version Identifier", "stp.version", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_bpdu_type,
{ "BPDU type", "stp.type", FT_UINT8, NULL }},
{ "BPDU type", "stp.type", FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_bpdu_flags,
{ "BPDU flags", "stp.flags", FT_UINT8, NULL }},
{ "BPDU flags", "stp.flags", FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_bpdu_root_mac,
{ "Root Identifier", "stp.root.hw", FT_ETHER, NULL }},
{ "Root Identifier", "stp.root.hw", FT_ETHER, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_bpdu_root_cost,
{ "Root Path Cost", "stp.root.cost", FT_UINT32, NULL }},
{ "Root Path Cost", "stp.root.cost", FT_UINT32, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_bpdu_bridge_mac,
{ "Bridge Identifier", "stp.bridge.hw", FT_ETHER, NULL }},
{ "Bridge Identifier", "stp.bridge.hw", FT_ETHER, BASE_NONE, NULL, 0x0,
""}},
{ &hf_bpdu_port_id,
{ "Port identifier", "stp.port", FT_UINT16, NULL }},
{ "Port identifier", "stp.port", FT_UINT16, BASE_HEX, NULL, 0x0,
""}},
{ &hf_bpdu_msg_age,
{ "Message Age", "stp.msg_age", FT_DOUBLE, NULL }},
{ "Message Age", "stp.msg_age", FT_DOUBLE, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_bpdu_max_age,
{ "Max Age", "stp.max_age", FT_DOUBLE, NULL }},
{ "Max Age", "stp.max_age", FT_DOUBLE, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_bpdu_hello_time,
{ "Hello Time", "stp.hello", FT_DOUBLE, NULL }},
{ "Hello Time", "stp.hello", FT_DOUBLE, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_bpdu_forward_delay,
{ "Forward Delay", "stp.forward", FT_DOUBLE, NULL }}
{ "Forward Delay", "stp.forward", FT_DOUBLE, BASE_NONE, NULL, 0x0,
"" }},
};
proto_bpdu = proto_register_protocol("Spanning Tree Protocol", "stp");

8
packet-cdp.c
View File

@ -2,7 +2,7 @@
* Routines for the disassembly of the "Cisco Discovery Protocol"
* (c) Copyright Hannes R. Boehm <hannes@boehm.org>
*
* $Id: packet-cdp.c,v 1.14 1999/09/17 05:56:53 guy Exp $
* $Id: packet-cdp.c,v 1.15 1999/10/12 06:20:03 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -280,10 +280,12 @@ proto_register_cdp(void)
{
static hf_register_info hf[] = {
{ &hf_cdp_tlvtype,
{ "Type", "cdp.tlv.type", FT_VALS_UINT16, VALS(type_vals) }},
{ "Type", "cdp.tlv.type", FT_UINT16, BASE_HEX, VALS(type_vals), 0x0,
"" }},
{ &hf_cdp_tlvlength,
{ "Length", "cdp.tlv.len", FT_UINT16, NULL }},
{ "Length", "cdp.tlv.len", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
};
proto_cdp = proto_register_protocol("Cisco Discovery Protocol", "cdp");

14
packet-eth.c
View File

@ -1,7 +1,7 @@
/* packet-eth.c
* Routines for ethernet packet disassembly
*
* $Id: packet-eth.c,v 1.19 1999/09/15 06:26:42 gram Exp $
* $Id: packet-eth.c,v 1.20 1999/10/12 06:20:04 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -215,17 +215,21 @@ proto_register_eth(void)
static hf_register_info hf[] = {
{ &hf_eth_dst,
{ "Destination", "eth.dst", FT_ETHER, NULL }},
{ "Destination", "eth.dst", FT_ETHER, BASE_NONE, NULL, 0x0,
"Destination Hardware Address" }},
{ &hf_eth_src,
{ "Source", "eth.src", FT_ETHER, NULL }},
{ "Source", "eth.src", FT_ETHER, BASE_NONE, NULL, 0x0,
"Source Hardware Address" }},
{ &hf_eth_len,
{ "Length", "eth.len", FT_UINT16, NULL }},
{ "Length", "eth.len", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
/* registered here but handled in ethertype.c */
{ &hf_eth_type,
{ "Type", "eth.type", FT_VALS_UINT16, VALS(etype_vals) }}
{ "Type", "eth.type", FT_UINT16, BASE_HEX, VALS(etype_vals), 0x0,
"" }}
};
proto_eth = proto_register_protocol ("Ethernet", "eth" );

11
packet-fddi.c
View File

@ -3,7 +3,7 @@
*
* Laurent Deniel <deniel@worldnet.fr>
*
* $Id: packet-fddi.c,v 1.21 1999/09/10 04:53:14 guy Exp $
* $Id: packet-fddi.c,v 1.22 1999/10/12 06:20:05 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -348,13 +348,16 @@ proto_register_fddi(void)
* NULL, just show the hex value, else show the string.
*/
{ &hf_fddi_fc,
{ "Frame Control", "fddi.fc", FT_UINT8, NULL }},
{ "Frame Control", "fddi.fc", FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_fddi_dst,
{ "Destination", "fddi.dst", FT_ETHER, NULL }},
{ "Destination", "fddi.dst", FT_ETHER, BASE_NONE, NULL, 0x0,
"Destination Hardware Address" }},
{ &hf_fddi_src,
{ "Source", "fddi.src", FT_ETHER, NULL }},
{ "Source", "fddi.src", FT_ETHER, BASE_NONE, NULL, 0x0,
"" }},
};
proto_fddi = proto_register_protocol ("Fiber Distributed Data Interface", "fddi" );

25
packet-ftp.c
View File

@ -2,7 +2,7 @@
* Routines for ftp packet dissection
* Copyright 1999, Richard Sharpe <rsharpe@ns.aus.com>
*
* $Id: packet-ftp.c,v 1.8 1999/10/09 11:56:15 deniel Exp $
* $Id: packet-ftp.c,v 1.9 1999/10/12 06:20:05 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@unicom.net>
@ -162,17 +162,28 @@ proto_register_ftp(void)
{
static hf_register_info hf[] = {
{ &hf_ftp_response,
{ "Response", "ftp.response", FT_BOOLEAN, NULL }},
{ "Response", "ftp.response", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_ftp_request,
{ "Request", "ftp.request", FT_BOOLEAN, NULL }},
{ "Request", "ftp.request", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_ftp_request_command,
{ "Request command", "ftp.request.command", FT_STRING, NULL }},
{ "Request command", "ftp.request.command", FT_STRING, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_ftp_request_data,
{ "Request data", "ftp.request.data", FT_STRING, NULL }},
{ "Request data", "ftp.request.data", FT_STRING, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_ftp_response_code,
{ "Response code", "ftp.response.code", FT_UINT8, NULL }},
{ "Response code", "ftp.response.code", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_ftp_response_data,
{ "Response data", "ftp.reponse.data", FT_STRING, NULL }}
{ "Response data", "ftp.reponse.data", FT_STRING, BASE_NONE, NULL, 0x0,
"" }}
};
proto_ftp = proto_register_protocol("File Transfer Protocol", "ftp");

8
packet-giop.c
View File

@ -3,7 +3,7 @@
*
* Laurent Deniel <deniel@worldnet.fr>
*
* $Id: packet-giop.c,v 1.7 1999/10/09 13:31:30 deniel Exp $
* $Id: packet-giop.c,v 1.8 1999/10/12 06:20:05 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -709,9 +709,11 @@ proto_register_giop(void)
{
static hf_register_info hf[] = {
{ &hf_giop_message_type,
{ "Message type", "giop.type", FT_UINT8, NULL }},
{ "Message type", "giop.type", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_giop_message_size,
{ "Message size", "giop.len", FT_UINT32, NULL }}
{ "Message size", "giop.len", FT_UINT32, BASE_DEC, NULL, 0x0,
"" }},
};
proto_giop = proto_register_protocol("General Inter-ORB Protocol", "giop");

11
packet-icmpv6.c
View File

@ -1,7 +1,7 @@
/* packet-icmpv6.c
* Routines for ICMPv6 packet disassembly
*
* $Id: packet-icmpv6.c,v 1.8 1999/10/10 16:09:33 deniel Exp $
* $Id: packet-icmpv6.c,v 1.9 1999/10/12 06:20:07 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -578,11 +578,14 @@ proto_register_icmpv6(void)
{
static hf_register_info hf[] = {
{ &hf_icmpv6_type,
{ "Type", "icmpv6.type", FT_UINT8, NULL }},
{ "Type", "icmpv6.type", FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_icmpv6_code,
{ "Code", "icmpv6.code", FT_UINT8, NULL }},
{ "Code", "icmpv6.code", FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_icmpv6_checksum,
{ "Checksum", "icmpv6.checksum", FT_UINT16, NULL }}
{ "Checksum", "icmpv6.checksum", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }}
};
proto_icmpv6 = proto_register_protocol("Internet Control Message Protocol v6",

18
packet-icp.c
View File

@ -2,7 +2,7 @@
* Routines for ICP (internet cache protocol) packet disassembly RFC 2186 && RFC 2187
*
*
* $Id: packet-icp.c,v 1.1 1999/09/14 08:06:24 guy Exp $
* $Id: packet-icp.c,v 1.2 1999/10/12 06:20:07 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Peter Torvals
@ -260,13 +260,21 @@ proto_register_icp(void)
{
static hf_register_info hf[] = {
{ &hf_icp_opcode,
{ "Opcode","icp.opcode", FT_UINT8, NULL }},
{ "Opcode","icp.opcode", FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_icp_version,
{ "Version", "icp.version", FT_UINT8, NULL }},
{ "Version", "icp.version", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_icp_length,
{ "Length","icp.length", FT_UINT16, NULL }},
{ "Length","icp.length", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_icp_request_nr,
{ "Request Number","icp.nr", FT_UINT32, NULL }} };
{ "Request Number","icp.nr", FT_UINT32, BASE_DEC, NULL, 0x0,
"" }},
};
proto_icp = proto_register_protocol ("Internet Cache protocol", "icp");
proto_register_field_array(proto_icp, hf, array_length(hf));

71
packet-ip.c
View File

@ -1,7 +1,7 @@
/* packet-ip.c
* Routines for IP and miscellaneous IP protocol packet disassembly
*
* $Id: packet-ip.c,v 1.50 1999/10/02 16:21:07 deniel Exp $
* $Id: packet-ip.c,v 1.51 1999/10/12 06:20:08 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -1191,19 +1191,24 @@ proto_register_igmp(void)
static hf_register_info hf[] = {
{ &hf_igmp_version,
{ "Version", "igmp.version", FT_UINT8, NULL }},
{ "Version", "igmp.version", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_igmp_type,
{ "Type", "igmp.type", FT_UINT8, NULL }},
{ "Type", "igmp.type", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_igmp_unused,
{ "Unused", "igmp.unused", FT_UINT8, NULL }},
{ "Unused", "igmp.unused", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_igmp_checksum,
{ "Checksum", "igmp.checksum", FT_UINT16, NULL }},
{ "Checksum", "igmp.checksum", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_igmp_group,
{ "Group address", "igmp.group", FT_IPv4, NULL }}
{ "Group address", "igmp.group", FT_IPv4, BASE_NONE, NULL, 0x0,
"" }},
};
proto_igmp = proto_register_protocol ("Internet Group Management Protocol", "igmp");
@ -1216,46 +1221,61 @@ proto_register_ip(void)
static hf_register_info hf[] = {
{ &hf_ip_version,
{ "Version", "ip.version", FT_UINT8, NULL }},
{ "Version", "ip.version", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_ip_hdr_len,
{ "Header Length", "ip.hdr_len", FT_UINT8, NULL }},
{ "Header Length", "ip.hdr_len", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_ip_tos,
{ "Type of Service", "ip.tos", FT_UINT8, NULL }},
{ "Type of Service", "ip.tos", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_ip_tos_precedence,
{ "Precedence", "ip.tos.precedence", FT_VALS_UINT8, VALS(precedence_vals) }},
{ "Precedence", "ip.tos.precedence", FT_UINT8, BASE_DEC, VALS(precedence_vals),
0x0,
"" }},
{ &hf_ip_len,
{ "Total Length", "ip.len", FT_UINT16 }},
{ "Total Length", "ip.len", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_ip_id,
{ "Identification", "ip.id", FT_UINT32 }},
{ "Identification", "ip.id", FT_UINT32, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_ip_dst,
{ "Destination", "ip.dst", FT_IPv4, NULL }},
{ "Destination", "ip.dst", FT_IPv4, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_ip_src,
{ "Source", "ip.src", FT_IPv4, NULL }},
{ "Source", "ip.src", FT_IPv4, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_ip_addr,
{ "Source or Destination Address", "ip.addr", FT_IPv4, NULL }},
{ "Source or Destination Address", "ip.addr", FT_IPv4, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_ip_flags,
{ "Flags", "ip.flags", FT_UINT8, NULL }},
{ "Flags", "ip.flags", FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_ip_frag_offset,
{ "Fragment offset", "ip.frag_offset", FT_UINT16, NULL }},
{ "Fragment offset", "ip.frag_offset", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_ip_ttl,
{ "Time to live", "ip.ttl", FT_UINT8, NULL }},
{ "Time to live", "ip.ttl", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_ip_proto,
{ "Protocol", "ip.proto", FT_VALS_UINT8, VALS(proto_vals) }},
{ "Protocol", "ip.proto", FT_UINT8, BASE_HEX, VALS(proto_vals), 0x0,
"" }},
{ &hf_ip_checksum,
{ "Header checksum", "ip.checksum", FT_UINT16, NULL }}
{ "Header checksum", "ip.checksum", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
};
proto_ip = proto_register_protocol ("Internet Protocol", "ip");
@ -1268,11 +1288,16 @@ proto_register_icmp(void)
static hf_register_info hf[] = {
{ &hf_icmp_type,
{ "Type", "icmp.type", FT_UINT8, NULL }},
{ "Type", "icmp.type", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_icmp_code,
{ "Code", "icmp.code", FT_UINT8, NULL }},
{ "Code", "icmp.code", FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_icmp_checksum,
{ "Checksum", "icmp.checksum", FT_UINT16, NULL }}
{ "Checksum", "icmp.checksum", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
};
proto_icmp = proto_register_protocol ("Internet Control Message Protocol",

14
packet-ipsec.c
View File

@ -1,7 +1,7 @@
/* packet-ipsec.c
* Routines for IPsec packet disassembly
*
* $Id: packet-ipsec.c,v 1.4 1999/10/11 12:37:50 deniel Exp $
* $Id: packet-ipsec.c,v 1.5 1999/10/12 06:20:09 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -162,16 +162,20 @@ proto_register_ipsec(void)
static hf_register_info hf_ah[] = {
{ &hf_ah_spi,
{ "SPI", "ah.spi", FT_UINT32, NULL }},
{ "SPI", "ah.spi", FT_UINT32, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_ah_sequence,
{ "Sequence", "ah.sequence", FT_UINT32, NULL }}
{ "Sequence", "ah.sequence", FT_UINT32, BASE_HEX, NULL, 0x0,
"" }}
};
static hf_register_info hf_esp[] = {
{ &hf_esp_spi,
{ "SPI", "esp.spi", FT_UINT32, NULL }},
{ "SPI", "esp.spi", FT_UINT32, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_esp_sequence,
{ "Sequence", "esp.sequence", FT_UINT32, NULL }}
{ "Sequence", "esp.sequence", FT_UINT32, BASE_HEX, NULL, 0x0,
"" }}
};
proto_ah = proto_register_protocol("Authentication Header", "ah");

8
packet-ipv6.c
View File

@ -1,7 +1,7 @@
/* packet-ipv6.c
* Routines for IPv6 packet disassembly
*
* $Id: packet-ipv6.c,v 1.14 1999/10/11 17:05:49 deniel Exp $
* $Id: packet-ipv6.c,v 1.15 1999/10/12 06:20:09 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -414,9 +414,11 @@ proto_register_ipv6(void)
{
static hf_register_info hf[] = {
{ &hf_ipv6_src,
{ "Source", "ipv6.src", FT_IPv6, NULL }},
{ "Source", "ipv6.src", FT_IPv6, BASE_NONE, NULL, 0x0,
"Source IPv6 Address" }},
{ &hf_ipv6_dst,
{ "Destination", "ipv6.dst", FT_IPv6, NULL }}
{ "Destination", "ipv6.dst", FT_IPv6, BASE_NONE, NULL, 0x0,
"Destination IPv6 Address" }}
};
proto_ipv6 = proto_register_protocol("Internet Protocol Version 6", "ipv6");

36
packet-ipx.c
View File

@ -2,7 +2,7 @@
* Routines for NetWare's IPX
* Gilbert Ramirez <gram@verdict.uthscsa.edu>
*
* $Id: packet-ipx.c,v 1.27 1999/09/15 22:33:17 gram Exp $
* $Id: packet-ipx.c,v 1.28 1999/10/12 06:20:10 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@unicom.net>
@ -285,8 +285,7 @@ dissect_ipx(const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
ti = proto_tree_add_item(tree, proto_ipx, offset, 30, NULL);
ipx_tree = proto_item_add_subtree(ti, ETT_IPX);
proto_tree_add_item_format(ipx_tree, hf_ipx_checksum, offset, 2, ipx_checksum,
"Checksum: 0x%04x", ipx_checksum);
proto_tree_add_item(ipx_tree, hf_ipx_checksum, offset, 2, ipx_checksum);
proto_tree_add_item_format(ipx_tree, hf_ipx_len, offset+2, 2, ipx_length,
"Length: %d bytes", ipx_length);
proto_tree_add_item_format(ipx_tree, hf_ipx_hops, offset+4, 1, ipx_hops,
@ -631,34 +630,45 @@ proto_register_ipx(void)
{
static hf_register_info hf_ipx[] = {
{ &hf_ipx_checksum,
{ "Checksum", "ipx.checksum", FT_UINT16, NULL }},
{ "Checksum", "ipx.checksum", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_ipx_len,
{ "Length", "ipx.len", FT_UINT16, NULL }},
{ "Length", "ipx.len", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_ipx_hops,
{ "Transport Control (Hops)", "ipx.hops", FT_UINT8, NULL }},
{ "Transport Control (Hops)", "ipx.hops", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_ipx_packet_type,
{ "Packet Type", "ipx.packet_type", FT_VALS_UINT8, VALS(ipx_packet_type_vals) }},
{ "Packet Type", "ipx.packet_type", FT_UINT8, BASE_HEX, VALS(ipx_packet_type_vals),
0x0,
"" }},
{ &hf_ipx_dnet,
{ "Destination Network","ipx.dstnet", FT_IPXNET, NULL }},
{ "Destination Network","ipx.dst.net", FT_IPXNET, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_ipx_dnode,
{ "Destination Node", "ipx.dstnode", FT_ETHER, NULL }},
{ "Destination Node", "ipx.dst.node", FT_ETHER, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_ipx_dsocket,
{ "Destination Socket", "ipx.dstsocket", FT_UINT16, NULL }},
{ "Destination Socket", "ipx.dst.socket", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_ipx_snet,
{ "Source Network","ipx.srcnet", FT_IPXNET, NULL }},
{ "Source Network","ipx.src.net", FT_IPXNET, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_ipx_snode,
{ "Source Node", "ipx.srcnode", FT_ETHER, NULL }},
{ "Source Node", "ipx.src.node", FT_ETHER, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_ipx_ssocket,
{ "Source Socket", "ipx.srcsocket", FT_UINT16, NULL }},
{ "Source Socket", "ipx.src.socket", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
};
proto_ipx = proto_register_protocol ("Internetwork Packet eXchange", "ipx");

9
packet-lapb.c
View File

@ -2,7 +2,7 @@
* Routines for lapb frame disassembly
* Olivier Abad <abad@daba.dhis.org>
*
* $Id: packet-lapb.c,v 1.5 1999/09/12 18:37:01 guy Exp $
* $Id: packet-lapb.c,v 1.6 1999/10/12 06:20:11 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -105,9 +105,12 @@ proto_register_lapb(void)
{
static hf_register_info hf[] = {
{ &hf_lapb_address,
{ "Address Field", "lapb.address", FT_UINT8, NULL} },
{ "Address Field", "lapb.address", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_lapb_control,
{ "Control Field", "lapb.control", FT_STRING, NULL} },
{ "Control Field", "lapb.control", FT_STRING, BASE_NONE, NULL, 0x0,
"" }},
};
proto_lapb = proto_register_protocol ("LAPB", "lapb");

19
packet-llc.c
View File

@ -2,7 +2,7 @@
* Routines for IEEE 802.2 LLC layer
* Gilbert Ramirez <gramirez@tivoli.com>
*
* $Id: packet-llc.c,v 1.25 1999/10/08 20:50:38 guy Exp $
* $Id: packet-llc.c,v 1.26 1999/10/12 06:20:11 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@unicom.net>
@ -85,7 +85,7 @@ static struct sap_info saps[] = {
{ 0x00, NULL, NULL },
{ 0x02, NULL, NULL },
{ 0x03, NULL, NULL },
{ 0x04, NULL, NULL },
{ 0x04, NULL, dissect_sna },
{ 0x05, NULL, NULL },
{ 0x06, capture_ip, dissect_ip },
{ 0x08, NULL, NULL },
@ -322,20 +322,25 @@ proto_register_llc(void)
{
static hf_register_info hf[] = {
{ &hf_llc_dsap,
{ "DSAP", "llc.dsap", FT_VALS_UINT8, VALS(sap_vals) }},
{ "DSAP", "llc.dsap", FT_UINT8, BASE_HEX, VALS(sap_vals), 0x0,
"" }},
{ &hf_llc_ssap,
{ "SSAP", "llc.ssap", FT_VALS_UINT8, VALS(sap_vals) }},
{ "SSAP", "llc.ssap", FT_UINT8, BASE_HEX, VALS(sap_vals), 0x0,
"" }},
{ &hf_llc_ctrl,
{ "Control", "llc.control", FT_VALS_UINT8, VALS(llc_ctrl_vals) }},
{ "Control", "llc.control", FT_UINT8, BASE_HEX, VALS(llc_ctrl_vals), 0x0,
"" }},
/* registered here but handled in ethertype.c */
{ &hf_llc_type,
{ "Type", "llc.type", FT_VALS_UINT16, VALS(etype_vals) }},
{ "Type", "llc.type", FT_UINT16, BASE_HEX, VALS(etype_vals), 0x0,
"" }},
{ &hf_llc_oui,
{ "Organization Code", "llc.oui", FT_VALS_UINT24, VALS(llc_oui_vals) }}
{ "Organization Code", "llc.oui", FT_UINT24, BASE_HEX, VALS(llc_oui_vals), 0x0,
""}}
};
proto_llc = proto_register_protocol ("Logical-Link Control", "llc" );

8
packet-null.c
View File

@ -1,7 +1,7 @@
/* packet-null.c
* Routines for null packet disassembly
*
* $Id: packet-null.c,v 1.15 1999/08/24 17:26:13 gram Exp $
* $Id: packet-null.c,v 1.16 1999/10/12 06:20:12 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -311,10 +311,12 @@ proto_register_null(void)
/* registered here but handled in ethertype.c */
{ &hf_null_etype,
{ "Type", "null.type", FT_VALS_UINT16, VALS(etype_vals) }},
{ "Type", "null.type", FT_UINT16, BASE_HEX, VALS(etype_vals), 0x0,
"" }},
{ &hf_null_family,
{ "Family", "null.family", FT_VALS_UINT32, VALS(family_vals) }}
{ "Family", "null.family", FT_UINT32, BASE_HEX, VALS(family_vals), 0x0,
"" }}
};
proto_null = proto_register_protocol ("Null/Loopback", "null" );

45
packet-osi.c
View File

@ -1,7 +1,7 @@
/* packet-osi.c
* Routines for ISO/OSI network and transport protocol packet disassembly
*
* $Id: packet-osi.c,v 1.10 1999/09/18 15:51:31 deniel Exp $
* $Id: packet-osi.c,v 1.11 1999/10/12 06:20:12 gram Exp $
* Laurent Deniel <deniel@worldnet.fr>
*
* Ethereal - Network traffic analyzer
@ -1633,27 +1633,48 @@ void proto_register_clnp(void)
{
static hf_register_info hf[] = {
{ &hf_clnp_id,
{ "Protocol identifier", "clnp.id", FT_UINT8, NULL }},
{ "Protocol identifier", "clnp.id", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_clnp_length,
{ "Length", "clnp.len", FT_UINT8, NULL }},
{ "Length", "clnp.len", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_clnp_version,
{ "Version", "clnp.version", FT_UINT8, NULL }},
{ "Version", "clnp.version", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_clnp_ttl,
{ "TTL", "clnp.ttl", FT_UINT8, NULL }},
{ "TTL", "clnp.ttl", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_clnp_type,
{ "Type code", "clnp.type", FT_UINT8, NULL }},
{ "Type code", "clnp.type", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_clnp_pdu_length,
{ "PDU segment length", "clnp.pdu.len", FT_UINT16, NULL }},
{ "PDU segment length", "clnp.pdu.len", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_clnp_checksum,
{ "Checksum", "clnp.checksum",FT_UINT16, NULL }},
{ "Checksum", "clnp.checksum",FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_clnp_dest_length,
{ "Destination address length", "clnp.dsap.len", FT_UINT8, NULL }},
{ "Destination address length", "clnp.dsap.len", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_clnp_dest,
{ "Destination address", "clnp.dsap", FT_BYTES, NULL }},
{ "Destination address", "clnp.dsap", FT_BYTES, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_clnp_src_length,
{ "Source address length","clnp.ssap.len",FT_UINT8, NULL }},
{ "Source address length","clnp.ssap.len",FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_clnp_src,
{ "Source address", "clnp.ssap", FT_BYTES, NULL }},
{ "Source address", "clnp.ssap", FT_BYTES, BASE_NONE, NULL, 0x0,
"" }},
};
proto_clnp = proto_register_protocol("ISO CLNP", "clnp");

11
packet-ppp.c
View File

@ -1,7 +1,7 @@
/* packet-ppp.c
* Routines for ppp packet disassembly
*
* $Id: packet-ppp.c,v 1.20 1999/09/11 22:40:30 gerald Exp $
* $Id: packet-ppp.c,v 1.21 1999/10/12 06:20:14 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -1151,13 +1151,16 @@ proto_register_mp(void)
{
static hf_register_info hf[] = {
{ &hf_mp_frag_first,
{ "First fragment", "mp.first", FT_BOOLEAN, NULL }},
{ "First fragment", "mp.first", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_mp_frag_last,
{ "Last fragment", "mp.last", FT_BOOLEAN, NULL }},
{ "Last fragment", "mp.last", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_mp_sequence_num,
{ "Sequence number", "mp.seq", FT_UINT32, NULL }}
{ "Sequence number", "mp.seq", FT_UINT32, BASE_DEC, NULL, 0x0,
"" }}
};
proto_mp = proto_register_protocol("PPP Multilink Protocol", "mp");

13
packet-radius.c
View File

@ -1,7 +1,7 @@
/* packet-radius.c
* Routines for RADIUS packet disassembly
*
* $Id: packet-radius.c,v 1.3 1999/08/03 14:59:16 gram Exp $
* $Id: packet-radius.c,v 1.4 1999/10/12 06:20:15 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Johan Feyaerts
@ -614,11 +614,16 @@ proto_register_radius(void)
{
static hf_register_info hf[] = {
{ &hf_radius_code,
{ "Code","radius.code", FT_UINT8, NULL }},
{ "Code","radius.code", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_radius_id,
{ "Identifier", "radius.id", FT_UINT8, NULL }},
{ "Identifier", "radius.id", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_radius_length,
{ "Length","radius.length", FT_UINT16, NULL }}
{ "Length","radius.length", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }}
};
proto_radius = proto_register_protocol ("Radius Protocol", "radius");

112
packet-rsvp.c
View File

@ -3,7 +3,7 @@
*
* (c) Copyright Ashok Narayanan <ashokn@cisco.com>
*
* $Id: packet-rsvp.c,v 1.8 1999/08/29 04:15:30 gram Exp $
* $Id: packet-rsvp.c,v 1.9 1999/10/12 06:20:16 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -153,73 +153,125 @@ static hf_register_info rsvpf_info[] = {
/* Message type number */
{&rsvp_filter[RSVPF_MSG],
{ "Message Type", "rsvp.msg", FT_VALS_UINT8, VALS(message_type_vals) }},
{ "Message Type", "rsvp.msg", FT_UINT8, BASE_NONE, message_type_vals, 0x0,
"" }},
/* Message type shorthands */
{&rsvp_filter[RSVPF_PATH],
{ "Path Message", "rsvp.path", FT_UINT8, NULL }},
{ "Path Message", "rsvp.path", FT_UINT8, BASE_NONE, NULL, 0x0,
"" }},
{&rsvp_filter[RSVPF_RESV],
{ "Resv Message", "rsvp.resv", FT_UINT8, NULL }},
{ "Resv Message", "rsvp.resv", FT_UINT8, BASE_NONE, NULL, 0x0,
"" }},
{&rsvp_filter[RSVPF_PATHERR],
{ "Path Error Message", "rsvp.perr", FT_UINT8, NULL }},
{ "Path Error Message", "rsvp.perr", FT_UINT8, BASE_NONE, NULL, 0x0,
"" }},
{&rsvp_filter[RSVPF_RESVERR],
{ "Resv Error Message", "rsvp.rerr", FT_UINT8, NULL }},
{ "Resv Error Message", "rsvp.rerr", FT_UINT8, BASE_NONE, NULL, 0x0,
"" }},
{&rsvp_filter[RSVPF_PATHTEAR],
{ "Path Tear Message", "rsvp.ptear", FT_UINT8, NULL }},
{ "Path Tear Message", "rsvp.ptear", FT_UINT8, BASE_NONE, NULL, 0x0,
"" }},
{&rsvp_filter[RSVPF_RESVTEAR],
{ "Resv Tear Message", "rsvp.rtear", FT_UINT8, NULL }},
{ "Resv Tear Message", "rsvp.rtear", FT_UINT8, BASE_NONE, NULL, 0x0,
"" }},
{&rsvp_filter[RSVPF_RCONFIRM],
{ "Resv Confirm Message", "rsvp.resvconf", FT_UINT8, NULL }},
{ "Resv Confirm Message", "rsvp.resvconf", FT_UINT8, BASE_NONE, NULL, 0x0,
"" }},
/* Object present */
{&rsvp_filter[RSVPF_OBJECT],
{ "", "rsvp.object", FT_VALS_UINT8, VALS(rsvp_class_vals) }},
{ "", "rsvp.object", FT_UINT8, BASE_NONE, rsvp_class_vals, 0x0,
"" }},
/* Object present shorthands */
{&rsvp_filter[RSVPF_SESSION],
{ "SESSION", "rsvp.session", FT_UINT8, NULL }},
{ "SESSION", "rsvp.session", FT_UINT8, BASE_NONE, NULL, 0x0,
"" }},
{&rsvp_filter[RSVPF_HOP],
{ "HOP", "rsvp.hop", FT_UINT8, NULL }},
{ "HOP", "rsvp.hop", FT_UINT8, BASE_NONE, NULL, 0x0,
"" }},
{&rsvp_filter[RSVPF_INTEGRITY],
{ "INTEGRITY", "rsvp.integrity", FT_UINT8, NULL }},
{ "INTEGRITY", "rsvp.integrity", FT_UINT8, BASE_NONE, NULL, 0x0,
"" }},
{&rsvp_filter[RSVPF_TIME_VALUES],
{ "TIME VALUES", "rsvp.time", FT_UINT8, NULL }},
{ "TIME VALUES", "rsvp.time", FT_UINT8, BASE_NONE, NULL, 0x0,
"" }},
{&rsvp_filter[RSVPF_ERROR],
{ "ERROR", "rsvp.error", FT_UINT8, NULL }},
{ "ERROR", "rsvp.error", FT_UINT8, BASE_NONE, NULL, 0x0,
"" }},
{&rsvp_filter[RSVPF_SCOPE],
{ "SCOPE", "rsvp.scope", FT_UINT8, NULL }},
{ "SCOPE", "rsvp.scope", FT_UINT8, BASE_NONE, NULL, 0x0,
"" }},
{&rsvp_filter[RSVPF_STYLE],
{ "STYLE", "rsvp.style", FT_UINT8, NULL }},
{ "STYLE", "rsvp.style", FT_UINT8, BASE_NONE, NULL, 0x0,
"" }},
{&rsvp_filter[RSVPF_FLOWSPEC],
{ "FLOWSPEC", "rsvp.flowspec", FT_UINT8, NULL }},
{ "FLOWSPEC", "rsvp.flowspec", FT_UINT8, BASE_NONE, NULL, 0x0,
"" }},
{&rsvp_filter[RSVPF_FILTER_SPEC],
{ "FILTERSPEC", "rsvp.filter", FT_UINT8, NULL }},
{ "FILTERSPEC", "rsvp.filter", FT_UINT8, BASE_NONE, NULL, 0x0,
"" }},
{&rsvp_filter[RSVPF_SENDER],
{ "SENDER TEMPLATE", "rsvp.sender", FT_UINT8, NULL }},
{ "SENDER TEMPLATE", "rsvp.sender", FT_UINT8, BASE_NONE, NULL, 0x0,
"" }},
{&rsvp_filter[RSVPF_TSPEC],
{ "SENDER TSPEC", "rsvp.tspec", FT_UINT8, NULL }},
{ "SENDER TSPEC", "rsvp.tspec", FT_UINT8, BASE_NONE, NULL, 0x0,
"" }},
{&rsvp_filter[RSVPF_ADSPEC],
{ "ADSPEC", "rsvp.adspec", FT_UINT8, NULL }},
{ "ADSPEC", "rsvp.adspec", FT_UINT8, BASE_NONE, NULL, 0x0,
"" }},
{&rsvp_filter[RSVPF_POLICY],
{ "POLICY", "rsvp.policy", FT_UINT8, NULL }},
{ "POLICY", "rsvp.policy", FT_UINT8, BASE_NONE, NULL, 0x0,
"" }},
{&rsvp_filter[RSVPF_CONFIRM],
{ "CONFIRM", "rsvp.confirm", FT_UINT8, NULL }},
{ "CONFIRM", "rsvp.confirm", FT_UINT8, BASE_NONE, NULL, 0x0,
"" }},
{&rsvp_filter[RSVPF_UNKNOWN_OBJ],
{ "Unknown object", "rsvp.obj_unknown", FT_UINT8, NULL }},
{ "Unknown object", "rsvp.obj_unknown", FT_UINT8, BASE_NONE, NULL, 0x0,
"" }},
/* Session fields */
{&rsvp_filter[RSVPF_SESSION_IP],
{ "Destination address", "rsvp.session.ip", FT_IPv4, NULL }},
{ "Destination address", "rsvp.session.ip", FT_IPv4, BASE_NONE, NULL, 0x0,
"" }},
{&rsvp_filter[RSVPF_SESSION_PORT],
{ "Port number", "rsvp.session.port", FT_UINT16, NULL }},
{ "Port number", "rsvp.session.port", FT_UINT16, BASE_NONE, NULL, 0x0,
"" }},
{&rsvp_filter[RSVPF_SESSION_PROTO],
{ "Protocol", "rsvp.session.proto", FT_VALS_UINT8, VALS(proto_vals) }},
{ "Protocol", "rsvp.session.proto", FT_UINT8, BASE_NONE, VALS(proto_vals), 0x0,
"" }},
/* Sender template fields */
{&rsvp_filter[RSVPF_SENDER_IP],
{ "Sender Template IPv4 address", "rsvp.template.ip", FT_IPv4, NULL }},
{ "Sender Template IPv4 address", "rsvp.template.ip", FT_IPv4, BASE_NONE, NULL, 0x0,
"" }},
{&rsvp_filter[RSVPF_SENDER_PORT],
{ "Sender Template port number", "rsvp.template.port", FT_UINT16, NULL }}
{ "Sender Template port number", "rsvp.template.port", FT_UINT16, BASE_NONE, NULL, 0x0,
"" }}
};
static inline int rsvp_class_to_filter_num(int classnum)

604
packet-sna.c Normal file
View File

@ -0,0 +1,604 @@
/* packet-sna.c
* Routines for SNA
* Gilbert Ramirez <gram@xiexie.org>
*
* $Id: packet-sna.c,v 1.1 1999/10/12 06:20:17 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@unicom.net>
* Copyright 1998 Gerald Combs
*
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#ifdef HAVE_SYS_TYPES_H
# include <sys/types.h>
#endif
#include <glib.h>
#include "packet.h"
/*
* http://www.wanresources.com/snacell.html
*
*/
static int proto_sna = -1;
static int hf_sna_th = -1;
static int hf_sna_th_0 = -1;
static int hf_sna_th_fid = -1;
static int hf_sna_th_mpf = -1;
static int hf_sna_th_odai = -1;
static int hf_sna_th_efi = -1;
static int hf_sna_th_daf = -1;
static int hf_sna_th_oaf = -1;
static int hf_sna_th_snf = -1;
static int hf_sna_th_dcf = -1;
static int hf_sna_th_lsid = -1;
static int hf_sna_rh = -1;
static int hf_sna_rh_0 = -1;
static int hf_sna_rh_1 = -1;
static int hf_sna_rh_2 = -1;
static int hf_sna_rh_rri = -1;
static int hf_sna_rh_ru_category = -1;
static int hf_sna_rh_fi = -1;
static int hf_sna_rh_sdi = -1;
static int hf_sna_rh_bci = -1;
static int hf_sna_rh_eci = -1;
static int hf_sna_rh_dr1 = -1;
static int hf_sna_rh_lcci = -1;
static int hf_sna_rh_dr2 = -1;
static int hf_sna_rh_eri = -1;
static int hf_sna_rh_rti = -1;
static int hf_sna_rh_rlwi = -1;
static int hf_sna_rh_qri = -1;
static int hf_sna_rh_pi = -1;
static int hf_sna_rh_bbi = -1;
static int hf_sna_rh_ebi = -1;
static int hf_sna_rh_cdi = -1;
static int hf_sna_rh_csi = -1;
static int hf_sna_rh_edi = -1;
static int hf_sna_rh_pdi = -1;
static int hf_sna_rh_cebi = -1;
static int hf_sna_ru = -1;
/* Format Identifier */
static const value_string sna_th_fid_vals[] = {
{ 0x0, "SNA device <--> Non-SNA Device" },
{ 0x1, "Subarea Node <--> Subarea Node" },
{ 0x2, "Subarea Node <--> PU2" },
{ 0x3, "Subarea Node or SNA host <--> Subarea Node" },
{ 0x4, "?" },
{ 0x5, "?" },
{ 0xf, "Adjaced Subarea Nodes" },
{ 0x0, NULL }
};
/* Mapping Field */
static const value_string sna_th_mpf_vals[] = {
{ 0, "Middle segment of a BIU" },
{ 1, "Last segment of a BIU" },
{ 2, "First segment of a BIU" },
{ 3 , "Whole BIU" },
{ 0, NULL }
};
/* Expedited Flow Indicator */
static const value_string sna_th_efi_vals[] = {
{ 0, "Normal Flow" },
{ 1, "Expedited Flow" }
};
/* Request/Response Indicator */
static const value_string sna_rh_rri_vals[] = {
{ 0, "Request" },
{ 1, "Response" }
};
/* Request/Response Unit Category */
static const value_string sna_rh_ru_category_vals[] = {
{ 0x00, "Function Management Data (FMD)" },
{ 0x01, "Network Control (NC)" },
{ 0x10, "Data Flow Control (DFC)" },
{ 0x11, "Session Control (SC)" },
};
/* Format Indicator */
static const true_false_string sna_rh_fi_truth =
{ "FM Header", "No FM Header" };
/* Sense Data Included */
static const true_false_string sna_rh_sdi_truth =
{ "Included", "Not Included" };
/* Begin Chain Indicator */
static const true_false_string sna_rh_bci_truth =
{ "First in Chain", "Not First in Chain" };
/* End Chain Indicator */
static const true_false_string sna_rh_eci_truth =
{ "Last in Chain", "Not Last in Chain" };
/* Lengith-Checked Compression Indicator */
static const true_false_string sna_rh_lcci_truth =
{ "Compressed", "Not Compressed" };
/* Response Type Indicator */
static const true_false_string sna_rh_rti_truth =
{ "Negative", "Positive" };
/* Exception Response Indicator */
static const true_false_string sna_rh_eri_truth =
{ "Exception", "Definite" };
/* Queued Response Indicator */
static const true_false_string sna_rh_qri_truth =
{ "Enqueue response in TC queues", "Response bypasses TC queues" };
/* Code Selection Indicator */
static const value_string sna_rh_csi_vals[] = {
{ 0, "EBCDIC" },
{ 1, "ASCII" }
};
static int dissect_fid0_1 (const u_char*, int, frame_data*, proto_tree*);
static int dissect_fid2 (const u_char*, int, frame_data*, proto_tree*);
static int dissect_fid3 (const u_char*, int, frame_data*, proto_tree*);
static void dissect_rh (const u_char*, int, frame_data*, proto_tree*);
void
dissect_sna(const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
proto_tree *sna_tree = NULL, *th_tree = NULL, *rh_tree = NULL;
proto_item *sna_ti, *th_ti, *rh_ti;
guint8 th_fid;
int sna_header_len = 0, th_header_len = 0;
if (IS_DATA_IN_FRAME(offset)) {
/* Transmission Header Format Identifier */
th_fid = hi_nibble(pd[offset]);
}
else {
/* If our first byte isn't here, stop dissecting */
return;
}
/* Summary information */
if (check_col(fd, COL_PROTOCOL))
col_add_str(fd, COL_PROTOCOL, "SNA");
if (check_col(fd, COL_INFO))
col_add_str(fd, COL_INFO, val_to_str(th_fid, sna_th_fid_vals, "Unknown FID: %01x"));
if (tree) {
/* Don't bother setting length. We'll set it later after we find
* the lengths of TH/RH/RU */
sna_ti = proto_tree_add_item(tree, proto_sna, offset, 0, NULL);
sna_tree = proto_item_add_subtree(sna_ti, ETT_SNA);
/* --- TH --- */
/* Don't bother setting length. We'll set it later after we find
* the length of TH */
th_ti = proto_tree_add_item(sna_tree, hf_sna_th, offset, 0, NULL);
th_tree = proto_item_add_subtree(th_ti, ETT_SNA_TH);
switch(th_fid) {
case 0x0:
case 0x1:
th_header_len = dissect_fid0_1(pd, offset, fd, th_tree);
break;
case 0x2:
th_header_len = dissect_fid2(pd, offset, fd, th_tree);
break;
case 0x3:
th_header_len = dissect_fid3(pd, offset, fd, th_tree);
break;
default:
dissect_data(pd, offset+1, fd, tree);
}
sna_header_len += th_header_len;
offset += th_header_len;
proto_item_set_len(th_ti, th_header_len);
/* --- RH --- */
if (BYTES_ARE_IN_FRAME(offset, 3)) {
rh_ti = proto_tree_add_item(sna_tree, hf_sna_rh, offset, 3, NULL);
rh_tree = proto_item_add_subtree(rh_ti, ETT_SNA_RH);
dissect_rh(pd, offset, fd, rh_tree);
sna_header_len += 3;
offset += 3;
}
else {
/* If our first byte isn't here, stop dissecting */
return;
}
proto_item_set_len(sna_ti, sna_header_len);
}
if (IS_DATA_IN_FRAME(offset+1)) {
dissect_data(pd, offset, fd, tree);
}
}
/* FID Types 0 and 1 */
static int
dissect_fid0_1 (const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
proto_tree *bf_tree;
proto_item *bf_item;
guint8 th_0;
guint16 daf, oaf, snf, dcf;
static int bytes_in_header = 10;
if (!BYTES_ARE_IN_FRAME(offset, bytes_in_header)) {
return 0;
}
th_0 = pd[offset+0];
daf = pntohs(&pd[offset+2]);
oaf = pntohs(&pd[offset+4]);
snf = pntohs(&pd[offset+6]);
dcf = pntohs(&pd[offset+8]);
/* Create the bitfield tree */
bf_item = proto_tree_add_item(tree, hf_sna_th_0, offset, 1, th_0);
bf_tree = proto_item_add_subtree(bf_item, ETT_SNA_TH_FID);
proto_tree_add_item(bf_tree, hf_sna_th_fid, offset, 1, th_0);
proto_tree_add_item(bf_tree, hf_sna_th_mpf, offset, 1, th_0);
proto_tree_add_item(bf_tree, hf_sna_th_efi ,offset, 1, th_0);
proto_tree_add_text(tree, offset+1, 1, "Reserved");
proto_tree_add_item(tree, hf_sna_th_daf ,offset+2, 1, daf);
proto_tree_add_item(tree, hf_sna_th_oaf ,offset+4, 1, oaf);
proto_tree_add_item(tree, hf_sna_th_snf ,offset+6, 2, snf);
proto_tree_add_item(tree, hf_sna_th_dcf ,offset+8, 2, dcf);
if (check_col(fd, COL_RES_DL_DST))
col_add_fstr(fd, COL_RES_DL_DST, "%02X", daf);
if (check_col(fd, COL_RES_DL_SRC))
col_add_fstr(fd, COL_RES_DL_SRC, "%02X", oaf);
return bytes_in_header;
}
/* FID Type 2 */
static int
dissect_fid2 (const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
proto_tree *bf_tree;
proto_item *bf_item;
guint8 th_0, daf, oaf;
guint16 snf;
static int bytes_in_header = 6;
if (!BYTES_ARE_IN_FRAME(offset, bytes_in_header)) {
return 0;
}
th_0 = pd[offset+0];
daf = pd[offset+2];
oaf = pd[offset+3];
snf = pntohs(&pd[offset+4]);
/* Create the bitfield tree */
bf_item = proto_tree_add_item(tree, hf_sna_th_0, offset, 1, th_0);
bf_tree = proto_item_add_subtree(bf_item, ETT_SNA_TH_FID);
proto_tree_add_item(bf_tree, hf_sna_th_fid, offset, 1, th_0);
proto_tree_add_item(bf_tree, hf_sna_th_mpf, offset, 1, th_0);
proto_tree_add_item(bf_tree, hf_sna_th_odai ,offset, 1, th_0);
proto_tree_add_item(bf_tree, hf_sna_th_efi ,offset, 1, th_0);
proto_tree_add_text(tree, offset+1, 1, "Reserved");
proto_tree_add_item(tree, hf_sna_th_daf ,offset+2, 1, daf);
proto_tree_add_item(tree, hf_sna_th_oaf ,offset+3, 1, oaf);
proto_tree_add_item(tree, hf_sna_th_snf ,offset+4, 2, snf);
if (check_col(fd, COL_RES_DL_DST))
col_add_fstr(fd, COL_RES_DL_DST, "%02X", daf);
if (check_col(fd, COL_RES_DL_SRC))
col_add_fstr(fd, COL_RES_DL_SRC, "%02X", oaf);
return bytes_in_header;
}
/* FID Type 3 */
static int
dissect_fid3 (const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
proto_tree *bf_tree;
proto_item *bf_item;
guint8 th_0;
guint8 lsid;
static int bytes_in_header = 2;
if (!BYTES_ARE_IN_FRAME(offset, bytes_in_header)) {
return 0;
}
th_0 = pd[offset+0];
lsid = pd[offset+1];
/* Create the bitfield tree */
bf_item = proto_tree_add_item(tree, hf_sna_th_0, offset, 1, th_0);
bf_tree = proto_item_add_subtree(bf_item, ETT_SNA_TH_FID);
proto_tree_add_item(bf_tree, hf_sna_th_fid, offset, 1, th_0);
proto_tree_add_item(bf_tree, hf_sna_th_mpf, offset, 1, th_0);
proto_tree_add_item(bf_tree, hf_sna_th_efi ,offset, 1, th_0);
proto_tree_add_item(tree, hf_sna_th_lsid ,offset+1, 1, lsid);
return bytes_in_header;
}
/* RH */
static void
dissect_rh (const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
proto_tree *bf_tree;
proto_item *bf_item;
gboolean is_response;
guint8 rh_0, rh_1, rh_2;
rh_0 = pd[offset+0];
rh_1 = pd[offset+1];
rh_2 = pd[offset+2];
is_response = (rh_0 & 0x80);
/* Create the bitfield tree for byte 0*/
bf_item = proto_tree_add_item(tree, hf_sna_rh_0, offset, 1, rh_0);
bf_tree = proto_item_add_subtree(bf_item, ETT_SNA_RH_0);
proto_tree_add_item(bf_tree, hf_sna_rh_rri, offset, 1, rh_0);
proto_tree_add_item(bf_tree, hf_sna_rh_ru_category, offset, 1, rh_0);
proto_tree_add_item(bf_tree, hf_sna_rh_fi, offset, 1, rh_0);
proto_tree_add_item(bf_tree, hf_sna_rh_sdi, offset, 1, rh_0);
if (is_response) {
proto_tree_add_item(bf_tree, hf_sna_rh_bci, offset, 1, rh_0);
proto_tree_add_item(bf_tree, hf_sna_rh_eci, offset, 1, rh_0);
}
offset += 1;
/* Create the bitfield tree for byte 1*/
bf_item = proto_tree_add_item(tree, hf_sna_rh_1, offset, 1, rh_1);
bf_tree = proto_item_add_subtree(bf_item, ETT_SNA_RH_1);
proto_tree_add_item(bf_tree, hf_sna_rh_dr1, offset, 1, rh_1);
if (!is_response) {
proto_tree_add_item(bf_tree, hf_sna_rh_lcci, offset, 1, rh_1);
}
proto_tree_add_item(bf_tree, hf_sna_rh_dr2, offset, 1, rh_1);
if (is_response) {
proto_tree_add_item(bf_tree, hf_sna_rh_rti, offset, 1, rh_1);
}
else {
proto_tree_add_item(bf_tree, hf_sna_rh_eri, offset, 1, rh_1);
proto_tree_add_item(bf_tree, hf_sna_rh_rlwi, offset, 1, rh_1);
}
proto_tree_add_item(bf_tree, hf_sna_rh_qri, offset, 1, rh_1);
proto_tree_add_item(bf_tree, hf_sna_rh_pi, offset, 1, rh_1);
offset += 1;
/* Create the bitfield tree for byte 2*/
bf_item = proto_tree_add_item(tree, hf_sna_rh_2, offset, 1, rh_2);
if (!is_response) {
bf_tree = proto_item_add_subtree(bf_item, ETT_SNA_RH_2);
proto_tree_add_item(bf_tree, hf_sna_rh_bbi, offset, 1, rh_2);
proto_tree_add_item(bf_tree, hf_sna_rh_ebi, offset, 1, rh_2);
proto_tree_add_item(bf_tree, hf_sna_rh_cdi, offset, 1, rh_2);
proto_tree_add_item(bf_tree, hf_sna_rh_csi, offset, 1, rh_2);
proto_tree_add_item(bf_tree, hf_sna_rh_edi, offset, 1, rh_2);
proto_tree_add_item(bf_tree, hf_sna_rh_pdi, offset, 1, rh_2);
proto_tree_add_item(bf_tree, hf_sna_rh_cebi, offset, 1, rh_2);
}
/* XXX - check for sdi. If TRUE, the next 4 bytes will be sense data */
}
void
proto_register_sna(void)
{
static hf_register_info hf[] = {
{ &hf_sna_th,
{ "Transmission Header", "sna.th", FT_NONE, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_sna_th_0,
{ "Transmission Header Byte 0", "sna.th.0", FT_UINT8, BASE_HEX, NULL, 0x0,
"Byte 0 of Tranmission Header contains FID, MPF, ODAI,"
" and EFI as bitfields." }},
{ &hf_sna_th_fid,
{ "Format Identifer", "sna.th.fid", FT_UINT8, BASE_HEX, VALS(sna_th_fid_vals), 0xf0,
"Format Identification" }},
{ &hf_sna_th_mpf,
{ "Mapping Field", "sna.th.mpf", FT_UINT8, BASE_NONE, VALS(sna_th_mpf_vals), 0x0c,
"The Mapping Field specifies whether the information field"
" associated with the TH is a complete or partial BIU." }},
{ &hf_sna_th_odai,
{ "ODAI Assignment Indicator", "sna.th.odai", FT_UINT8, BASE_DEC, NULL, 0x02,
"The ODAI indicates which node assigned the OAF'-DAF' values"
" carried in the TH." }},
{ &hf_sna_th_efi,
{ "Expedited Flow Indicator", "sna.th.efi", FT_UINT8, BASE_DEC, VALS(sna_th_efi_vals), 0x01,
"The EFI designates whether the PIU belongs to the normal"
" or expedited flow." }},
{ &hf_sna_th_daf,
{ "Destination Address Field", "sna.th.daf", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_sna_th_oaf,
{ "Origin Address Field", "sna.th.oaf", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_sna_th_snf,
{ "Sequence Number Field", "sna.th.snf", FT_UINT16, BASE_NONE, NULL, 0x0,
"The Sequence Number Field contains a numerical identifier for"
" the associated BIU."}},
{ &hf_sna_th_dcf,
{ "Data Count Field", "sna.th.dcf", FT_UINT16, BASE_DEC, NULL, 0x0,
"A binary count of the number of bytes in the BIU or BIU segment associated "
"with the tranmission header. The count does not include any of the bytes "
"in the transmission header."}},
{ &hf_sna_th_lsid,
{ "Local Session Identification", "sna.th.lsid", FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_sna_rh,
{ "Request/Response Header", "sna.rh", FT_NONE, BASE_NONE, NULL, 0x0,
"" }},
{ &hf_sna_rh_0,
{ "Request/Response Header Byte 0", "sna.rh.0", FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_sna_rh_1,
{ "Request/Response Header Byte 1", "sna.rh.1", FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_sna_rh_2,
{ "Request/Response Header Byte 2", "sna.rh.2", FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_sna_rh_rri,
{ "Request/Response Indicator", "sna.rh.rri", FT_UINT8, BASE_DEC, VALS(sna_rh_rri_vals), 0x80,
"Denotes whether this is a request or a response." }},
{ &hf_sna_rh_ru_category,
{ "Request/Response Unit Category", "sna.rh.ru_category", FT_UINT8, BASE_HEX,
VALS(sna_rh_ru_category_vals), 0x60,
"" }},
{ &hf_sna_rh_fi,
{ "Format Indicator", "sna.rh.fi", FT_BOOLEAN, 8, TFS(&sna_rh_fi_truth), 0x08,
"" }},
{ &hf_sna_rh_sdi,
{ "Sense Data Included", "sna.rh.sdi", FT_BOOLEAN, 8, TFS(&sna_rh_sdi_truth), 0x04,
"Indicates that a 4-byte sense data field is included in the associated RU." }},
{ &hf_sna_rh_bci,
{ "Begin Chain Indicator", "sna.rh.bci", FT_BOOLEAN, 8, TFS(&sna_rh_bci_truth), 0x02,
"" }},
{ &hf_sna_rh_eci,
{ "End Chain Indicator", "sna.rh.eci", FT_BOOLEAN, 8, TFS(&sna_rh_eci_truth), 0x01,
"" }},
{ &hf_sna_rh_dr1,
{ "Definite Response 1 Indicator", "sna.rh.dr1", FT_BOOLEAN, 8, NULL, 0x80,
"" }},
{ &hf_sna_rh_lcci,
{ "Length-Checked Compression Indicator", "sna.rh.lcci", FT_BOOLEAN, 8,
TFS(&sna_rh_lcci_truth), 0x40,
"" }},
{ &hf_sna_rh_dr2,
{ "Definite Response 2 Indicator", "sna.rh.dr2", FT_BOOLEAN, 8, NULL, 0x20,
"" }},
{ &hf_sna_rh_eri,
{ "Exception Response Indicator", "sna.rh.eri", FT_BOOLEAN, 8, NULL, 0x10,
"Used in conjunction with DR1I and DR2I to indicate, in a request, "
"the form of response requested." }},
{ &hf_sna_rh_rti,
{ "Response Type Indicator", "sna.rh.rti", FT_BOOLEAN, 8, TFS(&sna_rh_rti_truth), 0x10,
"" }},
{ &hf_sna_rh_rlwi,
{ "Request Larger Window Indicator", "sna.rh.rlwi", FT_BOOLEAN, 8, NULL, 0x04,
"Indicates whether a larger pacing window was requested." }},
{ &hf_sna_rh_qri,
{ "Queued Response Indicator", "sna.rh.qri", FT_BOOLEAN, 8, TFS(&sna_rh_qri_truth), 0x02,
"" }},
{ &hf_sna_rh_pi,
{ "Pacing Indicator", "sna.rh.pi", FT_BOOLEAN, 8, NULL, 0x01,
"" }},
{ &hf_sna_rh_bbi,
{ "Begin Bracket Indicator", "sna.rh.bbi", FT_BOOLEAN, 8, NULL, 0x80,
"" }},
{ &hf_sna_rh_ebi,
{ "End Bracket Indicator", "sna.rh.ebi", FT_BOOLEAN, 8, NULL, 0x40,
"" }},
{ &hf_sna_rh_cdi,
{ "Change Direction Indicator", "sna.rh.cdi", FT_BOOLEAN, 8, NULL, 0x20,
"" }},
{ &hf_sna_rh_csi,
{ "Code Selection Indicator", "sna.rh.csi", FT_BOOLEAN, 8, VALS(sna_rh_csi_vals), 0x08,
"Specifies the encoding used for the associated FMD RU." }},
{ &hf_sna_rh_edi,
{ "Enciphered Data Indicator", "sna.rh.edi", FT_BOOLEAN, 8, NULL, 0x04,
"Indicates that information in the associated RU is enciphered under "
"session-level cryptography protocols." }},
{ &hf_sna_rh_pdi,
{ "Padded Data Indicator", "sna.rh.pdi", FT_BOOLEAN, 8, NULL, 0x02,
"Indicates that the RU was padded at the end, before encipherment, to the next "
"integral multiple of 8 bytes." }},
{ &hf_sna_rh_cebi,
{ "Conditional End Bracket Indicator", "sna.rh.cebi", FT_BOOLEAN, 8, NULL, 0x01,
"Used to indicate the beginning or end of a group of exchanged "
"requests and responses called a bracket. Only used on LU-LU sessions." }},
{ &hf_sna_ru,
{ "Request/Response Unit", "sna.ru", FT_NONE, BASE_NONE, NULL, 0x0,
""}},
};
proto_sna = proto_register_protocol("Systems Network Architecture", "sna");
proto_register_field_array(proto_sna, hf, array_length(hf));
}

17
packet-tcp.c
View File

@ -1,7 +1,7 @@
/* packet-tcp.c
* Routines for TCP packet disassembly
*
* $Id: packet-tcp.c,v 1.33 1999/09/17 05:56:56 guy Exp $
* $Id: packet-tcp.c,v 1.34 1999/10/12 06:20:17 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -528,19 +528,24 @@ proto_register_tcp(void)
static hf_register_info hf[] = {
{ &hf_tcp_srcport,
{ "Source Port", "tcp.srcport", FT_UINT16, NULL }},
{ "Source Port", "tcp.srcport", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_tcp_dstport,
{ "Destination Port", "tcp.dstport", FT_UINT16, NULL }},
{ "Destination Port", "tcp.dstport", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_tcp_port,
{ "Source or Destination Port", "tcp.port", FT_UINT16, NULL }},
{ "Source or Destination Port", "tcp.port", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_tcp_seq,
{ "Sequence number", "tcp.seq", FT_UINT32, NULL }},
{ "Sequence number", "tcp.seq", FT_UINT32, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_tcp_ack,
{ "Acknowledgement number", "tcp.ack", FT_UINT32, NULL }},
{ "Acknowledgement number", "tcp.ack", FT_UINT32, BASE_DEC, NULL, 0x0,
"" }},
};
proto_tcp = proto_register_protocol ("Transmission Control Protocol", "tcp");

97
packet-tr.c
View File

@ -2,7 +2,7 @@
* Routines for Token-Ring packet disassembly
* Gilbert Ramirez <gram@verdict.uthscsa.edu>
*
* $Id: packet-tr.c,v 1.28 1999/09/22 05:40:12 gram Exp $
* $Id: packet-tr.c,v 1.29 1999/10/12 06:20:18 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@unicom.net>
@ -59,11 +59,7 @@ static int hf_tr_rif_bridge = -1;
#define TR_MIN_HEADER_LEN 14
#define TR_MAX_HEADER_LEN 32
static const value_string ac_vals[] = {
{ 0, "Token" },
{ 0x10, "Frame" },
{ 0, NULL }
};
static const true_false_string ac_truth = { "Frame", "Token" };
static const value_string pcf_vals[] = {
{ 0, "Normal buffer" },
@ -78,8 +74,8 @@ static const value_string pcf_vals[] = {
static const value_string frame_vals[] = {
{ 0, "MAC" },
{ 64, "LLC" },
{ 128, "Reserved" },
{ 1, "LLC" },
{ 2, "Reserved" },
{ 0, NULL },
};
@ -419,33 +415,20 @@ dissect_tr(const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
tr_tree = proto_item_add_subtree(ti, ETT_TOKEN_RING);
/* Create the Access Control bitfield tree */
ti = proto_tree_add_item_format(tr_tree, hf_tr_ac, offset, 1, trn_ac,
"Access Control (0x%02x)", trn_ac);
ti = proto_tree_add_item(tr_tree, hf_tr_ac, offset, 1, trn_ac);
bf_tree = proto_item_add_subtree(ti, ETT_TOKEN_RING_AC);
proto_tree_add_item_format(bf_tree, hf_tr_priority, offset, 1, trn_ac & 0xe0,
decode_numeric_bitfield(trn_ac, 0xe0, 8, "Priority = %d"));
proto_tree_add_item_format(bf_tree, hf_tr_frame, offset, 1, trn_ac & 0x10,
decode_enumerated_bitfield(trn_ac, 0x10, 8, ac_vals, "%s"));
proto_tree_add_item_format(bf_tree, hf_tr_monitor_cnt, offset, 1, trn_ac & 0x08,
decode_numeric_bitfield(trn_ac, 0x08, 8, "Monitor Count"));
proto_tree_add_item_format(bf_tree, hf_tr_priority_reservation, offset, 1, trn_ac & 0x07,
decode_numeric_bitfield(trn_ac, 0x07, 8, "Priority Reservation = %d"));
proto_tree_add_item(bf_tree, hf_tr_priority, offset, 1, trn_ac);
proto_tree_add_item(bf_tree, hf_tr_frame, offset, 1, trn_ac);
proto_tree_add_item(bf_tree, hf_tr_monitor_cnt, offset, 1, trn_ac);
proto_tree_add_item(bf_tree, hf_tr_priority_reservation, offset, 1, trn_ac);
/* Create the Frame Control bitfield tree */
ti = proto_tree_add_item_format(tr_tree, hf_tr_fc, offset + 1, 1, trn_fc,
"Frame Control (0x%02x)", trn_fc);
ti = proto_tree_add_item(tr_tree, hf_tr_fc, offset + 1, 1, trn_fc);
bf_tree = proto_item_add_subtree(ti, ETT_TOKEN_RING_FC);
proto_tree_add_item_format(bf_tree, hf_tr_fc_type, offset + 1, 1, trn_fc & 0xc0,
decode_enumerated_bitfield(trn_fc, 0xc0, 8, frame_vals, "%s"));
proto_tree_add_item_format(bf_tree, hf_tr_fc_pcf, offset + 1, 1, trn_fc & 0x0f,
decode_enumerated_bitfield(trn_fc, 0x0f, 8, pcf_vals, "%s"));
proto_tree_add_item(bf_tree, hf_tr_fc_type, offset + 1, 1, trn_fc);
proto_tree_add_item(bf_tree, hf_tr_fc_pcf, offset + 1, 1, trn_fc);
proto_tree_add_item(tr_tree, hf_tr_dst, offset + 2, 6, trn_dhost);
proto_tree_add_item(tr_tree, hf_tr_src, offset + 8, 6, trn_shost);
@ -557,58 +540,78 @@ proto_register_tr(void)
{
static hf_register_info hf[] = {
{ &hf_tr_ac,
{ "Access Control", "tr.ac", FT_UINT8, NULL }},
{ "Access Control", "tr.ac", FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_tr_priority,
{ "Priority", "tr.priority", FT_UINT8, NULL }},
{ "Priority", "tr.priority", FT_UINT8, BASE_DEC, NULL, 0xe0,
"" }},
{ &hf_tr_frame,
{ "Frame", "tr.frame", FT_VALS_UINT8, VALS(ac_vals) }},
{ "Frame", "tr.frame", FT_BOOLEAN, 8, TFS(&ac_truth), 0x10,
"" }},
{ &hf_tr_monitor_cnt,
{ "Monitor Count", "tr.monitor_cnt", FT_UINT8, NULL }},
{ "Monitor Count", "tr.monitor_cnt", FT_UINT8, BASE_DEC, NULL, 0x08,
"" }},
{ &hf_tr_priority_reservation,
{ "Priority Reservation","tr.priority_reservation", FT_UINT8, NULL }},
{ "Priority Reservation","tr.priority_reservation", FT_UINT8, BASE_DEC, NULL, 0x07,
"" }},
{ &hf_tr_fc,
{ "Frame Control", "tr.fc", FT_UINT8, NULL }},
{ "Frame Control", "tr.fc", FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_tr_fc_type,
{ "Frame Type", "tr.frame_type", FT_VALS_UINT8, VALS(frame_vals) }},
{ "Frame Type", "tr.frame_type", FT_UINT8, BASE_DEC, VALS(frame_vals), 0xc0,
"" }},
{ &hf_tr_fc_pcf,
{ "Frame PCF", "tr.frame_pcf", FT_VALS_UINT8, VALS(pcf_vals) }},
{ "Frame PCF", "tr.frame_pcf", FT_UINT8, BASE_DEC, VALS(pcf_vals), 0x0f,
"" }},
{ &hf_tr_dst,
{ "Destination", "tr.dst", FT_ETHER, NULL }},
{ "Destination", "tr.dst", FT_ETHER, BASE_NONE, NULL, 0x0,
"Destination Hardware Address" }},
{ &hf_tr_src,
{ "Source", "tr.src", FT_ETHER, NULL }},
{ "Source", "tr.src", FT_ETHER, BASE_NONE, NULL, 0x0,
"Source Hardware Address" }},
{ &hf_tr_sr,
{ "Source Routed", "tr.sr", FT_BOOLEAN, NULL }},
{ "Source Routed", "tr.sr", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Source Routed" }},
{ &hf_tr_rif_bytes,
{ "RIF Bytes", "tr.rif_bytes", FT_UINT8, NULL }},
{ "RIF Bytes", "tr.rif_bytes", FT_UINT8, BASE_DEC, NULL, 0x0,
"Number of bytes in Routing Information Fields, including "
"the two bytes of Routing Control Field" }},
{ &hf_tr_broadcast,
{ "Broadcast Type", "tr.broadcast", FT_VALS_UINT8, VALS(broadcast_vals) }},
{ "Broadcast Type", "tr.broadcast", FT_UINT8, BASE_DEC, VALS(broadcast_vals), 0x0,
"Type of Token-Ring Broadcast" }},
{ &hf_tr_max_frame_size,
{ "Maximum Frame Size", "tr.max_frame_size", FT_VALS_UINT8, VALS(max_frame_size_vals) }},
{ "Maximum Frame Size", "tr.max_frame_size", FT_UINT8, BASE_DEC, VALS(max_frame_size_vals),
0x0,
"" }},
{ &hf_tr_direction,
{ "Direction", "tr.direction", FT_VALS_UINT8, VALS(direction_vals) }},
{ "Direction", "tr.direction", FT_UINT8, BASE_DEC, VALS(direction_vals), 0x0,
"Direction of RIF" }},
{ &hf_tr_rif,
{ "Ring-Bridge Pairs", "tr.rif", FT_STRING, NULL }},
{ "Ring-Bridge Pairs", "tr.rif", FT_STRING, BASE_NONE, NULL, 0x0,
"String representing Ring-Bridge Pairs" }},
{ &hf_tr_rif_ring,
{ "RIF Ring", "tr.rif.ring", FT_UINT16, NULL }},
{ "RIF Ring", "tr.rif.ring", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_tr_rif_bridge,
{ "RIF Bridge", "tr.rif.bridge", FT_UINT8, NULL }}
{ "RIF Bridge", "tr.rif.bridge", FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
};
proto_tr = proto_register_protocol("Token-Ring", "tr");

56
packet-trmac.c
View File

@ -2,7 +2,7 @@
* Routines for Token-Ring Media Access Control
* Gilbert Ramirez <gram@verdict.uthscsa.edu>
*
* $Id: packet-trmac.c,v 1.15 1999/09/17 04:20:23 gram Exp $
* $Id: packet-trmac.c,v 1.16 1999/10/12 06:20:19 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@unicom.net>
@ -320,58 +320,76 @@ proto_register_trmac(void)
{
static hf_register_info hf[] = {
{ &hf_trmac_mv,
{ "Major Vector", "trmac.mvec", FT_VALS_UINT8, VALS(major_vector_vs) }},
{ "Major Vector", "trmac.mvec", FT_UINT8, BASE_HEX, major_vector_vs, 0x0,
"" }},
{ &hf_trmac_length,
{ "Total Length", "trmac.length", FT_UINT8, NULL }},
{ "Total Length", "trmac.length", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_trmac_srcclass,
{ "Source Class", "trmac.srcclass", FT_VALS_UINT8, VALS(classes_vs) }},
{ "Source Class", "trmac.srcclass", FT_UINT8, BASE_HEX, classes_vs, 0x0,
"" }},
{ &hf_trmac_dstclass,
{ "Destination Class", "trmac.dstclass", FT_VALS_UINT8, VALS(classes_vs) }},
{ "Destination Class", "trmac.dstclass", FT_UINT8, BASE_HEX, classes_vs, 0x0,
"" }},
{ &hf_trmac_sv,
{ "Sub-Vector", "trmac.svec", FT_UINT8, NULL }},
{ "Sub-Vector", "trmac.svec", FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
{ &hf_trmac_errors_iso,
{ "Isolating Errors", "trmac.errors.iso", FT_UINT16, NULL }},
{ "Isolating Errors", "trmac.errors.iso", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_trmac_errors_line,
{ "Line Errors", "trmac.errors.line", FT_UINT8, NULL }},
{ "Line Errors", "trmac.errors.line", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_trmac_errors_internal,
{ "Internal Errors", "trmac.errors.internal", FT_UINT8, NULL }},
{ "Internal Errors", "trmac.errors.internal", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_trmac_errors_burst,
{ "Burst Errors", "trmac.errors.burst", FT_UINT8, NULL }},
{ "Burst Errors", "trmac.errors.burst", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_trmac_errors_ac,
{ "A/C Errors", "trmac.errors.ac", FT_UINT8, NULL }},
{ "A/C Errors", "trmac.errors.ac", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_trmac_errors_abort,
{ "Abort Delimiter Transmitted Errors", "trmac.errors.abort", FT_UINT8, NULL }},
{ "Abort Delimiter Transmitted Errors", "trmac.errors.abort", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_trmac_errors_noniso,
{ "Non-Isolating Errors", "trmac.errors.noniso", FT_UINT16, NULL }},
{ "Non-Isolating Errors", "trmac.errors.noniso", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_trmac_errors_lost,
{ "Lost Frame Errors", "trmac.errors.lost", FT_UINT8, NULL }},
{ "Lost Frame Errors", "trmac.errors.lost", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_trmac_errors_congestion,
{ "Receiver Congestion Errors", "trmac.errors.congestion", FT_UINT8, NULL }},
{ "Receiver Congestion Errors", "trmac.errors.congestion", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_trmac_errors_fc,
{ "Frame-Copied Errors", "trmac.errors.fc", FT_UINT8, NULL }},
{ "Frame-Copied Errors", "trmac.errors.fc", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_trmac_errors_freq,
{ "Frequency Errors", "trmac.errors.freq", FT_UINT8, NULL }},
{ "Frequency Errors", "trmac.errors.freq", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_trmac_errors_token,
{ "Token Errors", "trmac.errors.token", FT_UINT8, NULL }},
{ "Token Errors", "trmac.errors.token", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_trmac_naun,
{ "NAUN", "trmac.naun", FT_ETHER, NULL }}
{ "NAUN", "trmac.naun", FT_ETHER, BASE_DEC, NULL, 0x0,
"" }},
};
proto_trmac = proto_register_protocol("Token-Ring Media Access Control", "trmac");

17
packet-udp.c
View File

@ -1,7 +1,7 @@
/* packet-udp.c
* Routines for UDP packet disassembly
*
* $Id: packet-udp.c,v 1.25 1999/10/02 16:58:41 deniel Exp $
* $Id: packet-udp.c,v 1.26 1999/10/12 06:20:19 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -287,19 +287,24 @@ proto_register_udp(void)
{
static hf_register_info hf[] = {
{ &hf_udp_srcport,
{ "Source Port", "udp.srcport", FT_UINT16, NULL }},
{ "Source Port", "udp.srcport", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_udp_dstport,
{ "Destination Port", "udp.dstport", FT_UINT16, NULL }},
{ "Destination Port", "udp.dstport", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_udp_port,
{ "Source or Destination Port", "udp.port", FT_UINT16, NULL }},
{ "Source or Destination Port", "udp.port", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_udp_length,
{ "Length", "udp.length", FT_UINT16, NULL }},
{ "Length", "udp.length", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_udp_checksum,
{ "Checksum", "udp.checksum", FT_UINT16, NULL }}
{ "Checksum", "udp.checksum", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
};
proto_udp = proto_register_protocol("User Datagram Protocol", "udp");

9
packet-x25.c
View File

@ -2,7 +2,7 @@
* Routines for x25 packet disassembly
* Olivier Abad <abad@daba.dhis.org>
*
* $Id: packet-x25.c,v 1.6 1999/09/12 18:37:00 guy Exp $
* $Id: packet-x25.c,v 1.7 1999/10/12 06:20:20 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -1448,9 +1448,12 @@ proto_register_x25(void)
{
static hf_register_info hf[] = {
{ &hf_x25_lcn,
{ "Logical Channel", "x25.lcn", FT_UINT16, NULL} },
{ "Logical Channel", "x25.lcn", FT_UINT16, BASE_DEC, NULL, 0x0,
"" } },
{ &hf_x25_type,
{ "Packet Type", "x25.type", FT_STRING, NULL} },
{ "Packet Type", "x25.type", FT_STRING, BASE_NONE, NULL, 0x0,
"" } },
};
proto_x25 = proto_register_protocol ("X.25", "x25");

20
packet.c
View File

@ -1,7 +1,7 @@
/* packet.c
* Routines for packet disassembly
*
* $Id: packet.c,v 1.45 1999/09/29 22:19:12 guy Exp $
* $Id: packet.c,v 1.46 1999/10/12 06:20:21 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -517,7 +517,7 @@ match_strval(guint32 val, const value_string *vs) {
/* Generate, into "buf", a string showing the bits of a bitfield.
Return a pointer to the character after that string. */
static char *
char *
decode_bitfield_value(char *buf, guint32 val, guint32 mask, int width)
{
int i;
@ -728,19 +728,25 @@ proto_register_frame(void)
{
static hf_register_info hf[] = {
{ &hf_frame_arrival_time,
{ "Arrival Time", "frame.time", FT_ABSOLUTE_TIME, NULL }},
{ "Arrival Time", "frame.time", FT_ABSOLUTE_TIME, BASE_NONE, NULL, 0x0,
""}},
{ &hf_frame_time_delta,
{ "Time delta from previous packet", "frame.time_delta", FT_RELATIVE_TIME, NULL }},
{ "Time delta from previous packet", "frame.time_delta", FT_RELATIVE_TIME, BASE_NONE, NULL,
0x0,
"" }},
{ &hf_frame_number,
{ "Frame Number", "frame.number", FT_UINT32, NULL }},
{ "Frame Number", "frame.number", FT_UINT32, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_frame_packet_len,
{ "Total Frame Length", "frame.pkt_len", FT_UINT32, NULL }},
{ "Total Frame Length", "frame.pkt_len", FT_UINT32, BASE_DEC, NULL, 0x0,
"" }},
{ &hf_frame_capture_len,
{ "Capture Frame Length", "frame.cap_len", FT_UINT32, NULL }}
{ "Capture Frame Length", "frame.cap_len", FT_UINT32, BASE_DEC, NULL, 0x0,
"" }},
};
proto_frame = proto_register_protocol("Frame", "frame");

21
packet.h
View File

@ -1,7 +1,7 @@
/* packet.h
* Definitions for packet disassembly structures and routines
*
* $Id: packet.h,v 1.103 1999/10/10 11:50:45 sharpe Exp $
* $Id: packet.h,v 1.104 1999/10/12 06:20:22 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -146,6 +146,13 @@ typedef struct _value_string {
gchar *strptr;
} value_string;
/* Struct for boolean enumerations */
typedef struct true_false_string {
char *true_string;
char *false_string;
} true_false_string;
/* Many of the structs and definitions below and in packet-*.c files
* were taken from include files in the Linux distribution. */
@ -343,6 +350,14 @@ enum {
ETT_IPP,
ETT_IPP_AS,
ETT_IPP_ATTR,
ETT_SNA,
ETT_SNA_TH,
ETT_SNA_TH_FID,
ETT_SNA_RH,
ETT_SNA_RH_0,
ETT_SNA_RH_1,
ETT_SNA_RH_2,
ETT_SNA_RU,
NUM_TREE_TYPES /* last item number plus one */
};
@ -363,6 +378,7 @@ int get_token_len(const u_char *linep, const u_char *lineend,
gchar* format_text(const u_char *line, int len);
gchar* val_to_str(guint32, const value_string *, const char *);
gchar* match_strval(guint32, const value_string*);
char * decode_bitfield_value(char *buf, guint32 val, guint32 mask, int width);
const char *decode_boolean_bitfield(guint32 val, guint32 mask, int width,
const char *truedesc, const char *falsedesc);
const char *decode_enumerated_bitfield(guint32 val, guint32 mask, int width,
@ -430,6 +446,8 @@ void dissect_raw(const u_char *, frame_data *, proto_tree *);
*/
void dissect_fddi(const u_char *, frame_data *, proto_tree *, gboolean);
typedef void (*DissectFunc) (const u_char*, int, frame_data*, proto_tree*);
/*
* Routines in packet-*.c
* Routines should take four args: packet data *, offset, frame_data *,
@ -482,6 +500,7 @@ void dissect_rip(const u_char *, int, frame_data *, proto_tree *);
void dissect_rsvp(const u_char *, int, frame_data *, proto_tree *);
void dissect_rtsp(const u_char *, int, frame_data *, proto_tree *);
void dissect_sdp(const u_char *, int, frame_data *, proto_tree *);
void dissect_sna(const u_char *, int, frame_data *, proto_tree *);
void dissect_snmp(const u_char *, int, frame_data *, proto_tree *);
void dissect_tcp(const u_char *, int, frame_data *, proto_tree *);
void dissect_telnet(const u_char *, int, frame_data *, proto_tree *);

470
proto.c
View File

@ -1,7 +1,7 @@
/* proto.c
* Routines for protocol tree
*
* $Id: proto.c,v 1.34 1999/10/12 04:21:12 gram Exp $
* $Id: proto.c,v 1.35 1999/10/12 06:20:23 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -81,6 +81,16 @@ static proto_item *
proto_tree_add_item_value(proto_tree *tree, int hfindex, gint start,
gint length, int include_format, int visible, va_list ap);
static void fill_label_boolean(field_info *fi, gchar *label_str);
static void fill_label_uint(field_info *fi, gchar *label_str);
static void fill_label_enumerated_uint(field_info *fi, gchar *label_str);
static void fill_label_enumerated_bitfield(field_info *fi, gchar *label_str);
static void fill_label_numeric_bitfield(field_info *fi, gchar *label_str);
static int hfinfo_bitwidth(header_field_info *hfinfo);
static char* hfinfo_uint_vals_format(header_field_info *hfinfo);
static char* hfinfo_uint_format(header_field_info *hfinfo);
static gboolean check_for_protocol_or_field_id(GNode *node, gpointer data);
static gboolean check_for_field_within_protocol(GNode *node, gpointer data);
@ -134,6 +144,7 @@ void proto_register_rsvp(void);
void proto_register_rtsp(void);
void proto_register_sdp(void);
void proto_register_smb(void);
void proto_register_sna(void);
#if defined(WITH_SNMP_CMU) || defined(WITH_SNMP_UCD)
void proto_register_snmp(void);
#endif
@ -172,6 +183,12 @@ gboolean proto_tree_is_visible = TRUE;
void
proto_init(void)
{
static hf_register_info hf[] = {
{ &hf_text_only,
{ "Text", "text", FT_TEXT_ONLY, BASE_NONE, NULL, 0x0,
"" }},
};
if (gmc_hfinfo)
g_mem_chunk_destroy(gmc_hfinfo);
if (gmc_field_info)
@ -242,6 +259,7 @@ proto_init(void)
proto_register_rtsp();
proto_register_sdp();
proto_register_smb();
proto_register_sna();
#if defined(WITH_SNMP_CMU) || defined(WITH_SNMP_UCD)
proto_register_snmp();
#endif
@ -256,12 +274,7 @@ proto_init(void)
/* Register one special-case FT_TEXT_ONLY field for use when
converting ethereal to new-style proto_tree. These fields
are merely strings on the GUI tree; they are not filterable */
hf_text_only = proto_register_field (
/* name */ "Text",
/* abbrev */ "text",
/* ftype */ FT_TEXT_ONLY,
/* parent */ -1,
/* vals[] */ NULL );
proto_register_field_array(-1, hf, array_length(hf));
}
void
@ -370,6 +383,7 @@ proto_tree_add_item_value(proto_tree *tree, int hfindex, gint start,
proto_item *pi;
field_info *fi;
char *junk, *format;
header_field_info *hfinfo;
if (!tree)
return(NULL);
@ -386,6 +400,9 @@ proto_tree_add_item_value(proto_tree *tree, int hfindex, gint start,
fi->tree_type = ETT_NONE;
fi->visible = visible;
/* for convenience */
hfinfo = fi->hfinfo;
/* from the stdarg man page on Solaris 2.6:
NOTES
It is up to the calling routine to specify in some manner
@ -400,15 +417,11 @@ NOTES
converts float arguments to double before passing them to a
function.
*/
switch(fi->hfinfo->type) {
switch(hfinfo->type) {
case FT_NONE:
junk = va_arg(ap, guint8*);
break;
case FT_BOOLEAN:
fi->value.numeric = va_arg(ap, unsigned int) ? TRUE : FALSE;
break;
case FT_BYTES:
/* This g_malloc'ed memory is freed in
proto_tree_free_node() */
@ -416,19 +429,27 @@ NOTES
memcpy(fi->value.bytes, va_arg(ap, guint8*), length);
break;
case FT_BOOLEAN:
case FT_UINT8:
case FT_VALS_UINT8:
fi->value.numeric = va_arg(ap, unsigned int);
break;
case FT_UINT16:
case FT_VALS_UINT16:
case FT_UINT24:
case FT_UINT32:
case FT_INT8:
case FT_INT16:
case FT_INT24:
case FT_INT32:
fi->value.numeric = va_arg(ap, unsigned int);
if (hfinfo->bitmask) {
/* Mask out irrelevant portions */
fi->value.numeric &= hfinfo->bitmask;
/* Shift bits */
if (hfinfo->bitshift > 0) {
fi->value.numeric >>= hfinfo->bitshift;
}
}
break;
case FT_UINT32:
case FT_VALS_UINT24:
case FT_VALS_UINT32:
case FT_IPv4:
case FT_IPXNET:
fi->value.numeric = va_arg(ap, unsigned int);
@ -462,7 +483,7 @@ NOTES
break;
default:
g_error("hfinfo->type %d not handled\n", fi->hfinfo->type);
g_error("hfinfo->type %d not handled\n", hfinfo->type);
break;
}
@ -507,7 +528,20 @@ proto_item_add_subtree(proto_item *pi, gint idx) {
int
proto_register_protocol(char *name, char *abbrev)
{
return proto_register_field(name, abbrev, FT_NONE, -1, NULL);
struct header_field_info *hfinfo;
/* Here we do allocate a new header_field_info struct */
hfinfo = g_mem_chunk_alloc(gmc_hfinfo);
hfinfo->name = name;
hfinfo->abbrev = abbrev;
hfinfo->type = FT_NONE;
hfinfo->strings = NULL;
hfinfo->bitmask = 0;
hfinfo->bitshift = 0;
hfinfo->blurb = "";
hfinfo->parent = -1; /* this field differentiates protos and fields */
return proto_register_field_init(hfinfo, hfinfo->parent);
}
/* for use with static arrays only, since we don't allocate our own copies
@ -524,29 +558,26 @@ proto_register_field_array(int parent, hf_register_info *hf, int num_records)
}
}
/* Here we do allocate a new header_field_info struct */
int
proto_register_field(char *name, char *abbrev, enum ftenum type, int parent,
struct value_string* vals)
{
struct header_field_info *hfinfo;
hfinfo = g_mem_chunk_alloc(gmc_hfinfo);
hfinfo->name = name; /* should I g_strdup? */
hfinfo->abbrev = abbrev; /* should I g_strdup? */
hfinfo->type = type;
hfinfo->vals = vals;
hfinfo->parent = parent; /* this field differentiates protos and fields */
return proto_register_field_init(hfinfo, parent);
}
static int
proto_register_field_init(header_field_info *hfinfo, int parent)
{
g_assert((hfinfo->vals == NULL) || (hfinfo->type == FT_VALS_UINT8 || hfinfo->type == FT_VALS_UINT16 ||
hfinfo->type == FT_VALS_UINT24 || hfinfo->type == FT_VALS_UINT32));
/* These types of fields are allowed to have value_strings or true_false_strings */
g_assert((hfinfo->strings == NULL) || (
(hfinfo->type == FT_UINT8) ||
(hfinfo->type == FT_UINT16) ||
(hfinfo->type == FT_UINT24) ||
(hfinfo->type == FT_UINT32) ||
(hfinfo->type == FT_INT8) ||
(hfinfo->type == FT_INT16) ||
(hfinfo->type == FT_INT24) ||
(hfinfo->type == FT_INT32) ||
(hfinfo->type == FT_BOOLEAN) ));
/* if this is a bitfield, compure bitshift */
if (hfinfo->bitmask) {
while ((hfinfo->bitmask & (1 << hfinfo->bitshift)) == 0)
hfinfo->bitshift++;
}
hfinfo->parent = parent;
@ -559,32 +590,52 @@ proto_register_field_init(header_field_info *hfinfo, int parent)
void
proto_item_fill_label(field_info *fi, gchar *label_str)
{
char *s;
struct header_field_info *hfinfo = fi->hfinfo;
switch(fi->hfinfo->type) {
switch(hfinfo->type) {
case FT_NONE:
snprintf(label_str, ITEM_LABEL_LENGTH,
"%s", fi->hfinfo->name);
"%s", hfinfo->name);
break;
case FT_BOOLEAN:
snprintf(label_str, ITEM_LABEL_LENGTH,
"%s: %s", fi->hfinfo->name,
fi->value.numeric == TRUE ? "True" : "False");
fill_label_boolean(fi, label_str);
break;
case FT_BYTES:
snprintf(label_str, ITEM_LABEL_LENGTH,
"%s: %s", fi->hfinfo->name,
"%s: %s", hfinfo->name,
bytes_to_str(fi->value.bytes, fi->length));
break;
/* Four types of integers to take care of:
* Bitfield, with val_string
* Bitfield, w/o val_string
* Non-bitfield, with val_string
* Non-bitfield, w/o val_string
*/
case FT_UINT8:
case FT_UINT16:
case FT_UINT32:
snprintf(label_str, ITEM_LABEL_LENGTH,
"%s: %u", fi->hfinfo->name,
fi->value.numeric);
case FT_INT8:
case FT_INT16:
case FT_INT32:
if (hfinfo->bitmask) {
if (hfinfo->strings) {
fill_label_enumerated_bitfield(fi, label_str);
}
else {
fill_label_numeric_bitfield(fi, label_str);
}
}
else {
if (hfinfo->strings) {
fill_label_enumerated_uint(fi, label_str);
}
else {
fill_label_uint(fi, label_str);
}
}
break;
case FT_DOUBLE:
@ -605,35 +656,6 @@ proto_item_fill_label(field_info *fi, gchar *label_str)
rel_time_to_str(&fi->value.time));
break;
case FT_VALS_UINT8:
s = match_strval(fi->value.numeric, cVALS(fi->hfinfo->vals));
snprintf(label_str, ITEM_LABEL_LENGTH,
"%s: %s (0x%02x)", fi->hfinfo->name,
(s ? s : "Unknown"), fi->value.numeric);
break;
case FT_VALS_UINT16:
s = match_strval(fi->value.numeric, cVALS(fi->hfinfo->vals));
snprintf(label_str, ITEM_LABEL_LENGTH,
"%s: %s (0x%04x)", fi->hfinfo->name,
(s ? s : "Unknown"), fi->value.numeric);
break;
case FT_VALS_UINT24:
s = match_strval(fi->value.numeric, cVALS(fi->hfinfo->vals));
snprintf(label_str, ITEM_LABEL_LENGTH,
"%s: %s (0x%06x)", fi->hfinfo->name,
(s ? s : "Unknown"), fi->value.numeric);
break;
case FT_VALS_UINT32:
s = match_strval(fi->value.numeric, cVALS(fi->hfinfo->vals));
snprintf(label_str, ITEM_LABEL_LENGTH,
"%s: %s (0x%08x)", fi->hfinfo->name,
(s ? s : "Unknown"), fi->value.numeric);
break;
case FT_IPXNET:
snprintf(label_str, ITEM_LABEL_LENGTH,
"%s: 0x%08X", fi->hfinfo->name, fi->value.numeric);
@ -671,6 +693,259 @@ proto_item_fill_label(field_info *fi, gchar *label_str)
}
}
static void
fill_label_boolean(field_info *fi, gchar *label_str)
{
char *p = label_str;
int bitfield_byte_length = 0, bitwidth;
guint32 unshifted_value;
struct header_field_info *hfinfo = fi->hfinfo;
struct true_false_string default_tf = { "True", "False" };
struct true_false_string *tfstring = &default_tf;
if (hfinfo->strings) {
tfstring = (struct true_false_string*) hfinfo->strings;
}
if (hfinfo->bitmask) {
/* Figure out the bit width */
bitwidth = hfinfo_bitwidth(hfinfo);
/* Un-shift bits */
unshifted_value = fi->value.numeric;
if (hfinfo->bitshift > 0) {
unshifted_value <<= hfinfo->bitshift;
}
/* Create the bitfield first */
p = decode_bitfield_value(label_str, unshifted_value, hfinfo->bitmask, bitwidth);
bitfield_byte_length = p - label_str;
}
/* Fill in the textual info */
snprintf(p, ITEM_LABEL_LENGTH - bitfield_byte_length,
"%s: %s", hfinfo->name,
fi->value.numeric ? tfstring->true_string : tfstring->false_string);
}
/* Fills data for bitfield ints with val_strings */
static void
fill_label_enumerated_bitfield(field_info *fi, gchar *label_str)
{
char *format = NULL, *p;
int bitfield_byte_length, bitwidth;
guint32 unshifted_value;
struct header_field_info *hfinfo = fi->hfinfo;
/* Figure out the bit width */
bitwidth = hfinfo_bitwidth(hfinfo);
/* Pick the proper format string */
format = hfinfo_uint_vals_format(hfinfo);
/* Un-shift bits */
unshifted_value = fi->value.numeric;
if (hfinfo->bitshift > 0) {
unshifted_value <<= hfinfo->bitshift;
}
/* Create the bitfield first */
p = decode_bitfield_value(label_str, unshifted_value, hfinfo->bitmask, bitwidth);
bitfield_byte_length = p - label_str;
/* Fill in the textual info using stored (shifted) value */
snprintf(p, ITEM_LABEL_LENGTH - bitfield_byte_length,
format, hfinfo->name,
val_to_str(fi->value.numeric, cVALS(hfinfo->strings), "Unknown"),
fi->value.numeric);
}
static void
fill_label_numeric_bitfield(field_info *fi, gchar *label_str)
{
char *format = NULL, *p;
int bitfield_byte_length, bitwidth;
guint32 unshifted_value;
struct header_field_info *hfinfo = fi->hfinfo;
/* Figure out the bit width */
bitwidth = hfinfo_bitwidth(hfinfo);
/* Pick the proper format string */
format = hfinfo_uint_format(hfinfo);
/* Un-shift bits */
unshifted_value = fi->value.numeric;
if (hfinfo->bitshift > 0) {
unshifted_value <<= hfinfo->bitshift;
}
/* Create the bitfield using */
p = decode_bitfield_value(label_str, unshifted_value, hfinfo->bitmask, bitwidth);
bitfield_byte_length = p - label_str;
/* Fill in the textual info using stored (shifted) value */
snprintf(p, ITEM_LABEL_LENGTH - bitfield_byte_length,
format, hfinfo->name, fi->value.numeric);
}
static void
fill_label_enumerated_uint(field_info *fi, gchar *label_str)
{
char *format = NULL;
struct header_field_info *hfinfo = fi->hfinfo;
/* Pick the proper format string */
format = hfinfo_uint_vals_format(hfinfo);
/* Fill in the textual info */
snprintf(label_str, ITEM_LABEL_LENGTH,
format, hfinfo->name,
val_to_str(fi->value.numeric, cVALS(hfinfo->strings), "Unknown"),
fi->value.numeric);
}
static void
fill_label_uint(field_info *fi, gchar *label_str)
{
char *format = NULL;
struct header_field_info *hfinfo = fi->hfinfo;
/* Pick the proper format string */
format = hfinfo_uint_format(hfinfo);
/* Fill in the textual info */
snprintf(label_str, ITEM_LABEL_LENGTH,
format, hfinfo->name, fi->value.numeric);
}
static int
hfinfo_bitwidth(header_field_info *hfinfo)
{
int bitwidth = 0;
if (!hfinfo->bitmask) {
return 0;
}
switch(hfinfo->type) {
case FT_UINT8:
case FT_INT8:
bitwidth = 8;
break;
case FT_UINT16:
case FT_INT16:
bitwidth = 16;
break;
case FT_UINT24:
case FT_INT24:
bitwidth = 24;
break;
case FT_UINT32:
case FT_INT32:
bitwidth = 32;
break;
case FT_BOOLEAN:
bitwidth = hfinfo->display; /* hacky? :) */
break;
default:
g_assert_not_reached();
;
}
return bitwidth;
}
static char*
hfinfo_uint_vals_format(header_field_info *hfinfo)
{
char *format = NULL;
switch(hfinfo->display) {
case BASE_DEC:
case BASE_NONE:
case BASE_OCT: /* I'm lazy */
case BASE_BIN: /* I'm lazy */
format = "%s: %s (%u)";
break;
case BASE_HEX:
switch(hfinfo->type) {
case FT_UINT8:
case FT_INT8:
format = "%s: %s (0x%02x)";
break;
case FT_UINT16:
case FT_INT16:
format = "%s: %s (0x%04x)";
break;
case FT_UINT24:
case FT_INT24:
format = "%s: %s (0x%06x)";
break;
case FT_UINT32:
case FT_INT32:
format = "%s: %s (0x%08x)";
break;
default:
g_assert_not_reached();
;
}
break;
default:
g_assert_not_reached();
;
}
return format;
}
static char*
hfinfo_uint_format(header_field_info *hfinfo)
{
char *format = NULL;
/* Pick the proper format string */
switch(hfinfo->display) {
case BASE_DEC:
case BASE_NONE:
case BASE_OCT: /* I'm lazy */
case BASE_BIN: /* I'm lazy */
format = "%s: %u";
break;
case BASE_HEX:
switch(hfinfo->type) {
case FT_UINT8:
case FT_INT8:
format = "%s: 0x%02x";
break;
case FT_UINT16:
case FT_INT16:
format = "%s: 0x%04x";
break;
case FT_UINT24:
case FT_INT24:
format = "%s: 0x%06x";
break;
case FT_UINT32:
case FT_INT32:
format = "%s: 0x%08x";
break;
default:
g_assert_not_reached();
;
}
break;
default:
g_assert_not_reached();
;
}
return format;
}
int
proto_registrar_n(void)
{
@ -752,18 +1027,19 @@ proto_registrar_get_length(int n)
return 0;
case FT_UINT8:
case FT_VALS_UINT8:
case FT_INT8:
return 1;
case FT_UINT16:
case FT_VALS_UINT16:
case FT_INT16:
return 2;
case FT_VALS_UINT24:
case FT_UINT24:
case FT_INT24:
return 3;
case FT_UINT32:
case FT_VALS_UINT32:
case FT_INT32:
case FT_IPXNET:
case FT_IPv4:
return 4;
@ -926,6 +1202,18 @@ proto_registrar_dump(void)
case FT_UINT32:
enum_name = "FT_UINT32";
break;
case FT_INT8:
enum_name = "FT_INT8";
break;
case FT_INT16:
enum_name = "FT_INT16";
break;
case FT_INT24:
enum_name = "FT_INT24";
break;
case FT_INT32:
enum_name = "FT_INT32";
break;
case FT_DOUBLE:
enum_name = "FT_DOUBLE";
break;
@ -953,18 +1241,6 @@ proto_registrar_dump(void)
case FT_IPXNET:
enum_name = "FT_IPXNET";
break;
case FT_VALS_UINT8:
enum_name = "FT_VALS_UINT8";
break;
case FT_VALS_UINT16:
enum_name = "FT_VALS_UINT16";
break;
case FT_VALS_UINT24:
enum_name = "FT_VALS_UINT24";
break;
case FT_VALS_UINT32:
enum_name = "FT_VALS_UINT32";
break;
case FT_TEXT_ONLY:
enum_name = "FT_TEXT_ONLY";
break;

43
proto.h
View File

@ -1,7 +1,7 @@
/* proto.h
* Definitions for protocol display
*
* $Id: proto.h,v 1.16 1999/10/12 04:21:13 gram Exp $
* $Id: proto.h,v 1.17 1999/10/12 06:20:24 gram Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -48,6 +48,8 @@ struct value_string;
* need this macro */
#define VALS(x) (struct value_string*)(x)
/* ... and similarly, */
#define TFS(x) (struct true_false_string*)(x)
/* field types */
enum ftenum {
@ -55,7 +57,12 @@ enum ftenum {
FT_BOOLEAN, /* TRUE and FALSE come from <glib.h> */
FT_UINT8,
FT_UINT16,
FT_UINT24, /* really a UINT32, but displayed as 3 hex-digits if FD_HEX*/
FT_UINT32,
FT_INT8,
FT_INT16,
FT_INT24,
FT_INT32,
FT_DOUBLE,
FT_ABSOLUTE_TIME,
FT_RELATIVE_TIME,
@ -65,23 +72,32 @@ enum ftenum {
FT_IPv4,
FT_IPv6,
FT_IPXNET,
FT_VALS_UINT8,
FT_VALS_UINT16,
FT_VALS_UINT24,
FT_VALS_UINT32,
FT_TEXT_ONLY, /* non-filterable, used when converting ethereal
from old-style proto_tree to new-style proto_tree */
NUM_FIELD_TYPES /* last item number plus one */
};
enum {
BASE_NONE,
BASE_DEC,
BASE_HEX,
BASE_OCT,
BASE_BIN
};
/* information describing a header field */
typedef struct header_field_info {
char *name;
char *abbrev;
enum ftenum type;
struct value_string *vals;
int id; /* assigned by order of registration */
int parent; /* parent protocol */
int display; /* for integers only, so far. Base and Endianness */
void *strings; /* val_string or true_false_string */
guint32 bitmask;
char *blurb; /* Brief description of field. */
int id; /* assigned by registration function, not programmer */
int parent; /* parent protocol */
int bitshift; /* bits to shift */
} header_field_info;
/* Used when registering many fields at once */
@ -90,10 +106,6 @@ typedef struct hf_register_info {
header_field_info hfinfo;
} hf_register_info;
#ifdef WIN32
/* 'boolean' is a reserved word on win32 */
#define boolean truth_value
#endif
/* Info stored in each proto_item GNode */
typedef struct field_info {
@ -134,9 +146,16 @@ void proto_init(void);
/* Frees memory used by proto routines. Called at program shutdown */
void proto_cleanup(void);
/* Set length of proto_item after having already been created. */
void proto_item_set_len(proto_item *ti, gint length);
/* Creates new proto_tree root */
proto_tree* proto_tree_create_root(void);
/* Clear memory for entry proto_tree. Clears proto_tree struct also. */
void proto_tree_free(proto_tree *tree);
/* Create a subtree under an existing item; returns tree pointer */
proto_tree* proto_item_add_subtree(proto_item *ti, gint idx);
int