Mirror it after protocol dissector API.
Change-Id: I7985bcfa9e07654c7cf005efec94efc205d7a304
Reviewed-on: https://code.wireshark.org/review/18496
Reviewed-by: Michael Mann <mmann78@netscape.net>
bytes_to_str@Base 1.99.2
bytestring_to_str@Base 1.9.1
call_ber_oid_callback@Base 1.9.1
+ call_capture_dissector@Base 2.3.0
call_data_dissector@Base 2.1.0
call_dissector@Base 1.9.1
call_dissector_only@Base 1.9.1
call_per_oid_callback@Base 1.99.1
camelSRTtype_naming@Base 1.9.1
camel_opr_code_strings@Base 1.9.1
+ capture_dissector_add_uint@Base 2.3.0
capture_dissector_get_count@Base 2.1.0
capture_dissector_increment_count@Base 2.1.0
check_xdlc_control@Base 1.9.1
crc32_mpeg2_tvb_seed@Base 1.9.1
crc32c_tvb_offset_calculate@Base 1.99.0
crc6_compute_tvb@Base 1.99.0
+ create_capture_dissector_handle@Base 2.3.0
create_dissector_handle@Base 2.1.0
create_dissector_handle_with_name@Base 2.1.0
dcerpc_get_proto_hf_opnum@Base 2.1.0
filter_expression_new@Base 1.9.1
filter_expression_free@Base 1.99.3
find_and_mark_frame_depended_upon@Base 1.12.0~rc1
+ find_capture_dissector@Base 2.3.0
find_circuit@Base 1.9.1
find_conversation@Base 1.9.1
find_conversation_filter@Base 2.0.0
struct capture_dissector_handle
{
- guint32 pattern;
+ const char *name;
capture_dissector_t dissector;
protocol_t* protocol;
};
guint32 count;
} capture_dissector_count_t;
+static GHashTable *registered_dissectors = NULL;
+
static GHashTable *capture_dissector_tables = NULL;
static void
void capture_dissector_init(void)
{
+ registered_dissectors = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, NULL);
capture_dissector_tables = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, destroy_capture_dissector_table);
}
void capture_dissector_cleanup(void)
{
g_hash_table_destroy(capture_dissector_tables);
+ g_hash_table_destroy(registered_dissectors);
}
void register_capture_dissector_table(const char *name, const char *ui_name)
}
-void register_capture_dissector(const char* name, const guint32 pattern, capture_dissector_t dissector, const int proto)
+static capture_dissector_handle_t
+new_capture_dissector_handle(capture_dissector_t dissector, int proto, const char *name)
+{
+ struct capture_dissector_handle* handle;
+
+ handle = wmem_new(wmem_epan_scope(), struct capture_dissector_handle);
+ handle->name = name;
+ handle->dissector = dissector;
+ handle->protocol = find_protocol_by_id(proto);
+ return handle;
+}
+
+capture_dissector_handle_t
+create_capture_dissector_handle(capture_dissector_t dissector, const int proto)
+{
+ return new_capture_dissector_handle(dissector, proto, NULL);
+}
+
+capture_dissector_handle_t find_capture_dissector(const char *name)
+{
+ return (capture_dissector_handle_t)g_hash_table_lookup(registered_dissectors, name);
+}
+
+capture_dissector_handle_t register_capture_dissector(const char *name, capture_dissector_t dissector, int proto)
+{
+ capture_dissector_handle_t handle;
+
+ /* Make sure the registration is unique */
+ g_assert(g_hash_table_lookup(registered_dissectors, name) == NULL);
+
+ handle = new_capture_dissector_handle(dissector, proto, name);
+ g_hash_table_insert(registered_dissectors, (gpointer)name, handle);
+ return handle;
+}
+
+void capture_dissector_add_uint(const char *name, const guint32 pattern, capture_dissector_handle_t handle)
{
struct capture_dissector_table* sub_dissectors;
- struct capture_dissector_handle *handle;
+
+ if (handle == NULL)
+ return;
/* Make sure table exists */
sub_dissectors = (struct capture_dissector_table*)g_hash_table_lookup( capture_dissector_tables, name );
/* Make sure the registration is unique */
g_assert(g_hash_table_lookup(sub_dissectors->hash_table, GUINT_TO_POINTER(pattern)) == NULL);
- handle = wmem_new(wmem_epan_scope(), struct capture_dissector_handle);
- handle->pattern = pattern;
- handle->dissector = dissector;
- handle->protocol = find_protocol_by_id(proto);
-
g_hash_table_insert(sub_dissectors->hash_table, GUINT_TO_POINTER(pattern), (gpointer) handle);
}
gboolean try_capture_dissector(const char* name, const guint32 pattern, const guchar *pd, int offset, int len, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header)
{
struct capture_dissector_table* sub_dissectors;
- struct capture_dissector_handle* handle;
+ capture_dissector_handle_t handle;
sub_dissectors = (struct capture_dissector_table*)g_hash_table_lookup( capture_dissector_tables, name );
if (sub_dissectors == NULL)
return FALSE;
}
- handle = (struct capture_dissector_handle *)g_hash_table_lookup(sub_dissectors->hash_table, GUINT_TO_POINTER(pattern));
+ handle = (capture_dissector_handle_t)g_hash_table_lookup(sub_dissectors->hash_table, GUINT_TO_POINTER(pattern));
if (handle == NULL)
return FALSE;
return handle->dissector(pd, offset, len, cpinfo, pseudo_header);
}
+gboolean call_capture_dissector(capture_dissector_handle_t handle, const guchar *pd, int offset, int len, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header)
+{
+ if (handle == NULL)
+ return FALSE;
+ return handle->dissector(pd, offset, len, cpinfo, pseudo_header);
+}
+
guint32 capture_dissector_get_count(packet_counts* counts, const int proto)
{
capture_dissector_count_t* hash_count = (capture_dissector_count_t*)g_hash_table_lookup(counts->counts_hash, GUINT_TO_POINTER(proto));
/** @file
*/
+typedef struct capture_dissector_handle* capture_dissector_handle_t;
+
/** callback function definition for capture dissectors */
typedef gboolean (*capture_dissector_t)(const guchar *pd, int offset, int len, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header);
/* a protocol uses the function to register a capture sub-dissector table
+ * @param[in] name Name of capture sub-dissector table.
+ * @param[in] ui_name Name string used when referring to capture sub-dissector table in UI.
*/
WS_DLL_PUBLIC void register_capture_dissector_table(const char *name, const char *ui_name);
+/* Create an anonymous handle for a capture dissector
+ * @param[in] dissector capture dissector function.
+ * @param[in] proto Protocol associated with capture dissector function.
+ * @return Handle created for capture dissector
+ */
+WS_DLL_PUBLIC capture_dissector_handle_t create_capture_dissector_handle(capture_dissector_t dissector, const int proto);
+
+/* Find a dissector by name
+ * @param[in] name Name of capture dissector
+ * @return Handle for capture dissector if found, NULL otherwise
+ */
+WS_DLL_PUBLIC capture_dissector_handle_t find_capture_dissector(const char *name);
-/** Register a new capture dissector. */
-WS_DLL_PUBLIC void register_capture_dissector(const char* name, const guint32 pattern, capture_dissector_t dissector, const int proto);
+/* Register a new capture dissector
+ * @param[in] name Name of capture dissector function.
+ * @param[in] dissector capture dissector function.
+ * @param[in] proto Protocol associated with capture dissector function.
+ * @return Handle created for capture dissector
+ */
+WS_DLL_PUBLIC capture_dissector_handle_t register_capture_dissector(const char *name, capture_dissector_t dissector, int proto);
+
+/* Add an entry to a uint capture dissector table
+ * @param[in] name Name of capture dissector table
+ * @param[in] pattern Numerical value associated with capture dissector
+ * @param[in] handle Handle to capture dissector
+ */
+WS_DLL_PUBLIC void capture_dissector_add_uint(const char *name, const guint32 pattern, capture_dissector_handle_t handle);
+/* Look for a given value in a given uint capture dissector table and, if found,
+ * call the dissector with the arguments supplied, and return TRUE,
+ * otherwise return FALSE
+ * @param[in] name Name of capture dissector table
+ * @param[in] pattern Numerical value associated with capture dissector
+ * @param[in] pd Data buffer of captured bytes
+ * @param[in] offset Current offset into pd
+ * @param[in] len Length of pd
+ * @param[in] cpinfo Capture statistics
+ * @param[in] pseudo_header Wiretap pseudo header information
+ */
WS_DLL_PUBLIC gboolean try_capture_dissector(const char* name, const guint32 pattern, const guchar *pd, int offset, int len, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header);
+/* Call a capture dissector through a handle. If handle is value return TRUE,
+ * otherwise return FALSE
+ * @param[in] handle Capture dissector handle
+ * @param[in] pd Data buffer of captured bytes
+ * @param[in] offset Current offset into pd
+ * @param[in] len Length of pd
+ * @param[in] cpinfo Capture statistics
+ * @param[in] pseudo_header Wiretap pseudo header information
+ */
+WS_DLL_PUBLIC gboolean call_capture_dissector(capture_dissector_handle_t handle, const guchar *pd, int offset, int len, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header);
+
+/* Get current capture packet count for a particular protocol
+ * @param[in] counts Packet count structure
+ * @param[in] proto Protocol to retrieve packet count from
+ * @return Number of packets captured for a particular protocol
+ */
WS_DLL_PUBLIC guint32 capture_dissector_get_count(packet_counts* counts, const int proto);
+
+/* Increment packet capture count by 1 for a particular protocol.
+ * @param[in] cpinfo Capture statistics
+ * @param[in] proto Protocol to increment packet count
+ */
WS_DLL_PUBLIC void capture_dissector_increment_count(capture_packet_info_t *cpinfo, const int proto);
extern void capture_dissector_init(void);
packet-atalk.h \
packet-atm.h \
packet-atn-ulcs.h \
- packet-ax25.h \
packet-bacapp.h \
packet-ber.h \
packet-bfd.h \
proto_reg_handoff_ap1394(void)
{
dissector_handle_t ap1394_handle;
+ capture_dissector_handle_t ap1394_cap_handle;
ethertype_subdissector_table = find_dissector_table("ethertype");
ap1394_handle = create_dissector_handle(dissect_ap1394, proto_ap1394);
dissector_add_uint("wtap_encap", WTAP_ENCAP_APPLE_IP_OVER_IEEE1394, ap1394_handle);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_APPLE_IP_OVER_IEEE1394, capture_ap1394, proto_ap1394);
+
+ ap1394_cap_handle = create_capture_dissector_handle(capture_ap1394, proto_ap1394);
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_APPLE_IP_OVER_IEEE1394, ap1394_cap_handle);
}
/*
static dissector_table_t arcnet_dissector_table;
+static capture_dissector_handle_t ip_cap_handle;
+static capture_dissector_handle_t arp_cap_handle;
+
/* Cache protocol for packet counting */
static int proto_ipx = -1;
case ARCNET_PROTO_IP_1051:
/* No fragmentation stuff in the header */
- return capture_ip(pd, offset + 1, len, cpinfo, pseudo_header);
+ return call_capture_dissector(ip_cap_handle, pd, offset + 1, len, cpinfo, pseudo_header);
case ARCNET_PROTO_IP_1201:
/*
type appears after the padding. */
offset += 4;
}
- return capture_ip(pd, offset + 3, len, cpinfo, pseudo_header);
+ return call_capture_dissector(ip_cap_handle, pd, offset + 3, len, cpinfo, pseudo_header);
case ARCNET_PROTO_ARP_1051:
case ARCNET_PROTO_ARP_1201:
/*
* XXX - do we have to worry about fragmentation for ARP?
*/
- return capture_arp(pd, offset + 1, len, cpinfo, pseudo_header);
+ return call_capture_dissector(arp_cap_handle, pd, offset + 1, len, cpinfo, pseudo_header);
case ARCNET_PROTO_IPX:
capture_dissector_increment_count(cpinfo, proto_ipx);
proto_reg_handoff_arcnet (void)
{
dissector_handle_t arcnet_handle, arcnet_linux_handle;
+ capture_dissector_handle_t arcnet_cap_handle;
arcnet_handle = create_dissector_handle (dissect_arcnet, proto_arcnet);
dissector_add_uint ("wtap_encap", WTAP_ENCAP_ARCNET, arcnet_handle);
proto_ipx = proto_get_id_by_filter_name("ipx");
- register_capture_dissector("wtap_encap", WTAP_ENCAP_ARCNET_LINUX, capture_arcnet, proto_arcnet);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_ARCNET, capture_arcnet_has_exception, proto_arcnet);
+ arcnet_cap_handle = create_capture_dissector_handle(capture_arcnet, proto_arcnet);
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_ARCNET_LINUX, arcnet_cap_handle);
+ arcnet_cap_handle = create_capture_dissector_handle(capture_arcnet_has_exception, proto_arcnet);
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_ARCNET, arcnet_cap_handle);
+
+ ip_cap_handle = find_capture_dissector("ip");
+ arp_cap_handle = find_capture_dissector("arp");
}
/*
static dissector_handle_t atmarp_handle;
static dissector_handle_t ax25arp_handle;
+static capture_dissector_handle_t arp_cap_handle;
+
/* Used for determining if frequency of ARP requests constitute a storm */
#define STORM 1
#define NO_STORM 2
register_init_routine(&arp_init_protocol);
register_cleanup_routine(&arp_cleanup_protocol);
+
+ arp_cap_handle = register_capture_dissector("arp", capture_arp, proto_arp);
}
void
dissector_add_uint("arcnet.protocol_id", ARCNET_PROTO_RARP_1201, arp_handle);
dissector_add_uint("ax25.pid", AX25_P_ARP, arp_handle);
dissector_add_uint("gre.proto", ETHERTYPE_ARP, arp_handle);
- register_capture_dissector("ethertype", ETHERTYPE_ARP, capture_arp, proto_arp);
- register_capture_dissector("ax25.pid", AX25_P_ARP, capture_arp, proto_arp);
+ capture_dissector_add_uint("ethertype", ETHERTYPE_ARP, arp_cap_handle);
+ capture_dissector_add_uint("ax25.pid", AX25_P_ARP, arp_cap_handle);
}
/*
const gchar *tvb_arphrdaddr_to_str(tvbuff_t *tvb, gint offset, int ad_len, guint16 type);
void dissect_atm_nsap(tvbuff_t *tvb, packet_info* pinfo, int offset, int len, proto_tree *tree);
-gboolean capture_arp(const guchar *pd, int offset, int len, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header);
extern const value_string arp_hrd_vals[];
dissector_handle_t atp_handle;
dissector_handle_t zip_ddp_handle;
dissector_handle_t rtmp_data_handle, llap_handle;
+ capture_dissector_handle_t llap_cap_handle;
ddp_short_handle = create_dissector_handle(dissect_ddp_short, proto_ddp);
ddp_handle = create_dissector_handle(dissect_ddp, proto_ddp);
llap_handle = create_dissector_handle(dissect_llap, proto_llap);
dissector_add_uint("wtap_encap", WTAP_ENCAP_LOCALTALK, llap_handle);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_LOCALTALK, capture_llap, proto_llap);
+ llap_cap_handle = create_capture_dissector_handle(capture_llap, proto_llap);
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_LOCALTALK, llap_cap_handle);
register_init_routine( atp_init);
register_cleanup_routine( atp_cleanup);
void
proto_reg_handoff_atm(void)
{
+ capture_dissector_handle_t atm_cap_handle;
+
/*
* Get handles for the Ethernet, Token Ring, Frame Relay, LLC,
* SSCOP, LANE, and ILMI dissectors.
dissector_add_uint("wtap_encap", WTAP_ENCAP_ATM_PDUS_UNTRUNCATED,
atm_untruncated_handle);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_ATM_PDUS, capture_atm, proto_atm);
- register_capture_dissector("atm.aal5.type", TRAF_LANE, capture_lane, proto_atm_lane);
+
+ atm_cap_handle = create_capture_dissector_handle(capture_atm, proto_atm);
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_ATM_PDUS, atm_cap_handle);
+ atm_cap_handle = create_capture_dissector_handle(capture_lane, proto_atm_lane);
+ capture_dissector_add_uint("atm.aal5.type", TRAF_LANE, atm_cap_handle);
}
/*
#include <epan/capture_dissectors.h>
#include <epan/prefs.h>
#include <wiretap/wtap.h>
-#include "packet-ax25.h"
#define STRLEN 80
static dissector_handle_t kiss_handle;
+static capture_dissector_handle_t ax25_cap_handle;
+
/* Dissector handles - all the possibles are listed */
static dissector_handle_t ax25_handle;
switch ( kiss_cmd & KISS_CMD_MASK )
{
case KISS_DATA_FRAME :
- return capture_ax25( pd, l_offset, len, cpinfo, pseudo_header );
+ return call_capture_dissector( ax25_cap_handle, pd, l_offset, len, cpinfo, pseudo_header );
case KISS_TXDELAY : break;
case KISS_PERSISTENCE : break;
case KISS_SLOT_TIME : break;
case KISS_SETHARDWARE : break;
case KISS_DATA_FRAME_ACK:
l_offset += 2;
- return capture_ax25( pd, l_offset, len, cpinfo, pseudo_header );
+ return call_capture_dissector( ax25_cap_handle, pd, l_offset, len, cpinfo, pseudo_header );
case KISS_POLL_MODE : break;
case KISS_RETURN : break;
default : break;
void
proto_reg_handoff_ax25_kiss(void)
{
+ capture_dissector_handle_t ax25_kiss_cap_handle;
+
dissector_add_uint( "wtap_encap", WTAP_ENCAP_AX25_KISS, kiss_handle );
- register_capture_dissector("wtap_encap", WTAP_ENCAP_AX25_KISS, capture_ax25_kiss, proto_ax25_kiss);
+ ax25_kiss_cap_handle = create_capture_dissector_handle(capture_ax25_kiss, proto_ax25_kiss);
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_AX25_KISS, ax25_kiss_cap_handle);
/* only currently implemented for AX.25 */
ax25_handle = find_dissector_add_dependency( "ax25", proto_ax25_kiss );
+
+ ax25_cap_handle = find_capture_dissector("ax25");
}
/*
#include <epan/xdlc.h>
#include <epan/ax25_pids.h>
#include <epan/ipproto.h>
-#include "packet-ax25.h"
#define STRLEN 80
/* Dissector table */
static dissector_table_t ax25_dissector_table;
+static capture_dissector_handle_t ax25_cap_handle;
+
/* Initialize the protocol and registered fields */
static int proto_ax25 = -1;
static int hf_ax25_dst = -1;
/* Register dissector table for protocol IDs */
ax25_dissector_table = register_dissector_table("ax25.pid", "AX.25 protocol ID", proto_ax25, FT_UINT8, BASE_HEX);
register_capture_dissector_table("ax25.pid", "AX.25");
+
+ ax25_cap_handle = register_capture_dissector("ax25", capture_ax25, proto_ax25);
}
void
dissector_add_uint("wtap_encap", WTAP_ENCAP_AX25, ax25_handle);
dissector_add_uint("ip.proto", IP_PROTO_AX25, ax25_handle);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_AX25, capture_ax25, proto_ax25);
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_AX25, ax25_cap_handle);
}
/*
+++ /dev/null
-/* packet-ax25.h
- *
- * Routines for Amateur Packet Radio protocol dissection
- * Copyright 2005,2006,2007,2008,2009,2010,2012 R.W. Stearn <richard@rns-stearn.demon.co.uk>
- *
- * Wireshark - Network traffic analyzer
- * By Gerald Combs <gerald@wireshark,org>
- * Copyright 1998 Gerald Combs
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- */
-
-#ifndef __PACKET_AX25_H__
-#define __PACKET_AX25_H__
-
-extern
-gboolean capture_ax25(const guchar *, int, int, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header);
-
-#endif
#include <epan/etypes.h>
#include <epan/capture_dissectors.h>
-#include "packet-ax25.h"
-
#define STRLEN 80
#define BPQ_HEADER_SIZE 2 /* length of bpq_len */
static dissector_handle_t bpq_handle;
static dissector_handle_t ax25_handle;
+static capture_dissector_handle_t ax25_cap_handle;
+
static int proto_bpq = -1;
static int hf_bpq_len = -1;
l_offset = offset;
l_offset += BPQ_HEADER_SIZE; /* step over bpq header to point at the AX.25 packet*/
- return capture_ax25( pd, l_offset, len, cpinfo, pseudo_header );
+ return call_capture_dissector( ax25_cap_handle, pd, l_offset, len, cpinfo, pseudo_header );
}
void
void
proto_reg_handoff_bpq(void)
{
+ capture_dissector_handle_t bpq_cap_handle;
+
dissector_add_uint("ethertype", ETHERTYPE_BPQ, bpq_handle);
- register_capture_dissector("ethertype", ETHERTYPE_BPQ, capture_bpq, proto_bpq);
+ bpq_cap_handle = create_capture_dissector_handle(capture_bpq, proto_bpq);
+ capture_dissector_add_uint("ethertype", ETHERTYPE_BPQ, bpq_cap_handle);
/* BPQ is only implemented for AX.25 */
ax25_handle = find_dissector_add_dependency( "ax25", proto_bpq );
+ ax25_cap_handle = find_capture_dissector( "ax25" );
}
/*
static dissector_table_t subdissector_table;
+static capture_dissector_handle_t ip_cap_handle;
+
static const value_string chdlc_address_vals[] = {
{CHDLC_ADDR_UNICAST, "Unicast"},
{CHDLC_ADDR_MULTICAST, "Multicast"},
switch (pntoh16(&pd[offset + 2])) {
case ETHERTYPE_IP:
- return capture_ip(pd, offset + 4, len, cpinfo, pseudo_header);
+ return call_capture_dissector(ip_cap_handle, pd, offset + 4, len, cpinfo, pseudo_header);
}
return FALSE;
&chdlc_fcs_decode,
fcs_options, ENC_BIG_ENDIAN);
+ register_capture_dissector("chdlc", capture_chdlc, proto_chdlc);
+
}
void
proto_reg_handoff_chdlc(void)
{
dissector_handle_t chdlc_handle;
+ capture_dissector_handle_t chdlc_cap_handle;
chdlc_handle = find_dissector("chdlc");
dissector_add_uint("wtap_encap", WTAP_ENCAP_CHDLC, chdlc_handle);
dissector_add_uint("juniper.proto", JUNIPER_PROTO_CHDLC, chdlc_handle);
dissector_add_uint("l2tp.pw_type", L2TPv3_PROTOCOL_CHDLC, chdlc_handle);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_CHDLC, capture_chdlc, proto_chdlc);
+ chdlc_cap_handle = find_capture_dissector("chdlc");
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_CHDLC, chdlc_cap_handle);
+
+ ip_cap_handle = find_capture_dissector("ip");
}
#define CHDLC_ADDR_UNICAST 0x0f
#define CHDLC_ADDR_MULTICAST 0x8f
-extern
-gboolean capture_chdlc(const guchar *, int, int, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header);
-
extern const value_string chdlc_vals[];
void
#include "config.h"
#include <epan/packet.h>
-#include <epan/capture_dissectors.h>
#include <epan/expert.h>
#include <wiretap/wtap.h>
clip_handle = create_dissector_handle(dissect_clip, proto_clip);
/* XXX - no protocol, can't be disabled */
dissector_add_uint("wtap_encap", WTAP_ENCAP_LINUX_ATM_CLIP, clip_handle);
-
- register_capture_dissector("wtap_encap", WTAP_ENCAP_LINUX_ATM_CLIP, capture_ip, proto_clip);
}
/*
proto_reg_handoff_enc(void)
{
dissector_handle_t enc_handle;
+ capture_dissector_handle_t enc_cap_handle;
enc_handle = create_dissector_handle(dissect_enc, proto_enc);
dissector_add_uint("wtap_encap", WTAP_ENCAP_ENC, enc_handle);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_ENC, capture_enc, proto_enc);
+ enc_cap_handle = create_capture_dissector_handle(capture_enc, proto_enc);
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_ENC, enc_cap_handle);
}
/*
static dissector_handle_t fw1_handle;
static dissector_handle_t ethertype_handle;
+static capture_dissector_handle_t isl_cap_handle;
+static capture_dissector_handle_t ipx_cap_handle;
+static capture_dissector_handle_t llc_cap_handle;
static heur_dissector_list_t heur_subdissector_list;
static heur_dissector_list_t eth_trailer_subdissector_list;
if ((pd[offset] == 0x01 || pd[offset] == 0x0C) && pd[offset+1] == 0x00
&& pd[offset+2] == 0x0C && pd[offset+3] == 0x00
&& pd[offset+4] == 0x00) {
- return capture_isl(pd, offset, len, cpinfo, pseudo_header);
+ return call_capture_dissector(isl_cap_handle, pd, offset, len, cpinfo, pseudo_header);
}
}
switch (ethhdr_type) {
case ETHERNET_802_3:
- return capture_ipx(pd, offset, len, cpinfo, pseudo_header);
+ return call_capture_dissector(ipx_cap_handle, pd, offset, len, cpinfo, pseudo_header);
case ETHERNET_802_2:
- return capture_llc(pd, offset, len, cpinfo, pseudo_header);
+ return call_capture_dissector(llc_cap_handle, pd, offset, len, cpinfo, pseudo_header);
case ETHERNET_II:
return try_capture_dissector("ethertype", etype, pd, offset, len, cpinfo, pseudo_header);
}
register_conversation_table(proto_eth, TRUE, eth_conversation_packet, eth_hostlist_packet);
register_conversation_filter("eth", "Ethernet", eth_filter_valid, eth_build_filter);
+
+ register_capture_dissector("eth", capture_eth, proto_eth);
}
void
proto_reg_handoff_eth(void)
{
dissector_handle_t eth_handle, eth_withoutfcs_handle, eth_maybefcs_handle;
+ capture_dissector_handle_t eth_cap_handle;
/* Get a handle for the Firewall-1 dissector. */
fw1_handle = find_dissector_add_dependency("fw1", proto_eth);
dissector_add_for_decode_as("pcli.payload", eth_withoutfcs_handle);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_ETHERNET, capture_eth, proto_eth);
- register_capture_dissector("atm_lane", TRAF_ST_LANE_802_3, capture_eth, proto_eth);
- register_capture_dissector("atm_lane", TRAF_ST_LANE_802_3_MC, capture_eth, proto_eth);
- register_capture_dissector("ppi", 1 /* DLT_EN10MB */, capture_eth, proto_eth);
- register_capture_dissector("sll.ltype", LINUX_SLL_P_ETHERNET, capture_eth, proto_eth);
+ eth_cap_handle = find_capture_dissector("eth");
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_ETHERNET, eth_cap_handle);
+ capture_dissector_add_uint("atm_lane", TRAF_ST_LANE_802_3, eth_cap_handle);
+ capture_dissector_add_uint("atm_lane", TRAF_ST_LANE_802_3_MC, eth_cap_handle);
+ capture_dissector_add_uint("ppi", 1 /* DLT_EN10MB */, eth_cap_handle);
+ capture_dissector_add_uint("sll.ltype", LINUX_SLL_P_ETHERNET, eth_cap_handle);
+
+ isl_cap_handle = find_capture_dissector("isl");
+ ipx_cap_handle = find_capture_dissector("ipx");
+ llc_cap_handle = find_capture_dissector("llc");
}
/*
guint16 type;
} eth_hdr;
-extern
-gboolean capture_eth(const guchar *, int, int, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header);
-
void add_ethernet_trailer(packet_info *pinfo, proto_tree *tree, proto_tree *fh_tree,
int trailer_id, tvbuff_t *tvb, tvbuff_t *trailer_tvb,
int fcs_len);
static dissector_handle_t fddi_handle, fddi_bitswapped_handle;
+static capture_dissector_handle_t llc_cap_handle;
+
static gboolean fddi_padding = FALSE;
#define FDDI_PADDING ((fddi_padding) ? 3 : 0)
case FDDI_FC_LLC_ASYNC + 13 :
case FDDI_FC_LLC_ASYNC + 14 :
case FDDI_FC_LLC_ASYNC + 15 :
- return capture_llc(pd, offset, len, cpinfo, pseudo_header);
+ return call_capture_dissector(llc_cap_handle, pd, offset, len, cpinfo, pseudo_header);
} /* fc */
return FALSE;
void
proto_reg_handoff_fddi(void)
{
+ capture_dissector_handle_t fddi_cap_handle;
+
/*
* Get a handle for the LLC dissector.
*/
dissector_add_uint("wtap_encap", WTAP_ENCAP_FDDI_BITSWAPPED,
fddi_bitswapped_handle);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_FDDI, capture_fddi, proto_fddi);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_FDDI_BITSWAPPED, capture_fddi, proto_fddi);
+ fddi_cap_handle = create_capture_dissector_handle(capture_fddi, proto_fddi);
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_FDDI, fddi_cap_handle);
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_FDDI_BITSWAPPED, fddi_cap_handle);
+
+ llc_cap_handle = find_capture_dissector("llc");
}
/*
static dissector_handle_t gprs_ns_handle;
static dissector_handle_t data_handle;
+static capture_dissector_handle_t chdlc_cap_handle;
+static capture_dissector_handle_t eth_cap_handle;
+
static dissector_table_t osinl_incl_subdissector_table;
/*
fr_nlpid = pd[offset];
}
offset++;
- switch (fr_nlpid) {
-
- case NLPID_IP:
- return capture_ip(pd, offset, len, cpinfo, pseudo_header);
-
- case NLPID_IP6:
- return capture_ipv6(pd, offset, len, cpinfo, pseudo_header);
-
- case NLPID_PPP:
- return capture_ppp_hdlc(pd, offset, len, cpinfo, pseudo_header);
-
- case NLPID_SNAP:
- return capture_snap(pd, offset, len, cpinfo, pseudo_header);
-
- default:
- return FALSE;
- }
+ return try_capture_dissector("fr.nlpid", fr_nlpid, pd, offset, len, cpinfo, pseudo_header);
} else {
if (addr == 0) {
/*
* If the data does not start with unnumbered information (03) and
* the DLCI# is not 0, then there may be Cisco Frame Relay encapsulation.
*/
- return capture_chdlc(pd, offset, len, cpinfo, pseudo_header);
+ return call_capture_dissector(chdlc_cap_handle, pd, offset, len, cpinfo, pseudo_header);
}
break;
case RAW_ETHER:
if (addr != 0)
- return capture_eth(pd, offset, len, cpinfo, pseudo_header);
+ return call_capture_dissector(eth_cap_handle, pd, offset, len, cpinfo, pseudo_header);
return FALSE;
}
prefs_register_enum_preference(frencap_module, "encap", "Encapsulation",
"Encapsulation", &fr_encap,
fr_encap_options, FALSE);
+
+ register_capture_dissector_table("fr.nlpid", "Frame Relay NLPID");
}
void
proto_reg_handoff_fr(void)
{
dissector_handle_t fr_handle, fr_phdr_handle;
+ capture_dissector_handle_t fr_cap_handle;
fr_handle = find_dissector("fr");
dissector_add_uint("gre.proto", ETHERTYPE_RAW_FR, fr_handle);
fr_phdr_handle = create_dissector_handle(dissect_fr_phdr, proto_fr);
dissector_add_uint("wtap_encap", WTAP_ENCAP_FRELAY_WITH_PHDR, fr_phdr_handle);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_FRELAY, capture_fr, proto_fr);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_FRELAY_WITH_PHDR, capture_fr, proto_fr);
+ fr_cap_handle = create_capture_dissector_handle(capture_fr, proto_fr);
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_FRELAY, fr_cap_handle);
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_FRELAY_WITH_PHDR, fr_cap_handle);
eth_withfcs_handle = find_dissector_add_dependency("eth_withfcs", proto_fr);
gprs_ns_handle = find_dissector_add_dependency("gprs_ns", proto_fr);
data_handle = find_dissector_add_dependency("data", proto_fr);
osinl_incl_subdissector_table = find_dissector_table("osinl.incl");
+
+ chdlc_cap_handle = find_capture_dissector("chdlc");
+ eth_cap_handle = find_capture_dissector("eth");
}
/*
proto_reg_handoff_gre(void)
{
dissector_handle_t gre_handle;
+ capture_dissector_handle_t gre_cap_handle;
gre_handle = create_dissector_handle(dissect_gre, proto_gre);
dissector_add_uint("ip.proto", IP_PROTO_GRE, gre_handle);
- register_capture_dissector("ip.proto", IP_PROTO_GRE, capture_gre, proto_gre);
+ gre_cap_handle = create_capture_dissector_handle(capture_gre, proto_gre);
+ capture_dissector_add_uint("ip.proto", IP_PROTO_GRE, gre_cap_handle);
}
/*
proto_reg_handoff_i2c(void)
{
dissector_handle_t i2c_handle;
+ capture_dissector_handle_t i2c_cap_handle;
i2c_handle = create_dissector_handle(dissect_i2c, proto_i2c);
dissector_add_uint("wtap_encap", WTAP_ENCAP_I2C, i2c_handle);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_I2C, capture_i2c, proto_i2c);
+ i2c_cap_handle = create_capture_dissector_handle(capture_i2c, proto_i2c);
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_I2C, i2c_cap_handle);
}
/*
void proto_reg_handoff_icmp(void)
{
dissector_handle_t icmp_handle;
+ capture_dissector_handle_t icmp_cap_handle;
/*
* Get handle for the IP dissector.
icmp_handle = find_dissector("icmp");
dissector_add_uint("ip.proto", IP_PROTO_ICMP, icmp_handle);
- register_capture_dissector("ip.proto", IP_PROTO_ICMP, capture_icmp, proto_icmp);
+ icmp_cap_handle = create_capture_dissector_handle(capture_icmp, proto_icmp);
+ capture_dissector_add_uint("ip.proto", IP_PROTO_ICMP, icmp_cap_handle);
}
/*
void
proto_reg_handoff_icmpv6(void)
{
+ capture_dissector_handle_t icmpv6_cap_handle;
+
dissector_add_uint("ip.proto", IP_PROTO_ICMPV6, icmpv6_handle);
- register_capture_dissector("ip.proto", IP_PROTO_ICMPV6, capture_icmpv6, proto_icmpv6);
+ icmpv6_cap_handle = create_capture_dissector_handle(capture_icmpv6, proto_icmpv6);
+ capture_dissector_add_uint("ip.proto", IP_PROTO_ICMPV6, icmpv6_cap_handle);
/*
* Get a handle for the IPv6 dissector.
static dissector_handle_t ieee80211_handle;
static dissector_handle_t ieee80211_radio_handle;
+static capture_dissector_handle_t ieee80211_cap_handle;
+static capture_dissector_handle_t wlancap_cap_handle;
+
static int proto_prism = -1;
/* Prism radio header */
cookie = pntoh32(pd);
if ((cookie == WLANCAP_MAGIC_COOKIE_V1) ||
(cookie == WLANCAP_MAGIC_COOKIE_V2)) {
- return capture_wlancap(pd, offset, len, cpinfo, pseudo_header);
+ return call_capture_dissector(wlancap_cap_handle, pd, offset, len, cpinfo, pseudo_header);
}
/* Prism header */
offset += PRISM_HEADER_LENGTH;
/* 802.11 header follows */
- return capture_ieee80211(pd, offset, len, cpinfo, pseudo_header);
+ return call_capture_dissector(ieee80211_cap_handle, pd, offset, len, cpinfo, pseudo_header);
}
static int
void proto_reg_handoff_ieee80211_prism(void)
{
+ capture_dissector_handle_t ieee80211_prism_cap_handle;
+
dissector_add_uint("wtap_encap", WTAP_ENCAP_IEEE_802_11_PRISM, prism_handle);
ieee80211_handle = find_dissector_add_dependency("wlan", proto_prism);
ieee80211_radio_handle = find_dissector_add_dependency("wlan_radio", proto_prism);
wlancap_handle = find_dissector_add_dependency("wlancap", proto_prism);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_IEEE_802_11_PRISM, capture_prism, proto_prism);
+ ieee80211_prism_cap_handle = create_capture_dissector_handle(capture_prism, proto_prism);
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_IEEE_802_11_PRISM, ieee80211_prism_cap_handle);
+
+ ieee80211_cap_handle = find_capture_dissector("ieee80211");
+ wlancap_cap_handle = find_capture_dissector("wlancap");
}
/*
static dissector_handle_t ieee80211_radio_handle;
+static capture_dissector_handle_t ieee80211_cap_handle;
+static capture_dissector_handle_t ieee80211_datapad_cap_handle;
+
static int radiotap_tap = -1;
/* Settings */
/* 802.11 header follows */
if (rflags & IEEE80211_RADIOTAP_F_DATAPAD)
- return capture_ieee80211_datapad(pd, offset + it_len, len, cpinfo, pseudo_header);
+ return call_capture_dissector(ieee80211_datapad_cap_handle, pd, offset + it_len, len, cpinfo, pseudo_header);
- return capture_ieee80211(pd, offset + it_len, len, cpinfo, pseudo_header);
+ return call_capture_dissector(ieee80211_cap_handle, pd, offset + it_len, len, cpinfo, pseudo_header);
}
static int
void proto_reg_handoff_radiotap(void)
{
dissector_handle_t radiotap_handle;
+ capture_dissector_handle_t radiotap_cap_handle;
/* handle for 802.11+radio information dissector */
ieee80211_radio_handle = find_dissector_add_dependency("wlan_radio", proto_radiotap);
dissector_add_uint("wtap_encap", WTAP_ENCAP_IEEE_802_11_RADIOTAP,
radiotap_handle);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_IEEE_802_11_RADIOTAP, capture_radiotap, proto_radiotap);
+ radiotap_cap_handle = create_capture_dissector_handle(capture_radiotap, proto_radiotap);
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_IEEE_802_11_RADIOTAP, radiotap_cap_handle);
+
+ ieee80211_cap_handle = find_capture_dissector("ieee80211");
+ ieee80211_datapad_cap_handle = find_capture_dissector("ieee80211_datapad");
}
/*
static gint ett_wlancap = -1;
static dissector_handle_t wlancap_handle;
+static capture_dissector_handle_t wlancap_cap_handle;
+static capture_dissector_handle_t ieee80211_cap_handle;
gboolean
capture_wlancap(const guchar *pd, int offset, int len, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header _U_)
offset += length;
/* 802.11 header follows */
- return capture_ieee80211(pd, offset, len, cpinfo, pseudo_header);
+ return call_capture_dissector(ieee80211_cap_handle, pd, offset, len, cpinfo, pseudo_header);
}
/*
dissector_add_uint("wtap_encap", WTAP_ENCAP_IEEE_802_11_AVS,
wlancap_handle);
proto_register_subtree_array(tree_array, array_length(tree_array));
+
+ wlancap_cap_handle = register_capture_dissector("wlancap", capture_wlancap, proto_wlancap);
}
void proto_reg_handoff_ieee80211_wlancap(void)
{
ieee80211_radio_handle = find_dissector_add_dependency("wlan_radio", proto_wlancap);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_IEEE_802_11_AVS, capture_wlancap, proto_wlancap);
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_IEEE_802_11_AVS, wlancap_cap_handle);
+
+ ieee80211_cap_handle = find_capture_dissector("ieee80211");
}
/*
static dissector_handle_t ipx_handle;
static dissector_handle_t eth_withoutfcs_handle;
+static capture_dissector_handle_t llc_cap_handle;
+static capture_dissector_handle_t ipx_cap_handle;
+
static int wlan_tap = -1;
static const value_string access_network_type_vals[] = {
}
#endif
if ((pd[offset+hdr_length] == 0xff) && (pd[offset+hdr_length+1] == 0xff))
- return capture_ipx (pd, offset+hdr_length, len, cpinfo, pseudo_header);
+ return call_capture_dissector (ipx_cap_handle, pd, offset+hdr_length, len, cpinfo, pseudo_header);
else if ((pd[offset+hdr_length] == 0x00) && (pd[offset+hdr_length+1] == 0x00))
- return capture_llc (pd, offset + hdr_length + 2, len, cpinfo, pseudo_header);
+ return call_capture_dissector (llc_cap_handle, pd, offset + hdr_length + 2, len, cpinfo, pseudo_header);
}
else {
- return capture_llc (pd, offset + hdr_length, len, cpinfo, pseudo_header);
+ return call_capture_dissector (llc_cap_handle, pd, offset + hdr_length, len, cpinfo, pseudo_header);
}
break;
}
register_dissector("wlan_bsfc", dissect_ieee80211_bsfc, proto_wlan);
register_dissector("wlan_noqos", dissect_ieee80211_noqos, proto_wlan);
+ register_capture_dissector("ieee80211", capture_ieee80211, proto_wlan);
+ register_capture_dissector("ieee80211_datapad", capture_ieee80211_datapad, proto_wlan);
+
register_init_routine(wlan_defragment_init);
register_cleanup_routine(wlan_defragment_cleanup);
register_init_routine(wlan_retransmit_init);
{
dissector_handle_t data_encap_handle, centrino_handle;
dissector_handle_t wlan_rsna_eapol_wpa_key_handle, wlan_rsna_eapol_rsn_key_handle, wlan_withoutfcs_handle;
+ capture_dissector_handle_t ieee80211_cap_handle;
/*
* Get handles for the LLC, IPX and Ethernet dissectors.
ipx_handle = find_dissector_add_dependency("ipx", proto_wlan);
eth_withoutfcs_handle = find_dissector_add_dependency("eth_withoutfcs", proto_wlan);
+ llc_cap_handle = find_capture_dissector("llc");
+ ipx_cap_handle = find_capture_dissector("ipx");
+
ieee80211_handle = find_dissector("wlan");
dissector_add_uint("wtap_encap", WTAP_ENCAP_IEEE_802_11, ieee80211_handle);
centrino_handle = create_dissector_handle( dissect_ieee80211_centrino, proto_centrino );
dissector_add_uint("ethertype", ETHERTYPE_CENTRINO_PROMISC, centrino_handle);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_IEEE_802_11, capture_ieee80211, proto_wlan);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_IEEE_802_11_WITH_RADIO, capture_ieee80211, proto_wlan);
- register_capture_dissector("ppi", 105 /* DLT_DLT_IEEE802_11 */, capture_ieee80211, proto_wlan);
+ ieee80211_cap_handle = find_capture_dissector("ieee80211");
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_IEEE_802_11, ieee80211_cap_handle);
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_IEEE_802_11_WITH_RADIO, ieee80211_cap_handle);
+ capture_dissector_add_uint("ppi", 105 /* DLT_DLT_IEEE802_11 */, ieee80211_cap_handle);
/* Register handoff to Aruba GRE */
dissector_add_uint("gre.proto", GRE_ARUBA_8200, ieee80211_handle);
extern "C" {
#endif /* __cplusplus */
-extern
-gboolean capture_ieee80211 (const guchar *, int, int, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header);
-gboolean capture_ieee80211_datapad (const guchar *, int, int, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header);
-
-extern
-gboolean capture_wlancap(const guchar *, int, int, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header);
-
void dissect_wifi_p2p_ie(packet_info *pinfo, proto_tree *tree, tvbuff_t *tvb,
int offset, gint size);
int dissect_wifi_p2p_public_action(packet_info *pinfo, proto_tree *tree,
static dissector_handle_t ethertype_handle;
+static capture_dissector_handle_t ipx_cap_handle;
+static capture_dissector_handle_t llc_cap_handle;
+
void dissect_ieee8021ah_common(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, proto_tree *parent, int tree_index);
if (encap_proto <= IEEE_802_3_MAX_LEN) {
if ( pd[offset + IEEE8021AH_LEN] == 0xff
&& pd[offset + IEEE8021AH_LEN + 1] == 0xff ) {
- return capture_ipx(pd, offset + IEEE8021AH_LEN, len, cpinfo, pseudo_header);
+ return call_capture_dissector(ipx_cap_handle, pd, offset + IEEE8021AH_LEN, len, cpinfo, pseudo_header);
}
else {
- return capture_llc(pd, offset + IEEE8021AH_LEN, len, cpinfo, pseudo_header);
+ return call_capture_dissector(llc_cap_handle, pd, offset + IEEE8021AH_LEN, len, cpinfo, pseudo_header);
}
}
static gboolean prefs_initialized = FALSE;
static dissector_handle_t ieee8021ah_handle;
static unsigned int old_ieee8021ah_ethertype;
+ static capture_dissector_handle_t ieee8021ah_cap_handle;
if (!prefs_initialized){
dissector_handle_t ieee8021ad_handle;
dissector_add_uint("ethertype", ETHERTYPE_IEEE_802_1AD, ieee8021ad_handle);
ethertype_handle = find_dissector_add_dependency("ethertype", proto_ieee8021ah);
find_dissector_add_dependency("ethertype", proto_ieee8021ad);
- register_capture_dissector("ethertype", ETHERTYPE_IEEE_802_1AD, capture_ieee8021ah, proto_ieee8021ah);
- register_capture_dissector("ethertype", ETHERTYPE_IEEE_802_1AH, capture_ieee8021ah, proto_ieee8021ah);
+ ieee8021ah_cap_handle = create_capture_dissector_handle(capture_ieee8021ah, proto_ieee8021ah);
+ capture_dissector_add_uint("ethertype", ETHERTYPE_IEEE_802_1AD, ieee8021ah_cap_handle);
+ capture_dissector_add_uint("ethertype", ETHERTYPE_IEEE_802_1AH, ieee8021ah_cap_handle);
prefs_initialized = TRUE;
}
old_ieee8021ah_ethertype = ieee8021ah_ethertype;
dissector_add_uint("ethertype", ieee8021ah_ethertype, ieee8021ah_handle);
+
+ ipx_cap_handle = find_capture_dissector("ipx");
+ llc_cap_handle = find_capture_dissector("llc");
}
/*
static dissector_table_t ip_dissector_table;
static dissector_handle_t ipv6_handle;
+static capture_dissector_handle_t ip_cap_handle;
/* IP structs and definitions */
register_decode_as(&ip_da);
register_conversation_table(proto_ip, TRUE, ip_conversation_packet, ip_hostlist_packet);
register_conversation_filter("ip", "IPv4", ip_filter_valid, ip_build_filter);
+
+ ip_cap_handle = register_capture_dissector("ip", capture_ip, proto_ip);
}
void
{
dissector_handle_t ip_handle;
dissector_handle_t ipv4_handle;
+ capture_dissector_handle_t clip_cap_handle;
+ int proto_clip;
ip_handle = find_dissector("ip");
ipv6_handle = find_dissector("ipv6");
dissector_add_uint("vxlan.next_proto", VXLAN_IPV4, ip_handle);
heur_dissector_add("tipc", dissect_ip_heur, "IP over TIPC", "ip_tipc", proto_ip, HEURISTIC_ENABLE);
- register_capture_dissector("ethertype", ETHERTYPE_IP, capture_ip, proto_ip);
- register_capture_dissector("ax25.pid", AX25_P_IP, capture_ip, proto_ip);
- register_capture_dissector("enc", BSD_AF_INET, capture_ip, proto_ip);
- register_capture_dissector("ppp_hdlc", PPP_IP, capture_ip, proto_ip);
- register_capture_dissector("llc.dsap", SAP_IP, capture_ip, proto_ip);
+
+ capture_dissector_add_uint("ethertype", ETHERTYPE_IP, ip_cap_handle);
+ capture_dissector_add_uint("ax25.pid", AX25_P_IP, ip_cap_handle);
+ capture_dissector_add_uint("enc", BSD_AF_INET, ip_cap_handle);
+ capture_dissector_add_uint("ppp_hdlc", PPP_IP, ip_cap_handle);
+ capture_dissector_add_uint("llc.dsap", SAP_IP, ip_cap_handle);
+ capture_dissector_add_uint("null.bsd", BSD_AF_INET, ip_cap_handle);
+ capture_dissector_add_uint("fr.nlpid", NLPID_IP, ip_cap_handle);
+
+ /* Classic IP uses the same capture function, but wants its own
+ protocol associated with it. To eliminate linking dependencies,
+ just add it here */
+ proto_clip = proto_get_id_by_filter_name( "clip" );
+ clip_cap_handle = register_capture_dissector("clip", capture_ip, proto_clip);
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_LINUX_ATM_CLIP, clip_cap_handle);
}
/*
#define IPDSFIELD_ECN_MASK 0x03
#define IPDSFIELD_ECN(dsfield) ((dsfield) & IPDSFIELD_ECN_MASK)
-gboolean capture_ip(const guchar *, int, int, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header);
-
gboolean ip_try_dissect(gboolean heur_first, guint nxt, tvbuff_t *tvb,
packet_info *pinfo, proto_tree *tree, ws_ip *iph);
/* Initialize the subtree pointers */
static gint ett_ipfc = -1;
static dissector_handle_t llc_handle;
+static capture_dissector_handle_t llc_cap_handle;
static gboolean
capture_ipfc (const guchar *pd, int offset _U_, int len, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header _U_)
if (!BYTES_ARE_IN_FRAME(0, len, 16))
return FALSE;
- return capture_llc(pd, 16, len, cpinfo, pseudo_header);
+ return call_capture_dissector(llc_cap_handle, pd, 16, len, cpinfo, pseudo_header);
}
static int
proto_reg_handoff_ipfc (void)
{
dissector_handle_t ipfc_handle;
+ capture_dissector_handle_t ipfc_cap_handle;
ipfc_handle = create_dissector_handle (dissect_ipfc, proto_ipfc);
dissector_add_uint("wtap_encap", WTAP_ENCAP_IP_OVER_FC, ipfc_handle);
llc_handle = find_dissector_add_dependency("llc", proto_ipfc);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_IP_OVER_FC, capture_ipfc, proto_ipfc);
+ ipfc_cap_handle = create_capture_dissector_handle(capture_ipfc, proto_ipfc);
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_IP_OVER_FC, ipfc_cap_handle);
+
+ llc_cap_handle = find_capture_dissector("llc");
}
/*
#include <epan/exported_pdu.h>
#include <epan/proto_data.h>
#include <epan/decode_as.h>
+#include <epan/capture_dissectors.h>
/* If you want to be able to decrypt or Check Authentication of ESP packets you MUST define this : */
#ifdef HAVE_LIBGCRYPT
proto_reg_handoff_ipsec(void)
{
dissector_handle_t esp_handle, ah_handle, ipcomp_handle;
+ capture_dissector_handle_t ah_cap_handle;
data_handle = find_dissector("data");
ah_handle = find_dissector("ah");
dissector_add_uint("ip.proto", IP_PROTO_IPCOMP, ipcomp_handle);
ip_dissector_table = find_dissector_table("ip.proto");
- register_capture_dissector("ip.proto", IP_PROTO_AH, capture_ah, proto_ah);
+
+ ah_cap_handle = create_capture_dissector_handle(capture_ah, proto_ah);
+ capture_dissector_add_uint("ip.proto", IP_PROTO_AH, ah_cap_handle);
exported_pdu_tap = find_tap_id(EXPORT_PDU_TAP_NAME_LAYER_3);
}
register_conversation_table(proto_ipv6, TRUE, ipv6_conversation_packet, ipv6_hostlist_packet);
register_conversation_filter("ipv6", "IPv6", ipv6_filter_valid, ipv6_build_filter);
+
+ register_capture_dissector("ipv6", capture_ipv6, proto_ipv6);
}
void
dissector_handle_t ipv6_routing_handle;
dissector_handle_t ipv6_fraghdr_handle;
dissector_handle_t ipv6_dstopts_handle;
+ capture_dissector_handle_t ipv6_cap_handle;
+ capture_dissector_handle_t ipv6_ext_cap_handle;
ipv6_handle = find_dissector("ipv6");
dissector_add_uint("ethertype", ETHERTYPE_IPv6, ipv6_handle);
dissector_add_uint("ip.proto", IP_PROTO_DSTOPTS, ipv6_dstopts_handle);
ip_dissector_table = find_dissector_table("ip.proto");
- register_capture_dissector("ethertype", ETHERTYPE_IPv6, capture_ipv6, proto_ipv6);
- register_capture_dissector("enc", BSD_AF_INET6_BSD, capture_ipv6, proto_ipv6);
- register_capture_dissector("ip.proto", IP_PROTO_HOPOPTS, capture_ipv6_exthdr, proto_ipv6_hopopts);
- register_capture_dissector("ip.proto", IP_PROTO_ROUTING, capture_ipv6_exthdr, proto_ipv6_routing);
- register_capture_dissector("ip.proto", IP_PROTO_FRAGMENT, capture_ipv6_exthdr, proto_ipv6_fraghdr);
- register_capture_dissector("ip.proto", IP_PROTO_DSTOPTS, capture_ipv6_exthdr, proto_ipv6_dstopts);
+
+ ipv6_cap_handle = find_capture_dissector("ipv6");
+ capture_dissector_add_uint("ethertype", ETHERTYPE_IPv6, ipv6_cap_handle);
+ capture_dissector_add_uint("enc", BSD_AF_INET6_BSD, ipv6_cap_handle);
+ capture_dissector_add_uint("null.bsd", BSD_AF_INET6_BSD, ipv6_cap_handle);
+ capture_dissector_add_uint("null.bsd", BSD_AF_INET6_FREEBSD, ipv6_cap_handle);
+ capture_dissector_add_uint("null.bsd", BSD_AF_INET6_DARWIN, ipv6_cap_handle);
+ capture_dissector_add_uint("fr.nlpid", NLPID_IP6, ipv6_cap_handle);
+
+ ipv6_ext_cap_handle = create_capture_dissector_handle(capture_ipv6_exthdr, proto_ipv6_hopopts);
+ capture_dissector_add_uint("ip.proto", IP_PROTO_HOPOPTS, ipv6_ext_cap_handle);
+ ipv6_ext_cap_handle = create_capture_dissector_handle(capture_ipv6_exthdr, proto_ipv6_routing);
+ capture_dissector_add_uint("ip.proto", IP_PROTO_ROUTING, ipv6_ext_cap_handle);
+ ipv6_ext_cap_handle = create_capture_dissector_handle(capture_ipv6_exthdr, proto_ipv6_fraghdr);
+ capture_dissector_add_uint("ip.proto", IP_PROTO_FRAGMENT, ipv6_ext_cap_handle);
+ ipv6_ext_cap_handle = create_capture_dissector_handle(capture_ipv6_exthdr, proto_ipv6_dstopts);
+ capture_dissector_add_uint("ip.proto", IP_PROTO_DSTOPTS, ipv6_ext_cap_handle);
}
/*
#define __PACKET_IPV6_H_DEFINED__
#include <epan/ipv6.h>
-#include <epan/capture_dissectors.h>
#include "packet-ip.h"
#ifdef __cplusplus
ipv6_pinfo_t *p_get_ipv6_pinfo(packet_info *pinfo);
-gboolean capture_ipv6(const guchar *, int, int, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header);
-
-gboolean capture_ipv6_exthdr(const guchar *, int, int, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header);
-
void ipv6_dissect_next(guint nxt, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, ws_ip *iph);
#ifdef __cplusplus
ipx_tap=register_tap("ipx");
register_conversation_table(proto_ipx, TRUE, ipx_conversation_packet, ipx_hostlist_packet);
+
+ register_capture_dissector("ipx", capture_ipx, proto_ipx);
}
void
dissector_handle_t ipx_handle, spx_handle;
dissector_handle_t ipxsap_handle, ipxrip_handle;
dissector_handle_t serialization_handle, ipxmsg_handle;
+ capture_dissector_handle_t ipx_cap_handle;
ipx_handle = find_dissector("ipx");
dissector_add_uint_with_preference("udp.port", UDP_PORT_IPX, ipx_handle);
dissector_add_uint("ipx.socket", IPX_SOCKET_IPX_MESSAGE, ipxmsg_handle);
dissector_add_uint("ipx.socket", IPX_SOCKET_IPX_MESSAGE1, ipxmsg_handle);
- register_capture_dissector("ethertype", ETHERTYPE_IPX, capture_ipx, proto_ipx);
- register_capture_dissector("ppp_hdlc", PPP_IPX, capture_ipx, proto_ipx);
- register_capture_dissector("sll.ltype", LINUX_SLL_P_802_3, capture_ipx, proto_ipx);
- register_capture_dissector("llc.dsap", SAP_NETWARE1, capture_ipx, proto_ipx);
- register_capture_dissector("llc.dsap", SAP_NETWARE2, capture_ipx, proto_ipx);
+ ipx_cap_handle = find_capture_dissector("ipx");
+ capture_dissector_add_uint("ethertype", ETHERTYPE_IPX, ipx_cap_handle);
+ capture_dissector_add_uint("ppp_hdlc", PPP_IPX, ipx_cap_handle);
+ capture_dissector_add_uint("sll.ltype", LINUX_SLL_P_802_3, ipx_cap_handle);
+ capture_dissector_add_uint("llc.dsap", SAP_NETWARE1, ipx_cap_handle);
+ capture_dissector_add_uint("llc.dsap", SAP_NETWARE2, ipx_cap_handle);
}
/*
extern value_string_ext ipx_socket_vals_ext;
extern value_string_ext novell_server_vals_ext;
-gboolean capture_ipx(const guchar *pd, int offset, int len, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header);
-
/*
* Structure passed to SPX subdissectors, containing information from
* the SPX header that might be useful to the subdissector.
#include <epan/packet.h>
#include <epan/exceptions.h>
#include <epan/show_exception.h>
+#include <epan/capture_dissectors.h>
#include "packet-isl.h"
#include "packet-eth.h"
static dissector_handle_t eth_withfcs_handle;
static dissector_handle_t tr_handle;
+static capture_dissector_handle_t eth_cap_handle;
+static capture_dissector_handle_t tr_cap_handle;
+
gboolean
capture_isl(const guchar *pd, int offset, int len, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header _U_)
{
case TYPE_ETHER:
offset += 14+12; /* skip the header */
- return capture_eth(pd, offset, len, cpinfo, pseudo_header);
+ return call_capture_dissector(eth_cap_handle, pd, offset, len, cpinfo, pseudo_header);
case TYPE_TR:
offset += 14+17; /* skip the header */
- return capture_tr(pd, offset, len, cpinfo, pseudo_header);
+ return call_capture_dissector(tr_cap_handle, pd, offset, len, cpinfo, pseudo_header);
break;
}
proto_isl = proto_register_protocol("Cisco ISL", "ISL", "isl");
proto_register_field_array(proto_isl, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
+
+ register_capture_dissector("isl", capture_isl, proto_isl);
}
void
*/
eth_withfcs_handle = find_dissector_add_dependency("eth_withfcs", proto_isl);
tr_handle = find_dissector_add_dependency("tr", proto_isl);
+
+ eth_cap_handle = find_capture_dissector("eth");
+ tr_cap_handle = find_capture_dissector("tr");
}
/*
#ifndef __PACKET_ISL_H__
#define __PACKET_ISL_H__
-gboolean capture_isl(const guchar *, int, int, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header);
-
void dissect_isl(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
int fcs_len);
#include <epan/bridged_pids.h>
#include <epan/ppptypes.h>
#include <epan/arcnet_pids.h>
+#include <epan/nlpid.h>
#include "packet-fc.h"
#include "packet-ip.h"
#include "packet-ipx.h"
g_hash_table_insert(oui_info_table, GUINT_TO_POINTER(oui), new_info);
}
-gboolean
-capture_llc(const guchar *pd, int offset, int len, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header _U_) {
-
- int is_snap;
- guint16 control;
- int llc_header_len;
-
- if (!BYTES_ARE_IN_FRAME(offset, len, 2))
- return FALSE;
-
- is_snap = (pd[offset] == SAP_SNAP) && (pd[offset+1] == SAP_SNAP);
- llc_header_len = 2; /* DSAP + SSAP */
-
- /*
- * XXX - the page referred to in the comment above about the
- * Command/Response bit also implies that LLC Type 2 always
- * uses extended operation, so we don't need to determine
- * whether it's basic or extended operation; is that the case?
- */
- control = get_xdlc_control(pd, offset+2, pd[offset+1] & SSAP_CR_BIT);
- llc_header_len += XDLC_CONTROL_LEN(control, TRUE);
- if (!BYTES_ARE_IN_FRAME(offset, len, llc_header_len))
- return FALSE;
-
- if (!XDLC_IS_INFORMATION(control))
- return FALSE;
-
- if (is_snap)
- return capture_snap(pd, offset+llc_header_len, len, cpinfo, pseudo_header);
-
- /* non-SNAP */
- return try_capture_dissector("llc.dsap", pd[offset], pd, offset + llc_header_len, len, cpinfo, pseudo_header);
-}
-
gboolean
capture_snap(const guchar *pd, int offset, int len, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header _U_)
{
return FALSE;
}
+gboolean
+capture_llc(const guchar *pd, int offset, int len, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header _U_) {
+
+ int is_snap;
+ guint16 control;
+ int llc_header_len;
+
+ if (!BYTES_ARE_IN_FRAME(offset, len, 2))
+ return FALSE;
+
+ is_snap = (pd[offset] == SAP_SNAP) && (pd[offset+1] == SAP_SNAP);
+ llc_header_len = 2; /* DSAP + SSAP */
+
+ /*
+ * XXX - the page referred to in the comment above about the
+ * Command/Response bit also implies that LLC Type 2 always
+ * uses extended operation, so we don't need to determine
+ * whether it's basic or extended operation; is that the case?
+ */
+ control = get_xdlc_control(pd, offset+2, pd[offset+1] & SSAP_CR_BIT);
+ llc_header_len += XDLC_CONTROL_LEN(control, TRUE);
+ if (!BYTES_ARE_IN_FRAME(offset, len, llc_header_len))
+ return FALSE;
+
+ if (!XDLC_IS_INFORMATION(control))
+ return FALSE;
+
+ if (is_snap)
+ return capture_snap(pd, offset+llc_header_len, len, cpinfo, pseudo_header);
+
+ /* non-SNAP */
+ return try_capture_dissector("llc.dsap", pd[offset], pd, offset + llc_header_len, len, cpinfo, pseudo_header);
+}
+
/* Used only for U frames */
static const xdlc_cf_items llc_cf_items = {
NULL,
register_capture_dissector_table("llc.dsap", "LLC");
register_dissector("llc", dissect_llc, proto_llc);
+
+ register_capture_dissector("llc", capture_llc, proto_llc);
}
void
proto_reg_handoff_llc(void)
{
dissector_handle_t llc_handle;
+ capture_dissector_handle_t llc_cap_handle;
+ capture_dissector_handle_t llc_snap_handle;
/*
* Get handles for the BPDU, Ethernet, FDDI, Token Ring and
dissector_add_uint("juniper.proto", JUNIPER_PROTO_LLC, llc_handle);
dissector_add_uint("juniper.proto", JUNIPER_PROTO_LLC_SNAP, llc_handle);
- register_capture_dissector("ethertype", ETHERTYPE_JUMBO_LLC, capture_llc, proto_llc);
- register_capture_dissector("atm.aal5.type", TRAF_LLCMX, capture_llc, proto_llc);
- register_capture_dissector("sll.ltype", LINUX_SLL_P_802_2, capture_llc, proto_llc);
+ llc_cap_handle = find_capture_dissector("llc");
+ capture_dissector_add_uint("ethertype", ETHERTYPE_JUMBO_LLC, llc_cap_handle);
+ capture_dissector_add_uint("atm.aal5.type", TRAF_LLCMX, llc_cap_handle);
+ capture_dissector_add_uint("sll.ltype", LINUX_SLL_P_802_2, llc_cap_handle);
+
+ llc_snap_handle = register_capture_dissector("llc_snap", capture_snap, proto_llc);
+ capture_dissector_add_uint("fr.nlpid", NLPID_SNAP, llc_snap_handle);
+
/*
* Register all the fields for PIDs for various OUIs.
#include "ws_symbol_export.h"
-gboolean capture_llc(const guchar *, int, int, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header);
-
extern const value_string sap_vals[];
-gboolean capture_snap(const guchar *, int, int, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header);
-
void dissect_snap(tvbuff_t *, int, packet_info *, proto_tree *,
proto_tree *, int, int, int, int, int);
proto_reg_handoff_netbios(void)
{
dissector_handle_t netbios_handle;
+ capture_dissector_handle_t netbios_cap_handle;
- netbios_handle = create_dissector_handle(dissect_netbios,
- proto_netbios);
+ netbios_handle = create_dissector_handle(dissect_netbios, proto_netbios);
dissector_add_uint("llc.dsap", SAP_NETBIOS, netbios_handle);
- register_capture_dissector("llc.dsap", SAP_NETBIOS, capture_netbios, proto_netbios);
+ netbios_cap_handle = create_capture_dissector_handle(capture_netbios, proto_netbios);
+ capture_dissector_add_uint("llc.dsap", SAP_NETBIOS, netbios_cap_handle);
}
void
proto_reg_handoff_netrom(void)
{
+ capture_dissector_handle_t netrom_cap_handle;
+
dissector_add_uint( "ax25.pid", AX25_P_NETROM, create_dissector_handle( dissect_netrom, proto_netrom ) );
- register_capture_dissector("ax25.pid", AX25_P_NETROM, capture_netrom, proto_netrom);
+ netrom_cap_handle = create_capture_dissector_handle(capture_netrom, proto_netrom);
+ capture_dissector_add_uint("ax25.pid", AX25_P_NETROM, netrom_cap_handle);
ip_handle = find_dissector_add_dependency( "ip", proto_netrom );
}
};
static dissector_handle_t ppp_hdlc_handle;
+static capture_dissector_handle_t ppp_hdlc_cap_handle;
static gboolean
capture_null( const guchar *pd, int offset _U_, int len, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header _U_ )
/*
* Hand it to PPP.
*/
- return capture_ppp_hdlc(pd, 0, len, cpinfo, pseudo_header);
+ return call_capture_dissector(ppp_hdlc_cap_handle, pd, 0, len, cpinfo, pseudo_header);
} else {
/*
* Treat it as a normal DLT_NULL header.
*/
if (null_header > IEEE_802_3_MAX_LEN)
return try_capture_dissector("ethertype", null_header, pd, 4, len, cpinfo, pseudo_header);
- else {
-
- switch (null_header) {
-
- case BSD_AF_INET:
- return capture_ip(pd, 4, len, cpinfo, pseudo_header);
-
- case BSD_AF_INET6_BSD:
- case BSD_AF_INET6_FREEBSD:
- case BSD_AF_INET6_DARWIN:
- return capture_ipv6(pd, 4, len, cpinfo, pseudo_header);
- }
- }
- }
-
- return FALSE;
-}
-
-static gboolean
-capture_loop( const guchar *pd, int offset _U_, int len, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header _U_ )
-{
- guint32 loop_family;
-
- if (!BYTES_ARE_IN_FRAME(0, len, (int)sizeof(loop_family)))
- return FALSE;
-
- loop_family = pntoh32(&pd[0]);
-
- switch (loop_family) {
-
- case BSD_AF_INET:
- return capture_ip(pd, 4, len, cpinfo, pseudo_header);
-
- case BSD_AF_INET6_BSD:
- case BSD_AF_INET6_FREEBSD:
- case BSD_AF_INET6_DARWIN:
- return capture_ipv6(pd, 4, len, cpinfo, pseudo_header);
+ else
+ return try_capture_dissector("null.bsd", null_header, pd, 4, len, cpinfo, pseudo_header);
}
return FALSE;
/* subdissector code */
null_dissector_table = register_dissector_table("null.type",
"Null type", proto_null, FT_UINT32, BASE_DEC);
+
+ register_capture_dissector_table("null.bsd", "Null/Loopback BSD AF");
}
void
proto_reg_handoff_null(void)
{
dissector_handle_t null_handle, loop_handle;
+ capture_dissector_handle_t null_cap_handle;
/*
* Get a handle for the PPP-in-HDLC-like-framing dissector and
loop_handle = create_dissector_handle(dissect_loop, proto_null);
dissector_add_uint("wtap_encap", WTAP_ENCAP_LOOP, loop_handle);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_NULL, capture_null, proto_null);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_LOOP, capture_loop, proto_null);
+ null_cap_handle = create_capture_dissector_handle(capture_null, proto_null);
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_NULL, null_cap_handle);
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_LOOP, null_cap_handle);
+
+ ppp_hdlc_cap_handle = find_capture_dissector("ppp_hdlc");
}
/*
proto_reg_handoff_ospf(void)
{
dissector_handle_t ospf_handle;
+ capture_dissector_handle_t ospf_cap_handle;
ospf_handle = create_dissector_handle(dissect_ospf, proto_ospf);
dissector_add_uint("ip.proto", IP_PROTO_OSPF, ospf_handle);
- register_capture_dissector("ip.proto", IP_PROTO_OSPF, capture_ospf, proto_ospf);
+ ospf_cap_handle = create_capture_dissector_handle(capture_ospf, proto_ospf);
+ capture_dissector_add_uint("ip.proto", IP_PROTO_OSPF, ospf_cap_handle);
}
/*
static expert_field ei_pktap_hdrlen_too_short = EI_INIT;
static dissector_handle_t pktap_handle;
+static capture_dissector_handle_t eth_cap_handle;
/*
* XXX - these are little-endian in the captures I've seen, but Apple
switch (dlt) {
case 1: /* DLT_EN10MB */
- return capture_eth(pd, hdrlen, len, cpinfo, pseudo_header);
+ return call_capture_dissector(eth_cap_handle, pd, hdrlen, len, cpinfo, pseudo_header);
}
void
proto_reg_handoff_pktap(void)
{
+ capture_dissector_handle_t pktap_cap_handle;
+
dissector_add_uint("wtap_encap", WTAP_ENCAP_PKTAP, pktap_handle);
pcap_pktdata_handle = find_dissector_add_dependency("pcap_pktdata", proto_pktap);
uses DLT_USER2 for PKTAP; if you are using DLT_USER2 for your
own purposes, feel free to call your own capture_ routine for
WTAP_ENCAP_USER2. */
- register_capture_dissector("wtap_encap", WTAP_ENCAP_PKTAP, capture_pktap, proto_pktap);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_USER2, capture_pktap, proto_pktap);
+ pktap_cap_handle = create_capture_dissector_handle(capture_pktap, proto_pktap);
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_PKTAP, pktap_cap_handle);
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_USER2, pktap_cap_handle);
+
+ eth_cap_handle = find_capture_dissector("eth");
}
/*
void
proto_reg_handoff_ppi(void)
{
+ capture_dissector_handle_t ppi_cap_handle;
+
ieee80211_radio_handle = find_dissector_add_dependency("wlan_radio", proto_ppi);
pcap_pktdata_handle = find_dissector_add_dependency("pcap_pktdata", proto_ppi);
ppi_gps_handle = find_dissector_add_dependency("ppi_gps", proto_ppi);
ppi_fnet_handle = find_dissector_add_dependency("ppi_fnet", proto_ppi);
dissector_add_uint("wtap_encap", WTAP_ENCAP_PPI, ppi_handle);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_PPI, capture_ppi, proto_ppi);
+ ppi_cap_handle = create_capture_dissector_handle(capture_ppi, proto_ppi);
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_PPI, ppi_cap_handle);
}
/*
static dissector_handle_t eth_withfcs_handle;
static dissector_handle_t eth_withoutfcs_handle;
+static capture_dissector_handle_t chdlc_cap_handle;
+
static const value_string ppp_direction_vals[] = {
{P2P_DIR_RECV, "DCE->DTE"},
{P2P_DIR_SENT, "DTE->DCE"},
return FALSE;
if (pd[0] == CHDLC_ADDR_UNICAST || pd[0] == CHDLC_ADDR_MULTICAST)
- return capture_chdlc(pd, offset, len, cpinfo, pseudo_header);
+ return call_capture_dissector(chdlc_cap_handle, pd, offset, len, cpinfo, pseudo_header);
if (!BYTES_ARE_IN_FRAME(offset, len, 4))
return FALSE;
proto_register_field_array(proto_ppp_hdlc, hf, array_length(hf));
register_capture_dissector_table("ppp_hdlc", "PPP-HDLC");
+ register_capture_dissector("ppp_hdlc", capture_ppp_hdlc, proto_ppp_hdlc);
}
void
proto_reg_handoff_ppp_raw_hdlc(void)
{
dissector_handle_t ppp_raw_hdlc_handle;
+ capture_dissector_handle_t ppp_hdlc_cap_handle;
ppp_raw_hdlc_handle = create_dissector_handle(dissect_ppp_raw_hdlc, proto_ppp);
dissector_add_uint("gre.proto", ETHERTYPE_3GPP2, ppp_raw_hdlc_handle);
heur_dissector_add("usb.bulk", dissect_ppp_usb, "PPP USB bulk endpoint", "ppp_usb_bulk", proto_ppp, HEURISTIC_ENABLE);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_PPP, capture_ppp_hdlc, proto_ppp_hdlc);
- register_capture_dissector("sll.ltype", LINUX_SLL_P_PPPHDLC, capture_ppp_hdlc, proto_ppp_hdlc);
+
+ ppp_hdlc_cap_handle = find_capture_dissector("ppp_hdlc");
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_PPP, ppp_hdlc_cap_handle);
+ capture_dissector_add_uint("sll.ltype", LINUX_SLL_P_PPPHDLC, ppp_hdlc_cap_handle);
+ capture_dissector_add_uint("fr.nlpid", NLPID_PPP, ppp_hdlc_cap_handle);
+
+ chdlc_cap_handle = find_capture_dissector("chdlc");
}
/*
#include <epan/params.h>
#include "ws_symbol_export.h"
-extern
-gboolean capture_ppp_hdlc(const guchar *, int, int, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header _U_);
-
tvbuff_t *decode_fcs(tvbuff_t *tvb, packet_info *pinfo, proto_tree *fh_tree, int fcs_decode, int proto_offset);
/*
static dissector_handle_t ipv6_handle;
static dissector_handle_t ppp_hdlc_handle;
+static capture_dissector_handle_t ip_cap_handle;
+static capture_dissector_handle_t ipv6_cap_handle;
+static capture_dissector_handle_t ppp_hdlc_cap_handle;
+
static gboolean
capture_raw(const guchar *pd, int offset _U_, int len, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header _U_)
{
* sometimes. This check should be removed when 2.2 is out.
*/
if (BYTES_ARE_IN_FRAME(0,len,2) && pd[0] == 0xff && pd[1] == 0x03) {
- return capture_ppp_hdlc(pd, 0, len, cpinfo, pseudo_header);
+ return call_capture_dissector(ppp_hdlc_cap_handle, pd, 0, len, cpinfo, pseudo_header);
}
/* The Linux ISDN driver sends a fake MAC address before the PPP header
* on its ippp interfaces... */
else if (BYTES_ARE_IN_FRAME(0,len,8) && pd[6] == 0xff && pd[7] == 0x03) {
- return capture_ppp_hdlc(pd, 6, len, cpinfo, pseudo_header);
+ return call_capture_dissector(ppp_hdlc_cap_handle, pd, 6, len, cpinfo, pseudo_header);
}
/* ...except when it just puts out one byte before the PPP header... */
else if (BYTES_ARE_IN_FRAME(0,len,3) && pd[1] == 0xff && pd[2] == 0x03) {
- return capture_ppp_hdlc(pd, 1, len, cpinfo, pseudo_header);
+ return call_capture_dissector(ppp_hdlc_cap_handle, pd, 1, len, cpinfo, pseudo_header);
}
/* ...and if the connection is currently down, it sends 10 bytes of zeroes
* instead of a fake MAC address and PPP header. */
else if (BYTES_ARE_IN_FRAME(0,len,10) && memcmp(pd, zeroes, 10) == 0) {
- return capture_ip(pd, 10, len, cpinfo, pseudo_header);
+ return call_capture_dissector(ip_cap_handle, pd, 10, len, cpinfo, pseudo_header);
}
else {
/*
case 0x40:
/* IPv4 */
- return capture_ip(pd, 0, len, cpinfo, pseudo_header);
+ return call_capture_dissector(ip_cap_handle, pd, 0, len, cpinfo, pseudo_header);
#if 0
case 0x60:
/* IPv6 */
- return capture_ipv6(pd, 0, len, cpinfo, pseudo_header);
+ return call_capture_dissector(ipv6_cap_handle, pd, 0, len, cpinfo, pseudo_header);
#endif
}
}
void
proto_reg_handoff_raw(void)
{
+ capture_dissector_handle_t raw_cap_handle;
+
/*
* Get handles for the IP, IPv6, undissected-data, and
* PPP-in-HDLC-like-framing dissectors.
ipv6_handle = find_dissector_add_dependency("ipv6", proto_raw);
ppp_hdlc_handle = find_dissector_add_dependency("ppp_hdlc", proto_raw);
dissector_add_uint("wtap_encap", WTAP_ENCAP_RAW_IP, raw_handle);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_RAW_IP, capture_raw, proto_raw);
+ raw_cap_handle = create_capture_dissector_handle(capture_raw, proto_raw);
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_RAW_IP, raw_cap_handle);
+
+ ip_cap_handle = find_capture_dissector("ip");
+ ipv6_cap_handle = find_capture_dissector("ipv6");
+ ppp_hdlc_cap_handle = find_capture_dissector("ppp_hdlc");
}
/*
proto_reg_handoff_sctp(void)
{
dissector_handle_t sctp_handle;
+ capture_dissector_handle_t sctp_cap_handle;
sctp_handle = find_dissector("sctp");
dissector_add_uint("wtap_encap", WTAP_ENCAP_SCTP, sctp_handle);
dissector_add_uint("ip.proto", IP_PROTO_SCTP, sctp_handle);
dissector_add_uint_with_preference("udp.port", UDP_TUNNELING_PORT, sctp_handle);
- register_capture_dissector("ip.proto", IP_PROTO_SCTP, capture_sctp, proto_sctp);
+ sctp_cap_handle = create_capture_dissector_handle(capture_sctp, proto_sctp);
+ capture_dissector_add_uint("ip.proto", IP_PROTO_SCTP, sctp_cap_handle);
}
/*
shim6_handle = create_dissector_handle(dissect_shim6, proto_shim6);
dissector_add_uint("ip.proto", IP_PROTO_SHIM6, shim6_handle);
-
- register_capture_dissector("ip.proto", IP_PROTO_SHIM6, capture_ipv6_exthdr, proto_shim6);
}
/*
void
proto_reg_handoff_sll(void)
{
+ capture_dissector_handle_t sll_cap_handle;
+
/*
* Get handles for the IPX and LLC dissectors.
*/
netlink_handle = find_dissector_add_dependency("netlink", proto_sll);
dissector_add_uint("wtap_encap", WTAP_ENCAP_SLL, sll_handle);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_SLL, capture_sll, hfi_sll->id);
+ sll_cap_handle = create_capture_dissector_handle(capture_sll, proto_sll);
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_SLL, sll_cap_handle);
}
/*
proto_reg_handoff_tcp(void)
{
dissector_handle_t tcp_handle;
+ capture_dissector_handle_t tcp_cap_handle;
tcp_handle = find_dissector("tcp");
dissector_add_uint("ip.proto", IP_PROTO_TCP, tcp_handle);
tcp_tap = register_tap("tcp");
tcp_follow_tap = register_tap("tcp_follow");
- register_capture_dissector("ip.proto", IP_PROTO_TCP, capture_tcp, proto_tcp);
+ tcp_cap_handle = create_capture_dissector_handle(capture_tcp, proto_tcp);
+ capture_dissector_add_uint("ip.proto", IP_PROTO_TCP, tcp_cap_handle);
mptcp_tap = register_tap("mptcp");
exported_pdu_tap = find_tap_id(EXPORT_PDU_TAP_NAME_LAYER_4);
static dissector_handle_t trmac_handle;
static dissector_handle_t llc_handle;
+static capture_dissector_handle_t llc_cap_handle;
+
static const char* tr_conv_get_filter_type(conv_item_t* conv, conv_filter_type_e filter)
{
if ((filter == CONV_FT_SRC_ADDRESS) && (conv->src_address.type == AT_ETHER))
/* The package is either MAC (0) or LLC (1)*/
switch (frame_type) {
case 1:
- return capture_llc(pd, offset, len, cpinfo, pseudo_header);
+ return call_capture_dissector(llc_cap_handle, pd, offset, len, cpinfo, pseudo_header);
}
return FALSE;
tr_tap=register_tap("tr");
register_conversation_table(proto_tr, TRUE, tr_conversation_packet, tr_hostlist_packet);
+
+ register_capture_dissector("tr", capture_tr, proto_tr);
}
void
proto_reg_handoff_tr(void)
{
dissector_handle_t tr_handle;
+ capture_dissector_handle_t tr_cap_handle;
/*
* Get handles for the TR MAC and LLC dissectors.
dissector_add_uint("wtap_encap", WTAP_ENCAP_TOKEN_RING, tr_handle);
dissector_add_uint("sflow_245.header_protocol", SFLOW_245_HEADER_TOKENRING, tr_handle);
- register_capture_dissector("wtap_encap", WTAP_ENCAP_TOKEN_RING, capture_tr, proto_tr);
- register_capture_dissector("atm_lane", TRAF_ST_LANE_802_5, capture_tr, proto_tr);
- register_capture_dissector("atm_lane", TRAF_ST_LANE_802_5_MC, capture_tr, proto_tr);
+ tr_cap_handle = find_capture_dissector("tr");
+ capture_dissector_add_uint("wtap_encap", WTAP_ENCAP_TOKEN_RING, tr_cap_handle);
+ capture_dissector_add_uint("atm_lane", TRAF_ST_LANE_802_5, tr_cap_handle);
+ capture_dissector_add_uint("atm_lane", TRAF_ST_LANE_802_5_MC, tr_cap_handle);
+
+ llc_cap_handle = find_capture_dissector("llc");
}
/*
address src;
} tr_hdr;
-extern
-gboolean capture_tr(const guchar *, int, int, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header);
-
#endif
void
proto_reg_handoff_udp(void)
{
+ capture_dissector_handle_t udp_cap_handle;
+
dissector_add_uint("ip.proto", IP_PROTO_UDP, udp_handle);
dissector_add_uint("ip.proto", IP_PROTO_UDPLITE, udplite_handle);
- register_capture_dissector("ip.proto", IP_PROTO_UDP, capture_udp, hfi_udp->id);
- register_capture_dissector("ip.proto", IP_PROTO_UDPLITE, capture_udp, hfi_udplite->id);
+ udp_cap_handle = create_capture_dissector_handle(capture_udp, hfi_udp->id);
+ capture_dissector_add_uint("ip.proto", IP_PROTO_UDP, udp_cap_handle);
+ udp_cap_handle = create_capture_dissector_handle(capture_udp, hfi_udplite->id);
+ capture_dissector_add_uint("ip.proto", IP_PROTO_UDPLITE, udp_cap_handle);
udp_tap = register_tap("udp");
udp_follow_tap = register_tap("udp_follow");
proto_reg_handoff_vines_icp(void)
{
dissector_handle_t vines_icp_handle;
+ capture_dissector_handle_t vines_echo_cap_handle;
+ capture_dissector_handle_t vines_ip_cap_handle;
- vines_icp_handle = create_dissector_handle(dissect_vines_icp,
- proto_vines_icp);
+ vines_icp_handle = create_dissector_handle(dissect_vines_icp, proto_vines_icp);
dissector_add_uint("vines_ip.protocol", VIP_PROTO_ICP, vines_icp_handle);
- register_capture_dissector("ethertype", ETHERTYPE_VINES_IP, capture_vines, proto_vines_ip);
- register_capture_dissector("ethertype", ETHERTYPE_VINES_ECHO, capture_vines, proto_vines_echo);
- register_capture_dissector("ppp_hdlc", PPP_VINES, capture_vines, proto_vines_echo);
- register_capture_dissector("ip.proto", PPP_VINES, capture_vines, proto_vines_echo);
- register_capture_dissector("llc.dsap", SAP_VINES1, capture_vines, proto_vines_echo);
- register_capture_dissector("llc.dsap", SAP_VINES2, capture_vines, proto_vines_echo);
+
+ vines_ip_cap_handle = create_capture_dissector_handle(capture_vines, proto_vines_ip);
+ capture_dissector_add_uint("ethertype", ETHERTYPE_VINES_IP, vines_ip_cap_handle);
+ vines_echo_cap_handle = create_capture_dissector_handle(capture_vines, proto_vines_echo);
+ capture_dissector_add_uint("ethertype", ETHERTYPE_VINES_ECHO, vines_echo_cap_handle);
+ capture_dissector_add_uint("ppp_hdlc", PPP_VINES, vines_echo_cap_handle);
+ capture_dissector_add_uint("ip.proto", PPP_VINES, vines_echo_cap_handle);
+ capture_dissector_add_uint("llc.dsap", SAP_VINES1, vines_echo_cap_handle);
+ capture_dissector_add_uint("llc.dsap", SAP_VINES2, vines_echo_cap_handle);
}
/*
static dissector_handle_t vlan_handle;
static dissector_handle_t ethertype_handle;
+static capture_dissector_handle_t llc_cap_handle;
+static capture_dissector_handle_t ipx_cap_handle;
+
static header_field_info *hfi_vlan = NULL;
#define VLAN_HFI_INIT HFI_INIT(proto_vlan)
encap_proto = pntoh16( &pd[offset+2] );
if ( encap_proto <= IEEE_802_3_MAX_LEN) {
if ( pd[offset+4] == 0xff && pd[offset+5] == 0xff ) {
- return capture_ipx(pd,offset+4,len, cpinfo, pseudo_header);
+ return call_capture_dissector(ipx_cap_handle, pd,offset+4,len, cpinfo, pseudo_header);
} else {
- return capture_llc(pd,offset+4,len, cpinfo, pseudo_header);
+ return call_capture_dissector(llc_cap_handle, pd,offset+4,len, cpinfo, pseudo_header);
}
}
{
static gboolean prefs_initialized = FALSE;
static unsigned int old_q_in_q_ethertype;
+ capture_dissector_handle_t vlan_cap_handle;
if (!prefs_initialized)
{
dissector_add_uint("ethertype", ETHERTYPE_VLAN, vlan_handle);
- register_capture_dissector("ethertype", ETHERTYPE_VLAN, capture_vlan, hfi_vlan->id);
+ vlan_cap_handle = create_capture_dissector_handle(capture_vlan, hfi_vlan->id);
+ capture_dissector_add_uint("ethertype", ETHERTYPE_VLAN, vlan_cap_handle);
prefs_initialized = TRUE;
}
ethertype_handle = find_dissector_add_dependency("ethertype", hfi_vlan->id);
dissector_add_uint("ethertype", q_in_q_ethertype, vlan_handle);
+
+ llc_cap_handle = find_capture_dissector("llc");
+ ipx_cap_handle = find_capture_dissector("ipx");
}
/*
git.samba.org / metze / wireshark / wip.git / commitdiff