1998-09-16 02:39:15 +00:00
|
|
|
/* packet.c
|
|
|
|
* Routines for packet disassembly
|
|
|
|
*
|
2006-05-21 05:12:17 +00:00
|
|
|
* Wireshark - Network traffic analyzer
|
|
|
|
* By Gerald Combs <gerald@wireshark.org>
|
1998-09-16 02:39:15 +00:00
|
|
|
* Copyright 1998 Gerald Combs
|
2002-08-28 20:41:00 +00:00
|
|
|
*
|
2018-02-07 11:26:45 +00:00
|
|
|
* SPDX-License-Identifier: GPL-2.0-or-later
|
1998-09-16 02:39:15 +00:00
|
|
|
*/
|
|
|
|
|
2012-09-20 01:48:30 +00:00
|
|
|
#include "config.h"
|
1998-09-16 02:39:15 +00:00
|
|
|
|
1999-03-23 03:14:46 +00:00
|
|
|
#include <glib.h>
|
1998-09-16 02:39:15 +00:00
|
|
|
|
|
|
|
#include <stdio.h>
|
2000-03-26 07:59:47 +00:00
|
|
|
#include <stdlib.h>
|
2000-08-11 13:37:21 +00:00
|
|
|
|
1998-09-16 02:39:15 +00:00
|
|
|
#include <stdarg.h>
|
1998-11-18 03:01:44 +00:00
|
|
|
#include <string.h>
|
1998-10-12 01:40:57 +00:00
|
|
|
#include <time.h>
|
1998-09-16 02:39:15 +00:00
|
|
|
|
1998-09-27 22:12:47 +00:00
|
|
|
#include "packet.h"
|
1999-12-29 07:25:48 +00:00
|
|
|
#include "timestamp.h"
|
1998-09-16 02:39:15 +00:00
|
|
|
|
2001-04-01 05:48:15 +00:00
|
|
|
#include "osi-utils.h"
|
2001-04-01 02:47:56 +00:00
|
|
|
#include "to_str.h"
|
1999-12-29 07:25:48 +00:00
|
|
|
|
2004-08-06 19:57:49 +00:00
|
|
|
#include "addr_resolv.h"
|
2000-05-11 08:18:09 +00:00
|
|
|
#include "tvbuff.h"
|
2001-12-18 19:09:08 +00:00
|
|
|
#include "epan_dissect.h"
|
2008-08-05 02:23:35 +00:00
|
|
|
|
2012-11-09 00:08:27 +00:00
|
|
|
#include "wmem/wmem.h"
|
2000-04-04 16:33:57 +00:00
|
|
|
|
2013-11-10 15:59:37 +00:00
|
|
|
#include <epan/exceptions.h>
|
2005-02-09 23:38:00 +00:00
|
|
|
#include <epan/reassemble.h>
|
2005-10-03 18:34:21 +00:00
|
|
|
#include <epan/stream.h>
|
2006-08-31 22:56:38 +00:00
|
|
|
#include <epan/expert.h>
|
2016-10-07 20:25:01 +00:00
|
|
|
#include <epan/prefs.h>
|
2013-12-20 23:25:36 +00:00
|
|
|
#include <epan/range.h>
|
2002-02-24 06:45:14 +00:00
|
|
|
|
2015-11-04 08:45:54 +00:00
|
|
|
#include <wsutil/str_util.h>
|
2018-09-18 17:09:31 +00:00
|
|
|
#include <wsutil/ws_printf.h> /* ws_debug_printf */
|
2015-11-04 08:45:54 +00:00
|
|
|
|
2001-04-01 23:11:43 +00:00
|
|
|
static gint proto_malformed = -1;
|
2001-04-01 22:01:34 +00:00
|
|
|
static dissector_handle_t frame_handle = NULL;
|
2014-01-08 04:35:28 +00:00
|
|
|
static dissector_handle_t file_handle = NULL;
|
2001-11-26 05:41:15 +00:00
|
|
|
static dissector_handle_t data_handle = NULL;
|
2001-04-01 22:01:34 +00:00
|
|
|
|
2012-10-20 19:54:56 +00:00
|
|
|
/**
|
|
|
|
* A data source.
|
|
|
|
* Has a tvbuff and a name.
|
|
|
|
*/
|
|
|
|
struct data_source {
|
2013-08-29 02:05:31 +00:00
|
|
|
tvbuff_t *tvb;
|
|
|
|
char *name;
|
2012-10-20 19:54:56 +00:00
|
|
|
};
|
|
|
|
|
2013-08-11 13:42:12 +00:00
|
|
|
/*
|
|
|
|
* A dissector table.
|
|
|
|
*
|
|
|
|
* "hash_table" is a hash table, indexed by port number, supplying
|
|
|
|
* a "struct dtbl_entry"; it records what dissector is assigned to
|
|
|
|
* that uint or string value in that table.
|
|
|
|
*
|
|
|
|
* "dissector_handles" is a list of all dissectors that *could* be
|
|
|
|
* used in that table; not all of them are necessarily in the table,
|
|
|
|
* as they may be for protocols that don't have a fixed uint value,
|
|
|
|
* e.g. for TCP or UDP port number tables and protocols with no fixed
|
|
|
|
* port number.
|
|
|
|
*
|
|
|
|
* "ui_name" is the name the dissector table has in the user interface.
|
|
|
|
*
|
|
|
|
* "type" is a field type giving the width of the uint value for that
|
|
|
|
* dissector table, if it's a uint dissector table.
|
|
|
|
*
|
2014-12-10 02:35:01 +00:00
|
|
|
* "param" is the base in which to display the uint value for that
|
|
|
|
* dissector table, if it's a uint dissector table, or if it's a string
|
|
|
|
* table, TRUE/FALSE to indicate case-insensitive or not.
|
2016-03-13 11:51:45 +00:00
|
|
|
*
|
|
|
|
* "protocol" is the protocol associated with the dissector table. Used
|
|
|
|
* for determining dependencies.
|
2013-08-11 13:42:12 +00:00
|
|
|
*/
|
|
|
|
struct dissector_table {
|
|
|
|
GHashTable *hash_table;
|
|
|
|
GSList *dissector_handles;
|
|
|
|
const char *ui_name;
|
|
|
|
ftenum_t type;
|
2014-12-10 02:35:01 +00:00
|
|
|
int param;
|
2016-03-13 11:51:45 +00:00
|
|
|
protocol_t *protocol;
|
2016-08-30 22:51:54 +00:00
|
|
|
GHashFunc hash_func;
|
|
|
|
gboolean supports_decode_as;
|
2013-08-11 13:42:12 +00:00
|
|
|
};
|
|
|
|
|
2018-09-14 19:58:35 +00:00
|
|
|
/*
|
|
|
|
* Dissector tables. const char * -> dissector_table *
|
|
|
|
*/
|
2013-08-11 13:42:12 +00:00
|
|
|
static GHashTable *dissector_tables = NULL;
|
|
|
|
|
2018-09-14 19:58:35 +00:00
|
|
|
/*
|
|
|
|
* Dissector table aliases. const char * -> const char *
|
|
|
|
*/
|
|
|
|
static GHashTable *dissector_table_aliases = NULL;
|
|
|
|
|
2013-08-11 13:42:12 +00:00
|
|
|
/*
|
|
|
|
* List of registered dissectors.
|
|
|
|
*/
|
|
|
|
static GHashTable *registered_dissectors = NULL;
|
|
|
|
|
2016-03-13 03:11:03 +00:00
|
|
|
/*
|
|
|
|
* A dissector dependency list.
|
|
|
|
*/
|
|
|
|
struct depend_dissector_list {
|
|
|
|
GSList *dissectors;
|
|
|
|
};
|
|
|
|
|
2016-03-31 19:53:05 +00:00
|
|
|
/* Maps char *dissector_name to depend_dissector_list_t */
|
2016-03-13 03:11:03 +00:00
|
|
|
static GHashTable *depend_dissector_lists = NULL;
|
|
|
|
|
2017-01-18 13:01:06 +00:00
|
|
|
/* Allow protocols to register a "cleanup" routine to be
|
|
|
|
* run after the initial sequential run through the packets.
|
|
|
|
* Note that the file can still be open after this; this is not
|
|
|
|
* the final cleanup. */
|
|
|
|
static GSList *postseq_cleanup_routines;
|
|
|
|
|
2017-04-12 02:53:48 +00:00
|
|
|
/*
|
|
|
|
* Post-dissector information - handle for the dissector and a list
|
|
|
|
* of hfids for the fields the post-dissector wants.
|
|
|
|
*/
|
|
|
|
typedef struct {
|
|
|
|
dissector_handle_t handle;
|
2017-04-17 01:48:30 +00:00
|
|
|
GArray *wanted_hfids;
|
2017-04-12 02:53:48 +00:00
|
|
|
} postdissector;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Array of all postdissectors.
|
|
|
|
*/
|
|
|
|
static GArray *postdissectors = NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* i-th element of that array.
|
|
|
|
*/
|
|
|
|
#define POSTDISSECTORS(i) g_array_index(postdissectors, postdissector, i)
|
2017-01-20 11:33:18 +00:00
|
|
|
|
2016-03-13 03:11:03 +00:00
|
|
|
static void
|
|
|
|
destroy_depend_dissector_list(void *data)
|
|
|
|
{
|
|
|
|
depend_dissector_list_t dissector_list = (depend_dissector_list_t)data;
|
|
|
|
GSList **list = &(dissector_list->dissectors);
|
|
|
|
|
2018-04-17 10:48:35 +00:00
|
|
|
g_slist_free_full(*list, g_free);
|
2016-03-13 03:11:03 +00:00
|
|
|
g_slice_free(struct depend_dissector_list, dissector_list);
|
|
|
|
}
|
|
|
|
|
2014-12-21 07:32:23 +00:00
|
|
|
/*
|
|
|
|
* A heuristics dissector list.
|
|
|
|
*/
|
2014-12-21 04:13:28 +00:00
|
|
|
struct heur_dissector_list {
|
2016-03-13 11:51:45 +00:00
|
|
|
protocol_t *protocol;
|
2014-12-21 07:32:23 +00:00
|
|
|
GSList *dissectors;
|
2014-12-21 04:13:28 +00:00
|
|
|
};
|
|
|
|
|
2013-08-11 13:42:12 +00:00
|
|
|
static GHashTable *heur_dissector_lists = NULL;
|
|
|
|
|
2015-07-11 21:33:26 +00:00
|
|
|
/* Name hashtables for fast detection of duplicate names */
|
|
|
|
static GHashTable* heuristic_short_names = NULL;
|
|
|
|
|
2013-10-11 01:11:21 +00:00
|
|
|
static void
|
2018-04-17 10:48:35 +00:00
|
|
|
destroy_heuristic_dissector_entry(gpointer data)
|
2013-10-11 01:11:21 +00:00
|
|
|
{
|
2017-01-06 23:39:17 +00:00
|
|
|
heur_dtbl_entry_t *hdtbl_entry = (heur_dtbl_entry_t *)data;
|
|
|
|
g_free(hdtbl_entry->list_name);
|
|
|
|
g_free(hdtbl_entry->short_name);
|
2013-10-11 01:11:21 +00:00
|
|
|
g_slice_free(heur_dtbl_entry_t, data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
destroy_heuristic_dissector_list(void *data)
|
|
|
|
{
|
2015-06-22 23:30:13 +00:00
|
|
|
heur_dissector_list_t dissector_list = (heur_dissector_list_t)data;
|
|
|
|
GSList **list = &(dissector_list->dissectors);
|
2013-10-11 01:11:21 +00:00
|
|
|
|
2018-04-17 10:48:35 +00:00
|
|
|
g_slist_free_full(*list, destroy_heuristic_dissector_entry);
|
2015-06-22 23:30:13 +00:00
|
|
|
g_slice_free(struct heur_dissector_list, dissector_list);
|
2013-10-11 01:11:21 +00:00
|
|
|
}
|
|
|
|
|
2013-10-11 01:33:40 +00:00
|
|
|
static void
|
|
|
|
destroy_dissector_table(void *data)
|
|
|
|
{
|
|
|
|
struct dissector_table *table = (struct dissector_table *)data;
|
|
|
|
|
|
|
|
g_hash_table_destroy(table->hash_table);
|
|
|
|
g_slist_free(table->dissector_handles);
|
2013-10-12 02:41:44 +00:00
|
|
|
g_slice_free(struct dissector_table, data);
|
2013-10-11 01:33:40 +00:00
|
|
|
}
|
|
|
|
|
2000-10-06 10:11:40 +00:00
|
|
|
void
|
|
|
|
packet_init(void)
|
2013-08-13 03:11:28 +00:00
|
|
|
{
|
2013-10-11 01:33:40 +00:00
|
|
|
dissector_tables = g_hash_table_new_full(g_str_hash, g_str_equal,
|
|
|
|
NULL, destroy_dissector_table);
|
2013-08-14 17:36:47 +00:00
|
|
|
|
2018-09-14 19:58:35 +00:00
|
|
|
dissector_table_aliases = g_hash_table_new_full(g_str_hash, g_str_equal,
|
|
|
|
NULL, NULL);
|
|
|
|
|
2013-08-13 03:11:28 +00:00
|
|
|
registered_dissectors = g_hash_table_new_full(g_str_hash, g_str_equal,
|
2013-10-11 01:33:40 +00:00
|
|
|
NULL, NULL);
|
2013-08-14 17:36:47 +00:00
|
|
|
|
2016-03-13 03:11:03 +00:00
|
|
|
depend_dissector_lists = g_hash_table_new_full(g_str_hash, g_str_equal,
|
2016-03-31 19:53:05 +00:00
|
|
|
g_free, destroy_depend_dissector_list);
|
2016-03-13 03:11:03 +00:00
|
|
|
|
2013-10-11 01:11:21 +00:00
|
|
|
heur_dissector_lists = g_hash_table_new_full(g_str_hash, g_str_equal,
|
|
|
|
NULL, destroy_heuristic_dissector_list);
|
2015-07-11 21:33:26 +00:00
|
|
|
|
2017-11-05 13:05:20 +00:00
|
|
|
heuristic_short_names = g_hash_table_new(g_str_hash, g_str_equal);
|
2013-08-13 03:11:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
packet_cache_proto_handles(void)
|
2000-10-06 10:11:40 +00:00
|
|
|
{
|
2011-04-20 16:35:42 +00:00
|
|
|
frame_handle = find_dissector("frame");
|
2013-08-01 17:19:20 +00:00
|
|
|
g_assert(frame_handle != NULL);
|
|
|
|
|
2014-01-08 04:35:28 +00:00
|
|
|
file_handle = find_dissector("file");
|
|
|
|
g_assert(file_handle != NULL);
|
|
|
|
|
2011-04-20 16:35:42 +00:00
|
|
|
data_handle = find_dissector("data");
|
2013-08-01 17:19:20 +00:00
|
|
|
g_assert(data_handle != NULL);
|
|
|
|
|
2013-10-09 12:56:19 +00:00
|
|
|
proto_malformed = proto_get_id_by_filter_name("_ws.malformed");
|
2013-08-01 17:19:20 +00:00
|
|
|
g_assert(proto_malformed != -1);
|
2000-10-06 10:11:40 +00:00
|
|
|
}
|
|
|
|
|
2016-12-13 11:40:22 +00:00
|
|
|
/* List of routines that are called before we make a pass through a capture file
|
|
|
|
* and dissect all its packets. See register_init_routine, register_cleanup_routine
|
|
|
|
* and register_shutdown_routine in packet.h */
|
|
|
|
static GSList *init_routines = NULL;
|
|
|
|
static GSList *cleanup_routines = NULL;
|
|
|
|
static GSList *shutdown_routines = NULL;
|
|
|
|
|
|
|
|
typedef void (*void_func_t)(void);
|
|
|
|
|
|
|
|
/* Initialize all data structures used for dissection. */
|
|
|
|
static void
|
|
|
|
call_routine(gpointer routine, gpointer dummy _U_)
|
|
|
|
{
|
|
|
|
void_func_t func = (void_func_t)routine;
|
|
|
|
(*func)();
|
|
|
|
}
|
|
|
|
|
2000-10-06 10:11:40 +00:00
|
|
|
void
|
|
|
|
packet_cleanup(void)
|
|
|
|
{
|
2017-01-16 21:49:28 +00:00
|
|
|
g_slist_free(init_routines);
|
|
|
|
g_slist_free(cleanup_routines);
|
2017-01-18 13:01:06 +00:00
|
|
|
g_slist_free(postseq_cleanup_routines);
|
2013-08-11 13:42:12 +00:00
|
|
|
g_hash_table_destroy(dissector_tables);
|
2018-09-14 19:58:35 +00:00
|
|
|
g_hash_table_destroy(dissector_table_aliases);
|
2013-08-11 13:42:12 +00:00
|
|
|
g_hash_table_destroy(registered_dissectors);
|
2016-03-13 03:11:03 +00:00
|
|
|
g_hash_table_destroy(depend_dissector_lists);
|
2013-08-11 13:42:12 +00:00
|
|
|
g_hash_table_destroy(heur_dissector_lists);
|
2015-07-11 21:33:26 +00:00
|
|
|
g_hash_table_destroy(heuristic_short_names);
|
2016-12-13 11:40:22 +00:00
|
|
|
g_slist_foreach(shutdown_routines, &call_routine, NULL);
|
2017-01-19 21:58:32 +00:00
|
|
|
g_slist_free(shutdown_routines);
|
2017-08-28 11:42:59 +00:00
|
|
|
if (postdissectors) {
|
|
|
|
for (guint i = 0; i < postdissectors->len; i++) {
|
|
|
|
if (POSTDISSECTORS(i).wanted_hfids) {
|
|
|
|
g_array_free(POSTDISSECTORS(i).wanted_hfids, TRUE);
|
|
|
|
}
|
|
|
|
}
|
2017-04-12 02:53:48 +00:00
|
|
|
g_array_free(postdissectors, TRUE);
|
2017-08-28 11:42:59 +00:00
|
|
|
}
|
2000-10-06 10:11:40 +00:00
|
|
|
}
|
|
|
|
|
2001-06-29 09:46:54 +00:00
|
|
|
/*
|
2002-02-17 00:51:21 +00:00
|
|
|
* Given a tvbuff, and a length from a packet header, adjust the length
|
|
|
|
* of the tvbuff to reflect the specified length.
|
2001-06-29 09:46:54 +00:00
|
|
|
*/
|
|
|
|
void
|
2010-04-03 18:18:50 +00:00
|
|
|
set_actual_length(tvbuff_t *tvb, const guint specified_len)
|
2001-06-29 09:46:54 +00:00
|
|
|
{
|
2009-10-12 01:31:01 +00:00
|
|
|
if (specified_len < tvb_reported_length(tvb)) {
|
|
|
|
/* Adjust the length of this tvbuff to include only the specified
|
|
|
|
payload length.
|
|
|
|
|
|
|
|
The dissector above the one calling us (the dissector above is
|
|
|
|
probably us) may use that to determine how much of its packet
|
|
|
|
was padding. */
|
|
|
|
tvb_set_reported_length(tvb, specified_len);
|
|
|
|
}
|
2001-06-29 09:46:54 +00:00
|
|
|
}
|
|
|
|
|
Provide a general mechanism by which dissectors can register "init"
routines, which are called before a dissection pass is made over all the
packets in a capture - the "init" routine would clear out any state
information that needs to be initialized before such a dissection pass.
Make the NCP, SMB, AFS, and ONC RPC dissectors register their "init"
routines with that mechanism, have the code that reads in a capture file
call the routine that calls all registered "init" routines rather than
calling a wired-in set of "init" routines, and also have the code that
runs a filtering or colorizing pass over all the packets call that
routine, as a filtering or colorizing pass is a dissection pass.
Have the ONC RPC "init" routine zero out the table of RPC calls, so that
it completely erases any state from the previous dissection pass (so
that, for example, if you run a filtering pass, it doesn't mark any
non-duplicate packets as duplicates because it remembers them from the
previous pass).
svn path=/trunk/; revision=1050
1999-11-17 21:58:33 +00:00
|
|
|
void
|
|
|
|
register_init_routine(void (*func)(void))
|
|
|
|
{
|
2013-10-15 18:21:03 +00:00
|
|
|
init_routines = g_slist_prepend(init_routines, (gpointer)func);
|
Provide a general mechanism by which dissectors can register "init"
routines, which are called before a dissection pass is made over all the
packets in a capture - the "init" routine would clear out any state
information that needs to be initialized before such a dissection pass.
Make the NCP, SMB, AFS, and ONC RPC dissectors register their "init"
routines with that mechanism, have the code that reads in a capture file
call the routine that calls all registered "init" routines rather than
calling a wired-in set of "init" routines, and also have the code that
runs a filtering or colorizing pass over all the packets call that
routine, as a filtering or colorizing pass is a dissection pass.
Have the ONC RPC "init" routine zero out the table of RPC calls, so that
it completely erases any state from the previous dissection pass (so
that, for example, if you run a filtering pass, it doesn't mark any
non-duplicate packets as duplicates because it remembers them from the
previous pass).
svn path=/trunk/; revision=1050
1999-11-17 21:58:33 +00:00
|
|
|
}
|
|
|
|
|
2015-06-23 23:54:19 +00:00
|
|
|
void
|
|
|
|
register_cleanup_routine(void (*func)(void))
|
|
|
|
{
|
|
|
|
cleanup_routines = g_slist_prepend(cleanup_routines, (gpointer)func);
|
|
|
|
}
|
|
|
|
|
2016-12-13 11:40:22 +00:00
|
|
|
/* register a new shutdown routine */
|
|
|
|
void
|
|
|
|
register_shutdown_routine(void (*func)(void))
|
Provide a general mechanism by which dissectors can register "init"
routines, which are called before a dissection pass is made over all the
packets in a capture - the "init" routine would clear out any state
information that needs to be initialized before such a dissection pass.
Make the NCP, SMB, AFS, and ONC RPC dissectors register their "init"
routines with that mechanism, have the code that reads in a capture file
call the routine that calls all registered "init" routines rather than
calling a wired-in set of "init" routines, and also have the code that
runs a filtering or colorizing pass over all the packets call that
routine, as a filtering or colorizing pass is a dissection pass.
Have the ONC RPC "init" routine zero out the table of RPC calls, so that
it completely erases any state from the previous dissection pass (so
that, for example, if you run a filtering pass, it doesn't mark any
non-duplicate packets as duplicates because it remembers them from the
previous pass).
svn path=/trunk/; revision=1050
1999-11-17 21:58:33 +00:00
|
|
|
{
|
2016-12-13 11:40:22 +00:00
|
|
|
shutdown_routines = g_slist_prepend(shutdown_routines, (gpointer)func);
|
Provide a general mechanism by which dissectors can register "init"
routines, which are called before a dissection pass is made over all the
packets in a capture - the "init" routine would clear out any state
information that needs to be initialized before such a dissection pass.
Make the NCP, SMB, AFS, and ONC RPC dissectors register their "init"
routines with that mechanism, have the code that reads in a capture file
call the routine that calls all registered "init" routines rather than
calling a wired-in set of "init" routines, and also have the code that
runs a filtering or colorizing pass over all the packets call that
routine, as a filtering or colorizing pass is a dissection pass.
Have the ONC RPC "init" routine zero out the table of RPC calls, so that
it completely erases any state from the previous dissection pass (so
that, for example, if you run a filtering pass, it doesn't mark any
non-duplicate packets as duplicates because it remembers them from the
previous pass).
svn path=/trunk/; revision=1050
1999-11-17 21:58:33 +00:00
|
|
|
}
|
|
|
|
|
2017-01-18 21:03:54 +00:00
|
|
|
/* Initialize all data structures used for dissection. */
|
Provide a general mechanism by which dissectors can register "init"
routines, which are called before a dissection pass is made over all the
packets in a capture - the "init" routine would clear out any state
information that needs to be initialized before such a dissection pass.
Make the NCP, SMB, AFS, and ONC RPC dissectors register their "init"
routines with that mechanism, have the code that reads in a capture file
call the routine that calls all registered "init" routines rather than
calling a wired-in set of "init" routines, and also have the code that
runs a filtering or colorizing pass over all the packets call that
routine, as a filtering or colorizing pass is a dissection pass.
Have the ONC RPC "init" routine zero out the table of RPC calls, so that
it completely erases any state from the previous dissection pass (so
that, for example, if you run a filtering pass, it doesn't mark any
non-duplicate packets as duplicates because it remembers them from the
previous pass).
svn path=/trunk/; revision=1050
1999-11-17 21:58:33 +00:00
|
|
|
void
|
2002-02-24 06:45:14 +00:00
|
|
|
init_dissection(void)
|
Provide a general mechanism by which dissectors can register "init"
routines, which are called before a dissection pass is made over all the
packets in a capture - the "init" routine would clear out any state
information that needs to be initialized before such a dissection pass.
Make the NCP, SMB, AFS, and ONC RPC dissectors register their "init"
routines with that mechanism, have the code that reads in a capture file
call the routine that calls all registered "init" routines rather than
calling a wired-in set of "init" routines, and also have the code that
runs a filtering or colorizing pass over all the packets call that
routine, as a filtering or colorizing pass is a dissection pass.
Have the ONC RPC "init" routine zero out the table of RPC calls, so that
it completely erases any state from the previous dissection pass (so
that, for example, if you run a filtering pass, it doesn't mark any
non-duplicate packets as duplicates because it remembers them from the
previous pass).
svn path=/trunk/; revision=1050
1999-11-17 21:58:33 +00:00
|
|
|
{
|
2012-10-12 21:37:02 +00:00
|
|
|
/*
|
2018-09-02 12:43:40 +00:00
|
|
|
* Reinitialize resolution information. Don't leak host entries from
|
|
|
|
* one file to another (e.g. embarassing-host-name.example.com from
|
|
|
|
* file1.pcapng into a name resolution block in file2.pcapng).
|
2012-10-12 21:37:02 +00:00
|
|
|
*/
|
2018-09-02 12:43:40 +00:00
|
|
|
host_name_lookup_reset();
|
|
|
|
|
|
|
|
wmem_enter_file_scope();
|
2012-10-12 21:37:02 +00:00
|
|
|
|
2002-02-24 06:45:14 +00:00
|
|
|
/* Initialize the table of conversations. */
|
|
|
|
epan_conversation_init();
|
|
|
|
|
|
|
|
/* Initialize protocol-specific variables. */
|
2015-06-23 23:54:19 +00:00
|
|
|
g_slist_foreach(init_routines, &call_routine, NULL);
|
Provide a general mechanism by which dissectors can register "init"
routines, which are called before a dissection pass is made over all the
packets in a capture - the "init" routine would clear out any state
information that needs to be initialized before such a dissection pass.
Make the NCP, SMB, AFS, and ONC RPC dissectors register their "init"
routines with that mechanism, have the code that reads in a capture file
call the routine that calls all registered "init" routines rather than
calling a wired-in set of "init" routines, and also have the code that
runs a filtering or colorizing pass over all the packets call that
routine, as a filtering or colorizing pass is a dissection pass.
Have the ONC RPC "init" routine zero out the table of RPC calls, so that
it completely erases any state from the previous dissection pass (so
that, for example, if you run a filtering pass, it doesn't mark any
non-duplicate packets as duplicates because it remembers them from the
previous pass).
svn path=/trunk/; revision=1050
1999-11-17 21:58:33 +00:00
|
|
|
|
2006-08-31 22:56:38 +00:00
|
|
|
/* Initialize the stream-handling tables */
|
2005-10-03 18:34:21 +00:00
|
|
|
stream_init();
|
2006-08-31 22:56:38 +00:00
|
|
|
|
|
|
|
/* Initialize the expert infos */
|
2013-05-24 17:59:36 +00:00
|
|
|
expert_packet_init();
|
2002-02-24 06:45:14 +00:00
|
|
|
}
|
2002-01-05 04:12:17 +00:00
|
|
|
|
2005-03-23 12:58:59 +00:00
|
|
|
void
|
|
|
|
cleanup_dissection(void)
|
|
|
|
{
|
2009-09-06 18:25:23 +00:00
|
|
|
/* Cleanup protocol-specific variables. */
|
2015-06-23 23:54:19 +00:00
|
|
|
g_slist_foreach(cleanup_routines, &call_routine, NULL);
|
2009-09-06 18:25:23 +00:00
|
|
|
|
|
|
|
/* Cleanup the stream-handling tables */
|
|
|
|
stream_cleanup();
|
|
|
|
|
2015-08-15 17:31:51 +00:00
|
|
|
/* Cleanup the expert infos */
|
2013-05-24 17:59:36 +00:00
|
|
|
expert_packet_cleanup();
|
2013-03-06 01:53:03 +00:00
|
|
|
|
2012-11-09 00:08:27 +00:00
|
|
|
wmem_leave_file_scope();
|
2012-10-12 21:37:02 +00:00
|
|
|
|
|
|
|
/*
|
2018-09-02 12:43:40 +00:00
|
|
|
* Keep the name resolution info around until we start the next
|
|
|
|
* dissection. Lua scripts may potentially do name resolution at
|
|
|
|
* any time, even if we're not dissecting and have no capture
|
|
|
|
* file open.
|
2012-10-12 21:37:02 +00:00
|
|
|
*/
|
2005-03-23 12:58:59 +00:00
|
|
|
}
|
|
|
|
|
2002-01-05 04:12:17 +00:00
|
|
|
void
|
2004-02-01 02:35:06 +00:00
|
|
|
register_postseq_cleanup_routine(void_func_t func)
|
2002-01-05 04:12:17 +00:00
|
|
|
{
|
2013-10-15 18:21:03 +00:00
|
|
|
postseq_cleanup_routines = g_slist_prepend(postseq_cleanup_routines,
|
2004-02-01 02:35:06 +00:00
|
|
|
(gpointer)func);
|
2002-01-05 04:12:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Call all the registered "postseq_cleanup" routines. */
|
|
|
|
void
|
|
|
|
postseq_cleanup_all_protocols(void)
|
|
|
|
{
|
|
|
|
g_slist_foreach(postseq_cleanup_routines,
|
2017-01-18 21:03:54 +00:00
|
|
|
&call_routine, NULL);
|
2002-01-05 04:12:17 +00:00
|
|
|
}
|
|
|
|
|
2002-02-18 01:08:44 +00:00
|
|
|
/*
|
|
|
|
* Add a new data source to the list of data sources for a frame, given
|
|
|
|
* the tvbuff for the data source and its name.
|
|
|
|
*/
|
|
|
|
void
|
2005-07-23 11:41:25 +00:00
|
|
|
add_new_data_source(packet_info *pinfo, tvbuff_t *tvb, const char *name)
|
2002-02-18 01:08:44 +00:00
|
|
|
{
|
2012-10-20 19:54:56 +00:00
|
|
|
struct data_source *src;
|
2002-02-18 01:08:44 +00:00
|
|
|
|
2016-07-15 00:18:24 +00:00
|
|
|
src = wmem_new(pinfo->pool, struct data_source);
|
2002-02-18 01:08:44 +00:00
|
|
|
src->tvb = tvb;
|
2016-07-15 00:18:24 +00:00
|
|
|
src->name = wmem_strdup(pinfo->pool, name);
|
2014-01-29 23:04:20 +00:00
|
|
|
/* This could end up slow, but we should never have that many data
|
|
|
|
* sources so it probably doesn't matter */
|
2002-06-04 07:03:57 +00:00
|
|
|
pinfo->data_src = g_slist_append(pinfo->data_src, src);
|
2002-02-18 01:08:44 +00:00
|
|
|
}
|
|
|
|
|
2014-01-29 23:04:20 +00:00
|
|
|
void
|
|
|
|
remove_last_data_source(packet_info *pinfo)
|
|
|
|
{
|
|
|
|
GSList *last;
|
|
|
|
|
|
|
|
last = g_slist_last(pinfo->data_src);
|
|
|
|
pinfo->data_src = g_slist_delete_link(pinfo->data_src, last);
|
|
|
|
}
|
|
|
|
|
2015-01-18 02:17:24 +00:00
|
|
|
char*
|
2012-10-20 19:54:56 +00:00
|
|
|
get_data_source_name(const struct data_source *src)
|
2009-07-12 10:19:13 +00:00
|
|
|
{
|
2015-06-24 00:30:22 +00:00
|
|
|
guint length = tvb_captured_length(src->tvb);
|
2013-03-06 01:53:03 +00:00
|
|
|
|
2015-01-18 02:17:24 +00:00
|
|
|
return wmem_strdup_printf(NULL, "%s (%u byte%s)", src->name, length,
|
2013-03-06 01:53:03 +00:00
|
|
|
plurality(length, "", "s"));
|
2012-10-20 19:54:56 +00:00
|
|
|
}
|
2009-07-12 10:19:13 +00:00
|
|
|
|
2012-10-20 19:54:56 +00:00
|
|
|
tvbuff_t *
|
|
|
|
get_data_source_tvb(const struct data_source *src)
|
|
|
|
{
|
|
|
|
return src->tvb;
|
2009-07-12 10:19:13 +00:00
|
|
|
}
|
|
|
|
|
2017-01-22 17:01:33 +00:00
|
|
|
/*
|
|
|
|
* Find and return the tvb associated with the given data source name
|
|
|
|
*/
|
|
|
|
tvbuff_t *
|
|
|
|
get_data_source_tvb_by_name(packet_info *pinfo, const char *name)
|
|
|
|
{
|
2017-01-30 10:07:36 +00:00
|
|
|
GSList *source;
|
2017-01-22 17:01:33 +00:00
|
|
|
for (source = pinfo->data_src; source; source = source->next) {
|
|
|
|
struct data_source *this_source = (struct data_source *)source;
|
|
|
|
if (this_source->name && strcmp(this_source->name, name) == 0) {
|
|
|
|
return this_source->tvb;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-02-18 01:08:44 +00:00
|
|
|
/*
|
|
|
|
* Free up a frame's list of data sources.
|
|
|
|
*/
|
|
|
|
void
|
2002-06-04 07:03:57 +00:00
|
|
|
free_data_sources(packet_info *pinfo)
|
2002-02-18 01:08:44 +00:00
|
|
|
{
|
2009-08-15 06:38:10 +00:00
|
|
|
if (pinfo->data_src) {
|
|
|
|
g_slist_free(pinfo->data_src);
|
|
|
|
pinfo->data_src = NULL;
|
|
|
|
}
|
2002-02-18 01:08:44 +00:00
|
|
|
}
|
2002-01-05 04:12:17 +00:00
|
|
|
|
2012-02-28 03:19:49 +00:00
|
|
|
void
|
|
|
|
mark_frame_as_depended_upon(packet_info *pinfo, guint32 frame_num)
|
|
|
|
{
|
|
|
|
/* Don't mark a frame as dependent on itself */
|
2016-01-24 03:40:51 +00:00
|
|
|
if (frame_num != pinfo->num) {
|
2012-02-28 03:19:49 +00:00
|
|
|
pinfo->dependent_frames = g_slist_prepend(pinfo->dependent_frames, GUINT_TO_POINTER(frame_num));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-05-09 23:50:34 +00:00
|
|
|
/* Allow dissectors to register a "final_registration" routine
|
2006-03-16 23:18:15 +00:00
|
|
|
* that is run like the proto_register_XXX() routine, but at the
|
2002-05-09 23:50:34 +00:00
|
|
|
* end of the epan_init() function; that is, *after* all other
|
2002-05-10 20:02:40 +00:00
|
|
|
* subsystems, like dfilters, have finished initializing. This is
|
2002-05-09 23:50:34 +00:00
|
|
|
* useful for dissector registration routines which need to compile
|
|
|
|
* display filters. dfilters can't initialize itself until all protocols
|
2006-03-16 23:18:15 +00:00
|
|
|
* have registered themselves. */
|
2002-05-09 23:50:34 +00:00
|
|
|
static GSList *final_registration_routines;
|
|
|
|
|
|
|
|
void
|
|
|
|
register_final_registration_routine(void (*func)(void))
|
|
|
|
{
|
2013-10-15 18:21:03 +00:00
|
|
|
final_registration_routines = g_slist_prepend(final_registration_routines,
|
2004-02-01 02:35:06 +00:00
|
|
|
(gpointer)func);
|
2002-05-09 23:50:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Call all the registered "final_registration" routines. */
|
|
|
|
void
|
|
|
|
final_registration_all_protocols(void)
|
|
|
|
{
|
|
|
|
g_slist_foreach(final_registration_routines,
|
2017-01-18 21:03:54 +00:00
|
|
|
&call_routine, NULL);
|
2002-05-09 23:50:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2000-10-06 10:11:40 +00:00
|
|
|
/* Creates the top-most tvbuff and calls dissect_frame() */
|
1998-09-16 02:39:15 +00:00
|
|
|
void
|
2014-05-25 00:04:44 +00:00
|
|
|
dissect_record(epan_dissect_t *edt, int file_type_subtype,
|
2018-02-09 00:19:12 +00:00
|
|
|
wtap_rec *rec, tvbuff_t *tvb, frame_data *fd, column_info *cinfo)
|
1998-09-27 22:12:47 +00:00
|
|
|
{
|
2014-05-25 18:21:38 +00:00
|
|
|
const char *volatile record_type;
|
2014-12-19 13:08:38 +00:00
|
|
|
frame_data_t frame_dissector_data;
|
2014-05-25 00:04:44 +00:00
|
|
|
|
2018-02-09 00:19:12 +00:00
|
|
|
switch (rec->rec_type) {
|
2014-05-25 00:04:44 +00:00
|
|
|
|
|
|
|
case REC_TYPE_PACKET:
|
|
|
|
record_type = "Frame";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case REC_TYPE_FT_SPECIFIC_EVENT:
|
|
|
|
record_type = "Event";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case REC_TYPE_FT_SPECIFIC_REPORT:
|
|
|
|
record_type = "Report";
|
|
|
|
break;
|
|
|
|
|
2016-04-24 18:21:50 +00:00
|
|
|
case REC_TYPE_SYSCALL:
|
|
|
|
record_type = "System Call";
|
|
|
|
break;
|
|
|
|
|
2014-05-25 00:04:44 +00:00
|
|
|
default:
|
|
|
|
/*
|
|
|
|
* XXX - if we add record types that shouldn't be
|
|
|
|
* dissected and displayed, but that need to at
|
|
|
|
* least be processed somewhere, we need to somehow
|
|
|
|
* indicate that to our caller.
|
|
|
|
*/
|
|
|
|
g_assert_not_reached();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2003-04-16 05:55:41 +00:00
|
|
|
if (cinfo != NULL)
|
2013-07-21 20:48:30 +00:00
|
|
|
col_init(cinfo, edt->session);
|
|
|
|
edt->pi.epan = edt->session;
|
2013-10-20 10:11:16 +00:00
|
|
|
/* edt->pi.pool created in epan_dissect_init() */
|
2002-03-28 09:12:00 +00:00
|
|
|
edt->pi.current_proto = "<Missing Protocol Name>";
|
|
|
|
edt->pi.cinfo = cinfo;
|
2016-01-23 03:50:21 +00:00
|
|
|
edt->pi.presence_flags = 0;
|
2016-01-24 03:40:51 +00:00
|
|
|
edt->pi.num = fd->num;
|
2016-01-23 04:09:35 +00:00
|
|
|
if (fd->flags.has_ts) {
|
2016-01-23 03:50:21 +00:00
|
|
|
edt->pi.presence_flags |= PINFO_HAS_TS;
|
2016-01-23 04:09:35 +00:00
|
|
|
edt->pi.abs_ts = fd->abs_ts;
|
2016-01-23 03:50:21 +00:00
|
|
|
}
|
2018-02-09 00:19:12 +00:00
|
|
|
switch (rec->rec_type) {
|
|
|
|
|
|
|
|
case REC_TYPE_PACKET:
|
|
|
|
edt->pi.pseudo_header = &rec->rec_header.packet_header.pseudo_header;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case REC_TYPE_FT_SPECIFIC_EVENT:
|
|
|
|
case REC_TYPE_FT_SPECIFIC_REPORT:
|
|
|
|
edt->pi.pseudo_header = NULL;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case REC_TYPE_SYSCALL:
|
|
|
|
edt->pi.pseudo_header = NULL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2016-01-23 03:50:21 +00:00
|
|
|
edt->pi.fd = fd;
|
2018-02-09 00:19:12 +00:00
|
|
|
edt->pi.rec = rec;
|
2015-11-26 04:44:52 +00:00
|
|
|
clear_address(&edt->pi.dl_src);
|
|
|
|
clear_address(&edt->pi.dl_dst);
|
|
|
|
clear_address(&edt->pi.net_src);
|
|
|
|
clear_address(&edt->pi.net_dst);
|
|
|
|
clear_address(&edt->pi.src);
|
|
|
|
clear_address(&edt->pi.dst);
|
2003-02-27 03:56:48 +00:00
|
|
|
edt->pi.noreassembly_reason = "";
|
2001-12-08 21:03:41 +00:00
|
|
|
edt->pi.ptype = PT_NONE;
|
2017-11-01 11:45:42 +00:00
|
|
|
edt->pi.use_endpoint = FALSE;
|
|
|
|
edt->pi.conv_endpoint = NULL;
|
2001-12-08 21:03:41 +00:00
|
|
|
edt->pi.p2p_dir = P2P_DIR_UNKNOWN;
|
2009-06-06 17:03:34 +00:00
|
|
|
edt->pi.link_dir = LINK_DIR_UNKNOWN;
|
2013-11-05 17:48:48 +00:00
|
|
|
edt->pi.layers = wmem_list_new(edt->pi.pool);
|
2013-07-11 05:47:02 +00:00
|
|
|
edt->tvb = tvb;
|
2008-05-21 20:20:37 +00:00
|
|
|
|
2013-07-21 23:07:33 +00:00
|
|
|
frame_delta_abs_time(edt->session, fd, fd->frame_ref_num, &edt->pi.rel_ts);
|
|
|
|
|
2018-02-09 00:19:12 +00:00
|
|
|
/* pkt comment use first user, later from rec */
|
2014-02-25 20:42:35 +00:00
|
|
|
if (fd->flags.has_user_comment)
|
2014-12-19 13:08:38 +00:00
|
|
|
frame_dissector_data.pkt_comment = epan_get_user_comment(edt->session, fd);
|
2013-08-01 21:24:54 +00:00
|
|
|
else if (fd->flags.has_phdr_comment)
|
2018-02-09 00:19:12 +00:00
|
|
|
frame_dissector_data.pkt_comment = rec->opt_comment;
|
2014-12-19 13:08:38 +00:00
|
|
|
else
|
|
|
|
frame_dissector_data.pkt_comment = NULL;
|
|
|
|
frame_dissector_data.file_type_subtype = file_type_subtype;
|
2015-12-30 20:28:07 +00:00
|
|
|
frame_dissector_data.color_edt = edt; /* Used strictly for "coloring rules" */
|
2013-08-01 20:59:38 +00:00
|
|
|
|
2000-05-11 08:18:09 +00:00
|
|
|
TRY {
|
2001-12-08 21:03:41 +00:00
|
|
|
/* Add this tvbuffer into the data_src list */
|
2014-05-25 00:04:44 +00:00
|
|
|
add_new_data_source(&edt->pi, edt->tvb, record_type);
|
2002-02-11 19:02:56 +00:00
|
|
|
|
|
|
|
/* Even though dissect_frame() catches all the exceptions a
|
|
|
|
* sub-dissector can throw, dissect_frame() itself may throw
|
|
|
|
* a ReportedBoundsError in bizarre cases. Thus, we catch the exception
|
|
|
|
* in this function. */
|
2014-12-19 13:08:38 +00:00
|
|
|
call_dissector_with_data(frame_handle, edt->tvb, &edt->pi, edt->tree, &frame_dissector_data);
|
2000-05-11 08:18:09 +00:00
|
|
|
}
|
|
|
|
CATCH(BoundsError) {
|
2000-10-06 10:11:40 +00:00
|
|
|
g_assert_not_reached();
|
2000-05-16 04:44:14 +00:00
|
|
|
}
|
2013-04-18 19:22:24 +00:00
|
|
|
CATCH2(FragmentBoundsError, ReportedBoundsError) {
|
2013-08-01 17:19:20 +00:00
|
|
|
proto_tree_add_protocol_format(edt->tree, proto_malformed, edt->tvb, 0, 0,
|
2014-05-25 00:04:44 +00:00
|
|
|
"[Malformed %s: Packet Length]",
|
|
|
|
record_type);
|
1998-11-12 00:06:47 +00:00
|
|
|
}
|
2000-05-11 08:18:09 +00:00
|
|
|
ENDTRY;
|
2009-09-06 07:55:17 +00:00
|
|
|
|
2000-04-13 20:39:38 +00:00
|
|
|
fd->flags.visited = 1;
|
1999-07-07 22:52:57 +00:00
|
|
|
}
|
|
|
|
|
2014-01-08 04:35:28 +00:00
|
|
|
/* Creates the top-most tvbuff and calls dissect_file() */
|
|
|
|
void
|
2018-02-09 00:19:12 +00:00
|
|
|
dissect_file(epan_dissect_t *edt, wtap_rec *rec,
|
2014-01-08 04:35:28 +00:00
|
|
|
tvbuff_t *tvb, frame_data *fd, column_info *cinfo)
|
|
|
|
{
|
2015-12-30 20:28:07 +00:00
|
|
|
file_data_t file_dissector_data;
|
|
|
|
|
2014-01-08 04:35:28 +00:00
|
|
|
if (cinfo != NULL)
|
|
|
|
col_init(cinfo, edt->session);
|
|
|
|
edt->pi.epan = edt->session;
|
|
|
|
/* edt->pi.pool created in epan_dissect_init() */
|
|
|
|
edt->pi.current_proto = "<Missing Filetype Name>";
|
|
|
|
edt->pi.cinfo = cinfo;
|
|
|
|
edt->pi.fd = fd;
|
2018-02-09 00:19:12 +00:00
|
|
|
edt->pi.rec = rec;
|
|
|
|
edt->pi.pseudo_header = NULL;
|
2015-11-26 04:44:52 +00:00
|
|
|
clear_address(&edt->pi.dl_src);
|
|
|
|
clear_address(&edt->pi.dl_dst);
|
|
|
|
clear_address(&edt->pi.net_src);
|
|
|
|
clear_address(&edt->pi.net_dst);
|
|
|
|
clear_address(&edt->pi.src);
|
|
|
|
clear_address(&edt->pi.dst);
|
2014-01-08 04:35:28 +00:00
|
|
|
edt->pi.noreassembly_reason = "";
|
|
|
|
edt->pi.ptype = PT_NONE;
|
2017-11-01 11:45:42 +00:00
|
|
|
edt->pi.use_endpoint = FALSE;
|
|
|
|
edt->pi.conv_endpoint = NULL;
|
2014-01-08 04:35:28 +00:00
|
|
|
edt->pi.p2p_dir = P2P_DIR_UNKNOWN;
|
|
|
|
edt->pi.link_dir = LINK_DIR_UNKNOWN;
|
|
|
|
edt->pi.layers = wmem_list_new(edt->pi.pool);
|
|
|
|
edt->tvb = tvb;
|
|
|
|
|
|
|
|
|
|
|
|
frame_delta_abs_time(edt->session, fd, fd->frame_ref_num, &edt->pi.rel_ts);
|
|
|
|
|
|
|
|
|
|
|
|
TRY {
|
2018-02-09 00:19:12 +00:00
|
|
|
/* pkt comment use first user, later from rec */
|
2014-12-19 13:08:38 +00:00
|
|
|
if (fd->flags.has_user_comment)
|
2015-12-30 20:28:07 +00:00
|
|
|
file_dissector_data.pkt_comment = epan_get_user_comment(edt->session, fd);
|
2014-12-19 13:08:38 +00:00
|
|
|
else if (fd->flags.has_phdr_comment)
|
2018-02-09 00:19:12 +00:00
|
|
|
file_dissector_data.pkt_comment = rec->opt_comment;
|
2014-12-19 13:08:38 +00:00
|
|
|
else
|
2015-12-30 20:28:07 +00:00
|
|
|
file_dissector_data.pkt_comment = NULL;
|
|
|
|
file_dissector_data.color_edt = edt; /* Used strictly for "coloring rules" */
|
|
|
|
|
2014-12-19 13:08:38 +00:00
|
|
|
|
2014-01-08 04:35:28 +00:00
|
|
|
/* Add this tvbuffer into the data_src list */
|
|
|
|
add_new_data_source(&edt->pi, edt->tvb, "File");
|
|
|
|
|
|
|
|
/* Even though dissect_file() catches all the exceptions a
|
|
|
|
* sub-dissector can throw, dissect_frame() itself may throw
|
|
|
|
* a ReportedBoundsError in bizarre cases. Thus, we catch the exception
|
|
|
|
* in this function. */
|
2015-12-30 20:28:07 +00:00
|
|
|
call_dissector_with_data(file_handle, edt->tvb, &edt->pi, edt->tree, &file_dissector_data);
|
2014-01-08 04:35:28 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
CATCH(BoundsError) {
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
2018-04-20 03:18:10 +00:00
|
|
|
CATCH3(FragmentBoundsError, ContainedBoundsError, ReportedBoundsError) {
|
2014-01-08 04:35:28 +00:00
|
|
|
proto_tree_add_protocol_format(edt->tree, proto_malformed, edt->tvb, 0, 0,
|
2018-02-08 08:31:29 +00:00
|
|
|
"[Malformed Record: Packet Length]");
|
2014-01-08 04:35:28 +00:00
|
|
|
}
|
|
|
|
ENDTRY;
|
|
|
|
|
|
|
|
fd->flags.visited = 1;
|
|
|
|
}
|
|
|
|
|
2000-04-03 09:24:12 +00:00
|
|
|
/*********************** code added for sub-dissector lookup *********************/
|
|
|
|
|
2017-08-27 19:53:23 +00:00
|
|
|
enum dissector_e {
|
|
|
|
DISSECTOR_TYPE_SIMPLE,
|
|
|
|
DISSECTOR_TYPE_CALLBACK
|
|
|
|
};
|
|
|
|
|
2001-12-03 04:00:26 +00:00
|
|
|
/*
|
2010-04-03 18:18:50 +00:00
|
|
|
* A dissector handle.
|
2001-12-03 04:00:26 +00:00
|
|
|
*/
|
|
|
|
struct dissector_handle {
|
|
|
|
const char *name; /* dissector name */
|
2017-08-27 19:53:23 +00:00
|
|
|
enum dissector_e dissector_type;
|
|
|
|
void *dissector_func;
|
|
|
|
void *dissector_data;
|
2003-11-16 23:17:27 +00:00
|
|
|
protocol_t *protocol;
|
2001-12-03 04:00:26 +00:00
|
|
|
};
|
2001-02-01 07:34:33 +00:00
|
|
|
|
2005-05-11 10:40:53 +00:00
|
|
|
/* This function will return
|
|
|
|
* old style dissector :
|
|
|
|
* length of the payload or 1 of the payload is empty
|
|
|
|
* new dissector :
|
|
|
|
* >0 this protocol was successfully dissected and this was this protocol.
|
|
|
|
* 0 this packet did not match this protocol.
|
|
|
|
*
|
|
|
|
* The only time this function will return 0 is if it is a new style dissector
|
|
|
|
* and if the dissector rejected the packet.
|
2006-03-07 16:28:25 +00:00
|
|
|
*/
|
2003-01-20 05:42:37 +00:00
|
|
|
static int
|
|
|
|
call_dissector_through_handle(dissector_handle_t handle, tvbuff_t *tvb,
|
2012-09-11 08:28:07 +00:00
|
|
|
packet_info *pinfo, proto_tree *tree, void *data)
|
2003-01-20 05:42:37 +00:00
|
|
|
{
|
2003-08-12 20:09:38 +00:00
|
|
|
const char *saved_proto;
|
2014-10-11 20:39:17 +00:00
|
|
|
int len;
|
2003-01-20 05:42:37 +00:00
|
|
|
|
2003-08-12 20:09:38 +00:00
|
|
|
saved_proto = pinfo->current_proto;
|
|
|
|
|
2016-12-30 00:41:33 +00:00
|
|
|
if ((handle->protocol != NULL) && (!proto_is_pino(handle->protocol))) {
|
2003-08-12 20:09:38 +00:00
|
|
|
pinfo->current_proto =
|
2009-10-12 01:31:01 +00:00
|
|
|
proto_get_protocol_short_name(handle->protocol);
|
2003-08-12 20:09:38 +00:00
|
|
|
}
|
|
|
|
|
2017-08-27 19:53:23 +00:00
|
|
|
if (handle->dissector_type == DISSECTOR_TYPE_SIMPLE) {
|
|
|
|
len = ((dissector_t)handle->dissector_func)(tvb, pinfo, tree, data);
|
|
|
|
}
|
|
|
|
else if (handle->dissector_type == DISSECTOR_TYPE_CALLBACK) {
|
|
|
|
len = ((dissector_cb_t)handle->dissector_func)(tvb, pinfo, tree, data, handle->dissector_data);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
2003-08-12 20:09:38 +00:00
|
|
|
pinfo->current_proto = saved_proto;
|
|
|
|
|
2014-10-11 20:39:17 +00:00
|
|
|
return len;
|
2003-01-20 05:42:37 +00:00
|
|
|
}
|
|
|
|
|
2002-10-28 23:04:15 +00:00
|
|
|
/*
|
|
|
|
* Call a dissector through a handle.
|
|
|
|
* If the protocol for that handle isn't enabled, return 0 without
|
|
|
|
* calling the dissector.
|
|
|
|
* Otherwise, if the handle refers to a new-style dissector, call the
|
|
|
|
* dissector and return its return value, otherwise call it and return
|
|
|
|
* the length of the tvbuff pointed to by the argument.
|
|
|
|
*/
|
2007-11-09 06:07:30 +00:00
|
|
|
|
|
|
|
static int
|
|
|
|
call_dissector_work_error(dissector_handle_t handle, tvbuff_t *tvb,
|
2012-09-11 08:28:07 +00:00
|
|
|
packet_info *pinfo_arg, proto_tree *tree, void *);
|
2007-11-09 06:07:30 +00:00
|
|
|
|
2002-10-28 23:04:15 +00:00
|
|
|
static int
|
2012-09-11 08:28:07 +00:00
|
|
|
call_dissector_work(dissector_handle_t handle, tvbuff_t *tvb, packet_info *pinfo_arg,
|
|
|
|
proto_tree *tree, gboolean add_proto_name, void *data)
|
2002-10-28 23:04:15 +00:00
|
|
|
{
|
2017-09-11 22:11:45 +00:00
|
|
|
packet_info *pinfo = pinfo_arg;
|
2012-01-20 02:43:37 +00:00
|
|
|
const char *saved_proto;
|
|
|
|
guint16 saved_can_desegment;
|
2014-10-11 20:39:17 +00:00
|
|
|
int len;
|
2013-11-05 17:48:48 +00:00
|
|
|
guint saved_layers_len = 0;
|
2017-09-11 22:11:45 +00:00
|
|
|
int saved_tree_count = tree ? tree->tree_data->count : 0;
|
2002-10-28 23:04:15 +00:00
|
|
|
|
2003-11-16 23:17:27 +00:00
|
|
|
if (handle->protocol != NULL &&
|
|
|
|
!proto_is_protocol_enabled(handle->protocol)) {
|
2002-10-28 23:04:15 +00:00
|
|
|
/*
|
|
|
|
* The protocol isn't enabled.
|
|
|
|
*/
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
saved_proto = pinfo->current_proto;
|
|
|
|
saved_can_desegment = pinfo->can_desegment;
|
2013-11-05 17:48:48 +00:00
|
|
|
saved_layers_len = wmem_list_count(pinfo->layers);
|
2005-01-20 11:05:06 +00:00
|
|
|
|
2002-10-28 23:04:15 +00:00
|
|
|
/*
|
|
|
|
* can_desegment is set to 2 by anyone which offers the
|
|
|
|
* desegmentation api/service.
|
|
|
|
* Then everytime a subdissector is called it is decremented
|
|
|
|
* by one.
|
|
|
|
* Thus only the subdissector immediately on top of whoever
|
|
|
|
* offers this service can use it.
|
2003-12-29 22:44:50 +00:00
|
|
|
* We save the current value of "can_desegment" for the
|
|
|
|
* benefit of TCP proxying dissectors such as SOCKS, so they
|
|
|
|
* can restore it and allow the dissectors they call to use
|
|
|
|
* the desegmentation service.
|
2002-10-28 23:04:15 +00:00
|
|
|
*/
|
2003-12-29 22:44:50 +00:00
|
|
|
pinfo->saved_can_desegment = saved_can_desegment;
|
2002-10-28 23:04:15 +00:00
|
|
|
pinfo->can_desegment = saved_can_desegment-(saved_can_desegment>0);
|
2016-12-30 00:41:33 +00:00
|
|
|
if ((handle->protocol != NULL) && (!proto_is_pino(handle->protocol))) {
|
2002-10-28 23:04:15 +00:00
|
|
|
pinfo->current_proto =
|
2009-10-12 01:31:01 +00:00
|
|
|
proto_get_protocol_short_name(handle->protocol);
|
2005-01-19 04:49:29 +00:00
|
|
|
|
|
|
|
/*
|
2017-09-11 22:11:45 +00:00
|
|
|
* Add the protocol name to the layers only if told to
|
|
|
|
* do so. Asn2wrs generated dissectors may be added
|
|
|
|
* multiple times otherwise.
|
2005-01-19 04:49:29 +00:00
|
|
|
*/
|
2017-09-11 22:11:45 +00:00
|
|
|
/* XXX Should we check for a duplicate layer here? */
|
2013-04-23 17:17:56 +00:00
|
|
|
if (add_proto_name) {
|
|
|
|
pinfo->curr_layer_num++;
|
2013-11-05 17:48:48 +00:00
|
|
|
wmem_list_append(pinfo->layers, GINT_TO_POINTER(proto_get_id(handle->protocol)));
|
2005-01-19 04:49:29 +00:00
|
|
|
}
|
2002-10-28 23:04:15 +00:00
|
|
|
}
|
2003-01-20 05:42:37 +00:00
|
|
|
|
2012-01-20 02:43:37 +00:00
|
|
|
if (pinfo->flags.in_error_pkt) {
|
2014-10-11 20:39:17 +00:00
|
|
|
len = call_dissector_work_error(handle, tvb, pinfo, tree, data);
|
2007-11-09 06:07:30 +00:00
|
|
|
} else {
|
2003-01-20 05:42:37 +00:00
|
|
|
/*
|
2017-09-11 22:11:45 +00:00
|
|
|
* Just call the subdissector.
|
|
|
|
*/
|
2014-10-11 20:39:17 +00:00
|
|
|
len = call_dissector_through_handle(handle, tvb, pinfo, tree, data);
|
2007-11-09 06:07:30 +00:00
|
|
|
}
|
2017-10-05 19:39:10 +00:00
|
|
|
if (handle->protocol != NULL && !proto_is_pino(handle->protocol) && add_proto_name &&
|
2017-09-11 22:11:45 +00:00
|
|
|
(len == 0 || (tree && saved_tree_count == tree->tree_data->count))) {
|
2003-01-20 05:42:37 +00:00
|
|
|
/*
|
2017-09-11 22:11:45 +00:00
|
|
|
* We've added a layer and either the dissector didn't
|
|
|
|
* accept the packet or we didn't add any items to the
|
|
|
|
* tree. Remove it.
|
2003-01-20 05:42:37 +00:00
|
|
|
*/
|
2013-11-05 17:48:48 +00:00
|
|
|
while (wmem_list_count(pinfo->layers) > saved_layers_len) {
|
2017-09-11 22:11:45 +00:00
|
|
|
pinfo->curr_layer_num--;
|
2013-11-05 17:48:48 +00:00
|
|
|
wmem_list_remove_frame(pinfo->layers, wmem_list_tail(pinfo->layers));
|
2003-01-20 05:42:37 +00:00
|
|
|
}
|
2017-09-11 22:11:45 +00:00
|
|
|
}
|
|
|
|
pinfo->current_proto = saved_proto;
|
|
|
|
pinfo->can_desegment = saved_can_desegment;
|
2014-10-11 20:39:17 +00:00
|
|
|
return len;
|
2007-11-09 06:07:30 +00:00
|
|
|
}
|
2003-01-20 05:42:37 +00:00
|
|
|
|
|
|
|
|
2007-11-09 06:07:30 +00:00
|
|
|
static int
|
|
|
|
call_dissector_work_error(dissector_handle_t handle, tvbuff_t *tvb,
|
2012-09-11 08:28:07 +00:00
|
|
|
packet_info *pinfo_arg, proto_tree *tree, void *data)
|
2007-11-09 06:07:30 +00:00
|
|
|
{
|
2012-01-20 02:43:37 +00:00
|
|
|
packet_info *pinfo = pinfo_arg;
|
|
|
|
const char *saved_proto;
|
|
|
|
guint16 saved_can_desegment;
|
2014-10-11 20:39:17 +00:00
|
|
|
volatile int len = 0;
|
2012-01-20 02:43:37 +00:00
|
|
|
gboolean save_writable;
|
|
|
|
address save_dl_src;
|
|
|
|
address save_dl_dst;
|
|
|
|
address save_net_src;
|
|
|
|
address save_net_dst;
|
|
|
|
address save_src;
|
|
|
|
address save_dst;
|
2003-01-20 05:42:37 +00:00
|
|
|
|
2007-11-09 06:07:30 +00:00
|
|
|
/*
|
|
|
|
* This isn't a packet being transported inside
|
|
|
|
* the protocol whose dissector is calling us,
|
|
|
|
* it's a copy of a packet that caused an error
|
|
|
|
* in some protocol included in a packet that
|
|
|
|
* reports the error (e.g., an ICMP Unreachable
|
|
|
|
* packet).
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Save the current state of the writability of
|
|
|
|
* the columns, and restore them after the
|
|
|
|
* dissector returns, so that the columns
|
|
|
|
* don't reflect the packet that got the error,
|
|
|
|
* they reflect the packet that reported the
|
|
|
|
* error.
|
|
|
|
*/
|
|
|
|
saved_proto = pinfo->current_proto;
|
|
|
|
saved_can_desegment = pinfo->can_desegment;
|
2003-01-20 05:42:37 +00:00
|
|
|
|
2016-06-14 15:55:08 +00:00
|
|
|
save_writable = col_get_writable(pinfo->cinfo, -1);
|
|
|
|
col_set_writable(pinfo->cinfo, -1, FALSE);
|
2015-11-26 04:44:52 +00:00
|
|
|
copy_address_shallow(&save_dl_src, &pinfo->dl_src);
|
|
|
|
copy_address_shallow(&save_dl_dst, &pinfo->dl_dst);
|
|
|
|
copy_address_shallow(&save_net_src, &pinfo->net_src);
|
|
|
|
copy_address_shallow(&save_net_dst, &pinfo->net_dst);
|
|
|
|
copy_address_shallow(&save_src, &pinfo->src);
|
|
|
|
copy_address_shallow(&save_dst, &pinfo->dst);
|
2007-11-09 06:07:30 +00:00
|
|
|
|
|
|
|
/* Dissect the contained packet. */
|
|
|
|
TRY {
|
2014-10-11 20:39:17 +00:00
|
|
|
len = call_dissector_through_handle(handle, tvb,pinfo, tree, data);
|
2007-11-09 06:07:30 +00:00
|
|
|
}
|
|
|
|
CATCH(BoundsError) {
|
|
|
|
/*
|
|
|
|
* Restore the column writability and addresses.
|
|
|
|
*/
|
2016-06-14 15:55:08 +00:00
|
|
|
col_set_writable(pinfo->cinfo, -1, save_writable);
|
2015-11-26 04:44:52 +00:00
|
|
|
copy_address_shallow(&pinfo->dl_src, &save_dl_src);
|
|
|
|
copy_address_shallow(&pinfo->dl_dst, &save_dl_dst);
|
|
|
|
copy_address_shallow(&pinfo->net_src, &save_net_src);
|
|
|
|
copy_address_shallow(&pinfo->net_dst, &save_net_dst);
|
|
|
|
copy_address_shallow(&pinfo->src, &save_src);
|
|
|
|
copy_address_shallow(&pinfo->dst, &save_dst);
|
2007-11-09 06:07:30 +00:00
|
|
|
|
2003-01-20 05:42:37 +00:00
|
|
|
/*
|
2007-11-09 06:07:30 +00:00
|
|
|
* Restore the current protocol, so any
|
|
|
|
* "Short Frame" indication reflects that
|
|
|
|
* protocol, not the protocol for the
|
|
|
|
* packet that got the error.
|
|
|
|
*/
|
|
|
|
pinfo->current_proto = saved_proto;
|
2005-01-20 11:05:06 +00:00
|
|
|
|
|
|
|
/*
|
2007-11-09 06:07:30 +00:00
|
|
|
* Restore the desegmentability state.
|
|
|
|
*/
|
|
|
|
pinfo->can_desegment = saved_can_desegment;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Rethrow the exception, so this will be
|
|
|
|
* reported as a short frame.
|
|
|
|
*/
|
|
|
|
RETHROW;
|
2005-01-20 11:05:06 +00:00
|
|
|
}
|
2018-04-20 03:18:10 +00:00
|
|
|
CATCH3(FragmentBoundsError, ContainedBoundsError, ReportedBoundsError) {
|
2007-11-09 06:07:30 +00:00
|
|
|
/*
|
|
|
|
* "ret" wasn't set because an exception was thrown
|
|
|
|
* before "call_dissector_through_handle()" returned.
|
|
|
|
* As it called something, at least one dissector
|
|
|
|
* accepted the packet, and, as an exception was
|
|
|
|
* thrown, not only was all the tvbuff dissected,
|
|
|
|
* a dissector tried dissecting past the end of
|
|
|
|
* the data in some tvbuff, so we'll assume that
|
|
|
|
* the entire tvbuff was dissected.
|
|
|
|
*/
|
2015-06-24 00:30:22 +00:00
|
|
|
len = tvb_captured_length(tvb);
|
2007-11-09 06:07:30 +00:00
|
|
|
}
|
|
|
|
ENDTRY;
|
|
|
|
|
2016-06-14 15:55:08 +00:00
|
|
|
col_set_writable(pinfo->cinfo, -1, save_writable);
|
2015-11-26 04:44:52 +00:00
|
|
|
copy_address_shallow(&pinfo->dl_src, &save_dl_src);
|
|
|
|
copy_address_shallow(&pinfo->dl_dst, &save_dl_dst);
|
|
|
|
copy_address_shallow(&pinfo->net_src, &save_net_src);
|
|
|
|
copy_address_shallow(&pinfo->net_dst, &save_net_dst);
|
|
|
|
copy_address_shallow(&pinfo->src, &save_src);
|
|
|
|
copy_address_shallow(&pinfo->dst, &save_dst);
|
2007-11-09 06:07:30 +00:00
|
|
|
pinfo->want_pdu_tracking = 0;
|
2014-10-11 20:39:17 +00:00
|
|
|
return len;
|
2002-10-28 23:04:15 +00:00
|
|
|
}
|
|
|
|
|
Get rid of the lists of conversation dissectors; instead, have a
dissector table contain both a hash table, to use to look up port
numbers to find a dissector, and a list of all dissectors that *could*
be assigned to ports in that hash table, to be used by user interface
code.
Make the "Decode As" dialog box code use that.
Also make it *not* let you choose whether to set the dissector for both
the UDP and TCP versions of a port; some protocols run only atop TCP,
some run only atop UDP, and even those that can run atop both may have
different dissector handles to use over TCP and UDP, so handling a
single merged list would be a mess. (If the user is setting the
dissector for a TCP port, only those protocols that Ethereal can handle
over TCP should be listed; if the user is setting the dissector for a
UDP port, only those protocols that Ethereal can handle over TCP should
be listed; if the user is setting a dissector for both, only those
protocols that Ethereal can handle over *both* TCP *and* UDP should be
listed, *and* there needs to be a way to let the "Decode As" code get
both the TCP handle *and* the UDP handle and use the right ones. If
somebody really wants that, they need to implement all of the above if
they want the code to be correct.)
Fix the code that handles setting the dissection for the IP protocol
number to correctly update the lists of protocols being dissected as TCP
and as UDP; the code before this change wasn't updating the single such
list to add new protocols.
svn path=/trunk/; revision=4311
2001-12-03 08:47:31 +00:00
|
|
|
/*
|
|
|
|
* An entry in the hash table portion of a dissector table.
|
|
|
|
*/
|
2001-02-01 07:34:33 +00:00
|
|
|
struct dtbl_entry {
|
2001-12-03 04:00:26 +00:00
|
|
|
dissector_handle_t initial;
|
|
|
|
dissector_handle_t current;
|
2001-02-01 07:34:33 +00:00
|
|
|
};
|
|
|
|
|
2001-12-08 06:41:48 +00:00
|
|
|
/* Finds a dissector table by table name. */
|
2002-11-15 03:10:36 +00:00
|
|
|
dissector_table_t
|
Change the sub-dissector handoff registration routines so that the
sub-dissector table is not stored in the header_field_info struct, but
in a separate namespace. Dissector tables are now registered by name
and not by field ID. For example:
udp_dissector_table = register_dissector_table("udp.port");
Because of this different namespace, dissector tables can have names
that are not field names. This is useful for ethertype, since multiple
fields are "ethertypes".
packet-ethertype.c replaces ethertype.c (the name was changed so that it
would be named in the same fashion as all the filenames passed to make-reg-dotc)
Although it registers no protocol or field, it registers one dissector table:
ethertype_dissector_table = register_dissector_table("ethertype");
All protocols that can be called because of an ethertype field now register
that fact with dissector_add() calls.
In this way, one dissector_table services all ethertype fields
(hf_eth_type, hf_llc_type, hf_null_etype, hf_vlan_etype)
Furthermore, the code allows for names of protocols to exist in the
etype_vals, yet a dissector for that protocol doesn't exist. The name
of the dissector is printed in COL_INFO. You're welcome, Richard. :-)
svn path=/trunk/; revision=1848
2000-04-13 18:18:56 +00:00
|
|
|
find_dissector_table(const char *name)
|
|
|
|
{
|
2018-09-14 19:58:35 +00:00
|
|
|
dissector_table_t dissector_table = (dissector_table_t) g_hash_table_lookup(dissector_tables, name);
|
|
|
|
if (! dissector_table) {
|
|
|
|
const char *new_name = (const char *) g_hash_table_lookup(dissector_table_aliases, name);
|
|
|
|
if (new_name) {
|
|
|
|
dissector_table = (dissector_table_t) g_hash_table_lookup(dissector_tables, new_name);
|
|
|
|
}
|
|
|
|
if (dissector_table) {
|
2018-09-18 17:09:31 +00:00
|
|
|
g_warning("%s is now %s", name, new_name);
|
2018-09-14 19:58:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return dissector_table;
|
Change the sub-dissector handoff registration routines so that the
sub-dissector table is not stored in the header_field_info struct, but
in a separate namespace. Dissector tables are now registered by name
and not by field ID. For example:
udp_dissector_table = register_dissector_table("udp.port");
Because of this different namespace, dissector tables can have names
that are not field names. This is useful for ethertype, since multiple
fields are "ethertypes".
packet-ethertype.c replaces ethertype.c (the name was changed so that it
would be named in the same fashion as all the filenames passed to make-reg-dotc)
Although it registers no protocol or field, it registers one dissector table:
ethertype_dissector_table = register_dissector_table("ethertype");
All protocols that can be called because of an ethertype field now register
that fact with dissector_add() calls.
In this way, one dissector_table services all ethertype fields
(hf_eth_type, hf_llc_type, hf_null_etype, hf_vlan_etype)
Furthermore, the code allows for names of protocols to exist in the
etype_vals, yet a dissector for that protocol doesn't exist. The name
of the dissector is printed in COL_INFO. You're welcome, Richard. :-)
svn path=/trunk/; revision=1848
2000-04-13 18:18:56 +00:00
|
|
|
}
|
2000-04-03 09:24:12 +00:00
|
|
|
|
2005-01-19 04:49:29 +00:00
|
|
|
/* Find an entry in a uint dissector table. */
|
2003-09-06 23:37:02 +00:00
|
|
|
static dtbl_entry_t *
|
2010-04-03 18:18:50 +00:00
|
|
|
find_uint_dtbl_entry(dissector_table_t sub_dissectors, const guint32 pattern)
|
2003-09-06 23:37:02 +00:00
|
|
|
{
|
|
|
|
switch (sub_dissectors->type) {
|
|
|
|
|
|
|
|
case FT_UINT8:
|
|
|
|
case FT_UINT16:
|
|
|
|
case FT_UINT24:
|
|
|
|
case FT_UINT32:
|
|
|
|
/*
|
2010-12-20 05:35:29 +00:00
|
|
|
* You can do a uint lookup in these tables.
|
2003-09-06 23:37:02 +00:00
|
|
|
*/
|
|
|
|
break;
|
2017-07-09 17:44:06 +00:00
|
|
|
case FT_NONE:
|
|
|
|
/* For now treat as uint */
|
|
|
|
break;
|
2003-09-06 23:37:02 +00:00
|
|
|
|
|
|
|
default:
|
|
|
|
/*
|
2010-12-20 05:35:29 +00:00
|
|
|
* But you can't do a uint lookup in any other types
|
2003-09-06 23:37:02 +00:00
|
|
|
* of tables.
|
|
|
|
*/
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find the entry.
|
|
|
|
*/
|
2013-03-14 06:46:29 +00:00
|
|
|
return (dtbl_entry_t *)g_hash_table_lookup(sub_dissectors->hash_table,
|
2009-10-12 01:31:01 +00:00
|
|
|
GUINT_TO_POINTER(pattern));
|
2003-09-06 23:37:02 +00:00
|
|
|
}
|
|
|
|
|
2009-10-05 18:52:46 +00:00
|
|
|
#if 0
|
|
|
|
static void
|
2010-12-20 05:35:29 +00:00
|
|
|
dissector_add_uint_sanity_check(const char *name, guint32 pattern, dissector_handle_t handle, dissector_table_t sub_dissectors)
|
2009-10-05 18:52:46 +00:00
|
|
|
{
|
|
|
|
dtbl_entry_t *dtbl_entry;
|
|
|
|
|
|
|
|
if (pattern == 0) {
|
|
|
|
g_warning("%s: %s registering using a pattern of 0",
|
|
|
|
name, proto_get_protocol_filter_name(proto_get_id(handle->protocol)));
|
|
|
|
}
|
|
|
|
|
|
|
|
dtbl_entry = g_hash_table_lookup(sub_dissectors->hash_table, GUINT_TO_POINTER(pattern));
|
|
|
|
if (dtbl_entry != NULL) {
|
|
|
|
g_warning("%s: %s registering using pattern %d already registered by %s",
|
|
|
|
name, proto_get_protocol_filter_name(proto_get_id(handle->protocol)),
|
2012-01-20 02:43:37 +00:00
|
|
|
pattern, proto_get_protocol_filter_name(proto_get_id(dtbl_entry->initial->protocol)));
|
2009-10-05 18:52:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2003-09-06 23:37:02 +00:00
|
|
|
/* Add an entry to a uint dissector table. */
|
Add routines to:
register lists of "heuristic" dissectors, which are handed a
frame that may or may contain a payload for the protocol they
dissect, and that return FALSE if it's not or dissect the packet
and return TRUE if it is;
add a dissector to such a list;
go through such a list, calling each dissector until either a
dissector returns TRUE, in which case the routine returns TRUE,
or it runs out of entries in the list, in which case the routine
returns FALSE.
Have lists of heuristic dissectors for TCP and for COTP when used with
the Inactive Subset of CLNP, and add the GIOP and Yahoo Messenger
dissectors to the first list and the Sinec H1 dissector to the second
list.
Make the dissector name argument to "dissector_add()" and
"dissector_delete()" a "const char *" rarther than just a "char *".
Add "heur_dissector_add()", the routine to add a heuristic dissector to
a list of heuristic dissectors, to the set of routines we can export to
plugins through a table on platforms where dynamically-loaded code can't
call stuff in the main program, and initialize the element in the table
in question for "dissector_add()" (which we'd forgotten to do).
svn path=/trunk/; revision=1909
2000-05-05 09:32:36 +00:00
|
|
|
void
|
2010-12-20 05:35:29 +00:00
|
|
|
dissector_add_uint(const char *name, const guint32 pattern, dissector_handle_t handle)
|
Add routines to:
register lists of "heuristic" dissectors, which are handed a
frame that may or may contain a payload for the protocol they
dissect, and that return FALSE if it's not or dissect the packet
and return TRUE if it is;
add a dissector to such a list;
go through such a list, calling each dissector until either a
dissector returns TRUE, in which case the routine returns TRUE,
or it runs out of entries in the list, in which case the routine
returns FALSE.
Have lists of heuristic dissectors for TCP and for COTP when used with
the Inactive Subset of CLNP, and add the GIOP and Yahoo Messenger
dissectors to the first list and the Sinec H1 dissector to the second
list.
Make the dissector name argument to "dissector_add()" and
"dissector_delete()" a "const char *" rarther than just a "char *".
Add "heur_dissector_add()", the routine to add a heuristic dissector to
a list of heuristic dissectors, to the set of routines we can export to
plugins through a table on platforms where dynamically-loaded code can't
call stuff in the main program, and initialize the element in the table
in question for "dissector_add()" (which we'd forgotten to do).
svn path=/trunk/; revision=1909
2000-05-05 09:32:36 +00:00
|
|
|
{
|
Revert r44978: dissector_add_uint: Legalize formerly improper use of the API when calling it with pattern value of 0
dissector_add_uint() is *not only* used by tcp.port/udp.port dissector tables where 0 is not valid port number,
in some dissector tables 0 is valid protocol number, packet type, etc..
Sample dissectors using dissector_add_uint(.pattern = 0):
packet-ansi_637.c:2348: dissector_add_uint("ansi_a.sms", 0, ansi_637_trans_handle);
packet-cip.c:6017: dissector_add_uint("cip.class.iface", 0, cip_class_generic_handle );
packet-lon.c:723: dissector_add_uint("cnip.protocol", 0, lon_handle);
packet-q931.c:3599: dissector_add_uint("lapd.sapi", LAPD_SAPI_Q931 /* 0 */, q931_handle);
svn path=/trunk/; revision=44980
2012-09-18 19:29:00 +00:00
|
|
|
dissector_table_t sub_dissectors;
|
|
|
|
dtbl_entry_t *dtbl_entry;
|
|
|
|
|
|
|
|
sub_dissectors = find_dissector_table(name);
|
|
|
|
|
2011-06-01 18:02:16 +00:00
|
|
|
/*
|
2016-06-21 17:56:00 +00:00
|
|
|
* Make sure the handle and the dissector table exist.
|
Revert r44978: dissector_add_uint: Legalize formerly improper use of the API when calling it with pattern value of 0
dissector_add_uint() is *not only* used by tcp.port/udp.port dissector tables where 0 is not valid port number,
in some dissector tables 0 is valid protocol number, packet type, etc..
Sample dissectors using dissector_add_uint(.pattern = 0):
packet-ansi_637.c:2348: dissector_add_uint("ansi_a.sms", 0, ansi_637_trans_handle);
packet-cip.c:6017: dissector_add_uint("cip.class.iface", 0, cip_class_generic_handle );
packet-lon.c:723: dissector_add_uint("cnip.protocol", 0, lon_handle);
packet-q931.c:3599: dissector_add_uint("lapd.sapi", LAPD_SAPI_Q931 /* 0 */, q931_handle);
svn path=/trunk/; revision=44980
2012-09-18 19:29:00 +00:00
|
|
|
*/
|
2016-06-21 17:56:00 +00:00
|
|
|
if (handle == NULL) {
|
|
|
|
fprintf(stderr, "OOPS: handle to register \"%s\" to doesn't exist\n",
|
|
|
|
name);
|
|
|
|
if (getenv("WIRESHARK_ABORT_ON_DISSECTOR_BUG") != NULL)
|
|
|
|
abort();
|
|
|
|
return;
|
|
|
|
}
|
Revert r44978: dissector_add_uint: Legalize formerly improper use of the API when calling it with pattern value of 0
dissector_add_uint() is *not only* used by tcp.port/udp.port dissector tables where 0 is not valid port number,
in some dissector tables 0 is valid protocol number, packet type, etc..
Sample dissectors using dissector_add_uint(.pattern = 0):
packet-ansi_637.c:2348: dissector_add_uint("ansi_a.sms", 0, ansi_637_trans_handle);
packet-cip.c:6017: dissector_add_uint("cip.class.iface", 0, cip_class_generic_handle );
packet-lon.c:723: dissector_add_uint("cnip.protocol", 0, lon_handle);
packet-q931.c:3599: dissector_add_uint("lapd.sapi", LAPD_SAPI_Q931 /* 0 */, q931_handle);
svn path=/trunk/; revision=44980
2012-09-18 19:29:00 +00:00
|
|
|
if (sub_dissectors == NULL) {
|
|
|
|
fprintf(stderr, "OOPS: dissector table \"%s\" doesn't exist\n",
|
|
|
|
name);
|
|
|
|
fprintf(stderr, "Protocol being registered is \"%s\"\n",
|
|
|
|
proto_get_protocol_long_name(handle->protocol));
|
|
|
|
if (getenv("WIRESHARK_ABORT_ON_DISSECTOR_BUG") != NULL)
|
|
|
|
abort();
|
|
|
|
return;
|
|
|
|
}
|
2011-06-01 18:02:16 +00:00
|
|
|
|
Revert r44978: dissector_add_uint: Legalize formerly improper use of the API when calling it with pattern value of 0
dissector_add_uint() is *not only* used by tcp.port/udp.port dissector tables where 0 is not valid port number,
in some dissector tables 0 is valid protocol number, packet type, etc..
Sample dissectors using dissector_add_uint(.pattern = 0):
packet-ansi_637.c:2348: dissector_add_uint("ansi_a.sms", 0, ansi_637_trans_handle);
packet-cip.c:6017: dissector_add_uint("cip.class.iface", 0, cip_class_generic_handle );
packet-lon.c:723: dissector_add_uint("cnip.protocol", 0, lon_handle);
packet-q931.c:3599: dissector_add_uint("lapd.sapi", LAPD_SAPI_Q931 /* 0 */, q931_handle);
svn path=/trunk/; revision=44980
2012-09-18 19:29:00 +00:00
|
|
|
switch (sub_dissectors->type) {
|
2003-09-06 23:37:02 +00:00
|
|
|
|
Revert r44978: dissector_add_uint: Legalize formerly improper use of the API when calling it with pattern value of 0
dissector_add_uint() is *not only* used by tcp.port/udp.port dissector tables where 0 is not valid port number,
in some dissector tables 0 is valid protocol number, packet type, etc..
Sample dissectors using dissector_add_uint(.pattern = 0):
packet-ansi_637.c:2348: dissector_add_uint("ansi_a.sms", 0, ansi_637_trans_handle);
packet-cip.c:6017: dissector_add_uint("cip.class.iface", 0, cip_class_generic_handle );
packet-lon.c:723: dissector_add_uint("cnip.protocol", 0, lon_handle);
packet-q931.c:3599: dissector_add_uint("lapd.sapi", LAPD_SAPI_Q931 /* 0 */, q931_handle);
svn path=/trunk/; revision=44980
2012-09-18 19:29:00 +00:00
|
|
|
case FT_UINT8:
|
|
|
|
case FT_UINT16:
|
|
|
|
case FT_UINT24:
|
|
|
|
case FT_UINT32:
|
2003-09-06 23:37:02 +00:00
|
|
|
/*
|
Revert r44978: dissector_add_uint: Legalize formerly improper use of the API when calling it with pattern value of 0
dissector_add_uint() is *not only* used by tcp.port/udp.port dissector tables where 0 is not valid port number,
in some dissector tables 0 is valid protocol number, packet type, etc..
Sample dissectors using dissector_add_uint(.pattern = 0):
packet-ansi_637.c:2348: dissector_add_uint("ansi_a.sms", 0, ansi_637_trans_handle);
packet-cip.c:6017: dissector_add_uint("cip.class.iface", 0, cip_class_generic_handle );
packet-lon.c:723: dissector_add_uint("cnip.protocol", 0, lon_handle);
packet-q931.c:3599: dissector_add_uint("lapd.sapi", LAPD_SAPI_Q931 /* 0 */, q931_handle);
svn path=/trunk/; revision=44980
2012-09-18 19:29:00 +00:00
|
|
|
* You can do a uint lookup in these tables.
|
2003-09-06 23:37:02 +00:00
|
|
|
*/
|
Revert r44978: dissector_add_uint: Legalize formerly improper use of the API when calling it with pattern value of 0
dissector_add_uint() is *not only* used by tcp.port/udp.port dissector tables where 0 is not valid port number,
in some dissector tables 0 is valid protocol number, packet type, etc..
Sample dissectors using dissector_add_uint(.pattern = 0):
packet-ansi_637.c:2348: dissector_add_uint("ansi_a.sms", 0, ansi_637_trans_handle);
packet-cip.c:6017: dissector_add_uint("cip.class.iface", 0, cip_class_generic_handle );
packet-lon.c:723: dissector_add_uint("cnip.protocol", 0, lon_handle);
packet-q931.c:3599: dissector_add_uint("lapd.sapi", LAPD_SAPI_Q931 /* 0 */, q931_handle);
svn path=/trunk/; revision=44980
2012-09-18 19:29:00 +00:00
|
|
|
break;
|
2012-09-18 19:04:04 +00:00
|
|
|
|
Revert r44978: dissector_add_uint: Legalize formerly improper use of the API when calling it with pattern value of 0
dissector_add_uint() is *not only* used by tcp.port/udp.port dissector tables where 0 is not valid port number,
in some dissector tables 0 is valid protocol number, packet type, etc..
Sample dissectors using dissector_add_uint(.pattern = 0):
packet-ansi_637.c:2348: dissector_add_uint("ansi_a.sms", 0, ansi_637_trans_handle);
packet-cip.c:6017: dissector_add_uint("cip.class.iface", 0, cip_class_generic_handle );
packet-lon.c:723: dissector_add_uint("cnip.protocol", 0, lon_handle);
packet-q931.c:3599: dissector_add_uint("lapd.sapi", LAPD_SAPI_Q931 /* 0 */, q931_handle);
svn path=/trunk/; revision=44980
2012-09-18 19:29:00 +00:00
|
|
|
default:
|
|
|
|
/*
|
|
|
|
* But you can't do a uint lookup in any other types
|
|
|
|
* of tables.
|
|
|
|
*/
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
2000-04-03 09:24:12 +00:00
|
|
|
|
2009-08-03 17:25:17 +00:00
|
|
|
#if 0
|
Revert r44978: dissector_add_uint: Legalize formerly improper use of the API when calling it with pattern value of 0
dissector_add_uint() is *not only* used by tcp.port/udp.port dissector tables where 0 is not valid port number,
in some dissector tables 0 is valid protocol number, packet type, etc..
Sample dissectors using dissector_add_uint(.pattern = 0):
packet-ansi_637.c:2348: dissector_add_uint("ansi_a.sms", 0, ansi_637_trans_handle);
packet-cip.c:6017: dissector_add_uint("cip.class.iface", 0, cip_class_generic_handle );
packet-lon.c:723: dissector_add_uint("cnip.protocol", 0, lon_handle);
packet-q931.c:3599: dissector_add_uint("lapd.sapi", LAPD_SAPI_Q931 /* 0 */, q931_handle);
svn path=/trunk/; revision=44980
2012-09-18 19:29:00 +00:00
|
|
|
dissector_add_uint_sanity_check(name, pattern, handle, sub_dissectors);
|
2009-08-03 17:25:17 +00:00
|
|
|
#endif
|
2009-10-05 18:52:46 +00:00
|
|
|
|
2013-03-14 06:46:29 +00:00
|
|
|
dtbl_entry = (dtbl_entry_t *)g_malloc(sizeof (dtbl_entry_t));
|
Revert r44978: dissector_add_uint: Legalize formerly improper use of the API when calling it with pattern value of 0
dissector_add_uint() is *not only* used by tcp.port/udp.port dissector tables where 0 is not valid port number,
in some dissector tables 0 is valid protocol number, packet type, etc..
Sample dissectors using dissector_add_uint(.pattern = 0):
packet-ansi_637.c:2348: dissector_add_uint("ansi_a.sms", 0, ansi_637_trans_handle);
packet-cip.c:6017: dissector_add_uint("cip.class.iface", 0, cip_class_generic_handle );
packet-lon.c:723: dissector_add_uint("cnip.protocol", 0, lon_handle);
packet-q931.c:3599: dissector_add_uint("lapd.sapi", LAPD_SAPI_Q931 /* 0 */, q931_handle);
svn path=/trunk/; revision=44980
2012-09-18 19:29:00 +00:00
|
|
|
dtbl_entry->current = handle;
|
|
|
|
dtbl_entry->initial = dtbl_entry->current;
|
Allow either old-style (pre-tvbuff) or new-style (tvbuffified)
dissectors to be registered as dissectors for particular ports,
registered as heuristic dissectors, and registered as dissectors for
conversations, and have routines to be used both by old-style and
new-style dissectors to call registered dissectors.
Have the code that calls those dissectors translate the arguments as
necessary. (For conversation dissectors, replace
"find_conversation_dissector()", which just returns a pointer to the
dissector, with "old_try_conversation_dissector()" and
"try_conversation_dissector()", which actually call the dissector, so
that there's a single place at which we can do that translation. Also
make "dissector_lookup()" static and, instead of calling it and, if it
returns a non-null pointer, calling that dissector, just use
"old_dissector_try_port()" or "dissector_try_port()", for the same
reason.)
This allows some dissectors that took old-style arguments and
immediately translated them to new-style arguments to just take
new-style arguments; make them do so. It also allows some new-style
dissectors not to have to translate arguments before calling routines to
look up and call dissectors; make them not do so.
Get rid of checks for too-short frames in new-style dissectors - the
tvbuff code does those checks for you.
Give the routines to register old-style dissectors, and to call
dissectors from old-style dissectors, names beginning with "old_", with
the routines for new-style dissectors not having the "old_". Update the
dissectors that use those routines appropriately.
Rename "dissect_data()" to "old_dissect_data()", and
"dissect_data_tvb()" to "dissect_data()".
svn path=/trunk/; revision=2218
2000-08-07 03:21:25 +00:00
|
|
|
|
Revert r44978: dissector_add_uint: Legalize formerly improper use of the API when calling it with pattern value of 0
dissector_add_uint() is *not only* used by tcp.port/udp.port dissector tables where 0 is not valid port number,
in some dissector tables 0 is valid protocol number, packet type, etc..
Sample dissectors using dissector_add_uint(.pattern = 0):
packet-ansi_637.c:2348: dissector_add_uint("ansi_a.sms", 0, ansi_637_trans_handle);
packet-cip.c:6017: dissector_add_uint("cip.class.iface", 0, cip_class_generic_handle );
packet-lon.c:723: dissector_add_uint("cnip.protocol", 0, lon_handle);
packet-q931.c:3599: dissector_add_uint("lapd.sapi", LAPD_SAPI_Q931 /* 0 */, q931_handle);
svn path=/trunk/; revision=44980
2012-09-18 19:29:00 +00:00
|
|
|
/* do the table insertion */
|
2018-02-08 08:31:29 +00:00
|
|
|
g_hash_table_insert(sub_dissectors->hash_table,
|
|
|
|
GUINT_TO_POINTER(pattern), (gpointer)dtbl_entry);
|
Get rid of the lists of conversation dissectors; instead, have a
dissector table contain both a hash table, to use to look up port
numbers to find a dissector, and a list of all dissectors that *could*
be assigned to ports in that hash table, to be used by user interface
code.
Make the "Decode As" dialog box code use that.
Also make it *not* let you choose whether to set the dissector for both
the UDP and TCP versions of a port; some protocols run only atop TCP,
some run only atop UDP, and even those that can run atop both may have
different dissector handles to use over TCP and UDP, so handling a
single merged list would be a mess. (If the user is setting the
dissector for a TCP port, only those protocols that Ethereal can handle
over TCP should be listed; if the user is setting the dissector for a
UDP port, only those protocols that Ethereal can handle over TCP should
be listed; if the user is setting a dissector for both, only those
protocols that Ethereal can handle over *both* TCP *and* UDP should be
listed, *and* there needs to be a way to let the "Decode As" code get
both the TCP handle *and* the UDP handle and use the right ones. If
somebody really wants that, they need to implement all of the above if
they want the code to be correct.)
Fix the code that handles setting the dissection for the IP protocol
number to correctly update the lists of protocols being dissected as TCP
and as UDP; the code before this change wasn't updating the single such
list to add new protocols.
svn path=/trunk/; revision=4311
2001-12-03 08:47:31 +00:00
|
|
|
|
|
|
|
/*
|
2016-08-30 22:51:54 +00:00
|
|
|
* Now, if this table supports "Decode As", add this handle
|
|
|
|
* to the list of handles that could be used for "Decode As"
|
|
|
|
* with this table, because it *is* being used with this table.
|
Get rid of the lists of conversation dissectors; instead, have a
dissector table contain both a hash table, to use to look up port
numbers to find a dissector, and a list of all dissectors that *could*
be assigned to ports in that hash table, to be used by user interface
code.
Make the "Decode As" dialog box code use that.
Also make it *not* let you choose whether to set the dissector for both
the UDP and TCP versions of a port; some protocols run only atop TCP,
some run only atop UDP, and even those that can run atop both may have
different dissector handles to use over TCP and UDP, so handling a
single merged list would be a mess. (If the user is setting the
dissector for a TCP port, only those protocols that Ethereal can handle
over TCP should be listed; if the user is setting the dissector for a
UDP port, only those protocols that Ethereal can handle over TCP should
be listed; if the user is setting a dissector for both, only those
protocols that Ethereal can handle over *both* TCP *and* UDP should be
listed, *and* there needs to be a way to let the "Decode As" code get
both the TCP handle *and* the UDP handle and use the right ones. If
somebody really wants that, they need to implement all of the above if
they want the code to be correct.)
Fix the code that handles setting the dissection for the IP protocol
number to correctly update the lists of protocols being dissected as TCP
and as UDP; the code before this change wasn't updating the single such
list to add new protocols.
svn path=/trunk/; revision=4311
2001-12-03 08:47:31 +00:00
|
|
|
*/
|
2016-08-30 22:51:54 +00:00
|
|
|
if (sub_dissectors->supports_decode_as)
|
|
|
|
dissector_add_for_decode_as(name, handle);
|
2000-04-03 09:24:12 +00:00
|
|
|
}
|
|
|
|
|
2013-08-25 18:48:26 +00:00
|
|
|
|
|
|
|
|
2017-10-28 02:43:47 +00:00
|
|
|
void dissector_add_uint_range(const char *name, range_t *range,
|
2013-08-29 02:05:31 +00:00
|
|
|
dissector_handle_t handle)
|
2013-08-25 18:48:26 +00:00
|
|
|
{
|
2017-10-28 02:43:47 +00:00
|
|
|
dissector_table_t sub_dissectors;
|
2013-08-29 02:05:31 +00:00
|
|
|
guint32 i, j;
|
|
|
|
|
|
|
|
if (range) {
|
2016-10-07 20:25:01 +00:00
|
|
|
if (range->nranges == 0) {
|
2017-10-28 02:43:47 +00:00
|
|
|
/*
|
|
|
|
* Even an empty range would want a chance for
|
|
|
|
* Decode As, if the dissector table supports
|
|
|
|
* it.
|
|
|
|
*/
|
|
|
|
sub_dissectors = find_dissector_table(name);
|
|
|
|
if (sub_dissectors->supports_decode_as)
|
|
|
|
dissector_add_for_decode_as(name, handle);
|
2016-10-07 20:25:01 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
for (i = 0; i < range->nranges; i++) {
|
|
|
|
for (j = range->ranges[i].low; j < range->ranges[i].high; j++)
|
2017-10-28 02:43:47 +00:00
|
|
|
dissector_add_uint(name, j, handle);
|
|
|
|
dissector_add_uint(name, range->ranges[i].high, handle);
|
2016-10-07 20:25:01 +00:00
|
|
|
}
|
2013-08-29 02:05:31 +00:00
|
|
|
}
|
|
|
|
}
|
2013-08-25 18:48:26 +00:00
|
|
|
}
|
|
|
|
|
2016-10-07 20:25:01 +00:00
|
|
|
static void
|
|
|
|
dissector_add_preference(const char *name, dissector_handle_t handle, guint init_value)
|
|
|
|
{
|
|
|
|
guint* uint_var;
|
|
|
|
module_t *module;
|
|
|
|
gchar *description, *title;
|
2018-02-08 08:31:29 +00:00
|
|
|
dissector_table_t pref_dissector_table = find_dissector_table(name);
|
2016-10-07 20:25:01 +00:00
|
|
|
int proto_id = proto_get_id(handle->protocol);
|
|
|
|
|
|
|
|
uint_var = wmem_new(wmem_epan_scope(), guint);
|
|
|
|
*uint_var = init_value;
|
|
|
|
|
|
|
|
/* If the dissector already has a preference module, use it */
|
|
|
|
module = prefs_find_module(proto_get_protocol_filter_name(proto_id));
|
|
|
|
if (module == NULL)
|
|
|
|
{
|
|
|
|
/* Otherwise create a new one */
|
|
|
|
module = prefs_register_protocol(proto_id, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
description = wmem_strdup_printf(wmem_epan_scope(), "Set the %s for %s (if other than the default of %u)",
|
|
|
|
pref_dissector_table->ui_name, proto_get_protocol_short_name(handle->protocol), *uint_var);
|
|
|
|
title = wmem_strdup_printf(wmem_epan_scope(), "%s %s", proto_get_protocol_short_name(handle->protocol),
|
|
|
|
pref_dissector_table->ui_name);
|
|
|
|
|
|
|
|
prefs_register_decode_as_preference(module, name, title, description, uint_var);
|
|
|
|
}
|
|
|
|
|
|
|
|
void dissector_add_uint_with_preference(const char *name, const guint32 pattern,
|
|
|
|
dissector_handle_t handle)
|
|
|
|
{
|
|
|
|
dissector_add_preference(name, handle, pattern);
|
|
|
|
dissector_add_uint(name, pattern, handle);
|
|
|
|
}
|
|
|
|
|
2017-10-28 02:43:47 +00:00
|
|
|
void dissector_add_uint_range_with_preference(const char *name, const char* range_str,
|
2016-10-07 20:25:01 +00:00
|
|
|
dissector_handle_t handle)
|
|
|
|
{
|
|
|
|
range_t** range;
|
|
|
|
module_t *module;
|
|
|
|
gchar *description, *title;
|
2018-02-08 08:31:29 +00:00
|
|
|
dissector_table_t pref_dissector_table = find_dissector_table(name);
|
2016-10-07 20:25:01 +00:00
|
|
|
int proto_id = proto_get_id(handle->protocol);
|
|
|
|
guint32 max_value = 0;
|
|
|
|
|
|
|
|
/* If a dissector is added for Decode As only, it's dissector
|
|
|
|
table value would default to 0.
|
|
|
|
Set up a preference value with that information
|
|
|
|
*/
|
2016-12-22 20:12:27 +00:00
|
|
|
range = wmem_new0(wmem_epan_scope(), range_t*);
|
2016-10-07 20:25:01 +00:00
|
|
|
|
|
|
|
/* If the dissector already has a preference module, use it */
|
|
|
|
module = prefs_find_module(proto_get_protocol_filter_name(proto_id));
|
|
|
|
if (module == NULL) {
|
|
|
|
/* Otherwise create a new one */
|
|
|
|
module = prefs_register_protocol(proto_id, NULL);
|
|
|
|
}
|
|
|
|
/* Some preference callback functions use the proto_reg_handoff_
|
|
|
|
routine to apply preferences, which could duplicate the
|
|
|
|
registration of a preference. Check for that here */
|
2017-10-28 02:43:47 +00:00
|
|
|
if (prefs_find_preference(module, name) == NULL) {
|
2016-10-07 20:25:01 +00:00
|
|
|
description = wmem_strdup_printf(wmem_epan_scope(), "%s %s(s)",
|
|
|
|
proto_get_protocol_short_name(handle->protocol), pref_dissector_table->ui_name);
|
|
|
|
title = wmem_strdup_printf(wmem_epan_scope(), "%s(s)", pref_dissector_table->ui_name);
|
|
|
|
|
|
|
|
/* Max value is based on datatype of dissector table */
|
|
|
|
switch (pref_dissector_table->type) {
|
|
|
|
|
|
|
|
case FT_UINT8:
|
|
|
|
max_value = 0xFF;
|
|
|
|
break;
|
|
|
|
case FT_UINT16:
|
|
|
|
max_value = 0xFFFF;
|
|
|
|
break;
|
|
|
|
case FT_UINT24:
|
|
|
|
max_value = 0xFFFFFF;
|
|
|
|
break;
|
|
|
|
case FT_UINT32:
|
|
|
|
max_value = 0xFFFFFFFF;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2017-10-28 02:43:47 +00:00
|
|
|
g_error("The dissector table %s (%s) is not an integer type - are you using a buggy plugin?", name, pref_dissector_table->ui_name);
|
2016-10-07 20:25:01 +00:00
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
|
2016-12-22 20:12:27 +00:00
|
|
|
range_convert_str(wmem_epan_scope(), range, range_str, max_value);
|
2017-10-28 02:43:47 +00:00
|
|
|
prefs_register_decode_as_range_preference(module, name, title, description, range, max_value);
|
2016-10-07 20:25:01 +00:00
|
|
|
}
|
|
|
|
|
2017-10-28 02:43:47 +00:00
|
|
|
dissector_add_uint_range(name, *range, handle);
|
2016-10-07 20:25:01 +00:00
|
|
|
}
|
|
|
|
|
2003-09-06 23:37:02 +00:00
|
|
|
/* Delete the entry for a dissector in a uint dissector table
|
|
|
|
with a particular pattern. */
|
2000-04-03 09:24:12 +00:00
|
|
|
|
|
|
|
/* NOTE: this doesn't use the dissector call variable. It is included to */
|
2010-12-20 05:35:29 +00:00
|
|
|
/* be consistant with the dissector_add_uint and more importantly to be used */
|
Add routines to:
register lists of "heuristic" dissectors, which are handed a
frame that may or may contain a payload for the protocol they
dissect, and that return FALSE if it's not or dissect the packet
and return TRUE if it is;
add a dissector to such a list;
go through such a list, calling each dissector until either a
dissector returns TRUE, in which case the routine returns TRUE,
or it runs out of entries in the list, in which case the routine
returns FALSE.
Have lists of heuristic dissectors for TCP and for COTP when used with
the Inactive Subset of CLNP, and add the GIOP and Yahoo Messenger
dissectors to the first list and the Sinec H1 dissector to the second
list.
Make the dissector name argument to "dissector_add()" and
"dissector_delete()" a "const char *" rarther than just a "char *".
Add "heur_dissector_add()", the routine to add a heuristic dissector to
a list of heuristic dissectors, to the set of routines we can export to
plugins through a table on platforms where dynamically-loaded code can't
call stuff in the main program, and initialize the element in the table
in question for "dissector_add()" (which we'd forgotten to do).
svn path=/trunk/; revision=1909
2000-05-05 09:32:36 +00:00
|
|
|
/* if the technique of adding a temporary dissector is implemented. */
|
|
|
|
/* If temporary dissectors are deleted, then the original dissector must */
|
2000-04-03 09:24:12 +00:00
|
|
|
/* be available. */
|
Add routines to:
register lists of "heuristic" dissectors, which are handed a
frame that may or may contain a payload for the protocol they
dissect, and that return FALSE if it's not or dissect the packet
and return TRUE if it is;
add a dissector to such a list;
go through such a list, calling each dissector until either a
dissector returns TRUE, in which case the routine returns TRUE,
or it runs out of entries in the list, in which case the routine
returns FALSE.
Have lists of heuristic dissectors for TCP and for COTP when used with
the Inactive Subset of CLNP, and add the GIOP and Yahoo Messenger
dissectors to the first list and the Sinec H1 dissector to the second
list.
Make the dissector name argument to "dissector_add()" and
"dissector_delete()" a "const char *" rarther than just a "char *".
Add "heur_dissector_add()", the routine to add a heuristic dissector to
a list of heuristic dissectors, to the set of routines we can export to
plugins through a table on platforms where dynamically-loaded code can't
call stuff in the main program, and initialize the element in the table
in question for "dissector_add()" (which we'd forgotten to do).
svn path=/trunk/; revision=1909
2000-05-05 09:32:36 +00:00
|
|
|
void
|
2010-12-20 05:35:29 +00:00
|
|
|
dissector_delete_uint(const char *name, const guint32 pattern,
|
2002-03-02 20:51:46 +00:00
|
|
|
dissector_handle_t handle _U_)
|
Add routines to:
register lists of "heuristic" dissectors, which are handed a
frame that may or may contain a payload for the protocol they
dissect, and that return FALSE if it's not or dissect the packet
and return TRUE if it is;
add a dissector to such a list;
go through such a list, calling each dissector until either a
dissector returns TRUE, in which case the routine returns TRUE,
or it runs out of entries in the list, in which case the routine
returns FALSE.
Have lists of heuristic dissectors for TCP and for COTP when used with
the Inactive Subset of CLNP, and add the GIOP and Yahoo Messenger
dissectors to the first list and the Sinec H1 dissector to the second
list.
Make the dissector name argument to "dissector_add()" and
"dissector_delete()" a "const char *" rarther than just a "char *".
Add "heur_dissector_add()", the routine to add a heuristic dissector to
a list of heuristic dissectors, to the set of routines we can export to
plugins through a table on platforms where dynamically-loaded code can't
call stuff in the main program, and initialize the element in the table
in question for "dissector_add()" (which we'd forgotten to do).
svn path=/trunk/; revision=1909
2000-05-05 09:32:36 +00:00
|
|
|
{
|
2018-02-08 08:31:29 +00:00
|
|
|
dissector_table_t sub_dissectors = find_dissector_table(name);
|
Allow either old-style (pre-tvbuff) or new-style (tvbuffified)
dissectors to be registered as dissectors for particular ports,
registered as heuristic dissectors, and registered as dissectors for
conversations, and have routines to be used both by old-style and
new-style dissectors to call registered dissectors.
Have the code that calls those dissectors translate the arguments as
necessary. (For conversation dissectors, replace
"find_conversation_dissector()", which just returns a pointer to the
dissector, with "old_try_conversation_dissector()" and
"try_conversation_dissector()", which actually call the dissector, so
that there's a single place at which we can do that translation. Also
make "dissector_lookup()" static and, instead of calling it and, if it
returns a non-null pointer, calling that dissector, just use
"old_dissector_try_port()" or "dissector_try_port()", for the same
reason.)
This allows some dissectors that took old-style arguments and
immediately translated them to new-style arguments to just take
new-style arguments; make them do so. It also allows some new-style
dissectors not to have to translate arguments before calling routines to
look up and call dissectors; make them not do so.
Get rid of checks for too-short frames in new-style dissectors - the
tvbuff code does those checks for you.
Give the routines to register old-style dissectors, and to call
dissectors from old-style dissectors, names beginning with "old_", with
the routines for new-style dissectors not having the "old_". Update the
dissectors that use those routines appropriately.
Rename "dissect_data()" to "old_dissect_data()", and
"dissect_data_tvb()" to "dissect_data()".
svn path=/trunk/; revision=2218
2000-08-07 03:21:25 +00:00
|
|
|
dtbl_entry_t *dtbl_entry;
|
2000-04-03 09:24:12 +00:00
|
|
|
|
2011-09-06 09:09:36 +00:00
|
|
|
/* sanity check */
|
2018-02-08 08:31:29 +00:00
|
|
|
g_assert(sub_dissectors);
|
2000-04-03 09:24:12 +00:00
|
|
|
|
Allow either old-style (pre-tvbuff) or new-style (tvbuffified)
dissectors to be registered as dissectors for particular ports,
registered as heuristic dissectors, and registered as dissectors for
conversations, and have routines to be used both by old-style and
new-style dissectors to call registered dissectors.
Have the code that calls those dissectors translate the arguments as
necessary. (For conversation dissectors, replace
"find_conversation_dissector()", which just returns a pointer to the
dissector, with "old_try_conversation_dissector()" and
"try_conversation_dissector()", which actually call the dissector, so
that there's a single place at which we can do that translation. Also
make "dissector_lookup()" static and, instead of calling it and, if it
returns a non-null pointer, calling that dissector, just use
"old_dissector_try_port()" or "dissector_try_port()", for the same
reason.)
This allows some dissectors that took old-style arguments and
immediately translated them to new-style arguments to just take
new-style arguments; make them do so. It also allows some new-style
dissectors not to have to translate arguments before calling routines to
look up and call dissectors; make them not do so.
Get rid of checks for too-short frames in new-style dissectors - the
tvbuff code does those checks for you.
Give the routines to register old-style dissectors, and to call
dissectors from old-style dissectors, names beginning with "old_", with
the routines for new-style dissectors not having the "old_". Update the
dissectors that use those routines appropriately.
Rename "dissect_data()" to "old_dissect_data()", and
"dissect_data_tvb()" to "dissect_data()".
svn path=/trunk/; revision=2218
2000-08-07 03:21:25 +00:00
|
|
|
/*
|
|
|
|
* Find the entry.
|
|
|
|
*/
|
2003-09-06 23:37:02 +00:00
|
|
|
dtbl_entry = find_uint_dtbl_entry(sub_dissectors, pattern);
|
Allow either old-style (pre-tvbuff) or new-style (tvbuffified)
dissectors to be registered as dissectors for particular ports,
registered as heuristic dissectors, and registered as dissectors for
conversations, and have routines to be used both by old-style and
new-style dissectors to call registered dissectors.
Have the code that calls those dissectors translate the arguments as
necessary. (For conversation dissectors, replace
"find_conversation_dissector()", which just returns a pointer to the
dissector, with "old_try_conversation_dissector()" and
"try_conversation_dissector()", which actually call the dissector, so
that there's a single place at which we can do that translation. Also
make "dissector_lookup()" static and, instead of calling it and, if it
returns a non-null pointer, calling that dissector, just use
"old_dissector_try_port()" or "dissector_try_port()", for the same
reason.)
This allows some dissectors that took old-style arguments and
immediately translated them to new-style arguments to just take
new-style arguments; make them do so. It also allows some new-style
dissectors not to have to translate arguments before calling routines to
look up and call dissectors; make them not do so.
Get rid of checks for too-short frames in new-style dissectors - the
tvbuff code does those checks for you.
Give the routines to register old-style dissectors, and to call
dissectors from old-style dissectors, names beginning with "old_", with
the routines for new-style dissectors not having the "old_". Update the
dissectors that use those routines appropriately.
Rename "dissect_data()" to "old_dissect_data()", and
"dissect_data_tvb()" to "dissect_data()".
svn path=/trunk/; revision=2218
2000-08-07 03:21:25 +00:00
|
|
|
|
|
|
|
if (dtbl_entry != NULL) {
|
|
|
|
/*
|
|
|
|
* Found - remove it.
|
|
|
|
*/
|
Get rid of the lists of conversation dissectors; instead, have a
dissector table contain both a hash table, to use to look up port
numbers to find a dissector, and a list of all dissectors that *could*
be assigned to ports in that hash table, to be used by user interface
code.
Make the "Decode As" dialog box code use that.
Also make it *not* let you choose whether to set the dissector for both
the UDP and TCP versions of a port; some protocols run only atop TCP,
some run only atop UDP, and even those that can run atop both may have
different dissector handles to use over TCP and UDP, so handling a
single merged list would be a mess. (If the user is setting the
dissector for a TCP port, only those protocols that Ethereal can handle
over TCP should be listed; if the user is setting the dissector for a
UDP port, only those protocols that Ethereal can handle over TCP should
be listed; if the user is setting a dissector for both, only those
protocols that Ethereal can handle over *both* TCP *and* UDP should be
listed, *and* there needs to be a way to let the "Decode As" code get
both the TCP handle *and* the UDP handle and use the right ones. If
somebody really wants that, they need to implement all of the above if
they want the code to be correct.)
Fix the code that handles setting the dissection for the IP protocol
number to correctly update the lists of protocols being dissected as TCP
and as UDP; the code before this change wasn't updating the single such
list to add new protocols.
svn path=/trunk/; revision=4311
2001-12-03 08:47:31 +00:00
|
|
|
g_hash_table_remove(sub_dissectors->hash_table,
|
2009-10-12 01:31:01 +00:00
|
|
|
GUINT_TO_POINTER(pattern));
|
Allow either old-style (pre-tvbuff) or new-style (tvbuffified)
dissectors to be registered as dissectors for particular ports,
registered as heuristic dissectors, and registered as dissectors for
conversations, and have routines to be used both by old-style and
new-style dissectors to call registered dissectors.
Have the code that calls those dissectors translate the arguments as
necessary. (For conversation dissectors, replace
"find_conversation_dissector()", which just returns a pointer to the
dissector, with "old_try_conversation_dissector()" and
"try_conversation_dissector()", which actually call the dissector, so
that there's a single place at which we can do that translation. Also
make "dissector_lookup()" static and, instead of calling it and, if it
returns a non-null pointer, calling that dissector, just use
"old_dissector_try_port()" or "dissector_try_port()", for the same
reason.)
This allows some dissectors that took old-style arguments and
immediately translated them to new-style arguments to just take
new-style arguments; make them do so. It also allows some new-style
dissectors not to have to translate arguments before calling routines to
look up and call dissectors; make them not do so.
Get rid of checks for too-short frames in new-style dissectors - the
tvbuff code does those checks for you.
Give the routines to register old-style dissectors, and to call
dissectors from old-style dissectors, names beginning with "old_", with
the routines for new-style dissectors not having the "old_". Update the
dissectors that use those routines appropriately.
Rename "dissect_data()" to "old_dissect_data()", and
"dissect_data_tvb()" to "dissect_data()".
svn path=/trunk/; revision=2218
2000-08-07 03:21:25 +00:00
|
|
|
}
|
2000-04-03 09:24:12 +00:00
|
|
|
}
|
|
|
|
|
2017-10-28 02:43:47 +00:00
|
|
|
void dissector_delete_uint_range(const char *name, range_t *range,
|
2013-08-29 02:05:31 +00:00
|
|
|
dissector_handle_t handle)
|
2013-08-25 18:48:26 +00:00
|
|
|
{
|
2013-08-29 02:05:31 +00:00
|
|
|
guint32 i, j;
|
|
|
|
|
|
|
|
if (range) {
|
|
|
|
for (i = 0; i < range->nranges; i++) {
|
2016-01-09 14:27:14 +00:00
|
|
|
for (j = range->ranges[i].low; j < range->ranges[i].high; j++)
|
2017-10-28 02:43:47 +00:00
|
|
|
dissector_delete_uint(name, j, handle);
|
|
|
|
dissector_delete_uint(name, range->ranges[i].high, handle);
|
2013-08-29 02:05:31 +00:00
|
|
|
}
|
|
|
|
}
|
2013-08-25 18:48:26 +00:00
|
|
|
}
|
|
|
|
|
2013-09-09 05:36:45 +00:00
|
|
|
static gboolean
|
|
|
|
dissector_delete_all_check (gpointer key _U_, gpointer value, gpointer user_data)
|
|
|
|
{
|
2013-09-09 05:51:35 +00:00
|
|
|
dtbl_entry_t *dtbl_entry = (dtbl_entry_t *) value;
|
2013-09-09 06:41:03 +00:00
|
|
|
dissector_handle_t handle = (dissector_handle_t) user_data;
|
2013-09-09 05:36:45 +00:00
|
|
|
|
2015-08-11 12:08:08 +00:00
|
|
|
if (!dtbl_entry->current->protocol) {
|
|
|
|
/*
|
|
|
|
* Not all dissectors are registered with a protocol, so we need this
|
|
|
|
* check when running from dissector_delete_from_all_tables.
|
|
|
|
*/
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2013-09-09 05:36:45 +00:00
|
|
|
return (proto_get_id (dtbl_entry->current->protocol) == proto_get_id (handle->protocol));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Delete all entries from a dissector table. */
|
|
|
|
void dissector_delete_all(const char *name, dissector_handle_t handle)
|
|
|
|
{
|
|
|
|
dissector_table_t sub_dissectors = find_dissector_table(name);
|
|
|
|
g_assert (sub_dissectors);
|
|
|
|
|
|
|
|
g_hash_table_foreach_remove (sub_dissectors->hash_table, dissector_delete_all_check, handle);
|
|
|
|
}
|
|
|
|
|
2015-08-11 12:08:08 +00:00
|
|
|
static void
|
|
|
|
dissector_delete_from_table(gpointer key _U_, gpointer value, gpointer user_data)
|
|
|
|
{
|
|
|
|
dissector_table_t sub_dissectors = (dissector_table_t) value;
|
|
|
|
g_assert (sub_dissectors);
|
|
|
|
|
|
|
|
g_hash_table_foreach_remove(sub_dissectors->hash_table, dissector_delete_all_check, user_data);
|
|
|
|
sub_dissectors->dissector_handles = g_slist_remove(sub_dissectors->dissector_handles, user_data);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Delete handle from all tables and dissector_handles lists */
|
|
|
|
static void
|
|
|
|
dissector_delete_from_all_tables(dissector_handle_t handle)
|
|
|
|
{
|
|
|
|
g_hash_table_foreach(dissector_tables, dissector_delete_from_table, handle);
|
|
|
|
}
|
|
|
|
|
2003-09-06 23:37:02 +00:00
|
|
|
/* Change the entry for a dissector in a uint dissector table
|
|
|
|
with a particular pattern to use a new dissector handle. */
|
2001-02-01 07:34:33 +00:00
|
|
|
void
|
2010-12-20 05:35:29 +00:00
|
|
|
dissector_change_uint(const char *name, const guint32 pattern, dissector_handle_t handle)
|
2001-02-01 07:34:33 +00:00
|
|
|
{
|
2018-02-08 08:31:29 +00:00
|
|
|
dissector_table_t sub_dissectors = find_dissector_table(name);
|
2001-02-01 07:34:33 +00:00
|
|
|
dtbl_entry_t *dtbl_entry;
|
|
|
|
|
2011-09-06 09:09:36 +00:00
|
|
|
/* sanity check */
|
2018-02-08 08:31:29 +00:00
|
|
|
g_assert(sub_dissectors);
|
2001-02-01 07:34:33 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* See if the entry already exists. If so, reuse it.
|
|
|
|
*/
|
2003-09-06 23:37:02 +00:00
|
|
|
dtbl_entry = find_uint_dtbl_entry(sub_dissectors, pattern);
|
2001-02-01 07:34:33 +00:00
|
|
|
if (dtbl_entry != NULL) {
|
2012-01-20 02:43:37 +00:00
|
|
|
dtbl_entry->current = handle;
|
|
|
|
return;
|
2001-02-01 07:34:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2001-12-03 04:00:26 +00:00
|
|
|
* Don't create an entry if there is no dissector handle - I.E. the
|
2001-02-01 07:34:33 +00:00
|
|
|
* user said not to decode something that wasn't being decoded
|
|
|
|
* in the first place.
|
|
|
|
*/
|
2001-12-03 04:00:26 +00:00
|
|
|
if (handle == NULL)
|
2012-01-20 02:43:37 +00:00
|
|
|
return;
|
2001-02-01 07:34:33 +00:00
|
|
|
|
2013-03-14 06:46:29 +00:00
|
|
|
dtbl_entry = (dtbl_entry_t *)g_malloc(sizeof (dtbl_entry_t));
|
2001-12-03 04:00:26 +00:00
|
|
|
dtbl_entry->initial = NULL;
|
|
|
|
dtbl_entry->current = handle;
|
2001-02-01 07:34:33 +00:00
|
|
|
|
2011-09-06 09:09:36 +00:00
|
|
|
/* do the table insertion */
|
2018-02-08 08:31:29 +00:00
|
|
|
g_hash_table_insert(sub_dissectors->hash_table,
|
|
|
|
GUINT_TO_POINTER(pattern), (gpointer)dtbl_entry);
|
2001-02-01 07:34:33 +00:00
|
|
|
}
|
|
|
|
|
2003-09-06 23:37:02 +00:00
|
|
|
/* Reset an entry in a uint dissector table to its initial value. */
|
2001-02-01 07:34:33 +00:00
|
|
|
void
|
2010-12-20 05:35:29 +00:00
|
|
|
dissector_reset_uint(const char *name, const guint32 pattern)
|
2001-02-01 07:34:33 +00:00
|
|
|
{
|
2018-02-08 08:31:29 +00:00
|
|
|
dissector_table_t sub_dissectors = find_dissector_table(name);
|
2012-01-20 02:43:37 +00:00
|
|
|
dtbl_entry_t *dtbl_entry;
|
2001-02-01 07:34:33 +00:00
|
|
|
|
2011-09-06 09:09:36 +00:00
|
|
|
/* sanity check */
|
2018-02-08 08:31:29 +00:00
|
|
|
g_assert(sub_dissectors);
|
2001-02-01 07:34:33 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Find the entry.
|
|
|
|
*/
|
2003-09-06 23:37:02 +00:00
|
|
|
dtbl_entry = find_uint_dtbl_entry(sub_dissectors, pattern);
|
2001-02-01 07:34:33 +00:00
|
|
|
|
|
|
|
if (dtbl_entry == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Found - is there an initial value?
|
|
|
|
*/
|
2001-12-03 04:00:26 +00:00
|
|
|
if (dtbl_entry->initial != NULL) {
|
2001-02-01 07:34:33 +00:00
|
|
|
dtbl_entry->current = dtbl_entry->initial;
|
|
|
|
} else {
|
Get rid of the lists of conversation dissectors; instead, have a
dissector table contain both a hash table, to use to look up port
numbers to find a dissector, and a list of all dissectors that *could*
be assigned to ports in that hash table, to be used by user interface
code.
Make the "Decode As" dialog box code use that.
Also make it *not* let you choose whether to set the dissector for both
the UDP and TCP versions of a port; some protocols run only atop TCP,
some run only atop UDP, and even those that can run atop both may have
different dissector handles to use over TCP and UDP, so handling a
single merged list would be a mess. (If the user is setting the
dissector for a TCP port, only those protocols that Ethereal can handle
over TCP should be listed; if the user is setting the dissector for a
UDP port, only those protocols that Ethereal can handle over TCP should
be listed; if the user is setting a dissector for both, only those
protocols that Ethereal can handle over *both* TCP *and* UDP should be
listed, *and* there needs to be a way to let the "Decode As" code get
both the TCP handle *and* the UDP handle and use the right ones. If
somebody really wants that, they need to implement all of the above if
they want the code to be correct.)
Fix the code that handles setting the dissection for the IP protocol
number to correctly update the lists of protocols being dissected as TCP
and as UDP; the code before this change wasn't updating the single such
list to add new protocols.
svn path=/trunk/; revision=4311
2001-12-03 08:47:31 +00:00
|
|
|
g_hash_table_remove(sub_dissectors->hash_table,
|
2009-10-12 01:31:01 +00:00
|
|
|
GUINT_TO_POINTER(pattern));
|
2001-02-01 07:34:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-09-06 23:37:02 +00:00
|
|
|
/* Look for a given value in a given uint dissector table and, if found,
|
2017-04-17 15:55:09 +00:00
|
|
|
call the dissector with the arguments supplied, and return the number
|
|
|
|
of bytes consumed by the dissector, otherwise return 0. */
|
2009-04-21 16:53:00 +00:00
|
|
|
|
2014-10-06 13:17:46 +00:00
|
|
|
int
|
2010-12-20 05:35:29 +00:00
|
|
|
dissector_try_uint_new(dissector_table_t sub_dissectors, const guint32 uint_val,
|
2012-10-12 21:37:02 +00:00
|
|
|
tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
2012-09-11 09:06:48 +00:00
|
|
|
const gboolean add_proto_name, void *data)
|
Allow either old-style (pre-tvbuff) or new-style (tvbuffified)
dissectors to be registered as dissectors for particular ports,
registered as heuristic dissectors, and registered as dissectors for
conversations, and have routines to be used both by old-style and
new-style dissectors to call registered dissectors.
Have the code that calls those dissectors translate the arguments as
necessary. (For conversation dissectors, replace
"find_conversation_dissector()", which just returns a pointer to the
dissector, with "old_try_conversation_dissector()" and
"try_conversation_dissector()", which actually call the dissector, so
that there's a single place at which we can do that translation. Also
make "dissector_lookup()" static and, instead of calling it and, if it
returns a non-null pointer, calling that dissector, just use
"old_dissector_try_port()" or "dissector_try_port()", for the same
reason.)
This allows some dissectors that took old-style arguments and
immediately translated them to new-style arguments to just take
new-style arguments; make them do so. It also allows some new-style
dissectors not to have to translate arguments before calling routines to
look up and call dissectors; make them not do so.
Get rid of checks for too-short frames in new-style dissectors - the
tvbuff code does those checks for you.
Give the routines to register old-style dissectors, and to call
dissectors from old-style dissectors, names beginning with "old_", with
the routines for new-style dissectors not having the "old_". Update the
dissectors that use those routines appropriately.
Rename "dissect_data()" to "old_dissect_data()", and
"dissect_data_tvb()" to "dissect_data()".
svn path=/trunk/; revision=2218
2000-08-07 03:21:25 +00:00
|
|
|
{
|
2012-01-20 02:43:37 +00:00
|
|
|
dtbl_entry_t *dtbl_entry;
|
2002-02-26 11:55:39 +00:00
|
|
|
struct dissector_handle *handle;
|
2012-01-20 02:43:37 +00:00
|
|
|
guint32 saved_match_uint;
|
2014-10-06 13:17:46 +00:00
|
|
|
int len;
|
2001-11-29 09:05:25 +00:00
|
|
|
|
2010-12-20 05:35:29 +00:00
|
|
|
dtbl_entry = find_uint_dtbl_entry(sub_dissectors, uint_val);
|
2017-04-17 16:00:27 +00:00
|
|
|
if (dtbl_entry == NULL) {
|
2001-12-03 04:00:26 +00:00
|
|
|
/*
|
2017-04-17 16:00:27 +00:00
|
|
|
* There's no entry in the table for our value.
|
2001-12-03 04:00:26 +00:00
|
|
|
*/
|
2017-04-17 16:00:27 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2002-02-26 11:55:39 +00:00
|
|
|
|
2017-04-17 16:00:27 +00:00
|
|
|
/*
|
|
|
|
* Is there currently a dissector handle for this entry?
|
|
|
|
*/
|
|
|
|
handle = dtbl_entry->current;
|
|
|
|
if (handle == NULL) {
|
2002-02-26 11:55:39 +00:00
|
|
|
/*
|
2017-04-17 16:00:27 +00:00
|
|
|
* No - pretend this dissector didn't exist,
|
|
|
|
* so that other dissectors might have a chance
|
|
|
|
* to dissect this packet.
|
2002-02-26 11:55:39 +00:00
|
|
|
*/
|
2017-04-17 16:00:27 +00:00
|
|
|
return 0;
|
2002-08-28 20:41:00 +00:00
|
|
|
}
|
2017-04-17 16:00:27 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Save the current value of "pinfo->match_uint",
|
|
|
|
* set it to the uint_val that matched, call the
|
|
|
|
* dissector, and restore "pinfo->match_uint".
|
|
|
|
*/
|
|
|
|
saved_match_uint = pinfo->match_uint;
|
|
|
|
pinfo->match_uint = uint_val;
|
|
|
|
len = call_dissector_work(handle, tvb, pinfo, tree, add_proto_name, data);
|
|
|
|
pinfo->match_uint = saved_match_uint;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If a new-style dissector returned 0, it means that
|
|
|
|
* it didn't think this tvbuff represented a packet for
|
|
|
|
* its protocol, and didn't dissect anything.
|
|
|
|
*
|
|
|
|
* Old-style dissectors can't reject the packet.
|
|
|
|
*
|
|
|
|
* 0 is also returned if the protocol wasn't enabled.
|
|
|
|
*
|
|
|
|
* If the packet was rejected, we return 0, so that
|
|
|
|
* other dissectors might have a chance to dissect this
|
|
|
|
* packet, otherwise we return the dissected length.
|
|
|
|
*/
|
|
|
|
return len;
|
Make a routine that takes a dissector table, a port number, and
pd/offset/fd/tree arguments, looks up the port number in the dissector
table, and:
if it finds it, call the corresponding dissector routine with
the pd/offset/fd/tree arguments, and return TRUE;
if it doesn't find it, return FALSE.
Use that in the TCP and UDP dissectors.
Don't add arbitrary UDP ports for which a dissector is found in the
table as ports that should be dissected as TFTP; this should only be
done if we find a packet going from port XXX to the official TFTP port.
Don't register TFTP in UDP's dissector table, as it has to be handled
specially (i.e., we have to add the source port as a TFTP port, although
we really should register the source port *and* IP address); eventually,
we should move that registration to the TFTP dissector itself, at which
point we can register TFTP normally.
svn path=/trunk/; revision=1785
2000-04-04 05:37:36 +00:00
|
|
|
}
|
2000-04-03 09:24:12 +00:00
|
|
|
|
2014-10-06 13:17:46 +00:00
|
|
|
int
|
2010-12-20 05:35:29 +00:00
|
|
|
dissector_try_uint(dissector_table_t sub_dissectors, const guint32 uint_val,
|
2009-10-12 01:31:01 +00:00
|
|
|
tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
|
2009-04-21 16:53:00 +00:00
|
|
|
{
|
|
|
|
|
2012-09-11 09:06:48 +00:00
|
|
|
return dissector_try_uint_new(sub_dissectors, uint_val, tvb, pinfo, tree, TRUE, NULL);
|
2009-04-21 16:53:00 +00:00
|
|
|
}
|
2010-12-20 05:35:29 +00:00
|
|
|
|
2003-09-06 23:37:02 +00:00
|
|
|
/* Look for a given value in a given uint dissector table and, if found,
|
|
|
|
return the dissector handle for that value. */
|
2001-12-03 05:07:18 +00:00
|
|
|
dissector_handle_t
|
2010-12-20 05:35:29 +00:00
|
|
|
dissector_get_uint_handle(dissector_table_t const sub_dissectors, const guint32 uint_val)
|
2001-12-03 05:07:18 +00:00
|
|
|
{
|
|
|
|
dtbl_entry_t *dtbl_entry;
|
|
|
|
|
2010-12-20 05:35:29 +00:00
|
|
|
dtbl_entry = find_uint_dtbl_entry(sub_dissectors, uint_val);
|
2001-12-03 05:07:18 +00:00
|
|
|
if (dtbl_entry != NULL)
|
|
|
|
return dtbl_entry->current;
|
|
|
|
else
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-12-10 19:23:26 +00:00
|
|
|
dissector_handle_t
|
|
|
|
dissector_get_default_uint_handle(const char *name, const guint32 uint_val)
|
|
|
|
{
|
|
|
|
dissector_table_t sub_dissectors = find_dissector_table(name);
|
|
|
|
|
|
|
|
if (sub_dissectors != NULL) {
|
|
|
|
dtbl_entry_t *dtbl_entry = find_uint_dtbl_entry(sub_dissectors, uint_val);
|
|
|
|
if (dtbl_entry != NULL)
|
|
|
|
return dtbl_entry->initial;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2005-01-19 04:49:29 +00:00
|
|
|
/* Find an entry in a string dissector table. */
|
2003-09-06 23:37:02 +00:00
|
|
|
static dtbl_entry_t *
|
2010-04-03 18:18:50 +00:00
|
|
|
find_string_dtbl_entry(dissector_table_t const sub_dissectors, const gchar *pattern)
|
2003-09-06 23:37:02 +00:00
|
|
|
{
|
2014-12-10 02:35:01 +00:00
|
|
|
dtbl_entry_t *ret;
|
|
|
|
char *key;
|
|
|
|
|
2003-09-06 23:37:02 +00:00
|
|
|
switch (sub_dissectors->type) {
|
|
|
|
|
|
|
|
case FT_STRING:
|
|
|
|
case FT_STRINGZ:
|
2014-04-12 22:26:34 +00:00
|
|
|
case FT_STRINGZPAD:
|
2003-09-06 23:37:02 +00:00
|
|
|
/*
|
|
|
|
* You can do a string lookup in these tables.
|
|
|
|
*/
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
/*
|
|
|
|
* But you can't do a string lookup in any other types
|
|
|
|
* of tables.
|
|
|
|
*/
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
|
2014-12-10 02:35:01 +00:00
|
|
|
if (sub_dissectors->param == TRUE) {
|
|
|
|
key = g_ascii_strdown(pattern, -1);
|
|
|
|
} else {
|
|
|
|
key = g_strdup(pattern);
|
|
|
|
}
|
|
|
|
|
2003-09-06 23:37:02 +00:00
|
|
|
/*
|
|
|
|
* Find the entry.
|
|
|
|
*/
|
2014-12-10 02:35:01 +00:00
|
|
|
ret = (dtbl_entry_t *)g_hash_table_lookup(sub_dissectors->hash_table, key);
|
|
|
|
|
|
|
|
g_free(key);
|
|
|
|
|
|
|
|
return ret;
|
2003-09-06 23:37:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Add an entry to a string dissector table. */
|
|
|
|
void
|
2005-07-23 11:41:25 +00:00
|
|
|
dissector_add_string(const char *name, const gchar *pattern,
|
2009-10-12 01:31:01 +00:00
|
|
|
dissector_handle_t handle)
|
2003-09-06 23:37:02 +00:00
|
|
|
{
|
2018-02-08 08:31:29 +00:00
|
|
|
dissector_table_t sub_dissectors = find_dissector_table(name);
|
2012-01-20 02:43:37 +00:00
|
|
|
dtbl_entry_t *dtbl_entry;
|
2014-12-10 02:35:01 +00:00
|
|
|
char *key;
|
2003-09-06 23:37:02 +00:00
|
|
|
|
2011-06-01 18:02:16 +00:00
|
|
|
/*
|
2016-06-21 18:21:33 +00:00
|
|
|
* Make sure the handle and the dissector table exist.
|
2011-06-01 18:02:16 +00:00
|
|
|
*/
|
2016-06-21 18:21:33 +00:00
|
|
|
if (handle == NULL) {
|
|
|
|
fprintf(stderr, "OOPS: handle to register \"%s\" to doesn't exist\n",
|
|
|
|
name);
|
|
|
|
if (getenv("WIRESHARK_ABORT_ON_DISSECTOR_BUG") != NULL)
|
|
|
|
abort();
|
|
|
|
return;
|
|
|
|
}
|
2011-06-01 18:02:16 +00:00
|
|
|
if (sub_dissectors == NULL) {
|
|
|
|
fprintf(stderr, "OOPS: dissector table \"%s\" doesn't exist\n",
|
|
|
|
name);
|
|
|
|
fprintf(stderr, "Protocol being registered is \"%s\"\n",
|
|
|
|
proto_get_protocol_long_name(handle->protocol));
|
|
|
|
if (getenv("WIRESHARK_ABORT_ON_DISSECTOR_BUG") != NULL)
|
|
|
|
abort();
|
|
|
|
return;
|
|
|
|
}
|
2003-09-06 23:37:02 +00:00
|
|
|
|
|
|
|
switch (sub_dissectors->type) {
|
|
|
|
|
|
|
|
case FT_STRING:
|
|
|
|
case FT_STRINGZ:
|
2014-04-12 22:26:34 +00:00
|
|
|
case FT_STRINGZPAD:
|
2003-09-06 23:37:02 +00:00
|
|
|
/*
|
|
|
|
* You can do a string lookup in these tables.
|
|
|
|
*/
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
/*
|
|
|
|
* But you can't do a string lookup in any other types
|
|
|
|
* of tables.
|
|
|
|
*/
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
|
2013-03-14 06:46:29 +00:00
|
|
|
dtbl_entry = (dtbl_entry_t *)g_malloc(sizeof (dtbl_entry_t));
|
2003-09-06 23:37:02 +00:00
|
|
|
dtbl_entry->current = handle;
|
|
|
|
dtbl_entry->initial = dtbl_entry->current;
|
|
|
|
|
2014-12-10 02:35:01 +00:00
|
|
|
if (sub_dissectors->param == TRUE) {
|
|
|
|
key = g_ascii_strdown(pattern, -1);
|
|
|
|
} else {
|
|
|
|
key = g_strdup(pattern);
|
|
|
|
}
|
|
|
|
|
2011-09-06 09:09:36 +00:00
|
|
|
/* do the table insertion */
|
2018-02-08 08:31:29 +00:00
|
|
|
g_hash_table_insert(sub_dissectors->hash_table, (gpointer)key,
|
2009-10-12 01:31:01 +00:00
|
|
|
(gpointer)dtbl_entry);
|
2003-09-06 23:37:02 +00:00
|
|
|
|
|
|
|
/*
|
2016-08-30 22:51:54 +00:00
|
|
|
* Now, if this table supports "Decode As", add this handle
|
|
|
|
* to the list of handles that could be used for "Decode As"
|
|
|
|
* with this table, because it *is* being used with this table.
|
2003-09-06 23:37:02 +00:00
|
|
|
*/
|
2016-08-30 22:51:54 +00:00
|
|
|
if (sub_dissectors->supports_decode_as)
|
|
|
|
dissector_add_for_decode_as(name, handle);
|
2003-09-06 23:37:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Delete the entry for a dissector in a string dissector table
|
|
|
|
with a particular pattern. */
|
|
|
|
|
|
|
|
/* NOTE: this doesn't use the dissector call variable. It is included to */
|
|
|
|
/* be consistant with the dissector_add_string and more importantly to */
|
|
|
|
/* be used if the technique of adding a temporary dissector is */
|
|
|
|
/* implemented. */
|
|
|
|
/* If temporary dissectors are deleted, then the original dissector must */
|
|
|
|
/* be available. */
|
|
|
|
void
|
|
|
|
dissector_delete_string(const char *name, const gchar *pattern,
|
|
|
|
dissector_handle_t handle _U_)
|
|
|
|
{
|
2018-02-08 08:31:29 +00:00
|
|
|
dissector_table_t sub_dissectors = find_dissector_table(name);
|
2012-01-20 02:43:37 +00:00
|
|
|
dtbl_entry_t *dtbl_entry;
|
2003-09-06 23:37:02 +00:00
|
|
|
|
2011-09-06 09:09:36 +00:00
|
|
|
/* sanity check */
|
2018-02-08 08:31:29 +00:00
|
|
|
g_assert(sub_dissectors);
|
2003-09-06 23:37:02 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Find the entry.
|
|
|
|
*/
|
|
|
|
dtbl_entry = find_string_dtbl_entry(sub_dissectors, pattern);
|
|
|
|
|
|
|
|
if (dtbl_entry != NULL) {
|
|
|
|
/*
|
|
|
|
* Found - remove it.
|
|
|
|
*/
|
|
|
|
g_hash_table_remove(sub_dissectors->hash_table, pattern);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Change the entry for a dissector in a string dissector table
|
|
|
|
with a particular pattern to use a new dissector handle. */
|
|
|
|
void
|
2010-02-23 04:35:23 +00:00
|
|
|
dissector_change_string(const char *name, const gchar *pattern,
|
2009-10-12 01:31:01 +00:00
|
|
|
dissector_handle_t handle)
|
2003-09-06 23:37:02 +00:00
|
|
|
{
|
2018-02-08 08:31:29 +00:00
|
|
|
dissector_table_t sub_dissectors = find_dissector_table(name);
|
2012-01-20 02:43:37 +00:00
|
|
|
dtbl_entry_t *dtbl_entry;
|
2003-09-06 23:37:02 +00:00
|
|
|
|
2011-09-06 09:09:36 +00:00
|
|
|
/* sanity check */
|
2018-02-08 08:31:29 +00:00
|
|
|
g_assert(sub_dissectors);
|
2003-09-06 23:37:02 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* See if the entry already exists. If so, reuse it.
|
|
|
|
*/
|
|
|
|
dtbl_entry = find_string_dtbl_entry(sub_dissectors, pattern);
|
|
|
|
if (dtbl_entry != NULL) {
|
2012-01-20 02:43:37 +00:00
|
|
|
dtbl_entry->current = handle;
|
|
|
|
return;
|
2003-09-06 23:37:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Don't create an entry if there is no dissector handle - I.E. the
|
|
|
|
* user said not to decode something that wasn't being decoded
|
|
|
|
* in the first place.
|
|
|
|
*/
|
|
|
|
if (handle == NULL)
|
2012-01-20 02:43:37 +00:00
|
|
|
return;
|
2003-09-06 23:37:02 +00:00
|
|
|
|
2013-03-14 06:46:29 +00:00
|
|
|
dtbl_entry = (dtbl_entry_t *)g_malloc(sizeof (dtbl_entry_t));
|
2003-09-06 23:37:02 +00:00
|
|
|
dtbl_entry->initial = NULL;
|
|
|
|
dtbl_entry->current = handle;
|
|
|
|
|
2011-09-06 09:09:36 +00:00
|
|
|
/* do the table insertion */
|
2018-02-08 08:31:29 +00:00
|
|
|
g_hash_table_insert(sub_dissectors->hash_table, (gpointer)g_strdup(pattern),
|
2009-10-12 01:31:01 +00:00
|
|
|
(gpointer)dtbl_entry);
|
2003-09-06 23:37:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Reset an entry in a string sub-dissector table to its initial value. */
|
|
|
|
void
|
|
|
|
dissector_reset_string(const char *name, const gchar *pattern)
|
|
|
|
{
|
2018-02-08 08:31:29 +00:00
|
|
|
dissector_table_t sub_dissectors = find_dissector_table(name);
|
2012-01-20 02:43:37 +00:00
|
|
|
dtbl_entry_t *dtbl_entry;
|
2003-09-06 23:37:02 +00:00
|
|
|
|
2011-09-06 09:09:36 +00:00
|
|
|
/* sanity check */
|
2018-02-08 08:31:29 +00:00
|
|
|
g_assert(sub_dissectors);
|
2003-09-06 23:37:02 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Find the entry.
|
|
|
|
*/
|
|
|
|
dtbl_entry = find_string_dtbl_entry(sub_dissectors, pattern);
|
|
|
|
|
|
|
|
if (dtbl_entry == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Found - is there an initial value?
|
|
|
|
*/
|
|
|
|
if (dtbl_entry->initial != NULL) {
|
|
|
|
dtbl_entry->current = dtbl_entry->initial;
|
|
|
|
} else {
|
|
|
|
g_hash_table_remove(sub_dissectors->hash_table, pattern);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Look for a given string in a given dissector table and, if found, call
|
2014-10-11 20:39:17 +00:00
|
|
|
the dissector with the arguments supplied, and return length of dissected data,
|
|
|
|
otherwise return 0. */
|
2014-10-06 13:17:46 +00:00
|
|
|
int
|
2017-12-19 00:55:37 +00:00
|
|
|
dissector_try_string_new(dissector_table_t sub_dissectors, const gchar *string,
|
|
|
|
tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, const gboolean add_proto_name, void *data)
|
2013-10-30 04:06:54 +00:00
|
|
|
{
|
|
|
|
dtbl_entry_t *dtbl_entry;
|
|
|
|
struct dissector_handle *handle;
|
2014-10-06 13:17:46 +00:00
|
|
|
int len;
|
2013-10-30 04:06:54 +00:00
|
|
|
const gchar *saved_match_string;
|
|
|
|
|
|
|
|
/* XXX ASSERT instead ? */
|
2014-10-06 13:17:46 +00:00
|
|
|
if (!string) return 0;
|
2013-10-30 04:06:54 +00:00
|
|
|
dtbl_entry = find_string_dtbl_entry(sub_dissectors, string);
|
|
|
|
if (dtbl_entry != NULL) {
|
|
|
|
/*
|
|
|
|
* Is there currently a dissector handle for this entry?
|
|
|
|
*/
|
|
|
|
handle = dtbl_entry->current;
|
|
|
|
if (handle == NULL) {
|
|
|
|
/*
|
|
|
|
* No - pretend this dissector didn't exist,
|
|
|
|
* so that other dissectors might have a chance
|
|
|
|
* to dissect this packet.
|
|
|
|
*/
|
2014-10-06 13:17:46 +00:00
|
|
|
return 0;
|
2013-10-30 04:06:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Save the current value of "pinfo->match_string",
|
|
|
|
* set it to the string that matched, call the
|
|
|
|
* dissector, and restore "pinfo->match_string".
|
|
|
|
*/
|
|
|
|
saved_match_string = pinfo->match_string;
|
|
|
|
pinfo->match_string = string;
|
2017-12-19 00:55:37 +00:00
|
|
|
len = call_dissector_work(handle, tvb, pinfo, tree, add_proto_name, data);
|
2013-10-30 04:06:54 +00:00
|
|
|
pinfo->match_string = saved_match_string;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If a new-style dissector returned 0, it means that
|
|
|
|
* it didn't think this tvbuff represented a packet for
|
|
|
|
* its protocol, and didn't dissect anything.
|
|
|
|
*
|
|
|
|
* Old-style dissectors can't reject the packet.
|
|
|
|
*
|
|
|
|
* 0 is also returned if the protocol wasn't enabled.
|
|
|
|
*
|
2014-10-06 13:17:46 +00:00
|
|
|
* If the packet was rejected, we return 0, so that
|
2013-10-30 04:06:54 +00:00
|
|
|
* other dissectors might have a chance to dissect this
|
2014-10-06 13:17:46 +00:00
|
|
|
* packet, otherwise we return the dissected length.
|
2013-10-30 04:06:54 +00:00
|
|
|
*/
|
2014-10-06 13:17:46 +00:00
|
|
|
return len;
|
2013-10-30 04:06:54 +00:00
|
|
|
}
|
2014-10-06 13:17:46 +00:00
|
|
|
return 0;
|
2013-10-30 04:06:54 +00:00
|
|
|
}
|
|
|
|
|
2017-12-19 00:55:37 +00:00
|
|
|
int
|
|
|
|
dissector_try_string(dissector_table_t sub_dissectors, const gchar *string,
|
|
|
|
tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
|
|
|
|
{
|
|
|
|
return dissector_try_string_new(sub_dissectors, string, tvb, pinfo, tree, TRUE, data);
|
|
|
|
}
|
|
|
|
|
2003-09-09 18:09:42 +00:00
|
|
|
/* Look for a given value in a given string dissector table and, if found,
|
|
|
|
return the dissector handle for that value. */
|
|
|
|
dissector_handle_t
|
|
|
|
dissector_get_string_handle(dissector_table_t sub_dissectors,
|
2009-10-12 01:31:01 +00:00
|
|
|
const gchar *string)
|
2003-09-09 18:09:42 +00:00
|
|
|
{
|
|
|
|
dtbl_entry_t *dtbl_entry;
|
|
|
|
|
2015-09-20 19:09:38 +00:00
|
|
|
/* XXX ASSERT instead ? */
|
2015-09-20 19:08:34 +00:00
|
|
|
if (!string) return NULL;
|
2003-09-09 18:09:42 +00:00
|
|
|
dtbl_entry = find_string_dtbl_entry(sub_dissectors, string);
|
|
|
|
if (dtbl_entry != NULL)
|
|
|
|
return dtbl_entry->current;
|
|
|
|
else
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-12-10 19:23:26 +00:00
|
|
|
dissector_handle_t
|
|
|
|
dissector_get_default_string_handle(const char *name, const gchar *string)
|
|
|
|
{
|
2015-07-20 17:03:59 +00:00
|
|
|
dissector_table_t sub_dissectors;
|
2013-12-10 19:23:26 +00:00
|
|
|
|
2015-09-20 19:09:38 +00:00
|
|
|
/* XXX ASSERT instead ? */
|
2015-09-20 19:08:34 +00:00
|
|
|
if (!string) return NULL;
|
2015-07-20 17:03:59 +00:00
|
|
|
sub_dissectors = find_dissector_table(name);
|
2013-12-10 19:23:26 +00:00
|
|
|
if (sub_dissectors != NULL) {
|
|
|
|
dtbl_entry_t *dtbl_entry = find_string_dtbl_entry(sub_dissectors, string);
|
|
|
|
if (dtbl_entry != NULL)
|
|
|
|
return dtbl_entry->initial;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-07-02 03:56:54 +00:00
|
|
|
/* Add an entry to a "custom" dissector table. */
|
|
|
|
void dissector_add_custom_table_handle(const char *name, void *pattern, dissector_handle_t handle)
|
|
|
|
{
|
2018-02-08 08:31:29 +00:00
|
|
|
dissector_table_t sub_dissectors = find_dissector_table(name);
|
2015-07-02 03:56:54 +00:00
|
|
|
dtbl_entry_t *dtbl_entry;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make sure the dissector table exists.
|
|
|
|
*/
|
|
|
|
if (sub_dissectors == NULL) {
|
|
|
|
fprintf(stderr, "OOPS: dissector table \"%s\" doesn't exist\n",
|
|
|
|
name);
|
|
|
|
fprintf(stderr, "Protocol being registered is \"%s\"\n",
|
|
|
|
proto_get_protocol_long_name(handle->protocol));
|
|
|
|
if (getenv("WIRESHARK_ABORT_ON_DISSECTOR_BUG") != NULL)
|
|
|
|
abort();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
g_assert(sub_dissectors->type == FT_BYTES);
|
|
|
|
|
|
|
|
dtbl_entry = (dtbl_entry_t *)g_malloc(sizeof (dtbl_entry_t));
|
|
|
|
dtbl_entry->current = handle;
|
|
|
|
dtbl_entry->initial = dtbl_entry->current;
|
|
|
|
|
|
|
|
/* do the table insertion */
|
2018-02-08 08:31:29 +00:00
|
|
|
g_hash_table_insert(sub_dissectors->hash_table, (gpointer)pattern,
|
2015-07-02 03:56:54 +00:00
|
|
|
(gpointer)dtbl_entry);
|
|
|
|
|
|
|
|
/*
|
2016-08-30 22:51:54 +00:00
|
|
|
* Now, if this table supports "Decode As", add this handle
|
|
|
|
* to the list of handles that could be used for "Decode As"
|
|
|
|
* with this table, because it *is* being used with this table.
|
2015-07-02 03:56:54 +00:00
|
|
|
*/
|
2016-08-30 22:51:54 +00:00
|
|
|
if (sub_dissectors->supports_decode_as)
|
|
|
|
dissector_add_for_decode_as(name, handle);
|
2015-07-02 03:56:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
dissector_handle_t dissector_get_custom_table_handle(dissector_table_t sub_dissectors, void *key)
|
|
|
|
{
|
|
|
|
dtbl_entry_t *dtbl_entry = (dtbl_entry_t *)g_hash_table_lookup(sub_dissectors->hash_table, key);
|
|
|
|
|
|
|
|
if (dtbl_entry != NULL)
|
|
|
|
return dtbl_entry->current;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
2014-10-16 03:39:23 +00:00
|
|
|
/* Add an entry to a guid dissector table. */
|
|
|
|
void dissector_add_guid(const char *name, guid_key* guid_val, dissector_handle_t handle)
|
|
|
|
{
|
|
|
|
dissector_table_t sub_dissectors;
|
|
|
|
dtbl_entry_t *dtbl_entry;
|
|
|
|
|
|
|
|
sub_dissectors = find_dissector_table(name);
|
|
|
|
|
|
|
|
/*
|
2016-06-21 18:21:33 +00:00
|
|
|
* Make sure the handle and the dissector table exist.
|
2014-10-16 03:39:23 +00:00
|
|
|
*/
|
2016-06-21 18:21:33 +00:00
|
|
|
if (handle == NULL) {
|
|
|
|
fprintf(stderr, "OOPS: handle to register \"%s\" to doesn't exist\n",
|
|
|
|
name);
|
|
|
|
if (getenv("WIRESHARK_ABORT_ON_DISSECTOR_BUG") != NULL)
|
|
|
|
abort();
|
|
|
|
return;
|
|
|
|
}
|
2014-10-16 03:39:23 +00:00
|
|
|
if (sub_dissectors == NULL) {
|
|
|
|
fprintf(stderr, "OOPS: dissector table \"%s\" doesn't exist\n",
|
|
|
|
name);
|
|
|
|
fprintf(stderr, "Protocol being registered is \"%s\"\n",
|
|
|
|
proto_get_protocol_long_name(handle->protocol));
|
|
|
|
if (getenv("WIRESHARK_ABORT_ON_DISSECTOR_BUG") != NULL)
|
|
|
|
abort();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-06-21 18:21:33 +00:00
|
|
|
if (sub_dissectors->type != FT_GUID) {
|
2014-10-16 03:39:23 +00:00
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
|
|
|
|
dtbl_entry = (dtbl_entry_t *)g_malloc(sizeof (dtbl_entry_t));
|
|
|
|
dtbl_entry->current = handle;
|
|
|
|
dtbl_entry->initial = dtbl_entry->current;
|
|
|
|
|
|
|
|
/* do the table insertion */
|
2018-02-08 08:31:29 +00:00
|
|
|
g_hash_table_insert(sub_dissectors->hash_table,
|
2014-10-16 03:39:23 +00:00
|
|
|
guid_val, (gpointer)dtbl_entry);
|
|
|
|
|
|
|
|
/*
|
2016-08-30 22:51:54 +00:00
|
|
|
* Now, if this table supports "Decode As", add this handle
|
|
|
|
* to the list of handles that could be used for "Decode As"
|
|
|
|
* with this table, because it *is* being used with this table.
|
2014-10-16 03:39:23 +00:00
|
|
|
*/
|
2016-08-30 22:51:54 +00:00
|
|
|
if (sub_dissectors->supports_decode_as)
|
|
|
|
dissector_add_for_decode_as(name, handle);
|
2014-10-16 03:39:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Look for a given value in a given guid dissector table and, if found,
|
|
|
|
call the dissector with the arguments supplied, and return TRUE,
|
|
|
|
otherwise return FALSE. */
|
|
|
|
int dissector_try_guid_new(dissector_table_t sub_dissectors,
|
|
|
|
guid_key* guid_val, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, const gboolean add_proto_name, void *data)
|
|
|
|
{
|
|
|
|
dtbl_entry_t *dtbl_entry;
|
|
|
|
struct dissector_handle *handle;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
dtbl_entry = (dtbl_entry_t *)g_hash_table_lookup(sub_dissectors->hash_table, guid_val);
|
|
|
|
if (dtbl_entry != NULL) {
|
|
|
|
/*
|
|
|
|
* Is there currently a dissector handle for this entry?
|
|
|
|
*/
|
|
|
|
handle = dtbl_entry->current;
|
|
|
|
if (handle == NULL) {
|
|
|
|
/*
|
|
|
|
* No - pretend this dissector didn't exist,
|
|
|
|
* so that other dissectors might have a chance
|
|
|
|
* to dissect this packet.
|
|
|
|
*/
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Save the current value of "pinfo->match_uint",
|
|
|
|
* set it to the uint_val that matched, call the
|
|
|
|
* dissector, and restore "pinfo->match_uint".
|
|
|
|
*/
|
|
|
|
len = call_dissector_work(handle, tvb, pinfo, tree, add_proto_name, data);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If a new-style dissector returned 0, it means that
|
|
|
|
* it didn't think this tvbuff represented a packet for
|
|
|
|
* its protocol, and didn't dissect anything.
|
|
|
|
*
|
|
|
|
* Old-style dissectors can't reject the packet.
|
|
|
|
*
|
|
|
|
* 0 is also returned if the protocol wasn't enabled.
|
|
|
|
*
|
|
|
|
* If the packet was rejected, we return 0, so that
|
|
|
|
* other dissectors might have a chance to dissect this
|
|
|
|
* packet, otherwise we return the dissected length.
|
|
|
|
*/
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int dissector_try_guid(dissector_table_t sub_dissectors,
|
|
|
|
guid_key* guid_val, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
|
|
|
|
{
|
|
|
|
return dissector_try_guid_new(sub_dissectors, guid_val, tvb, pinfo, tree, TRUE, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Look for a given value in a given guid dissector table and, if found,
|
|
|
|
* return the current dissector handle for that value.
|
|
|
|
*
|
|
|
|
* @param[in] sub_dissectors Dissector table to search.
|
|
|
|
* @param[in] uint_val Value to match, e.g. the port number for the TCP dissector.
|
|
|
|
* @return The matching dissector handle on success, NULL if no match is found.
|
|
|
|
*/
|
|
|
|
dissector_handle_t dissector_get_guid_handle(
|
|
|
|
dissector_table_t const sub_dissectors, guid_key* guid_val)
|
|
|
|
{
|
|
|
|
dtbl_entry_t *dtbl_entry;
|
|
|
|
|
|
|
|
dtbl_entry = (dtbl_entry_t *)g_hash_table_lookup(sub_dissectors->hash_table, guid_val);
|
|
|
|
if (dtbl_entry != NULL)
|
|
|
|
return dtbl_entry->current;
|
|
|
|
else
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2017-07-09 17:44:06 +00:00
|
|
|
/* Use the currently assigned payload dissector for the dissector table and,
|
|
|
|
if any, call the dissector with the arguments supplied, and return the
|
|
|
|
number of bytes consumed, otherwise return 0. */
|
|
|
|
int dissector_try_payload(dissector_table_t sub_dissectors,
|
|
|
|
tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
|
|
|
|
{
|
|
|
|
return dissector_try_uint(sub_dissectors, 0, tvb, pinfo, tree);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Use the currently assigned payload dissector for the dissector table and,
|
|
|
|
if any, call the dissector with the arguments supplied, and return the
|
|
|
|
number of bytes consumed, otherwise return 0. */
|
|
|
|
int dissector_try_payload_new(dissector_table_t sub_dissectors,
|
|
|
|
tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, const gboolean add_proto_name, void *data)
|
|
|
|
{
|
|
|
|
return dissector_try_uint_new(sub_dissectors, 0, tvb, pinfo, tree, add_proto_name, data);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Change the entry for a dissector in a payload (FT_NONE) dissector table
|
|
|
|
with a particular pattern to use a new dissector handle. */
|
2017-10-28 02:43:47 +00:00
|
|
|
void dissector_change_payload(const char *name, dissector_handle_t handle)
|
2017-07-09 17:44:06 +00:00
|
|
|
{
|
2017-10-28 02:43:47 +00:00
|
|
|
dissector_change_uint(name, 0, handle);
|
2017-07-09 17:44:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Reset payload (FT_NONE) dissector table to its initial value. */
|
|
|
|
void dissector_reset_payload(const char *name)
|
|
|
|
{
|
|
|
|
dissector_reset_uint(name, 0);
|
|
|
|
}
|
2015-07-02 03:56:54 +00:00
|
|
|
|
2001-12-03 04:00:26 +00:00
|
|
|
dissector_handle_t
|
|
|
|
dtbl_entry_get_handle (dtbl_entry_t *dtbl_entry)
|
2001-02-01 07:34:33 +00:00
|
|
|
{
|
2001-12-03 04:00:26 +00:00
|
|
|
return dtbl_entry->current;
|
2001-02-01 07:34:33 +00:00
|
|
|
}
|
|
|
|
|
2013-03-24 10:53:31 +00:00
|
|
|
static gint
|
2012-08-29 22:19:29 +00:00
|
|
|
dissector_compare_filter_name(gconstpointer dissector_a, gconstpointer dissector_b)
|
2012-08-29 21:23:07 +00:00
|
|
|
{
|
2013-12-15 12:35:00 +00:00
|
|
|
const struct dissector_handle *a = (const struct dissector_handle *)dissector_a;
|
|
|
|
const struct dissector_handle *b = (const struct dissector_handle *)dissector_b;
|
2012-08-29 22:19:29 +00:00
|
|
|
const char *a_name, *b_name;
|
2012-08-29 21:23:07 +00:00
|
|
|
gint ret;
|
|
|
|
|
|
|
|
if (a->protocol == NULL)
|
|
|
|
a_name = "";
|
|
|
|
else
|
|
|
|
a_name = proto_get_protocol_filter_name(proto_get_id(a->protocol));
|
|
|
|
|
|
|
|
if (b->protocol == NULL)
|
|
|
|
b_name = "";
|
|
|
|
else
|
|
|
|
b_name = proto_get_protocol_filter_name(proto_get_id(b->protocol));
|
|
|
|
|
2012-10-12 21:37:02 +00:00
|
|
|
ret = strcmp(a_name, b_name);
|
2012-08-29 21:23:07 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
Get rid of the lists of conversation dissectors; instead, have a
dissector table contain both a hash table, to use to look up port
numbers to find a dissector, and a list of all dissectors that *could*
be assigned to ports in that hash table, to be used by user interface
code.
Make the "Decode As" dialog box code use that.
Also make it *not* let you choose whether to set the dissector for both
the UDP and TCP versions of a port; some protocols run only atop TCP,
some run only atop UDP, and even those that can run atop both may have
different dissector handles to use over TCP and UDP, so handling a
single merged list would be a mess. (If the user is setting the
dissector for a TCP port, only those protocols that Ethereal can handle
over TCP should be listed; if the user is setting the dissector for a
UDP port, only those protocols that Ethereal can handle over TCP should
be listed; if the user is setting a dissector for both, only those
protocols that Ethereal can handle over *both* TCP *and* UDP should be
listed, *and* there needs to be a way to let the "Decode As" code get
both the TCP handle *and* the UDP handle and use the right ones. If
somebody really wants that, they need to implement all of the above if
they want the code to be correct.)
Fix the code that handles setting the dissection for the IP protocol
number to correctly update the lists of protocols being dissected as TCP
and as UDP; the code before this change wasn't updating the single such
list to add new protocols.
svn path=/trunk/; revision=4311
2001-12-03 08:47:31 +00:00
|
|
|
/* Add a handle to the list of handles that *could* be used with this
|
2014-06-20 16:43:28 +00:00
|
|
|
table. That list is used by the "Decode As"/"-d" code in the UI. */
|
Get rid of the lists of conversation dissectors; instead, have a
dissector table contain both a hash table, to use to look up port
numbers to find a dissector, and a list of all dissectors that *could*
be assigned to ports in that hash table, to be used by user interface
code.
Make the "Decode As" dialog box code use that.
Also make it *not* let you choose whether to set the dissector for both
the UDP and TCP versions of a port; some protocols run only atop TCP,
some run only atop UDP, and even those that can run atop both may have
different dissector handles to use over TCP and UDP, so handling a
single merged list would be a mess. (If the user is setting the
dissector for a TCP port, only those protocols that Ethereal can handle
over TCP should be listed; if the user is setting the dissector for a
UDP port, only those protocols that Ethereal can handle over TCP should
be listed; if the user is setting a dissector for both, only those
protocols that Ethereal can handle over *both* TCP *and* UDP should be
listed, *and* there needs to be a way to let the "Decode As" code get
both the TCP handle *and* the UDP handle and use the right ones. If
somebody really wants that, they need to implement all of the above if
they want the code to be correct.)
Fix the code that handles setting the dissection for the IP protocol
number to correctly update the lists of protocols being dissected as TCP
and as UDP; the code before this change wasn't updating the single such
list to add new protocols.
svn path=/trunk/; revision=4311
2001-12-03 08:47:31 +00:00
|
|
|
void
|
2014-06-20 16:43:28 +00:00
|
|
|
dissector_add_for_decode_as(const char *name, dissector_handle_t handle)
|
Get rid of the lists of conversation dissectors; instead, have a
dissector table contain both a hash table, to use to look up port
numbers to find a dissector, and a list of all dissectors that *could*
be assigned to ports in that hash table, to be used by user interface
code.
Make the "Decode As" dialog box code use that.
Also make it *not* let you choose whether to set the dissector for both
the UDP and TCP versions of a port; some protocols run only atop TCP,
some run only atop UDP, and even those that can run atop both may have
different dissector handles to use over TCP and UDP, so handling a
single merged list would be a mess. (If the user is setting the
dissector for a TCP port, only those protocols that Ethereal can handle
over TCP should be listed; if the user is setting the dissector for a
UDP port, only those protocols that Ethereal can handle over TCP should
be listed; if the user is setting a dissector for both, only those
protocols that Ethereal can handle over *both* TCP *and* UDP should be
listed, *and* there needs to be a way to let the "Decode As" code get
both the TCP handle *and* the UDP handle and use the right ones. If
somebody really wants that, they need to implement all of the above if
they want the code to be correct.)
Fix the code that handles setting the dissection for the IP protocol
number to correctly update the lists of protocols being dissected as TCP
and as UDP; the code before this change wasn't updating the single such
list to add new protocols.
svn path=/trunk/; revision=4311
2001-12-03 08:47:31 +00:00
|
|
|
{
|
2018-02-08 08:31:29 +00:00
|
|
|
dissector_table_t sub_dissectors = find_dissector_table(name);
|
2012-01-20 02:43:37 +00:00
|
|
|
GSList *entry;
|
2015-10-29 13:23:55 +00:00
|
|
|
dissector_handle_t dup_handle;
|
Get rid of the lists of conversation dissectors; instead, have a
dissector table contain both a hash table, to use to look up port
numbers to find a dissector, and a list of all dissectors that *could*
be assigned to ports in that hash table, to be used by user interface
code.
Make the "Decode As" dialog box code use that.
Also make it *not* let you choose whether to set the dissector for both
the UDP and TCP versions of a port; some protocols run only atop TCP,
some run only atop UDP, and even those that can run atop both may have
different dissector handles to use over TCP and UDP, so handling a
single merged list would be a mess. (If the user is setting the
dissector for a TCP port, only those protocols that Ethereal can handle
over TCP should be listed; if the user is setting the dissector for a
UDP port, only those protocols that Ethereal can handle over TCP should
be listed; if the user is setting a dissector for both, only those
protocols that Ethereal can handle over *both* TCP *and* UDP should be
listed, *and* there needs to be a way to let the "Decode As" code get
both the TCP handle *and* the UDP handle and use the right ones. If
somebody really wants that, they need to implement all of the above if
they want the code to be correct.)
Fix the code that handles setting the dissection for the IP protocol
number to correctly update the lists of protocols being dissected as TCP
and as UDP; the code before this change wasn't updating the single such
list to add new protocols.
svn path=/trunk/; revision=4311
2001-12-03 08:47:31 +00:00
|
|
|
|
2011-06-01 18:02:16 +00:00
|
|
|
/*
|
|
|
|
* Make sure the dissector table exists.
|
|
|
|
*/
|
|
|
|
if (sub_dissectors == NULL) {
|
|
|
|
fprintf(stderr, "OOPS: dissector table \"%s\" doesn't exist\n",
|
|
|
|
name);
|
|
|
|
fprintf(stderr, "Protocol being registered is \"%s\"\n",
|
|
|
|
proto_get_protocol_long_name(handle->protocol));
|
|
|
|
if (getenv("WIRESHARK_ABORT_ON_DISSECTOR_BUG") != NULL)
|
|
|
|
abort();
|
|
|
|
return;
|
|
|
|
}
|
Get rid of the lists of conversation dissectors; instead, have a
dissector table contain both a hash table, to use to look up port
numbers to find a dissector, and a list of all dissectors that *could*
be assigned to ports in that hash table, to be used by user interface
code.
Make the "Decode As" dialog box code use that.
Also make it *not* let you choose whether to set the dissector for both
the UDP and TCP versions of a port; some protocols run only atop TCP,
some run only atop UDP, and even those that can run atop both may have
different dissector handles to use over TCP and UDP, so handling a
single merged list would be a mess. (If the user is setting the
dissector for a TCP port, only those protocols that Ethereal can handle
over TCP should be listed; if the user is setting the dissector for a
UDP port, only those protocols that Ethereal can handle over TCP should
be listed; if the user is setting a dissector for both, only those
protocols that Ethereal can handle over *both* TCP *and* UDP should be
listed, *and* there needs to be a way to let the "Decode As" code get
both the TCP handle *and* the UDP handle and use the right ones. If
somebody really wants that, they need to implement all of the above if
they want the code to be correct.)
Fix the code that handles setting the dissection for the IP protocol
number to correctly update the lists of protocols being dissected as TCP
and as UDP; the code before this change wasn't updating the single such
list to add new protocols.
svn path=/trunk/; revision=4311
2001-12-03 08:47:31 +00:00
|
|
|
|
2016-08-30 22:51:54 +00:00
|
|
|
/*
|
|
|
|
* Make sure it supports Decode As.
|
|
|
|
*/
|
|
|
|
if (!sub_dissectors->supports_decode_as) {
|
|
|
|
const char *dissector_name;
|
|
|
|
|
|
|
|
dissector_name = dissector_handle_get_dissector_name(handle);
|
|
|
|
if (dissector_name == NULL)
|
|
|
|
dissector_name = "(anonymous)";
|
|
|
|
fprintf(stderr, "Registering dissector %s for protocol %s in dissector table %s, which doesn't support Decode As\n",
|
|
|
|
dissector_name,
|
|
|
|
proto_get_protocol_short_name(handle->protocol),
|
|
|
|
name);
|
|
|
|
if (getenv("WIRESHARK_ABORT_ON_DISSECTOR_BUG") != NULL)
|
|
|
|
abort();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-03-13 03:11:03 +00:00
|
|
|
/* Add the dissector as a dependency
|
|
|
|
(some dissector tables don't have protocol association, so there is
|
|
|
|
the need for the NULL check */
|
|
|
|
if (sub_dissectors->protocol != NULL)
|
|
|
|
register_depend_dissector(proto_get_protocol_short_name(sub_dissectors->protocol), proto_get_protocol_short_name(handle->protocol));
|
|
|
|
|
Get rid of the lists of conversation dissectors; instead, have a
dissector table contain both a hash table, to use to look up port
numbers to find a dissector, and a list of all dissectors that *could*
be assigned to ports in that hash table, to be used by user interface
code.
Make the "Decode As" dialog box code use that.
Also make it *not* let you choose whether to set the dissector for both
the UDP and TCP versions of a port; some protocols run only atop TCP,
some run only atop UDP, and even those that can run atop both may have
different dissector handles to use over TCP and UDP, so handling a
single merged list would be a mess. (If the user is setting the
dissector for a TCP port, only those protocols that Ethereal can handle
over TCP should be listed; if the user is setting the dissector for a
UDP port, only those protocols that Ethereal can handle over TCP should
be listed; if the user is setting a dissector for both, only those
protocols that Ethereal can handle over *both* TCP *and* UDP should be
listed, *and* there needs to be a way to let the "Decode As" code get
both the TCP handle *and* the UDP handle and use the right ones. If
somebody really wants that, they need to implement all of the above if
they want the code to be correct.)
Fix the code that handles setting the dissection for the IP protocol
number to correctly update the lists of protocols being dissected as TCP
and as UDP; the code before this change wasn't updating the single such
list to add new protocols.
svn path=/trunk/; revision=4311
2001-12-03 08:47:31 +00:00
|
|
|
/* Is it already in this list? */
|
|
|
|
entry = g_slist_find(sub_dissectors->dissector_handles, (gpointer)handle);
|
|
|
|
if (entry != NULL) {
|
|
|
|
/*
|
|
|
|
* Yes - don't insert it again.
|
|
|
|
*/
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-08-30 22:51:54 +00:00
|
|
|
/* Ensure the protocol is unique. This prevents confusion when
|
|
|
|
using Decode As with duplicative entries.
|
|
|
|
|
|
|
|
FT_STRING can at least show the string value in the dialog,
|
|
|
|
so we don't do the check for them. */
|
|
|
|
if (sub_dissectors->type != FT_STRING)
|
2015-10-29 13:23:55 +00:00
|
|
|
{
|
|
|
|
for (entry = sub_dissectors->dissector_handles; entry != NULL; entry = g_slist_next(entry))
|
|
|
|
{
|
|
|
|
dup_handle = (dissector_handle_t)entry->data;
|
|
|
|
if (dup_handle->protocol == handle->protocol)
|
|
|
|
{
|
2016-07-12 18:25:49 +00:00
|
|
|
const char *dissector_name, *dup_dissector_name;
|
|
|
|
|
|
|
|
dissector_name = dissector_handle_get_dissector_name(handle);
|
|
|
|
if (dissector_name == NULL)
|
|
|
|
dissector_name = "(anonymous)";
|
|
|
|
dup_dissector_name = dissector_handle_get_dissector_name(dup_handle);
|
|
|
|
if (dup_dissector_name == NULL)
|
|
|
|
dup_dissector_name = "(anonymous)";
|
2016-04-17 06:45:11 +00:00
|
|
|
fprintf(stderr, "Duplicate dissectors %s and %s for protocol %s in dissector table %s\n",
|
2016-07-12 18:25:49 +00:00
|
|
|
dissector_name, dup_dissector_name,
|
2016-04-17 06:45:11 +00:00
|
|
|
proto_get_protocol_short_name(handle->protocol),
|
|
|
|
name);
|
2015-10-29 13:23:55 +00:00
|
|
|
if (getenv("WIRESHARK_ABORT_ON_DISSECTOR_BUG") != NULL)
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Get rid of the lists of conversation dissectors; instead, have a
dissector table contain both a hash table, to use to look up port
numbers to find a dissector, and a list of all dissectors that *could*
be assigned to ports in that hash table, to be used by user interface
code.
Make the "Decode As" dialog box code use that.
Also make it *not* let you choose whether to set the dissector for both
the UDP and TCP versions of a port; some protocols run only atop TCP,
some run only atop UDP, and even those that can run atop both may have
different dissector handles to use over TCP and UDP, so handling a
single merged list would be a mess. (If the user is setting the
dissector for a TCP port, only those protocols that Ethereal can handle
over TCP should be listed; if the user is setting the dissector for a
UDP port, only those protocols that Ethereal can handle over TCP should
be listed; if the user is setting a dissector for both, only those
protocols that Ethereal can handle over *both* TCP *and* UDP should be
listed, *and* there needs to be a way to let the "Decode As" code get
both the TCP handle *and* the UDP handle and use the right ones. If
somebody really wants that, they need to implement all of the above if
they want the code to be correct.)
Fix the code that handles setting the dissection for the IP protocol
number to correctly update the lists of protocols being dissected as TCP
and as UDP; the code before this change wasn't updating the single such
list to add new protocols.
svn path=/trunk/; revision=4311
2001-12-03 08:47:31 +00:00
|
|
|
/* Add it to the list. */
|
|
|
|
sub_dissectors->dissector_handles =
|
2012-08-29 22:19:29 +00:00
|
|
|
g_slist_insert_sorted(sub_dissectors->dissector_handles, (gpointer)handle, (GCompareFunc)dissector_compare_filter_name);
|
Get rid of the lists of conversation dissectors; instead, have a
dissector table contain both a hash table, to use to look up port
numbers to find a dissector, and a list of all dissectors that *could*
be assigned to ports in that hash table, to be used by user interface
code.
Make the "Decode As" dialog box code use that.
Also make it *not* let you choose whether to set the dissector for both
the UDP and TCP versions of a port; some protocols run only atop TCP,
some run only atop UDP, and even those that can run atop both may have
different dissector handles to use over TCP and UDP, so handling a
single merged list would be a mess. (If the user is setting the
dissector for a TCP port, only those protocols that Ethereal can handle
over TCP should be listed; if the user is setting the dissector for a
UDP port, only those protocols that Ethereal can handle over TCP should
be listed; if the user is setting a dissector for both, only those
protocols that Ethereal can handle over *both* TCP *and* UDP should be
listed, *and* there needs to be a way to let the "Decode As" code get
both the TCP handle *and* the UDP handle and use the right ones. If
somebody really wants that, they need to implement all of the above if
they want the code to be correct.)
Fix the code that handles setting the dissection for the IP protocol
number to correctly update the lists of protocols being dissected as TCP
and as UDP; the code before this change wasn't updating the single such
list to add new protocols.
svn path=/trunk/; revision=4311
2001-12-03 08:47:31 +00:00
|
|
|
}
|
|
|
|
|
2016-10-07 20:25:01 +00:00
|
|
|
void dissector_add_for_decode_as_with_preference(const char *name,
|
|
|
|
dissector_handle_t handle)
|
|
|
|
{
|
|
|
|
/* If a dissector is added for Decode As only, it's dissector
|
|
|
|
table value would default to 0.
|
|
|
|
Set up a preference value with that information
|
|
|
|
*/
|
|
|
|
dissector_add_preference(name, handle, 0);
|
|
|
|
|
|
|
|
dissector_add_for_decode_as(name, handle);
|
|
|
|
}
|
|
|
|
|
2001-12-03 04:00:26 +00:00
|
|
|
dissector_handle_t
|
|
|
|
dtbl_entry_get_initial_handle (dtbl_entry_t *dtbl_entry)
|
2001-02-01 07:34:33 +00:00
|
|
|
{
|
2001-12-03 04:00:26 +00:00
|
|
|
return dtbl_entry->initial;
|
2001-02-01 07:34:33 +00:00
|
|
|
}
|
|
|
|
|
2013-11-22 00:20:23 +00:00
|
|
|
GSList *
|
|
|
|
dissector_table_get_dissector_handles(dissector_table_t dissector_table) {
|
2016-10-07 20:25:01 +00:00
|
|
|
if (!dissector_table)
|
|
|
|
return NULL;
|
|
|
|
|
2013-11-22 00:20:23 +00:00
|
|
|
return dissector_table->dissector_handles;
|
|
|
|
}
|
|
|
|
|
2016-10-07 20:25:01 +00:00
|
|
|
/*
|
|
|
|
* Data structure used as user data when iterating dissector handles
|
|
|
|
*/
|
|
|
|
typedef struct lookup_entry {
|
2018-03-08 01:49:42 +00:00
|
|
|
const gchar* dissector_short_name;
|
2016-10-07 20:25:01 +00:00
|
|
|
dissector_handle_t handle;
|
|
|
|
} lookup_entry_t;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A callback function to changed a dissector_handle if matched
|
|
|
|
* This is used when iterating a dissector table
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
find_dissector_in_table(gpointer item, gpointer user_data)
|
|
|
|
{
|
|
|
|
dissector_handle_t handle = (dissector_handle_t)item;
|
|
|
|
lookup_entry_t * lookup = (lookup_entry_t *)user_data;
|
|
|
|
const gchar *proto_short_name = dissector_handle_get_short_name(handle);
|
|
|
|
if (proto_short_name && strcmp(lookup->dissector_short_name, proto_short_name) == 0) {
|
|
|
|
lookup->handle = handle;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-08 01:49:42 +00:00
|
|
|
dissector_handle_t dissector_table_get_dissector_handle(dissector_table_t dissector_table, const gchar* short_name)
|
2016-10-07 20:25:01 +00:00
|
|
|
{
|
|
|
|
lookup_entry_t lookup;
|
|
|
|
|
|
|
|
lookup.dissector_short_name = short_name;
|
|
|
|
lookup.handle = NULL;
|
|
|
|
|
|
|
|
g_slist_foreach(dissector_table->dissector_handles, find_dissector_in_table, &lookup);
|
|
|
|
return lookup.handle;
|
|
|
|
}
|
|
|
|
|
2013-11-22 00:20:23 +00:00
|
|
|
ftenum_t
|
|
|
|
dissector_table_get_type(dissector_table_t dissector_table) {
|
|
|
|
if (!dissector_table) return FT_NONE;
|
|
|
|
return dissector_table->type;
|
|
|
|
}
|
|
|
|
|
2016-08-30 22:51:54 +00:00
|
|
|
void
|
|
|
|
dissector_table_allow_decode_as(dissector_table_t dissector_table)
|
2015-10-29 13:23:55 +00:00
|
|
|
{
|
2016-08-30 22:51:54 +00:00
|
|
|
dissector_table->supports_decode_as = TRUE;
|
2015-10-29 13:23:55 +00:00
|
|
|
}
|
|
|
|
|
2014-10-16 03:39:23 +00:00
|
|
|
static gint
|
|
|
|
uuid_equal(gconstpointer k1, gconstpointer k2)
|
|
|
|
{
|
|
|
|
const guid_key *key1 = (const guid_key *)k1;
|
|
|
|
const guid_key *key2 = (const guid_key *)k2;
|
|
|
|
return ((memcmp(&key1->guid, &key2->guid, sizeof (e_guid_t)) == 0)
|
|
|
|
&& (key1->ver == key2->ver));
|
|
|
|
}
|
|
|
|
|
|
|
|
static guint
|
|
|
|
uuid_hash(gconstpointer k)
|
|
|
|
{
|
|
|
|
const guid_key *key = (const guid_key *)k;
|
|
|
|
/* This isn't perfect, but the Data1 part of these is almost always
|
|
|
|
unique. */
|
|
|
|
return key->guid.data1;
|
|
|
|
}
|
|
|
|
|
2001-02-01 07:34:33 +00:00
|
|
|
/**************************************************/
|
|
|
|
/* */
|
|
|
|
/* Routines to walk dissector tables */
|
|
|
|
/* */
|
|
|
|
/**************************************************/
|
|
|
|
|
|
|
|
typedef struct dissector_foreach_info {
|
2012-01-20 02:43:37 +00:00
|
|
|
gpointer caller_data;
|
|
|
|
DATFunc caller_func;
|
|
|
|
GHFunc next_func;
|
2011-04-20 16:35:42 +00:00
|
|
|
const gchar *table_name;
|
2012-01-20 02:43:37 +00:00
|
|
|
ftenum_t selector_type;
|
2001-02-01 07:34:33 +00:00
|
|
|
} dissector_foreach_info_t;
|
|
|
|
|
|
|
|
/*
|
2001-12-03 01:20:51 +00:00
|
|
|
* Called for each entry in a dissector table.
|
2001-02-01 07:34:33 +00:00
|
|
|
*/
|
|
|
|
static void
|
2001-12-03 01:20:51 +00:00
|
|
|
dissector_table_foreach_func (gpointer key, gpointer value, gpointer user_data)
|
2001-02-01 07:34:33 +00:00
|
|
|
{
|
|
|
|
dissector_foreach_info_t *info;
|
2012-01-20 02:43:37 +00:00
|
|
|
dtbl_entry_t *dtbl_entry;
|
2001-02-01 07:34:33 +00:00
|
|
|
|
|
|
|
g_assert(value);
|
|
|
|
g_assert(user_data);
|
|
|
|
|
2013-03-14 06:46:29 +00:00
|
|
|
dtbl_entry = (dtbl_entry_t *)value;
|
2001-12-03 04:00:26 +00:00
|
|
|
if (dtbl_entry->current == NULL ||
|
2003-11-16 23:17:27 +00:00
|
|
|
dtbl_entry->current->protocol == NULL) {
|
2001-12-03 04:00:26 +00:00
|
|
|
/*
|
|
|
|
* Either there is no dissector for this entry, or
|
|
|
|
* the dissector doesn't have a protocol associated
|
|
|
|
* with it.
|
|
|
|
*
|
|
|
|
* XXX - should the latter check be done?
|
|
|
|
*/
|
|
|
|
return;
|
2001-02-01 07:34:33 +00:00
|
|
|
}
|
|
|
|
|
2013-03-14 06:46:29 +00:00
|
|
|
info = (dissector_foreach_info_t *)user_data;
|
2003-09-07 00:47:57 +00:00
|
|
|
info->caller_func(info->table_name, info->selector_type, key, value,
|
2009-10-12 01:31:01 +00:00
|
|
|
info->caller_data);
|
2001-02-01 07:34:33 +00:00
|
|
|
}
|
|
|
|
|
2001-12-03 01:20:51 +00:00
|
|
|
/*
|
|
|
|
* Called for each entry in the table of all dissector tables.
|
|
|
|
*/
|
2001-02-01 07:34:33 +00:00
|
|
|
static void
|
2001-12-03 01:20:51 +00:00
|
|
|
dissector_all_tables_foreach_func (gpointer key, gpointer value, gpointer user_data)
|
2001-02-01 07:34:33 +00:00
|
|
|
{
|
2012-01-20 02:43:37 +00:00
|
|
|
dissector_table_t sub_dissectors;
|
2001-02-01 07:34:33 +00:00
|
|
|
dissector_foreach_info_t *info;
|
|
|
|
|
|
|
|
g_assert(value);
|
|
|
|
g_assert(user_data);
|
|
|
|
|
2013-03-14 06:46:29 +00:00
|
|
|
sub_dissectors = (dissector_table_t)value;
|
|
|
|
info = (dissector_foreach_info_t *)user_data;
|
2001-02-01 07:34:33 +00:00
|
|
|
info->table_name = (gchar*) key;
|
2003-09-07 00:47:57 +00:00
|
|
|
info->selector_type = get_dissector_table_selector_type(info->table_name);
|
2001-12-03 09:00:25 +00:00
|
|
|
g_hash_table_foreach(sub_dissectors->hash_table, info->next_func, info);
|
2001-02-01 07:34:33 +00:00
|
|
|
}
|
|
|
|
|
2001-12-03 01:20:51 +00:00
|
|
|
/*
|
|
|
|
* Walk all dissector tables calling a user supplied function on each
|
|
|
|
* entry.
|
|
|
|
*/
|
2005-08-02 04:34:35 +00:00
|
|
|
static void
|
2001-02-01 07:34:33 +00:00
|
|
|
dissector_all_tables_foreach (DATFunc func,
|
|
|
|
gpointer user_data)
|
|
|
|
{
|
|
|
|
dissector_foreach_info_t info;
|
|
|
|
|
|
|
|
info.caller_data = user_data;
|
|
|
|
info.caller_func = func;
|
2012-01-20 02:43:37 +00:00
|
|
|
info.next_func = dissector_table_foreach_func;
|
2001-12-03 01:20:51 +00:00
|
|
|
g_hash_table_foreach(dissector_tables, dissector_all_tables_foreach_func, &info);
|
2001-02-01 07:34:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
Get rid of the lists of conversation dissectors; instead, have a
dissector table contain both a hash table, to use to look up port
numbers to find a dissector, and a list of all dissectors that *could*
be assigned to ports in that hash table, to be used by user interface
code.
Make the "Decode As" dialog box code use that.
Also make it *not* let you choose whether to set the dissector for both
the UDP and TCP versions of a port; some protocols run only atop TCP,
some run only atop UDP, and even those that can run atop both may have
different dissector handles to use over TCP and UDP, so handling a
single merged list would be a mess. (If the user is setting the
dissector for a TCP port, only those protocols that Ethereal can handle
over TCP should be listed; if the user is setting the dissector for a
UDP port, only those protocols that Ethereal can handle over TCP should
be listed; if the user is setting a dissector for both, only those
protocols that Ethereal can handle over *both* TCP *and* UDP should be
listed, *and* there needs to be a way to let the "Decode As" code get
both the TCP handle *and* the UDP handle and use the right ones. If
somebody really wants that, they need to implement all of the above if
they want the code to be correct.)
Fix the code that handles setting the dissection for the IP protocol
number to correctly update the lists of protocols being dissected as TCP
and as UDP; the code before this change wasn't updating the single such
list to add new protocols.
svn path=/trunk/; revision=4311
2001-12-03 08:47:31 +00:00
|
|
|
* Walk one dissector table's hash table calling a user supplied function
|
|
|
|
* on each entry.
|
2001-02-01 07:34:33 +00:00
|
|
|
*/
|
|
|
|
void
|
2013-11-22 00:20:23 +00:00
|
|
|
dissector_table_foreach (const char *table_name,
|
2012-01-20 02:43:37 +00:00
|
|
|
DATFunc func,
|
|
|
|
gpointer user_data)
|
2001-02-01 07:34:33 +00:00
|
|
|
{
|
|
|
|
dissector_foreach_info_t info;
|
2013-11-22 00:20:23 +00:00
|
|
|
dissector_table_t sub_dissectors = find_dissector_table(table_name);
|
2001-02-01 07:34:33 +00:00
|
|
|
|
2013-11-22 00:20:23 +00:00
|
|
|
info.table_name = table_name;
|
2003-09-07 00:47:57 +00:00
|
|
|
info.selector_type = sub_dissectors->type;
|
2012-01-20 02:43:37 +00:00
|
|
|
info.caller_func = func;
|
|
|
|
info.caller_data = user_data;
|
Get rid of the lists of conversation dissectors; instead, have a
dissector table contain both a hash table, to use to look up port
numbers to find a dissector, and a list of all dissectors that *could*
be assigned to ports in that hash table, to be used by user interface
code.
Make the "Decode As" dialog box code use that.
Also make it *not* let you choose whether to set the dissector for both
the UDP and TCP versions of a port; some protocols run only atop TCP,
some run only atop UDP, and even those that can run atop both may have
different dissector handles to use over TCP and UDP, so handling a
single merged list would be a mess. (If the user is setting the
dissector for a TCP port, only those protocols that Ethereal can handle
over TCP should be listed; if the user is setting the dissector for a
UDP port, only those protocols that Ethereal can handle over TCP should
be listed; if the user is setting a dissector for both, only those
protocols that Ethereal can handle over *both* TCP *and* UDP should be
listed, *and* there needs to be a way to let the "Decode As" code get
both the TCP handle *and* the UDP handle and use the right ones. If
somebody really wants that, they need to implement all of the above if
they want the code to be correct.)
Fix the code that handles setting the dissection for the IP protocol
number to correctly update the lists of protocols being dissected as TCP
and as UDP; the code before this change wasn't updating the single such
list to add new protocols.
svn path=/trunk/; revision=4311
2001-12-03 08:47:31 +00:00
|
|
|
g_hash_table_foreach(sub_dissectors->hash_table, dissector_table_foreach_func, &info);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Walk one dissector table's list of handles calling a user supplied
|
|
|
|
* function on each entry.
|
|
|
|
*/
|
|
|
|
void
|
2013-11-22 00:20:23 +00:00
|
|
|
dissector_table_foreach_handle(const char *table_name,
|
2012-01-20 02:43:37 +00:00
|
|
|
DATFunc_handle func,
|
|
|
|
gpointer user_data)
|
Get rid of the lists of conversation dissectors; instead, have a
dissector table contain both a hash table, to use to look up port
numbers to find a dissector, and a list of all dissectors that *could*
be assigned to ports in that hash table, to be used by user interface
code.
Make the "Decode As" dialog box code use that.
Also make it *not* let you choose whether to set the dissector for both
the UDP and TCP versions of a port; some protocols run only atop TCP,
some run only atop UDP, and even those that can run atop both may have
different dissector handles to use over TCP and UDP, so handling a
single merged list would be a mess. (If the user is setting the
dissector for a TCP port, only those protocols that Ethereal can handle
over TCP should be listed; if the user is setting the dissector for a
UDP port, only those protocols that Ethereal can handle over TCP should
be listed; if the user is setting a dissector for both, only those
protocols that Ethereal can handle over *both* TCP *and* UDP should be
listed, *and* there needs to be a way to let the "Decode As" code get
both the TCP handle *and* the UDP handle and use the right ones. If
somebody really wants that, they need to implement all of the above if
they want the code to be correct.)
Fix the code that handles setting the dissection for the IP protocol
number to correctly update the lists of protocols being dissected as TCP
and as UDP; the code before this change wasn't updating the single such
list to add new protocols.
svn path=/trunk/; revision=4311
2001-12-03 08:47:31 +00:00
|
|
|
{
|
2013-11-22 00:20:23 +00:00
|
|
|
dissector_table_t sub_dissectors = find_dissector_table(table_name);
|
Get rid of the lists of conversation dissectors; instead, have a
dissector table contain both a hash table, to use to look up port
numbers to find a dissector, and a list of all dissectors that *could*
be assigned to ports in that hash table, to be used by user interface
code.
Make the "Decode As" dialog box code use that.
Also make it *not* let you choose whether to set the dissector for both
the UDP and TCP versions of a port; some protocols run only atop TCP,
some run only atop UDP, and even those that can run atop both may have
different dissector handles to use over TCP and UDP, so handling a
single merged list would be a mess. (If the user is setting the
dissector for a TCP port, only those protocols that Ethereal can handle
over TCP should be listed; if the user is setting the dissector for a
UDP port, only those protocols that Ethereal can handle over TCP should
be listed; if the user is setting a dissector for both, only those
protocols that Ethereal can handle over *both* TCP *and* UDP should be
listed, *and* there needs to be a way to let the "Decode As" code get
both the TCP handle *and* the UDP handle and use the right ones. If
somebody really wants that, they need to implement all of the above if
they want the code to be correct.)
Fix the code that handles setting the dissection for the IP protocol
number to correctly update the lists of protocols being dissected as TCP
and as UDP; the code before this change wasn't updating the single such
list to add new protocols.
svn path=/trunk/; revision=4311
2001-12-03 08:47:31 +00:00
|
|
|
GSList *tmp;
|
|
|
|
|
|
|
|
for (tmp = sub_dissectors->dissector_handles; tmp != NULL;
|
2009-10-12 01:31:01 +00:00
|
|
|
tmp = g_slist_next(tmp))
|
2013-11-22 00:20:23 +00:00
|
|
|
func(table_name, tmp->data, user_data);
|
2001-02-01 07:34:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2001-12-03 01:20:51 +00:00
|
|
|
* Called for each entry in a dissector table.
|
2001-02-01 07:34:33 +00:00
|
|
|
*/
|
|
|
|
static void
|
2001-12-03 01:20:51 +00:00
|
|
|
dissector_table_foreach_changed_func (gpointer key, gpointer value, gpointer user_data)
|
2001-02-01 07:34:33 +00:00
|
|
|
{
|
2012-01-20 02:43:37 +00:00
|
|
|
dtbl_entry_t *dtbl_entry;
|
2001-02-01 07:34:33 +00:00
|
|
|
dissector_foreach_info_t *info;
|
|
|
|
|
|
|
|
g_assert(value);
|
|
|
|
g_assert(user_data);
|
|
|
|
|
2013-03-14 06:46:29 +00:00
|
|
|
dtbl_entry = (dtbl_entry_t *)value;
|
2001-12-03 04:00:26 +00:00
|
|
|
if (dtbl_entry->initial == dtbl_entry->current) {
|
2001-12-03 01:20:51 +00:00
|
|
|
/*
|
|
|
|
* Entry hasn't changed - don't call the function.
|
|
|
|
*/
|
|
|
|
return;
|
2001-02-01 07:34:33 +00:00
|
|
|
}
|
|
|
|
|
2013-03-14 06:46:29 +00:00
|
|
|
info = (dissector_foreach_info_t *)user_data;
|
2003-09-07 00:47:57 +00:00
|
|
|
info->caller_func(info->table_name, info->selector_type, key, value,
|
2009-10-12 01:31:01 +00:00
|
|
|
info->caller_data);
|
2001-02-01 07:34:33 +00:00
|
|
|
}
|
|
|
|
|
2001-12-03 01:20:51 +00:00
|
|
|
/*
|
|
|
|
* Walk all dissector tables calling a user supplied function only on
|
|
|
|
* any entry that has been changed from its original state.
|
|
|
|
*/
|
2001-02-01 07:34:33 +00:00
|
|
|
void
|
2012-01-20 02:43:37 +00:00
|
|
|
dissector_all_tables_foreach_changed (DATFunc func,
|
2001-02-01 07:34:33 +00:00
|
|
|
gpointer user_data)
|
|
|
|
{
|
|
|
|
dissector_foreach_info_t info;
|
|
|
|
|
|
|
|
info.caller_data = user_data;
|
|
|
|
info.caller_func = func;
|
2012-01-20 02:43:37 +00:00
|
|
|
info.next_func = dissector_table_foreach_changed_func;
|
2001-12-03 01:20:51 +00:00
|
|
|
g_hash_table_foreach(dissector_tables, dissector_all_tables_foreach_func, &info);
|
2001-02-01 07:34:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Walk one dissector table calling a user supplied function only on
|
|
|
|
* any entry that has been changed from its original state.
|
|
|
|
*/
|
|
|
|
void
|
2013-11-22 00:20:23 +00:00
|
|
|
dissector_table_foreach_changed (const char *table_name,
|
2012-01-20 02:43:37 +00:00
|
|
|
DATFunc func,
|
|
|
|
gpointer user_data)
|
2001-02-01 07:34:33 +00:00
|
|
|
{
|
|
|
|
dissector_foreach_info_t info;
|
2013-11-22 00:20:23 +00:00
|
|
|
dissector_table_t sub_dissectors = find_dissector_table(table_name);
|
2001-02-01 07:34:33 +00:00
|
|
|
|
2013-11-22 00:20:23 +00:00
|
|
|
info.table_name = table_name;
|
2003-09-07 00:47:57 +00:00
|
|
|
info.selector_type = sub_dissectors->type;
|
2012-01-20 02:43:37 +00:00
|
|
|
info.caller_func = func;
|
|
|
|
info.caller_data = user_data;
|
Get rid of the lists of conversation dissectors; instead, have a
dissector table contain both a hash table, to use to look up port
numbers to find a dissector, and a list of all dissectors that *could*
be assigned to ports in that hash table, to be used by user interface
code.
Make the "Decode As" dialog box code use that.
Also make it *not* let you choose whether to set the dissector for both
the UDP and TCP versions of a port; some protocols run only atop TCP,
some run only atop UDP, and even those that can run atop both may have
different dissector handles to use over TCP and UDP, so handling a
single merged list would be a mess. (If the user is setting the
dissector for a TCP port, only those protocols that Ethereal can handle
over TCP should be listed; if the user is setting the dissector for a
UDP port, only those protocols that Ethereal can handle over TCP should
be listed; if the user is setting a dissector for both, only those
protocols that Ethereal can handle over *both* TCP *and* UDP should be
listed, *and* there needs to be a way to let the "Decode As" code get
both the TCP handle *and* the UDP handle and use the right ones. If
somebody really wants that, they need to implement all of the above if
they want the code to be correct.)
Fix the code that handles setting the dissection for the IP protocol
number to correctly update the lists of protocols being dissected as TCP
and as UDP; the code before this change wasn't updating the single such
list to add new protocols.
svn path=/trunk/; revision=4311
2001-12-03 08:47:31 +00:00
|
|
|
g_hash_table_foreach(sub_dissectors->hash_table,
|
2009-10-12 01:31:01 +00:00
|
|
|
dissector_table_foreach_changed_func, &info);
|
2001-02-01 07:34:33 +00:00
|
|
|
}
|
|
|
|
|
2003-06-05 04:47:58 +00:00
|
|
|
typedef struct dissector_foreach_table_info {
|
2009-10-12 01:31:01 +00:00
|
|
|
gpointer caller_data;
|
|
|
|
DATFunc_table caller_func;
|
2003-06-05 04:47:58 +00:00
|
|
|
} dissector_foreach_table_info_t;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Called for each entry in the table of all dissector tables.
|
2014-12-11 03:04:50 +00:00
|
|
|
* This is used if we directly process the hash table.
|
2003-06-05 04:47:58 +00:00
|
|
|
*/
|
|
|
|
static void
|
2016-01-05 12:06:36 +00:00
|
|
|
dissector_all_tables_foreach_table_func (gpointer key, gpointer value, gpointer user_data)
|
2003-06-05 04:47:58 +00:00
|
|
|
{
|
2012-01-20 02:43:37 +00:00
|
|
|
dissector_table_t table;
|
2003-06-05 04:47:58 +00:00
|
|
|
dissector_foreach_table_info_t *info;
|
|
|
|
|
2013-03-14 06:46:29 +00:00
|
|
|
table = (dissector_table_t)value;
|
2013-08-29 02:05:31 +00:00
|
|
|
info = (dissector_foreach_table_info_t *)user_data;
|
2016-01-05 12:06:36 +00:00
|
|
|
(*info->caller_func)((gchar *)key, table->ui_name, info->caller_data);
|
2003-06-05 04:47:58 +00:00
|
|
|
}
|
|
|
|
|
2012-08-29 21:23:07 +00:00
|
|
|
/*
|
|
|
|
* Called for each key in the table of all dissector tables.
|
2014-12-11 03:04:50 +00:00
|
|
|
* This is used if we get a list of table names, sort it, and process the list.
|
2012-08-29 21:23:07 +00:00
|
|
|
*/
|
|
|
|
static void
|
|
|
|
dissector_all_tables_foreach_list_func (gpointer key, gpointer user_data)
|
|
|
|
{
|
|
|
|
dissector_table_t table;
|
|
|
|
dissector_foreach_table_info_t *info;
|
|
|
|
|
2018-02-08 08:31:29 +00:00
|
|
|
table = (dissector_table_t)g_hash_table_lookup(dissector_tables, key);
|
2013-08-29 02:05:31 +00:00
|
|
|
info = (dissector_foreach_table_info_t *)user_data;
|
2012-08-29 21:23:07 +00:00
|
|
|
(*info->caller_func)((gchar*)key, table->ui_name, info->caller_data);
|
|
|
|
}
|
|
|
|
|
2003-06-05 04:47:58 +00:00
|
|
|
/*
|
|
|
|
* Walk all dissector tables calling a user supplied function on each
|
|
|
|
* table.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
dissector_all_tables_foreach_table (DATFunc_table func,
|
2014-12-11 03:04:50 +00:00
|
|
|
gpointer user_data,
|
|
|
|
GCompareFunc compare_key_func)
|
2003-06-05 04:47:58 +00:00
|
|
|
{
|
|
|
|
dissector_foreach_table_info_t info;
|
2013-08-29 02:05:31 +00:00
|
|
|
GList *list;
|
2003-06-05 04:47:58 +00:00
|
|
|
|
|
|
|
info.caller_data = user_data;
|
|
|
|
info.caller_func = func;
|
2012-08-29 21:23:07 +00:00
|
|
|
if (compare_key_func != NULL)
|
|
|
|
{
|
|
|
|
list = g_hash_table_get_keys(dissector_tables);
|
|
|
|
list = g_list_sort(list, compare_key_func);
|
|
|
|
g_list_foreach(list, dissector_all_tables_foreach_list_func, &info);
|
2012-08-29 22:14:55 +00:00
|
|
|
g_list_free(list);
|
2012-08-29 21:23:07 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
g_hash_table_foreach(dissector_tables, dissector_all_tables_foreach_table_func, &info);
|
|
|
|
}
|
2003-06-05 04:47:58 +00:00
|
|
|
}
|
|
|
|
|
Change the sub-dissector handoff registration routines so that the
sub-dissector table is not stored in the header_field_info struct, but
in a separate namespace. Dissector tables are now registered by name
and not by field ID. For example:
udp_dissector_table = register_dissector_table("udp.port");
Because of this different namespace, dissector tables can have names
that are not field names. This is useful for ethertype, since multiple
fields are "ethertypes".
packet-ethertype.c replaces ethertype.c (the name was changed so that it
would be named in the same fashion as all the filenames passed to make-reg-dotc)
Although it registers no protocol or field, it registers one dissector table:
ethertype_dissector_table = register_dissector_table("ethertype");
All protocols that can be called because of an ethertype field now register
that fact with dissector_add() calls.
In this way, one dissector_table services all ethertype fields
(hf_eth_type, hf_llc_type, hf_null_etype, hf_vlan_etype)
Furthermore, the code allows for names of protocols to exist in the
etype_vals, yet a dissector for that protocol doesn't exist. The name
of the dissector is printed in COL_INFO. You're welcome, Richard. :-)
svn path=/trunk/; revision=1848
2000-04-13 18:18:56 +00:00
|
|
|
dissector_table_t
|
2016-03-13 11:51:45 +00:00
|
|
|
register_dissector_table(const char *name, const char *ui_name, const int proto, const ftenum_t type,
|
2016-08-30 22:51:54 +00:00
|
|
|
const int param)
|
Change the sub-dissector handoff registration routines so that the
sub-dissector table is not stored in the header_field_info struct, but
in a separate namespace. Dissector tables are now registered by name
and not by field ID. For example:
udp_dissector_table = register_dissector_table("udp.port");
Because of this different namespace, dissector tables can have names
that are not field names. This is useful for ethertype, since multiple
fields are "ethertypes".
packet-ethertype.c replaces ethertype.c (the name was changed so that it
would be named in the same fashion as all the filenames passed to make-reg-dotc)
Although it registers no protocol or field, it registers one dissector table:
ethertype_dissector_table = register_dissector_table("ethertype");
All protocols that can be called because of an ethertype field now register
that fact with dissector_add() calls.
In this way, one dissector_table services all ethertype fields
(hf_eth_type, hf_llc_type, hf_null_etype, hf_vlan_etype)
Furthermore, the code allows for names of protocols to exist in the
etype_vals, yet a dissector for that protocol doesn't exist. The name
of the dissector is printed in COL_INFO. You're welcome, Richard. :-)
svn path=/trunk/; revision=1848
2000-04-13 18:18:56 +00:00
|
|
|
{
|
|
|
|
dissector_table_t sub_dissectors;
|
2000-04-03 09:24:12 +00:00
|
|
|
|
Change the sub-dissector handoff registration routines so that the
sub-dissector table is not stored in the header_field_info struct, but
in a separate namespace. Dissector tables are now registered by name
and not by field ID. For example:
udp_dissector_table = register_dissector_table("udp.port");
Because of this different namespace, dissector tables can have names
that are not field names. This is useful for ethertype, since multiple
fields are "ethertypes".
packet-ethertype.c replaces ethertype.c (the name was changed so that it
would be named in the same fashion as all the filenames passed to make-reg-dotc)
Although it registers no protocol or field, it registers one dissector table:
ethertype_dissector_table = register_dissector_table("ethertype");
All protocols that can be called because of an ethertype field now register
that fact with dissector_add() calls.
In this way, one dissector_table services all ethertype fields
(hf_eth_type, hf_llc_type, hf_null_etype, hf_vlan_etype)
Furthermore, the code allows for names of protocols to exist in the
etype_vals, yet a dissector for that protocol doesn't exist. The name
of the dissector is printed in COL_INFO. You're welcome, Richard. :-)
svn path=/trunk/; revision=1848
2000-04-13 18:18:56 +00:00
|
|
|
/* Make sure the registration is unique */
|
2018-02-08 08:31:29 +00:00
|
|
|
if (g_hash_table_lookup(dissector_tables, name)) {
|
2014-12-21 07:25:55 +00:00
|
|
|
g_error("The dissector table %s (%s) is already registered - are you using a buggy plugin?", name, ui_name);
|
2007-10-02 05:07:13 +00:00
|
|
|
}
|
2000-04-03 09:24:12 +00:00
|
|
|
|
Add routines to:
register lists of "heuristic" dissectors, which are handed a
frame that may or may contain a payload for the protocol they
dissect, and that return FALSE if it's not or dissect the packet
and return TRUE if it is;
add a dissector to such a list;
go through such a list, calling each dissector until either a
dissector returns TRUE, in which case the routine returns TRUE,
or it runs out of entries in the list, in which case the routine
returns FALSE.
Have lists of heuristic dissectors for TCP and for COTP when used with
the Inactive Subset of CLNP, and add the GIOP and Yahoo Messenger
dissectors to the first list and the Sinec H1 dissector to the second
list.
Make the dissector name argument to "dissector_add()" and
"dissector_delete()" a "const char *" rarther than just a "char *".
Add "heur_dissector_add()", the routine to add a heuristic dissector to
a list of heuristic dissectors, to the set of routines we can export to
plugins through a table on platforms where dynamically-loaded code can't
call stuff in the main program, and initialize the element in the table
in question for "dissector_add()" (which we'd forgotten to do).
svn path=/trunk/; revision=1909
2000-05-05 09:32:36 +00:00
|
|
|
/* Create and register the dissector table for this name; returns */
|
Change the sub-dissector handoff registration routines so that the
sub-dissector table is not stored in the header_field_info struct, but
in a separate namespace. Dissector tables are now registered by name
and not by field ID. For example:
udp_dissector_table = register_dissector_table("udp.port");
Because of this different namespace, dissector tables can have names
that are not field names. This is useful for ethertype, since multiple
fields are "ethertypes".
packet-ethertype.c replaces ethertype.c (the name was changed so that it
would be named in the same fashion as all the filenames passed to make-reg-dotc)
Although it registers no protocol or field, it registers one dissector table:
ethertype_dissector_table = register_dissector_table("ethertype");
All protocols that can be called because of an ethertype field now register
that fact with dissector_add() calls.
In this way, one dissector_table services all ethertype fields
(hf_eth_type, hf_llc_type, hf_null_etype, hf_vlan_etype)
Furthermore, the code allows for names of protocols to exist in the
etype_vals, yet a dissector for that protocol doesn't exist. The name
of the dissector is printed in COL_INFO. You're welcome, Richard. :-)
svn path=/trunk/; revision=1848
2000-04-13 18:18:56 +00:00
|
|
|
/* a pointer to the dissector table. */
|
2013-10-11 01:33:40 +00:00
|
|
|
sub_dissectors = g_slice_new(struct dissector_table);
|
2003-09-06 23:37:02 +00:00
|
|
|
switch (type) {
|
|
|
|
|
|
|
|
case FT_UINT8:
|
|
|
|
case FT_UINT16:
|
|
|
|
case FT_UINT24:
|
|
|
|
case FT_UINT32:
|
|
|
|
/*
|
|
|
|
* XXX - there's no "g_uint_hash()" or "g_uint_equal()",
|
|
|
|
* so we use "g_direct_hash()" and "g_direct_equal()".
|
|
|
|
*/
|
2015-07-02 03:56:54 +00:00
|
|
|
sub_dissectors->hash_func = g_direct_hash;
|
2018-02-08 08:31:29 +00:00
|
|
|
sub_dissectors->hash_table = g_hash_table_new_full(g_direct_hash,
|
2012-09-08 15:03:07 +00:00
|
|
|
g_direct_equal,
|
|
|
|
NULL,
|
2018-02-08 08:31:29 +00:00
|
|
|
&g_free);
|
2003-09-06 23:37:02 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case FT_STRING:
|
|
|
|
case FT_STRINGZ:
|
2014-04-12 22:26:34 +00:00
|
|
|
case FT_STRINGZPAD:
|
2015-07-02 03:56:54 +00:00
|
|
|
sub_dissectors->hash_func = g_str_hash;
|
2018-02-08 08:31:29 +00:00
|
|
|
sub_dissectors->hash_table = g_hash_table_new_full(g_str_hash,
|
2012-09-08 15:03:07 +00:00
|
|
|
g_str_equal,
|
2013-10-30 01:42:11 +00:00
|
|
|
&g_free,
|
2018-02-08 08:31:29 +00:00
|
|
|
&g_free);
|
2003-09-06 23:37:02 +00:00
|
|
|
break;
|
2014-10-16 03:39:23 +00:00
|
|
|
case FT_GUID:
|
2018-02-08 08:31:29 +00:00
|
|
|
sub_dissectors->hash_table = g_hash_table_new_full(uuid_hash,
|
2014-10-16 03:39:23 +00:00
|
|
|
uuid_equal,
|
|
|
|
NULL,
|
2018-02-08 08:31:29 +00:00
|
|
|
&g_free);
|
2014-10-16 03:39:23 +00:00
|
|
|
break;
|
2017-07-09 17:44:06 +00:00
|
|
|
|
|
|
|
case FT_NONE:
|
|
|
|
/* Dissector tables with FT_NONE don't have values associated with
|
|
|
|
dissectors so this will always be a hash table size of 1 just
|
|
|
|
to store the single dtbl_entry_t */
|
|
|
|
sub_dissectors->hash_func = g_direct_hash;
|
2018-02-08 08:31:29 +00:00
|
|
|
sub_dissectors->hash_table = g_hash_table_new_full(g_direct_hash,
|
2017-07-09 17:44:06 +00:00
|
|
|
g_direct_equal,
|
|
|
|
NULL,
|
2018-02-08 08:31:29 +00:00
|
|
|
&g_free);
|
2017-07-09 17:44:06 +00:00
|
|
|
break;
|
|
|
|
|
2003-09-06 23:37:02 +00:00
|
|
|
default:
|
2016-05-16 11:39:01 +00:00
|
|
|
g_error("The dissector table %s (%s) is registering an unsupported type - are you using a buggy plugin?", name, ui_name);
|
2003-09-06 23:37:02 +00:00
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
Get rid of the lists of conversation dissectors; instead, have a
dissector table contain both a hash table, to use to look up port
numbers to find a dissector, and a list of all dissectors that *could*
be assigned to ports in that hash table, to be used by user interface
code.
Make the "Decode As" dialog box code use that.
Also make it *not* let you choose whether to set the dissector for both
the UDP and TCP versions of a port; some protocols run only atop TCP,
some run only atop UDP, and even those that can run atop both may have
different dissector handles to use over TCP and UDP, so handling a
single merged list would be a mess. (If the user is setting the
dissector for a TCP port, only those protocols that Ethereal can handle
over TCP should be listed; if the user is setting the dissector for a
UDP port, only those protocols that Ethereal can handle over TCP should
be listed; if the user is setting a dissector for both, only those
protocols that Ethereal can handle over *both* TCP *and* UDP should be
listed, *and* there needs to be a way to let the "Decode As" code get
both the TCP handle *and* the UDP handle and use the right ones. If
somebody really wants that, they need to implement all of the above if
they want the code to be correct.)
Fix the code that handles setting the dissection for the IP protocol
number to correctly update the lists of protocols being dissected as TCP
and as UDP; the code before this change wasn't updating the single such
list to add new protocols.
svn path=/trunk/; revision=4311
2001-12-03 08:47:31 +00:00
|
|
|
sub_dissectors->dissector_handles = NULL;
|
2001-12-08 06:41:48 +00:00
|
|
|
sub_dissectors->ui_name = ui_name;
|
2012-01-20 02:43:37 +00:00
|
|
|
sub_dissectors->type = type;
|
2014-12-10 02:35:01 +00:00
|
|
|
sub_dissectors->param = param;
|
2016-03-13 11:51:45 +00:00
|
|
|
sub_dissectors->protocol = find_protocol_by_id(proto);
|
2016-08-30 22:51:54 +00:00
|
|
|
sub_dissectors->supports_decode_as = FALSE;
|
2018-02-08 08:31:29 +00:00
|
|
|
g_hash_table_insert(dissector_tables, (gpointer)name, (gpointer) sub_dissectors);
|
Change the sub-dissector handoff registration routines so that the
sub-dissector table is not stored in the header_field_info struct, but
in a separate namespace. Dissector tables are now registered by name
and not by field ID. For example:
udp_dissector_table = register_dissector_table("udp.port");
Because of this different namespace, dissector tables can have names
that are not field names. This is useful for ethertype, since multiple
fields are "ethertypes".
packet-ethertype.c replaces ethertype.c (the name was changed so that it
would be named in the same fashion as all the filenames passed to make-reg-dotc)
Although it registers no protocol or field, it registers one dissector table:
ethertype_dissector_table = register_dissector_table("ethertype");
All protocols that can be called because of an ethertype field now register
that fact with dissector_add() calls.
In this way, one dissector_table services all ethertype fields
(hf_eth_type, hf_llc_type, hf_null_etype, hf_vlan_etype)
Furthermore, the code allows for names of protocols to exist in the
etype_vals, yet a dissector for that protocol doesn't exist. The name
of the dissector is printed in COL_INFO. You're welcome, Richard. :-)
svn path=/trunk/; revision=1848
2000-04-13 18:18:56 +00:00
|
|
|
return sub_dissectors;
|
2000-04-03 09:24:12 +00:00
|
|
|
}
|
Add routines to:
register lists of "heuristic" dissectors, which are handed a
frame that may or may contain a payload for the protocol they
dissect, and that return FALSE if it's not or dissect the packet
and return TRUE if it is;
add a dissector to such a list;
go through such a list, calling each dissector until either a
dissector returns TRUE, in which case the routine returns TRUE,
or it runs out of entries in the list, in which case the routine
returns FALSE.
Have lists of heuristic dissectors for TCP and for COTP when used with
the Inactive Subset of CLNP, and add the GIOP and Yahoo Messenger
dissectors to the first list and the Sinec H1 dissector to the second
list.
Make the dissector name argument to "dissector_add()" and
"dissector_delete()" a "const char *" rarther than just a "char *".
Add "heur_dissector_add()", the routine to add a heuristic dissector to
a list of heuristic dissectors, to the set of routines we can export to
plugins through a table on platforms where dynamically-loaded code can't
call stuff in the main program, and initialize the element in the table
in question for "dissector_add()" (which we'd forgotten to do).
svn path=/trunk/; revision=1909
2000-05-05 09:32:36 +00:00
|
|
|
|
2015-07-02 03:56:54 +00:00
|
|
|
dissector_table_t register_custom_dissector_table(const char *name,
|
2016-08-30 22:51:54 +00:00
|
|
|
const char *ui_name, const int proto, GHashFunc hash_func, GEqualFunc key_equal_func)
|
2015-07-02 03:56:54 +00:00
|
|
|
{
|
|
|
|
dissector_table_t sub_dissectors;
|
|
|
|
|
|
|
|
/* Make sure the registration is unique */
|
2018-02-08 08:31:29 +00:00
|
|
|
if (g_hash_table_lookup(dissector_tables, name)) {
|
2015-07-02 03:56:54 +00:00
|
|
|
g_error("The dissector table %s (%s) is already registered - are you using a buggy plugin?", name, ui_name);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create and register the dissector table for this name; returns */
|
|
|
|
/* a pointer to the dissector table. */
|
|
|
|
sub_dissectors = g_slice_new(struct dissector_table);
|
|
|
|
sub_dissectors->hash_func = hash_func;
|
|
|
|
sub_dissectors->hash_table = g_hash_table_new_full(hash_func,
|
|
|
|
key_equal_func,
|
|
|
|
&g_free,
|
2018-02-08 08:31:29 +00:00
|
|
|
&g_free);
|
2015-07-02 03:56:54 +00:00
|
|
|
|
|
|
|
sub_dissectors->dissector_handles = NULL;
|
|
|
|
sub_dissectors->ui_name = ui_name;
|
|
|
|
sub_dissectors->type = FT_BYTES; /* Consider key a "blob" of data, no need to really create new type */
|
|
|
|
sub_dissectors->param = BASE_NONE;
|
2016-03-13 11:51:45 +00:00
|
|
|
sub_dissectors->protocol = find_protocol_by_id(proto);
|
2016-08-30 22:51:54 +00:00
|
|
|
sub_dissectors->supports_decode_as = FALSE;
|
2018-02-08 08:31:29 +00:00
|
|
|
g_hash_table_insert(dissector_tables, (gpointer)name, (gpointer) sub_dissectors);
|
2015-07-02 03:56:54 +00:00
|
|
|
return sub_dissectors;
|
|
|
|
}
|
|
|
|
|
2018-09-14 19:58:35 +00:00
|
|
|
void
|
|
|
|
register_dissector_table_alias(dissector_table_t dissector_table, const char *alias_name) {
|
|
|
|
if (!dissector_table || !alias_name) return;
|
|
|
|
|
|
|
|
const char *name = NULL;
|
|
|
|
GList *list = g_hash_table_get_keys(dissector_tables);
|
|
|
|
for (GList *cur = list; cur; cur = cur->next) {
|
|
|
|
if (g_hash_table_lookup(dissector_tables, cur->data) == dissector_table) {
|
|
|
|
name = (const char *) cur->data;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
g_list_free(list);
|
|
|
|
if (!name) return;
|
|
|
|
|
|
|
|
g_hash_table_insert(dissector_table_aliases, (gpointer) alias_name, (gpointer) name);
|
|
|
|
}
|
|
|
|
|
2015-08-11 12:08:08 +00:00
|
|
|
void
|
|
|
|
deregister_dissector_table(const char *name)
|
|
|
|
{
|
2018-09-14 19:58:35 +00:00
|
|
|
dissector_table_t sub_dissectors = (dissector_table_t) g_hash_table_lookup(dissector_tables, name);
|
2015-08-11 12:08:08 +00:00
|
|
|
if (!sub_dissectors) return;
|
|
|
|
|
2016-04-05 16:24:25 +00:00
|
|
|
g_hash_table_remove(dissector_tables, name);
|
2018-09-14 19:58:35 +00:00
|
|
|
|
|
|
|
GList *list = g_hash_table_get_keys(dissector_table_aliases);
|
|
|
|
for (GList *cur = list; cur; cur = cur->next) {
|
|
|
|
gpointer alias_name = cur->data;
|
|
|
|
if (g_hash_table_lookup(dissector_table_aliases, alias_name) == name) {
|
|
|
|
g_hash_table_remove(dissector_table_aliases, alias_name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
g_list_free(list);
|
2015-08-11 12:08:08 +00:00
|
|
|
}
|
|
|
|
|
2005-07-24 19:01:28 +00:00
|
|
|
const char *
|
2001-12-08 06:41:48 +00:00
|
|
|
get_dissector_table_ui_name(const char *name)
|
|
|
|
{
|
2013-12-10 19:23:26 +00:00
|
|
|
dissector_table_t sub_dissectors = find_dissector_table(name);
|
|
|
|
if (!sub_dissectors) return NULL;
|
2001-12-08 06:41:48 +00:00
|
|
|
|
|
|
|
return sub_dissectors->ui_name;
|
|
|
|
}
|
|
|
|
|
|
|
|
ftenum_t
|
2003-09-07 00:47:57 +00:00
|
|
|
get_dissector_table_selector_type(const char *name)
|
2001-12-08 06:41:48 +00:00
|
|
|
{
|
2013-12-10 19:23:26 +00:00
|
|
|
dissector_table_t sub_dissectors = find_dissector_table(name);
|
|
|
|
if (!sub_dissectors) return FT_NONE;
|
2001-12-08 06:41:48 +00:00
|
|
|
|
|
|
|
return sub_dissectors->type;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2014-12-10 02:35:01 +00:00
|
|
|
get_dissector_table_param(const char *name)
|
2001-12-08 06:41:48 +00:00
|
|
|
{
|
2013-12-10 19:23:26 +00:00
|
|
|
dissector_table_t sub_dissectors = find_dissector_table(name);
|
|
|
|
if (!sub_dissectors) return 0;
|
2001-12-08 06:41:48 +00:00
|
|
|
|
2014-12-10 02:35:01 +00:00
|
|
|
return sub_dissectors->param;
|
2001-12-08 06:41:48 +00:00
|
|
|
}
|
|
|
|
|
2011-12-28 15:05:59 +00:00
|
|
|
/* Finds a heuristic dissector table by table name. */
|
2014-12-21 04:13:28 +00:00
|
|
|
heur_dissector_list_t
|
Add routines to:
register lists of "heuristic" dissectors, which are handed a
frame that may or may contain a payload for the protocol they
dissect, and that return FALSE if it's not or dissect the packet
and return TRUE if it is;
add a dissector to such a list;
go through such a list, calling each dissector until either a
dissector returns TRUE, in which case the routine returns TRUE,
or it runs out of entries in the list, in which case the routine
returns FALSE.
Have lists of heuristic dissectors for TCP and for COTP when used with
the Inactive Subset of CLNP, and add the GIOP and Yahoo Messenger
dissectors to the first list and the Sinec H1 dissector to the second
list.
Make the dissector name argument to "dissector_add()" and
"dissector_delete()" a "const char *" rarther than just a "char *".
Add "heur_dissector_add()", the routine to add a heuristic dissector to
a list of heuristic dissectors, to the set of routines we can export to
plugins through a table on platforms where dynamically-loaded code can't
call stuff in the main program, and initialize the element in the table
in question for "dissector_add()" (which we'd forgotten to do).
svn path=/trunk/; revision=1909
2000-05-05 09:32:36 +00:00
|
|
|
find_heur_dissector_list(const char *name)
|
|
|
|
{
|
2014-12-21 04:13:28 +00:00
|
|
|
return (heur_dissector_list_t)g_hash_table_lookup(heur_dissector_lists, name);
|
Add routines to:
register lists of "heuristic" dissectors, which are handed a
frame that may or may contain a payload for the protocol they
dissect, and that return FALSE if it's not or dissect the packet
and return TRUE if it is;
add a dissector to such a list;
go through such a list, calling each dissector until either a
dissector returns TRUE, in which case the routine returns TRUE,
or it runs out of entries in the list, in which case the routine
returns FALSE.
Have lists of heuristic dissectors for TCP and for COTP when used with
the Inactive Subset of CLNP, and add the GIOP and Yahoo Messenger
dissectors to the first list and the Sinec H1 dissector to the second
list.
Make the dissector name argument to "dissector_add()" and
"dissector_delete()" a "const char *" rarther than just a "char *".
Add "heur_dissector_add()", the routine to add a heuristic dissector to
a list of heuristic dissectors, to the set of routines we can export to
plugins through a table on platforms where dynamically-loaded code can't
call stuff in the main program, and initialize the element in the table
in question for "dissector_add()" (which we'd forgotten to do).
svn path=/trunk/; revision=1909
2000-05-05 09:32:36 +00:00
|
|
|
}
|
|
|
|
|
2014-03-10 05:54:51 +00:00
|
|
|
gboolean
|
|
|
|
has_heur_dissector_list(const gchar *name) {
|
|
|
|
return (find_heur_dissector_list(name) != NULL);
|
|
|
|
}
|
|
|
|
|
2015-07-05 21:31:14 +00:00
|
|
|
heur_dtbl_entry_t* find_heur_dissector_by_unique_short_name(const char *short_name)
|
|
|
|
{
|
2015-12-28 21:00:39 +00:00
|
|
|
return (heur_dtbl_entry_t*)g_hash_table_lookup(heuristic_short_names, short_name);
|
2015-07-05 21:31:14 +00:00
|
|
|
}
|
|
|
|
|
Add routines to:
register lists of "heuristic" dissectors, which are handed a
frame that may or may contain a payload for the protocol they
dissect, and that return FALSE if it's not or dissect the packet
and return TRUE if it is;
add a dissector to such a list;
go through such a list, calling each dissector until either a
dissector returns TRUE, in which case the routine returns TRUE,
or it runs out of entries in the list, in which case the routine
returns FALSE.
Have lists of heuristic dissectors for TCP and for COTP when used with
the Inactive Subset of CLNP, and add the GIOP and Yahoo Messenger
dissectors to the first list and the Sinec H1 dissector to the second
list.
Make the dissector name argument to "dissector_add()" and
"dissector_delete()" a "const char *" rarther than just a "char *".
Add "heur_dissector_add()", the routine to add a heuristic dissector to
a list of heuristic dissectors, to the set of routines we can export to
plugins through a table on platforms where dynamically-loaded code can't
call stuff in the main program, and initialize the element in the table
in question for "dissector_add()" (which we'd forgotten to do).
svn path=/trunk/; revision=1909
2000-05-05 09:32:36 +00:00
|
|
|
void
|
2015-07-13 00:40:31 +00:00
|
|
|
heur_dissector_add(const char *name, heur_dissector_t dissector, const char *display_name, const char *short_name, const int proto, heuristic_enable_e enable)
|
Add routines to:
register lists of "heuristic" dissectors, which are handed a
frame that may or may contain a payload for the protocol they
dissect, and that return FALSE if it's not or dissect the packet
and return TRUE if it is;
add a dissector to such a list;
go through such a list, calling each dissector until either a
dissector returns TRUE, in which case the routine returns TRUE,
or it runs out of entries in the list, in which case the routine
returns FALSE.
Have lists of heuristic dissectors for TCP and for COTP when used with
the Inactive Subset of CLNP, and add the GIOP and Yahoo Messenger
dissectors to the first list and the Sinec H1 dissector to the second
list.
Make the dissector name argument to "dissector_add()" and
"dissector_delete()" a "const char *" rarther than just a "char *".
Add "heur_dissector_add()", the routine to add a heuristic dissector to
a list of heuristic dissectors, to the set of routines we can export to
plugins through a table on platforms where dynamically-loaded code can't
call stuff in the main program, and initialize the element in the table
in question for "dissector_add()" (which we'd forgotten to do).
svn path=/trunk/; revision=1909
2000-05-05 09:32:36 +00:00
|
|
|
{
|
2014-12-21 07:32:23 +00:00
|
|
|
heur_dissector_list_t sub_dissectors = find_heur_dissector_list(name);
|
2012-01-20 02:43:37 +00:00
|
|
|
const char *proto_name;
|
|
|
|
heur_dtbl_entry_t *hdtbl_entry;
|
2015-07-13 00:40:31 +00:00
|
|
|
guint i, list_size;
|
|
|
|
GSList *list_entry;
|
Add routines to:
register lists of "heuristic" dissectors, which are handed a
frame that may or may contain a payload for the protocol they
dissect, and that return FALSE if it's not or dissect the packet
and return TRUE if it is;
add a dissector to such a list;
go through such a list, calling each dissector until either a
dissector returns TRUE, in which case the routine returns TRUE,
or it runs out of entries in the list, in which case the routine
returns FALSE.
Have lists of heuristic dissectors for TCP and for COTP when used with
the Inactive Subset of CLNP, and add the GIOP and Yahoo Messenger
dissectors to the first list and the Sinec H1 dissector to the second
list.
Make the dissector name argument to "dissector_add()" and
"dissector_delete()" a "const char *" rarther than just a "char *".
Add "heur_dissector_add()", the routine to add a heuristic dissector to
a list of heuristic dissectors, to the set of routines we can export to
plugins through a table on platforms where dynamically-loaded code can't
call stuff in the main program, and initialize the element in the table
in question for "dissector_add()" (which we'd forgotten to do).
svn path=/trunk/; revision=1909
2000-05-05 09:32:36 +00:00
|
|
|
|
2011-06-01 18:02:16 +00:00
|
|
|
/*
|
|
|
|
* Make sure the dissector table exists.
|
|
|
|
*/
|
|
|
|
if (sub_dissectors == NULL) {
|
|
|
|
fprintf(stderr, "OOPS: dissector table \"%s\" doesn't exist\n",
|
|
|
|
name);
|
|
|
|
proto_name = proto_get_protocol_name(proto);
|
|
|
|
if (proto_name != NULL) {
|
|
|
|
fprintf(stderr, "Protocol being registered is \"%s\"\n",
|
|
|
|
proto_name);
|
|
|
|
}
|
|
|
|
if (getenv("WIRESHARK_ABORT_ON_DISSECTOR_BUG") != NULL)
|
|
|
|
abort();
|
|
|
|
return;
|
|
|
|
}
|
Add routines to:
register lists of "heuristic" dissectors, which are handed a
frame that may or may contain a payload for the protocol they
dissect, and that return FALSE if it's not or dissect the packet
and return TRUE if it is;
add a dissector to such a list;
go through such a list, calling each dissector until either a
dissector returns TRUE, in which case the routine returns TRUE,
or it runs out of entries in the list, in which case the routine
returns FALSE.
Have lists of heuristic dissectors for TCP and for COTP when used with
the Inactive Subset of CLNP, and add the GIOP and Yahoo Messenger
dissectors to the first list and the Sinec H1 dissector to the second
list.
Make the dissector name argument to "dissector_add()" and
"dissector_delete()" a "const char *" rarther than just a "char *".
Add "heur_dissector_add()", the routine to add a heuristic dissector to
a list of heuristic dissectors, to the set of routines we can export to
plugins through a table on platforms where dynamically-loaded code can't
call stuff in the main program, and initialize the element in the table
in question for "dissector_add()" (which we'd forgotten to do).
svn path=/trunk/; revision=1909
2000-05-05 09:32:36 +00:00
|
|
|
|
2015-07-11 21:33:26 +00:00
|
|
|
/* Verify that sub-dissector is not already in the list */
|
|
|
|
list_size = g_slist_length(sub_dissectors->dissectors);
|
|
|
|
for (i = 0; i < list_size; i++)
|
|
|
|
{
|
|
|
|
list_entry = g_slist_nth(sub_dissectors->dissectors, i);
|
|
|
|
hdtbl_entry = (heur_dtbl_entry_t *)list_entry->data;
|
|
|
|
if ((hdtbl_entry->dissector == dissector) &&
|
|
|
|
(hdtbl_entry->protocol == find_protocol_by_id(proto)))
|
|
|
|
{
|
|
|
|
proto_name = proto_get_protocol_name(proto);
|
|
|
|
if (proto_name != NULL) {
|
|
|
|
fprintf(stderr, "Protocol %s is already registered in \"%s\" table\n",
|
|
|
|
proto_name, name);
|
|
|
|
}
|
|
|
|
if (getenv("WIRESHARK_ABORT_ON_DISSECTOR_BUG") != NULL)
|
|
|
|
abort();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Ensure short_name is unique */
|
2015-12-28 21:00:39 +00:00
|
|
|
if (g_hash_table_lookup(heuristic_short_names, short_name) != NULL) {
|
2015-07-11 21:33:26 +00:00
|
|
|
g_error("Duplicate heuristic short_name \"%s\"!"
|
|
|
|
" This might be caused by an inappropriate plugin or a development error.", short_name);
|
|
|
|
}
|
2012-01-20 02:43:37 +00:00
|
|
|
|
2013-10-11 01:11:21 +00:00
|
|
|
hdtbl_entry = g_slice_new(heur_dtbl_entry_t);
|
2012-01-20 02:43:37 +00:00
|
|
|
hdtbl_entry->dissector = dissector;
|
|
|
|
hdtbl_entry->protocol = find_protocol_by_id(proto);
|
2015-07-11 21:33:26 +00:00
|
|
|
hdtbl_entry->display_name = display_name;
|
2016-12-21 01:23:35 +00:00
|
|
|
hdtbl_entry->short_name = g_strdup(short_name);
|
2014-03-10 05:54:51 +00:00
|
|
|
hdtbl_entry->list_name = g_strdup(name);
|
2015-07-13 00:40:31 +00:00
|
|
|
hdtbl_entry->enabled = (enable == HEURISTIC_ENABLE);
|
Allow either old-style (pre-tvbuff) or new-style (tvbuffified)
dissectors to be registered as dissectors for particular ports,
registered as heuristic dissectors, and registered as dissectors for
conversations, and have routines to be used both by old-style and
new-style dissectors to call registered dissectors.
Have the code that calls those dissectors translate the arguments as
necessary. (For conversation dissectors, replace
"find_conversation_dissector()", which just returns a pointer to the
dissector, with "old_try_conversation_dissector()" and
"try_conversation_dissector()", which actually call the dissector, so
that there's a single place at which we can do that translation. Also
make "dissector_lookup()" static and, instead of calling it and, if it
returns a non-null pointer, calling that dissector, just use
"old_dissector_try_port()" or "dissector_try_port()", for the same
reason.)
This allows some dissectors that took old-style arguments and
immediately translated them to new-style arguments to just take
new-style arguments; make them do so. It also allows some new-style
dissectors not to have to translate arguments before calling routines to
look up and call dissectors; make them not do so.
Get rid of checks for too-short frames in new-style dissectors - the
tvbuff code does those checks for you.
Give the routines to register old-style dissectors, and to call
dissectors from old-style dissectors, names beginning with "old_", with
the routines for new-style dissectors not having the "old_". Update the
dissectors that use those routines appropriately.
Rename "dissect_data()" to "old_dissect_data()", and
"dissect_data_tvb()" to "dissect_data()".
svn path=/trunk/; revision=2218
2000-08-07 03:21:25 +00:00
|
|
|
|
Add routines to:
register lists of "heuristic" dissectors, which are handed a
frame that may or may contain a payload for the protocol they
dissect, and that return FALSE if it's not or dissect the packet
and return TRUE if it is;
add a dissector to such a list;
go through such a list, calling each dissector until either a
dissector returns TRUE, in which case the routine returns TRUE,
or it runs out of entries in the list, in which case the routine
returns FALSE.
Have lists of heuristic dissectors for TCP and for COTP when used with
the Inactive Subset of CLNP, and add the GIOP and Yahoo Messenger
dissectors to the first list and the Sinec H1 dissector to the second
list.
Make the dissector name argument to "dissector_add()" and
"dissector_delete()" a "const char *" rarther than just a "char *".
Add "heur_dissector_add()", the routine to add a heuristic dissector to
a list of heuristic dissectors, to the set of routines we can export to
plugins through a table on platforms where dynamically-loaded code can't
call stuff in the main program, and initialize the element in the table
in question for "dissector_add()" (which we'd forgotten to do).
svn path=/trunk/; revision=1909
2000-05-05 09:32:36 +00:00
|
|
|
/* do the table insertion */
|
2016-12-21 01:23:35 +00:00
|
|
|
g_hash_table_insert(heuristic_short_names, (gpointer)hdtbl_entry->short_name, hdtbl_entry);
|
2015-07-11 21:33:26 +00:00
|
|
|
|
2014-12-21 07:32:23 +00:00
|
|
|
sub_dissectors->dissectors = g_slist_prepend(sub_dissectors->dissectors,
|
|
|
|
(gpointer)hdtbl_entry);
|
2015-07-21 17:32:42 +00:00
|
|
|
|
|
|
|
/* XXX - could be optimized to pass hdtbl_entry directly */
|
2016-12-21 01:23:35 +00:00
|
|
|
proto_add_heuristic_dissector(hdtbl_entry->protocol, hdtbl_entry->short_name);
|
2016-03-13 03:11:03 +00:00
|
|
|
|
|
|
|
/* Add the dissector as a dependency
|
|
|
|
(some heuristic tables don't have protocol association, so there is
|
|
|
|
the need for the NULL check */
|
|
|
|
if (sub_dissectors->protocol != NULL)
|
|
|
|
register_depend_dissector(proto_get_protocol_short_name(sub_dissectors->protocol), proto_get_protocol_short_name(hdtbl_entry->protocol));
|
Add routines to:
register lists of "heuristic" dissectors, which are handed a
frame that may or may contain a payload for the protocol they
dissect, and that return FALSE if it's not or dissect the packet
and return TRUE if it is;
add a dissector to such a list;
go through such a list, calling each dissector until either a
dissector returns TRUE, in which case the routine returns TRUE,
or it runs out of entries in the list, in which case the routine
returns FALSE.
Have lists of heuristic dissectors for TCP and for COTP when used with
the Inactive Subset of CLNP, and add the GIOP and Yahoo Messenger
dissectors to the first list and the Sinec H1 dissector to the second
list.
Make the dissector name argument to "dissector_add()" and
"dissector_delete()" a "const char *" rarther than just a "char *".
Add "heur_dissector_add()", the routine to add a heuristic dissector to
a list of heuristic dissectors, to the set of routines we can export to
plugins through a table on platforms where dynamically-loaded code can't
call stuff in the main program, and initialize the element in the table
in question for "dissector_add()" (which we'd forgotten to do).
svn path=/trunk/; revision=1909
2000-05-05 09:32:36 +00:00
|
|
|
}
|
|
|
|
|
2007-08-07 21:26:07 +00:00
|
|
|
|
|
|
|
|
2012-01-20 02:43:37 +00:00
|
|
|
static int
|
2018-02-08 08:31:29 +00:00
|
|
|
find_matching_heur_dissector(gconstpointer a, gconstpointer b) {
|
2012-01-20 02:43:37 +00:00
|
|
|
const heur_dtbl_entry_t *hdtbl_entry_a = (const heur_dtbl_entry_t *) a;
|
|
|
|
const heur_dtbl_entry_t *hdtbl_entry_b = (const heur_dtbl_entry_t *) b;
|
2013-08-29 02:05:31 +00:00
|
|
|
|
2012-01-20 02:43:37 +00:00
|
|
|
return (hdtbl_entry_a->dissector == hdtbl_entry_b->dissector) &&
|
|
|
|
(hdtbl_entry_a->protocol == hdtbl_entry_b->protocol) ? 0 : 1;
|
2007-08-07 21:26:07 +00:00
|
|
|
}
|
|
|
|
|
2012-01-20 02:43:37 +00:00
|
|
|
void
|
|
|
|
heur_dissector_delete(const char *name, heur_dissector_t dissector, const int proto) {
|
2014-12-21 04:13:28 +00:00
|
|
|
heur_dissector_list_t sub_dissectors = find_heur_dissector_list(name);
|
2012-01-20 02:43:37 +00:00
|
|
|
heur_dtbl_entry_t hdtbl_entry;
|
|
|
|
GSList *found_entry;
|
2008-05-21 20:20:37 +00:00
|
|
|
|
2007-08-07 21:26:07 +00:00
|
|
|
/* sanity check */
|
|
|
|
g_assert(sub_dissectors != NULL);
|
|
|
|
|
2012-01-20 02:43:37 +00:00
|
|
|
hdtbl_entry.dissector = dissector;
|
|
|
|
hdtbl_entry.protocol = find_protocol_by_id(proto);
|
2007-08-07 21:26:07 +00:00
|
|
|
|
2014-12-21 07:32:23 +00:00
|
|
|
found_entry = g_slist_find_custom(sub_dissectors->dissectors,
|
|
|
|
(gpointer) &hdtbl_entry, find_matching_heur_dissector);
|
2007-08-07 21:26:07 +00:00
|
|
|
|
|
|
|
if (found_entry) {
|
2016-03-11 19:54:26 +00:00
|
|
|
heur_dtbl_entry_t *found_hdtbl_entry = (heur_dtbl_entry_t *)(found_entry->data);
|
|
|
|
g_free(found_hdtbl_entry->list_name);
|
2016-04-05 16:24:25 +00:00
|
|
|
g_hash_table_remove(heuristic_short_names, found_hdtbl_entry->short_name);
|
2016-12-21 01:23:35 +00:00
|
|
|
g_free(found_hdtbl_entry->short_name);
|
2013-10-11 01:11:21 +00:00
|
|
|
g_slice_free(heur_dtbl_entry_t, found_entry->data);
|
2014-12-21 07:32:23 +00:00
|
|
|
sub_dissectors->dissectors = g_slist_delete_link(sub_dissectors->dissectors,
|
|
|
|
found_entry);
|
2007-08-07 21:26:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Allow either old-style (pre-tvbuff) or new-style (tvbuffified)
dissectors to be registered as dissectors for particular ports,
registered as heuristic dissectors, and registered as dissectors for
conversations, and have routines to be used both by old-style and
new-style dissectors to call registered dissectors.
Have the code that calls those dissectors translate the arguments as
necessary. (For conversation dissectors, replace
"find_conversation_dissector()", which just returns a pointer to the
dissector, with "old_try_conversation_dissector()" and
"try_conversation_dissector()", which actually call the dissector, so
that there's a single place at which we can do that translation. Also
make "dissector_lookup()" static and, instead of calling it and, if it
returns a non-null pointer, calling that dissector, just use
"old_dissector_try_port()" or "dissector_try_port()", for the same
reason.)
This allows some dissectors that took old-style arguments and
immediately translated them to new-style arguments to just take
new-style arguments; make them do so. It also allows some new-style
dissectors not to have to translate arguments before calling routines to
look up and call dissectors; make them not do so.
Get rid of checks for too-short frames in new-style dissectors - the
tvbuff code does those checks for you.
Give the routines to register old-style dissectors, and to call
dissectors from old-style dissectors, names beginning with "old_", with
the routines for new-style dissectors not having the "old_". Update the
dissectors that use those routines appropriately.
Rename "dissect_data()" to "old_dissect_data()", and
"dissect_data_tvb()" to "dissect_data()".
svn path=/trunk/; revision=2218
2000-08-07 03:21:25 +00:00
|
|
|
gboolean
|
2012-09-11 08:26:48 +00:00
|
|
|
dissector_try_heuristic(heur_dissector_list_t sub_dissectors, tvbuff_t *tvb,
|
2014-05-20 10:54:20 +00:00
|
|
|
packet_info *pinfo, proto_tree *tree, heur_dtbl_entry_t **heur_dtbl_entry, void *data)
|
Allow either old-style (pre-tvbuff) or new-style (tvbuffified)
dissectors to be registered as dissectors for particular ports,
registered as heuristic dissectors, and registered as dissectors for
conversations, and have routines to be used both by old-style and
new-style dissectors to call registered dissectors.
Have the code that calls those dissectors translate the arguments as
necessary. (For conversation dissectors, replace
"find_conversation_dissector()", which just returns a pointer to the
dissector, with "old_try_conversation_dissector()" and
"try_conversation_dissector()", which actually call the dissector, so
that there's a single place at which we can do that translation. Also
make "dissector_lookup()" static and, instead of calling it and, if it
returns a non-null pointer, calling that dissector, just use
"old_dissector_try_port()" or "dissector_try_port()", for the same
reason.)
This allows some dissectors that took old-style arguments and
immediately translated them to new-style arguments to just take
new-style arguments; make them do so. It also allows some new-style
dissectors not to have to translate arguments before calling routines to
look up and call dissectors; make them not do so.
Get rid of checks for too-short frames in new-style dissectors - the
tvbuff code does those checks for you.
Give the routines to register old-style dissectors, and to call
dissectors from old-style dissectors, names beginning with "old_", with
the routines for new-style dissectors not having the "old_". Update the
dissectors that use those routines appropriately.
Rename "dissect_data()" to "old_dissect_data()", and
"dissect_data_tvb()" to "dissect_data()".
svn path=/trunk/; revision=2218
2000-08-07 03:21:25 +00:00
|
|
|
{
|
2012-01-20 02:43:37 +00:00
|
|
|
gboolean status;
|
2014-03-10 05:54:51 +00:00
|
|
|
const char *saved_curr_proto;
|
|
|
|
const char *saved_heur_list_name;
|
2012-01-20 02:43:37 +00:00
|
|
|
GSList *entry;
|
|
|
|
guint16 saved_can_desegment;
|
2013-11-05 17:48:48 +00:00
|
|
|
guint saved_layers_len = 0;
|
2014-05-20 10:54:20 +00:00
|
|
|
heur_dtbl_entry_t *hdtbl_entry;
|
|
|
|
int proto_id;
|
2017-09-11 22:11:45 +00:00
|
|
|
int len;
|
|
|
|
int saved_tree_count = tree ? tree->tree_data->count : 0;
|
2001-11-29 09:05:25 +00:00
|
|
|
|
|
|
|
/* can_desegment is set to 2 by anyone which offers this api/service.
|
|
|
|
then everytime a subdissector is called it is decremented by one.
|
|
|
|
thus only the subdissector immediately ontop of whoever offers this
|
|
|
|
service can use it.
|
2003-12-29 22:44:50 +00:00
|
|
|
We save the current value of "can_desegment" for the
|
|
|
|
benefit of TCP proxying dissectors such as SOCKS, so they
|
|
|
|
can restore it and allow the dissectors they call to use
|
|
|
|
the desegmentation service.
|
2001-11-29 09:05:25 +00:00
|
|
|
*/
|
2012-01-20 02:43:37 +00:00
|
|
|
saved_can_desegment = pinfo->can_desegment;
|
2003-12-29 22:44:50 +00:00
|
|
|
pinfo->saved_can_desegment = saved_can_desegment;
|
2012-01-20 02:43:37 +00:00
|
|
|
pinfo->can_desegment = saved_can_desegment-(saved_can_desegment>0);
|
Add routines to:
register lists of "heuristic" dissectors, which are handed a
frame that may or may contain a payload for the protocol they
dissect, and that return FALSE if it's not or dissect the packet
and return TRUE if it is;
add a dissector to such a list;
go through such a list, calling each dissector until either a
dissector returns TRUE, in which case the routine returns TRUE,
or it runs out of entries in the list, in which case the routine
returns FALSE.
Have lists of heuristic dissectors for TCP and for COTP when used with
the Inactive Subset of CLNP, and add the GIOP and Yahoo Messenger
dissectors to the first list and the Sinec H1 dissector to the second
list.
Make the dissector name argument to "dissector_add()" and
"dissector_delete()" a "const char *" rarther than just a "char *".
Add "heur_dissector_add()", the routine to add a heuristic dissector to
a list of heuristic dissectors, to the set of routines we can export to
plugins through a table on platforms where dynamically-loaded code can't
call stuff in the main program, and initialize the element in the table
in question for "dissector_add()" (which we'd forgotten to do).
svn path=/trunk/; revision=1909
2000-05-05 09:32:36 +00:00
|
|
|
|
2012-01-20 02:43:37 +00:00
|
|
|
status = FALSE;
|
2014-03-10 05:54:51 +00:00
|
|
|
saved_curr_proto = pinfo->current_proto;
|
|
|
|
saved_heur_list_name = pinfo->heur_list_name;
|
2005-01-20 11:05:06 +00:00
|
|
|
|
2013-11-05 17:48:48 +00:00
|
|
|
saved_layers_len = wmem_list_count(pinfo->layers);
|
2014-05-20 10:54:20 +00:00
|
|
|
*heur_dtbl_entry = NULL;
|
2005-01-20 11:05:06 +00:00
|
|
|
|
2014-12-21 07:32:23 +00:00
|
|
|
for (entry = sub_dissectors->dissectors; entry != NULL;
|
2014-12-21 04:13:28 +00:00
|
|
|
entry = g_slist_next(entry)) {
|
2003-12-29 22:44:50 +00:00
|
|
|
/* XXX - why set this now and above? */
|
2001-11-29 09:05:25 +00:00
|
|
|
pinfo->can_desegment = saved_can_desegment-(saved_can_desegment>0);
|
2012-01-20 02:43:37 +00:00
|
|
|
hdtbl_entry = (heur_dtbl_entry_t *)entry->data;
|
2005-01-20 11:05:06 +00:00
|
|
|
|
2012-01-20 02:43:37 +00:00
|
|
|
if (hdtbl_entry->protocol != NULL &&
|
2014-05-20 10:54:20 +00:00
|
|
|
(!proto_is_protocol_enabled(hdtbl_entry->protocol)||(hdtbl_entry->enabled==FALSE))) {
|
In "{old_}dissector_try_port()", check whether the protocol for the
dissector is enabled and, if not, return FALSE, just as if there hadn't
been any entry for that port number in the table. If it is enabled, set
"pinfo->current_proto" from its short name before calling the dissector.
In "dissector_try_heuristic()", check whether the protocols for
dissectors are enabled and, if not, skip those dissectors, just as if
they hadn't been in the table. (We don't set "pinfo->current_proto"
before calling a dissector, as we don't know whether the dissector in
question will be the one to dissect the packet. Arguably, we should
have, for heuristic dissectors, separate "recognize" and "dissect"
routines, where the former never throws an exception and returns TRUE or
FALSE, and the latter is called only if the "recognize" routine claimed
the frame, and is just a "dissector_t" that doesn't return a value.)
In "{old_}call_dissector()", check whether the protocol for the
dissector is enabled and, if not, call "{old_}dissect_data()". if it is
enabled, set "pinfo->current_proto" from its short name before calling
the dissector.
svn path=/trunk/; revision=2861
2001-01-10 10:44:48 +00:00
|
|
|
/*
|
|
|
|
* No - don't try this dissector.
|
|
|
|
*/
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2012-01-20 02:43:37 +00:00
|
|
|
if (hdtbl_entry->protocol != NULL) {
|
2016-05-09 21:06:28 +00:00
|
|
|
proto_id = proto_get_id(hdtbl_entry->protocol);
|
2014-03-10 05:54:51 +00:00
|
|
|
/* do NOT change this behavior - wslua uses the protocol short name set here in order
|
|
|
|
to determine which Lua-based heurisitc dissector to call */
|
2001-05-30 06:41:08 +00:00
|
|
|
pinfo->current_proto =
|
2012-01-20 02:43:37 +00:00
|
|
|
proto_get_protocol_short_name(hdtbl_entry->protocol);
|
2005-01-20 11:05:06 +00:00
|
|
|
|
2006-03-07 13:48:54 +00:00
|
|
|
/*
|
|
|
|
* Add the protocol name to the layers; we'll remove it
|
|
|
|
* if the dissector fails.
|
|
|
|
*/
|
2017-09-11 22:11:45 +00:00
|
|
|
pinfo->curr_layer_num++;
|
2014-05-20 10:54:20 +00:00
|
|
|
wmem_list_append(pinfo->layers, GINT_TO_POINTER(proto_id));
|
2005-01-20 11:05:06 +00:00
|
|
|
}
|
2014-03-10 05:54:51 +00:00
|
|
|
|
|
|
|
pinfo->heur_list_name = hdtbl_entry->list_name;
|
|
|
|
|
2017-09-11 22:11:45 +00:00
|
|
|
len = (hdtbl_entry->dissector)(tvb, pinfo, tree, data);
|
|
|
|
if (hdtbl_entry->protocol != NULL &&
|
|
|
|
(len == 0 || (tree && saved_tree_count == tree->tree_data->count))) {
|
2005-01-20 11:05:06 +00:00
|
|
|
/*
|
2017-09-11 22:11:45 +00:00
|
|
|
* We added a protocol layer above. The dissector
|
|
|
|
* didn't accept the packet or it didn't add any
|
|
|
|
* items to the tree so remove it from the list.
|
2005-01-20 11:05:06 +00:00
|
|
|
*/
|
2013-11-05 17:48:48 +00:00
|
|
|
while (wmem_list_count(pinfo->layers) > saved_layers_len) {
|
2017-09-11 22:11:45 +00:00
|
|
|
pinfo->curr_layer_num--;
|
2013-11-05 17:48:48 +00:00
|
|
|
wmem_list_remove_frame(pinfo->layers, wmem_list_tail(pinfo->layers));
|
2009-10-12 01:31:01 +00:00
|
|
|
}
|
Allow either old-style (pre-tvbuff) or new-style (tvbuffified)
dissectors to be registered as dissectors for particular ports,
registered as heuristic dissectors, and registered as dissectors for
conversations, and have routines to be used both by old-style and
new-style dissectors to call registered dissectors.
Have the code that calls those dissectors translate the arguments as
necessary. (For conversation dissectors, replace
"find_conversation_dissector()", which just returns a pointer to the
dissector, with "old_try_conversation_dissector()" and
"try_conversation_dissector()", which actually call the dissector, so
that there's a single place at which we can do that translation. Also
make "dissector_lookup()" static and, instead of calling it and, if it
returns a non-null pointer, calling that dissector, just use
"old_dissector_try_port()" or "dissector_try_port()", for the same
reason.)
This allows some dissectors that took old-style arguments and
immediately translated them to new-style arguments to just take
new-style arguments; make them do so. It also allows some new-style
dissectors not to have to translate arguments before calling routines to
look up and call dissectors; make them not do so.
Get rid of checks for too-short frames in new-style dissectors - the
tvbuff code does those checks for you.
Give the routines to register old-style dissectors, and to call
dissectors from old-style dissectors, names beginning with "old_", with
the routines for new-style dissectors not having the "old_". Update the
dissectors that use those routines appropriately.
Rename "dissect_data()" to "old_dissect_data()", and
"dissect_data_tvb()" to "dissect_data()".
svn path=/trunk/; revision=2218
2000-08-07 03:21:25 +00:00
|
|
|
}
|
2017-10-05 19:39:10 +00:00
|
|
|
if (len) {
|
|
|
|
*heur_dtbl_entry = hdtbl_entry;
|
|
|
|
status = TRUE;
|
|
|
|
break;
|
|
|
|
}
|
Add routines to:
register lists of "heuristic" dissectors, which are handed a
frame that may or may contain a payload for the protocol they
dissect, and that return FALSE if it's not or dissect the packet
and return TRUE if it is;
add a dissector to such a list;
go through such a list, calling each dissector until either a
dissector returns TRUE, in which case the routine returns TRUE,
or it runs out of entries in the list, in which case the routine
returns FALSE.
Have lists of heuristic dissectors for TCP and for COTP when used with
the Inactive Subset of CLNP, and add the GIOP and Yahoo Messenger
dissectors to the first list and the Sinec H1 dissector to the second
list.
Make the dissector name argument to "dissector_add()" and
"dissector_delete()" a "const char *" rarther than just a "char *".
Add "heur_dissector_add()", the routine to add a heuristic dissector to
a list of heuristic dissectors, to the set of routines we can export to
plugins through a table on platforms where dynamically-loaded code can't
call stuff in the main program, and initialize the element in the table
in question for "dissector_add()" (which we'd forgotten to do).
svn path=/trunk/; revision=1909
2000-05-05 09:32:36 +00:00
|
|
|
}
|
2014-03-10 05:54:51 +00:00
|
|
|
|
|
|
|
pinfo->current_proto = saved_curr_proto;
|
|
|
|
pinfo->heur_list_name = saved_heur_list_name;
|
|
|
|
pinfo->can_desegment = saved_can_desegment;
|
2001-01-12 09:25:29 +00:00
|
|
|
return status;
|
Add routines to:
register lists of "heuristic" dissectors, which are handed a
frame that may or may contain a payload for the protocol they
dissect, and that return FALSE if it's not or dissect the packet
and return TRUE if it is;
add a dissector to such a list;
go through such a list, calling each dissector until either a
dissector returns TRUE, in which case the routine returns TRUE,
or it runs out of entries in the list, in which case the routine
returns FALSE.
Have lists of heuristic dissectors for TCP and for COTP when used with
the Inactive Subset of CLNP, and add the GIOP and Yahoo Messenger
dissectors to the first list and the Sinec H1 dissector to the second
list.
Make the dissector name argument to "dissector_add()" and
"dissector_delete()" a "const char *" rarther than just a "char *".
Add "heur_dissector_add()", the routine to add a heuristic dissector to
a list of heuristic dissectors, to the set of routines we can export to
plugins through a table on platforms where dynamically-loaded code can't
call stuff in the main program, and initialize the element in the table
in question for "dissector_add()" (which we'd forgotten to do).
svn path=/trunk/; revision=1909
2000-05-05 09:32:36 +00:00
|
|
|
}
|
|
|
|
|
2014-12-11 04:15:36 +00:00
|
|
|
typedef struct heur_dissector_foreach_info {
|
|
|
|
gpointer caller_data;
|
|
|
|
DATFunc_heur caller_func;
|
|
|
|
GHFunc next_func;
|
|
|
|
const gchar *table_name;
|
|
|
|
} heur_dissector_foreach_info_t;
|
|
|
|
|
2011-09-05 13:04:23 +00:00
|
|
|
/*
|
2014-12-11 04:15:36 +00:00
|
|
|
* Called for each entry in a heuristic dissector table.
|
2011-09-05 13:04:23 +00:00
|
|
|
*/
|
2014-12-11 04:15:36 +00:00
|
|
|
static void
|
|
|
|
heur_dissector_table_foreach_func (gpointer data, gpointer user_data)
|
|
|
|
{
|
|
|
|
heur_dissector_foreach_info_t *info;
|
2011-09-05 13:04:23 +00:00
|
|
|
|
2014-12-11 04:15:36 +00:00
|
|
|
g_assert(data);
|
|
|
|
g_assert(user_data);
|
2011-12-28 15:05:59 +00:00
|
|
|
|
2014-12-11 04:15:36 +00:00
|
|
|
info = (heur_dissector_foreach_info_t *)user_data;
|
|
|
|
info->caller_func(info->table_name, (heur_dtbl_entry_t *)data,
|
|
|
|
info->caller_data);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Walk one heuristic dissector table's list calling a user supplied function
|
|
|
|
* on each entry.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
heur_dissector_table_foreach (const char *table_name,
|
|
|
|
DATFunc_heur func,
|
|
|
|
gpointer user_data)
|
2011-12-28 15:05:59 +00:00
|
|
|
{
|
2014-12-11 04:15:36 +00:00
|
|
|
heur_dissector_foreach_info_t info;
|
2014-12-21 04:13:28 +00:00
|
|
|
heur_dissector_list_t sub_dissectors = find_heur_dissector_list(table_name);
|
2011-12-28 15:05:59 +00:00
|
|
|
|
2014-12-11 04:15:36 +00:00
|
|
|
info.table_name = table_name;
|
|
|
|
info.caller_func = func;
|
|
|
|
info.caller_data = user_data;
|
2014-12-21 07:32:23 +00:00
|
|
|
g_slist_foreach(sub_dissectors->dissectors,
|
|
|
|
heur_dissector_table_foreach_func, &info);
|
2011-12-28 15:05:59 +00:00
|
|
|
}
|
|
|
|
|
2014-12-11 04:15:36 +00:00
|
|
|
/*
|
|
|
|
* Called for each entry in the table of all heuristic dissector tables.
|
|
|
|
*/
|
|
|
|
typedef struct heur_dissector_foreach_table_info {
|
|
|
|
gpointer caller_data;
|
|
|
|
DATFunc_heur_table caller_func;
|
|
|
|
} heur_dissector_foreach_table_info_t;
|
2011-12-28 15:05:59 +00:00
|
|
|
|
2014-12-11 03:04:50 +00:00
|
|
|
/*
|
|
|
|
* Called for each entry in the table of all heuristic dissector tables.
|
|
|
|
* This is used if we directly process the hash table.
|
|
|
|
*/
|
2011-09-05 13:04:23 +00:00
|
|
|
static void
|
2016-01-05 12:06:36 +00:00
|
|
|
dissector_all_heur_tables_foreach_table_func (gpointer key, gpointer value, gpointer user_data)
|
2011-09-05 13:04:23 +00:00
|
|
|
{
|
|
|
|
heur_dissector_foreach_table_info_t *info;
|
|
|
|
|
2013-03-14 06:46:29 +00:00
|
|
|
info = (heur_dissector_foreach_table_info_t *)user_data;
|
2016-01-05 12:06:36 +00:00
|
|
|
(*info->caller_func)((gchar *)key, (struct heur_dissector_list *)value, info->caller_data);
|
2011-09-05 13:04:23 +00:00
|
|
|
}
|
|
|
|
|
2014-12-11 03:04:50 +00:00
|
|
|
/*
|
|
|
|
* Called for each key in the table of all dissector tables.
|
|
|
|
* This is used if we get a list of table names, sort it, and process the list.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
dissector_all_heur_tables_foreach_list_func (gpointer key, gpointer user_data)
|
|
|
|
{
|
2015-09-25 21:33:54 +00:00
|
|
|
struct heur_dissector_list *list;
|
2014-12-11 03:04:50 +00:00
|
|
|
heur_dissector_foreach_table_info_t *info;
|
|
|
|
|
2015-09-25 21:33:54 +00:00
|
|
|
list = (struct heur_dissector_list *)g_hash_table_lookup(heur_dissector_lists, key);
|
2014-12-11 03:04:50 +00:00
|
|
|
info = (heur_dissector_foreach_table_info_t *)user_data;
|
|
|
|
(*info->caller_func)((gchar*)key, list, info->caller_data);
|
|
|
|
}
|
|
|
|
|
2011-09-05 13:04:23 +00:00
|
|
|
/*
|
|
|
|
* Walk all heuristic dissector tables calling a user supplied function on each
|
|
|
|
* table.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
dissector_all_heur_tables_foreach_table (DATFunc_heur_table func,
|
2014-12-11 03:04:50 +00:00
|
|
|
gpointer user_data,
|
|
|
|
GCompareFunc compare_key_func)
|
2011-09-05 13:04:23 +00:00
|
|
|
{
|
|
|
|
heur_dissector_foreach_table_info_t info;
|
2014-12-11 03:04:50 +00:00
|
|
|
GList *list;
|
2011-09-05 13:04:23 +00:00
|
|
|
|
|
|
|
info.caller_data = user_data;
|
|
|
|
info.caller_func = func;
|
2014-12-11 03:04:50 +00:00
|
|
|
if (compare_key_func != NULL)
|
|
|
|
{
|
|
|
|
list = g_hash_table_get_keys(dissector_tables);
|
|
|
|
list = g_list_sort(list, compare_key_func);
|
|
|
|
g_list_foreach(list, dissector_all_heur_tables_foreach_list_func, &info);
|
|
|
|
g_list_free(list);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
g_hash_table_foreach(heur_dissector_lists, dissector_all_heur_tables_foreach_table_func, &info);
|
|
|
|
}
|
2011-09-05 13:04:23 +00:00
|
|
|
}
|
|
|
|
|
2014-12-11 04:15:36 +00:00
|
|
|
static void
|
|
|
|
display_heur_dissector_table_entries(const char *table_name,
|
|
|
|
heur_dtbl_entry_t *hdtbl_entry, gpointer user_data _U_)
|
|
|
|
{
|
|
|
|
if (hdtbl_entry->protocol != NULL) {
|
2016-07-24 12:53:39 +00:00
|
|
|
ws_debug_printf("%s\t%s\t%c\n",
|
2014-12-11 04:15:36 +00:00
|
|
|
table_name,
|
|
|
|
proto_get_protocol_filter_name(proto_get_id(hdtbl_entry->protocol)),
|
|
|
|
(proto_is_protocol_enabled(hdtbl_entry->protocol) && hdtbl_entry->enabled) ? 'T' : 'F');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2016-01-05 12:06:36 +00:00
|
|
|
dissector_dump_heur_decodes_display(const gchar *table_name, struct heur_dissector_list *listptr _U_, gpointer user_data _U_)
|
2014-12-11 04:15:36 +00:00
|
|
|
{
|
|
|
|
heur_dissector_table_foreach(table_name, display_heur_dissector_table_entries, NULL);
|
|
|
|
}
|
|
|
|
|
2011-12-28 15:05:59 +00:00
|
|
|
/*
|
|
|
|
* For each heuristic dissector table, dump list of dissectors (filter_names) for that table
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
dissector_dump_heur_decodes(void)
|
|
|
|
{
|
2014-12-11 03:04:50 +00:00
|
|
|
dissector_all_heur_tables_foreach_table(dissector_dump_heur_decodes_display, NULL, NULL);
|
2011-12-28 15:05:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-12-21 04:13:28 +00:00
|
|
|
heur_dissector_list_t
|
2016-03-13 11:51:45 +00:00
|
|
|
register_heur_dissector_list(const char *name, const int proto)
|
Add routines to:
register lists of "heuristic" dissectors, which are handed a
frame that may or may contain a payload for the protocol they
dissect, and that return FALSE if it's not or dissect the packet
and return TRUE if it is;
add a dissector to such a list;
go through such a list, calling each dissector until either a
dissector returns TRUE, in which case the routine returns TRUE,
or it runs out of entries in the list, in which case the routine
returns FALSE.
Have lists of heuristic dissectors for TCP and for COTP when used with
the Inactive Subset of CLNP, and add the GIOP and Yahoo Messenger
dissectors to the first list and the Sinec H1 dissector to the second
list.
Make the dissector name argument to "dissector_add()" and
"dissector_delete()" a "const char *" rarther than just a "char *".
Add "heur_dissector_add()", the routine to add a heuristic dissector to
a list of heuristic dissectors, to the set of routines we can export to
plugins through a table on platforms where dynamically-loaded code can't
call stuff in the main program, and initialize the element in the table
in question for "dissector_add()" (which we'd forgotten to do).
svn path=/trunk/; revision=1909
2000-05-05 09:32:36 +00:00
|
|
|
{
|
2014-12-21 04:13:28 +00:00
|
|
|
heur_dissector_list_t sub_dissectors;
|
|
|
|
|
Add routines to:
register lists of "heuristic" dissectors, which are handed a
frame that may or may contain a payload for the protocol they
dissect, and that return FALSE if it's not or dissect the packet
and return TRUE if it is;
add a dissector to such a list;
go through such a list, calling each dissector until either a
dissector returns TRUE, in which case the routine returns TRUE,
or it runs out of entries in the list, in which case the routine
returns FALSE.
Have lists of heuristic dissectors for TCP and for COTP when used with
the Inactive Subset of CLNP, and add the GIOP and Yahoo Messenger
dissectors to the first list and the Sinec H1 dissector to the second
list.
Make the dissector name argument to "dissector_add()" and
"dissector_delete()" a "const char *" rarther than just a "char *".
Add "heur_dissector_add()", the routine to add a heuristic dissector to
a list of heuristic dissectors, to the set of routines we can export to
plugins through a table on platforms where dynamically-loaded code can't
call stuff in the main program, and initialize the element in the table
in question for "dissector_add()" (which we'd forgotten to do).
svn path=/trunk/; revision=1909
2000-05-05 09:32:36 +00:00
|
|
|
/* Make sure the registration is unique */
|
2014-12-21 07:25:55 +00:00
|
|
|
if (g_hash_table_lookup(heur_dissector_lists, name) != NULL) {
|
|
|
|
g_error("The heuristic dissector list %s is already registered - are you using a buggy plugin?", name);
|
|
|
|
}
|
Add routines to:
register lists of "heuristic" dissectors, which are handed a
frame that may or may contain a payload for the protocol they
dissect, and that return FALSE if it's not or dissect the packet
and return TRUE if it is;
add a dissector to such a list;
go through such a list, calling each dissector until either a
dissector returns TRUE, in which case the routine returns TRUE,
or it runs out of entries in the list, in which case the routine
returns FALSE.
Have lists of heuristic dissectors for TCP and for COTP when used with
the Inactive Subset of CLNP, and add the GIOP and Yahoo Messenger
dissectors to the first list and the Sinec H1 dissector to the second
list.
Make the dissector name argument to "dissector_add()" and
"dissector_delete()" a "const char *" rarther than just a "char *".
Add "heur_dissector_add()", the routine to add a heuristic dissector to
a list of heuristic dissectors, to the set of routines we can export to
plugins through a table on platforms where dynamically-loaded code can't
call stuff in the main program, and initialize the element in the table
in question for "dissector_add()" (which we'd forgotten to do).
svn path=/trunk/; revision=1909
2000-05-05 09:32:36 +00:00
|
|
|
|
2014-12-21 07:32:23 +00:00
|
|
|
/* Create and register the dissector table for this name; returns */
|
|
|
|
/* a pointer to the dissector table. */
|
2014-12-21 04:13:28 +00:00
|
|
|
sub_dissectors = g_slice_new(struct heur_dissector_list);
|
2016-03-13 11:51:45 +00:00
|
|
|
sub_dissectors->protocol = find_protocol_by_id(proto);
|
2014-12-21 07:32:23 +00:00
|
|
|
sub_dissectors->dissectors = NULL; /* initially empty */
|
Add routines to:
register lists of "heuristic" dissectors, which are handed a
frame that may or may contain a payload for the protocol they
dissect, and that return FALSE if it's not or dissect the packet
and return TRUE if it is;
add a dissector to such a list;
go through such a list, calling each dissector until either a
dissector returns TRUE, in which case the routine returns TRUE,
or it runs out of entries in the list, in which case the routine
returns FALSE.
Have lists of heuristic dissectors for TCP and for COTP when used with
the Inactive Subset of CLNP, and add the GIOP and Yahoo Messenger
dissectors to the first list and the Sinec H1 dissector to the second
list.
Make the dissector name argument to "dissector_add()" and
"dissector_delete()" a "const char *" rarther than just a "char *".
Add "heur_dissector_add()", the routine to add a heuristic dissector to
a list of heuristic dissectors, to the set of routines we can export to
plugins through a table on platforms where dynamically-loaded code can't
call stuff in the main program, and initialize the element in the table
in question for "dissector_add()" (which we'd forgotten to do).
svn path=/trunk/; revision=1909
2000-05-05 09:32:36 +00:00
|
|
|
g_hash_table_insert(heur_dissector_lists, (gpointer)name,
|
2009-10-12 01:31:01 +00:00
|
|
|
(gpointer) sub_dissectors);
|
2014-12-21 04:13:28 +00:00
|
|
|
return sub_dissectors;
|
Add tables of "conversation" dissectors, which are associated with
particular protocols, and which keep track of all dissectors that could
be associated with conversations using those particular protocols - for
example, the RTP and RTCP dissectors could be assigned to UDP
conversations.
This is for future use with UI features allowing the dissector for a
given conversation to be set from the UI, to allow
1) conversations between two ports, both of which have
dissectors associated with them, that have been given to the
wrong dissector to be given to the right dissector;
2) conversations between two ports, neither of which have
dissectors associated with them, to be given to a dissector
(RTP and RTCP, for example, typically run on random ports,
and if you don't have, in a capture, traffic that would say
"OK, traffic between these two hosts and ports will be RTP
traffic", you may have to tell Ethereal explicitly what
protocol the conversation is).
svn path=/trunk/; revision=2848
2001-01-09 05:53:21 +00:00
|
|
|
}
|
|
|
|
|
Add a mechanism by which a dissector can be registered by name, another
dissector can get a "handle" for that dissector by name and then call
that dissector through the handle.
This allows dissectors that can't be called through a port table or a
heuristic table to be called from other dissectors without directly
referring to the dissector function - dynamically-loaded modules, under
Windows, cannot directly call functions in the main program, and
non-plugin dissectors are in the main program and thus cannot be called
from plugin dissectors unless either
1) a pointer to the dissector is put in the Big Transfer Vector
or
2) some other mechanism for getting a pointer to the dissector
is provided.
This mechanism could also support registering old-style dissectors and
calling them from new-style dissectors without the new-style dissector
having to do the argument translation itself (I didn't add support for
registering old-style dissectors because I'd prefer to have people
tvbuffify their code if they have to register a dissector...).
It could also, in the future, perhaps support
disabling of protocols;
setting "pinfo->current_proto";
inside "call_dissector()" - and inside "{old_}dissector_try_port()" and
"{old_"dissector_try_heuristic()" - allowing a pile of stuff that
currently has to be done in every dissector be done by common code.
(I have some ideas about how to do this, by
having "proto_register_protocol()" take an abbreviation - of the
sort that would be put in, for example, "pinfo->current_proto" -
as an argument;
having the calls to register dissectors take an index returned
by "proto_register_protocol()" as an argument.
The abbreviation could be used elsewhere as well, e.g. in the "Decoding"
tab of the "Edit->Protocols" dialog box, and in a GUI for constructing
protocol filters. Watch this space.)
Make "dissect_sdp()" the first client of this mechanism; it's now static
to "packet-sdp.c", and all dissectors that call it - including the MGCP
plugin - now call it through a dissector handle fetched by
"find_dissector()". (Next step - see if Ethereal can now compile on
Windows as a result of this.)
svn path=/trunk/; revision=2647
2000-11-15 07:07:52 +00:00
|
|
|
/*
|
|
|
|
* Register dissectors by name; used if one dissector always calls a
|
|
|
|
* particular dissector, or if it bases the decision of which dissector
|
|
|
|
* to call on something other than a numerical value or on "try a bunch
|
|
|
|
* of dissectors until one likes the packet".
|
|
|
|
*/
|
|
|
|
|
2011-03-31 12:14:59 +00:00
|
|
|
/* Get the long name of the protocol for a dissector handle, if it has
|
|
|
|
a protocol. */
|
|
|
|
const char *
|
|
|
|
dissector_handle_get_long_name(const dissector_handle_t handle)
|
|
|
|
{
|
|
|
|
if (handle == NULL || handle->protocol == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return proto_get_protocol_long_name(handle->protocol);
|
|
|
|
}
|
|
|
|
|
2004-02-28 20:59:23 +00:00
|
|
|
/* Get the short name of the protocol for a dissector handle, if it has
|
|
|
|
a protocol. */
|
2005-07-24 19:01:28 +00:00
|
|
|
const char *
|
2010-04-03 18:18:50 +00:00
|
|
|
dissector_handle_get_short_name(const dissector_handle_t handle)
|
2001-12-03 04:00:26 +00:00
|
|
|
{
|
2004-02-28 20:59:23 +00:00
|
|
|
if (handle->protocol == NULL) {
|
|
|
|
/*
|
|
|
|
* No protocol (see, for example, the handle for
|
|
|
|
* dissecting the set of protocols where the first
|
|
|
|
* octet of the payload is an OSI network layer protocol
|
|
|
|
* ID).
|
|
|
|
*/
|
|
|
|
return NULL;
|
|
|
|
}
|
2003-11-16 23:17:27 +00:00
|
|
|
return proto_get_protocol_short_name(handle->protocol);
|
2001-12-03 04:00:26 +00:00
|
|
|
}
|
Add a mechanism by which a dissector can be registered by name, another
dissector can get a "handle" for that dissector by name and then call
that dissector through the handle.
This allows dissectors that can't be called through a port table or a
heuristic table to be called from other dissectors without directly
referring to the dissector function - dynamically-loaded modules, under
Windows, cannot directly call functions in the main program, and
non-plugin dissectors are in the main program and thus cannot be called
from plugin dissectors unless either
1) a pointer to the dissector is put in the Big Transfer Vector
or
2) some other mechanism for getting a pointer to the dissector
is provided.
This mechanism could also support registering old-style dissectors and
calling them from new-style dissectors without the new-style dissector
having to do the argument translation itself (I didn't add support for
registering old-style dissectors because I'd prefer to have people
tvbuffify their code if they have to register a dissector...).
It could also, in the future, perhaps support
disabling of protocols;
setting "pinfo->current_proto";
inside "call_dissector()" - and inside "{old_}dissector_try_port()" and
"{old_"dissector_try_heuristic()" - allowing a pile of stuff that
currently has to be done in every dissector be done by common code.
(I have some ideas about how to do this, by
having "proto_register_protocol()" take an abbreviation - of the
sort that would be put in, for example, "pinfo->current_proto" -
as an argument;
having the calls to register dissectors take an index returned
by "proto_register_protocol()" as an argument.
The abbreviation could be used elsewhere as well, e.g. in the "Decoding"
tab of the "Edit->Protocols" dialog box, and in a GUI for constructing
protocol filters. Watch this space.)
Make "dissect_sdp()" the first client of this mechanism; it's now static
to "packet-sdp.c", and all dissectors that call it - including the MGCP
plugin - now call it through a dissector handle fetched by
"find_dissector()". (Next step - see if Ethereal can now compile on
Windows as a result of this.)
svn path=/trunk/; revision=2647
2000-11-15 07:07:52 +00:00
|
|
|
|
2004-02-28 20:59:23 +00:00
|
|
|
/* Get the index of the protocol for a dissector handle, if it has
|
|
|
|
a protocol. */
|
2002-11-15 03:10:36 +00:00
|
|
|
int
|
2010-04-03 18:18:50 +00:00
|
|
|
dissector_handle_get_protocol_index(const dissector_handle_t handle)
|
2002-11-15 03:10:36 +00:00
|
|
|
{
|
2004-02-28 20:59:23 +00:00
|
|
|
if (handle->protocol == NULL) {
|
|
|
|
/*
|
|
|
|
* No protocol (see, for example, the handle for
|
|
|
|
* dissecting the set of protocols where the first
|
|
|
|
* octet of the payload is an OSI network layer protocol
|
|
|
|
* ID).
|
|
|
|
*/
|
|
|
|
return -1;
|
|
|
|
}
|
2003-11-16 23:17:27 +00:00
|
|
|
return proto_get_id(handle->protocol);
|
2002-11-15 03:10:36 +00:00
|
|
|
}
|
|
|
|
|
2014-02-18 15:03:04 +00:00
|
|
|
/* Get a GList of all registered dissector names. The content of the list
|
|
|
|
is owned by the hash table and should not be modified or freed.
|
|
|
|
Use g_list_free() when done using the list. */
|
|
|
|
GList*
|
2014-02-25 21:44:29 +00:00
|
|
|
get_dissector_names(void)
|
2014-02-18 15:03:04 +00:00
|
|
|
{
|
|
|
|
return g_hash_table_get_keys(registered_dissectors);
|
|
|
|
}
|
|
|
|
|
Add a mechanism by which a dissector can be registered by name, another
dissector can get a "handle" for that dissector by name and then call
that dissector through the handle.
This allows dissectors that can't be called through a port table or a
heuristic table to be called from other dissectors without directly
referring to the dissector function - dynamically-loaded modules, under
Windows, cannot directly call functions in the main program, and
non-plugin dissectors are in the main program and thus cannot be called
from plugin dissectors unless either
1) a pointer to the dissector is put in the Big Transfer Vector
or
2) some other mechanism for getting a pointer to the dissector
is provided.
This mechanism could also support registering old-style dissectors and
calling them from new-style dissectors without the new-style dissector
having to do the argument translation itself (I didn't add support for
registering old-style dissectors because I'd prefer to have people
tvbuffify their code if they have to register a dissector...).
It could also, in the future, perhaps support
disabling of protocols;
setting "pinfo->current_proto";
inside "call_dissector()" - and inside "{old_}dissector_try_port()" and
"{old_"dissector_try_heuristic()" - allowing a pile of stuff that
currently has to be done in every dissector be done by common code.
(I have some ideas about how to do this, by
having "proto_register_protocol()" take an abbreviation - of the
sort that would be put in, for example, "pinfo->current_proto" -
as an argument;
having the calls to register dissectors take an index returned
by "proto_register_protocol()" as an argument.
The abbreviation could be used elsewhere as well, e.g. in the "Decoding"
tab of the "Edit->Protocols" dialog box, and in a GUI for constructing
protocol filters. Watch this space.)
Make "dissect_sdp()" the first client of this mechanism; it's now static
to "packet-sdp.c", and all dissectors that call it - including the MGCP
plugin - now call it through a dissector handle fetched by
"find_dissector()". (Next step - see if Ethereal can now compile on
Windows as a result of this.)
svn path=/trunk/; revision=2647
2000-11-15 07:07:52 +00:00
|
|
|
/* Find a registered dissector by name. */
|
|
|
|
dissector_handle_t
|
|
|
|
find_dissector(const char *name)
|
|
|
|
{
|
2013-03-14 06:46:29 +00:00
|
|
|
return (dissector_handle_t)g_hash_table_lookup(registered_dissectors, name);
|
Add a mechanism by which a dissector can be registered by name, another
dissector can get a "handle" for that dissector by name and then call
that dissector through the handle.
This allows dissectors that can't be called through a port table or a
heuristic table to be called from other dissectors without directly
referring to the dissector function - dynamically-loaded modules, under
Windows, cannot directly call functions in the main program, and
non-plugin dissectors are in the main program and thus cannot be called
from plugin dissectors unless either
1) a pointer to the dissector is put in the Big Transfer Vector
or
2) some other mechanism for getting a pointer to the dissector
is provided.
This mechanism could also support registering old-style dissectors and
calling them from new-style dissectors without the new-style dissector
having to do the argument translation itself (I didn't add support for
registering old-style dissectors because I'd prefer to have people
tvbuffify their code if they have to register a dissector...).
It could also, in the future, perhaps support
disabling of protocols;
setting "pinfo->current_proto";
inside "call_dissector()" - and inside "{old_}dissector_try_port()" and
"{old_"dissector_try_heuristic()" - allowing a pile of stuff that
currently has to be done in every dissector be done by common code.
(I have some ideas about how to do this, by
having "proto_register_protocol()" take an abbreviation - of the
sort that would be put in, for example, "pinfo->current_proto" -
as an argument;
having the calls to register dissectors take an index returned
by "proto_register_protocol()" as an argument.
The abbreviation could be used elsewhere as well, e.g. in the "Decoding"
tab of the "Edit->Protocols" dialog box, and in a GUI for constructing
protocol filters. Watch this space.)
Make "dissect_sdp()" the first client of this mechanism; it's now static
to "packet-sdp.c", and all dissectors that call it - including the MGCP
plugin - now call it through a dissector handle fetched by
"find_dissector()". (Next step - see if Ethereal can now compile on
Windows as a result of this.)
svn path=/trunk/; revision=2647
2000-11-15 07:07:52 +00:00
|
|
|
}
|
|
|
|
|
2016-03-13 03:11:03 +00:00
|
|
|
/** Find a dissector by name and add parent protocol as a depedency*/
|
|
|
|
dissector_handle_t find_dissector_add_dependency(const char *name, const int parent_proto)
|
|
|
|
{
|
|
|
|
dissector_handle_t handle = (dissector_handle_t)g_hash_table_lookup(registered_dissectors, name);
|
|
|
|
if ((handle != NULL) && (parent_proto > 0))
|
|
|
|
{
|
|
|
|
register_depend_dissector(proto_get_protocol_short_name(find_protocol_by_id(parent_proto)), dissector_handle_get_short_name(handle));
|
|
|
|
}
|
|
|
|
|
|
|
|
return handle;
|
|
|
|
}
|
|
|
|
|
2013-06-18 01:13:07 +00:00
|
|
|
/* Get a dissector name from handle. */
|
|
|
|
const char *
|
|
|
|
dissector_handle_get_dissector_name(const dissector_handle_t handle)
|
|
|
|
{
|
|
|
|
if (handle == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return handle->name;
|
|
|
|
}
|
|
|
|
|
2016-10-10 20:07:39 +00:00
|
|
|
static dissector_handle_t
|
2017-08-27 19:53:23 +00:00
|
|
|
new_dissector_handle(enum dissector_e type, void *dissector, const int proto, const char *name, void *cb_data)
|
2002-04-28 00:13:05 +00:00
|
|
|
{
|
|
|
|
struct dissector_handle *handle;
|
|
|
|
|
2013-10-11 01:33:40 +00:00
|
|
|
handle = wmem_new(wmem_epan_scope(), struct dissector_handle);
|
2016-10-10 20:07:39 +00:00
|
|
|
handle->name = name;
|
2017-08-27 19:53:23 +00:00
|
|
|
handle->dissector_type = type;
|
|
|
|
handle->dissector_func = dissector;
|
|
|
|
handle->dissector_data = cb_data;
|
2013-08-29 02:05:31 +00:00
|
|
|
handle->protocol = find_protocol_by_id(proto);
|
2002-04-28 00:13:05 +00:00
|
|
|
return handle;
|
|
|
|
}
|
|
|
|
|
2016-10-10 20:07:39 +00:00
|
|
|
/* Create an anonymous handle for a new dissector. */
|
|
|
|
dissector_handle_t
|
|
|
|
create_dissector_handle(dissector_t dissector, const int proto)
|
2015-07-02 03:56:54 +00:00
|
|
|
{
|
2017-08-27 19:53:23 +00:00
|
|
|
return new_dissector_handle(DISSECTOR_TYPE_SIMPLE, dissector, proto, NULL, NULL);
|
2016-10-10 20:07:39 +00:00
|
|
|
}
|
2015-07-02 03:56:54 +00:00
|
|
|
|
2016-10-10 20:07:39 +00:00
|
|
|
dissector_handle_t
|
|
|
|
create_dissector_handle_with_name(dissector_t dissector,
|
|
|
|
const int proto, const char* name)
|
|
|
|
{
|
2017-08-27 19:53:23 +00:00
|
|
|
return new_dissector_handle(DISSECTOR_TYPE_SIMPLE, dissector, proto, name, NULL);
|
2015-07-02 03:56:54 +00:00
|
|
|
}
|
|
|
|
|
2015-08-11 12:08:08 +00:00
|
|
|
/* Destroy an anonymous handle for a dissector. */
|
2015-12-10 18:47:01 +00:00
|
|
|
static void
|
2015-08-11 12:08:08 +00:00
|
|
|
destroy_dissector_handle(dissector_handle_t handle)
|
|
|
|
{
|
|
|
|
if (handle == NULL) return;
|
|
|
|
|
|
|
|
dissector_delete_from_all_tables(handle);
|
|
|
|
deregister_postdissector(handle);
|
|
|
|
wmem_free(wmem_epan_scope(), handle);
|
|
|
|
}
|
|
|
|
|
2016-10-16 03:26:14 +00:00
|
|
|
static dissector_handle_t
|
|
|
|
register_dissector_handle(const char *name, dissector_handle_t handle)
|
|
|
|
{
|
|
|
|
/* Make sure the registration is unique */
|
|
|
|
g_assert(g_hash_table_lookup(registered_dissectors, name) == NULL);
|
|
|
|
|
|
|
|
g_hash_table_insert(registered_dissectors, (gpointer)name, handle);
|
|
|
|
|
|
|
|
return handle;
|
|
|
|
}
|
|
|
|
|
2015-08-11 12:08:08 +00:00
|
|
|
/* Register a new dissector by name. */
|
2013-08-05 17:23:47 +00:00
|
|
|
dissector_handle_t
|
2016-01-14 01:02:42 +00:00
|
|
|
register_dissector(const char *name, dissector_t dissector, const int proto)
|
2002-02-26 11:55:39 +00:00
|
|
|
{
|
|
|
|
struct dissector_handle *handle;
|
|
|
|
|
2017-08-27 19:53:23 +00:00
|
|
|
handle = new_dissector_handle(DISSECTOR_TYPE_SIMPLE, dissector, proto, name, NULL);
|
|
|
|
|
|
|
|
return register_dissector_handle(name, handle);
|
|
|
|
}
|
|
|
|
|
|
|
|
dissector_handle_t
|
|
|
|
register_dissector_with_data(const char *name, dissector_cb_t dissector, const int proto, void *cb_data)
|
|
|
|
{
|
|
|
|
struct dissector_handle *handle;
|
|
|
|
|
|
|
|
handle = new_dissector_handle(DISSECTOR_TYPE_CALLBACK, dissector, proto, name, cb_data);
|
2002-02-26 11:55:39 +00:00
|
|
|
|
2016-10-16 03:26:14 +00:00
|
|
|
return register_dissector_handle(name, handle);
|
2002-02-26 11:55:39 +00:00
|
|
|
}
|
|
|
|
|
2016-03-31 19:53:05 +00:00
|
|
|
static gboolean
|
|
|
|
remove_depend_dissector_from_list(depend_dissector_list_t sub_dissectors, const char *dependent)
|
|
|
|
{
|
|
|
|
GSList *found_entry;
|
|
|
|
|
|
|
|
found_entry = g_slist_find_custom(sub_dissectors->dissectors,
|
2016-04-05 16:24:25 +00:00
|
|
|
dependent, (GCompareFunc)strcmp);
|
2016-03-31 19:53:05 +00:00
|
|
|
|
|
|
|
if (found_entry) {
|
|
|
|
g_free(found_entry->data);
|
|
|
|
sub_dissectors->dissectors = g_slist_delete_link(sub_dissectors->dissectors, found_entry);
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
remove_depend_dissector_ghfunc(gpointer key _U_, gpointer value, gpointer user_data)
|
|
|
|
{
|
|
|
|
depend_dissector_list_t sub_dissectors = (depend_dissector_list_t) value;
|
|
|
|
const char *dependent = (const char *)user_data;
|
|
|
|
|
|
|
|
remove_depend_dissector_from_list(sub_dissectors, dependent);
|
|
|
|
}
|
|
|
|
|
2015-08-11 12:08:08 +00:00
|
|
|
/* Deregister a dissector by name. */
|
|
|
|
void
|
|
|
|
deregister_dissector(const char *name)
|
|
|
|
{
|
|
|
|
dissector_handle_t handle = find_dissector(name);
|
|
|
|
if (handle == NULL) return;
|
|
|
|
|
2016-04-05 16:24:25 +00:00
|
|
|
g_hash_table_remove(registered_dissectors, name);
|
|
|
|
g_hash_table_remove(depend_dissector_lists, name);
|
2016-03-31 19:53:05 +00:00
|
|
|
g_hash_table_foreach(depend_dissector_lists, remove_depend_dissector_ghfunc, (gpointer)name);
|
2016-04-05 16:24:25 +00:00
|
|
|
g_hash_table_remove(heur_dissector_lists, name);
|
2015-08-11 12:08:08 +00:00
|
|
|
|
|
|
|
destroy_dissector_handle(handle);
|
|
|
|
}
|
|
|
|
|
2007-12-15 13:20:17 +00:00
|
|
|
/* Call a dissector through a handle but if the dissector rejected it
|
|
|
|
* return 0.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
call_dissector_only(dissector_handle_t handle, tvbuff_t *tvb,
|
2012-09-11 08:28:07 +00:00
|
|
|
packet_info *pinfo, proto_tree *tree, void *data)
|
2007-12-15 13:20:17 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
g_assert(handle != NULL);
|
2012-09-11 08:28:07 +00:00
|
|
|
ret = call_dissector_work(handle, tvb, pinfo, tree, TRUE, data);
|
2007-12-15 13:20:17 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-05-11 10:40:53 +00:00
|
|
|
/* Call a dissector through a handle and if this fails call the "data"
|
|
|
|
* dissector.
|
|
|
|
*/
|
2002-02-26 11:55:39 +00:00
|
|
|
int
|
2012-09-11 09:06:13 +00:00
|
|
|
call_dissector_with_data(dissector_handle_t handle, tvbuff_t *tvb,
|
|
|
|
packet_info *pinfo, proto_tree *tree, void *data)
|
Add a mechanism by which a dissector can be registered by name, another
dissector can get a "handle" for that dissector by name and then call
that dissector through the handle.
This allows dissectors that can't be called through a port table or a
heuristic table to be called from other dissectors without directly
referring to the dissector function - dynamically-loaded modules, under
Windows, cannot directly call functions in the main program, and
non-plugin dissectors are in the main program and thus cannot be called
from plugin dissectors unless either
1) a pointer to the dissector is put in the Big Transfer Vector
or
2) some other mechanism for getting a pointer to the dissector
is provided.
This mechanism could also support registering old-style dissectors and
calling them from new-style dissectors without the new-style dissector
having to do the argument translation itself (I didn't add support for
registering old-style dissectors because I'd prefer to have people
tvbuffify their code if they have to register a dissector...).
It could also, in the future, perhaps support
disabling of protocols;
setting "pinfo->current_proto";
inside "call_dissector()" - and inside "{old_}dissector_try_port()" and
"{old_"dissector_try_heuristic()" - allowing a pile of stuff that
currently has to be done in every dissector be done by common code.
(I have some ideas about how to do this, by
having "proto_register_protocol()" take an abbreviation - of the
sort that would be put in, for example, "pinfo->current_proto" -
as an argument;
having the calls to register dissectors take an index returned
by "proto_register_protocol()" as an argument.
The abbreviation could be used elsewhere as well, e.g. in the "Decoding"
tab of the "Edit->Protocols" dialog box, and in a GUI for constructing
protocol filters. Watch this space.)
Make "dissect_sdp()" the first client of this mechanism; it's now static
to "packet-sdp.c", and all dissectors that call it - including the MGCP
plugin - now call it through a dissector handle fetched by
"find_dissector()". (Next step - see if Ethereal can now compile on
Windows as a result of this.)
svn path=/trunk/; revision=2647
2000-11-15 07:07:52 +00:00
|
|
|
{
|
2002-02-26 11:55:39 +00:00
|
|
|
int ret;
|
2001-01-12 09:25:29 +00:00
|
|
|
|
2012-09-11 09:06:13 +00:00
|
|
|
ret = call_dissector_only(handle, tvb, pinfo, tree, data);
|
2002-10-28 23:04:15 +00:00
|
|
|
if (ret == 0) {
|
In "{old_}dissector_try_port()", check whether the protocol for the
dissector is enabled and, if not, return FALSE, just as if there hadn't
been any entry for that port number in the table. If it is enabled, set
"pinfo->current_proto" from its short name before calling the dissector.
In "dissector_try_heuristic()", check whether the protocols for
dissectors are enabled and, if not, skip those dissectors, just as if
they hadn't been in the table. (We don't set "pinfo->current_proto"
before calling a dissector, as we don't know whether the dissector in
question will be the one to dissect the packet. Arguably, we should
have, for heuristic dissectors, separate "recognize" and "dissect"
routines, where the former never throws an exception and returns TRUE or
FALSE, and the latter is called only if the "recognize" routine claimed
the frame, and is just a "dissector_t" that doesn't return a value.)
In "{old_}call_dissector()", check whether the protocol for the
dissector is enabled and, if not, call "{old_}dissect_data()". if it is
enabled, set "pinfo->current_proto" from its short name before calling
the dissector.
svn path=/trunk/; revision=2861
2001-01-10 10:44:48 +00:00
|
|
|
/*
|
2002-10-28 23:04:15 +00:00
|
|
|
* The protocol was disabled, or the dissector rejected
|
|
|
|
* it. Just dissect this packet as data.
|
In "{old_}dissector_try_port()", check whether the protocol for the
dissector is enabled and, if not, return FALSE, just as if there hadn't
been any entry for that port number in the table. If it is enabled, set
"pinfo->current_proto" from its short name before calling the dissector.
In "dissector_try_heuristic()", check whether the protocols for
dissectors are enabled and, if not, skip those dissectors, just as if
they hadn't been in the table. (We don't set "pinfo->current_proto"
before calling a dissector, as we don't know whether the dissector in
question will be the one to dissect the packet. Arguably, we should
have, for heuristic dissectors, separate "recognize" and "dissect"
routines, where the former never throws an exception and returns TRUE or
FALSE, and the latter is called only if the "recognize" routine claimed
the frame, and is just a "dissector_t" that doesn't return a value.)
In "{old_}call_dissector()", check whether the protocol for the
dissector is enabled and, if not, call "{old_}dissect_data()". if it is
enabled, set "pinfo->current_proto" from its short name before calling
the dissector.
svn path=/trunk/; revision=2861
2001-01-10 10:44:48 +00:00
|
|
|
*/
|
2003-11-16 23:17:27 +00:00
|
|
|
g_assert(data_handle->protocol != NULL);
|
2012-09-11 08:28:07 +00:00
|
|
|
call_dissector_work(data_handle, tvb, pinfo, tree, TRUE, NULL);
|
2015-06-24 00:30:22 +00:00
|
|
|
return tvb_captured_length(tvb);
|
In "{old_}dissector_try_port()", check whether the protocol for the
dissector is enabled and, if not, return FALSE, just as if there hadn't
been any entry for that port number in the table. If it is enabled, set
"pinfo->current_proto" from its short name before calling the dissector.
In "dissector_try_heuristic()", check whether the protocols for
dissectors are enabled and, if not, skip those dissectors, just as if
they hadn't been in the table. (We don't set "pinfo->current_proto"
before calling a dissector, as we don't know whether the dissector in
question will be the one to dissect the packet. Arguably, we should
have, for heuristic dissectors, separate "recognize" and "dissect"
routines, where the former never throws an exception and returns TRUE or
FALSE, and the latter is called only if the "recognize" routine claimed
the frame, and is just a "dissector_t" that doesn't return a value.)
In "{old_}call_dissector()", check whether the protocol for the
dissector is enabled and, if not, call "{old_}dissect_data()". if it is
enabled, set "pinfo->current_proto" from its short name before calling
the dissector.
svn path=/trunk/; revision=2861
2001-01-10 10:44:48 +00:00
|
|
|
}
|
2002-02-26 11:55:39 +00:00
|
|
|
return ret;
|
Add a mechanism by which a dissector can be registered by name, another
dissector can get a "handle" for that dissector by name and then call
that dissector through the handle.
This allows dissectors that can't be called through a port table or a
heuristic table to be called from other dissectors without directly
referring to the dissector function - dynamically-loaded modules, under
Windows, cannot directly call functions in the main program, and
non-plugin dissectors are in the main program and thus cannot be called
from plugin dissectors unless either
1) a pointer to the dissector is put in the Big Transfer Vector
or
2) some other mechanism for getting a pointer to the dissector
is provided.
This mechanism could also support registering old-style dissectors and
calling them from new-style dissectors without the new-style dissector
having to do the argument translation itself (I didn't add support for
registering old-style dissectors because I'd prefer to have people
tvbuffify their code if they have to register a dissector...).
It could also, in the future, perhaps support
disabling of protocols;
setting "pinfo->current_proto";
inside "call_dissector()" - and inside "{old_}dissector_try_port()" and
"{old_"dissector_try_heuristic()" - allowing a pile of stuff that
currently has to be done in every dissector be done by common code.
(I have some ideas about how to do this, by
having "proto_register_protocol()" take an abbreviation - of the
sort that would be put in, for example, "pinfo->current_proto" -
as an argument;
having the calls to register dissectors take an index returned
by "proto_register_protocol()" as an argument.
The abbreviation could be used elsewhere as well, e.g. in the "Decoding"
tab of the "Edit->Protocols" dialog box, and in a GUI for constructing
protocol filters. Watch this space.)
Make "dissect_sdp()" the first client of this mechanism; it's now static
to "packet-sdp.c", and all dissectors that call it - including the MGCP
plugin - now call it through a dissector handle fetched by
"find_dissector()". (Next step - see if Ethereal can now compile on
Windows as a result of this.)
svn path=/trunk/; revision=2647
2000-11-15 07:07:52 +00:00
|
|
|
}
|
2005-03-11 16:17:41 +00:00
|
|
|
|
2012-09-11 09:06:13 +00:00
|
|
|
int
|
|
|
|
call_dissector(dissector_handle_t handle, tvbuff_t *tvb,
|
|
|
|
packet_info *pinfo, proto_tree *tree)
|
|
|
|
{
|
|
|
|
return call_dissector_with_data(handle, tvb, pinfo, tree, NULL);
|
|
|
|
}
|
|
|
|
|
2016-03-20 00:33:14 +00:00
|
|
|
int
|
|
|
|
call_data_dissector(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
|
|
|
|
{
|
|
|
|
return call_dissector_work(data_handle, tvb, pinfo, tree, TRUE, NULL);
|
|
|
|
}
|
2014-05-20 10:54:20 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Call a heuristic dissector through a heur_dtbl_entry
|
|
|
|
*/
|
|
|
|
void call_heur_dissector_direct(heur_dtbl_entry_t *heur_dtbl_entry, tvbuff_t *tvb,
|
|
|
|
packet_info *pinfo, proto_tree *tree, void *data)
|
|
|
|
{
|
|
|
|
const char *saved_curr_proto;
|
|
|
|
const char *saved_heur_list_name;
|
|
|
|
guint16 saved_can_desegment;
|
2017-11-24 00:05:05 +00:00
|
|
|
guint saved_layers_len = 0;
|
2014-05-20 10:54:20 +00:00
|
|
|
|
|
|
|
g_assert(heur_dtbl_entry);
|
|
|
|
|
|
|
|
/* can_desegment is set to 2 by anyone which offers this api/service.
|
|
|
|
then everytime a subdissector is called it is decremented by one.
|
|
|
|
thus only the subdissector immediately ontop of whoever offers this
|
|
|
|
service can use it.
|
|
|
|
We save the current value of "can_desegment" for the
|
|
|
|
benefit of TCP proxying dissectors such as SOCKS, so they
|
|
|
|
can restore it and allow the dissectors they call to use
|
|
|
|
the desegmentation service.
|
|
|
|
*/
|
|
|
|
saved_can_desegment = pinfo->can_desegment;
|
|
|
|
pinfo->saved_can_desegment = saved_can_desegment;
|
|
|
|
pinfo->can_desegment = saved_can_desegment-(saved_can_desegment>0);
|
|
|
|
|
|
|
|
saved_curr_proto = pinfo->current_proto;
|
|
|
|
saved_heur_list_name = pinfo->heur_list_name;
|
|
|
|
|
2017-11-24 00:05:05 +00:00
|
|
|
saved_layers_len = wmem_list_count(pinfo->layers);
|
|
|
|
|
2015-06-24 19:21:42 +00:00
|
|
|
if (!heur_dtbl_entry->enabled ||
|
|
|
|
(heur_dtbl_entry->protocol != NULL && !proto_is_protocol_enabled(heur_dtbl_entry->protocol))) {
|
|
|
|
g_assert(data_handle->protocol != NULL);
|
|
|
|
call_dissector_work(data_handle, tvb, pinfo, tree, TRUE, NULL);
|
|
|
|
return;
|
|
|
|
}
|
2014-05-20 10:54:20 +00:00
|
|
|
|
|
|
|
if (heur_dtbl_entry->protocol != NULL) {
|
|
|
|
/* do NOT change this behavior - wslua uses the protocol short name set here in order
|
2016-08-23 20:10:08 +00:00
|
|
|
to determine which Lua-based heuristic dissector to call */
|
2014-05-20 10:54:20 +00:00
|
|
|
pinfo->current_proto = proto_get_protocol_short_name(heur_dtbl_entry->protocol);
|
2017-11-24 00:05:05 +00:00
|
|
|
pinfo->curr_layer_num++;
|
2015-06-24 19:21:42 +00:00
|
|
|
wmem_list_append(pinfo->layers, GINT_TO_POINTER(proto_get_id(heur_dtbl_entry->protocol)));
|
2014-05-20 10:54:20 +00:00
|
|
|
}
|
|
|
|
|
2014-12-24 20:04:01 +00:00
|
|
|
pinfo->heur_list_name = heur_dtbl_entry->list_name;
|
|
|
|
|
2016-08-23 20:10:08 +00:00
|
|
|
/* call the dissector, in case of failure call data handle (might happen with exported PDUs) */
|
2018-02-08 08:31:29 +00:00
|
|
|
if (!(*heur_dtbl_entry->dissector)(tvb, pinfo, tree, data)) {
|
2016-08-23 20:10:08 +00:00
|
|
|
call_dissector_work(data_handle, tvb, pinfo, tree, TRUE, NULL);
|
2014-05-20 10:54:20 +00:00
|
|
|
|
2017-11-24 00:05:05 +00:00
|
|
|
/*
|
|
|
|
* We added a protocol layer above. The dissector
|
|
|
|
* didn't accept the packet or it didn't add any
|
|
|
|
* items to the tree so remove it from the list.
|
|
|
|
*/
|
|
|
|
while (wmem_list_count(pinfo->layers) > saved_layers_len) {
|
|
|
|
pinfo->curr_layer_num--;
|
|
|
|
wmem_list_remove_frame(pinfo->layers, wmem_list_tail(pinfo->layers));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-05-20 10:54:20 +00:00
|
|
|
/* Restore info from caller */
|
|
|
|
pinfo->can_desegment = saved_can_desegment;
|
|
|
|
pinfo->current_proto = saved_curr_proto;
|
|
|
|
pinfo->heur_list_name = saved_heur_list_name;
|
|
|
|
|
|
|
|
}
|
2014-11-17 02:25:56 +00:00
|
|
|
|
2017-01-02 21:24:41 +00:00
|
|
|
static gint
|
|
|
|
find_matching_proto_name(gconstpointer arg1, gconstpointer arg2)
|
|
|
|
{
|
|
|
|
const char *protocol_name = (const char*)arg1;
|
|
|
|
const gchar *name = (const gchar *)arg2;
|
|
|
|
|
|
|
|
return strcmp(protocol_name, name);
|
|
|
|
}
|
|
|
|
|
2016-03-13 03:11:03 +00:00
|
|
|
gboolean register_depend_dissector(const char* parent, const char* dependent)
|
|
|
|
{
|
|
|
|
GSList *list_entry;
|
|
|
|
depend_dissector_list_t sub_dissectors;
|
|
|
|
|
|
|
|
if ((parent == NULL) || (dependent == NULL))
|
|
|
|
{
|
|
|
|
/* XXX - assert on parent? */
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
sub_dissectors = find_depend_dissector_list(parent);
|
|
|
|
if (sub_dissectors == NULL) {
|
|
|
|
/* parent protocol doesn't exist, create it */
|
|
|
|
sub_dissectors = g_slice_new(struct depend_dissector_list);
|
|
|
|
sub_dissectors->dissectors = NULL; /* initially empty */
|
2016-03-31 19:53:05 +00:00
|
|
|
g_hash_table_insert(depend_dissector_lists, (gpointer)g_strdup(parent), (gpointer) sub_dissectors);
|
2016-03-13 03:11:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Verify that sub-dissector is not already in the list */
|
2017-01-02 21:24:41 +00:00
|
|
|
list_entry = g_slist_find_custom(sub_dissectors->dissectors, (gpointer)dependent, find_matching_proto_name);
|
|
|
|
if (list_entry != NULL)
|
|
|
|
return TRUE; /* Dependency already exists */
|
2016-03-13 03:11:03 +00:00
|
|
|
|
2016-03-31 19:53:05 +00:00
|
|
|
sub_dissectors->dissectors = g_slist_prepend(sub_dissectors->dissectors, (gpointer)g_strdup(dependent));
|
2016-03-13 03:11:03 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
gboolean deregister_depend_dissector(const char* parent, const char* dependent)
|
|
|
|
{
|
|
|
|
depend_dissector_list_t sub_dissectors = find_depend_dissector_list(parent);
|
|
|
|
|
|
|
|
/* sanity check */
|
|
|
|
g_assert(sub_dissectors != NULL);
|
|
|
|
|
2016-03-31 19:53:05 +00:00
|
|
|
return remove_depend_dissector_from_list(sub_dissectors, dependent);
|
2016-03-13 03:11:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
depend_dissector_list_t find_depend_dissector_list(const char* name)
|
|
|
|
{
|
|
|
|
return (depend_dissector_list_t)g_hash_table_lookup(depend_dissector_lists, name);
|
|
|
|
}
|
|
|
|
|
2005-03-11 16:17:41 +00:00
|
|
|
/*
|
|
|
|
* Dumps the "layer type"/"decode as" associations to stdout, similar
|
|
|
|
* to the proto_registrar_dump_*() routines.
|
|
|
|
*
|
|
|
|
* There is one record per line. The fields are tab-delimited.
|
|
|
|
*
|
|
|
|
* Field 1 = layer type, e.g. "tcp.port"
|
|
|
|
* Field 2 = selector in decimal
|
|
|
|
* Field 3 = "decode as" name, e.g. "http"
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
2007-04-23 17:40:33 +00:00
|
|
|
dissector_dump_decodes_display(const gchar *table_name,
|
2016-01-05 12:06:36 +00:00
|
|
|
ftenum_t selector_type _U_, gpointer key, gpointer value,
|
2009-10-12 01:31:01 +00:00
|
|
|
gpointer user_data _U_)
|
2005-03-11 16:17:41 +00:00
|
|
|
{
|
2015-06-03 14:14:42 +00:00
|
|
|
guint32 selector = GPOINTER_TO_UINT (key);
|
2012-01-20 02:43:37 +00:00
|
|
|
dissector_table_t sub_dissectors = find_dissector_table(table_name);
|
|
|
|
dtbl_entry_t *dtbl_entry;
|
|
|
|
dissector_handle_t handle;
|
|
|
|
gint proto_id;
|
|
|
|
const gchar *decode_as;
|
2005-03-11 16:17:41 +00:00
|
|
|
|
|
|
|
g_assert(sub_dissectors);
|
|
|
|
switch (sub_dissectors->type) {
|
|
|
|
|
|
|
|
case FT_UINT8:
|
|
|
|
case FT_UINT16:
|
|
|
|
case FT_UINT24:
|
|
|
|
case FT_UINT32:
|
2013-03-14 06:46:29 +00:00
|
|
|
dtbl_entry = (dtbl_entry_t *)value;
|
2005-03-11 16:17:41 +00:00
|
|
|
g_assert(dtbl_entry);
|
|
|
|
|
2012-01-20 02:43:37 +00:00
|
|
|
handle = dtbl_entry->current;
|
2005-03-11 16:17:41 +00:00
|
|
|
g_assert(handle);
|
|
|
|
|
|
|
|
proto_id = dissector_handle_get_protocol_index(handle);
|
|
|
|
|
|
|
|
if (proto_id != -1) {
|
|
|
|
decode_as = proto_get_protocol_filter_name(proto_id);
|
|
|
|
g_assert(decode_as != NULL);
|
2016-07-24 12:53:39 +00:00
|
|
|
ws_debug_printf("%s\t%u\t%s\n", table_name, selector, decode_as);
|
2005-03-11 16:17:41 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2011-05-17 22:18:32 +00:00
|
|
|
dissector_dump_decodes(void)
|
2008-05-21 20:20:37 +00:00
|
|
|
{
|
2005-03-11 16:17:41 +00:00
|
|
|
dissector_all_tables_foreach(dissector_dump_decodes_display, NULL);
|
|
|
|
}
|
2006-01-24 00:26:57 +00:00
|
|
|
|
2014-11-17 02:25:56 +00:00
|
|
|
/*
|
|
|
|
* Dumps the "layer type"/"decode as" associations to stdout, similar
|
|
|
|
* to the proto_registrar_dump_*() routines.
|
|
|
|
*
|
|
|
|
* There is one record per line. The fields are tab-delimited.
|
|
|
|
*
|
|
|
|
* Field 1 = layer type, e.g. "tcp.port"
|
|
|
|
* Field 2 = selector in decimal
|
|
|
|
* Field 3 = "decode as" name, e.g. "http"
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
dissector_dump_dissector_tables_display (gpointer key, gpointer user_data _U_)
|
|
|
|
{
|
|
|
|
const char *table_name = (const char *)key;
|
|
|
|
dissector_table_t table;
|
|
|
|
|
|
|
|
table = (dissector_table_t)g_hash_table_lookup(dissector_tables, key);
|
2016-07-24 12:53:39 +00:00
|
|
|
ws_debug_printf("%s\t%s\t%s", table_name, table->ui_name, ftype_name(table->type));
|
2014-11-17 02:25:56 +00:00
|
|
|
switch (table->type) {
|
|
|
|
|
|
|
|
case FT_UINT8:
|
|
|
|
case FT_UINT16:
|
|
|
|
case FT_UINT24:
|
|
|
|
case FT_UINT32:
|
2014-12-10 02:35:01 +00:00
|
|
|
switch(table->param) {
|
2014-11-17 02:25:56 +00:00
|
|
|
|
|
|
|
case BASE_NONE:
|
2016-07-24 12:53:39 +00:00
|
|
|
ws_debug_printf("\tBASE_NONE");
|
2014-11-17 02:25:56 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case BASE_DEC:
|
2016-07-24 12:53:39 +00:00
|
|
|
ws_debug_printf("\tBASE_DEC");
|
2014-11-17 02:25:56 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case BASE_HEX:
|
2016-07-24 12:53:39 +00:00
|
|
|
ws_debug_printf("\tBASE_HEX");
|
2014-11-17 02:25:56 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case BASE_DEC_HEX:
|
2016-07-24 12:53:39 +00:00
|
|
|
ws_debug_printf("\tBASE_DEC_HEX");
|
2014-11-17 02:25:56 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case BASE_HEX_DEC:
|
2016-07-24 12:53:39 +00:00
|
|
|
ws_debug_printf("\tBASE_HEX_DEC");
|
2014-11-17 02:25:56 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2016-07-24 12:53:39 +00:00
|
|
|
ws_debug_printf("\t%d", table->param);
|
2014-11-17 02:25:56 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2017-10-28 04:25:50 +00:00
|
|
|
if (table->protocol != NULL) {
|
|
|
|
ws_debug_printf("\t%s",
|
|
|
|
proto_get_protocol_short_name(table->protocol));
|
|
|
|
} else
|
|
|
|
ws_debug_printf("\t(no protocol)");
|
2017-10-28 04:17:52 +00:00
|
|
|
ws_debug_printf("\tDecode As %ssupported",
|
|
|
|
table->supports_decode_as ? "" : "not ");
|
2016-07-24 12:53:39 +00:00
|
|
|
ws_debug_printf("\n");
|
2014-11-17 02:25:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static gint
|
|
|
|
compare_dissector_key_name(gconstpointer dissector_a, gconstpointer dissector_b)
|
|
|
|
{
|
|
|
|
return strcmp((const char*)dissector_a, (const char*)dissector_b);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dissector_dump_dissector_tables(void)
|
|
|
|
{
|
|
|
|
GList *list;
|
|
|
|
|
|
|
|
list = g_hash_table_get_keys(dissector_tables);
|
|
|
|
list = g_list_sort(list, compare_dissector_key_name);
|
|
|
|
g_list_foreach(list, dissector_dump_dissector_tables_display, NULL);
|
|
|
|
g_list_free(list);
|
|
|
|
}
|
|
|
|
|
2008-05-21 20:20:37 +00:00
|
|
|
void
|
|
|
|
register_postdissector(dissector_handle_t handle)
|
|
|
|
{
|
2017-04-12 02:53:48 +00:00
|
|
|
postdissector p;
|
2006-03-07 16:28:25 +00:00
|
|
|
|
2017-04-12 02:53:48 +00:00
|
|
|
if (!postdissectors)
|
|
|
|
postdissectors = g_array_sized_new(FALSE, FALSE, (guint)sizeof(postdissector), 1);
|
|
|
|
|
|
|
|
p.handle = handle;
|
2017-04-17 01:48:30 +00:00
|
|
|
p.wanted_hfids = NULL;
|
2017-04-12 02:53:48 +00:00
|
|
|
postdissectors = g_array_append_val(postdissectors, p);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2017-04-17 01:48:30 +00:00
|
|
|
set_postdissector_wanted_hfids(dissector_handle_t handle, GArray *wanted_hfids)
|
2017-04-12 02:53:48 +00:00
|
|
|
{
|
2017-08-28 11:42:59 +00:00
|
|
|
guint i;
|
2017-04-12 02:53:48 +00:00
|
|
|
|
2017-08-28 11:42:59 +00:00
|
|
|
if (!postdissectors) return;
|
2017-04-12 02:53:48 +00:00
|
|
|
|
2017-08-28 11:42:59 +00:00
|
|
|
for (i = 0; i < postdissectors->len; i++) {
|
|
|
|
if (POSTDISSECTORS(i).handle == handle) {
|
|
|
|
if (POSTDISSECTORS(i).wanted_hfids) {
|
|
|
|
g_array_free(POSTDISSECTORS(i).wanted_hfids, TRUE);
|
|
|
|
}
|
|
|
|
POSTDISSECTORS(i).wanted_hfids = wanted_hfids;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2006-01-24 00:26:57 +00:00
|
|
|
}
|
|
|
|
|
2015-08-11 12:08:08 +00:00
|
|
|
void
|
|
|
|
deregister_postdissector(dissector_handle_t handle)
|
|
|
|
{
|
2017-08-28 11:42:59 +00:00
|
|
|
guint i;
|
2017-04-12 02:53:48 +00:00
|
|
|
|
2017-08-28 11:42:59 +00:00
|
|
|
if (!postdissectors) return;
|
2015-08-11 12:08:08 +00:00
|
|
|
|
2017-08-28 11:42:59 +00:00
|
|
|
for (i = 0; i < postdissectors->len; i++) {
|
|
|
|
if (POSTDISSECTORS(i).handle == handle) {
|
|
|
|
if (POSTDISSECTORS(i).wanted_hfids) {
|
|
|
|
g_array_free(POSTDISSECTORS(i).wanted_hfids, TRUE);
|
|
|
|
}
|
|
|
|
postdissectors = g_array_remove_index_fast(postdissectors, i);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2015-08-11 12:08:08 +00:00
|
|
|
}
|
|
|
|
|
2008-05-21 16:56:50 +00:00
|
|
|
gboolean
|
2011-05-17 22:18:32 +00:00
|
|
|
have_postdissector(void)
|
2008-05-21 20:20:37 +00:00
|
|
|
{
|
2009-10-12 01:31:01 +00:00
|
|
|
guint i;
|
|
|
|
dissector_handle_t handle;
|
2008-05-21 20:20:37 +00:00
|
|
|
|
2017-04-12 02:53:48 +00:00
|
|
|
for (i = 0; i < postdissectors->len; i++) {
|
|
|
|
handle = POSTDISSECTORS(i).handle;
|
2008-05-21 20:20:37 +00:00
|
|
|
|
2009-10-12 01:31:01 +00:00
|
|
|
if (handle->protocol != NULL
|
|
|
|
&& proto_is_protocol_enabled(handle->protocol)) {
|
|
|
|
/* We have at least one enabled postdissector */
|
|
|
|
return TRUE;
|
|
|
|
}
|
2008-05-21 20:20:37 +00:00
|
|
|
}
|
2009-10-12 01:31:01 +00:00
|
|
|
return FALSE;
|
2008-05-21 16:40:15 +00:00
|
|
|
}
|
|
|
|
|
2008-05-21 20:20:37 +00:00
|
|
|
void
|
|
|
|
call_all_postdissectors(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
|
|
|
|
{
|
2009-10-12 01:31:01 +00:00
|
|
|
guint i;
|
2008-05-21 20:20:37 +00:00
|
|
|
|
2017-04-12 02:53:48 +00:00
|
|
|
for (i = 0; i < postdissectors->len; i++) {
|
|
|
|
call_dissector_only(POSTDISSECTORS(i).handle,
|
|
|
|
tvb, pinfo, tree, NULL);
|
2009-10-12 01:31:01 +00:00
|
|
|
}
|
2006-01-24 00:26:57 +00:00
|
|
|
}
|
2012-08-29 22:19:29 +00:00
|
|
|
|
2017-04-12 02:53:48 +00:00
|
|
|
gboolean
|
2017-04-17 01:48:30 +00:00
|
|
|
postdissectors_want_hfids(void)
|
2017-04-12 02:53:48 +00:00
|
|
|
{
|
|
|
|
guint i;
|
|
|
|
|
|
|
|
for (i = 0; i < postdissectors->len; i++) {
|
2017-04-17 01:48:30 +00:00
|
|
|
if (POSTDISSECTORS(i).wanted_hfids != NULL &&
|
|
|
|
POSTDISSECTORS(i).wanted_hfids->len != 0)
|
2017-04-12 02:53:48 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2017-04-12 20:52:07 +00:00
|
|
|
void
|
2017-04-17 01:48:30 +00:00
|
|
|
prime_epan_dissect_with_postdissector_wanted_hfids(epan_dissect_t *edt)
|
2017-04-12 20:52:07 +00:00
|
|
|
{
|
|
|
|
guint i;
|
|
|
|
|
|
|
|
if (postdissectors == NULL) {
|
|
|
|
/*
|
2017-04-17 01:48:30 +00:00
|
|
|
* No postdissector expressed an interest in any hfids.
|
2017-04-12 20:52:07 +00:00
|
|
|
*/
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
for (i = 0; i < postdissectors->len; i++) {
|
2017-04-17 01:48:30 +00:00
|
|
|
if (POSTDISSECTORS(i).wanted_hfids != NULL &&
|
|
|
|
POSTDISSECTORS(i).wanted_hfids->len != 0)
|
2017-04-12 20:52:07 +00:00
|
|
|
epan_dissect_prime_with_hfid_array(edt,
|
2017-04-17 01:48:30 +00:00
|
|
|
POSTDISSECTORS(i).wanted_hfids);
|
2017-04-12 20:52:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-29 22:19:29 +00:00
|
|
|
/*
|
|
|
|
* Editor modelines - http://www.wireshark.org/tools/modelines.html
|
|
|
|
*
|
|
|
|
* Local variables:
|
|
|
|
* c-basic-offset: 8
|
|
|
|
* tab-width: 8
|
|
|
|
* indent-tabs-mode: t
|
|
|
|
* End:
|
|
|
|
*
|
|
|
|
* vi: set shiftwidth=8 tabstop=8 noexpandtab:
|
|
|
|
* :indentSize=8:tabSize=8:noTabs=false:
|
|
|
|
*/
|