1999-10-22 08:11:40 +00:00
|
|
|
/* packet-atalk.c
|
|
|
|
* Routines for Appletalk packet disassembly (DDP, currently).
|
1998-10-16 01:18:35 +00:00
|
|
|
*
|
2001-06-18 02:18:27 +00:00
|
|
|
* $Id: packet-atalk.c,v 1.55 2001/06/18 02:17:44 guy Exp $
|
1999-09-23 05:26:18 +00:00
|
|
|
*
|
1998-10-16 01:18:35 +00:00
|
|
|
* Simon Wilkinson <sxw@dcs.ed.ac.uk>
|
|
|
|
*
|
|
|
|
* 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
|
|
|
|
|
1999-11-04 07:06:50 +00:00
|
|
|
#ifdef HAVE_NETINET_IN_H
|
|
|
|
# include <netinet/in.h>
|
|
|
|
#endif
|
|
|
|
|
1999-03-23 03:14:46 +00:00
|
|
|
#include <glib.h>
|
|
|
|
#include "packet.h"
|
Change the sub-dissector handoff registration routines so that the
sub-dissector table is not stored in the header_field_info struct, but
in a separate namespace. Dissector tables are now registered by name
and not by field ID. For example:
udp_dissector_table = register_dissector_table("udp.port");
Because of this different namespace, dissector tables can have names
that are not field names. This is useful for ethertype, since multiple
fields are "ethertypes".
packet-ethertype.c replaces ethertype.c (the name was changed so that it
would be named in the same fashion as all the filenames passed to make-reg-dotc)
Although it registers no protocol or field, it registers one dissector table:
ethertype_dissector_table = register_dissector_table("ethertype");
All protocols that can be called because of an ethertype field now register
that fact with dissector_add() calls.
In this way, one dissector_table services all ethertype fields
(hf_eth_type, hf_llc_type, hf_null_etype, hf_vlan_etype)
Furthermore, the code allows for names of protocols to exist in the
etype_vals, yet a dissector for that protocol doesn't exist. The name
of the dissector is printed in COL_INFO. You're welcome, Richard. :-)
svn path=/trunk/; revision=1848
2000-04-13 18:18:56 +00:00
|
|
|
#include "etypes.h"
|
2000-04-16 21:37:07 +00:00
|
|
|
#include "ppptypes.h"
|
2000-11-17 06:02:21 +00:00
|
|
|
#include "aftypes.h"
|
2001-03-22 16:24:16 +00:00
|
|
|
#include "atalk-utils.h"
|
1999-03-23 03:14:46 +00:00
|
|
|
|
1999-07-29 05:47:07 +00:00
|
|
|
static int proto_ddp = -1;
|
1999-10-07 17:11:11 +00:00
|
|
|
static int hf_ddp_hopcount = -1;
|
|
|
|
static int hf_ddp_len = -1;
|
|
|
|
static int hf_ddp_checksum = -1;
|
|
|
|
static int hf_ddp_dst_net = -1;
|
|
|
|
static int hf_ddp_src_net = -1;
|
|
|
|
static int hf_ddp_dst_node = -1;
|
|
|
|
static int hf_ddp_src_node = -1;
|
|
|
|
static int hf_ddp_dst_socket = -1;
|
|
|
|
static int hf_ddp_src_socket = -1;
|
|
|
|
static int hf_ddp_type = -1;
|
1999-07-29 05:47:07 +00:00
|
|
|
|
1999-12-08 23:55:01 +00:00
|
|
|
static int proto_nbp = -1;
|
|
|
|
static int hf_nbp_op = -1;
|
|
|
|
static int hf_nbp_info = -1;
|
|
|
|
static int hf_nbp_count = -1;
|
|
|
|
static int hf_nbp_tid = -1;
|
|
|
|
|
1999-12-09 17:06:37 +00:00
|
|
|
static int hf_nbp_node_net = -1;
|
|
|
|
static int hf_nbp_node_port = -1;
|
|
|
|
static int hf_nbp_node_node = -1;
|
|
|
|
static int hf_nbp_node_enum = -1;
|
|
|
|
static int hf_nbp_node_object = -1;
|
|
|
|
static int hf_nbp_node_type = -1;
|
|
|
|
static int hf_nbp_node_zone = -1;
|
|
|
|
|
|
|
|
static int proto_rtmp = -1;
|
|
|
|
static int hf_rtmp_net = -1;
|
|
|
|
static int hf_rtmp_node_len = -1;
|
|
|
|
static int hf_rtmp_node = -1;
|
2000-11-13 04:26:14 +00:00
|
|
|
static int hf_rtmp_tuple_net = -1;
|
|
|
|
static int hf_rtmp_tuple_range_start = -1;
|
|
|
|
static int hf_rtmp_tuple_range_end = -1;
|
|
|
|
static int hf_rtmp_tuple_dist = -1;
|
|
|
|
static int hf_rtmp_function = -1;
|
1999-12-09 04:02:50 +00:00
|
|
|
|
1999-12-08 23:55:01 +00:00
|
|
|
static gint ett_nbp = -1;
|
|
|
|
static gint ett_nbp_info = -1;
|
1999-12-09 04:02:50 +00:00
|
|
|
static gint ett_nbp_node = -1;
|
1999-12-09 17:06:37 +00:00
|
|
|
static gint ett_rtmp = -1;
|
|
|
|
static gint ett_rtmp_tuple = -1;
|
1999-11-16 11:44:20 +00:00
|
|
|
static gint ett_ddp = -1;
|
1999-12-09 04:02:50 +00:00
|
|
|
static gint ett_pstring = -1;
|
1999-11-16 11:44:20 +00:00
|
|
|
|
2000-05-28 22:59:18 +00:00
|
|
|
static dissector_table_t ddp_dissector_table;
|
|
|
|
|
2000-11-11 09:18:15 +00:00
|
|
|
/*
|
|
|
|
* P = Padding, H = Hops, L = Len
|
|
|
|
*
|
|
|
|
* PPHHHHLL LLLLLLLL
|
|
|
|
*
|
|
|
|
* Assumes the argument is in host byte order.
|
|
|
|
*/
|
|
|
|
#define ddp_hops(x) ( ( x >> 10) & 0x3C )
|
|
|
|
#define ddp_len(x) ( x & 0x03ff )
|
1999-02-08 20:02:35 +00:00
|
|
|
typedef struct _e_ddp {
|
|
|
|
guint16 hops_len; /* combines pad, hops, and len */
|
1998-10-16 01:18:35 +00:00
|
|
|
guint16 sum,dnet,snet;
|
|
|
|
guint8 dnode,snode;
|
|
|
|
guint8 dport,sport;
|
|
|
|
guint8 type;
|
|
|
|
} e_ddp;
|
|
|
|
|
1999-10-07 17:11:11 +00:00
|
|
|
#define DDP_HEADER_SIZE 13
|
1998-10-16 01:18:35 +00:00
|
|
|
|
1999-10-22 08:11:40 +00:00
|
|
|
|
|
|
|
static const value_string op_vals[] = {
|
|
|
|
{DDP_RTMPDATA, "AppleTalk Routing Table response or data" },
|
|
|
|
{DDP_NBP, "AppleTalk Name Binding Protocol packet"},
|
|
|
|
{DDP_ATP, "AppleTalk Transaction Protocol packet"},
|
|
|
|
{DDP_AEP, "AppleTalk Echo Protocol packet"},
|
|
|
|
{DDP_RTMPREQ, "AppleTalk Routing Table request"},
|
|
|
|
{DDP_ZIP, "AppleTalk Zone Information Protocol packet"},
|
|
|
|
{DDP_ADSP, "AppleTalk Data Stream Protocol"},
|
2000-05-22 18:09:36 +00:00
|
|
|
{DDP_EIGRP, "Cisco EIGRP for AppleTalk"},
|
1999-10-22 08:11:40 +00:00
|
|
|
{0, NULL}
|
|
|
|
};
|
|
|
|
|
2000-11-13 04:26:14 +00:00
|
|
|
static const value_string rtmp_function_vals[] = {
|
|
|
|
{1, "Request"},
|
|
|
|
{2, "Route Data Request (split horizon processed)"},
|
|
|
|
{3, "Route Data Request (no split horizon processing)"},
|
|
|
|
{0, NULL}
|
|
|
|
};
|
|
|
|
|
1999-12-09 17:06:37 +00:00
|
|
|
#define NBP_LOOKUP 2
|
|
|
|
#define NBP_FORWARD 4
|
|
|
|
#define NBP_REPLY 3
|
|
|
|
|
1999-12-08 23:55:01 +00:00
|
|
|
static const value_string nbp_op_vals[] = {
|
|
|
|
{NBP_LOOKUP, "lookup"},
|
1999-12-09 17:06:37 +00:00
|
|
|
{NBP_FORWARD, "forward request"},
|
|
|
|
{NBP_REPLY, "reply"},
|
1999-12-08 23:55:01 +00:00
|
|
|
{0, NULL}
|
|
|
|
};
|
|
|
|
|
2000-11-13 04:26:14 +00:00
|
|
|
/*
|
|
|
|
* XXX - do this with an FT_UINT_STRING?
|
|
|
|
* Unfortunately, you can't extract from an FT_UINT_STRING the string,
|
|
|
|
* which we'd want to do in order to put it into the "Data:" portion.
|
|
|
|
*/
|
|
|
|
int dissect_pascal_string(tvbuff_t *tvb, int offset, proto_tree *tree,
|
|
|
|
int hf_index)
|
1999-12-09 04:02:50 +00:00
|
|
|
{
|
|
|
|
int len;
|
|
|
|
|
2000-11-13 04:26:14 +00:00
|
|
|
len = tvb_get_guint8(tvb, offset);
|
1999-12-09 04:02:50 +00:00
|
|
|
offset++;
|
|
|
|
|
|
|
|
if ( tree )
|
|
|
|
{
|
|
|
|
char *tmp;
|
|
|
|
proto_tree *item;
|
|
|
|
proto_tree *subtree;
|
|
|
|
|
2000-11-13 04:26:14 +00:00
|
|
|
/*
|
|
|
|
* XXX - if we could do this inside the protocol tree
|
|
|
|
* code, we could perhaps avoid allocating and freeing
|
|
|
|
* this string buffer.
|
|
|
|
*/
|
1999-12-09 04:02:50 +00:00
|
|
|
tmp = g_malloc( len+1 );
|
2000-11-13 04:26:14 +00:00
|
|
|
tvb_memcpy(tvb, tmp, offset, len);
|
1999-12-09 04:02:50 +00:00
|
|
|
tmp[len] = 0;
|
2000-11-13 04:26:14 +00:00
|
|
|
item = proto_tree_add_string(tree, hf_index, tvb, offset-1, len+1, tmp);
|
1999-12-09 04:02:50 +00:00
|
|
|
|
|
|
|
subtree = proto_item_add_subtree(item, ett_pstring);
|
2000-11-13 04:26:14 +00:00
|
|
|
proto_tree_add_text(subtree, tvb, offset-1, 1, "Length: %d", len);
|
|
|
|
proto_tree_add_text(subtree, tvb, offset, len, "Data: %s", tmp);
|
1999-12-09 04:02:50 +00:00
|
|
|
|
|
|
|
g_free(tmp);
|
|
|
|
}
|
|
|
|
offset += len;
|
|
|
|
|
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
|
1999-12-08 23:21:08 +00:00
|
|
|
static void
|
2000-11-13 04:26:14 +00:00
|
|
|
dissect_rtmp_request(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) {
|
|
|
|
proto_tree *rtmp_tree;
|
|
|
|
proto_item *ti;
|
|
|
|
guint8 function;
|
|
|
|
|
|
|
|
if (check_col(pinfo->fd, COL_PROTOCOL))
|
2000-11-19 08:54:37 +00:00
|
|
|
col_set_str(pinfo->fd, COL_PROTOCOL, "RTMP");
|
2001-01-22 03:33:45 +00:00
|
|
|
if (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_clear(pinfo->fd, COL_INFO);
|
|
|
|
|
|
|
|
function = tvb_get_guint8(tvb, 0);
|
2000-11-13 04:26:14 +00:00
|
|
|
|
|
|
|
if (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_add_fstr(pinfo->fd, COL_INFO, "%s",
|
|
|
|
val_to_str(function, rtmp_function_vals, "Unknown function (%02)"));
|
|
|
|
|
|
|
|
if (tree) {
|
|
|
|
ti = proto_tree_add_item(tree, proto_rtmp, tvb, 0, 1, FALSE);
|
|
|
|
rtmp_tree = proto_item_add_subtree(ti, ett_rtmp);
|
|
|
|
|
|
|
|
proto_tree_add_uint(rtmp_tree, hf_rtmp_function, tvb, 0, 1, function);
|
|
|
|
}
|
1999-12-08 23:25:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2000-11-13 04:26:14 +00:00
|
|
|
dissect_rtmp_data(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) {
|
1999-12-09 17:06:37 +00:00
|
|
|
proto_tree *rtmp_tree;
|
|
|
|
proto_item *ti;
|
2000-11-13 04:26:14 +00:00
|
|
|
int offset = 0;
|
1999-12-09 17:06:37 +00:00
|
|
|
guint16 net;
|
|
|
|
guint8 nodelen,nodelen_bits;
|
|
|
|
guint16 node; /* might be more than 8 bits */
|
|
|
|
int i;
|
|
|
|
|
2001-01-22 03:33:45 +00:00
|
|
|
if (check_col(pinfo->fd, COL_PROTOCOL))
|
|
|
|
col_set_str(pinfo->fd, COL_PROTOCOL, "RTMP");
|
|
|
|
if (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_clear(pinfo->fd, COL_INFO);
|
1999-12-09 17:06:37 +00:00
|
|
|
|
2000-11-13 04:26:14 +00:00
|
|
|
net = tvb_get_ntohs(tvb, offset);
|
|
|
|
nodelen_bits = tvb_get_guint8(tvb, offset+2);
|
1999-12-09 17:06:37 +00:00
|
|
|
if ( nodelen_bits <= 8 ) {
|
2000-11-13 04:26:14 +00:00
|
|
|
node = tvb_get_guint8(tvb, offset)+1;
|
|
|
|
nodelen = 1;
|
1999-12-09 17:06:37 +00:00
|
|
|
} else {
|
2000-11-13 04:26:14 +00:00
|
|
|
node = tvb_get_ntohs(tvb, offset);
|
|
|
|
nodelen = 2;
|
1999-12-09 17:06:37 +00:00
|
|
|
}
|
|
|
|
|
2000-11-13 04:26:14 +00:00
|
|
|
if (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_add_fstr(pinfo->fd, COL_INFO, "Net: %u Node Len: %u Node: %u",
|
1999-12-09 17:06:37 +00:00
|
|
|
net, nodelen_bits, node);
|
|
|
|
|
|
|
|
if (tree) {
|
2000-11-13 04:26:14 +00:00
|
|
|
ti = proto_tree_add_item(tree, proto_rtmp, tvb, offset,
|
|
|
|
tvb_length_remaining(tvb, offset), FALSE);
|
1999-12-09 17:06:37 +00:00
|
|
|
rtmp_tree = proto_item_add_subtree(ti, ett_rtmp);
|
|
|
|
|
2000-11-13 04:26:14 +00:00
|
|
|
proto_tree_add_uint(rtmp_tree, hf_rtmp_net, tvb, offset, 2, net);
|
|
|
|
proto_tree_add_uint(rtmp_tree, hf_rtmp_node_len, tvb, offset+2, 1,
|
|
|
|
nodelen_bits);
|
|
|
|
proto_tree_add_uint(rtmp_tree, hf_rtmp_node, tvb, offset+3, nodelen,
|
|
|
|
node);
|
1999-12-09 17:06:37 +00:00
|
|
|
offset += 3 + nodelen;
|
|
|
|
|
|
|
|
i = 1;
|
2000-11-13 08:58:17 +00:00
|
|
|
while (tvb_offset_exists(tvb, offset)) {
|
2000-11-13 04:26:14 +00:00
|
|
|
proto_tree *tuple_item, *tuple_tree;
|
|
|
|
guint16 tuple_net;
|
|
|
|
guint8 tuple_dist;
|
|
|
|
guint16 tuple_range_end;
|
|
|
|
|
|
|
|
tuple_net = tvb_get_ntohs(tvb, offset);
|
|
|
|
tuple_dist = tvb_get_guint8(tvb, offset+2);
|
|
|
|
|
|
|
|
if (tuple_dist & 0x80) {
|
|
|
|
tuple_range_end = tvb_get_ntohs(tvb, offset+3);
|
|
|
|
tuple_item = proto_tree_add_text(rtmp_tree, tvb, offset, 6,
|
|
|
|
"Tuple %d: Range Start: %u Dist: %u Range End: %u",
|
|
|
|
i, tuple_net, tuple_dist&0x7F, tuple_range_end);
|
|
|
|
} else {
|
|
|
|
tuple_item = proto_tree_add_text(rtmp_tree, tvb, offset, 3,
|
|
|
|
"Tuple %d: Net: %u Dist: %u",
|
1999-12-09 17:06:37 +00:00
|
|
|
i, tuple_net, tuple_dist);
|
2000-11-13 04:26:14 +00:00
|
|
|
}
|
|
|
|
tuple_tree = proto_item_add_subtree(tuple_item, ett_rtmp_tuple);
|
1999-12-09 17:06:37 +00:00
|
|
|
|
2000-11-13 04:26:14 +00:00
|
|
|
if (tuple_dist & 0x80) {
|
|
|
|
proto_tree_add_uint(tuple_tree, hf_rtmp_tuple_range_start, tvb, offset, 2,
|
1999-12-09 17:06:37 +00:00
|
|
|
tuple_net);
|
2000-11-13 04:26:14 +00:00
|
|
|
} else {
|
|
|
|
proto_tree_add_uint(tuple_tree, hf_rtmp_tuple_net, tvb, offset, 2,
|
|
|
|
tuple_net);
|
|
|
|
}
|
|
|
|
proto_tree_add_uint(tuple_tree, hf_rtmp_tuple_dist, tvb, offset+2, 1,
|
|
|
|
tuple_dist & 0x7F);
|
|
|
|
|
|
|
|
if (tuple_dist & 0x80) {
|
|
|
|
/*
|
|
|
|
* Extended network tuple.
|
|
|
|
*/
|
|
|
|
proto_tree_add_item(tuple_tree, hf_rtmp_tuple_range_end, tvb, offset+3, 2,
|
|
|
|
FALSE);
|
|
|
|
offset += 6;
|
|
|
|
} else
|
|
|
|
offset += 3;
|
|
|
|
|
|
|
|
i++;
|
|
|
|
}
|
1999-12-09 17:06:37 +00:00
|
|
|
}
|
1999-12-08 23:21:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2000-11-13 04:26:14 +00:00
|
|
|
dissect_nbp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) {
|
1999-12-08 23:55:01 +00:00
|
|
|
proto_tree *nbp_tree;
|
|
|
|
proto_tree *nbp_info_tree;
|
|
|
|
proto_item *ti, *info_item;
|
2000-11-13 04:26:14 +00:00
|
|
|
int offset = 0;
|
|
|
|
guint8 info;
|
1999-12-08 23:55:01 +00:00
|
|
|
guint op, count;
|
2001-04-27 01:27:37 +00:00
|
|
|
unsigned int i;
|
1999-12-08 23:55:01 +00:00
|
|
|
|
2001-01-22 03:33:45 +00:00
|
|
|
if (check_col(pinfo->fd, COL_PROTOCOL))
|
|
|
|
col_set_str(pinfo->fd, COL_PROTOCOL, "NBP");
|
|
|
|
if (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_clear(pinfo->fd, COL_INFO);
|
1999-12-08 23:55:01 +00:00
|
|
|
|
2000-11-13 04:26:14 +00:00
|
|
|
info = tvb_get_guint8(tvb, offset);
|
|
|
|
op = info >> 4;
|
|
|
|
count = info & 0x0F;
|
1999-12-08 23:55:01 +00:00
|
|
|
|
2000-11-13 04:26:14 +00:00
|
|
|
if (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_add_fstr(pinfo->fd, COL_INFO, "Op: %s Count: %u",
|
|
|
|
val_to_str(op, nbp_op_vals, "Unknown (0x%01x)"), count);
|
1999-12-08 23:55:01 +00:00
|
|
|
|
|
|
|
if (tree) {
|
2001-04-23 04:29:54 +00:00
|
|
|
ti = proto_tree_add_item(tree, proto_nbp, tvb, offset,
|
|
|
|
tvb_length_remaining(tvb, offset), FALSE);
|
1999-12-08 23:55:01 +00:00
|
|
|
nbp_tree = proto_item_add_subtree(ti, ett_nbp);
|
|
|
|
|
2000-11-13 04:26:14 +00:00
|
|
|
info_item = proto_tree_add_uint_format(nbp_tree, hf_nbp_info, tvb, offset, 1,
|
|
|
|
info,
|
|
|
|
"Info: 0x%01X Operation: %s Count: %u", info,
|
|
|
|
val_to_str(op, nbp_op_vals, "Unknown (0x%01X)"),
|
1999-12-08 23:55:01 +00:00
|
|
|
count);
|
2000-11-13 04:26:14 +00:00
|
|
|
nbp_info_tree = proto_item_add_subtree(info_item, ett_nbp_info);
|
|
|
|
proto_tree_add_uint(nbp_info_tree, hf_nbp_op, tvb, offset, 1, info);
|
|
|
|
proto_tree_add_uint(nbp_info_tree, hf_nbp_count, tvb, offset, 1, info);
|
|
|
|
proto_tree_add_item(nbp_tree, hf_nbp_tid, tvb, offset+1, 1, FALSE);
|
|
|
|
offset += 2;
|
1999-12-09 04:02:50 +00:00
|
|
|
|
|
|
|
for (i=0; i<count; i++) {
|
2000-11-13 04:26:14 +00:00
|
|
|
proto_tree *node_item,*node_tree;
|
|
|
|
int soffset = offset;
|
1999-12-09 04:02:50 +00:00
|
|
|
|
2000-11-13 04:26:14 +00:00
|
|
|
node_item = proto_tree_add_text(nbp_tree, tvb, offset, 4,
|
1999-12-09 04:02:50 +00:00
|
|
|
"Node %d", i+1);
|
2000-11-13 04:26:14 +00:00
|
|
|
node_tree = proto_item_add_subtree(node_item, ett_nbp_node);
|
|
|
|
|
|
|
|
proto_tree_add_item(node_tree, hf_nbp_node_net, tvb, offset, 2, FALSE);
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(node_tree, hf_nbp_node_node, tvb, offset, 1, FALSE);
|
|
|
|
offset++;
|
|
|
|
proto_tree_add_item(node_tree, hf_nbp_node_port, tvb, offset, 1, FALSE);
|
|
|
|
offset++;
|
|
|
|
proto_tree_add_item(node_tree, hf_nbp_node_enum, tvb, offset, 1, FALSE);
|
|
|
|
offset++;
|
|
|
|
|
|
|
|
offset = dissect_pascal_string(tvb, offset, node_tree, hf_nbp_node_object);
|
|
|
|
offset = dissect_pascal_string(tvb, offset, node_tree, hf_nbp_node_type);
|
|
|
|
offset = dissect_pascal_string(tvb, offset, node_tree, hf_nbp_node_zone);
|
|
|
|
|
|
|
|
proto_item_set_len(node_item, offset-soffset);
|
|
|
|
}
|
1999-12-08 23:55:01 +00:00
|
|
|
}
|
|
|
|
|
1999-12-08 23:21:08 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2000-11-17 06:02:21 +00:00
|
|
|
static void
|
2000-11-13 04:26:14 +00:00
|
|
|
dissect_ddp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) {
|
1998-10-16 01:18:35 +00:00
|
|
|
e_ddp ddp;
|
1999-03-23 03:14:46 +00:00
|
|
|
proto_tree *ddp_tree;
|
|
|
|
proto_item *ti;
|
2000-11-19 08:20:34 +00:00
|
|
|
static struct atalk_ddp_addr src, dst;
|
2000-11-13 04:26:14 +00:00
|
|
|
tvbuff_t *new_tvb;
|
1998-10-16 01:18:35 +00:00
|
|
|
|
2001-01-22 03:33:45 +00:00
|
|
|
if (check_col(pinfo->fd, COL_PROTOCOL))
|
|
|
|
col_set_str(pinfo->fd, COL_PROTOCOL, "DDP");
|
|
|
|
if (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_clear(pinfo->fd, COL_INFO);
|
1999-10-07 17:11:11 +00:00
|
|
|
|
2000-11-13 04:26:14 +00:00
|
|
|
tvb_memcpy(tvb, (guint8 *)&ddp, 0, sizeof(e_ddp));
|
1998-10-16 01:18:35 +00:00
|
|
|
ddp.dnet=ntohs(ddp.dnet);
|
|
|
|
ddp.snet=ntohs(ddp.snet);
|
|
|
|
ddp.sum=ntohs(ddp.sum);
|
2000-11-11 09:18:15 +00:00
|
|
|
ddp.hops_len=ntohs(ddp.hops_len);
|
1998-10-16 01:18:35 +00:00
|
|
|
|
1999-10-22 08:11:40 +00:00
|
|
|
src.net = ddp.snet;
|
|
|
|
src.node = ddp.snode;
|
|
|
|
src.port = ddp.sport;
|
|
|
|
dst.net = ddp.dnet;
|
|
|
|
dst.node = ddp.dnode;
|
|
|
|
dst.port = ddp.dport;
|
2000-11-13 04:26:14 +00:00
|
|
|
SET_ADDRESS(&pinfo->net_src, AT_ATALK, sizeof src, (guint8 *)&src);
|
|
|
|
SET_ADDRESS(&pinfo->src, AT_ATALK, sizeof src, (guint8 *)&src);
|
|
|
|
SET_ADDRESS(&pinfo->net_dst, AT_ATALK, sizeof dst, (guint8 *)&dst);
|
|
|
|
SET_ADDRESS(&pinfo->dst, AT_ATALK, sizeof dst, (guint8 *)&dst);
|
|
|
|
|
|
|
|
if (check_col(pinfo->fd, COL_INFO))
|
|
|
|
col_add_str(pinfo->fd, COL_INFO,
|
1998-10-20 05:31:03 +00:00
|
|
|
val_to_str(ddp.type, op_vals, "Unknown DDP protocol (%02x)"));
|
1998-10-16 01:18:35 +00:00
|
|
|
|
|
|
|
if (tree) {
|
2000-11-13 04:26:14 +00:00
|
|
|
ti = proto_tree_add_item(tree, proto_ddp, tvb, 0, DDP_HEADER_SIZE,
|
|
|
|
FALSE);
|
1999-11-16 11:44:20 +00:00
|
|
|
ddp_tree = proto_item_add_subtree(ti, ett_ddp);
|
2000-11-13 04:26:14 +00:00
|
|
|
proto_tree_add_uint(ddp_tree, hf_ddp_hopcount, tvb, 0, 1,
|
1999-10-07 17:11:11 +00:00
|
|
|
ddp_hops(ddp.hops_len));
|
2000-11-13 04:26:14 +00:00
|
|
|
proto_tree_add_uint(ddp_tree, hf_ddp_len, tvb, 0, 2,
|
1999-10-07 17:11:11 +00:00
|
|
|
ddp_len(ddp.hops_len));
|
2000-11-13 04:26:14 +00:00
|
|
|
proto_tree_add_uint(ddp_tree, hf_ddp_checksum, tvb, 2, 2,
|
|
|
|
ddp.sum);
|
|
|
|
proto_tree_add_uint(ddp_tree, hf_ddp_dst_net, tvb, 4, 2,
|
|
|
|
ddp.dnet);
|
|
|
|
proto_tree_add_uint(ddp_tree, hf_ddp_src_net, tvb, 6, 2,
|
|
|
|
ddp.snet);
|
|
|
|
proto_tree_add_uint(ddp_tree, hf_ddp_dst_node, tvb, 8, 1,
|
|
|
|
ddp.dnode);
|
|
|
|
proto_tree_add_uint(ddp_tree, hf_ddp_src_node, tvb, 9, 1,
|
|
|
|
ddp.snode);
|
|
|
|
proto_tree_add_uint(ddp_tree, hf_ddp_dst_socket, tvb, 10, 1,
|
|
|
|
ddp.dport);
|
|
|
|
proto_tree_add_uint(ddp_tree, hf_ddp_src_socket, tvb, 11, 1,
|
|
|
|
ddp.sport);
|
|
|
|
proto_tree_add_uint(ddp_tree, hf_ddp_type, tvb, 12, 1,
|
|
|
|
ddp.type);
|
1998-10-16 01:18:35 +00:00
|
|
|
}
|
|
|
|
|
2000-11-13 04:26:14 +00:00
|
|
|
new_tvb = tvb_new_subset(tvb, DDP_HEADER_SIZE, -1, -1);
|
1998-10-16 01:18:35 +00:00
|
|
|
|
2000-11-13 04:26:14 +00:00
|
|
|
if (!dissector_try_port(ddp_dissector_table, ddp.type, new_tvb, pinfo, tree))
|
2000-11-16 07:35:43 +00:00
|
|
|
dissect_data(new_tvb, 0, pinfo, tree);
|
1998-10-16 01:18:35 +00:00
|
|
|
}
|
1999-07-29 05:47:07 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
proto_register_atalk(void)
|
|
|
|
{
|
1999-12-08 23:55:01 +00:00
|
|
|
static hf_register_info hf_ddp[] = {
|
1999-10-07 17:11:11 +00:00
|
|
|
{ &hf_ddp_hopcount,
|
1999-10-12 06:21:15 +00:00
|
|
|
{ "Hop count", "ddp.hopcount", FT_UINT8, BASE_DEC, NULL, 0x0,
|
2001-06-18 02:18:27 +00:00
|
|
|
"", HFILL }},
|
1999-10-12 06:21:15 +00:00
|
|
|
|
1999-10-07 17:11:11 +00:00
|
|
|
{ &hf_ddp_len,
|
1999-10-12 06:21:15 +00:00
|
|
|
{ "Datagram length", "ddp.len", FT_UINT16, BASE_DEC, NULL, 0x0,
|
2001-06-18 02:18:27 +00:00
|
|
|
"", HFILL }},
|
1999-10-12 06:21:15 +00:00
|
|
|
|
1999-10-07 17:11:11 +00:00
|
|
|
{ &hf_ddp_checksum,
|
1999-10-12 06:21:15 +00:00
|
|
|
{ "Checksum", "ddp.checksum", FT_UINT16, BASE_DEC, NULL, 0x0,
|
2001-06-18 02:18:27 +00:00
|
|
|
"", HFILL }},
|
1999-10-12 06:21:15 +00:00
|
|
|
|
1999-10-07 17:11:11 +00:00
|
|
|
{ &hf_ddp_dst_net,
|
1999-10-12 06:21:15 +00:00
|
|
|
{ "Destination Net", "ddp.dst.net", FT_UINT16, BASE_DEC, NULL, 0x0,
|
2001-06-18 02:18:27 +00:00
|
|
|
"", HFILL }},
|
1999-10-12 06:21:15 +00:00
|
|
|
|
1999-10-07 17:11:11 +00:00
|
|
|
{ &hf_ddp_src_net,
|
1999-10-12 06:21:15 +00:00
|
|
|
{ "Source Net", "ddp.src.net", FT_UINT16, BASE_DEC, NULL, 0x0,
|
2001-06-18 02:18:27 +00:00
|
|
|
"", HFILL }},
|
1999-10-12 06:21:15 +00:00
|
|
|
|
1999-10-07 17:11:11 +00:00
|
|
|
{ &hf_ddp_dst_node,
|
1999-10-12 06:21:15 +00:00
|
|
|
{ "Destination Node", "ddp.dst.node", FT_UINT8, BASE_DEC, NULL, 0x0,
|
2001-06-18 02:18:27 +00:00
|
|
|
"", HFILL }},
|
1999-10-12 06:21:15 +00:00
|
|
|
|
1999-10-07 17:11:11 +00:00
|
|
|
{ &hf_ddp_src_node,
|
1999-10-12 06:21:15 +00:00
|
|
|
{ "Source Node", "ddp.src.node", FT_UINT8, BASE_DEC, NULL, 0x0,
|
2001-06-18 02:18:27 +00:00
|
|
|
"", HFILL }},
|
1999-10-12 06:21:15 +00:00
|
|
|
|
1999-10-07 17:11:11 +00:00
|
|
|
{ &hf_ddp_dst_socket,
|
1999-10-12 06:21:15 +00:00
|
|
|
{ "Destination Socket", "ddp.dst.socket", FT_UINT8, BASE_DEC, NULL, 0x0,
|
2001-06-18 02:18:27 +00:00
|
|
|
"", HFILL }},
|
1999-10-12 06:21:15 +00:00
|
|
|
|
1999-10-07 17:11:11 +00:00
|
|
|
{ &hf_ddp_src_socket,
|
1999-10-12 06:21:15 +00:00
|
|
|
{ "Source Socket", "ddp.src.socket", FT_UINT8, BASE_DEC, NULL, 0x0,
|
2001-06-18 02:18:27 +00:00
|
|
|
"", HFILL }},
|
1999-10-12 06:21:15 +00:00
|
|
|
|
1999-10-07 17:11:11 +00:00
|
|
|
{ &hf_ddp_type,
|
1999-10-22 08:11:40 +00:00
|
|
|
{ "Protocol type", "ddp.type", FT_UINT8, BASE_DEC, VALS(op_vals), 0x0,
|
2001-06-18 02:18:27 +00:00
|
|
|
"", HFILL }},
|
1999-10-07 17:11:11 +00:00
|
|
|
};
|
1999-12-08 23:55:01 +00:00
|
|
|
|
|
|
|
static hf_register_info hf_nbp[] = {
|
|
|
|
{ &hf_nbp_op,
|
|
|
|
{ "Operation", "nbp.op", FT_UINT8, BASE_DEC,
|
2001-06-18 02:18:27 +00:00
|
|
|
VALS(nbp_op_vals), 0xF0, "Operation", HFILL }},
|
1999-12-08 23:55:01 +00:00
|
|
|
{ &hf_nbp_info,
|
|
|
|
{ "Info", "nbp.info", FT_UINT8, BASE_HEX,
|
2001-06-18 02:18:27 +00:00
|
|
|
NULL, 0x0, "Info", HFILL }},
|
1999-12-08 23:55:01 +00:00
|
|
|
{ &hf_nbp_count,
|
|
|
|
{ "Count", "nbp.count", FT_UINT8, BASE_DEC,
|
2001-06-18 02:18:27 +00:00
|
|
|
NULL, 0x0F, "Count", HFILL }},
|
1999-12-09 04:02:50 +00:00
|
|
|
{ &hf_nbp_node_net,
|
|
|
|
{ "Network", "nbp.net", FT_UINT16, BASE_DEC,
|
2001-06-18 02:18:27 +00:00
|
|
|
NULL, 0x0, "Network", HFILL }},
|
1999-12-09 04:02:50 +00:00
|
|
|
{ &hf_nbp_node_node,
|
|
|
|
{ "Node", "nbp.node", FT_UINT8, BASE_DEC,
|
2001-06-18 02:18:27 +00:00
|
|
|
NULL, 0x0, "Node", HFILL }},
|
1999-12-09 04:02:50 +00:00
|
|
|
{ &hf_nbp_node_port,
|
|
|
|
{ "Port", "nbp.port", FT_UINT8, BASE_DEC,
|
2001-06-18 02:18:27 +00:00
|
|
|
NULL, 0x0, "Port", HFILL }},
|
1999-12-09 15:31:24 +00:00
|
|
|
{ &hf_nbp_node_enum,
|
|
|
|
{ "Enumerator", "nbp.enum", FT_UINT8, BASE_DEC,
|
2001-06-18 02:18:27 +00:00
|
|
|
NULL, 0x0, "Enumerator", HFILL }},
|
1999-12-09 15:31:24 +00:00
|
|
|
{ &hf_nbp_node_object,
|
|
|
|
{ "Object", "nbp.object", FT_STRING, BASE_DEC,
|
2001-06-18 02:18:27 +00:00
|
|
|
NULL, 0x0, "Object", HFILL }},
|
1999-12-09 04:02:50 +00:00
|
|
|
{ &hf_nbp_node_type,
|
|
|
|
{ "Type", "nbp.type", FT_STRING, BASE_DEC,
|
2001-06-18 02:18:27 +00:00
|
|
|
NULL, 0x0, "Type", HFILL }},
|
1999-12-09 15:31:24 +00:00
|
|
|
{ &hf_nbp_node_zone,
|
|
|
|
{ "Zone", "nbp.zone", FT_STRING, BASE_DEC,
|
2001-06-18 02:18:27 +00:00
|
|
|
NULL, 0x0, "Zone", HFILL }},
|
1999-12-08 23:55:01 +00:00
|
|
|
{ &hf_nbp_tid,
|
|
|
|
{ "Transaction ID", "nbp.tid", FT_UINT8, BASE_DEC,
|
2001-06-18 02:18:27 +00:00
|
|
|
NULL, 0x0, "Transaction ID", HFILL }}
|
1999-12-08 23:55:01 +00:00
|
|
|
};
|
|
|
|
|
1999-12-09 17:06:37 +00:00
|
|
|
static hf_register_info hf_rtmp[] = {
|
|
|
|
{ &hf_rtmp_net,
|
|
|
|
{ "Net", "rtmp.net", FT_UINT16, BASE_DEC,
|
2001-06-18 02:18:27 +00:00
|
|
|
NULL, 0x0, "Net", HFILL }},
|
1999-12-09 17:06:37 +00:00
|
|
|
{ &hf_rtmp_node,
|
|
|
|
{ "Node", "nbp.nodeid", FT_UINT8, BASE_DEC,
|
2001-06-18 02:18:27 +00:00
|
|
|
NULL, 0x0, "Node", HFILL }},
|
1999-12-09 17:06:37 +00:00
|
|
|
{ &hf_rtmp_node_len,
|
|
|
|
{ "Node Length", "nbp.nodeid.length", FT_UINT8, BASE_DEC,
|
2001-06-18 02:18:27 +00:00
|
|
|
NULL, 0x0, "Node Length", HFILL }},
|
1999-12-09 17:06:37 +00:00
|
|
|
{ &hf_rtmp_tuple_net,
|
|
|
|
{ "Net", "rtmp.tuple.net", FT_UINT16, BASE_DEC,
|
2001-06-18 02:18:27 +00:00
|
|
|
NULL, 0x0, "Net", HFILL }},
|
2000-11-13 04:26:14 +00:00
|
|
|
{ &hf_rtmp_tuple_range_start,
|
|
|
|
{ "Range Start", "rtmp.tuple.range_start", FT_UINT16, BASE_DEC,
|
2001-06-18 02:18:27 +00:00
|
|
|
NULL, 0x0, "Range Start", HFILL }},
|
2000-11-13 04:26:14 +00:00
|
|
|
{ &hf_rtmp_tuple_range_end,
|
|
|
|
{ "Range End", "rtmp.tuple.range_end", FT_UINT16, BASE_DEC,
|
2001-06-18 02:18:27 +00:00
|
|
|
NULL, 0x0, "Range End", HFILL }},
|
1999-12-09 17:06:37 +00:00
|
|
|
{ &hf_rtmp_tuple_dist,
|
|
|
|
{ "Distance", "rtmp.tuple.dist", FT_UINT16, BASE_DEC,
|
2001-06-18 02:18:27 +00:00
|
|
|
NULL, 0x0, "Distance", HFILL }},
|
2000-11-13 04:26:14 +00:00
|
|
|
{ &hf_rtmp_function,
|
|
|
|
{ "Function", "rtmp.function", FT_UINT8, BASE_DEC,
|
2001-06-18 02:18:27 +00:00
|
|
|
VALS(rtmp_function_vals), 0x0, "Request Function", HFILL }}
|
1999-12-09 17:06:37 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
1999-11-16 11:44:20 +00:00
|
|
|
static gint *ett[] = {
|
2001-01-03 06:56:03 +00:00
|
|
|
&ett_ddp,
|
1999-12-08 23:55:01 +00:00
|
|
|
&ett_nbp,
|
1999-12-09 04:02:50 +00:00
|
|
|
&ett_nbp_info,
|
|
|
|
&ett_nbp_node,
|
1999-12-09 17:06:37 +00:00
|
|
|
&ett_pstring,
|
|
|
|
&ett_rtmp,
|
|
|
|
&ett_rtmp_tuple
|
1999-11-16 11:44:20 +00:00
|
|
|
};
|
1999-07-29 05:47:07 +00:00
|
|
|
|
2001-01-03 06:56:03 +00:00
|
|
|
proto_ddp = proto_register_protocol("Datagram Delivery Protocol", "DDP", "ddp");
|
1999-12-08 23:55:01 +00:00
|
|
|
proto_register_field_array(proto_ddp, hf_ddp, array_length(hf_ddp));
|
|
|
|
|
2001-01-03 06:56:03 +00:00
|
|
|
proto_nbp = proto_register_protocol("Name Binding Protocol", "NBP", "nbp");
|
1999-12-08 23:55:01 +00:00
|
|
|
proto_register_field_array(proto_nbp, hf_nbp, array_length(hf_nbp));
|
|
|
|
|
2000-11-13 04:26:14 +00:00
|
|
|
proto_rtmp = proto_register_protocol("Routing Table Maintenance Protocol",
|
2001-01-03 06:56:03 +00:00
|
|
|
"RTMP", "rtmp");
|
1999-12-09 17:06:37 +00:00
|
|
|
proto_register_field_array(proto_rtmp, hf_rtmp, array_length(hf_rtmp));
|
|
|
|
|
1999-11-16 11:44:20 +00:00
|
|
|
proto_register_subtree_array(ett, array_length(ett));
|
2000-05-28 22:59:18 +00:00
|
|
|
|
|
|
|
/* subdissector code */
|
|
|
|
ddp_dissector_table = register_dissector_table("ddp.type");
|
1999-07-29 05:47:07 +00:00
|
|
|
}
|
Change the sub-dissector handoff registration routines so that the
sub-dissector table is not stored in the header_field_info struct, but
in a separate namespace. Dissector tables are now registered by name
and not by field ID. For example:
udp_dissector_table = register_dissector_table("udp.port");
Because of this different namespace, dissector tables can have names
that are not field names. This is useful for ethertype, since multiple
fields are "ethertypes".
packet-ethertype.c replaces ethertype.c (the name was changed so that it
would be named in the same fashion as all the filenames passed to make-reg-dotc)
Although it registers no protocol or field, it registers one dissector table:
ethertype_dissector_table = register_dissector_table("ethertype");
All protocols that can be called because of an ethertype field now register
that fact with dissector_add() calls.
In this way, one dissector_table services all ethertype fields
(hf_eth_type, hf_llc_type, hf_null_etype, hf_vlan_etype)
Furthermore, the code allows for names of protocols to exist in the
etype_vals, yet a dissector for that protocol doesn't exist. The name
of the dissector is printed in COL_INFO. You're welcome, Richard. :-)
svn path=/trunk/; revision=1848
2000-04-13 18:18:56 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
proto_reg_handoff_atalk(void)
|
|
|
|
{
|
2001-01-09 06:32:10 +00:00
|
|
|
dissector_add("ethertype", ETHERTYPE_ATALK, dissect_ddp, proto_ddp);
|
Add a new Wiretap encapsulation type for Cisco HDLC. Map the NetBSD
DLT_HDLC to it.
Make a separate dissector for Cisco HDLC, and add a dissector for Cisco
SLARP. Have the PPP dissector call the Cisco HDLC dissector if the
address field is the Cisco HDLC unicast or multicast address. Use the
Cisco HDLC dissector for the Cisco HDLC Wiretap encapsulation type.
Add a new dissector table "chdlctype", for Cisco HDLC packet types
(they're *almost* the same as Ethernet types, but 0x8035 is SLARP, not
Reverse ARP, and 0x2000 is the Cisco Discovery protocol, for example),
replacing "fr.chdlc".
Have a "chdlctype()" routine, similar to "ethertype()", used both by the
Cisco HDLC and Frame Relay dissectors. Have a "chdlc_vals[]"
"value_string" table for Cisco HDLC types and protocol names. Split the
packet type field in the Frame Relay dissector into separate SNAP and
Cisco HDLC fields, and give them the Ethernet type and Cisco HDLC type
"value_string" tables, respectively.
svn path=/trunk/; revision=3133
2001-03-15 09:11:03 +00:00
|
|
|
dissector_add("chdlctype", ETHERTYPE_ATALK, dissect_ddp, proto_ddp);
|
2001-01-09 06:32:10 +00:00
|
|
|
dissector_add("ppp.protocol", PPP_AT, dissect_ddp, proto_ddp);
|
|
|
|
dissector_add("null.type", BSD_AF_APPLETALK, dissect_ddp, proto_ddp);
|
|
|
|
dissector_add("ddp.type", DDP_NBP, dissect_nbp, proto_nbp);
|
|
|
|
dissector_add("ddp.type", DDP_RTMPREQ, dissect_rtmp_request, proto_rtmp);
|
|
|
|
dissector_add("ddp.type", DDP_RTMPDATA, dissect_rtmp_data, proto_rtmp);
|
Change the sub-dissector handoff registration routines so that the
sub-dissector table is not stored in the header_field_info struct, but
in a separate namespace. Dissector tables are now registered by name
and not by field ID. For example:
udp_dissector_table = register_dissector_table("udp.port");
Because of this different namespace, dissector tables can have names
that are not field names. This is useful for ethertype, since multiple
fields are "ethertypes".
packet-ethertype.c replaces ethertype.c (the name was changed so that it
would be named in the same fashion as all the filenames passed to make-reg-dotc)
Although it registers no protocol or field, it registers one dissector table:
ethertype_dissector_table = register_dissector_table("ethertype");
All protocols that can be called because of an ethertype field now register
that fact with dissector_add() calls.
In this way, one dissector_table services all ethertype fields
(hf_eth_type, hf_llc_type, hf_null_etype, hf_vlan_etype)
Furthermore, the code allows for names of protocols to exist in the
etype_vals, yet a dissector for that protocol doesn't exist. The name
of the dissector is printed in COL_INFO. You're welcome, Richard. :-)
svn path=/trunk/; revision=1848
2000-04-13 18:18:56 +00:00
|
|
|
}
|