void proto_reg_handoff_pw_satop(void)
{
data_handle = find_dissector("data");
pw_padding_handle = find_dissector("pw_padding");
/* For Decode As */
dissector_add_for_decode_as("mpls.label", find_dissector("pw_satop_mpls"));
dissector_add_for_decode_as("udp.port", find_dissector("pw_satop_udp"));
}
void
proto_reg_handoff_adb(void)
{
adb_service_handle = find_dissector_add_dependency("adb_service", proto_adb);
dissector_add_for_decode_as_with_preference("tcp.port", adb_handle);
dissector_add_for_decode_as("usb.device", adb_handle);
dissector_add_for_decode_as("usb.product", adb_handle);
dissector_add_for_decode_as("usb.protocol", adb_handle);
proto_tcp = proto_get_id_by_filter_name("tcp");
proto_usb = proto_get_id_by_filter_name("usb");
}
void proto_reg_handoff_pw_satop(void)
{
dissector_handle_t pw_satop_mpls_handle;
data_handle = find_dissector("data");
pw_padding_handle = find_dissector("pw_padding");
/* For Decode As */
pw_satop_mpls_handle = create_dissector_handle( dissect_pw_satop_mpls, proto );
dissector_add_for_decode_as("mpls.label", pw_satop_mpls_handle);
dissector_add_for_decode_as("udp.port", find_dissector("pw_satop_udp"));
}
void
proto_reg_handoff_bthcrp(void)
{
data_handle = find_dissector("data");
dissector_add_string("bluetooth.uuid", "12", bthcrp_handle);
dissector_add_string("bluetooth.uuid", "14", bthcrp_handle);
dissector_add_string("bluetooth.uuid", "16", bthcrp_handle);
dissector_add_string("bluetooth.uuid", "1125", bthcrp_handle);
dissector_add_string("bluetooth.uuid", "1126", bthcrp_handle);
dissector_add_string("bluetooth.uuid", "1127", bthcrp_handle);
dissector_add_for_decode_as("btl2cap.psm", bthcrp_handle);
dissector_add_for_decode_as("btl2cap.cid", bthcrp_handle);
}
/*--- proto_reg_handoff_x2ap ---------------------------------------*/
void
proto_reg_handoff_x2ap(void)
{
dissector_handle_t x2ap_handle;
static gboolean Initialized=FALSE;
static guint SctpPort;
x2ap_handle = find_dissector("x2ap");
if (!Initialized) {
dissector_add_for_decode_as("sctp.port", x2ap_handle);
dissector_add_uint("sctp.ppi", X2AP_PAYLOAD_PROTOCOL_ID, x2ap_handle);
Initialized=TRUE;
#include "packet-x2ap-dis-tab.c"
} else {
if (SctpPort != 0) {
dissector_delete_uint("sctp.port", SctpPort, x2ap_handle);
}
}
SctpPort=gbl_x2apSctpPort;
if (SctpPort != 0) {
dissector_add_uint("sctp.port", SctpPort, x2ap_handle);
}
}
void
proto_reg_handoff_pgm(void)
{
static gboolean initialized = FALSE;
static dissector_handle_t pgm_handle;
static guint old_udp_encap_ucast_port;
static guint old_udp_encap_mcast_port;
if (! initialized) {
pgm_handle = create_dissector_handle(dissect_pgm, proto_pgm);
dissector_add_for_decode_as("udp.port", pgm_handle);
dissector_add_uint("ip.proto", IP_PROTO_PGM, pgm_handle);
data_handle = find_dissector("data");
initialized = TRUE;
} else {
if (old_udp_encap_ucast_port != 0) {
dissector_delete_uint("udp.port", old_udp_encap_ucast_port, pgm_handle);
}
if (old_udp_encap_mcast_port != 0) {
dissector_delete_uint("udp.port", old_udp_encap_mcast_port, pgm_handle);
}
}
if (udp_encap_ucast_port != 0) {
dissector_add_uint("udp.port", udp_encap_ucast_port, pgm_handle);
}
if (udp_encap_mcast_port != 0) {
dissector_add_uint("udp.port", udp_encap_mcast_port, pgm_handle);
}
old_udp_encap_ucast_port = udp_encap_ucast_port;
old_udp_encap_mcast_port = udp_encap_mcast_port;
}
void
proto_reg_handoff_eth(void)
{
dissector_handle_t eth_maybefcs_handle, eth_withoutfcs_handle;
/* Get a handle for the Firewall-1 dissector. */
fw1_handle = find_dissector("fw1");
/* Get a handle for the ethertype dissector. */
ethertype_handle = find_dissector("ethertype");
/* Get a handle for the generic data dissector. */
data_handle = find_dissector("data");
eth_maybefcs_handle = find_dissector("eth");
dissector_add_uint("wtap_encap", WTAP_ENCAP_ETHERNET, eth_maybefcs_handle);
eth_withoutfcs_handle = find_dissector("eth_withoutfcs");
dissector_add_uint("ethertype", ETHERTYPE_ETHBRIDGE, eth_withoutfcs_handle);
dissector_add_uint("chdlc.protocol", ETHERTYPE_ETHBRIDGE, eth_withoutfcs_handle);
dissector_add_uint("gre.proto", ETHERTYPE_ETHBRIDGE, eth_withoutfcs_handle);
dissector_add_uint("sll.ltype", LINUX_SLL_P_ETHERNET, eth_withoutfcs_handle);
/*
* This is to handle the output for the Cisco CMTS "cable intercept"
* command - it encapsulates Ethernet frames in UDP packets, but
* the UDP port is user-defined.
*/
dissector_add_for_decode_as("udp.port", eth_withoutfcs_handle);
}
void
proto_reg_handoff_lge_monitor(void)
{
static dissector_handle_t lge_monitor_handle;
static guint saved_udp_port;
static gboolean lge_monitor_prefs_initialized = FALSE;
if (!lge_monitor_prefs_initialized) {
lge_monitor_handle = create_dissector_handle(dissect_lge_monitor, proto_lge_monitor);
dissector_add_for_decode_as("udp.port", lge_monitor_handle);
mtp3_handle = find_dissector("mtp3");
m3ua_handle = find_dissector("m3ua");
sccp_handle = find_dissector("sccp");
sctp_handle = find_dissector("sctp");
lge_monitor_prefs_initialized = TRUE;
}
else {
if (saved_udp_port != 0) {
dissector_delete_uint("udp.port", saved_udp_port, lge_monitor_handle);
}
}
if (LGEMonitorUDPPort != 0) {
dissector_add_uint("udp.port", LGEMonitorUDPPort, lge_monitor_handle);
}
saved_udp_port = LGEMonitorUDPPort;
}
void
proto_reg_handoff_nasdaq_itch(void)
{
dissector_handle_t nasdaq_itch_handle;
nasdaq_itch_handle = create_dissector_handle( dissect_nasdaq_itch, proto_nasdaq_itch );
dissector_add_for_decode_as("moldudp64.payload", nasdaq_itch_handle );
}
void
proto_reg_handoff_zrtp(void)
{
dissector_handle_t zrtp_handle;
zrtp_handle = find_dissector("zrtp");
dissector_add_for_decode_as("udp.port", zrtp_handle);
}
void
proto_reg_handoff_vxlan(void)
{
dissector_handle_t vxlan_handle;
eth_handle = find_dissector("eth");
vxlan_handle = create_dissector_handle(dissect_vxlan, proto_vxlan);
dissector_add_uint("udp.port", UDP_PORT_VXLAN, vxlan_handle);
dissector_add_for_decode_as("udp.port", vxlan_handle);
}
void
proto_reg_handoff_usb_dfu(void)
{
dissector_handle_t usf_dfu_descriptor_handle;
usf_dfu_descriptor_handle = new_create_dissector_handle(dissect_usb_dfu_descriptor, proto_usb_dfu);
dissector_add_uint("usb.descriptor", IF_CLASS_APPLICATION_SPECIFIC, usf_dfu_descriptor_handle);
dissector_add_uint("usb.product", (0x1d50 << 16) | 0x1db5, usb_dfu_handle); /* IDBG in DFU mode */
dissector_add_uint("usb.product", (0x1d50 << 16) | 0x6001, usb_dfu_handle); /* Ubertooth Zero DFU */
dissector_add_uint("usb.product", (0x1d50 << 16) | 0x6003, usb_dfu_handle); /* Ubertooth One DFU */
dissector_add_uint("usb.product", (0x1d50 << 16) | 0x600f, usb_dfu_handle); /* Paparazzi Lisa/M (DFU) */
dissector_add_uint("usb.product", (0x1d50 << 16) | 0x6011, usb_dfu_handle); /* LeoLipo (DFU) */
dissector_add_uint("usb.product", (0x1d50 << 16) | 0x6017, usb_dfu_handle); /* Black Magic Debug Probe (DFU) */
dissector_add_uint("usb.product", (0x1d50 << 16) | 0x6044, usb_dfu_handle); /* Open Source USB CANBUS converter (DFU Mode) */
dissector_add_uint("usb.product", (0x1d50 << 16) | 0x6064, usb_dfu_handle); /* CPC FPGA (DFU) */
dissector_add_uint("usb.product", (0x1d50 << 16) | 0x6069, usb_dfu_handle); /* xser (DFU mode) */
dissector_add_uint("usb.product", (0x1d50 << 16) | 0x6082, usb_dfu_handle); /* Facecandy *USB DFU loader */
dissector_add_uint("usb.product", (0x1d50 << 16) | 0x6084, usb_dfu_handle); /* arcin arcade controller (USB DFU loader) */
dissector_add_for_decode_as("usb.device", usb_dfu_handle);
dissector_add_for_decode_as("usb.protocol", usb_dfu_handle);
}
void
proto_reg_handoff_osi(void)
{
static gboolean osi_prefs_initialized = FALSE;
static dissector_handle_t osi_tpkt_handle, osi_juniper_handle;
static guint tcp_port_osi_over_tpkt;
if (!osi_prefs_initialized) {
osi_handle = create_dissector_handle(dissect_osi, proto_osi);
dissector_add_uint("llc.dsap", SAP_OSINL1, osi_handle);
dissector_add_uint("llc.dsap", SAP_OSINL2, osi_handle);
dissector_add_uint("llc.dsap", SAP_OSINL3, osi_handle);
dissector_add_uint("llc.dsap", SAP_OSINL4, osi_handle);
dissector_add_uint("llc.dsap", SAP_OSINL5, osi_handle);
dissector_add_uint("ppp.protocol", PPP_OSI, osi_handle);
dissector_add_uint("chdlc.protocol", CHDLCTYPE_OSI, osi_handle);
dissector_add_uint("null.type", BSD_AF_ISO, osi_handle);
dissector_add_uint("gre.proto", SAP_OSINL5, osi_handle);
dissector_add_uint("ip.proto", IP_PROTO_ISOIP, osi_handle); /* ISO network layer PDUs [RFC 1070] */
osi_juniper_handle = create_dissector_handle(dissect_osi_juniper, proto_osi);
dissector_add_uint("juniper.proto", JUNIPER_PROTO_ISO, osi_juniper_handle);
dissector_add_uint("juniper.proto", JUNIPER_PROTO_CLNP, osi_juniper_handle);
dissector_add_uint("juniper.proto", JUNIPER_PROTO_MPLS_CLNP, osi_juniper_handle);
data_handle = find_dissector("data");
ppp_handle = find_dissector("ppp");
osi_tpkt_handle = create_dissector_handle(dissect_osi_tpkt, proto_osi);
dissector_add_for_decode_as("tcp.port", osi_tpkt_handle);
osi_prefs_initialized = TRUE;
} else {
if (tcp_port_osi_over_tpkt != 0) {
dissector_delete_uint("tcp.port", tcp_port_osi_over_tpkt, osi_tpkt_handle);
}
}
if (global_tcp_port_osi_over_tpkt != 0) {
dissector_add_uint("tcp.port", global_tcp_port_osi_over_tpkt, osi_tpkt_handle);
}
tcp_port_osi_over_tpkt = global_tcp_port_osi_over_tpkt;
}
void
proto_reg_handoff_newmail(void)
{
static gboolean inited = FALSE;
static dissector_handle_t newmail_handle;
static guint preference_default_port_last;
if(!inited) {
newmail_handle = find_dissector("newmail");
dissector_add_for_decode_as("udp.port", newmail_handle);
inited = TRUE;
} else {
if (preference_default_port_last != 0) {
dissector_delete_uint("udp.port", preference_default_port_last, newmail_handle);
}
}
if(preference_default_port != 0) {
dissector_add_uint("udp.port", preference_default_port, newmail_handle);
}
preference_default_port_last = preference_default_port;
}
void proto_reg_handoff_netdump(void)
{
static gboolean initalized = FALSE;
static dissector_handle_t netdump_handle;
static int CurrentPort;
if (!initalized) {
netdump_handle = create_dissector_handle(dissect_netdump,
proto_netdump);
dissector_add_for_decode_as("udp.port", netdump_handle);
initalized = TRUE;
} else {
if (CurrentPort != 0)
dissector_delete_uint("udp.port", CurrentPort, netdump_handle);
}
CurrentPort = gPORT_PREF;
if (CurrentPort != 0)
dissector_add_uint("udp.port", CurrentPort, netdump_handle);
}
void
proto_reg_handoff_cwids(void)
{
static dissector_handle_t cwids_handle;
static guint saved_udp_port;
static gboolean initialized = FALSE;
if (!initialized) {
cwids_handle = create_dissector_handle(dissect_cwids, proto_cwids);
dissector_add_for_decode_as("udp.port", cwids_handle);
ieee80211_radio_handle = find_dissector("wlan_radio");
initialized = TRUE;
} else {
if (saved_udp_port != 0) {
dissector_delete_uint("udp.port", saved_udp_port, cwids_handle);
}
}
if (global_udp_port != 0) {
dissector_add_uint("udp.port", global_udp_port, cwids_handle);
}
saved_udp_port = global_udp_port;
}
void proto_reg_handoff_nwmtp(void)
{
dissector_add_for_decode_as("udp.port", nwmtp_handle);
mtp_handle = find_dissector("mtp3");
}
