2001-05-24 20:25:25 +00:00
|
|
|
/* packet-dsi.c
|
|
|
|
* Routines for dsi packet dissection
|
|
|
|
* Copyright 2001, Randy McEoin <rmceoin@pe.com>
|
|
|
|
*
|
2004-07-18 00:24:25 +00:00
|
|
|
* $Id$
|
2001-05-24 20:25:25 +00:00
|
|
|
*
|
2006-05-21 04:49:01 +00:00
|
|
|
* Wireshark - Network traffic analyzer
|
|
|
|
* By Gerald Combs <gerald@wireshark.org>
|
2001-05-24 20:25:25 +00:00
|
|
|
* Copyright 1998 Gerald Combs
|
|
|
|
*
|
|
|
|
* Copied from packet-pop.c
|
|
|
|
*
|
|
|
|
* 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.
|
2002-08-28 21:04:11 +00:00
|
|
|
*
|
2001-05-24 20:25:25 +00:00
|
|
|
* 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.
|
2002-08-28 21:04:11 +00:00
|
|
|
*
|
2001-05-24 20:25:25 +00:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
2012-06-28 22:56:06 +00:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
2001-05-24 20:25:25 +00:00
|
|
|
*/
|
|
|
|
|
2012-09-20 02:03:38 +00:00
|
|
|
#include "config.h"
|
2001-05-24 20:25:25 +00:00
|
|
|
|
|
|
|
#include <glib.h>
|
2002-01-21 07:37:49 +00:00
|
|
|
#include <epan/packet.h>
|
2002-04-22 08:50:49 +00:00
|
|
|
|
2004-09-27 22:55:15 +00:00
|
|
|
#include <epan/prefs.h>
|
Make a "tcp_dissect_pdus()" with the standard loop for a TCP segment,
extracting PDUs from it and possibly doing reassembly. Make the COPS,
DNS, DSI, Gryphon, and SCCP dissectors use it.
Add "set_actual_length()", "tcp_dissect_pdus()",
"decode_boolean_bitfield()", "decode_numeric_bitfield()", and
"decode_enumerated_bitfield()" to the list of routines available to
dissectors on platforms where routines in the main program aren't
available to dynamically-loaded code.
Declare routines in "to_str.h" as "extern"; as I remember, that's
necessary to allow the "decode_XXX_bitfield()" routines declared therein
to be made available to plugins as per the above.
Note that new exported routines should be added to the end of the table
if that's the only change being made to the table.
Create a new "plugin_api_decls.h" header file, used to declare both the
"p_" variables and the "p_" structure members in the routine-exporting
mechanism; this reduces the number of places you have to change to
change the list of exported routines.
svn path=/trunk/; revision=5394
2002-05-05 00:16:38 +00:00
|
|
|
#include "packet-tcp.h"
|
2002-04-25 23:58:02 +00:00
|
|
|
#include "packet-afp.h"
|
|
|
|
|
2001-05-24 20:25:25 +00:00
|
|
|
/* The information in this module (DSI) comes from:
|
|
|
|
|
2008-03-14 03:28:12 +00:00
|
|
|
AFP 2.1 & 2.2 documentation, in PDF form, at
|
|
|
|
|
|
|
|
http://developer.apple.com/DOCUMENTATION/macos8/pdf/ASAppleTalkFiling2.1_2.2.pdf
|
2001-05-24 20:25:25 +00:00
|
|
|
|
|
|
|
The netatalk source code by Wesley Craig & Adrian Sun
|
|
|
|
|
2005-03-31 22:04:59 +00:00
|
|
|
The Data Stream Interface description from
|
|
|
|
http://developer.apple.com/documentation/Networking/Conceptual/AFPClient/AFPClient-6.html
|
|
|
|
|
2008-03-14 03:28:12 +00:00
|
|
|
(no longer available, apparently)
|
2010-11-08 21:59:39 +00:00
|
|
|
|
|
|
|
Also, AFP 3.3 documents parts of DSI at:
|
2009-09-10 06:07:31 +00:00
|
|
|
http://developer.apple.com/mac/library/documentation/Networking/Conceptual/AFP/Introduction/Introduction.html
|
2008-03-14 03:28:12 +00:00
|
|
|
|
2001-05-24 20:25:25 +00:00
|
|
|
* What a Data Stream Interface packet looks like:
|
|
|
|
* 0 32
|
|
|
|
* |-------------------------------|
|
|
|
|
* |flags |command| requestID |
|
|
|
|
* |-------------------------------|
|
|
|
|
* |error code/enclosed data offset|
|
|
|
|
* |-------------------------------|
|
|
|
|
* |total data length |
|
|
|
|
* |-------------------------------|
|
|
|
|
* |reserved field |
|
|
|
|
* |-------------------------------|
|
2002-04-22 08:50:49 +00:00
|
|
|
*/
|
2010-11-08 21:59:39 +00:00
|
|
|
#define INET6_ADDRLEN 16
|
2001-05-24 20:25:25 +00:00
|
|
|
|
2013-03-16 16:25:41 +00:00
|
|
|
void proto_register_dsi(void);
|
|
|
|
void proto_reg_handoff_dsi(void);
|
|
|
|
|
2001-05-24 20:25:25 +00:00
|
|
|
static int proto_dsi = -1;
|
|
|
|
static int hf_dsi_flags = -1;
|
|
|
|
static int hf_dsi_command = -1;
|
|
|
|
static int hf_dsi_requestid = -1;
|
2002-04-28 22:10:00 +00:00
|
|
|
static int hf_dsi_offset = -1;
|
2002-04-28 19:21:39 +00:00
|
|
|
static int hf_dsi_error = -1;
|
2001-05-24 20:25:25 +00:00
|
|
|
static int hf_dsi_length = -1;
|
|
|
|
static int hf_dsi_reserved = -1;
|
|
|
|
|
|
|
|
static gint ett_dsi = -1;
|
|
|
|
|
2010-11-08 21:59:39 +00:00
|
|
|
static int hf_dsi_open_type = -1;
|
|
|
|
static int hf_dsi_open_len = -1;
|
|
|
|
static int hf_dsi_open_quantum = -1;
|
2009-09-10 06:07:31 +00:00
|
|
|
static int hf_dsi_replay_cache_size = -1;
|
2010-11-08 21:59:39 +00:00
|
|
|
static int hf_dsi_open_option = -1;
|
2002-05-08 23:46:34 +00:00
|
|
|
|
2010-11-08 21:59:39 +00:00
|
|
|
static int hf_dsi_attn_flag = -1;
|
|
|
|
static int hf_dsi_attn_flag_shutdown = -1;
|
|
|
|
static int hf_dsi_attn_flag_crash = -1;
|
|
|
|
static int hf_dsi_attn_flag_msg = -1;
|
|
|
|
static int hf_dsi_attn_flag_reconnect = -1;
|
|
|
|
static int hf_dsi_attn_flag_time = -1;
|
|
|
|
static int hf_dsi_attn_flag_bitmap = -1;
|
2002-05-08 23:46:34 +00:00
|
|
|
|
2010-11-08 21:59:39 +00:00
|
|
|
static gint ett_dsi_open = -1;
|
|
|
|
static gint ett_dsi_attn = -1;
|
|
|
|
static gint ett_dsi_attn_flag = -1;
|
2002-05-08 23:46:34 +00:00
|
|
|
|
2002-05-10 23:20:38 +00:00
|
|
|
static const value_string dsi_attn_flag_vals[] = {
|
2010-11-08 21:59:39 +00:00
|
|
|
{0x0, "Reserved" }, /* 0000 */
|
|
|
|
{0x1, "Reserved" }, /* 0001 */
|
|
|
|
{0x2, "Server message" }, /* 0010 */
|
|
|
|
{0x3, "Server notification, cf. extended bitmap" }, /* 0011 */
|
|
|
|
{0x4, "Server is shutting down, internal error" }, /* 0100 */
|
|
|
|
{0x8, "Server is shutting down" }, /* 1000 */
|
|
|
|
{0x9, "Server disconnects user" }, /* 1001 */
|
|
|
|
{0x10,"Server is shutting down, message" }, /* 1010 */
|
|
|
|
{0x11,"Server is shutting down, message,no reconnect"}, /* 1011 */
|
|
|
|
{0, NULL } };
|
|
|
|
static value_string_ext dsi_attn_flag_vals_ext = VALUE_STRING_EXT_INIT(dsi_attn_flag_vals);
|
2002-05-08 23:46:34 +00:00
|
|
|
|
2002-05-10 23:20:38 +00:00
|
|
|
static const value_string dsi_open_type_vals[] = {
|
2010-11-08 21:59:39 +00:00
|
|
|
{0, "Server quantum" },
|
|
|
|
{1, "Attention quantum" },
|
|
|
|
{2, "Replay cache size" },
|
|
|
|
{0, NULL } };
|
2002-05-08 23:46:34 +00:00
|
|
|
|
2002-04-30 22:05:33 +00:00
|
|
|
/* status stuff same for asp and afp */
|
|
|
|
static int hf_dsi_server_name = -1;
|
2003-04-15 05:45:02 +00:00
|
|
|
static int hf_dsi_utf8_server_name_len = -1;
|
|
|
|
static int hf_dsi_utf8_server_name = -1;
|
2002-04-30 22:05:33 +00:00
|
|
|
static int hf_dsi_server_type = -1;
|
|
|
|
static int hf_dsi_server_vers = -1;
|
|
|
|
static int hf_dsi_server_uams = -1;
|
|
|
|
static int hf_dsi_server_icon = -1;
|
2002-05-03 21:25:43 +00:00
|
|
|
static int hf_dsi_server_directory = -1;
|
2002-04-30 22:05:33 +00:00
|
|
|
|
|
|
|
static int hf_dsi_server_flag = -1;
|
|
|
|
static int hf_dsi_server_flag_copyfile = -1;
|
|
|
|
static int hf_dsi_server_flag_passwd = -1;
|
|
|
|
static int hf_dsi_server_flag_no_save_passwd = -1;
|
2010-11-08 21:59:39 +00:00
|
|
|
static int hf_dsi_server_flag_srv_msg = -1;
|
|
|
|
static int hf_dsi_server_flag_srv_sig = -1;
|
|
|
|
static int hf_dsi_server_flag_tcpip = -1;
|
|
|
|
static int hf_dsi_server_flag_notify = -1;
|
|
|
|
static int hf_dsi_server_flag_reconnect = -1;
|
|
|
|
static int hf_dsi_server_flag_directory = -1;
|
2002-10-17 22:38:19 +00:00
|
|
|
static int hf_dsi_server_flag_utf8_name = -1;
|
2005-06-19 00:08:30 +00:00
|
|
|
static int hf_dsi_server_flag_uuid = -1;
|
2009-09-10 06:07:31 +00:00
|
|
|
static int hf_dsi_server_flag_ext_sleep = -1;
|
2002-04-30 22:05:33 +00:00
|
|
|
static int hf_dsi_server_flag_fast_copy = -1;
|
2010-11-08 21:59:39 +00:00
|
|
|
static int hf_dsi_server_signature = -1;
|
2002-04-30 22:05:33 +00:00
|
|
|
|
2010-11-08 21:59:39 +00:00
|
|
|
static int hf_dsi_server_addr_len = -1;
|
|
|
|
static int hf_dsi_server_addr_type = -1;
|
|
|
|
static int hf_dsi_server_addr_value = -1;
|
2002-04-30 22:05:33 +00:00
|
|
|
|
|
|
|
static gint ett_dsi_status = -1;
|
|
|
|
static gint ett_dsi_uams = -1;
|
|
|
|
static gint ett_dsi_vers = -1;
|
|
|
|
static gint ett_dsi_addr = -1;
|
2002-05-08 23:46:34 +00:00
|
|
|
static gint ett_dsi_addr_line = -1;
|
2002-05-03 21:25:43 +00:00
|
|
|
static gint ett_dsi_directory = -1;
|
2003-04-15 05:45:02 +00:00
|
|
|
static gint ett_dsi_utf8_name = -1;
|
2002-04-30 22:05:33 +00:00
|
|
|
static gint ett_dsi_status_server_flag = -1;
|
|
|
|
|
2010-11-08 21:59:39 +00:00
|
|
|
static const value_string afp_server_addr_type_vals[] = {
|
|
|
|
{1, "IP address" },
|
|
|
|
{2, "IP+port address" },
|
|
|
|
{3, "DDP address" },
|
|
|
|
{4, "DNS name" },
|
|
|
|
{5, "IP+port ssh tunnel" },
|
|
|
|
{6, "IP6 address" },
|
|
|
|
{7, "IP6+port address" },
|
|
|
|
{0, NULL } };
|
|
|
|
value_string_ext afp_server_addr_type_vals_ext = VALUE_STRING_EXT_INIT(afp_server_addr_type_vals);
|
2002-04-30 22:05:33 +00:00
|
|
|
|
|
|
|
/* end status stuff */
|
|
|
|
|
2002-04-22 08:50:49 +00:00
|
|
|
/* desegmentation of DSI */
|
|
|
|
static gboolean dsi_desegment = TRUE;
|
|
|
|
|
2001-11-26 04:52:51 +00:00
|
|
|
static dissector_handle_t data_handle;
|
2002-04-25 23:58:02 +00:00
|
|
|
static dissector_handle_t afp_handle;
|
2001-11-26 04:52:51 +00:00
|
|
|
|
2010-11-08 21:59:39 +00:00
|
|
|
#define TCP_PORT_DSI 548
|
2001-05-24 20:25:25 +00:00
|
|
|
|
2010-11-08 21:59:39 +00:00
|
|
|
#define DSI_BLOCKSIZ 16
|
2002-04-25 23:58:02 +00:00
|
|
|
|
2001-05-24 20:25:25 +00:00
|
|
|
/* DSI flags */
|
|
|
|
#define DSIFL_REQUEST 0x00
|
|
|
|
#define DSIFL_REPLY 0x01
|
|
|
|
#define DSIFL_MAX 0x01
|
|
|
|
|
|
|
|
/* DSI Commands */
|
|
|
|
#define DSIFUNC_CLOSE 1 /* DSICloseSession */
|
|
|
|
#define DSIFUNC_CMD 2 /* DSICommand */
|
|
|
|
#define DSIFUNC_STAT 3 /* DSIGetStatus */
|
|
|
|
#define DSIFUNC_OPEN 4 /* DSIOpenSession */
|
|
|
|
#define DSIFUNC_TICKLE 5 /* DSITickle */
|
|
|
|
#define DSIFUNC_WRITE 6 /* DSIWrite */
|
|
|
|
#define DSIFUNC_ATTN 8 /* DSIAttention */
|
|
|
|
#define DSIFUNC_MAX 8 /* largest command */
|
|
|
|
|
|
|
|
static const value_string flag_vals[] = {
|
2010-11-08 21:59:39 +00:00
|
|
|
{DSIFL_REQUEST, "Request" },
|
|
|
|
{DSIFL_REPLY, "Reply" },
|
|
|
|
{0, NULL } };
|
2001-05-24 20:25:25 +00:00
|
|
|
|
|
|
|
static const value_string func_vals[] = {
|
2010-11-08 21:59:39 +00:00
|
|
|
{DSIFUNC_CLOSE, "CloseSession" },
|
|
|
|
{DSIFUNC_CMD, "Command" },
|
|
|
|
{DSIFUNC_STAT, "GetStatus" },
|
|
|
|
{DSIFUNC_OPEN, "OpenSession" },
|
|
|
|
{DSIFUNC_TICKLE, "Tickle" },
|
|
|
|
{DSIFUNC_WRITE, "Write" },
|
2010-11-15 21:32:27 +00:00
|
|
|
{ 7, "Unknown" },
|
2010-11-08 21:59:39 +00:00
|
|
|
{DSIFUNC_ATTN, "Attention" },
|
|
|
|
{0, NULL } };
|
|
|
|
static value_string_ext func_vals_ext = VALUE_STRING_EXT_INIT(func_vals);
|
2001-05-24 20:25:25 +00:00
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
static gint
|
2009-09-10 06:07:31 +00:00
|
|
|
dissect_dsi_open_session(tvbuff_t *tvb, proto_tree *dsi_tree, gint offset, gint dsi_length)
|
2002-05-08 23:46:34 +00:00
|
|
|
{
|
2010-11-08 21:59:39 +00:00
|
|
|
proto_tree *tree;
|
2002-05-08 23:46:34 +00:00
|
|
|
proto_item *ti;
|
|
|
|
guint8 type;
|
|
|
|
guint8 len;
|
|
|
|
|
|
|
|
ti = proto_tree_add_text(dsi_tree, tvb, offset, -1, "Open Session");
|
|
|
|
tree = proto_item_add_subtree(ti, ett_dsi_open);
|
2010-11-08 21:59:39 +00:00
|
|
|
|
2009-09-10 06:07:31 +00:00
|
|
|
while( dsi_length >2 ) {
|
2010-11-08 21:59:39 +00:00
|
|
|
|
2009-09-10 06:07:31 +00:00
|
|
|
type = tvb_get_guint8(tvb, offset);
|
2011-10-06 03:35:44 +00:00
|
|
|
proto_tree_add_item(tree, hf_dsi_open_type, tvb, offset, 1, ENC_BIG_ENDIAN);
|
2009-09-10 06:07:31 +00:00
|
|
|
offset++;
|
|
|
|
len = tvb_get_guint8(tvb, offset);
|
2011-10-06 03:35:44 +00:00
|
|
|
proto_tree_add_item(tree, hf_dsi_open_len, tvb, offset, 1, ENC_BIG_ENDIAN);
|
2009-09-10 06:07:31 +00:00
|
|
|
offset++;
|
|
|
|
switch (type) {
|
|
|
|
case 0:
|
2011-10-06 03:35:44 +00:00
|
|
|
proto_tree_add_item(tree, hf_dsi_open_quantum, tvb, offset, 4, ENC_BIG_ENDIAN);
|
2010-11-08 21:59:39 +00:00
|
|
|
break;
|
2009-09-10 06:07:31 +00:00
|
|
|
case 1:
|
2011-10-06 03:35:44 +00:00
|
|
|
proto_tree_add_item(tree, hf_dsi_open_quantum, tvb, offset, 4, ENC_BIG_ENDIAN);
|
2010-11-08 21:59:39 +00:00
|
|
|
break;
|
2009-09-10 06:07:31 +00:00
|
|
|
case 2:
|
2011-10-06 03:35:44 +00:00
|
|
|
proto_tree_add_item(tree, hf_dsi_replay_cache_size, tvb, offset, 4, ENC_BIG_ENDIAN);
|
2009-09-10 06:07:31 +00:00
|
|
|
break;
|
|
|
|
default:
|
2011-10-04 22:44:31 +00:00
|
|
|
proto_tree_add_item(tree, hf_dsi_open_option, tvb, offset, len, ENC_NA);
|
2009-09-10 06:07:31 +00:00
|
|
|
}
|
2010-11-08 21:59:39 +00:00
|
|
|
|
2009-09-10 06:07:31 +00:00
|
|
|
dsi_length -= len + 2;
|
2010-11-08 21:59:39 +00:00
|
|
|
|
2009-09-10 06:07:31 +00:00
|
|
|
offset += len;
|
2002-05-08 23:46:34 +00:00
|
|
|
}
|
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
static gint
|
2002-05-08 23:46:34 +00:00
|
|
|
dissect_dsi_attention(tvbuff_t *tvb, proto_tree *dsi_tree, gint offset)
|
|
|
|
{
|
2010-11-08 21:59:39 +00:00
|
|
|
proto_tree *tree;
|
2002-05-08 23:46:34 +00:00
|
|
|
proto_item *ti;
|
|
|
|
guint16 flag;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2002-05-08 23:46:34 +00:00
|
|
|
if (!tvb_reported_length_remaining(tvb,offset))
|
|
|
|
return offset;
|
|
|
|
|
|
|
|
flag = tvb_get_ntohs(tvb, offset);
|
|
|
|
ti = proto_tree_add_text(dsi_tree, tvb, offset, -1, "Attention");
|
|
|
|
tree = proto_item_add_subtree(ti, ett_dsi_attn);
|
|
|
|
|
2011-10-06 03:35:44 +00:00
|
|
|
ti = proto_tree_add_item(tree, hf_dsi_attn_flag, tvb, offset, 2, ENC_BIG_ENDIAN);
|
2002-05-08 23:46:34 +00:00
|
|
|
tree = proto_item_add_subtree(ti, ett_dsi_attn_flag);
|
2011-10-16 23:38:49 +00:00
|
|
|
proto_tree_add_item(tree, hf_dsi_attn_flag_shutdown, tvb, offset, 2, ENC_BIG_ENDIAN);
|
|
|
|
proto_tree_add_item(tree, hf_dsi_attn_flag_crash, tvb, offset, 2, ENC_BIG_ENDIAN);
|
|
|
|
proto_tree_add_item(tree, hf_dsi_attn_flag_msg, tvb, offset, 2, ENC_BIG_ENDIAN);
|
|
|
|
proto_tree_add_item(tree, hf_dsi_attn_flag_reconnect, tvb, offset, 2, ENC_BIG_ENDIAN);
|
2002-05-08 23:46:34 +00:00
|
|
|
/* FIXME */
|
2002-08-28 21:04:11 +00:00
|
|
|
if ((flag & 0xf000) != 0x3000)
|
2011-10-06 03:35:44 +00:00
|
|
|
proto_tree_add_item(tree, hf_dsi_attn_flag_time, tvb, offset, 2, ENC_BIG_ENDIAN);
|
2002-05-08 23:46:34 +00:00
|
|
|
else
|
2011-10-06 03:35:44 +00:00
|
|
|
proto_tree_add_item(tree, hf_dsi_attn_flag_bitmap, tvb, offset, 2, ENC_BIG_ENDIAN);
|
2002-05-08 23:46:34 +00:00
|
|
|
offset += 2;
|
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
/* -----------------------------
|
2002-04-30 22:05:33 +00:00
|
|
|
from netatalk/etc/afpd/status.c
|
|
|
|
*/
|
2002-08-28 21:04:11 +00:00
|
|
|
static gint
|
2002-05-01 07:07:09 +00:00
|
|
|
dissect_dsi_reply_get_status(tvbuff_t *tvb, proto_tree *tree, gint offset)
|
2002-04-30 22:05:33 +00:00
|
|
|
{
|
2010-11-08 21:59:39 +00:00
|
|
|
proto_tree *sub_tree;
|
2002-04-30 22:05:33 +00:00
|
|
|
proto_item *ti;
|
|
|
|
|
|
|
|
guint16 ofs;
|
|
|
|
guint16 flag;
|
|
|
|
guint16 sign_ofs = 0;
|
|
|
|
guint16 adr_ofs = 0;
|
2002-05-03 21:25:43 +00:00
|
|
|
guint16 dir_ofs = 0;
|
2003-04-15 05:45:02 +00:00
|
|
|
guint16 utf_ofs = 0;
|
2002-04-30 22:05:33 +00:00
|
|
|
guint8 nbe;
|
|
|
|
guint8 len;
|
|
|
|
guint8 i;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2002-05-03 21:25:43 +00:00
|
|
|
if (!tree)
|
|
|
|
return offset;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2002-04-30 22:05:33 +00:00
|
|
|
ti = proto_tree_add_text(tree, tvb, offset, -1, "Get Status");
|
|
|
|
tree = proto_item_add_subtree(ti, ett_dsi_status);
|
|
|
|
|
|
|
|
ofs = tvb_get_ntohs(tvb, offset +AFPSTATUS_MACHOFF);
|
|
|
|
proto_tree_add_text(tree, tvb, offset +AFPSTATUS_MACHOFF, 2, "Machine offset: %d", ofs);
|
|
|
|
|
|
|
|
ofs = tvb_get_ntohs(tvb, offset +AFPSTATUS_VERSOFF);
|
|
|
|
proto_tree_add_text(tree, tvb, offset +AFPSTATUS_VERSOFF, 2, "Version offset: %d", ofs);
|
|
|
|
|
|
|
|
ofs = tvb_get_ntohs(tvb, offset +AFPSTATUS_UAMSOFF);
|
|
|
|
proto_tree_add_text(tree, tvb, offset +AFPSTATUS_UAMSOFF, 2, "UAMS offset: %d", ofs);
|
|
|
|
|
|
|
|
ofs = tvb_get_ntohs(tvb, offset +AFPSTATUS_ICONOFF);
|
|
|
|
proto_tree_add_text(tree, tvb, offset +AFPSTATUS_ICONOFF, 2, "Icon offset: %d", ofs);
|
|
|
|
|
|
|
|
ofs = offset +AFPSTATUS_FLAGOFF;
|
2011-10-06 03:35:44 +00:00
|
|
|
ti = proto_tree_add_item(tree, hf_dsi_server_flag, tvb, ofs, 2, ENC_BIG_ENDIAN);
|
2002-04-30 22:05:33 +00:00
|
|
|
sub_tree = proto_item_add_subtree(ti, ett_dsi_status_server_flag);
|
2011-10-10 00:39:31 +00:00
|
|
|
proto_tree_add_item(sub_tree, hf_dsi_server_flag_copyfile , tvb, ofs, 2, ENC_BIG_ENDIAN);
|
|
|
|
proto_tree_add_item(sub_tree, hf_dsi_server_flag_passwd , tvb, ofs, 2, ENC_BIG_ENDIAN);
|
|
|
|
proto_tree_add_item(sub_tree, hf_dsi_server_flag_no_save_passwd, tvb, ofs, 2, ENC_BIG_ENDIAN);
|
|
|
|
proto_tree_add_item(sub_tree, hf_dsi_server_flag_srv_msg , tvb, ofs, 2, ENC_BIG_ENDIAN);
|
|
|
|
proto_tree_add_item(sub_tree, hf_dsi_server_flag_srv_sig , tvb, ofs, 2, ENC_BIG_ENDIAN);
|
|
|
|
proto_tree_add_item(sub_tree, hf_dsi_server_flag_tcpip , tvb, ofs, 2, ENC_BIG_ENDIAN);
|
|
|
|
proto_tree_add_item(sub_tree, hf_dsi_server_flag_notify , tvb, ofs, 2, ENC_BIG_ENDIAN);
|
|
|
|
proto_tree_add_item(sub_tree, hf_dsi_server_flag_reconnect , tvb, ofs, 2, ENC_BIG_ENDIAN);
|
|
|
|
proto_tree_add_item(sub_tree, hf_dsi_server_flag_directory , tvb, ofs, 2, ENC_BIG_ENDIAN);
|
|
|
|
proto_tree_add_item(sub_tree, hf_dsi_server_flag_utf8_name , tvb, ofs, 2, ENC_BIG_ENDIAN);
|
|
|
|
proto_tree_add_item(sub_tree, hf_dsi_server_flag_uuid , tvb, ofs, 2, ENC_BIG_ENDIAN);
|
|
|
|
proto_tree_add_item(sub_tree, hf_dsi_server_flag_ext_sleep , tvb, ofs, 2, ENC_BIG_ENDIAN);
|
|
|
|
proto_tree_add_item(sub_tree, hf_dsi_server_flag_fast_copy , tvb, ofs, 2, ENC_BIG_ENDIAN);
|
|
|
|
|
2012-04-27 18:58:37 +00:00
|
|
|
proto_tree_add_item(tree, hf_dsi_server_name, tvb, offset +AFPSTATUS_PRELEN, 1, ENC_ASCII|ENC_NA);
|
2002-04-30 22:05:33 +00:00
|
|
|
|
|
|
|
flag = tvb_get_ntohs(tvb, ofs);
|
|
|
|
if ((flag & AFPSRVRINFO_SRVSIGNATURE)) {
|
2002-10-17 22:38:19 +00:00
|
|
|
ofs = offset +AFPSTATUS_PRELEN +tvb_get_guint8(tvb, offset +AFPSTATUS_PRELEN) +1;
|
2002-04-30 22:05:33 +00:00
|
|
|
if ((ofs & 1))
|
|
|
|
ofs++;
|
|
|
|
|
|
|
|
sign_ofs = tvb_get_ntohs(tvb, ofs);
|
|
|
|
proto_tree_add_text(tree, tvb, ofs, 2, "Signature offset: %d", sign_ofs);
|
|
|
|
sign_ofs += offset;
|
|
|
|
|
|
|
|
if ((flag & AFPSRVRINFO_TCPIP)) {
|
|
|
|
ofs += 2;
|
|
|
|
adr_ofs = tvb_get_ntohs(tvb, ofs);
|
|
|
|
proto_tree_add_text(tree, tvb, ofs, 2, "Network address offset: %d", adr_ofs);
|
|
|
|
adr_ofs += offset;
|
|
|
|
}
|
2002-05-03 21:25:43 +00:00
|
|
|
|
|
|
|
if ((flag & AFPSRVRINFO_SRVDIRECTORY)) {
|
|
|
|
ofs += 2;
|
|
|
|
dir_ofs = tvb_get_ntohs(tvb, ofs);
|
|
|
|
proto_tree_add_text(tree, tvb, ofs, 2, "Directory services offset: %d", dir_ofs);
|
|
|
|
dir_ofs += offset;
|
|
|
|
}
|
2003-04-15 05:45:02 +00:00
|
|
|
if ((flag & AFPSRVRINFO_SRVUTF8)) {
|
|
|
|
ofs += 2;
|
|
|
|
utf_ofs = tvb_get_ntohs(tvb, ofs);
|
|
|
|
proto_tree_add_text(tree, tvb, ofs, 2, "UTF8 server name offset: %d", utf_ofs);
|
|
|
|
utf_ofs += offset;
|
|
|
|
}
|
2002-04-30 22:05:33 +00:00
|
|
|
}
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2002-04-30 22:05:33 +00:00
|
|
|
ofs = offset +tvb_get_ntohs(tvb, offset +AFPSTATUS_MACHOFF);
|
|
|
|
if (ofs)
|
2012-04-27 18:58:37 +00:00
|
|
|
proto_tree_add_item(tree, hf_dsi_server_type, tvb, ofs, 1, ENC_ASCII|ENC_NA);
|
2002-04-30 22:05:33 +00:00
|
|
|
|
|
|
|
ofs = offset +tvb_get_ntohs(tvb, offset +AFPSTATUS_VERSOFF);
|
|
|
|
if (ofs) {
|
|
|
|
nbe = tvb_get_guint8(tvb, ofs);
|
|
|
|
ti = proto_tree_add_text(tree, tvb, ofs, 1, "Version list: %d", nbe);
|
|
|
|
ofs++;
|
|
|
|
sub_tree = proto_item_add_subtree(ti, ett_dsi_vers);
|
|
|
|
for (i = 0; i < nbe; i++) {
|
2004-01-13 21:49:52 +00:00
|
|
|
len = tvb_get_guint8(tvb, ofs);
|
2012-04-27 18:58:37 +00:00
|
|
|
proto_tree_add_item(sub_tree, hf_dsi_server_vers, tvb, ofs, 1, ENC_ASCII|ENC_NA);
|
2004-01-13 21:49:52 +00:00
|
|
|
ofs += len + 1;
|
2002-04-30 22:05:33 +00:00
|
|
|
}
|
|
|
|
}
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2002-04-30 22:05:33 +00:00
|
|
|
ofs = offset +tvb_get_ntohs(tvb, offset +AFPSTATUS_UAMSOFF);
|
|
|
|
if (ofs) {
|
|
|
|
nbe = tvb_get_guint8(tvb, ofs);
|
|
|
|
ti = proto_tree_add_text(tree, tvb, ofs, 1, "UAMS list: %d", nbe);
|
|
|
|
ofs++;
|
|
|
|
sub_tree = proto_item_add_subtree(ti, ett_dsi_uams);
|
|
|
|
for (i = 0; i < nbe; i++) {
|
2004-01-13 21:49:52 +00:00
|
|
|
len = tvb_get_guint8(tvb, ofs);
|
2012-04-27 18:58:37 +00:00
|
|
|
proto_tree_add_item(sub_tree, hf_dsi_server_uams, tvb, ofs, 1, ENC_ASCII|ENC_NA);
|
2004-01-13 21:49:52 +00:00
|
|
|
ofs += len + 1;
|
2002-04-30 22:05:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ofs = offset +tvb_get_ntohs(tvb, offset +AFPSTATUS_ICONOFF);
|
|
|
|
if (ofs)
|
2011-10-04 22:44:31 +00:00
|
|
|
proto_tree_add_item(tree, hf_dsi_server_icon, tvb, ofs, 256, ENC_NA);
|
2002-04-30 22:05:33 +00:00
|
|
|
|
|
|
|
if (sign_ofs) {
|
2011-10-04 22:44:31 +00:00
|
|
|
proto_tree_add_item(tree, hf_dsi_server_signature, tvb, sign_ofs, 16, ENC_NA);
|
2002-04-30 22:05:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (adr_ofs) {
|
2010-11-08 21:59:39 +00:00
|
|
|
proto_tree *adr_tree;
|
2005-06-19 00:08:30 +00:00
|
|
|
unsigned char *tmp;
|
2002-05-08 23:46:34 +00:00
|
|
|
guint16 net;
|
|
|
|
guint8 node;
|
2010-11-08 21:59:39 +00:00
|
|
|
guint16 port;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2002-04-30 22:05:33 +00:00
|
|
|
ofs = adr_ofs;
|
|
|
|
nbe = tvb_get_guint8(tvb, ofs);
|
|
|
|
ti = proto_tree_add_text(tree, tvb, ofs, 1, "Address list: %d", nbe);
|
|
|
|
ofs++;
|
2002-05-08 23:46:34 +00:00
|
|
|
adr_tree = proto_item_add_subtree(ti, ett_dsi_addr);
|
2002-04-30 22:05:33 +00:00
|
|
|
for (i = 0; i < nbe; i++) {
|
2002-05-08 23:46:34 +00:00
|
|
|
guint8 type;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2002-05-08 23:46:34 +00:00
|
|
|
len = tvb_get_guint8(tvb, ofs);
|
|
|
|
type = tvb_get_guint8(tvb, ofs +1);
|
|
|
|
switch (type) {
|
|
|
|
case 1: /* IP */
|
2011-01-16 03:35:29 +00:00
|
|
|
ti = proto_tree_add_text(adr_tree, tvb, ofs, len, "ip: %s", tvb_ip_to_str(tvb, ofs+2));
|
2002-05-08 23:46:34 +00:00
|
|
|
break;
|
|
|
|
case 2: /* IP + port */
|
|
|
|
port = tvb_get_ntohs(tvb, ofs+6);
|
2011-01-16 03:35:29 +00:00
|
|
|
ti = proto_tree_add_text(adr_tree, tvb, ofs, len, "ip %s:%d", tvb_ip_to_str(tvb, ofs+2), port);
|
2002-05-08 23:46:34 +00:00
|
|
|
break;
|
|
|
|
case 3: /* DDP, atalk_addr_to_str want host order not network */
|
|
|
|
net = tvb_get_ntohs(tvb, ofs+2);
|
2002-08-28 21:04:11 +00:00
|
|
|
node = tvb_get_guint8(tvb, ofs +4);
|
2002-05-08 23:46:34 +00:00
|
|
|
port = tvb_get_guint8(tvb, ofs +5);
|
2003-04-15 05:45:02 +00:00
|
|
|
ti = proto_tree_add_text(adr_tree, tvb, ofs, len, "ddp: %u.%u:%u",
|
2002-05-08 23:46:34 +00:00
|
|
|
net, node, port);
|
|
|
|
break;
|
|
|
|
case 4: /* DNS */
|
2003-04-15 05:45:02 +00:00
|
|
|
case 5: /* SSH tunnel */
|
2002-05-08 23:46:34 +00:00
|
|
|
if (len > 2) {
|
2013-09-22 15:50:55 +00:00
|
|
|
tmp = tvb_get_string(wmem_packet_scope(), tvb, ofs +2, len -2);
|
2010-11-08 21:59:39 +00:00
|
|
|
ti = proto_tree_add_text(adr_tree, tvb, ofs, len, "%s: %s",
|
2003-04-15 05:45:02 +00:00
|
|
|
(type==4)?"dns":"ssh tunnel", tmp);
|
2002-05-08 23:46:34 +00:00
|
|
|
break;
|
2002-08-28 21:04:11 +00:00
|
|
|
}
|
2003-04-15 05:45:02 +00:00
|
|
|
else {
|
|
|
|
ti = proto_tree_add_text(adr_tree, tvb, ofs, len,"Malformed address type %d", type);
|
|
|
|
}
|
|
|
|
break;
|
2005-06-19 00:08:30 +00:00
|
|
|
case 6: /* IP6 */
|
2010-11-08 21:59:39 +00:00
|
|
|
ti = proto_tree_add_text(adr_tree, tvb, ofs, len, "ip6: %s",
|
2011-01-16 03:35:29 +00:00
|
|
|
tvb_ip6_to_str(tvb, ofs+2));
|
2005-06-19 00:08:30 +00:00
|
|
|
break;
|
|
|
|
case 7: /* IP6 + 2bytes port */
|
|
|
|
port = tvb_get_ntohs(tvb, ofs+ 2+INET6_ADDRLEN);
|
|
|
|
ti = proto_tree_add_text(adr_tree, tvb, ofs, len, "ip6 %s:%d",
|
2011-01-16 03:35:29 +00:00
|
|
|
tvb_ip6_to_str(tvb, ofs+2), port);
|
2005-06-19 00:08:30 +00:00
|
|
|
break;
|
2002-05-08 23:46:34 +00:00
|
|
|
default:
|
2008-12-18 19:08:49 +00:00
|
|
|
ti = proto_tree_add_text(adr_tree, tvb, ofs, len,"Unknown type : %d", type);
|
2002-05-08 23:46:34 +00:00
|
|
|
break;
|
2002-08-28 21:04:11 +00:00
|
|
|
}
|
2002-05-08 23:46:34 +00:00
|
|
|
len -= 2;
|
|
|
|
sub_tree = proto_item_add_subtree(ti,ett_dsi_addr_line);
|
2011-10-06 03:35:44 +00:00
|
|
|
proto_tree_add_item(sub_tree, hf_dsi_server_addr_len, tvb, ofs, 1, ENC_BIG_ENDIAN);
|
2002-04-30 22:05:33 +00:00
|
|
|
ofs++;
|
2011-10-06 03:35:44 +00:00
|
|
|
proto_tree_add_item(sub_tree, hf_dsi_server_addr_type, tvb, ofs, 1, ENC_BIG_ENDIAN);
|
2002-04-30 22:05:33 +00:00
|
|
|
ofs++;
|
2011-10-04 22:44:31 +00:00
|
|
|
proto_tree_add_item(sub_tree, hf_dsi_server_addr_value,tvb, ofs, len, ENC_NA);
|
2002-04-30 22:05:33 +00:00
|
|
|
ofs += len;
|
|
|
|
}
|
|
|
|
}
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2002-05-03 21:25:43 +00:00
|
|
|
if (dir_ofs) {
|
|
|
|
ofs = dir_ofs;
|
|
|
|
nbe = tvb_get_guint8(tvb, ofs);
|
|
|
|
ti = proto_tree_add_text(tree, tvb, ofs, 1, "Directory services list: %d", nbe);
|
|
|
|
ofs++;
|
|
|
|
sub_tree = proto_item_add_subtree(ti, ett_dsi_directory);
|
|
|
|
for (i = 0; i < nbe; i++) {
|
2004-01-13 21:49:52 +00:00
|
|
|
len = tvb_get_guint8(tvb, ofs);
|
2012-04-27 18:58:37 +00:00
|
|
|
proto_tree_add_item(sub_tree, hf_dsi_server_directory, tvb, ofs, 1, ENC_ASCII|ENC_NA);
|
2004-01-13 21:49:52 +00:00
|
|
|
ofs += len + 1;
|
2002-05-03 21:25:43 +00:00
|
|
|
}
|
|
|
|
}
|
2003-04-15 05:45:02 +00:00
|
|
|
if (utf_ofs) {
|
|
|
|
guint16 ulen;
|
2004-01-06 02:20:32 +00:00
|
|
|
char *tmp;
|
2003-04-15 05:45:02 +00:00
|
|
|
|
|
|
|
ofs = utf_ofs;
|
|
|
|
ulen = tvb_get_ntohs(tvb, ofs);
|
2013-09-22 15:50:55 +00:00
|
|
|
tmp = tvb_get_string(wmem_packet_scope(), tvb, ofs + 2, ulen);
|
2004-01-06 02:20:32 +00:00
|
|
|
ti = proto_tree_add_text(tree, tvb, ofs, ulen + 2, "UTF8 server name: %s", tmp);
|
2003-04-15 05:45:02 +00:00
|
|
|
sub_tree = proto_item_add_subtree(ti, ett_dsi_utf8_name);
|
2004-01-06 02:20:32 +00:00
|
|
|
proto_tree_add_uint(sub_tree, hf_dsi_utf8_server_name_len, tvb, ofs, 2, ulen);
|
2003-04-15 05:45:02 +00:00
|
|
|
ofs += 2;
|
2004-01-06 02:20:32 +00:00
|
|
|
proto_tree_add_string(sub_tree, hf_dsi_utf8_server_name, tvb, ofs, ulen, tmp);
|
|
|
|
ofs += ulen;
|
2003-04-15 05:45:02 +00:00
|
|
|
}
|
2002-05-03 21:25:43 +00:00
|
|
|
|
2012-04-30 21:15:17 +00:00
|
|
|
return ofs;
|
2002-04-30 22:05:33 +00:00
|
|
|
}
|
|
|
|
|
2013-11-09 17:46:28 +00:00
|
|
|
static int
|
|
|
|
dissect_dsi_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
|
2001-05-24 20:25:25 +00:00
|
|
|
{
|
2010-11-08 21:59:39 +00:00
|
|
|
proto_tree *dsi_tree;
|
2001-05-24 20:25:25 +00:00
|
|
|
proto_item *ti;
|
2002-04-22 08:50:49 +00:00
|
|
|
guint8 dsi_flags,dsi_command;
|
|
|
|
guint16 dsi_requestid;
|
|
|
|
gint32 dsi_code;
|
|
|
|
guint32 dsi_length;
|
|
|
|
guint32 dsi_reserved;
|
2002-04-25 23:58:02 +00:00
|
|
|
struct aspinfo aspinfo;
|
2010-11-08 21:59:39 +00:00
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2009-08-09 06:26:46 +00:00
|
|
|
col_set_str(pinfo->cinfo, COL_PROTOCOL, "DSI");
|
2013-06-14 01:02:11 +00:00
|
|
|
col_clear(pinfo->cinfo, COL_INFO);
|
2001-05-24 20:25:25 +00:00
|
|
|
|
2002-04-22 08:50:49 +00:00
|
|
|
dsi_flags = tvb_get_guint8(tvb, 0);
|
|
|
|
dsi_command = tvb_get_guint8(tvb, 1);
|
|
|
|
dsi_requestid = tvb_get_ntohs(tvb, 2);
|
|
|
|
dsi_code = tvb_get_ntohl(tvb, 4);
|
|
|
|
dsi_length = tvb_get_ntohl(tvb, 8);
|
|
|
|
dsi_reserved = tvb_get_ntohl(tvb, 12);
|
|
|
|
|
2013-06-14 01:02:11 +00:00
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO, "%s %s (%u)",
|
2002-04-22 08:50:49 +00:00
|
|
|
val_to_str(dsi_flags, flag_vals,
|
|
|
|
"Unknown flag (0x%02x)"),
|
2010-11-08 21:59:39 +00:00
|
|
|
val_to_str_ext(dsi_command, &func_vals_ext,
|
2002-04-22 08:50:49 +00:00
|
|
|
"Unknown function (0x%02x)"),
|
|
|
|
dsi_requestid);
|
|
|
|
|
2013-10-21 00:27:36 +00:00
|
|
|
ti = proto_tree_add_item(tree, proto_dsi, tvb, 0, -1, ENC_NA);
|
|
|
|
dsi_tree = proto_item_add_subtree(ti, ett_dsi);
|
2002-04-22 08:50:49 +00:00
|
|
|
|
2013-10-21 00:27:36 +00:00
|
|
|
if (tree) {
|
2002-04-22 08:50:49 +00:00
|
|
|
proto_tree_add_uint(dsi_tree, hf_dsi_flags, tvb,
|
|
|
|
0, 1, dsi_flags);
|
|
|
|
proto_tree_add_uint(dsi_tree, hf_dsi_command, tvb,
|
|
|
|
1, 1, dsi_command);
|
|
|
|
proto_tree_add_uint(dsi_tree, hf_dsi_requestid, tvb,
|
|
|
|
2, 2, dsi_requestid);
|
2002-04-28 22:10:00 +00:00
|
|
|
switch (dsi_flags) {
|
|
|
|
|
|
|
|
case DSIFL_REQUEST:
|
|
|
|
proto_tree_add_int(dsi_tree, hf_dsi_offset, tvb,
|
2002-04-28 19:21:39 +00:00
|
|
|
4, 4, dsi_code);
|
2002-04-28 22:10:00 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case DSIFL_REPLY:
|
|
|
|
proto_tree_add_int(dsi_tree, hf_dsi_error, tvb,
|
2002-04-28 19:21:39 +00:00
|
|
|
4, 4, dsi_code);
|
2002-04-28 22:10:00 +00:00
|
|
|
break;
|
2002-04-28 19:21:39 +00:00
|
|
|
}
|
2013-09-15 01:48:30 +00:00
|
|
|
proto_tree_add_uint_format_value(dsi_tree, hf_dsi_length, tvb,
|
2002-04-22 08:50:49 +00:00
|
|
|
8, 4, dsi_length,
|
2013-09-15 01:48:30 +00:00
|
|
|
"%u bytes", dsi_length);
|
2002-04-22 08:50:49 +00:00
|
|
|
proto_tree_add_uint(dsi_tree, hf_dsi_reserved, tvb,
|
|
|
|
12, 4, dsi_reserved);
|
2002-04-25 23:58:02 +00:00
|
|
|
}
|
2013-10-21 00:27:36 +00:00
|
|
|
|
2002-04-30 22:05:33 +00:00
|
|
|
switch (dsi_command) {
|
2002-05-08 23:46:34 +00:00
|
|
|
case DSIFUNC_OPEN:
|
|
|
|
if (tree) {
|
2009-09-10 06:07:31 +00:00
|
|
|
dissect_dsi_open_session(tvb, dsi_tree, DSI_BLOCKSIZ, dsi_length);
|
2002-05-08 23:46:34 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case DSIFUNC_ATTN:
|
|
|
|
if (tree) {
|
|
|
|
dissect_dsi_attention(tvb, dsi_tree, DSI_BLOCKSIZ);
|
|
|
|
}
|
|
|
|
break;
|
2002-04-30 22:05:33 +00:00
|
|
|
case DSIFUNC_STAT:
|
|
|
|
if (tree && (dsi_flags == DSIFL_REPLY)) {
|
2002-05-01 07:07:09 +00:00
|
|
|
dissect_dsi_reply_get_status(tvb, dsi_tree, DSI_BLOCKSIZ);
|
2002-04-30 22:05:33 +00:00
|
|
|
}
|
2002-08-28 21:04:11 +00:00
|
|
|
break;
|
2002-04-30 22:05:33 +00:00
|
|
|
case DSIFUNC_CMD:
|
|
|
|
case DSIFUNC_WRITE:
|
|
|
|
{
|
2010-11-08 21:59:39 +00:00
|
|
|
tvbuff_t *new_tvb;
|
2002-04-30 22:05:33 +00:00
|
|
|
int len = tvb_reported_length_remaining(tvb,DSI_BLOCKSIZ);
|
|
|
|
|
|
|
|
aspinfo.reply = (dsi_flags == DSIFL_REPLY);
|
|
|
|
aspinfo.command = dsi_command;
|
|
|
|
aspinfo.seq = dsi_requestid;
|
|
|
|
aspinfo.code = dsi_code;
|
2013-10-21 00:27:36 +00:00
|
|
|
proto_item_set_len(dsi_tree, DSI_BLOCKSIZ);
|
2002-04-30 22:05:33 +00:00
|
|
|
|
|
|
|
new_tvb = tvb_new_subset(tvb, DSI_BLOCKSIZ,-1,len);
|
2013-10-21 00:27:36 +00:00
|
|
|
call_dissector_with_data(afp_handle, new_tvb, pinfo, tree, &aspinfo);
|
2002-04-30 22:05:33 +00:00
|
|
|
}
|
|
|
|
break;
|
2010-11-08 21:59:39 +00:00
|
|
|
default:
|
2013-10-21 00:27:36 +00:00
|
|
|
call_dissector(data_handle,
|
|
|
|
tvb_new_subset_remaining(tvb, DSI_BLOCKSIZ),
|
|
|
|
pinfo, dsi_tree);
|
2002-04-30 22:05:33 +00:00
|
|
|
break;
|
2001-05-24 20:25:25 +00:00
|
|
|
}
|
2013-11-09 17:46:28 +00:00
|
|
|
|
|
|
|
return tvb_length(tvb);
|
2002-04-22 08:50:49 +00:00
|
|
|
}
|
2001-05-24 20:25:25 +00:00
|
|
|
|
Make a "tcp_dissect_pdus()" with the standard loop for a TCP segment,
extracting PDUs from it and possibly doing reassembly. Make the COPS,
DNS, DSI, Gryphon, and SCCP dissectors use it.
Add "set_actual_length()", "tcp_dissect_pdus()",
"decode_boolean_bitfield()", "decode_numeric_bitfield()", and
"decode_enumerated_bitfield()" to the list of routines available to
dissectors on platforms where routines in the main program aren't
available to dynamically-loaded code.
Declare routines in "to_str.h" as "extern"; as I remember, that's
necessary to allow the "decode_XXX_bitfield()" routines declared therein
to be made available to plugins as per the above.
Note that new exported routines should be added to the end of the table
if that's the only change being made to the table.
Create a new "plugin_api_decls.h" header file, used to declare both the
"p_" variables and the "p_" structure members in the routine-exporting
mechanism; this reduces the number of places you have to change to
change the list of exported routines.
svn path=/trunk/; revision=5394
2002-05-05 00:16:38 +00:00
|
|
|
static guint
|
2006-10-31 09:29:07 +00:00
|
|
|
get_dsi_pdu_len(packet_info *pinfo _U_, tvbuff_t *tvb, int offset)
|
2002-04-22 08:50:49 +00:00
|
|
|
{
|
|
|
|
guint32 plen;
|
2003-12-08 20:36:59 +00:00
|
|
|
guint8 dsi_flags,dsi_command;
|
|
|
|
|
|
|
|
dsi_flags = tvb_get_guint8(tvb, offset);
|
|
|
|
dsi_command = tvb_get_guint8(tvb, offset+ 1);
|
2010-11-08 21:59:39 +00:00
|
|
|
if ( dsi_flags > DSIFL_MAX || !dsi_command || dsi_command > DSIFUNC_MAX)
|
2003-12-08 20:36:59 +00:00
|
|
|
{
|
|
|
|
/* it's not a known dsi pdu start sequence */
|
|
|
|
return tvb_length_remaining(tvb, offset);
|
|
|
|
}
|
2001-05-24 20:25:25 +00:00
|
|
|
|
Make a "tcp_dissect_pdus()" with the standard loop for a TCP segment,
extracting PDUs from it and possibly doing reassembly. Make the COPS,
DNS, DSI, Gryphon, and SCCP dissectors use it.
Add "set_actual_length()", "tcp_dissect_pdus()",
"decode_boolean_bitfield()", "decode_numeric_bitfield()", and
"decode_enumerated_bitfield()" to the list of routines available to
dissectors on platforms where routines in the main program aren't
available to dynamically-loaded code.
Declare routines in "to_str.h" as "extern"; as I remember, that's
necessary to allow the "decode_XXX_bitfield()" routines declared therein
to be made available to plugins as per the above.
Note that new exported routines should be added to the end of the table
if that's the only change being made to the table.
Create a new "plugin_api_decls.h" header file, used to declare both the
"p_" variables and the "p_" structure members in the routine-exporting
mechanism; this reduces the number of places you have to change to
change the list of exported routines.
svn path=/trunk/; revision=5394
2002-05-05 00:16:38 +00:00
|
|
|
/*
|
|
|
|
* Get the length of the DSI packet.
|
|
|
|
*/
|
|
|
|
plen = tvb_get_ntohl(tvb, offset+8);
|
2001-05-24 20:25:25 +00:00
|
|
|
|
Make a "tcp_dissect_pdus()" with the standard loop for a TCP segment,
extracting PDUs from it and possibly doing reassembly. Make the COPS,
DNS, DSI, Gryphon, and SCCP dissectors use it.
Add "set_actual_length()", "tcp_dissect_pdus()",
"decode_boolean_bitfield()", "decode_numeric_bitfield()", and
"decode_enumerated_bitfield()" to the list of routines available to
dissectors on platforms where routines in the main program aren't
available to dynamically-loaded code.
Declare routines in "to_str.h" as "extern"; as I remember, that's
necessary to allow the "decode_XXX_bitfield()" routines declared therein
to be made available to plugins as per the above.
Note that new exported routines should be added to the end of the table
if that's the only change being made to the table.
Create a new "plugin_api_decls.h" header file, used to declare both the
"p_" variables and the "p_" structure members in the routine-exporting
mechanism; this reduces the number of places you have to change to
change the list of exported routines.
svn path=/trunk/; revision=5394
2002-05-05 00:16:38 +00:00
|
|
|
/*
|
|
|
|
* That length doesn't include the length of the header itself;
|
|
|
|
* add that in.
|
|
|
|
*/
|
|
|
|
return plen + 16;
|
|
|
|
}
|
2001-05-24 20:25:25 +00:00
|
|
|
|
2013-11-09 17:46:28 +00:00
|
|
|
static int
|
|
|
|
dissect_dsi(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data)
|
Make a "tcp_dissect_pdus()" with the standard loop for a TCP segment,
extracting PDUs from it and possibly doing reassembly. Make the COPS,
DNS, DSI, Gryphon, and SCCP dissectors use it.
Add "set_actual_length()", "tcp_dissect_pdus()",
"decode_boolean_bitfield()", "decode_numeric_bitfield()", and
"decode_enumerated_bitfield()" to the list of routines available to
dissectors on platforms where routines in the main program aren't
available to dynamically-loaded code.
Declare routines in "to_str.h" as "extern"; as I remember, that's
necessary to allow the "decode_XXX_bitfield()" routines declared therein
to be made available to plugins as per the above.
Note that new exported routines should be added to the end of the table
if that's the only change being made to the table.
Create a new "plugin_api_decls.h" header file, used to declare both the
"p_" variables and the "p_" structure members in the routine-exporting
mechanism; this reduces the number of places you have to change to
change the list of exported routines.
svn path=/trunk/; revision=5394
2002-05-05 00:16:38 +00:00
|
|
|
{
|
|
|
|
tcp_dissect_pdus(tvb, pinfo, tree, dsi_desegment, 12,
|
2013-11-09 17:46:28 +00:00
|
|
|
get_dsi_pdu_len, dissect_dsi_packet, data);
|
|
|
|
|
|
|
|
return tvb_length(tvb);
|
2001-05-24 20:25:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
proto_register_dsi(void)
|
|
|
|
{
|
|
|
|
|
2010-11-08 21:59:39 +00:00
|
|
|
static hf_register_info hf[] = {
|
|
|
|
{ &hf_dsi_flags,
|
|
|
|
{ "Flags", "dsi.flags",
|
|
|
|
FT_UINT8, BASE_HEX, VALS(flag_vals), 0x0,
|
|
|
|
"Indicates request or reply.", HFILL }},
|
|
|
|
|
|
|
|
{ &hf_dsi_command,
|
|
|
|
{ "Command", "dsi.command",
|
|
|
|
FT_UINT8, BASE_DEC|BASE_EXT_STRING, &func_vals_ext, 0x0,
|
|
|
|
"Represents a DSI command.", HFILL }},
|
|
|
|
|
|
|
|
{ &hf_dsi_requestid,
|
|
|
|
{ "Request ID", "dsi.requestid",
|
|
|
|
FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"Keeps track of which request this is. Replies must match a Request. IDs must be generated in sequential order.", HFILL }},
|
|
|
|
|
|
|
|
{ &hf_dsi_offset,
|
|
|
|
{ "Data offset", "dsi.data_offset",
|
|
|
|
FT_INT32, BASE_DEC, NULL, 0x0,
|
|
|
|
NULL, HFILL }},
|
|
|
|
|
|
|
|
{ &hf_dsi_error,
|
|
|
|
{ "Error code", "dsi.error_code",
|
|
|
|
FT_INT32, BASE_DEC|BASE_EXT_STRING, &asp_error_vals_ext, 0x0,
|
|
|
|
NULL, HFILL }},
|
|
|
|
|
|
|
|
{ &hf_dsi_length,
|
|
|
|
{ "Length", "dsi.length",
|
|
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
|
|
"Total length of the data that follows the DSI header.", HFILL }},
|
|
|
|
|
|
|
|
{ &hf_dsi_reserved,
|
|
|
|
{ "Reserved", "dsi.reserved",
|
|
|
|
FT_UINT32, BASE_HEX, NULL, 0x0,
|
|
|
|
"Reserved for future use. Should be set to zero.", HFILL }},
|
|
|
|
/* asp , afp */
|
|
|
|
{ &hf_dsi_utf8_server_name_len,
|
|
|
|
{ "Length", "dsi.utf8_server_name_len",
|
|
|
|
FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"UTF8 server name length.", HFILL }},
|
|
|
|
{ &hf_dsi_utf8_server_name,
|
|
|
|
{ "UTF8 Server name", "dsi.utf8_server_name",
|
|
|
|
FT_STRING, BASE_NONE, NULL, 0x0,
|
|
|
|
NULL, HFILL }},
|
|
|
|
|
|
|
|
{ &hf_dsi_server_name,
|
|
|
|
{ "Server name", "dsi.server_name",
|
|
|
|
FT_UINT_STRING, BASE_NONE, NULL, 0x0,
|
|
|
|
NULL, HFILL }},
|
|
|
|
|
|
|
|
{ &hf_dsi_server_type,
|
|
|
|
{ "Server type", "dsi.server_type",
|
|
|
|
FT_UINT_STRING, BASE_NONE, NULL, 0x0,
|
|
|
|
NULL, HFILL }},
|
|
|
|
|
|
|
|
{ &hf_dsi_server_vers,
|
|
|
|
{ "AFP version", "dsi.server_vers",
|
|
|
|
FT_UINT_STRING, BASE_NONE, NULL, 0x0,
|
|
|
|
NULL, HFILL }},
|
|
|
|
|
|
|
|
{ &hf_dsi_server_uams,
|
|
|
|
{ "UAM", "dsi.server_uams",
|
|
|
|
FT_UINT_STRING, BASE_NONE, NULL, 0x0,
|
|
|
|
NULL, HFILL }},
|
|
|
|
|
|
|
|
{ &hf_dsi_server_icon,
|
|
|
|
{ "Icon bitmap", "dsi.server_icon",
|
|
|
|
FT_BYTES, BASE_NONE, NULL, 0x0,
|
|
|
|
"Server icon bitmap", HFILL }},
|
|
|
|
|
|
|
|
{ &hf_dsi_server_directory,
|
|
|
|
{ "Directory service", "dsi.server_directory",
|
|
|
|
FT_UINT_STRING, BASE_NONE, NULL, 0x0,
|
|
|
|
"Server directory service", HFILL }},
|
|
|
|
|
|
|
|
{ &hf_dsi_server_signature,
|
|
|
|
{ "Server signature", "dsi.server_signature",
|
|
|
|
FT_BYTES, BASE_NONE, NULL, 0x0,
|
|
|
|
NULL, HFILL }},
|
|
|
|
|
|
|
|
{ &hf_dsi_server_flag,
|
|
|
|
{ "Flag", "dsi.server_flag",
|
|
|
|
FT_UINT16, BASE_HEX, NULL, 0x0,
|
|
|
|
"Server capabilities flag", HFILL }},
|
|
|
|
{ &hf_dsi_server_flag_copyfile,
|
|
|
|
{ "Support copyfile", "dsi.server_flag.copyfile",
|
|
|
|
FT_BOOLEAN, 16, NULL, AFPSRVRINFO_COPY,
|
|
|
|
"Server support copyfile", HFILL }},
|
|
|
|
{ &hf_dsi_server_flag_passwd,
|
|
|
|
{ "Support change password", "dsi.server_flag.passwd",
|
|
|
|
FT_BOOLEAN, 16, NULL, AFPSRVRINFO_PASSWD,
|
|
|
|
"Server support change password", HFILL }},
|
|
|
|
{ &hf_dsi_server_flag_no_save_passwd,
|
|
|
|
{ "Don't allow save password", "dsi.server_flag.no_save_passwd",
|
|
|
|
FT_BOOLEAN, 16, NULL, AFPSRVRINFO_NOSAVEPASSWD,
|
|
|
|
NULL, HFILL }},
|
|
|
|
{ &hf_dsi_server_flag_srv_msg,
|
|
|
|
{ "Support server message", "dsi.server_flag.srv_msg",
|
|
|
|
FT_BOOLEAN, 16, NULL, AFPSRVRINFO_SRVMSGS,
|
|
|
|
NULL, HFILL }},
|
|
|
|
{ &hf_dsi_server_flag_srv_sig,
|
|
|
|
{ "Support server signature", "dsi.server_flag.srv_sig",
|
|
|
|
FT_BOOLEAN, 16, NULL, AFPSRVRINFO_SRVSIGNATURE,
|
|
|
|
NULL, HFILL }},
|
|
|
|
{ &hf_dsi_server_flag_tcpip,
|
|
|
|
{ "Support TCP/IP", "dsi.server_flag.tcpip",
|
|
|
|
FT_BOOLEAN, 16, NULL, AFPSRVRINFO_TCPIP,
|
|
|
|
"Server support TCP/IP", HFILL }},
|
|
|
|
{ &hf_dsi_server_flag_notify,
|
|
|
|
{ "Support server notifications", "dsi.server_flag.notify",
|
|
|
|
FT_BOOLEAN, 16, NULL, AFPSRVRINFO_SRVNOTIFY,
|
|
|
|
"Server support notifications", HFILL }},
|
|
|
|
{ &hf_dsi_server_flag_reconnect,
|
|
|
|
{ "Support server reconnect", "dsi.server_flag.reconnect",
|
|
|
|
FT_BOOLEAN, 16, NULL, AFPSRVRINFO_SRVRECONNECT,
|
|
|
|
"Server support reconnect", HFILL }},
|
|
|
|
{ &hf_dsi_server_flag_directory,
|
|
|
|
{ "Support directory services", "dsi.server_flag.directory",
|
|
|
|
FT_BOOLEAN, 16, NULL, AFPSRVRINFO_SRVDIRECTORY,
|
|
|
|
"Server support directory services", HFILL }},
|
|
|
|
{ &hf_dsi_server_flag_utf8_name,
|
|
|
|
{ "Support UTF8 server name", "dsi.server_flag.utf8_name",
|
|
|
|
FT_BOOLEAN, 16, NULL, AFPSRVRINFO_SRVUTF8,
|
|
|
|
"Server support UTF8 server name", HFILL }},
|
|
|
|
{ &hf_dsi_server_flag_uuid,
|
|
|
|
{ "Support UUIDs", "dsi.server_flag.uuids",
|
|
|
|
FT_BOOLEAN, 16, NULL, AFPSRVRINFO_UUID,
|
|
|
|
"Server supports UUIDs", HFILL }},
|
|
|
|
{ &hf_dsi_server_flag_ext_sleep,
|
|
|
|
{ "Support extended sleep", "dsi.server_flag.ext_sleep",
|
|
|
|
FT_BOOLEAN, 16, NULL, AFPSRVRINFO_EXT_SLEEP,
|
|
|
|
"Server supports extended sleep", HFILL }},
|
|
|
|
{ &hf_dsi_server_flag_fast_copy,
|
|
|
|
{ "Support fast copy", "dsi.server_flag.fast_copy",
|
|
|
|
FT_BOOLEAN, 16, NULL, AFPSRVRINFO_FASTBOZO,
|
|
|
|
"Server support fast copy", HFILL }},
|
|
|
|
|
|
|
|
|
|
|
|
{ &hf_dsi_server_addr_len,
|
|
|
|
{ "Length", "dsi.server_addr.len",
|
|
|
|
FT_UINT8, BASE_DEC, NULL, 0x0,
|
|
|
|
"Address length.", HFILL }},
|
|
|
|
|
|
|
|
{ &hf_dsi_server_addr_type,
|
|
|
|
{ "Type", "dsi.server_addr.type",
|
|
|
|
FT_UINT8, BASE_DEC|BASE_EXT_STRING, &afp_server_addr_type_vals_ext, 0x0,
|
|
|
|
"Address type.", HFILL }},
|
|
|
|
|
|
|
|
{ &hf_dsi_server_addr_value,
|
|
|
|
{ "Value", "dsi.server_addr.value",
|
|
|
|
FT_BYTES, BASE_NONE, NULL, 0x0,
|
|
|
|
"Address value", HFILL }},
|
|
|
|
|
|
|
|
{ &hf_dsi_open_type,
|
|
|
|
{ "Option", "dsi.open_type",
|
|
|
|
FT_UINT8, BASE_DEC, VALS(dsi_open_type_vals), 0x0,
|
|
|
|
"Open session option type.", HFILL }},
|
|
|
|
|
|
|
|
{ &hf_dsi_open_len,
|
|
|
|
{ "Length", "dsi.open_len",
|
|
|
|
FT_UINT8, BASE_DEC, NULL, 0x0,
|
|
|
|
"Open session option len", HFILL }},
|
|
|
|
|
|
|
|
{ &hf_dsi_open_quantum,
|
|
|
|
{ "Quantum", "dsi.open_quantum",
|
|
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
|
|
"Server/Attention quantum", HFILL }},
|
|
|
|
|
|
|
|
{ &hf_dsi_replay_cache_size,
|
|
|
|
{ "Replay", "dsi.replay_cache",
|
|
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
|
|
"Replay cache size", HFILL }},
|
|
|
|
|
|
|
|
{ &hf_dsi_open_option,
|
|
|
|
{ "Option", "dsi.open_option",
|
|
|
|
FT_BYTES, BASE_NONE, NULL, 0x0,
|
|
|
|
"Open session options (undecoded)", HFILL }},
|
|
|
|
|
|
|
|
{ &hf_dsi_attn_flag,
|
|
|
|
{ "Flags", "dsi.attn_flag",
|
|
|
|
FT_UINT16, BASE_HEX|BASE_EXT_STRING, &dsi_attn_flag_vals_ext, 0xf000,
|
|
|
|
"Server attention flag", HFILL }},
|
|
|
|
{ &hf_dsi_attn_flag_shutdown,
|
|
|
|
{ "Shutdown", "dsi.attn_flag.shutdown",
|
|
|
|
FT_BOOLEAN, 16, NULL, 1<<15,
|
|
|
|
"Attention flag, server is shutting down", HFILL }},
|
|
|
|
{ &hf_dsi_attn_flag_crash,
|
|
|
|
{ "Crash", "dsi.attn_flag.crash",
|
|
|
|
FT_BOOLEAN, 16, NULL, 1<<14,
|
|
|
|
"Attention flag, server crash bit", HFILL }},
|
|
|
|
{ &hf_dsi_attn_flag_msg,
|
|
|
|
{ "Message", "dsi.attn_flag.msg",
|
|
|
|
FT_BOOLEAN, 16, NULL, 1<<13,
|
|
|
|
"Attention flag, server message bit", HFILL }},
|
|
|
|
{ &hf_dsi_attn_flag_reconnect,
|
|
|
|
{ "Don't reconnect", "dsi.attn_flag.reconnect",
|
|
|
|
FT_BOOLEAN, 16, NULL, 1<<12,
|
|
|
|
"Attention flag, don't reconnect bit", HFILL }},
|
|
|
|
{ &hf_dsi_attn_flag_time,
|
|
|
|
{ "Minutes", "dsi.attn_flag.time",
|
|
|
|
FT_UINT16, BASE_DEC, NULL, 0xfff,
|
|
|
|
"Number of minutes", HFILL }},
|
|
|
|
{ &hf_dsi_attn_flag_bitmap,
|
2012-01-19 20:19:28 +00:00
|
|
|
{ "Bitmap", "dsi.attn_flag.bitmap",
|
2010-11-08 21:59:39 +00:00
|
|
|
FT_UINT16, BASE_HEX, NULL, 0xfff,
|
|
|
|
"Attention extended bitmap", HFILL }},
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
static gint *ett[] = {
|
|
|
|
&ett_dsi,
|
|
|
|
&ett_dsi_open,
|
|
|
|
&ett_dsi_attn,
|
|
|
|
&ett_dsi_attn_flag,
|
|
|
|
/* asp afp */
|
|
|
|
&ett_dsi_status,
|
|
|
|
&ett_dsi_status_server_flag,
|
|
|
|
&ett_dsi_vers,
|
|
|
|
&ett_dsi_uams,
|
|
|
|
&ett_dsi_addr,
|
|
|
|
&ett_dsi_addr_line,
|
|
|
|
&ett_dsi_directory,
|
|
|
|
&ett_dsi_utf8_name,
|
|
|
|
};
|
|
|
|
module_t *dsi_module;
|
|
|
|
|
|
|
|
proto_dsi = proto_register_protocol("Data Stream Interface", "DSI", "dsi");
|
|
|
|
proto_register_field_array(proto_dsi, hf, array_length(hf));
|
|
|
|
proto_register_subtree_array(ett, array_length(ett));
|
|
|
|
|
|
|
|
dsi_module = prefs_register_protocol(proto_dsi, NULL);
|
|
|
|
prefs_register_bool_preference(dsi_module, "desegment",
|
|
|
|
"Reassemble DSI messages spanning multiple TCP segments",
|
|
|
|
"Whether the DSI dissector should reassemble messages spanning multiple TCP segments."
|
|
|
|
" To use this option, you must also enable \"Allow subdissectors to reassemble TCP streams\" in the TCP protocol settings.",
|
|
|
|
&dsi_desegment);
|
2001-05-24 20:25:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
proto_reg_handoff_dsi(void)
|
|
|
|
{
|
2010-11-08 21:59:39 +00:00
|
|
|
dissector_handle_t dsi_handle;
|
2002-04-22 08:50:49 +00:00
|
|
|
|
2013-11-09 17:46:28 +00:00
|
|
|
dsi_handle = new_create_dissector_handle(dissect_dsi, proto_dsi);
|
2010-12-20 05:35:29 +00:00
|
|
|
dissector_add_uint("tcp.port", TCP_PORT_DSI, dsi_handle);
|
2002-04-22 08:50:49 +00:00
|
|
|
|
2010-11-08 21:59:39 +00:00
|
|
|
data_handle = find_dissector("data");
|
|
|
|
afp_handle = find_dissector("afp");
|
2001-05-24 20:25:25 +00:00
|
|
|
}
|