1998-09-16 02:39:15 +00:00
|
|
|
/* packet.c
|
|
|
|
* Routines for packet disassembly
|
|
|
|
*
|
2003-06-05 04:47:58 +00:00
|
|
|
* $Id: packet.c,v 1.93 2003/06/05 04:47:58 guy Exp $
|
1998-09-16 03:22:19 +00:00
|
|
|
*
|
1998-09-16 02:39:15 +00:00
|
|
|
* Ethereal - Network traffic analyzer
|
2001-06-02 08:23:10 +00:00
|
|
|
* By Gerald Combs <gerald@ethereal.com>
|
1998-09-16 02:39:15 +00:00
|
|
|
* Copyright 1998 Gerald Combs
|
2002-08-28 20:41:00 +00:00
|
|
|
*
|
1998-09-16 02:39:15 +00:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
2002-08-28 20:41:00 +00:00
|
|
|
*
|
1998-09-16 02:39:15 +00:00
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
2002-08-28 20:41:00 +00:00
|
|
|
*
|
1998-09-16 02:39:15 +00:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include "config.h"
|
|
|
|
#endif
|
|
|
|
|
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
|
|
|
|
|
|
|
#ifdef HAVE_STDARG_H
|
1998-09-16 02:39:15 +00:00
|
|
|
#include <stdarg.h>
|
2000-08-11 13:37:21 +00:00
|
|
|
#endif
|
|
|
|
|
1998-11-18 03:01:44 +00:00
|
|
|
#include <string.h>
|
1998-09-16 02:39:15 +00:00
|
|
|
#include <ctype.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-03-22 16:24:16 +00:00
|
|
|
#include "atalk-utils.h"
|
2001-04-01 07:06:24 +00:00
|
|
|
#include "ipv6-utils.h"
|
2001-03-22 16:24:16 +00:00
|
|
|
#include "sna-utils.h"
|
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
|
|
|
|
|
|
|
#include "resolv.h"
|
2000-05-11 08:18:09 +00:00
|
|
|
#include "tvbuff.h"
|
2000-04-04 16:33:57 +00:00
|
|
|
#include "plugins.h"
|
2001-12-18 19:09:08 +00:00
|
|
|
#include "epan_dissect.h"
|
2000-04-04 16:33:57 +00:00
|
|
|
|
2002-02-24 06:45:14 +00:00
|
|
|
#include "../reassemble.h"
|
|
|
|
|
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;
|
2001-11-26 05:41:15 +00:00
|
|
|
static dissector_handle_t data_handle = NULL;
|
2001-04-01 22:01:34 +00:00
|
|
|
|
2002-08-28 20:41:00 +00:00
|
|
|
const true_false_string flags_set_truth = {
|
2002-08-21 21:25:23 +00:00
|
|
|
"Set",
|
|
|
|
"Not set"
|
|
|
|
};
|
|
|
|
|
2000-10-06 10:11:40 +00:00
|
|
|
void
|
|
|
|
packet_init(void)
|
|
|
|
{
|
2001-04-01 22:01:34 +00:00
|
|
|
frame_handle = find_dissector("frame");
|
2001-11-26 05:41:15 +00:00
|
|
|
data_handle = find_dissector("data");
|
2001-04-01 23:11:43 +00:00
|
|
|
proto_malformed = proto_get_id_by_filter_name("malformed");
|
2000-10-06 10:11:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
packet_cleanup(void)
|
|
|
|
{
|
|
|
|
/* nothing */
|
|
|
|
}
|
|
|
|
|
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
|
2002-02-17 00:51:21 +00:00
|
|
|
set_actual_length(tvbuff_t *tvb, guint specified_len)
|
2001-06-29 09:46:54 +00:00
|
|
|
{
|
2002-05-15 21:18:19 +00:00
|
|
|
if (specified_len < tvb_reported_length(tvb)) {
|
2001-06-29 09:46:54 +00:00
|
|
|
/* 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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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
|
|
|
/* Allow protocols to register "init" routines, which are called before
|
|
|
|
we make a pass through a capture file and dissect all its packets
|
|
|
|
(e.g., when we read in a new capture file, or run a "filter packets"
|
|
|
|
or "colorize packets" pass over the current capture file). */
|
|
|
|
static GSList *init_routines;
|
|
|
|
|
|
|
|
void
|
|
|
|
register_init_routine(void (*func)(void))
|
|
|
|
{
|
|
|
|
init_routines = g_slist_append(init_routines, func);
|
|
|
|
}
|
|
|
|
|
2002-02-24 06:45:14 +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
|
|
|
static void
|
2002-03-02 20:51:46 +00:00
|
|
|
call_init_routine(gpointer routine, gpointer dummy _U_)
|
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 (*func)(void) = routine;
|
|
|
|
|
|
|
|
(*func)();
|
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
{
|
2002-02-24 06:45:14 +00:00
|
|
|
/* Initialize the table of conversations. */
|
|
|
|
epan_conversation_init();
|
|
|
|
|
2002-10-22 08:22:07 +00:00
|
|
|
/* Initialize the table of circuits. */
|
|
|
|
epan_circuit_init();
|
|
|
|
|
2002-02-24 06:45:14 +00:00
|
|
|
/* Initialize protocol-specific variables. */
|
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
|
|
|
g_slist_foreach(init_routines, &call_init_routine, NULL);
|
|
|
|
|
2002-02-24 06:45:14 +00:00
|
|
|
/* Initialize the common data structures for fragment reassembly.
|
|
|
|
Must be done *after* calling init routines, as those routines
|
|
|
|
may free up space for fragments, which they find by using the
|
|
|
|
data structures that "reassemble_init()" frees. */
|
|
|
|
reassemble_init();
|
|
|
|
}
|
2002-01-05 04:12:17 +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;
|
|
|
|
|
|
|
|
void
|
|
|
|
register_postseq_cleanup_routine(void (*func)(void))
|
|
|
|
{
|
|
|
|
postseq_cleanup_routines = g_slist_append(postseq_cleanup_routines,
|
|
|
|
func);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Call all the registered "postseq_cleanup" routines. */
|
|
|
|
static void
|
2002-03-02 20:51:46 +00:00
|
|
|
call_postseq_cleanup_routine(gpointer routine, gpointer dummy _U_)
|
2002-01-05 04:12:17 +00:00
|
|
|
{
|
|
|
|
void (*func)(void) = routine;
|
|
|
|
|
|
|
|
(*func)();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
postseq_cleanup_all_protocols(void)
|
|
|
|
{
|
|
|
|
g_slist_foreach(postseq_cleanup_routines,
|
|
|
|
&call_postseq_cleanup_routine, NULL);
|
|
|
|
}
|
|
|
|
|
2002-02-18 01:08:44 +00:00
|
|
|
/* Contains information about data sources. */
|
|
|
|
static GMemChunk *data_source_chunk = NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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
|
2002-06-04 07:03:57 +00:00
|
|
|
add_new_data_source(packet_info *pinfo, tvbuff_t *tvb, char *name)
|
2002-02-18 01:08:44 +00:00
|
|
|
{
|
|
|
|
data_source *src;
|
|
|
|
|
|
|
|
if (data_source_chunk == NULL) {
|
|
|
|
data_source_chunk = g_mem_chunk_new("data_source_chunk",
|
|
|
|
sizeof (data_source), 10 * sizeof (data_source),
|
|
|
|
G_ALLOC_AND_FREE);
|
|
|
|
}
|
|
|
|
src = g_mem_chunk_alloc(data_source_chunk);
|
|
|
|
src->tvb = tvb;
|
2002-02-25 21:02:10 +00:00
|
|
|
/*
|
|
|
|
* XXX - if we require this argument to be a string constant,
|
|
|
|
* we don't need to allocate a buffer for a copy and make a
|
|
|
|
* copy, and wouldn't need to free the buffer, either.
|
|
|
|
*/
|
2002-02-18 01:08:44 +00:00
|
|
|
src->name = g_strdup(name);
|
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
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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
|
|
|
{
|
|
|
|
GSList *src_le;
|
|
|
|
data_source *src;
|
|
|
|
|
2002-06-04 07:03:57 +00:00
|
|
|
for (src_le = pinfo->data_src; src_le != NULL; src_le = src_le->next) {
|
2002-02-18 01:08:44 +00:00
|
|
|
src = src_le->data;
|
|
|
|
g_free(src->name);
|
|
|
|
g_mem_chunk_free(data_source_chunk, src);
|
|
|
|
}
|
2002-06-04 07:03:57 +00:00
|
|
|
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
|
|
|
|
2002-05-09 23:50:34 +00:00
|
|
|
/* Allow dissectors to register a "final_registration" routine
|
|
|
|
* that is run like the proto_register_XXX() routine, but the end
|
|
|
|
* 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
|
2002-05-10 20:02:40 +00:00
|
|
|
* have registereed themselves. */
|
2002-05-09 23:50:34 +00:00
|
|
|
static GSList *final_registration_routines;
|
|
|
|
|
|
|
|
void
|
|
|
|
register_final_registration_routine(void (*func)(void))
|
|
|
|
{
|
|
|
|
final_registration_routines = g_slist_append(final_registration_routines,
|
|
|
|
func);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Call all the registered "final_registration" routines. */
|
|
|
|
static void
|
2002-05-10 20:02:40 +00:00
|
|
|
call_final_registration_routine(gpointer routine, gpointer dummy _U_)
|
2002-05-09 23:50:34 +00:00
|
|
|
{
|
|
|
|
void (*func)(void) = routine;
|
|
|
|
|
|
|
|
(*func)();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
final_registration_all_protocols(void)
|
|
|
|
{
|
|
|
|
g_slist_foreach(final_registration_routines,
|
|
|
|
&call_final_registration_routine, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
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
|
2001-11-21 23:16:26 +00:00
|
|
|
dissect_packet(epan_dissect_t *edt, union wtap_pseudo_header *pseudo_header,
|
2002-08-02 21:29:45 +00:00
|
|
|
const guchar *pd, frame_data *fd, column_info *cinfo)
|
1998-09-27 22:12:47 +00:00
|
|
|
{
|
2003-04-16 05:55:41 +00:00
|
|
|
if (cinfo != NULL)
|
|
|
|
col_init(cinfo);
|
2002-03-28 09:12:00 +00:00
|
|
|
edt->pi.current_proto = "<Missing Protocol Name>";
|
|
|
|
edt->pi.cinfo = cinfo;
|
|
|
|
edt->pi.fd = fd;
|
|
|
|
edt->pi.pseudo_header = pseudo_header;
|
2002-06-04 07:03:57 +00:00
|
|
|
edt->pi.data_src = NULL;
|
2001-12-08 21:03:41 +00:00
|
|
|
edt->pi.dl_src.type = AT_NONE;
|
2003-03-01 09:38:41 +00:00
|
|
|
edt->pi.dl_src.len = 0;
|
|
|
|
edt->pi.dl_src.data = NULL;
|
2001-12-08 21:03:41 +00:00
|
|
|
edt->pi.dl_dst.type = AT_NONE;
|
2003-03-01 09:38:41 +00:00
|
|
|
edt->pi.dl_dst.len = 0;
|
|
|
|
edt->pi.dl_dst.data = NULL;
|
2001-12-08 21:03:41 +00:00
|
|
|
edt->pi.net_src.type = AT_NONE;
|
2003-03-01 09:38:41 +00:00
|
|
|
edt->pi.net_src.len = 0;
|
|
|
|
edt->pi.net_src.data = NULL;
|
2001-12-08 21:03:41 +00:00
|
|
|
edt->pi.net_dst.type = AT_NONE;
|
2003-03-01 09:38:41 +00:00
|
|
|
edt->pi.net_dst.len = 0;
|
|
|
|
edt->pi.net_dst.data = NULL;
|
2001-12-08 21:03:41 +00:00
|
|
|
edt->pi.src.type = AT_NONE;
|
2003-03-01 09:38:41 +00:00
|
|
|
edt->pi.src.len = 0;
|
|
|
|
edt->pi.src.data = NULL;
|
2001-12-08 21:03:41 +00:00
|
|
|
edt->pi.dst.type = AT_NONE;
|
2003-03-01 09:38:41 +00:00
|
|
|
edt->pi.dst.len = 0;
|
|
|
|
edt->pi.dst.data = NULL;
|
Use the "fragmented" field of the "packet_info" structure in
"dissect_frame()" to indicate whether a ReportedBoundsError was due to
the packet being malformed (i.e., the packet was shorter than it's
supposed to be, so the dissector went past the end trying to extract
fields that were supposed to be there) or due to it not being
reassembled (i.e., the packet was fragmented, and we didn't reassemble
it, but just treated the first fragment as the entire packet, so the
dissector went past the end trying to extract fields that were partially
or completely in fragments after that). Mark the latter as being
unreasembled rather than malformed.
Properly initialize, save, and restore that field, and properly set it,
so that works.
svn path=/trunk/; revision=4555
2002-01-17 06:29:20 +00:00
|
|
|
edt->pi.ethertype = 0;
|
2001-12-08 21:03:41 +00:00
|
|
|
edt->pi.ipproto = 0;
|
|
|
|
edt->pi.ipxptype = 0;
|
2002-10-22 08:22:07 +00:00
|
|
|
edt->pi.ctype = CT_NONE;
|
|
|
|
edt->pi.circuit_id = 0;
|
2003-02-27 03:56:48 +00:00
|
|
|
edt->pi.noreassembly_reason = "";
|
Use the "fragmented" field of the "packet_info" structure in
"dissect_frame()" to indicate whether a ReportedBoundsError was due to
the packet being malformed (i.e., the packet was shorter than it's
supposed to be, so the dissector went past the end trying to extract
fields that were supposed to be there) or due to it not being
reassembled (i.e., the packet was fragmented, and we didn't reassemble
it, but just treated the first fragment as the entire packet, so the
dissector went past the end trying to extract fields that were partially
or completely in fragments after that). Mark the latter as being
unreasembled rather than malformed.
Properly initialize, save, and restore that field, and properly set it,
so that works.
svn path=/trunk/; revision=4555
2002-01-17 06:29:20 +00:00
|
|
|
edt->pi.fragmented = FALSE;
|
2001-12-08 21:03:41 +00:00
|
|
|
edt->pi.in_error_pkt = FALSE;
|
|
|
|
edt->pi.ptype = PT_NONE;
|
|
|
|
edt->pi.srcport = 0;
|
|
|
|
edt->pi.destport = 0;
|
2002-03-28 09:12:00 +00:00
|
|
|
edt->pi.match_port = 0;
|
|
|
|
edt->pi.can_desegment = 0;
|
2003-04-23 10:20:29 +00:00
|
|
|
edt->pi.want_pdu_tracking = 0;
|
2001-12-08 21:03:41 +00:00
|
|
|
edt->pi.p2p_dir = P2P_DIR_UNKNOWN;
|
|
|
|
edt->pi.private_data = NULL;
|
2002-12-08 02:32:36 +00:00
|
|
|
edt->pi.oxid = 0;
|
|
|
|
edt->pi.rxid = 0;
|
|
|
|
edt->pi.r_ctl = 0;
|
2003-01-22 06:26:36 +00:00
|
|
|
edt->pi.src_idx = 0;
|
|
|
|
edt->pi.dst_idx = 0;
|
|
|
|
edt->pi.vsan = 0;
|
2001-11-21 23:16:26 +00:00
|
|
|
|
2000-05-11 08:18:09 +00:00
|
|
|
TRY {
|
2002-02-18 01:08:44 +00:00
|
|
|
edt->tvb = tvb_new_real_data(pd, fd->cap_len, fd->pkt_len);
|
2001-12-08 21:03:41 +00:00
|
|
|
/* Add this tvbuffer into the data_src list */
|
2002-06-04 07:03:57 +00:00
|
|
|
add_new_data_source(&edt->pi, edt->tvb, "Frame");
|
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. */
|
|
|
|
if(frame_handle != NULL)
|
|
|
|
call_dissector(frame_handle, edt->tvb, &edt->pi, edt->tree);
|
|
|
|
|
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
|
|
|
}
|
|
|
|
CATCH(ReportedBoundsError) {
|
2001-04-01 23:11:43 +00:00
|
|
|
if(proto_malformed != -1){
|
2001-11-21 23:16:26 +00:00
|
|
|
proto_tree_add_protocol_format(edt->tree, proto_malformed, edt->tvb, 0, 0,
|
2000-10-06 10:11:40 +00:00
|
|
|
"[Malformed Frame: Packet Length]" );
|
2001-04-01 23:11:43 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
1998-11-12 00:06:47 +00:00
|
|
|
}
|
2000-05-11 08:18:09 +00:00
|
|
|
ENDTRY;
|
|
|
|
|
2000-04-13 20:39:38 +00:00
|
|
|
fd->flags.visited = 1;
|
1999-07-07 22:52:57 +00:00
|
|
|
}
|
|
|
|
|
2000-04-03 09:24:12 +00:00
|
|
|
/*********************** code added for sub-dissector lookup *********************/
|
|
|
|
|
2001-12-03 04:00:26 +00:00
|
|
|
/*
|
|
|
|
* An dissector handle.
|
|
|
|
*/
|
|
|
|
struct dissector_handle {
|
|
|
|
const char *name; /* dissector name */
|
2002-02-26 11:55:39 +00:00
|
|
|
gboolean is_new; /* TRUE if new-style dissector */
|
|
|
|
union {
|
|
|
|
dissector_t old;
|
|
|
|
new_dissector_t new;
|
|
|
|
} dissector;
|
2001-10-31 05:59:20 +00:00
|
|
|
int proto_index;
|
2001-12-03 04:00:26 +00:00
|
|
|
};
|
2001-02-01 07:34:33 +00:00
|
|
|
|
2003-01-20 05:42:37 +00:00
|
|
|
static int
|
|
|
|
call_dissector_through_handle(dissector_handle_t handle, tvbuff_t *tvb,
|
|
|
|
packet_info *pinfo, proto_tree *tree)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (handle->is_new)
|
|
|
|
ret = (*handle->dissector.new)(tvb, pinfo, tree);
|
|
|
|
else {
|
|
|
|
(*handle->dissector.old)(tvb, pinfo, tree);
|
|
|
|
ret = tvb_length(tvb);
|
|
|
|
if (ret == 0) {
|
|
|
|
/*
|
|
|
|
* XXX - a tvbuff can have 0 bytes of data in
|
|
|
|
* it, so we have to make sure we don't return
|
|
|
|
* 0.
|
|
|
|
*/
|
|
|
|
ret = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
call_dissector_work(dissector_handle_t handle, tvbuff_t *tvb,
|
|
|
|
packet_info *pinfo, proto_tree *tree)
|
|
|
|
{
|
|
|
|
const char *saved_proto;
|
|
|
|
guint16 saved_can_desegment;
|
2003-01-20 05:42:37 +00:00
|
|
|
volatile int ret;
|
|
|
|
gboolean save_writable;
|
|
|
|
volatile address save_dl_src;
|
|
|
|
volatile address save_dl_dst;
|
|
|
|
volatile address save_net_src;
|
|
|
|
volatile address save_net_dst;
|
|
|
|
volatile address save_src;
|
|
|
|
volatile address save_dst;
|
2002-10-28 23:04:15 +00:00
|
|
|
|
|
|
|
if (handle->proto_index != -1 &&
|
|
|
|
!proto_is_protocol_enabled(handle->proto_index)) {
|
|
|
|
/*
|
|
|
|
* The protocol isn't enabled.
|
|
|
|
*/
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
saved_proto = pinfo->current_proto;
|
|
|
|
saved_can_desegment = pinfo->can_desegment;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
pinfo->can_desegment = saved_can_desegment-(saved_can_desegment>0);
|
|
|
|
if (handle->proto_index != -1) {
|
|
|
|
pinfo->current_proto =
|
|
|
|
proto_get_protocol_short_name(handle->proto_index);
|
|
|
|
}
|
2003-01-20 05:42:37 +00:00
|
|
|
|
|
|
|
if (pinfo->in_error_pkt) {
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
save_writable = col_get_writable(pinfo->cinfo);
|
|
|
|
col_set_writable(pinfo->cinfo, FALSE);
|
|
|
|
save_dl_src = pinfo->dl_src;
|
|
|
|
save_dl_dst = pinfo->dl_dst;
|
|
|
|
save_net_src = pinfo->net_src;
|
|
|
|
save_net_dst = pinfo->net_dst;
|
|
|
|
save_src = pinfo->src;
|
|
|
|
save_dst = pinfo->dst;
|
|
|
|
|
|
|
|
/* Dissect the contained packet. */
|
|
|
|
TRY {
|
|
|
|
ret = call_dissector_through_handle(handle, tvb,
|
|
|
|
pinfo, tree);
|
|
|
|
}
|
|
|
|
CATCH(BoundsError) {
|
2002-10-29 05:15:24 +00:00
|
|
|
/*
|
2003-01-20 05:42:37 +00:00
|
|
|
* Restore the column writability and addresses.
|
2002-10-29 05:15:24 +00:00
|
|
|
*/
|
2003-01-20 05:42:37 +00:00
|
|
|
col_set_writable(pinfo->cinfo, save_writable);
|
|
|
|
pinfo->dl_src = save_dl_src;
|
|
|
|
pinfo->dl_dst = save_dl_dst;
|
|
|
|
pinfo->net_src = save_net_src;
|
|
|
|
pinfo->net_dst = save_net_dst;
|
|
|
|
pinfo->src = save_src;
|
|
|
|
pinfo->dst = save_dst;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Restore the desegmentability state.
|
|
|
|
*/
|
|
|
|
pinfo->can_desegment = saved_can_desegment;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Rethrow the exception, so this will be
|
|
|
|
* reported as a short frame.
|
|
|
|
*/
|
|
|
|
RETHROW;
|
2002-10-29 05:15:24 +00:00
|
|
|
}
|
2003-01-20 05:42:37 +00:00
|
|
|
CATCH(ReportedBoundsError) {
|
|
|
|
; /* do nothing */
|
|
|
|
}
|
|
|
|
ENDTRY;
|
|
|
|
|
|
|
|
col_set_writable(pinfo->cinfo, save_writable);
|
|
|
|
pinfo->dl_src = save_dl_src;
|
|
|
|
pinfo->dl_dst = save_dl_dst;
|
|
|
|
pinfo->net_src = save_net_src;
|
|
|
|
pinfo->net_dst = save_net_dst;
|
|
|
|
pinfo->src = save_src;
|
|
|
|
pinfo->dst = save_dst;
|
2003-04-23 10:20:29 +00:00
|
|
|
pinfo->want_pdu_tracking = 0;
|
2003-01-20 05:42:37 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Just call the subdissector.
|
|
|
|
*/
|
|
|
|
ret = call_dissector_through_handle(handle, tvb, pinfo, tree);
|
2002-10-28 23:04:15 +00:00
|
|
|
}
|
|
|
|
pinfo->current_proto = saved_proto;
|
|
|
|
pinfo->can_desegment = saved_can_desegment;
|
2003-04-23 10:20:29 +00:00
|
|
|
pinfo->want_pdu_tracking -= !!(pinfo->want_pdu_tracking);
|
2002-10-28 23:04:15 +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
|
|
|
/*
|
|
|
|
* 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
|
|
|
};
|
|
|
|
|
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
|
|
|
/*
|
|
|
|
* 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 port number 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 port number.
|
2001-12-08 06:41:48 +00:00
|
|
|
*
|
|
|
|
* "ui_name" is the name the dissector table has in the user interface.
|
|
|
|
*
|
|
|
|
* "type" is a field type giving the width of the port number for that
|
|
|
|
* dissector table.
|
|
|
|
*
|
|
|
|
* "base" is the base in which to display the port number for that
|
|
|
|
* dissector 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
|
|
|
*/
|
|
|
|
struct dissector_table {
|
2001-12-08 06:41:48 +00:00
|
|
|
GHashTable *hash_table;
|
|
|
|
GSList *dissector_handles;
|
|
|
|
char *ui_name;
|
|
|
|
ftenum_t type;
|
|
|
|
int base;
|
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
|
|
|
};
|
|
|
|
|
|
|
|
static GHashTable *dissector_tables = NULL;
|
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
g_assert(dissector_tables);
|
|
|
|
return g_hash_table_lookup( dissector_tables, name );
|
|
|
|
}
|
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
|
|
|
void
|
2001-12-03 04:00:26 +00:00
|
|
|
dissector_add(const char *name, 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
|
|
|
{
|
2000-04-03 09:24:12 +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
|
|
|
|
|
|
|
/* sanity check */
|
|
|
|
g_assert( sub_dissectors);
|
|
|
|
|
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 = g_malloc(sizeof (dtbl_entry_t));
|
2001-12-03 04:00:26 +00:00
|
|
|
dtbl_entry->current = handle;
|
2001-02-01 07:34:33 +00:00
|
|
|
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
|
|
|
|
2000-04-03 09:24:12 +00:00
|
|
|
/* do the table insertion */
|
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_insert( sub_dissectors->hash_table,
|
|
|
|
GUINT_TO_POINTER( pattern), (gpointer)dtbl_entry);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now add it to the list of handles that could be used with this
|
|
|
|
* table, because it *is* being used with this table.
|
|
|
|
*/
|
|
|
|
dissector_add_handle(name, handle);
|
2000-04-03 09:24:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* delete the entry for this dissector at this pattern */
|
|
|
|
|
|
|
|
/* NOTE: this doesn't use the dissector call variable. It is included to */
|
|
|
|
/* be consistant with the dissector_add 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
|
2002-03-02 20:51:46 +00:00
|
|
|
dissector_delete(const char *name, guint32 pattern,
|
|
|
|
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
|
|
|
{
|
2000-04-03 09:24:12 +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
|
|
|
|
|
|
|
/* sanity check */
|
|
|
|
g_assert( sub_dissectors);
|
|
|
|
|
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.
|
|
|
|
*/
|
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
|
|
|
dtbl_entry = g_hash_table_lookup(sub_dissectors->hash_table,
|
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
|
|
|
GUINT_TO_POINTER(pattern));
|
|
|
|
|
|
|
|
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,
|
|
|
|
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
|
|
|
|
|
|
|
/*
|
|
|
|
* Now free up the entry.
|
|
|
|
*/
|
|
|
|
g_free(dtbl_entry);
|
|
|
|
}
|
2000-04-03 09:24:12 +00:00
|
|
|
}
|
|
|
|
|
2001-02-01 07:34:33 +00:00
|
|
|
void
|
2001-12-03 04:00:26 +00:00
|
|
|
dissector_change(const char *name, guint32 pattern, dissector_handle_t handle)
|
2001-02-01 07:34:33 +00:00
|
|
|
{
|
|
|
|
dissector_table_t sub_dissectors = find_dissector_table( name);
|
|
|
|
dtbl_entry_t *dtbl_entry;
|
|
|
|
|
|
|
|
/* sanity check */
|
|
|
|
g_assert( sub_dissectors);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* See if the entry already exists. If so, reuse 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
|
|
|
dtbl_entry = g_hash_table_lookup(sub_dissectors->hash_table,
|
2001-02-01 07:34:33 +00:00
|
|
|
GUINT_TO_POINTER(pattern));
|
|
|
|
if (dtbl_entry != NULL) {
|
2001-12-03 04:00:26 +00:00
|
|
|
dtbl_entry->current = handle;
|
2001-02-01 07:34:33 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
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)
|
2001-02-01 07:34:33 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
dtbl_entry = 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
|
|
|
|
|
|
|
/* do the table insertion */
|
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_insert( sub_dissectors->hash_table,
|
|
|
|
GUINT_TO_POINTER( pattern), (gpointer)dtbl_entry);
|
2001-02-01 07:34:33 +00:00
|
|
|
}
|
|
|
|
|
2001-10-31 05:59:20 +00:00
|
|
|
/* Reset a dissector in a sub-dissector table to its initial value. */
|
2001-02-01 07:34:33 +00:00
|
|
|
void
|
|
|
|
dissector_reset(const char *name, guint32 pattern)
|
|
|
|
{
|
|
|
|
dissector_table_t sub_dissectors = find_dissector_table( name);
|
|
|
|
dtbl_entry_t *dtbl_entry;
|
|
|
|
|
|
|
|
/* sanity check */
|
|
|
|
g_assert( sub_dissectors);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find the 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
|
|
|
dtbl_entry = g_hash_table_lookup(sub_dissectors->hash_table,
|
2001-02-01 07:34:33 +00:00
|
|
|
GUINT_TO_POINTER(pattern));
|
|
|
|
|
|
|
|
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,
|
|
|
|
GUINT_TO_POINTER(pattern));
|
2001-02-01 07:34:33 +00:00
|
|
|
g_free(dtbl_entry);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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
|
|
|
/* Look for a given port in a given dissector table and, if found, call
|
|
|
|
the dissector with the arguments supplied, and return TRUE, otherwise
|
2001-12-03 05:07:18 +00:00
|
|
|
return FALSE. */
|
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
|
|
|
|
dissector_try_port(dissector_table_t sub_dissectors, guint32 port,
|
|
|
|
tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
|
|
|
|
{
|
|
|
|
dtbl_entry_t *dtbl_entry;
|
2002-02-26 11:55:39 +00:00
|
|
|
struct dissector_handle *handle;
|
2001-01-13 04:28:42 +00:00
|
|
|
guint32 saved_match_port;
|
2002-02-26 11:55:39 +00:00
|
|
|
int ret;
|
2001-11-29 09:05:25 +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
|
|
|
dtbl_entry = g_hash_table_lookup(sub_dissectors->hash_table,
|
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
|
|
|
GUINT_TO_POINTER(port));
|
|
|
|
if (dtbl_entry != NULL) {
|
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
|
|
|
/*
|
2001-12-03 04:00:26 +00:00
|
|
|
* Is there currently a dissector handle for this entry?
|
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
|
|
|
handle = dtbl_entry->current;
|
|
|
|
if (handle == NULL) {
|
2001-12-03 04:00:26 +00:00
|
|
|
/*
|
|
|
|
* No - pretend this dissector didn't exist,
|
|
|
|
* so that other dissectors might have a chance
|
|
|
|
* to dissect this packet.
|
|
|
|
*/
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2002-10-28 23:04:15 +00:00
|
|
|
* Save the current value of "pinfo->match_port",
|
|
|
|
* set it to the port that matched, call the
|
|
|
|
* dissector, and restore "pinfo->match_port".
|
2001-12-03 04:00:26 +00:00
|
|
|
*/
|
2001-01-13 04:28:42 +00:00
|
|
|
saved_match_port = pinfo->match_port;
|
|
|
|
pinfo->match_port = port;
|
2002-10-28 23:04:15 +00:00
|
|
|
ret = call_dissector_work(handle, tvb, pinfo, tree);
|
2001-01-13 04:28:42 +00:00
|
|
|
pinfo->match_port = saved_match_port;
|
2002-02-26 11:55:39 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*
|
2002-10-28 23:04:15 +00:00
|
|
|
* 0 is also returned if the protocol wasn't enabled.
|
|
|
|
*
|
|
|
|
* If the packet was rejected, we return FALSE, so that
|
|
|
|
* other dissectors might have a chance to dissect this
|
|
|
|
* packet, otherwise we return TRUE.
|
2002-02-26 11:55:39 +00:00
|
|
|
*/
|
|
|
|
return ret != 0;
|
2002-08-28 20:41:00 +00:00
|
|
|
}
|
2001-11-29 09:05:25 +00:00
|
|
|
return FALSE;
|
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
|
|
|
|
2001-12-03 05:07:18 +00:00
|
|
|
/* Look for a given port in a given dissector table and, if found, return
|
|
|
|
the dissector handle for that port. */
|
|
|
|
dissector_handle_t
|
|
|
|
dissector_get_port_handle(dissector_table_t sub_dissectors, guint32 port)
|
|
|
|
{
|
|
|
|
dtbl_entry_t *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
|
|
|
dtbl_entry = g_hash_table_lookup(sub_dissectors->hash_table,
|
2001-12-03 05:07:18 +00:00
|
|
|
GUINT_TO_POINTER(port));
|
|
|
|
if (dtbl_entry != NULL)
|
|
|
|
return dtbl_entry->current;
|
|
|
|
else
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
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
|
|
|
|
table. That list is used by code in the UI. */
|
|
|
|
void
|
|
|
|
dissector_add_handle(const char *name, dissector_handle_t handle)
|
|
|
|
{
|
|
|
|
dissector_table_t sub_dissectors = find_dissector_table( name);
|
|
|
|
GSList *entry;
|
|
|
|
|
|
|
|
/* sanity check */
|
|
|
|
g_assert(sub_dissectors != NULL);
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Add it to the list. */
|
|
|
|
sub_dissectors->dissector_handles =
|
|
|
|
g_slist_append(sub_dissectors->dissector_handles, (gpointer)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
|
|
|
}
|
|
|
|
|
|
|
|
/**************************************************/
|
|
|
|
/* */
|
|
|
|
/* Routines to walk dissector tables */
|
|
|
|
/* */
|
|
|
|
/**************************************************/
|
|
|
|
|
|
|
|
typedef struct dissector_foreach_info {
|
|
|
|
gpointer caller_data;
|
|
|
|
DATFunc caller_func;
|
|
|
|
GHFunc next_func;
|
|
|
|
gchar *table_name;
|
|
|
|
} 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;
|
|
|
|
dtbl_entry_t *dtbl_entry;
|
|
|
|
|
|
|
|
g_assert(value);
|
|
|
|
g_assert(user_data);
|
|
|
|
|
|
|
|
dtbl_entry = value;
|
2001-12-03 04:00:26 +00:00
|
|
|
if (dtbl_entry->current == NULL ||
|
|
|
|
dtbl_entry->current->proto_index == -1) {
|
|
|
|
/*
|
|
|
|
* 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
|
|
|
}
|
|
|
|
|
|
|
|
info = user_data;
|
|
|
|
info->caller_func(info->table_name, key, value, info->caller_data);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
{
|
2001-12-03 09:00:25 +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);
|
|
|
|
|
2001-12-03 09:00:25 +00:00
|
|
|
sub_dissectors = value;
|
2001-02-01 07:34:33 +00:00
|
|
|
info = user_data;
|
|
|
|
info->table_name = (gchar*) key;
|
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.
|
|
|
|
*/
|
2001-02-01 07:34:33 +00:00
|
|
|
void
|
|
|
|
dissector_all_tables_foreach (DATFunc func,
|
|
|
|
gpointer user_data)
|
|
|
|
{
|
|
|
|
dissector_foreach_info_t info;
|
|
|
|
|
|
|
|
info.caller_data = user_data;
|
|
|
|
info.caller_func = func;
|
2001-12-03 01:20:51 +00:00
|
|
|
info.next_func = dissector_table_foreach_func;
|
|
|
|
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
|
|
|
|
dissector_table_foreach (char *name,
|
|
|
|
DATFunc func,
|
|
|
|
gpointer user_data)
|
|
|
|
{
|
|
|
|
dissector_foreach_info_t info;
|
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
|
|
|
dissector_table_t sub_dissectors = find_dissector_table( name);
|
2001-02-01 07:34:33 +00:00
|
|
|
|
|
|
|
info.table_name = name;
|
|
|
|
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
|
2003-06-05 04:47:58 +00:00
|
|
|
dissector_table_foreach_handle(char *name,
|
|
|
|
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
|
|
|
{
|
|
|
|
dissector_table_t sub_dissectors = find_dissector_table( name);
|
|
|
|
GSList *tmp;
|
|
|
|
|
|
|
|
for (tmp = sub_dissectors->dissector_handles; tmp != NULL;
|
|
|
|
tmp = g_slist_next(tmp))
|
|
|
|
func(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
|
|
|
{
|
|
|
|
dtbl_entry_t *dtbl_entry;
|
|
|
|
dissector_foreach_info_t *info;
|
|
|
|
|
|
|
|
g_assert(value);
|
|
|
|
g_assert(user_data);
|
|
|
|
|
|
|
|
dtbl_entry = 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
|
|
|
}
|
|
|
|
|
|
|
|
info = user_data;
|
|
|
|
info->caller_func(info->table_name, key, value, info->caller_data);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
dissector_all_tables_foreach_changed (DATFunc func,
|
|
|
|
gpointer user_data)
|
|
|
|
{
|
|
|
|
dissector_foreach_info_t info;
|
|
|
|
|
|
|
|
info.caller_data = user_data;
|
|
|
|
info.caller_func = func;
|
2001-12-03 01:20:51 +00:00
|
|
|
info.next_func = dissector_table_foreach_changed_func;
|
|
|
|
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
|
|
|
|
dissector_table_foreach_changed (char *name,
|
|
|
|
DATFunc func,
|
|
|
|
gpointer user_data)
|
|
|
|
{
|
|
|
|
dissector_foreach_info_t info;
|
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
|
|
|
dissector_table_t sub_dissectors = find_dissector_table( name);
|
2001-02-01 07:34:33 +00:00
|
|
|
|
|
|
|
info.table_name = name;
|
|
|
|
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_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 {
|
|
|
|
gpointer caller_data;
|
|
|
|
DATFunc_table caller_func;
|
|
|
|
} dissector_foreach_table_info_t;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Called for each entry in the table of all dissector tables.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
dissector_all_tables_foreach_table_func (gpointer key, gpointer value, gpointer user_data)
|
|
|
|
{
|
|
|
|
dissector_table_t table;
|
|
|
|
dissector_foreach_table_info_t *info;
|
|
|
|
|
|
|
|
table = value;
|
|
|
|
info = user_data;
|
|
|
|
(*info->caller_func)((gchar*)key, table->ui_name, info->caller_data);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Walk all dissector tables calling a user supplied function on each
|
|
|
|
* table.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
dissector_all_tables_foreach_table (DATFunc_table func,
|
|
|
|
gpointer user_data)
|
|
|
|
{
|
|
|
|
dissector_foreach_table_info_t info;
|
|
|
|
|
|
|
|
info.caller_data = user_data;
|
|
|
|
info.caller_func = func;
|
|
|
|
g_hash_table_foreach(dissector_tables, dissector_all_tables_foreach_table_func, &info);
|
|
|
|
}
|
|
|
|
|
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
|
2001-12-08 06:41:48 +00:00
|
|
|
register_dissector_table(const char *name, char *ui_name, ftenum_t type,
|
|
|
|
int base)
|
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
|
|
|
/* Create our hash-of-hashes if it doesn't already exist */
|
|
|
|
if (!dissector_tables) {
|
|
|
|
dissector_tables = g_hash_table_new( g_str_hash, g_str_equal );
|
|
|
|
g_assert(dissector_tables);
|
|
|
|
}
|
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 */
|
|
|
|
g_assert(!g_hash_table_lookup( dissector_tables, name ));
|
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. */
|
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 = g_malloc(sizeof (struct dissector_table));
|
|
|
|
sub_dissectors->hash_table = g_hash_table_new( g_direct_hash,
|
|
|
|
g_direct_equal );
|
|
|
|
sub_dissectors->dissector_handles = NULL;
|
2001-12-08 06:41:48 +00:00
|
|
|
sub_dissectors->ui_name = ui_name;
|
|
|
|
sub_dissectors->type = type;
|
|
|
|
sub_dissectors->base = base;
|
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
|
|
|
g_hash_table_insert( dissector_tables, (gpointer)name, (gpointer) sub_dissectors );
|
|
|
|
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
|
|
|
|
2001-12-08 06:41:48 +00:00
|
|
|
char *
|
|
|
|
get_dissector_table_ui_name(const char *name)
|
|
|
|
{
|
|
|
|
dissector_table_t sub_dissectors = find_dissector_table( name);
|
|
|
|
|
|
|
|
return sub_dissectors->ui_name;
|
|
|
|
}
|
|
|
|
|
|
|
|
ftenum_t
|
|
|
|
get_dissector_table_type(const char *name)
|
|
|
|
{
|
|
|
|
dissector_table_t sub_dissectors = find_dissector_table( name);
|
|
|
|
|
|
|
|
return sub_dissectors->type;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
get_dissector_table_base(const char *name)
|
|
|
|
{
|
|
|
|
dissector_table_t sub_dissectors = find_dissector_table( name);
|
|
|
|
|
|
|
|
return sub_dissectors->base;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
static GHashTable *heur_dissector_lists = NULL;
|
|
|
|
|
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
|
|
|
typedef struct {
|
2001-05-30 06:41:08 +00:00
|
|
|
heur_dissector_t dissector;
|
2001-01-09 06:32:10 +00:00
|
|
|
int proto_index;
|
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
|
|
|
} heur_dtbl_entry_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
|
|
|
/* Finds a heuristic dissector table by field name. */
|
|
|
|
static heur_dissector_list_t *
|
|
|
|
find_heur_dissector_list(const char *name)
|
|
|
|
{
|
|
|
|
g_assert(heur_dissector_lists != NULL);
|
|
|
|
return g_hash_table_lookup(heur_dissector_lists, name);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2001-01-09 06:32:10 +00:00
|
|
|
heur_dissector_add(const char *name, heur_dissector_t dissector, 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
|
|
|
{
|
|
|
|
heur_dissector_list_t *sub_dissectors = find_heur_dissector_list(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
|
|
|
heur_dtbl_entry_t *dtbl_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
|
|
|
|
|
|
|
/* sanity check */
|
|
|
|
g_assert(sub_dissectors != NULL);
|
|
|
|
|
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 = g_malloc(sizeof (heur_dtbl_entry_t));
|
2001-05-30 06:41:08 +00:00
|
|
|
dtbl_entry->dissector = dissector;
|
2001-01-09 06:32:10 +00:00
|
|
|
dtbl_entry->proto_index = proto;
|
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 */
|
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
|
|
|
*sub_dissectors = g_slist_append(*sub_dissectors, (gpointer)dtbl_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
|
|
|
}
|
|
|
|
|
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
|
|
|
|
dissector_try_heuristic(heur_dissector_list_t sub_dissectors,
|
|
|
|
tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
|
|
|
|
{
|
2001-01-12 09:25:29 +00:00
|
|
|
gboolean status;
|
|
|
|
const char *saved_proto;
|
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
|
|
|
GSList *entry;
|
|
|
|
heur_dtbl_entry_t *dtbl_entry;
|
2001-11-29 09:05:25 +00:00
|
|
|
guint16 saved_can_desegment;
|
|
|
|
|
|
|
|
/* 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.
|
|
|
|
*/
|
|
|
|
saved_can_desegment=pinfo->can_desegment;
|
|
|
|
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
|
|
|
|
2001-01-12 09:25:29 +00:00
|
|
|
status = FALSE;
|
|
|
|
saved_proto = pinfo->current_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
|
|
|
for (entry = sub_dissectors; entry != NULL; entry = g_slist_next(entry)) {
|
2001-11-29 09:05:25 +00:00
|
|
|
pinfo->can_desegment = saved_can_desegment-(saved_can_desegment>0);
|
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 = (heur_dtbl_entry_t *)entry->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
|
|
|
if (dtbl_entry->proto_index != -1 &&
|
|
|
|
!proto_is_protocol_enabled(dtbl_entry->proto_index)) {
|
|
|
|
/*
|
|
|
|
* No - don't try this dissector.
|
|
|
|
*/
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2001-05-30 06:41:08 +00:00
|
|
|
if (dtbl_entry->proto_index != -1) {
|
|
|
|
pinfo->current_proto =
|
|
|
|
proto_get_protocol_short_name(dtbl_entry->proto_index);
|
|
|
|
}
|
|
|
|
if ((*dtbl_entry->dissector)(tvb, pinfo, tree)) {
|
|
|
|
status = TRUE;
|
|
|
|
break;
|
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
|
|
|
}
|
2001-01-12 09:25:29 +00:00
|
|
|
pinfo->current_proto = saved_proto;
|
2001-11-29 09:05:25 +00:00
|
|
|
pinfo->can_desegment=saved_can_desegment;
|
2003-04-23 10:20:29 +00:00
|
|
|
pinfo->want_pdu_tracking -= !!(pinfo->want_pdu_tracking);
|
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
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
register_heur_dissector_list(const char *name, heur_dissector_list_t *sub_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
|
|
|
/* Create our hash-of-lists if it doesn't already exist */
|
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 (heur_dissector_lists == NULL) {
|
|
|
|
heur_dissector_lists = g_hash_table_new(g_str_hash, g_str_equal);
|
|
|
|
g_assert(heur_dissector_lists != NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Make sure the registration is unique */
|
|
|
|
g_assert(g_hash_table_lookup(heur_dissector_lists, name) == NULL);
|
|
|
|
|
|
|
|
*sub_dissectors = NULL; /* initially empty */
|
|
|
|
g_hash_table_insert(heur_dissector_lists, (gpointer)name,
|
|
|
|
(gpointer) 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".
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* List of registered dissectors.
|
|
|
|
*/
|
|
|
|
static GHashTable *registered_dissectors = NULL;
|
|
|
|
|
2001-12-03 04:00:26 +00:00
|
|
|
/* Get the short name of the protocol for a dissector handle. */
|
|
|
|
char *
|
|
|
|
dissector_handle_get_short_name(dissector_handle_t handle)
|
|
|
|
{
|
|
|
|
return proto_get_protocol_short_name(handle->proto_index);
|
|
|
|
}
|
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-11-15 03:10:36 +00:00
|
|
|
/* Get the index of the protocol for a dissector handle. */
|
|
|
|
int
|
|
|
|
dissector_handle_get_protocol_index(dissector_handle_t handle)
|
|
|
|
{
|
2003-05-23 22:09:36 +00:00
|
|
|
return handle->proto_index;
|
2002-11-15 03:10:36 +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
|
|
|
/* Find a registered dissector by name. */
|
|
|
|
dissector_handle_t
|
|
|
|
find_dissector(const char *name)
|
|
|
|
{
|
|
|
|
g_assert(registered_dissectors != NULL);
|
|
|
|
return g_hash_table_lookup(registered_dissectors, name);
|
|
|
|
}
|
|
|
|
|
2001-11-27 07:13:32 +00:00
|
|
|
/* Create an anonymous handle for a dissector. */
|
|
|
|
dissector_handle_t
|
|
|
|
create_dissector_handle(dissector_t dissector, int proto)
|
|
|
|
{
|
|
|
|
struct dissector_handle *handle;
|
|
|
|
|
|
|
|
handle = g_malloc(sizeof (struct dissector_handle));
|
|
|
|
handle->name = NULL;
|
2002-02-27 00:26:29 +00:00
|
|
|
handle->is_new = FALSE;
|
|
|
|
handle->dissector.old = dissector;
|
2001-11-27 07:13:32 +00:00
|
|
|
handle->proto_index = proto;
|
|
|
|
|
|
|
|
return handle;
|
|
|
|
}
|
|
|
|
|
2002-04-28 00:13:05 +00:00
|
|
|
dissector_handle_t
|
|
|
|
new_create_dissector_handle(new_dissector_t dissector, int proto)
|
|
|
|
{
|
|
|
|
struct dissector_handle *handle;
|
|
|
|
|
|
|
|
handle = g_malloc(sizeof (struct dissector_handle));
|
|
|
|
handle->name = NULL;
|
|
|
|
handle->is_new = TRUE;
|
|
|
|
handle->dissector.new = dissector;
|
|
|
|
handle->proto_index = proto;
|
|
|
|
|
|
|
|
return handle;
|
|
|
|
}
|
|
|
|
|
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 a dissector by name. */
|
|
|
|
void
|
2001-01-09 06:32:10 +00:00
|
|
|
register_dissector(const char *name, dissector_t dissector, int proto)
|
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
|
|
|
{
|
|
|
|
struct dissector_handle *handle;
|
|
|
|
|
|
|
|
/* Create our hash table if it doesn't already exist */
|
|
|
|
if (registered_dissectors == NULL) {
|
|
|
|
registered_dissectors = g_hash_table_new(g_str_hash, g_str_equal);
|
|
|
|
g_assert(registered_dissectors != NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Make sure the registration is unique */
|
|
|
|
g_assert(g_hash_table_lookup(registered_dissectors, name) == NULL);
|
|
|
|
|
|
|
|
handle = g_malloc(sizeof (struct dissector_handle));
|
|
|
|
handle->name = name;
|
2002-02-26 11:55:39 +00:00
|
|
|
handle->is_new = FALSE;
|
|
|
|
handle->dissector.old = dissector;
|
2001-01-09 06:32:10 +00:00
|
|
|
handle->proto_index = proto;
|
2002-08-28 20:41:00 +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
|
|
|
g_hash_table_insert(registered_dissectors, (gpointer)name,
|
|
|
|
(gpointer) handle);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2002-02-26 11:55:39 +00:00
|
|
|
new_register_dissector(const char *name, new_dissector_t dissector, int proto)
|
|
|
|
{
|
|
|
|
struct dissector_handle *handle;
|
|
|
|
|
|
|
|
/* Create our hash table if it doesn't already exist */
|
|
|
|
if (registered_dissectors == NULL) {
|
|
|
|
registered_dissectors = g_hash_table_new(g_str_hash, g_str_equal);
|
|
|
|
g_assert(registered_dissectors != NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Make sure the registration is unique */
|
|
|
|
g_assert(g_hash_table_lookup(registered_dissectors, name) == NULL);
|
|
|
|
|
|
|
|
handle = g_malloc(sizeof (struct dissector_handle));
|
|
|
|
handle->name = name;
|
|
|
|
handle->is_new = TRUE;
|
|
|
|
handle->dissector.new = dissector;
|
|
|
|
handle->proto_index = proto;
|
2002-08-28 20:41:00 +00:00
|
|
|
|
2002-02-26 11:55:39 +00:00
|
|
|
g_hash_table_insert(registered_dissectors, (gpointer)name,
|
|
|
|
(gpointer) handle);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Call a dissector through a handle. */
|
|
|
|
int
|
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
|
|
|
call_dissector(dissector_handle_t handle, tvbuff_t *tvb,
|
|
|
|
packet_info *pinfo, proto_tree *tree)
|
|
|
|
{
|
2002-02-26 11:55:39 +00:00
|
|
|
int ret;
|
2001-01-12 09:25:29 +00:00
|
|
|
|
2002-10-28 23:04:15 +00:00
|
|
|
ret = call_dissector_work(handle, tvb, pinfo, tree);
|
|
|
|
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
|
|
|
*/
|
2001-11-26 05:41:15 +00:00
|
|
|
g_assert(data_handle != NULL);
|
|
|
|
g_assert(data_handle->proto_index != -1);
|
2002-02-26 11:55:39 +00:00
|
|
|
call_dissector(data_handle, tvb, pinfo, tree);
|
|
|
|
return tvb_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
|
|
|
}
|