1999-12-07 06:13:19 +00:00
|
|
|
/* packet-srvloc.c
|
|
|
|
* Routines for SRVLOC (Service Location Protocol) packet dissection
|
|
|
|
* Copyright 1999, James Coe <jammer@cin.net>
|
2002-10-02 08:57:32 +00:00
|
|
|
* Copyright 2002, Brad Hards
|
2003-08-18 18:06:06 +00:00
|
|
|
* Updated for TCP segments by Greg Morris <gmorris@novell.com>
|
|
|
|
* Copyright 2003, Greg Morris
|
1999-12-07 06:13:19 +00:00
|
|
|
*
|
|
|
|
* NOTE: This is Alpha software not all features have been verified yet.
|
2002-08-28 21:04:11 +00:00
|
|
|
* In particular I have not had an opportunity to see how it
|
1999-12-07 06:13:19 +00:00
|
|
|
* responds to SRVLOC over TCP.
|
|
|
|
*
|
2004-07-18 00:24:25 +00:00
|
|
|
* $Id$
|
1999-12-07 06:13:19 +00:00
|
|
|
*
|
|
|
|
* Ethereal - Network traffic analyzer
|
2001-04-23 18:19:03 +00:00
|
|
|
* By Gerald Combs <gerald@ethereal.com>
|
1999-12-07 06:13:19 +00:00
|
|
|
* Copyright 1998 Gerald Combs
|
|
|
|
*
|
1999-12-15 01:48:58 +00:00
|
|
|
* Service Location Protocol is RFC 2165
|
2002-10-02 08:57:32 +00:00
|
|
|
* Service Location Protocol Version 2 is RFC 2608
|
|
|
|
* - partial support by Brad Hards <bradh@frogmouth.net>
|
1999-12-15 01:48:58 +00:00
|
|
|
*
|
1999-12-07 06:13:19 +00:00
|
|
|
* 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
|
|
|
*
|
1999-12-07 06:13:19 +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
|
|
|
*
|
1999-12-07 06:13:19 +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
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include "config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
2000-08-11 13:37:21 +00:00
|
|
|
#include <string.h>
|
|
|
|
#include <time.h>
|
|
|
|
#include <glib.h>
|
|
|
|
|
2002-01-21 07:37:49 +00:00
|
|
|
#include <epan/packet.h>
|
|
|
|
#include <epan/strutil.h>
|
2004-09-27 22:55:15 +00:00
|
|
|
#include <epan/prefs.h>
|
2003-08-18 18:06:06 +00:00
|
|
|
#include "packet-tcp.h"
|
2005-02-09 23:38:00 +00:00
|
|
|
#include <epan/reassemble.h>
|
2005-10-12 22:37:15 +00:00
|
|
|
#include <epan/emem.h>
|
1999-12-07 06:13:19 +00:00
|
|
|
|
2003-08-18 18:06:06 +00:00
|
|
|
static gboolean srvloc_desegment = TRUE;
|
2000-04-08 07:07:42 +00:00
|
|
|
static int proto_srvloc = -1;
|
|
|
|
static int hf_srvloc_version = -1;
|
|
|
|
static int hf_srvloc_function = -1;
|
2002-10-02 08:57:32 +00:00
|
|
|
static int hf_srvloc_pktlen = -1;
|
|
|
|
static int hf_srvloc_xid = -1;
|
|
|
|
static int hf_srvloc_langtaglen = -1;
|
|
|
|
static int hf_srvloc_langtag = -1;
|
|
|
|
static int hf_srvloc_nextextoff = -1;
|
2003-03-01 09:03:42 +00:00
|
|
|
static int hf_srvloc_flags_v1 = -1;
|
|
|
|
static int hf_srvloc_flags_v1_overflow = -1;
|
|
|
|
static int hf_srvloc_flags_v1_monolingual = -1;
|
|
|
|
static int hf_srvloc_flags_v1_url_auth = -1;
|
|
|
|
static int hf_srvloc_flags_v1_attribute_auth = -1;
|
|
|
|
static int hf_srvloc_flags_v1_fresh = -1;
|
2000-04-08 07:07:42 +00:00
|
|
|
static int hf_srvloc_error = -1;
|
2002-10-02 08:57:32 +00:00
|
|
|
static int hf_srvloc_flags_v2 = -1;
|
|
|
|
static int hf_srvloc_flags_v2_overflow = -1;
|
|
|
|
static int hf_srvloc_flags_v2_fresh = -1;
|
|
|
|
static int hf_srvloc_flags_v2_reqmulti = -1;
|
|
|
|
static int hf_srvloc_error_v2 = -1;
|
|
|
|
static int hf_srvloc_daadvert_timestamp = -1;
|
|
|
|
static int hf_srvloc_daadvert_urllen = -1;
|
|
|
|
static int hf_srvloc_daadvert_url = -1;
|
|
|
|
static int hf_srvloc_daadvert_scopelistlen = -1;
|
|
|
|
static int hf_srvloc_daadvert_scopelist = -1;
|
|
|
|
static int hf_srvloc_daadvert_attrlistlen = -1;
|
|
|
|
static int hf_srvloc_daadvert_attrlist = -1;
|
|
|
|
static int hf_srvloc_daadvert_slpspilen = -1;
|
|
|
|
static int hf_srvloc_daadvert_slpspi = -1;
|
|
|
|
static int hf_srvloc_daadvert_authcount = -1;
|
|
|
|
static int hf_srvloc_srvreq_prlistlen = -1;
|
|
|
|
static int hf_srvloc_srvreq_prlist = -1;
|
|
|
|
static int hf_srvloc_srvreq_srvtypelen = -1;
|
|
|
|
static int hf_srvloc_srvreq_srvtypelist = -1;
|
|
|
|
static int hf_srvloc_srvreq_scopelistlen = -1;
|
|
|
|
static int hf_srvloc_srvreq_scopelist = -1;
|
|
|
|
static int hf_srvloc_srvreq_predicatelen = -1;
|
|
|
|
static int hf_srvloc_srvreq_predicate = -1;
|
|
|
|
static int hf_srvloc_srvreq_slpspilen = -1;
|
|
|
|
static int hf_srvloc_srvreq_slpspi = -1;
|
|
|
|
static int hf_srvloc_srvrply_urlcount = -1;
|
|
|
|
static int hf_srvloc_srvreg_attrlistlen = -1;
|
|
|
|
static int hf_srvloc_srvreg_attrlist = -1;
|
|
|
|
static int hf_srvloc_srvreg_attrauthcount = -1;
|
|
|
|
static int hf_srvloc_srvreg_srvtypelen = -1;
|
|
|
|
static int hf_srvloc_srvreg_srvtype = -1;
|
|
|
|
static int hf_srvloc_srvreg_scopelistlen = -1;
|
|
|
|
static int hf_srvloc_srvreg_scopelist = -1;
|
|
|
|
static int hf_srvloc_srvdereg_scopelistlen = -1;
|
|
|
|
static int hf_srvloc_srvdereg_scopelist = -1;
|
|
|
|
static int hf_srvloc_srvdereg_taglistlen = -1;
|
|
|
|
static int hf_srvloc_srvdereg_taglist = -1;
|
|
|
|
static int hf_srvloc_attrreq_prlistlen = -1;
|
|
|
|
static int hf_srvloc_attrreq_prlist = -1;
|
|
|
|
static int hf_srvloc_attrreq_urllen = -1;
|
|
|
|
static int hf_srvloc_attrreq_url = -1;
|
|
|
|
static int hf_srvloc_attrreq_scopelistlen = -1;
|
|
|
|
static int hf_srvloc_attrreq_scopelist = -1;
|
2003-02-24 01:22:30 +00:00
|
|
|
static int hf_srvloc_attrreq_attrlistlen = -1;
|
|
|
|
static int hf_srvloc_attrreq_attrlist = -1;
|
2002-10-02 08:57:32 +00:00
|
|
|
static int hf_srvloc_attrreq_taglistlen = -1;
|
|
|
|
static int hf_srvloc_attrreq_taglist = -1;
|
|
|
|
static int hf_srvloc_attrreq_slpspilen = -1;
|
|
|
|
static int hf_srvloc_attrreq_slpspi = -1;
|
|
|
|
static int hf_srvloc_attrrply_attrlistlen = -1;
|
|
|
|
static int hf_srvloc_attrrply_attrlist = -1;
|
|
|
|
static int hf_srvloc_attrrply_attrauthcount = -1;
|
|
|
|
static int hf_srvloc_srvtypereq_prlistlen = -1;
|
|
|
|
static int hf_srvloc_srvtypereq_prlist = -1;
|
2003-02-24 01:22:30 +00:00
|
|
|
static int hf_srvloc_srvtypereq_nameauthlistlen = -1;
|
|
|
|
static int hf_srvloc_srvtypereq_nameauthlistlenall = -1;
|
|
|
|
static int hf_srvloc_srvtypereq_nameauthlist = -1;
|
2002-10-02 08:57:32 +00:00
|
|
|
static int hf_srvloc_srvtypereq_scopelistlen = -1;
|
|
|
|
static int hf_srvloc_srvtypereq_scopelist = -1;
|
2003-02-24 01:22:30 +00:00
|
|
|
static int hf_srvloc_srvtyperply_srvtypelen = -1;
|
|
|
|
static int hf_srvloc_srvtyperply_srvtype = -1;
|
|
|
|
static int hf_srvloc_srvtyperply_srvtypelistlen = -1;
|
|
|
|
static int hf_srvloc_srvtyperply_srvtypelist = -1;
|
2002-10-02 08:57:32 +00:00
|
|
|
static int hf_srvloc_saadvert_urllen = -1;
|
|
|
|
static int hf_srvloc_saadvert_url = -1;
|
|
|
|
static int hf_srvloc_saadvert_scopelistlen = -1;
|
|
|
|
static int hf_srvloc_saadvert_scopelist = -1;
|
|
|
|
static int hf_srvloc_saadvert_attrlistlen = -1;
|
|
|
|
static int hf_srvloc_saadvert_attrlist = -1;
|
|
|
|
static int hf_srvloc_saadvert_authcount = -1;
|
|
|
|
static int hf_srvloc_authblkv2_bsd = -1;
|
|
|
|
static int hf_srvloc_authblkv2_len = -1;
|
|
|
|
static int hf_srvloc_authblkv2_timestamp = -1;
|
|
|
|
static int hf_srvloc_authblkv2_slpspilen = -1;
|
|
|
|
static int hf_srvloc_authblkv2_slpspi = -1;
|
|
|
|
static int hf_srvloc_url_reserved = -1;
|
|
|
|
static int hf_srvloc_url_lifetime = -1;
|
|
|
|
static int hf_srvloc_url_urllen = -1;
|
|
|
|
static int hf_srvloc_url_url = -1;
|
|
|
|
static int hf_srvloc_url_numauths = -1;
|
2003-12-08 20:50:02 +00:00
|
|
|
static int hf_srvloc_add_ref_ip = -1;
|
2002-10-02 08:57:32 +00:00
|
|
|
|
1999-12-07 06:13:19 +00:00
|
|
|
|
|
|
|
static gint ett_srvloc = -1;
|
2000-04-08 07:07:42 +00:00
|
|
|
static gint ett_srvloc_flags = -1;
|
|
|
|
|
2002-10-02 08:57:32 +00:00
|
|
|
|
2003-03-01 09:03:42 +00:00
|
|
|
static const true_false_string tfs_srvloc_flags_overflow = {
|
2002-10-02 08:57:32 +00:00
|
|
|
"Message will not fit in datagram",
|
|
|
|
"Message will fit in a datagram"
|
|
|
|
};
|
2003-03-01 09:03:42 +00:00
|
|
|
static const true_false_string tfs_srvloc_flags_v1_monolingual = {
|
|
|
|
"Only responses in specified language will be accepted",
|
|
|
|
"Responses in any language will be accepted"
|
|
|
|
};
|
|
|
|
static const true_false_string tfs_srvloc_flags_v1_url_auth = {
|
|
|
|
"URL Authentication Block is present",
|
|
|
|
"URL Authentication Block is absent"
|
|
|
|
};
|
|
|
|
static const true_false_string tfs_srvloc_flags_v1_attribute_auth = {
|
|
|
|
"Attribute Authentication Block is present",
|
|
|
|
"Attribute Authentication Block is absent"
|
|
|
|
};
|
|
|
|
static const true_false_string tfs_srvloc_flags_fresh = {
|
2002-10-02 08:57:32 +00:00
|
|
|
"New Service Registration",
|
|
|
|
"Not a new Service Registration"
|
|
|
|
};
|
|
|
|
static const true_false_string tfs_srvloc_flags_v2_reqmulti = {
|
|
|
|
"Multicast (or broadcast) request",
|
|
|
|
"Not multicast or broadcast"
|
|
|
|
};
|
|
|
|
|
2000-04-08 07:07:42 +00:00
|
|
|
#define TCP_PORT_SRVLOC 427
|
|
|
|
#define UDP_PORT_SRVLOC 427
|
1999-12-07 06:13:19 +00:00
|
|
|
|
|
|
|
/* Define function types */
|
|
|
|
|
|
|
|
#define SRVREQ 1
|
|
|
|
#define SRVRPLY 2
|
|
|
|
#define SRVREG 3
|
|
|
|
#define SRVDEREG 4
|
|
|
|
#define SRVACK 5
|
|
|
|
#define ATTRRQST 6
|
|
|
|
#define ATTRRPLY 7
|
|
|
|
#define DAADVERT 8
|
|
|
|
#define SRVTYPERQST 9
|
|
|
|
#define SRVTYPERPLY 10
|
2002-10-02 08:57:32 +00:00
|
|
|
#define SAADVERT 11 /* SLPv2, section 8 */
|
1999-12-07 06:13:19 +00:00
|
|
|
|
|
|
|
/* Create protocol header structure */
|
|
|
|
|
2002-10-02 08:57:32 +00:00
|
|
|
/* bradh: looks like never used. */
|
|
|
|
/* bradh: comment it out for now since it doesn't work for v2
|
1999-12-07 06:13:19 +00:00
|
|
|
struct srvloc_hdr {
|
|
|
|
guint8 version;
|
|
|
|
guint8 function;
|
|
|
|
guint16 length;
|
|
|
|
guint8 flags;
|
|
|
|
guint8 dialect;
|
2002-08-02 23:36:07 +00:00
|
|
|
guchar language[2];
|
1999-12-07 06:13:19 +00:00
|
|
|
guint16 encoding;
|
|
|
|
guint16 xid;
|
|
|
|
};
|
2002-10-02 08:57:32 +00:00
|
|
|
*/
|
1999-12-07 06:13:19 +00:00
|
|
|
|
|
|
|
/* List to resolve function numbers to names */
|
|
|
|
|
1999-12-15 01:48:58 +00:00
|
|
|
static const value_string srvloc_functions[] = {
|
2002-08-28 21:04:11 +00:00
|
|
|
{ SRVREQ, "Service Request" },
|
|
|
|
{ SRVRPLY, "Service Reply" },
|
|
|
|
{ SRVREG, "Service Registration" },
|
|
|
|
{ SRVDEREG, "Service Deregister" },
|
|
|
|
{ SRVACK, "Service Acknowledge" },
|
|
|
|
{ ATTRRQST, "Attribute Request" },
|
|
|
|
{ ATTRRPLY, "Attribute Reply" },
|
|
|
|
{ DAADVERT, "DA Advertisement" },
|
|
|
|
{ SRVTYPERQST, "Service Type Request" },
|
|
|
|
{ SRVTYPERPLY, "Service Type Reply" },
|
2002-10-02 08:57:32 +00:00
|
|
|
{ SAADVERT, "SA Advertisement" }, /* v2 only */
|
2001-01-03 16:41:08 +00:00
|
|
|
{ 0, NULL }
|
1999-12-07 06:13:19 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* List to resolve flag values to names */
|
|
|
|
|
|
|
|
|
1999-12-09 20:46:28 +00:00
|
|
|
/* Define flag masks */
|
|
|
|
|
|
|
|
#define FLAG_O 0x80
|
|
|
|
#define FLAG_M 0x40
|
|
|
|
#define FLAG_U 0x20
|
|
|
|
#define FLAG_A 0x10
|
|
|
|
#define FLAG_F 0x08
|
|
|
|
|
2002-10-02 08:57:32 +00:00
|
|
|
/* it all changes for Version 2 */
|
|
|
|
#define FLAG_O_V2 0x8000
|
|
|
|
#define FLAG_F_V2 0x4000
|
|
|
|
#define FLAG_R_V2 0x2000
|
|
|
|
|
|
|
|
/* Define Error Codes - Version 1*/
|
1999-12-07 06:13:19 +00:00
|
|
|
|
|
|
|
#define SUCCESS 0
|
|
|
|
#define LANG_NOT_SPTD 1
|
|
|
|
#define PROT_PARSE_ERR 2
|
|
|
|
#define INVLD_REG 3
|
|
|
|
#define SCOPE_NOT_SPTD 4
|
|
|
|
#define CHRSET_NOT_UND 5
|
|
|
|
#define AUTH_ABSENT 6
|
|
|
|
#define AUTH_FAILED 7
|
|
|
|
|
|
|
|
/* List to resolve error codes to names */
|
|
|
|
|
|
|
|
static const value_string srvloc_errs[] = {
|
|
|
|
{ SUCCESS, "No Error" },
|
|
|
|
{ LANG_NOT_SPTD, "Language not supported" },
|
|
|
|
{ PROT_PARSE_ERR, "Protocol parse error" },
|
|
|
|
{ INVLD_REG, "Invalid registration" },
|
|
|
|
{ SCOPE_NOT_SPTD, "Scope not supported" },
|
|
|
|
{ CHRSET_NOT_UND, "Character set not understood" },
|
|
|
|
{ AUTH_ABSENT, "Authentication absent" },
|
|
|
|
{ AUTH_FAILED, "Authentication failed" },
|
2001-01-03 16:41:08 +00:00
|
|
|
{ 0, NULL }
|
1999-12-07 06:13:19 +00:00
|
|
|
};
|
|
|
|
|
2002-10-02 08:57:32 +00:00
|
|
|
/* Define Error Codes for Version 2 */
|
|
|
|
|
|
|
|
#define LANGUAGE_NOT_SUPPORTED 1
|
|
|
|
#define PARSE_ERROR 2
|
|
|
|
#define INVALID_REGISTRATION 3
|
|
|
|
#define SCOPE_NOT_SUPPORTED 4
|
|
|
|
#define AUTHENTICATION_UNKNOWN 5
|
|
|
|
#define AUTHENTICATION_ABSENT 6
|
|
|
|
#define AUTHENTICATION_FAILED 7
|
|
|
|
#define VER_NOT_SUPPORTED 9
|
|
|
|
#define INTERNAL_ERROR 10
|
|
|
|
#define DA_BUSY_NOW 11
|
|
|
|
#define OPTION_NOT_UNDERSTOOD 12
|
|
|
|
#define INVALID_UPDATE 13
|
|
|
|
#define MSG_NOT_SUPPORTED 14
|
|
|
|
#define REFRESH_REJECTED 15
|
|
|
|
|
|
|
|
static const value_string srvloc_errs_v2[] = {
|
|
|
|
{ SUCCESS, "No Error" },
|
|
|
|
{ LANGUAGE_NOT_SUPPORTED, "No data in the requested language" },
|
|
|
|
{ PARSE_ERROR, "The message fails to obey SLP syntax." },
|
|
|
|
{ INVALID_REGISTRATION, "The SrvReg has problems" },
|
|
|
|
{ SCOPE_NOT_SUPPORTED, "Scope list not supported" },
|
|
|
|
{ AUTHENTICATION_UNKNOWN, "Unsupported SLP SPI." },
|
|
|
|
{ AUTHENTICATION_ABSENT, "URL and ATTR authentication not provided"},
|
|
|
|
{ AUTHENTICATION_FAILED, "Authentication error"},
|
|
|
|
{ VER_NOT_SUPPORTED, "Unsupported version number in message header" },
|
|
|
|
{ INTERNAL_ERROR, "The DA (or SA) is too sick to respond" },
|
|
|
|
{ DA_BUSY_NOW, "UA or SA SHOULD retry" },
|
|
|
|
{ OPTION_NOT_UNDERSTOOD, "Unknown option from the mandatory range"},
|
|
|
|
{ INVALID_UPDATE, "Invalid SrvReg" },
|
|
|
|
{ MSG_NOT_SUPPORTED, "No support for AttrRqst or SrvTypeRqst" },
|
|
|
|
{ REFRESH_REJECTED, "SrvReg sent too soon"},
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
2001-01-13 08:57:46 +00:00
|
|
|
/*
|
|
|
|
* Character encodings.
|
|
|
|
* This is a small subset of what's in
|
|
|
|
*
|
2004-02-28 22:56:36 +00:00
|
|
|
* http://www.iana.org/assignments/character-sets
|
2001-01-13 08:57:46 +00:00
|
|
|
*
|
|
|
|
* XXX - we should do something useful with this, i.e. properly
|
|
|
|
* handle strings based on the character set they're in.
|
|
|
|
*
|
|
|
|
* XXX - what does "properly handle strings" mean? How do we know
|
|
|
|
* what character set the terminal can handle (for tty-based code)
|
|
|
|
* or the GUI can handle (for GUI code)?
|
|
|
|
*
|
|
|
|
* XXX - the Ethereal core really should be what does all the
|
|
|
|
* character set handling for strings, and it should be stuck with
|
|
|
|
* the task of figuring out how to properly handle them.
|
|
|
|
*/
|
|
|
|
#define CHARSET_ASCII 3
|
|
|
|
#define CHARSET_ISO_10646_UTF_1 27
|
|
|
|
#define CHARSET_ISO_646_BASIC 28
|
|
|
|
#define CHARSET_ISO_646_IRV 30
|
|
|
|
#define CHARSET_ISO_8859_1 4
|
|
|
|
#define CHARSET_ISO_10646_UCS_2 1000 /* a/k/a Unicode */
|
|
|
|
#define CHARSET_UTF_7 1012
|
|
|
|
#define CHARSET_UTF_8 106
|
|
|
|
|
|
|
|
static const value_string charsets[] = {
|
|
|
|
{ CHARSET_ASCII, "US-ASCII" },
|
|
|
|
{ CHARSET_ISO_10646_UTF_1, "ISO 10646 UTF-1" },
|
|
|
|
{ CHARSET_ISO_646_BASIC, "ISO 646 basic:1983" },
|
|
|
|
{ CHARSET_ISO_646_IRV, "ISO 646 IRV:1983" },
|
|
|
|
{ CHARSET_ISO_8859_1, "ISO 8859-1" },
|
|
|
|
{ CHARSET_ISO_10646_UCS_2, "Unicode" },
|
|
|
|
{ CHARSET_UTF_7, "UTF-7" },
|
|
|
|
{ CHARSET_UTF_8, "UTF-8" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
2000-08-04 07:38:13 +00:00
|
|
|
static int
|
2001-01-13 08:57:46 +00:00
|
|
|
dissect_authblk(tvbuff_t *tvb, int offset, proto_tree *tree)
|
1999-12-09 20:46:28 +00:00
|
|
|
{
|
2002-10-02 08:57:32 +00:00
|
|
|
struct tm *stamp;
|
|
|
|
time_t seconds;
|
|
|
|
double floatsec;
|
|
|
|
guint16 length;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2001-01-13 08:57:46 +00:00
|
|
|
seconds = tvb_get_ntohl(tvb, offset) - 2208988800ul;
|
1999-12-09 20:46:28 +00:00
|
|
|
stamp = gmtime(&seconds);
|
2001-07-15 19:14:03 +00:00
|
|
|
if (stamp != NULL) {
|
|
|
|
floatsec = stamp->tm_sec + tvb_get_ntohl(tvb, offset + 4) / 4294967296.0;
|
|
|
|
proto_tree_add_text(tree, tvb, offset, 8,
|
|
|
|
"Timestamp: %04d-%02d-%02d %02d:%02d:%07.4f UTC",
|
|
|
|
stamp->tm_year + 1900, stamp->tm_mon + 1,
|
|
|
|
stamp->tm_mday, stamp->tm_hour, stamp->tm_min,
|
|
|
|
floatsec);
|
|
|
|
} else {
|
|
|
|
proto_tree_add_text(tree, tvb, offset, 8, "Timestamp not representable");
|
|
|
|
}
|
2001-01-13 08:57:46 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset + 8, 2, "Block Structure Desciptor: %u",
|
|
|
|
tvb_get_ntohs(tvb, offset + 8));
|
|
|
|
length = tvb_get_ntohs(tvb, offset + 10);
|
|
|
|
proto_tree_add_text(tree, tvb, offset + 10, 2, "Authenticator length: %u",
|
1999-12-09 20:46:28 +00:00
|
|
|
length);
|
|
|
|
offset += 12;
|
2001-01-13 08:57:46 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, length, "Authentication block: %s",
|
|
|
|
tvb_format_text(tvb, offset, length));
|
1999-12-09 20:46:28 +00:00
|
|
|
offset += length;
|
2000-08-04 07:38:13 +00:00
|
|
|
return offset;
|
2001-03-09 04:35:25 +00:00
|
|
|
}
|
1999-12-09 20:46:28 +00:00
|
|
|
|
2002-10-02 08:57:32 +00:00
|
|
|
/* SLPv2 version - Needs to be fixed to match RFC2608 sect 9.2*/
|
|
|
|
static int
|
|
|
|
dissect_authblk_v2(tvbuff_t *tvb, int offset, proto_tree *tree)
|
|
|
|
{
|
|
|
|
guint16 length;
|
2005-04-20 19:16:02 +00:00
|
|
|
nstime_t ts;
|
2002-10-02 08:57:32 +00:00
|
|
|
|
|
|
|
proto_tree_add_item(tree, hf_srvloc_authblkv2_bsd, tvb, offset, 2, FALSE);
|
|
|
|
proto_tree_add_item(tree, hf_srvloc_authblkv2_len, tvb, offset+2, 2, FALSE);
|
2005-04-20 19:16:02 +00:00
|
|
|
ts.nsecs = 0;
|
|
|
|
ts.secs = tvb_get_ntohl(tvb, offset + 4);
|
|
|
|
proto_tree_add_time(tree, hf_srvloc_authblkv2_timestamp, tvb, offset+4, 4, &ts);
|
2002-10-02 08:57:32 +00:00
|
|
|
length = tvb_get_ntohs(tvb, offset + 8);
|
|
|
|
proto_tree_add_uint(tree, hf_srvloc_authblkv2_slpspilen, tvb, offset + 8, 2, length);
|
|
|
|
offset += 10;
|
|
|
|
proto_tree_add_item(tree, hf_srvloc_authblkv2_slpspi, tvb, offset, length, TRUE);
|
|
|
|
offset += length;
|
|
|
|
/* add code in here to handle Structured Authentication Block */
|
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
dissect_attrauthblk_v2(tvbuff_t *tvb, int offset, proto_tree *tree)
|
|
|
|
{
|
|
|
|
tvb=tvb; tree=tree; /* silence gcc for now */
|
|
|
|
/* add code in here to handle attribute authentication */
|
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
|
2003-02-24 01:22:30 +00:00
|
|
|
static void
|
|
|
|
add_v1_string(proto_tree *tree, int hf, tvbuff_t *tvb, int offset, int length,
|
|
|
|
guint16 encoding)
|
|
|
|
{
|
|
|
|
char *unicode_str;
|
|
|
|
|
|
|
|
switch (encoding) {
|
|
|
|
|
|
|
|
case CHARSET_ISO_10646_UCS_2:
|
2005-08-10 14:17:27 +00:00
|
|
|
unicode_str = tvb_get_ephemeral_faked_unicode(tvb, offset, length/2, FALSE);
|
2003-02-24 01:22:30 +00:00
|
|
|
proto_tree_add_string(tree, hf, tvb, offset, length,
|
|
|
|
unicode_str);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
proto_tree_add_item(tree, hf, tvb, offset, length, TRUE);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-10-12 22:37:15 +00:00
|
|
|
/*
|
|
|
|
* XXX - is this trying to guess the byte order?
|
|
|
|
*
|
|
|
|
* http://www.iana.org/assignments/character-sets
|
|
|
|
*
|
|
|
|
* says of ISO-10646-UCS-2, which has the code 1000 (this routine is used
|
|
|
|
* with CHARSET_ISO_10646_UCS_2, which is #defined to be 1000):
|
|
|
|
*
|
|
|
|
* this needs to specify network byte order: the standard
|
|
|
|
* does not specify (it is a 16-bit integer space)
|
|
|
|
*
|
|
|
|
* Does that mean that in SRVLOC, ISO-10646-UCS-2 is always big-endian?
|
|
|
|
* If so, can we just use "tvb_get_ephemeral_faked_unicode()" and be
|
|
|
|
* done with it?
|
|
|
|
*
|
|
|
|
* XXX - this is also used with CHARSET_UTF_8. Is that a cut-and-pasteo?
|
|
|
|
*/
|
2003-12-08 20:50:02 +00:00
|
|
|
static guint8*
|
|
|
|
unicode_to_bytes(tvbuff_t *tvb, int offset, int length, gboolean endianness)
|
|
|
|
{
|
|
|
|
const char *ascii_text = tvb_get_ptr(tvb, offset, length);
|
2005-04-25 03:02:50 +00:00
|
|
|
int i, j=0;
|
2003-12-08 20:50:02 +00:00
|
|
|
guint8 c_char, c_char1;
|
2005-10-12 22:37:15 +00:00
|
|
|
guint8 *byte_array;
|
2003-12-08 20:50:02 +00:00
|
|
|
|
|
|
|
if (endianness) {
|
2005-10-12 22:37:15 +00:00
|
|
|
byte_array = ep_alloc(length*2 + 1);
|
2003-12-08 20:50:02 +00:00
|
|
|
for (i = length; i > 0; i--) {
|
|
|
|
c_char = ascii_text[i];
|
|
|
|
if (c_char != 0) {
|
|
|
|
i--;
|
|
|
|
c_char1 = ascii_text[i];
|
|
|
|
if (c_char1 == 0) {
|
|
|
|
i--;
|
|
|
|
c_char1 = ascii_text[i];
|
|
|
|
}
|
|
|
|
byte_array[j] = c_char1;
|
|
|
|
j++;
|
|
|
|
byte_array[j] = c_char;
|
|
|
|
j++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2005-10-12 22:37:15 +00:00
|
|
|
byte_array = ep_alloc(length + 1);
|
2003-12-08 20:50:02 +00:00
|
|
|
for (i = 0; i < length; i++) {
|
|
|
|
c_char = ascii_text[i];
|
|
|
|
if (c_char != 0) {
|
|
|
|
byte_array[j] = c_char;
|
|
|
|
j++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
byte_array[j]=0;
|
|
|
|
return byte_array;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Format of x-x-x-xxxxxxxx. Each of these entries represents the service binding to UDP, TCP, or IPX.
|
|
|
|
* The first digit is the protocol family: 2 for TCP/UPD, 6 for IPX.
|
|
|
|
* The second digit is the socket type: 1 for socket stream (TCP), 2 for datagram (UDP and IPX).
|
|
|
|
* The third is the protocol: 6 for TCP, 17 for UDP, and 1000 for IPX.
|
|
|
|
* Last is the IP address, in hex, of the interface that is registered (or, in the case of IPX, an IPX network number).
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
attr_list(proto_tree *tree, int hf, tvbuff_t *tvb, int offset, int length,
|
|
|
|
guint16 encoding)
|
|
|
|
{
|
|
|
|
char *attr_type;
|
|
|
|
int i, svc, ss, type_len, foffset=offset;
|
|
|
|
guint32 prot;
|
|
|
|
guint8 *byte_value;
|
|
|
|
proto_item *ti;
|
|
|
|
proto_tree *srvloc_tree;
|
2005-01-07 10:44:44 +00:00
|
|
|
guint8 *tmp;
|
2003-12-08 20:50:02 +00:00
|
|
|
|
|
|
|
static const value_string srvloc_svc[] = {
|
|
|
|
{ 50, "TCP/UDP" },
|
|
|
|
{ 54, "IPX" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string srvloc_ss[] = {
|
|
|
|
{ 49, "Socket" },
|
|
|
|
{ 50, "Datagram" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string srvloc_prot[] = {
|
|
|
|
{ 54, "TCP" },
|
|
|
|
{ 17, "UDP" },
|
|
|
|
{ 1000, "IPX" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
|
|
|
switch (encoding) {
|
|
|
|
|
|
|
|
case CHARSET_ISO_10646_UCS_2:
|
|
|
|
|
2005-08-10 14:17:27 +00:00
|
|
|
tmp = tvb_get_ephemeral_faked_unicode(tvb, offset, length/2, FALSE);
|
2005-01-07 10:44:44 +00:00
|
|
|
type_len = strcspn(tmp, "=");
|
2005-08-10 14:17:27 +00:00
|
|
|
attr_type = tvb_get_ephemeral_faked_unicode(tvb, offset+2, type_len-1, FALSE);
|
2003-12-08 20:50:02 +00:00
|
|
|
proto_tree_add_string(tree, hf, tvb, offset, type_len*2, attr_type);
|
|
|
|
i=1;
|
|
|
|
for (foffset = offset + ((type_len*2)+2); foffset<length; foffset += 2) {
|
|
|
|
|
|
|
|
ti = proto_tree_add_text(tree, tvb, foffset, -1, "Item %d", i);
|
|
|
|
srvloc_tree = proto_item_add_subtree(ti, ett_srvloc);
|
|
|
|
|
|
|
|
svc = tvb_get_guint8(tvb, foffset+1);
|
|
|
|
proto_tree_add_text(srvloc_tree, tvb, foffset+1, 1,
|
|
|
|
"Service Type: %s", val_to_str(svc, srvloc_svc, "Unknown"));
|
|
|
|
ss = tvb_get_guint8(tvb, foffset+5);
|
|
|
|
proto_tree_add_text(srvloc_tree, tvb, foffset+5, 1,
|
|
|
|
"Communication Type: %s", val_to_str(ss, srvloc_ss, "Unknown"));
|
|
|
|
foffset += 9;
|
|
|
|
if (svc == 50) {
|
|
|
|
if (tvb_get_guint8(tvb, foffset)==54) { /* TCP */
|
|
|
|
prot = tvb_get_guint8(tvb, foffset);
|
|
|
|
proto_tree_add_text(srvloc_tree, tvb, foffset, 1,
|
|
|
|
"Protocol: %s", val_to_str(prot, srvloc_prot, "Unknown"));
|
|
|
|
foffset += 2;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
byte_value = unicode_to_bytes(tvb, foffset, 4, FALSE); /* UDP */
|
|
|
|
prot = atol(byte_value);
|
|
|
|
proto_tree_add_text(srvloc_tree, tvb, foffset, 4,
|
|
|
|
"Protocol: %s", val_to_str(prot, srvloc_prot, "Unknown"));
|
|
|
|
foffset += 4;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
byte_value = unicode_to_bytes(tvb, foffset, 8, FALSE); /* IPX */
|
|
|
|
prot = atol(byte_value);
|
|
|
|
proto_tree_add_text(srvloc_tree, tvb, foffset, 8,
|
|
|
|
"Protocol: %s", val_to_str(prot, srvloc_prot, "Unknown"));
|
|
|
|
foffset += 8;
|
|
|
|
}
|
|
|
|
if (svc == 50) {
|
|
|
|
byte_value = unicode_to_bytes(tvb, foffset, 16, TRUE); /* IP Address */
|
|
|
|
sscanf(byte_value,"%x",&prot);
|
|
|
|
proto_tree_add_ipv4(srvloc_tree, hf_srvloc_add_ref_ip, tvb, foffset+2, 16, prot);
|
|
|
|
byte_value = unicode_to_bytes(tvb, foffset+18, 8, FALSE); /* Port */
|
|
|
|
sscanf(byte_value,"%x",&prot);
|
|
|
|
proto_tree_add_text(srvloc_tree, tvb, foffset+18, 8, "Port: %d", prot);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
byte_value = unicode_to_bytes(tvb, foffset+2, 16, FALSE); /* IPX Network Address */
|
|
|
|
sscanf(byte_value,"%x",&prot);
|
|
|
|
proto_tree_add_text(srvloc_tree, tvb, foffset+2, 16, "Network: %s", byte_value);
|
|
|
|
byte_value = unicode_to_bytes(tvb, foffset+18, 24, FALSE); /* IPX Node Address */
|
|
|
|
sscanf(byte_value,"%x",&prot);
|
|
|
|
proto_tree_add_text(srvloc_tree, tvb, foffset+18, 24, "Node: %s", byte_value);
|
|
|
|
byte_value = unicode_to_bytes(tvb, foffset+42, 8, FALSE); /* Socket */
|
|
|
|
sscanf(byte_value,"%x",&prot);
|
|
|
|
proto_tree_add_text(srvloc_tree, tvb, foffset+42, 8, "Socket: %s", byte_value);
|
|
|
|
}
|
|
|
|
i++;
|
|
|
|
foffset += 57;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CHARSET_UTF_8:
|
|
|
|
type_len = strcspn(tvb_get_ptr(tvb, offset, length), "=");
|
|
|
|
attr_type = unicode_to_bytes(tvb, offset+1, type_len-1, FALSE);
|
|
|
|
proto_tree_add_string(tree, hf, tvb, offset+1, type_len-1, attr_type);
|
|
|
|
i=1;
|
|
|
|
for (foffset = offset + (type_len); foffset<length; foffset++) {
|
|
|
|
|
|
|
|
ti = proto_tree_add_text(tree, tvb, foffset, -1, "Item %d", i);
|
|
|
|
srvloc_tree = proto_item_add_subtree(ti, ett_srvloc);
|
|
|
|
|
|
|
|
svc = tvb_get_guint8(tvb, foffset+1);
|
|
|
|
proto_tree_add_text(srvloc_tree, tvb, foffset+1, 1,
|
|
|
|
"Service Type: %s", val_to_str(svc, srvloc_svc, "Unknown"));
|
|
|
|
ss = tvb_get_guint8(tvb, foffset+3);
|
|
|
|
proto_tree_add_text(srvloc_tree, tvb, foffset+3, 1,
|
|
|
|
"Communication Type: %s", val_to_str(ss, srvloc_ss, "Unknown"));
|
|
|
|
foffset += 5;
|
|
|
|
if (svc == 50) {
|
|
|
|
if (tvb_get_guint8(tvb, foffset)==54) { /* TCP */
|
|
|
|
prot = tvb_get_guint8(tvb, foffset);
|
|
|
|
proto_tree_add_text(srvloc_tree, tvb, foffset, 1,
|
|
|
|
"Protocol: %s", val_to_str(prot, srvloc_prot, "Unknown"));
|
|
|
|
foffset += 1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* UDP */
|
|
|
|
byte_value = unicode_to_bytes(tvb, foffset, 2, FALSE); /* UDP */
|
|
|
|
prot = atol(byte_value);
|
|
|
|
proto_tree_add_text(srvloc_tree, tvb, foffset, 2,
|
|
|
|
"Protocol: %s", val_to_str(prot, srvloc_prot, "Unknown"));
|
|
|
|
foffset += 2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
byte_value = unicode_to_bytes(tvb, foffset, 4, FALSE); /* IPX */
|
|
|
|
prot = atol(byte_value);
|
|
|
|
proto_tree_add_text(srvloc_tree, tvb, foffset, 4,
|
|
|
|
"Protocol: %s", val_to_str(prot, srvloc_prot, "Unknown"));
|
|
|
|
foffset += 4;
|
|
|
|
}
|
|
|
|
if (svc == 50) {
|
|
|
|
byte_value = unicode_to_bytes(tvb, foffset, 8, TRUE); /* IP Address */
|
|
|
|
sscanf(byte_value,"%x",&prot);
|
|
|
|
proto_tree_add_ipv4(srvloc_tree, hf_srvloc_add_ref_ip, tvb, foffset+1, 8, prot);
|
|
|
|
byte_value = unicode_to_bytes(tvb, foffset+9, 4, FALSE); /* Port */
|
|
|
|
sscanf(byte_value,"%x",&prot);
|
|
|
|
proto_tree_add_text(srvloc_tree, tvb, foffset+9, 4, "Port: %d", prot);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
byte_value = unicode_to_bytes(tvb, foffset+1, 8, FALSE); /* IPX Network Address */
|
|
|
|
sscanf(byte_value,"%x",&prot);
|
|
|
|
proto_tree_add_text(srvloc_tree, tvb, foffset+1, 8, "Network: %s", byte_value);
|
|
|
|
byte_value = unicode_to_bytes(tvb, foffset+9, 12, FALSE); /* IPX Node Address */
|
|
|
|
sscanf(byte_value,"%x",&prot);
|
|
|
|
proto_tree_add_text(srvloc_tree, tvb, foffset+9, 12, "Node: %s", byte_value);
|
|
|
|
byte_value = unicode_to_bytes(tvb, foffset+21, 4, FALSE); /* Socket */
|
|
|
|
sscanf(byte_value,"%x",&prot);
|
|
|
|
proto_tree_add_text(srvloc_tree, tvb, foffset+21, 4, "Socket: %s", byte_value);
|
|
|
|
}
|
|
|
|
i++;
|
|
|
|
foffset += 28;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
proto_tree_add_item(tree, hf, tvb, offset, length, TRUE);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-02-24 01:22:30 +00:00
|
|
|
static int
|
2003-02-24 02:04:18 +00:00
|
|
|
dissect_url_entry_v1(tvbuff_t *tvb, int offset, proto_tree *tree,
|
|
|
|
guint16 encoding, guint16 flags)
|
2003-02-24 01:22:30 +00:00
|
|
|
{
|
|
|
|
guint16 url_len;
|
|
|
|
|
|
|
|
proto_tree_add_item(tree, hf_srvloc_url_lifetime, tvb, offset, 2,
|
|
|
|
FALSE);
|
|
|
|
offset += 2;
|
|
|
|
url_len = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(tree, hf_srvloc_url_urllen, tvb, offset, 2,
|
|
|
|
url_len);
|
|
|
|
offset += 2;
|
|
|
|
add_v1_string(tree, hf_srvloc_url_url, tvb, offset, url_len, encoding);
|
|
|
|
offset += url_len;
|
|
|
|
if ( (flags & FLAG_U) == FLAG_U )
|
|
|
|
offset = dissect_authblk(tvb, offset, tree);
|
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
|
2002-10-02 08:57:32 +00:00
|
|
|
static int
|
2003-02-24 01:22:30 +00:00
|
|
|
dissect_url_entry_v2(tvbuff_t *tvb, int offset, proto_tree *tree)
|
2002-10-02 08:57:32 +00:00
|
|
|
{
|
|
|
|
guint8 reserved;
|
|
|
|
guint16 url_len;
|
|
|
|
guint8 num_auths;
|
|
|
|
|
|
|
|
reserved = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_uint(tree, hf_srvloc_url_reserved, tvb, offset, 1,
|
|
|
|
reserved);
|
|
|
|
offset += 1;
|
2003-02-24 01:22:30 +00:00
|
|
|
proto_tree_add_item(tree, hf_srvloc_url_lifetime, tvb, offset, 2,
|
|
|
|
FALSE);
|
2002-10-02 08:57:32 +00:00
|
|
|
offset += 2;
|
|
|
|
url_len = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(tree, hf_srvloc_url_urllen, tvb, offset, 2,
|
|
|
|
url_len);
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(tree, hf_srvloc_url_url, tvb, offset, url_len, TRUE);
|
|
|
|
offset += url_len;
|
|
|
|
num_auths = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_uint(tree, hf_srvloc_url_numauths, tvb, offset, 1,
|
|
|
|
num_auths);
|
|
|
|
offset += 1;
|
|
|
|
while (num_auths > 0) {
|
|
|
|
offset = dissect_authblk_v2(tvb, offset, tree);
|
|
|
|
num_auths--;
|
|
|
|
}
|
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
|
1999-12-07 06:13:19 +00:00
|
|
|
/* Packet dissection routine called by tcp & udp when port 427 detected */
|
|
|
|
|
2000-04-08 07:07:42 +00:00
|
|
|
static void
|
2001-01-13 08:57:46 +00:00
|
|
|
dissect_srvloc(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
|
1999-12-07 06:13:19 +00:00
|
|
|
{
|
2002-10-02 08:57:32 +00:00
|
|
|
int offset = 0;
|
|
|
|
proto_item *ti, *tf;
|
|
|
|
proto_tree *srvloc_tree, *srvloc_flags;
|
|
|
|
guint8 version;
|
|
|
|
guint8 function;
|
|
|
|
guint16 encoding;
|
|
|
|
guint32 length; /* three bytes needed for v2 */
|
|
|
|
guint16 flags; /* two byes needed for v2 */
|
|
|
|
guint32 count;
|
|
|
|
guint32 next_ext_off; /* three bytes, v2 only */
|
|
|
|
guint16 lang_tag_len;
|
|
|
|
nstime_t ts;
|
Add the "Edit:Protocols..." feature which currently only implements
the following:
It is now possible to enable/disable a particular protocol decoding
(i.e. the protocol dissector is void or not). When a protocol
is disabled, it is displayed as Data and of course, all linked
sub-protocols are disabled as well.
Disabling a protocol could be interesting:
- in case of buggy dissectors
- in case of wrong heuristics
- for performance reasons
- to decode the data as another protocol (TODO)
Currently (if I am not wrong), all dissectors but NFS can be disabled
(and dissectors that do not register protocols :-)
I do not like the way the RPC sub-dissectors are disabled (in the
sub-dissectors) since this could be done in the RPC dissector itself,
knowing the sub-protocol hfinfo entry (this is why, I've not modified
the NFS one yet).
Two functions are added in proto.c :
gboolean proto_is_protocol_enabled(int n);
void proto_set_decoding(int n, gboolean enabled);
and two MACROs which can be used in dissectors:
OLD_CHECK_DISPLAY_AS_DATA(index, pd, offset, fd, tree)
CHECK_DISPLAY_AS_DATA(index, tvb, pinfo, tree)
See also the XXX in proto_dlg.c and proto.c around the new functions.
svn path=/trunk/; revision=2267
2000-08-13 14:09:15 +00:00
|
|
|
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_PROTOCOL))
|
|
|
|
col_set_str(pinfo->cinfo, COL_PROTOCOL, "SRVLOC");
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_clear(pinfo->cinfo, COL_INFO);
|
2001-01-13 08:57:46 +00:00
|
|
|
|
|
|
|
version = tvb_get_guint8(tvb, offset);
|
|
|
|
function = tvb_get_guint8(tvb, offset + 1);
|
|
|
|
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_add_str(pinfo->cinfo, COL_INFO,
|
2001-01-13 08:57:46 +00:00
|
|
|
val_to_str(function, srvloc_functions, "Unknown Function (%u)"));
|
2002-08-28 21:04:11 +00:00
|
|
|
|
1999-12-07 06:13:19 +00:00
|
|
|
if (tree) {
|
2002-01-24 09:20:54 +00:00
|
|
|
ti = proto_tree_add_item(tree, proto_srvloc, tvb, offset, -1, FALSE);
|
1999-12-07 06:13:19 +00:00
|
|
|
srvloc_tree = proto_item_add_subtree(ti, ett_srvloc);
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2001-01-13 08:57:46 +00:00
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_version, tvb, offset, 1,
|
|
|
|
version);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_function, tvb, offset + 1, 1,
|
|
|
|
function);
|
2002-10-02 08:57:32 +00:00
|
|
|
if (version < 2) {
|
|
|
|
length = tvb_get_ntohs(tvb, offset + 2);
|
2003-02-24 01:22:30 +00:00
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_pktlen, tvb, offset + 2, 2,
|
2002-10-02 08:57:32 +00:00
|
|
|
length);
|
|
|
|
flags = tvb_get_guint8(tvb, offset + 4);
|
2003-03-01 09:03:42 +00:00
|
|
|
tf = proto_tree_add_uint(srvloc_tree, hf_srvloc_flags_v1, tvb, offset + 4, 1,
|
2002-10-02 08:57:32 +00:00
|
|
|
flags);
|
|
|
|
srvloc_flags = proto_item_add_subtree(tf, ett_srvloc_flags);
|
2003-03-01 09:03:42 +00:00
|
|
|
proto_tree_add_boolean(srvloc_flags, hf_srvloc_flags_v1_overflow,
|
|
|
|
tvb, offset+4, 1, flags);
|
|
|
|
proto_tree_add_boolean(srvloc_flags, hf_srvloc_flags_v1_monolingual,
|
|
|
|
tvb, offset+4, 1, flags);
|
|
|
|
proto_tree_add_boolean(srvloc_flags, hf_srvloc_flags_v1_url_auth,
|
|
|
|
tvb, offset+4, 1, flags);
|
|
|
|
proto_tree_add_boolean(srvloc_flags, hf_srvloc_flags_v1_attribute_auth,
|
|
|
|
tvb, offset+4, 1, flags);
|
|
|
|
proto_tree_add_boolean(srvloc_flags, hf_srvloc_flags_v1_fresh,
|
|
|
|
tvb, offset+4, 1, flags);
|
2002-10-02 08:57:32 +00:00
|
|
|
proto_tree_add_text(srvloc_tree, tvb, offset + 5, 1, "Dialect: %u",
|
|
|
|
tvb_get_guint8(tvb, offset + 5));
|
|
|
|
proto_tree_add_text(srvloc_tree, tvb, offset + 6, 2, "Language: %s",
|
|
|
|
tvb_format_text(tvb, offset + 6, 2));
|
|
|
|
encoding = tvb_get_ntohs(tvb, offset + 8);
|
|
|
|
proto_tree_add_text(srvloc_tree, tvb, offset + 8, 2, "Encoding: %u (%s)",
|
|
|
|
encoding,
|
|
|
|
val_to_str(encoding, charsets, "Unknown"));
|
|
|
|
proto_tree_add_text(srvloc_tree, tvb, offset + 10, 2, "Transaction ID: %u",
|
|
|
|
tvb_get_ntohs(tvb, offset + 10));
|
|
|
|
offset += 12;
|
|
|
|
|
|
|
|
switch (function) {
|
2001-01-13 08:57:46 +00:00
|
|
|
case SRVREQ:
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
2003-02-24 01:22:30 +00:00
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvreq_prlistlen, tvb, offset, 2, length);
|
2001-01-13 08:57:46 +00:00
|
|
|
offset += 2;
|
2003-02-24 01:22:30 +00:00
|
|
|
add_v1_string(srvloc_tree, hf_srvloc_srvreq_prlist, tvb, offset, length, encoding);
|
2001-01-13 08:57:46 +00:00
|
|
|
offset += length;
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
2003-02-24 01:22:30 +00:00
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvreq_predicatelen, tvb, offset, 2, length);
|
2001-01-13 08:57:46 +00:00
|
|
|
offset += 2;
|
2003-02-24 01:22:30 +00:00
|
|
|
add_v1_string(srvloc_tree, hf_srvloc_srvreq_predicate, tvb, offset, length, encoding);
|
2001-01-13 08:57:46 +00:00
|
|
|
offset += length;
|
2002-10-02 08:57:32 +00:00
|
|
|
break;
|
|
|
|
|
2001-01-13 08:57:46 +00:00
|
|
|
case SRVRPLY:
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_error, tvb, offset, 2, FALSE);
|
|
|
|
offset += 2;
|
|
|
|
count = tvb_get_ntohs(tvb, offset);
|
2003-02-24 01:22:30 +00:00
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvrply_urlcount, tvb, offset, 2, count);
|
2001-01-13 08:57:46 +00:00
|
|
|
offset += 2;
|
|
|
|
while (count > 0) {
|
2003-02-24 02:04:18 +00:00
|
|
|
offset = dissect_url_entry_v1(tvb, offset, srvloc_tree,
|
|
|
|
encoding, flags);
|
2001-01-13 08:57:46 +00:00
|
|
|
count--;
|
|
|
|
};
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SRVREG:
|
2003-02-24 02:04:18 +00:00
|
|
|
offset = dissect_url_entry_v1(tvb, offset, srvloc_tree, encoding,
|
2003-02-24 01:22:30 +00:00
|
|
|
flags);
|
2001-01-13 08:57:46 +00:00
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
2003-02-24 01:22:30 +00:00
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvreg_attrlistlen, tvb, offset, 2, length);
|
2001-01-13 08:57:46 +00:00
|
|
|
offset += 2;
|
2003-02-24 01:22:30 +00:00
|
|
|
add_v1_string(srvloc_tree, hf_srvloc_srvreg_attrlist, tvb, offset, length, encoding);
|
2001-01-13 08:57:46 +00:00
|
|
|
offset += length;
|
2002-08-28 21:04:11 +00:00
|
|
|
if ( (flags & FLAG_A) == FLAG_A )
|
2001-01-13 08:57:46 +00:00
|
|
|
offset = dissect_authblk(tvb, offset, srvloc_tree);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SRVDEREG:
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
2003-02-24 02:04:18 +00:00
|
|
|
proto_tree_add_uint(tree, hf_srvloc_url_urllen, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
add_v1_string(tree, hf_srvloc_url_url, tvb, offset, length, encoding);
|
2001-01-13 08:57:46 +00:00
|
|
|
offset += length;
|
2003-02-24 02:04:18 +00:00
|
|
|
if ( (flags & FLAG_U) == FLAG_U )
|
2001-01-13 08:57:46 +00:00
|
|
|
offset = dissect_authblk(tvb, offset, srvloc_tree);
|
2003-02-24 02:04:18 +00:00
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvdereg_taglistlen, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
add_v1_string(srvloc_tree, hf_srvloc_srvdereg_taglist, tvb, offset, length, encoding);
|
|
|
|
offset += length;
|
2003-02-24 19:23:26 +00:00
|
|
|
/*
|
|
|
|
* XXX - this was there before, but RFC 2165 doesn't speak
|
|
|
|
* of there being an attribute authentication block in
|
|
|
|
* a Service Deregister message. Is that a post-RFC-2165
|
|
|
|
* addition?
|
|
|
|
*/
|
|
|
|
if ( (flags & FLAG_A) == FLAG_A )
|
|
|
|
offset = dissect_authblk(tvb, offset, srvloc_tree);
|
2001-01-13 08:57:46 +00:00
|
|
|
break;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2001-01-13 08:57:46 +00:00
|
|
|
case SRVACK:
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_error, tvb, offset, 2, FALSE);
|
|
|
|
offset += 2;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ATTRRQST:
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
2003-02-24 01:22:30 +00:00
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_attrreq_prlistlen, tvb, offset, 2, length);
|
2001-01-13 08:57:46 +00:00
|
|
|
offset += 2;
|
2003-02-24 01:22:30 +00:00
|
|
|
add_v1_string(srvloc_tree, hf_srvloc_attrreq_prlist, tvb, offset, length, encoding);
|
2001-01-13 08:57:46 +00:00
|
|
|
offset += length;
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
2003-02-24 01:22:30 +00:00
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_attrreq_urllen, tvb, offset, 2, length);
|
2001-01-13 08:57:46 +00:00
|
|
|
offset += 2;
|
2003-02-24 01:22:30 +00:00
|
|
|
add_v1_string(srvloc_tree, hf_srvloc_attrreq_url, tvb, offset, length, encoding);
|
2001-01-13 08:57:46 +00:00
|
|
|
offset += length;
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
2003-02-24 01:22:30 +00:00
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_attrreq_scopelistlen, tvb, offset, 2, length);
|
2001-01-13 08:57:46 +00:00
|
|
|
offset += 2;
|
2003-02-24 01:22:30 +00:00
|
|
|
add_v1_string(srvloc_tree, hf_srvloc_attrreq_scopelist, tvb, offset, length, encoding);
|
2001-01-13 08:57:46 +00:00
|
|
|
offset += length;
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
2003-02-24 01:22:30 +00:00
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_attrreq_attrlistlen, tvb, offset, 2, length);
|
2001-01-13 08:57:46 +00:00
|
|
|
offset += 2;
|
2003-02-24 01:22:30 +00:00
|
|
|
add_v1_string(srvloc_tree, hf_srvloc_attrreq_attrlist, tvb, offset, length, encoding);
|
2001-01-13 08:57:46 +00:00
|
|
|
offset += length;
|
|
|
|
break;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2001-01-13 08:57:46 +00:00
|
|
|
case ATTRRPLY:
|
2002-10-02 08:57:32 +00:00
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_error_v2, tvb, offset, 2, FALSE);
|
2001-01-13 08:57:46 +00:00
|
|
|
offset += 2;
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
2003-02-24 01:22:30 +00:00
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_attrrply_attrlistlen, tvb, offset, 2, length);
|
2003-12-08 20:50:02 +00:00
|
|
|
if (length > 0) {
|
|
|
|
offset += 2;
|
|
|
|
attr_list(srvloc_tree, hf_srvloc_attrrply_attrlist, tvb, offset, length, encoding);
|
|
|
|
offset += length;
|
|
|
|
if ( (flags & FLAG_A) == FLAG_A )
|
|
|
|
offset = dissect_authblk(tvb, offset, srvloc_tree);
|
|
|
|
}
|
2001-01-13 08:57:46 +00:00
|
|
|
break;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2001-01-13 08:57:46 +00:00
|
|
|
case DAADVERT:
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_error, tvb, offset, 2, FALSE);
|
|
|
|
offset += 2;
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
2003-02-24 01:22:30 +00:00
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_daadvert_urllen, tvb, offset, 2, length);
|
2001-01-13 08:57:46 +00:00
|
|
|
offset += 2;
|
2003-02-24 01:22:30 +00:00
|
|
|
add_v1_string(srvloc_tree, hf_srvloc_daadvert_url, tvb, offset, length, encoding);
|
2001-01-13 08:57:46 +00:00
|
|
|
offset += length;
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
2003-02-24 01:22:30 +00:00
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_daadvert_scopelistlen, tvb, offset, 2, length);
|
2001-01-13 08:57:46 +00:00
|
|
|
offset += 2;
|
2003-02-24 01:22:30 +00:00
|
|
|
add_v1_string(srvloc_tree, hf_srvloc_daadvert_scopelist, tvb, offset, length, encoding);
|
2001-01-13 08:57:46 +00:00
|
|
|
offset += length;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SRVTYPERQST:
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
2003-02-24 01:22:30 +00:00
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvtypereq_prlistlen, tvb, offset, 2, length);
|
2001-01-13 08:57:46 +00:00
|
|
|
offset += 2;
|
2003-02-24 01:22:30 +00:00
|
|
|
add_v1_string(srvloc_tree, hf_srvloc_srvtypereq_prlist, tvb, offset, length, encoding);
|
2001-01-13 08:57:46 +00:00
|
|
|
offset += length;
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
2004-02-01 20:46:47 +00:00
|
|
|
/* Updated by Greg Morris on 1-30-04 */
|
|
|
|
if (0xFFFF == length) {
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvtypereq_nameauthlistlenall, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvtypereq_nameauthlistlen, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
add_v1_string(srvloc_tree, hf_srvloc_srvtypereq_nameauthlist, tvb, offset, length, encoding);
|
|
|
|
offset += length;
|
|
|
|
}
|
2001-01-13 08:57:46 +00:00
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
2003-02-24 01:22:30 +00:00
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvtypereq_scopelistlen, tvb, offset, 2, length);
|
2001-01-13 08:57:46 +00:00
|
|
|
offset += 2;
|
2003-02-24 01:22:30 +00:00
|
|
|
add_v1_string(srvloc_tree, hf_srvloc_srvtypereq_scopelist, tvb, offset, length, encoding);
|
2001-01-13 08:57:46 +00:00
|
|
|
offset += length;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SRVTYPERPLY:
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_error, tvb, offset, 2, FALSE);
|
|
|
|
offset += 2;
|
|
|
|
count = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_text(srvloc_tree, tvb, offset, 2, "Service Type Count: %u",
|
|
|
|
count);
|
|
|
|
offset += 2;
|
|
|
|
while (count > 0) {
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
2003-02-24 01:22:30 +00:00
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvtyperply_srvtypelen, tvb, offset, 2, length);
|
1999-12-07 06:13:19 +00:00
|
|
|
offset += 2;
|
2003-02-24 01:22:30 +00:00
|
|
|
add_v1_string(srvloc_tree, hf_srvloc_srvtyperply_srvtype, tvb, offset, length, encoding);
|
1999-12-07 06:13:19 +00:00
|
|
|
offset += length;
|
2001-01-13 08:57:46 +00:00
|
|
|
count--;
|
|
|
|
};
|
|
|
|
break;
|
1999-12-07 06:13:19 +00:00
|
|
|
|
2001-01-13 08:57:46 +00:00
|
|
|
default:
|
2002-01-24 09:20:54 +00:00
|
|
|
proto_tree_add_text(srvloc_tree, tvb, offset, -1, "Unknown Function Type");
|
2002-10-02 08:57:32 +00:00
|
|
|
};
|
|
|
|
}
|
|
|
|
else { /* Version 2 */
|
|
|
|
length = tvb_get_ntoh24(tvb, offset + 2);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_pktlen, tvb, offset + 2, 3,
|
|
|
|
length);
|
|
|
|
flags = tvb_get_ntohs(tvb, offset + 5);
|
|
|
|
tf = proto_tree_add_uint(srvloc_tree, hf_srvloc_flags_v2, tvb, offset + 5, 2,
|
|
|
|
flags);
|
|
|
|
srvloc_flags = proto_item_add_subtree(tf, ett_srvloc_flags);
|
|
|
|
proto_tree_add_boolean(srvloc_flags, hf_srvloc_flags_v2_overflow,
|
|
|
|
tvb, offset+5, 1, flags);
|
|
|
|
proto_tree_add_boolean(srvloc_flags, hf_srvloc_flags_v2_fresh,
|
|
|
|
tvb, offset+5, 1, flags);
|
|
|
|
proto_tree_add_boolean(srvloc_flags, hf_srvloc_flags_v2_reqmulti,
|
|
|
|
tvb, offset+5, 1, flags);
|
|
|
|
|
|
|
|
next_ext_off = tvb_get_ntoh24(tvb, offset + 7);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_nextextoff, tvb, offset + 7, 3,
|
|
|
|
next_ext_off);
|
2003-02-14 07:20:40 +00:00
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_xid, tvb, offset + 10, 2,
|
2002-10-02 08:57:32 +00:00
|
|
|
tvb_get_ntohs(tvb, offset + 10));
|
|
|
|
lang_tag_len = tvb_get_ntohs(tvb, offset + 12);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_langtaglen, tvb, offset + 12, 2, lang_tag_len);
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_langtag, tvb, offset + 14, lang_tag_len, TRUE);
|
|
|
|
offset += 14+lang_tag_len;
|
|
|
|
|
|
|
|
switch (function) {
|
|
|
|
case SRVREQ: /* RFC2608 8.1 */
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvreq_prlistlen, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_srvreq_prlist, tvb, offset, length, TRUE);
|
|
|
|
offset += length;
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvreq_srvtypelen, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_srvreq_srvtypelist, tvb, offset, length, TRUE);
|
|
|
|
offset += length;
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvreq_scopelistlen, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_srvreq_scopelist, tvb, offset, length, TRUE);
|
|
|
|
offset += length;
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvreq_predicatelen, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_srvreq_predicate, tvb, offset, length, TRUE);
|
|
|
|
offset += length;
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvreq_slpspilen, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_srvreq_slpspi, tvb, offset, length, TRUE);
|
|
|
|
offset += length;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SRVRPLY: /* RFC2608 8.2 */
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_error_v2, tvb, offset, 2, FALSE);
|
|
|
|
offset += 2;
|
|
|
|
count = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvrply_urlcount, tvb, offset, 2, count);
|
|
|
|
offset += 2;
|
|
|
|
while (count > 0) {
|
2003-02-24 01:22:30 +00:00
|
|
|
offset = dissect_url_entry_v2(tvb, offset, srvloc_tree);
|
2002-10-02 08:57:32 +00:00
|
|
|
count--;
|
|
|
|
};
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SRVREG: /* RFC2608 8.3 */
|
2003-02-24 01:22:30 +00:00
|
|
|
offset = dissect_url_entry_v2(tvb, offset, srvloc_tree);
|
2002-10-02 08:57:32 +00:00
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvreg_srvtypelen, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_srvreg_srvtype, tvb, offset, length, TRUE);
|
|
|
|
offset += length;
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvreg_scopelistlen, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_srvreg_scopelist, tvb, offset, length, TRUE);
|
|
|
|
offset += length;
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvreg_attrlistlen, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_srvreg_attrlist, tvb, offset, length, TRUE);
|
|
|
|
offset += length;
|
|
|
|
count = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvreg_attrauthcount, tvb, offset, 1, count);
|
|
|
|
offset += 1;
|
|
|
|
while (count > 0) {
|
|
|
|
offset = dissect_attrauthblk_v2(tvb, offset, srvloc_tree);
|
|
|
|
count--;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SRVDEREG: /* RFC2608 10.6 */
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvdereg_scopelistlen, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_srvdereg_scopelist, tvb, offset, length, TRUE);
|
|
|
|
offset += length;
|
2003-02-24 01:22:30 +00:00
|
|
|
offset = dissect_url_entry_v2(tvb, offset, srvloc_tree);
|
2002-10-02 08:57:32 +00:00
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvdereg_taglistlen, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_srvdereg_taglist, tvb, offset, length, TRUE);
|
|
|
|
offset += length;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SRVACK: /* RFC2608 8.4 */
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_error_v2, tvb, offset, 2, FALSE);
|
|
|
|
offset += 2;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ATTRRQST: /* RFC2608 10.3*/
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_attrreq_prlistlen, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_attrreq_prlist, tvb, offset, length, TRUE);
|
|
|
|
offset += length;
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_attrreq_urllen, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_attrreq_url, tvb, offset, length, TRUE);
|
|
|
|
offset += length;
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_attrreq_scopelistlen, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_attrreq_scopelist, tvb, offset, length, TRUE);
|
|
|
|
offset += length;
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_attrreq_taglistlen, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_attrreq_taglist, tvb, offset, length, TRUE);
|
|
|
|
offset += length;
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_attrreq_slpspilen, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_attrreq_slpspi, tvb, offset, length, TRUE);
|
|
|
|
offset += length;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ATTRRPLY: /* RFC2608 10.4 */
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_error_v2, tvb, offset, 2, FALSE);
|
|
|
|
offset += 2;
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_attrrply_attrlistlen, tvb, offset, 2, length);
|
2003-12-08 20:50:02 +00:00
|
|
|
if (length > 0) {
|
|
|
|
offset += 2;
|
|
|
|
attr_list(srvloc_tree, hf_srvloc_attrrply_attrlist, tvb, offset, length, CHARSET_UTF_8);
|
|
|
|
offset += length;
|
|
|
|
count = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_attrrply_attrauthcount, tvb, offset, 1, count);
|
|
|
|
offset += 1;
|
|
|
|
while (count > 0) {
|
|
|
|
offset = dissect_attrauthblk_v2(tvb, offset, srvloc_tree);
|
|
|
|
count--;
|
|
|
|
}
|
|
|
|
}
|
2002-10-02 08:57:32 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case DAADVERT: /* RCC 2608 8.5 */
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_error_v2, tvb, offset, 2, FALSE);
|
|
|
|
offset += 2;
|
|
|
|
ts.nsecs = 0;
|
|
|
|
ts.secs = tvb_get_ntohl(tvb, offset);
|
|
|
|
proto_tree_add_time(srvloc_tree, hf_srvloc_daadvert_timestamp, tvb, offset, 4,
|
|
|
|
&ts);
|
|
|
|
offset += 4;
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_daadvert_urllen, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_daadvert_url, tvb, offset, length, TRUE);
|
|
|
|
offset += length;
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_daadvert_scopelistlen, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_daadvert_scopelist, tvb, offset, length, TRUE);
|
|
|
|
offset += length;
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_daadvert_attrlistlen, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_daadvert_attrlist, tvb, offset, length, TRUE);
|
|
|
|
offset += length;
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_daadvert_slpspilen, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_daadvert_slpspi, tvb, offset, length, TRUE);
|
|
|
|
offset += length;
|
|
|
|
count = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_daadvert_authcount, tvb, offset, 1, count);
|
|
|
|
offset += 1;
|
|
|
|
while (count > 0) {
|
|
|
|
offset = dissect_authblk_v2(tvb, offset, srvloc_tree);
|
|
|
|
count--;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SRVTYPERQST: /* RFC2608 10.1 */
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvtypereq_prlistlen, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_srvtypereq_prlist, tvb, offset, length, TRUE);
|
|
|
|
offset += length;
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
2003-01-23 10:25:32 +00:00
|
|
|
if (0xFFFF == length) {
|
2003-02-24 01:22:30 +00:00
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvtypereq_nameauthlistlenall, tvb, offset, 2, length);
|
2003-01-23 10:25:32 +00:00
|
|
|
offset += 2;
|
|
|
|
} else {
|
2003-02-24 01:22:30 +00:00
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvtypereq_nameauthlistlen, tvb, offset, 2, length);
|
2003-01-23 10:25:32 +00:00
|
|
|
offset += 2;
|
2003-02-24 01:22:30 +00:00
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_srvtypereq_nameauthlist, tvb, offset, length, TRUE);
|
2003-01-23 10:25:32 +00:00
|
|
|
offset += length;
|
|
|
|
}
|
2002-10-02 08:57:32 +00:00
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvtypereq_scopelistlen, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_srvtypereq_scopelist, tvb, offset, length, TRUE);
|
|
|
|
offset += length;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SRVTYPERPLY: /* rfc2608 10.2 */
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_error_v2, tvb, offset, 2, FALSE);
|
|
|
|
offset += 2;
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
2003-02-24 01:22:30 +00:00
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_srvtyperply_srvtypelistlen, tvb, offset, 2, length);
|
2002-10-02 08:57:32 +00:00
|
|
|
offset += 2;
|
2003-02-24 01:22:30 +00:00
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_srvtyperply_srvtypelist, tvb, offset, length, TRUE);
|
2002-10-02 08:57:32 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SAADVERT: /* rfc2608 10.2 */
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_saadvert_urllen, tvb, offset, 2,
|
|
|
|
length);
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_saadvert_url, tvb, offset, length, TRUE);
|
|
|
|
offset += length;
|
2003-06-25 23:27:56 +00:00
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
2002-10-02 08:57:32 +00:00
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_saadvert_scopelistlen, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_saadvert_scopelist, tvb, offset, length, TRUE);
|
|
|
|
offset += length;
|
|
|
|
length = tvb_get_ntohs(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_saadvert_attrlistlen, tvb, offset, 2, length);
|
|
|
|
offset += 2;
|
|
|
|
proto_tree_add_item(srvloc_tree, hf_srvloc_saadvert_attrlist, tvb, offset, length, TRUE);
|
|
|
|
offset += length;
|
|
|
|
count = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_uint(srvloc_tree, hf_srvloc_saadvert_authcount, tvb, offset, 1, length);
|
|
|
|
offset += 1;
|
|
|
|
while (count > 0) {
|
|
|
|
offset = dissect_authblk_v2(tvb, offset, srvloc_tree);
|
|
|
|
count--;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
proto_tree_add_text(srvloc_tree, tvb, offset, -1, "Unknown Function Type");
|
|
|
|
};
|
|
|
|
};
|
|
|
|
}
|
2001-03-09 04:35:25 +00:00
|
|
|
}
|
1999-12-07 06:13:19 +00:00
|
|
|
|
2003-08-18 18:06:06 +00:00
|
|
|
static guint
|
|
|
|
get_srvloc_pdu_len(tvbuff_t *tvb, int offset)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Get the length of the SRVLOC packet.
|
2003-10-01 21:15:45 +00:00
|
|
|
* It starts at offset+2, but it's 2 bytes in SLPv1 and 3 bytes
|
|
|
|
* in SLPv2.
|
2003-08-18 18:06:06 +00:00
|
|
|
*/
|
2003-10-01 21:15:45 +00:00
|
|
|
if (tvb_get_guint8(tvb, offset) == 2)
|
|
|
|
return tvb_get_ntoh24(tvb, offset + 2);
|
|
|
|
else
|
|
|
|
return tvb_get_ntohs(tvb, offset + 2);
|
2003-08-18 18:06:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
dissect_srvloc_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
|
|
|
|
{
|
|
|
|
proto_tree *srvloc_tree = NULL;
|
|
|
|
proto_item *ti;
|
|
|
|
|
|
|
|
if (check_col(pinfo->cinfo, COL_PROTOCOL))
|
|
|
|
col_set_str(pinfo->cinfo, COL_PROTOCOL, "SRVLOC");
|
|
|
|
|
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
|
|
col_clear(pinfo->cinfo, COL_INFO);
|
|
|
|
|
|
|
|
if (tree) {
|
|
|
|
ti = proto_tree_add_item(tree, proto_srvloc, tvb, 0, -1, FALSE);
|
|
|
|
srvloc_tree = proto_item_add_subtree(ti, ett_srvloc);
|
|
|
|
}
|
|
|
|
dissect_srvloc(tvb, pinfo, srvloc_tree);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
dissect_srvloc_tcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
|
|
|
|
{
|
2003-10-01 21:15:45 +00:00
|
|
|
/*
|
|
|
|
* XXX - in SLPv1, the fixed length need only be 4, as the length
|
|
|
|
* is 2 bytes long; however, it must be 5 for SLPv2, as the length
|
|
|
|
* is 3 bytes long, and there's probably no harm in asking for 5
|
|
|
|
* bytes, as even SLPv1 packets start with a 12-byte header,
|
|
|
|
* and if the packet has a length that's 4 or less, it's bogus,
|
|
|
|
* and we can't handle a length < 4 anyway.
|
|
|
|
*/
|
|
|
|
tcp_dissect_pdus(tvb, pinfo, tree, srvloc_desegment, 5, get_srvloc_pdu_len,
|
2003-08-18 18:06:06 +00:00
|
|
|
dissect_srvloc_pdu);
|
|
|
|
}
|
|
|
|
|
1999-12-07 06:13:19 +00:00
|
|
|
/* Register protocol with Ethereal. */
|
|
|
|
|
|
|
|
void
|
|
|
|
proto_register_srvloc(void)
|
|
|
|
{
|
|
|
|
static hf_register_info hf[] = {
|
2002-10-02 08:57:32 +00:00
|
|
|
/* Helper functions for the Version 1 Header*/
|
|
|
|
{&hf_srvloc_error,
|
|
|
|
{"Error Code", "srvloc.err",
|
|
|
|
FT_UINT16, BASE_DEC, VALS(srvloc_errs), 0x0,
|
2001-06-18 02:18:27 +00:00
|
|
|
"", HFILL }
|
1999-12-07 06:13:19 +00:00
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2002-10-02 08:57:32 +00:00
|
|
|
/* Helper function for the Version 2 Header */
|
|
|
|
{&hf_srvloc_error_v2,
|
|
|
|
{"Error Code", "srvloc.errv2",
|
|
|
|
FT_UINT16, BASE_DEC, VALS(srvloc_errs_v2), 0x0,
|
|
|
|
"", HFILL }
|
|
|
|
},
|
|
|
|
{&hf_srvloc_xid,
|
|
|
|
{"XID", "srvloc.xid",
|
|
|
|
FT_UINT24, BASE_DEC, NULL, 0x0,
|
|
|
|
"Transaction ID", HFILL }
|
|
|
|
},
|
|
|
|
{&hf_srvloc_langtag,
|
|
|
|
{"Lang Tag", "srvloc.langtag",
|
2003-02-24 02:04:18 +00:00
|
|
|
FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"", HFILL }
|
|
|
|
},
|
|
|
|
{&hf_srvloc_langtaglen,
|
|
|
|
{"Lang Tag Len", "srvloc.langtaglen",
|
|
|
|
FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"", HFILL }
|
|
|
|
},
|
|
|
|
{&hf_srvloc_nextextoff,
|
|
|
|
{"Next Extension Offset", "srvloc.nextextoff",
|
|
|
|
FT_UINT24, BASE_DEC, NULL, 0x0,
|
|
|
|
"", HFILL }
|
|
|
|
},
|
2003-02-24 01:22:30 +00:00
|
|
|
|
|
|
|
/* Helper functions for URL and URL Entry parsing - both versions */
|
2002-10-02 08:57:32 +00:00
|
|
|
{&hf_srvloc_url_reserved,
|
|
|
|
{"Reserved", "srvloc.url.reserved",
|
|
|
|
FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }
|
|
|
|
},
|
|
|
|
{&hf_srvloc_url_lifetime,
|
2003-02-24 01:22:30 +00:00
|
|
|
{"URL lifetime", "srvloc.url.lifetime",
|
2002-10-02 08:57:32 +00:00
|
|
|
FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }
|
|
|
|
},
|
|
|
|
{&hf_srvloc_url_urllen,
|
|
|
|
{"URL Length", "srvloc.url.urllen",
|
|
|
|
FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }
|
|
|
|
},
|
|
|
|
{&hf_srvloc_url_url,
|
|
|
|
{"URL", "srvloc.url.url",
|
2003-02-24 02:04:18 +00:00
|
|
|
FT_STRING, BASE_NONE, NULL, 0x0, "", HFILL }
|
2002-10-02 08:57:32 +00:00
|
|
|
},
|
|
|
|
{&hf_srvloc_url_numauths,
|
|
|
|
{"Num Auths", "srvloc.url.numauths",
|
|
|
|
FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }
|
|
|
|
},
|
|
|
|
|
|
|
|
/* Helper functions for the common header fields */
|
1999-12-07 06:13:19 +00:00
|
|
|
{&hf_srvloc_function,
|
2002-08-28 21:04:11 +00:00
|
|
|
{"Function", "srvloc.function",
|
|
|
|
FT_UINT8, BASE_DEC, VALS(srvloc_functions), 0x0,
|
2001-06-18 02:18:27 +00:00
|
|
|
"", HFILL }
|
1999-12-07 06:13:19 +00:00
|
|
|
},
|
|
|
|
|
2002-10-02 08:57:32 +00:00
|
|
|
{&hf_srvloc_pktlen,
|
|
|
|
{"Packet Length", "srvloc.pktlen",
|
|
|
|
FT_UINT24, BASE_DEC, NULL, 0x0,
|
|
|
|
"", HFILL }
|
|
|
|
},
|
|
|
|
|
|
|
|
{ &hf_srvloc_version,
|
|
|
|
{ "Version", "srvloc.version",
|
|
|
|
FT_UINT8, BASE_DEC, NULL, 0x0,
|
|
|
|
"", HFILL }
|
|
|
|
},
|
|
|
|
|
2003-03-01 09:03:42 +00:00
|
|
|
{&hf_srvloc_flags_v1,
|
|
|
|
{"Flags", "srvloc.flags_v1",
|
2002-08-28 21:04:11 +00:00
|
|
|
FT_UINT8, BASE_HEX, NULL, 0x0,
|
2001-06-18 02:18:27 +00:00
|
|
|
"", HFILL }
|
1999-12-07 06:13:19 +00:00
|
|
|
},
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2003-03-01 09:03:42 +00:00
|
|
|
{ &hf_srvloc_flags_v1_overflow,
|
|
|
|
{ "Overflow", "srvloc.flags_v1.overflow.", FT_BOOLEAN, 8,
|
|
|
|
TFS(&tfs_srvloc_flags_overflow), FLAG_O, "Can whole packet fit into a datagram?", HFILL }},
|
|
|
|
|
|
|
|
{ &hf_srvloc_flags_v1_monolingual,
|
|
|
|
{ "Monolingual", "srvloc.flags_v1.monolingual", FT_BOOLEAN, 8,
|
|
|
|
TFS(&tfs_srvloc_flags_v1_monolingual), FLAG_M, "Can whole packet fit into a datagram?", HFILL }},
|
|
|
|
|
|
|
|
{ &hf_srvloc_flags_v1_url_auth,
|
|
|
|
{ "URL Authentication", "srvloc.flags_v1.url_auth", FT_BOOLEAN, 8,
|
|
|
|
TFS(&tfs_srvloc_flags_v1_url_auth), FLAG_U, "Can whole packet fit into a datagram?", HFILL }},
|
|
|
|
|
|
|
|
{ &hf_srvloc_flags_v1_attribute_auth,
|
|
|
|
{ "Attribute Authentication", "srvloc.flags_v1.attribute_auth", FT_BOOLEAN, 8,
|
|
|
|
TFS(&tfs_srvloc_flags_v1_attribute_auth), FLAG_A, "Can whole packet fit into a datagram?", HFILL }},
|
|
|
|
|
|
|
|
{ &hf_srvloc_flags_v1_fresh,
|
|
|
|
{ "Fresh Registration", "srvloc.flags_v1.fresh", FT_BOOLEAN, 8,
|
|
|
|
TFS(&tfs_srvloc_flags_fresh), FLAG_F, "Is this a new registration?", HFILL }},
|
|
|
|
|
2002-10-02 08:57:32 +00:00
|
|
|
{&hf_srvloc_flags_v2,
|
|
|
|
{"Flags", "srvloc.flags_v2",
|
|
|
|
FT_UINT16, BASE_HEX, NULL, 0x0,
|
|
|
|
"", HFILL }
|
|
|
|
},
|
|
|
|
|
|
|
|
{ &hf_srvloc_flags_v2_overflow,
|
2003-03-01 09:03:42 +00:00
|
|
|
{ "Overflow", "srvloc.flags_v2.overflow", FT_BOOLEAN, 16,
|
|
|
|
TFS(&tfs_srvloc_flags_overflow), FLAG_O_V2, "Can whole packet fit into a datagram?", HFILL }},
|
2002-10-02 08:57:32 +00:00
|
|
|
|
|
|
|
{ &hf_srvloc_flags_v2_fresh,
|
2003-03-01 09:03:42 +00:00
|
|
|
{ "Fresh Registration", "srvloc.flags_v2.fresh", FT_BOOLEAN, 16,
|
|
|
|
TFS(&tfs_srvloc_flags_fresh), FLAG_F_V2, "Is this a new registration?", HFILL }},
|
2002-10-02 08:57:32 +00:00
|
|
|
|
|
|
|
{ &hf_srvloc_flags_v2_reqmulti,
|
2003-03-01 09:03:42 +00:00
|
|
|
{ "Multicast requested", "srvloc.flags_v2.reqmulti", FT_BOOLEAN, 16,
|
|
|
|
TFS(&tfs_srvloc_flags_v2_reqmulti), FLAG_R_V2, "Do we want multicast?", HFILL }},
|
2002-10-02 08:57:32 +00:00
|
|
|
|
|
|
|
/* collection of helper functions for dissect_authblk_v2 */
|
|
|
|
{ &hf_srvloc_authblkv2_bsd,
|
|
|
|
{ "BSD", "srvloc.authblkv2_bsd", FT_UINT16, BASE_HEX, NULL, 0x0,
|
|
|
|
"Block Structure Descriptor", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_authblkv2_len,
|
|
|
|
{ "Length", "srvloc.authblkv2_len", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"Length of Authentication Block", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_authblkv2_timestamp,
|
|
|
|
{ "Timestamp", "srvloc.authblkv2.timestamp", FT_ABSOLUTE_TIME, BASE_NONE,
|
|
|
|
NULL, 0, "Timestamp on Authentication Block", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_authblkv2_slpspilen,
|
|
|
|
{ "SLP SPI Length", "srvloc.authblkv2.slpspilen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"Length of the SLP SPI", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_authblkv2_slpspi,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "SLP SPI", "srvloc.authblkv2.slpspi", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
|
|
|
|
/* collection of helper functions for Service Request */
|
|
|
|
{ &hf_srvloc_srvreq_prlistlen,
|
2003-02-24 01:22:30 +00:00
|
|
|
{ "Previous Response List Length", "srvloc.srvreq.prlistlen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"Length of Previous Response List", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_srvreq_prlist,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "Previous Response List", "srvloc.srvreq.prlist", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"Previous Response List", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_srvreq_srvtypelen,
|
|
|
|
{ "Service Type Length", "srvloc.srvreq.srvtypelen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"Length of Service Type List", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_srvreq_srvtypelist,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "Service Type List", "srvloc.srvreq.srvtypelist", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_srvreq_scopelistlen,
|
|
|
|
{ "Scope List Length", "srvloc.srvreq.scopelistlen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"Length of the Scope List", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_srvreq_scopelist,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "Scope List", "srvloc.srvreq.scopelist", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_srvreq_predicatelen,
|
|
|
|
{ "Predicate Length", "srvloc.srvreq.predicatelen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"Length of the Predicate", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_srvreq_predicate,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "Predicate", "srvloc.srvreq.predicate", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_srvreq_slpspilen,
|
|
|
|
{ "SLP SPI Length", "srvloc.srvreq.slpspilen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"Length of the SLP SPI", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_srvreq_slpspi,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "SLP SPI", "srvloc.srvreq.slpspi", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
|
|
|
|
/* Helper function for Service Request */
|
|
|
|
{ &hf_srvloc_srvrply_urlcount,
|
|
|
|
{ "Number of URLs", "srvloc.srvreq.urlcount", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
|
|
|
|
/* Helper functions for Service Registration */
|
|
|
|
{ &hf_srvloc_srvreg_srvtypelen,
|
|
|
|
{ "Service Type Length", "srvloc.srvreq.srvtypelen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_srvreg_srvtype,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "Service Type", "srvloc.srvreq.srvtype", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_srvreg_scopelistlen,
|
|
|
|
{ "Scope List Length", "srvloc.srvreq.scopelistlen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_srvreg_scopelist,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "Scope List", "srvloc.srvreq.scopelist", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_srvreg_attrlistlen,
|
|
|
|
{ "Attribute List Length", "srvloc.srvreq.attrlistlen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_srvreg_attrlist,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "Attribute List", "srvloc.srvreq.attrlist", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_srvreg_attrauthcount,
|
|
|
|
{ "Attr Auths", "srvloc.srvreq.attrauthcount", FT_UINT8, BASE_DEC, NULL, 0x0,
|
|
|
|
"Number of Attribute Authentication Blocks", HFILL}
|
|
|
|
},
|
|
|
|
|
|
|
|
/* Helper functions for Service Deregistration */
|
|
|
|
{ &hf_srvloc_srvdereg_scopelistlen,
|
|
|
|
{ "Scope List Length", "srvloc.srvdereq.scopelistlen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_srvdereg_scopelist,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "Scope List", "srvloc.srvdereq.scopelist", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_srvdereg_taglistlen,
|
|
|
|
{ "Tag List Length", "srvloc.srvdereq.taglistlen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_srvdereg_taglist,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "Tag List", "srvloc.srvdereq.taglist", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
|
|
/* collection of helper functions for Attribute Request */
|
|
|
|
{ &hf_srvloc_attrreq_prlistlen,
|
2003-02-24 01:22:30 +00:00
|
|
|
{ "Previous Response List Length", "srvloc.attrreq.prlistlen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"Length of Previous Response List", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_attrreq_prlist,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "Previous Response List", "srvloc.attrreq.prlist", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"Previous Response List", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_attrreq_urllen,
|
|
|
|
{ "URL Length", "srvloc.attrreq.urllen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_attrreq_url,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "Service URL", "srvloc.attrreq.url", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"URL of service", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_attrreq_scopelistlen,
|
|
|
|
{ "Scope List Length", "srvloc.attrreq.scopelistlen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"Length of the Scope List", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_attrreq_scopelist,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "Scope List", "srvloc.attrreq.scopelist", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"", HFILL}
|
|
|
|
},
|
2003-02-24 01:22:30 +00:00
|
|
|
{ &hf_srvloc_attrreq_attrlistlen,
|
|
|
|
{ "Attribute List Length", "srvloc.attrreq.attrlistlen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_attrreq_attrlist,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "Attribute List", "srvloc.attrreq.attrlist", FT_STRING, BASE_NONE, NULL, 0x0,
|
2003-02-24 01:22:30 +00:00
|
|
|
"", HFILL}
|
|
|
|
},
|
2002-10-02 08:57:32 +00:00
|
|
|
{ &hf_srvloc_attrreq_taglistlen,
|
|
|
|
{ "Tag List Length", "srvloc.attrreq.taglistlen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_attrreq_taglist,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "Tag List", "srvloc.attrreq.taglist", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_attrreq_slpspilen,
|
2003-02-14 07:20:40 +00:00
|
|
|
{ "SLP SPI Length", "srvloc.attrreq.slpspilen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"Length of the SLP SPI", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_attrreq_slpspi,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "SLP SPI", "srvloc.attrreq.slpspi", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
|
|
|
|
/* collection of helper functions for Attribute Reply */
|
|
|
|
{ &hf_srvloc_attrrply_attrlistlen,
|
|
|
|
{ "Attribute List Length", "srvloc.attrrply.attrlistlen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"Length of Attribute List", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_attrrply_attrlist,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "Attribute List", "srvloc.attrrply.attrlist", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_attrrply_attrauthcount,
|
|
|
|
{ "Attr Auths", "srvloc.srvreq.attrauthcount", FT_UINT8, BASE_DEC, NULL, 0x0,
|
|
|
|
"Number of Attribute Authentication Blocks", HFILL}
|
|
|
|
},
|
|
|
|
|
|
|
|
/* collection of helper functions for DA Advertisement */
|
|
|
|
{ &hf_srvloc_daadvert_timestamp,
|
|
|
|
{ "DAADVERT Timestamp", "srvloc.daadvert.timestamp", FT_ABSOLUTE_TIME, BASE_NONE,
|
|
|
|
NULL, 0, "Timestamp on DA Advert", HFILL }
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_daadvert_urllen,
|
|
|
|
{ "URL Length", "srvloc.daadvert.urllen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_daadvert_url,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "URL", "srvloc.daadvert.url", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_daadvert_scopelistlen,
|
|
|
|
{ "Scope List Length", "srvloc.daadvert.scopelistlen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"Length of the Scope List", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_daadvert_scopelist,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "Scope List", "srvloc.daadvert.scopelist", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_daadvert_attrlistlen,
|
|
|
|
{ "Attribute List Length", "srvloc.daadvert.attrlistlen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_daadvert_attrlist,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "Attribute List", "srvloc.daadvert.attrlist", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_daadvert_slpspilen,
|
2003-02-14 07:20:40 +00:00
|
|
|
{ "SLP SPI Length", "srvloc.daadvert.slpspilen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"Length of the SLP SPI", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_daadvert_slpspi,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "SLP SPI", "srvloc.daadvert.slpspi", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_daadvert_authcount,
|
|
|
|
{ "Auths", "srvloc.daadvert.authcount", FT_UINT8, BASE_DEC, NULL, 0x0,
|
|
|
|
"Number of Authentication Blocks", HFILL}
|
|
|
|
},
|
|
|
|
|
|
|
|
/* collection of helper functions for Service Type Request */
|
|
|
|
{ &hf_srvloc_srvtypereq_prlistlen,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "Previous Response List Length", "srvloc.srvtypereq.prlistlen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"Length of Previous Response List", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_srvtypereq_prlist,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "Previous Response List", "srvloc.srvtypereq.prlist", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"Previous Response List", HFILL}
|
|
|
|
},
|
2003-02-24 01:22:30 +00:00
|
|
|
{ &hf_srvloc_srvtypereq_nameauthlistlen,
|
2002-10-02 08:57:32 +00:00
|
|
|
{ "Naming Authority List Length", "srvloc.srvtypereq.nameauthlistlen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"Length of the Naming Authority List", HFILL}
|
|
|
|
},
|
2003-02-24 01:22:30 +00:00
|
|
|
{ &hf_srvloc_srvtypereq_nameauthlistlenall,
|
2003-01-23 10:25:32 +00:00
|
|
|
{ "Naming Authority List Length (All Naming Authorities)", "srvloc.srvtypereq.nameauthlistlen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"Length of the Naming Authority List", HFILL}
|
|
|
|
},
|
2003-02-24 01:22:30 +00:00
|
|
|
{ &hf_srvloc_srvtypereq_nameauthlist,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "Naming Authority List", "srvloc.srvtypereq.nameauthlist", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_srvtypereq_scopelistlen,
|
|
|
|
{ "Scope List Length", "srvloc.srvtypereq.scopelistlen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"Length of the Scope List", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_srvtypereq_scopelist,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "Scope List", "srvloc.srvtypereq.scopelist", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
|
|
|
|
/* collection of helper functions for Service Type Replies */
|
2003-02-24 01:22:30 +00:00
|
|
|
{ &hf_srvloc_srvtyperply_srvtypelen,
|
|
|
|
{ "Service Type Length", "srvloc.srvtypereq.srvtypelen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"Length of the Service Type", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_srvtyperply_srvtype,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "Service Type", "srvloc.srvtyperply.srvtype", FT_STRING, BASE_NONE, NULL, 0x0,
|
2003-02-24 01:22:30 +00:00
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_srvtyperply_srvtypelistlen,
|
|
|
|
{ "Service Type List Length", "srvloc.srvtypereq.srvtypelistlen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"Length of the Service Type List", HFILL}
|
2002-10-02 08:57:32 +00:00
|
|
|
},
|
2003-02-24 01:22:30 +00:00
|
|
|
{ &hf_srvloc_srvtyperply_srvtypelist,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "Service Type List", "srvloc.srvtyperply.srvtypelist", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
|
|
|
|
/* collection of helper functions for SA Advertisement */
|
|
|
|
{ &hf_srvloc_saadvert_urllen,
|
|
|
|
{ "URL Length", "srvloc.saadvert.urllen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_saadvert_url,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "URL", "srvloc.saadvert.url", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_saadvert_scopelistlen,
|
|
|
|
{ "Scope List Length", "srvloc.saadvert.scopelistlen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"Length of the Scope List", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_saadvert_scopelist,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "Scope List", "srvloc.saadvert.scopelist", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_saadvert_attrlistlen,
|
|
|
|
{ "Attribute List Length", "srvloc.saadvert.attrlistlen", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_saadvert_attrlist,
|
2003-02-24 02:04:18 +00:00
|
|
|
{ "Attribute List", "srvloc.saadvert.attrlist", FT_STRING, BASE_NONE, NULL, 0x0,
|
2002-10-02 08:57:32 +00:00
|
|
|
"", HFILL}
|
|
|
|
},
|
|
|
|
{ &hf_srvloc_saadvert_authcount,
|
|
|
|
{ "Auths", "srvloc.saadvert.authcount", FT_UINT8, BASE_DEC, NULL, 0x0,
|
|
|
|
"Number of Authentication Blocks", HFILL}
|
2003-12-08 20:50:02 +00:00
|
|
|
},
|
|
|
|
{ &hf_srvloc_add_ref_ip,
|
|
|
|
{ "IP Address", "srvloc.list.ipaddr", FT_IPv4, BASE_DEC, NULL, 0x0,
|
|
|
|
"IP Address of SLP server", HFILL}
|
2002-10-02 08:57:32 +00:00
|
|
|
}
|
2001-01-09 06:32:10 +00:00
|
|
|
};
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2001-01-09 06:32:10 +00:00
|
|
|
static gint *ett[] = {
|
|
|
|
&ett_srvloc,
|
|
|
|
&ett_srvloc_flags,
|
|
|
|
};
|
2003-08-18 18:06:06 +00:00
|
|
|
module_t *srvloc_module;
|
1999-12-07 06:13:19 +00:00
|
|
|
|
2001-01-03 06:56:03 +00:00
|
|
|
proto_srvloc = proto_register_protocol("Service Location Protocol",
|
|
|
|
"SRVLOC", "srvloc");
|
1999-12-07 06:13:19 +00:00
|
|
|
proto_register_field_array(proto_srvloc, hf, array_length(hf));
|
|
|
|
proto_register_subtree_array(ett, array_length(ett));
|
2003-08-18 18:06:06 +00:00
|
|
|
srvloc_module = prefs_register_protocol(proto_srvloc, NULL);
|
|
|
|
prefs_register_bool_preference(srvloc_module, "desegment_tcp",
|
2004-08-21 09:02:52 +00:00
|
|
|
"Reassemble SRVLOC messages spanning multiple TCP segments",
|
|
|
|
"Whether the SRVLOC 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.",
|
2003-08-18 18:06:06 +00:00
|
|
|
&srvloc_desegment);
|
2002-05-30 08:34:19 +00:00
|
|
|
}
|
2000-04-08 07:07:42 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
proto_reg_handoff_srvloc(void)
|
|
|
|
{
|
2003-08-18 18:06:06 +00:00
|
|
|
dissector_handle_t srvloc_handle, srvloc_tcp_handle;
|
2001-12-03 04:00:26 +00:00
|
|
|
srvloc_handle = create_dissector_handle(dissect_srvloc, proto_srvloc);
|
|
|
|
dissector_add("udp.port", UDP_PORT_SRVLOC, srvloc_handle);
|
2003-08-18 18:06:06 +00:00
|
|
|
srvloc_tcp_handle = create_dissector_handle(dissect_srvloc_tcp,
|
|
|
|
proto_srvloc);
|
|
|
|
dissector_add("tcp.port", TCP_PORT_SRVLOC, srvloc_tcp_handle);
|
2001-12-03 04:00:26 +00:00
|
|
|
}
|