void
proto_reg_handoff_btobex(void)
{
dissector_handle_t btobex_handle;
btobex_handle = find_dissector("btobex");
/* register in rfcomm and l2cap the profiles/services this dissector should handle */
dissector_add_uint("btrfcomm.service", BTSDP_OPP_SERVICE_UUID, btobex_handle);
dissector_add_uint("btrfcomm.service", BTSDP_FTP_SERVICE_UUID, btobex_handle);
dissector_add_uint("btrfcomm.service", BTSDP_BPP_DIRECT_PRINTING_SERVICE_UUID, btobex_handle);
dissector_add_uint("btrfcomm.service", BTSDP_BPP_REFERENCE_PRINTING_SERVICE_UUID, btobex_handle);
dissector_add_uint("btrfcomm.service", BTSDP_BPP_DIRECT_PRINTING_REF_OBJ_SERVICE_UUID, btobex_handle);
dissector_add_uint("btrfcomm.service", BTSDP_BPP_REFLECTED_UI_SERVICE_UUID, btobex_handle);
dissector_add_uint("btrfcomm.service", BTSDP_BPP_SERVICE_UUID, btobex_handle);
dissector_add_uint("btrfcomm.service", BTSDP_BPP_STATUS_SERVICE_UUID, btobex_handle);
dissector_add_uint("btrfcomm.service", BTSDP_BIP_SERVICE_UUID, btobex_handle);
dissector_add_uint("btrfcomm.service", BTSDP_BIP_RESPONDER_SERVICE_UUID, btobex_handle);
dissector_add_uint("btrfcomm.service", BTSDP_BIP_AUTO_ARCH_SERVICE_UUID, btobex_handle);
dissector_add_uint("btrfcomm.service", BTSDP_BIP_REF_OBJ_SERVICE_UUID, btobex_handle);
dissector_add_uint("btrfcomm.service", BTSDP_PBAP_PCE_SERVICE_UUID, btobex_handle);
dissector_add_uint("btrfcomm.service", BTSDP_PBAP_PSE_SERVICE_UUID, btobex_handle);
dissector_add_uint("btrfcomm.service", BTSDP_PBAP_SERVICE_UUID, btobex_handle);
dissector_add_uint("btrfcomm.service", BTSDP_MAP_SERVICE_UUID, btobex_handle);
dissector_add_uint("btrfcomm.service", BTSDP_MAP_ACCESS_SRV_SERVICE_UUID, btobex_handle);
dissector_add_uint("btrfcomm.service", BTSDP_MAP_NOTIFICATION_SRV_SERVICE_UUID, btobex_handle);
dissector_add_uint("btrfcomm.service", BTSDP_SYNC_SERVICE_UUID, btobex_handle);
dissector_add_uint("btrfcomm.service", BTSDP_SYNC_COMMAND_SERVICE_UUID, btobex_handle);
dissector_add_uint("btl2cap.service", BTSDP_OPP_SERVICE_UUID, btobex_handle);
dissector_add_uint("btl2cap.service", BTSDP_FTP_SERVICE_UUID, btobex_handle);
dissector_add_uint("btl2cap.service", BTSDP_BPP_DIRECT_PRINTING_SERVICE_UUID, btobex_handle);
dissector_add_uint("btl2cap.service", BTSDP_BPP_REFERENCE_PRINTING_SERVICE_UUID, btobex_handle);
dissector_add_uint("btl2cap.service", BTSDP_BPP_DIRECT_PRINTING_REF_OBJ_SERVICE_UUID, btobex_handle);
dissector_add_uint("btl2cap.service", BTSDP_BPP_REFLECTED_UI_SERVICE_UUID, btobex_handle);
dissector_add_uint("btl2cap.service", BTSDP_BPP_SERVICE_UUID, btobex_handle);
dissector_add_uint("btl2cap.service", BTSDP_BPP_STATUS_SERVICE_UUID, btobex_handle);
dissector_add_uint("btl2cap.service", BTSDP_BIP_SERVICE_UUID, btobex_handle);
dissector_add_uint("btl2cap.service", BTSDP_BIP_RESPONDER_SERVICE_UUID, btobex_handle);
dissector_add_uint("btl2cap.service", BTSDP_BIP_AUTO_ARCH_SERVICE_UUID, btobex_handle);
dissector_add_uint("btl2cap.service", BTSDP_BIP_REF_OBJ_SERVICE_UUID, btobex_handle);
dissector_add_uint("btl2cap.service", BTSDP_PBAP_PCE_SERVICE_UUID, btobex_handle);
dissector_add_uint("btl2cap.service", BTSDP_PBAP_PSE_SERVICE_UUID, btobex_handle);
dissector_add_uint("btl2cap.service", BTSDP_PBAP_SERVICE_UUID, btobex_handle);
dissector_add_uint("btl2cap.service", BTSDP_MAP_SERVICE_UUID, btobex_handle);
dissector_add_uint("btl2cap.service", BTSDP_MAP_ACCESS_SRV_SERVICE_UUID, btobex_handle);
dissector_add_uint("btl2cap.service", BTSDP_MAP_NOTIFICATION_SRV_SERVICE_UUID, btobex_handle);
dissector_add_uint("btl2cap.service", BTSDP_SYNC_SERVICE_UUID, btobex_handle);
dissector_add_uint("btl2cap.service", BTSDP_SYNC_COMMAND_SERVICE_UUID, btobex_handle);
xml_handle = find_dissector("xml");
data_handle = find_dissector("data");
dissector_add_handle("btrfcomm.channel", btobex_handle);
dissector_add_handle("btl2cap.psm", btobex_handle);
dissector_add_handle("btl2cap.cid", btobex_handle);
}
void
proto_reg_handoff_adb(void)
{
adb_service_handle = find_dissector("adb_service");
dissector_add_handle("tcp.port", adb_handle);
dissector_add_handle("usb.device", adb_handle);
dissector_add_handle("usb.product", adb_handle);
dissector_add_handle("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_alc(void)
{
static dissector_handle_t handle;
static gboolean preferences_initialized = FALSE;
static struct _alc_prefs preferences_old;
if (!preferences_initialized)
{
preferences_initialized = TRUE;
handle = create_dissector_handle(dissect_alc, proto);
dissector_add_handle("udp.port", handle);
xml_handle = find_dissector("xml");
} else {
if (preferences_old.use_default_udp_port)
dissector_delete_uint("udp.port", preferences_old.default_udp_port, handle);
}
if (preferences.use_default_udp_port)
dissector_add_uint("udp.port", preferences.default_udp_port, handle);
alc_prefs_save(&preferences, &preferences_old);
}
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_handle("udp.port", pgm_handle); /* for 'decode-as' */
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_pw_satop(void)
{
data_handle = find_dissector("data");
pw_padding_handle = find_dissector("pw_padding");
dissector_add("mpls.label", LABEL_INVALID, find_dissector("pw_satop_mpls"));
dissector_add_handle("udp.port", find_dissector("pw_satop_udp")); /* for Decode-As */
}
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 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("chdlctype", 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);
dissector_add_uint("usb.bulk", IF_CLASS_CDC_DATA, 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_handle("udp.port", eth_withoutfcs_handle);
}
void
proto_reg_handoff_bthcrp(void)
{
dissector_handle_t bthcrp_handle;
data_handle = find_dissector("data");
bthcrp_handle = find_dissector("bthcrp");
dissector_add_uint("btl2cap.service", BTSDP_HARDCOPY_CONTROL_CHANNEL_PROTOCOL_UUID, bthcrp_handle);
dissector_add_uint("btl2cap.service", BTSDP_HARDCOPY_DATA_CHANNEL_PROTOCOL_UUID, bthcrp_handle);
dissector_add_uint("btl2cap.service", BTSDP_HARDCOPY_NOTIFICATION_PROTOCOL_UUID, bthcrp_handle);
dissector_add_handle("btl2cap.psm", bthcrp_handle);
dissector_add_handle("btl2cap.cid", bthcrp_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_handle("udp.port", lge_monitor_handle); /* for 'decode-as' */
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;
}
/*--- proto_reg_handoff_s1ap ---------------------------------------*/
void
proto_reg_handoff_s1ap(void)
{
static gboolean Initialized=FALSE;
static dissector_handle_t s1ap_handle;
static guint SctpPort;
s1ap_handle = find_dissector("s1ap");
if (!Initialized) {
nas_eps_handle = find_dissector("nas-eps");
lppa_handle = find_dissector("lppa");
bssgp_handle = find_dissector("bssgp");
dissector_add_handle("sctp.port", s1ap_handle); /* for "decode-as" */
dissector_add_uint("sctp.ppi", S1AP_PAYLOAD_PROTOCOL_ID, s1ap_handle);
Initialized=TRUE;
#include "packet-s1ap-dis-tab.c"
} else {
if (SctpPort != 0) {
dissector_delete_uint("sctp.port", SctpPort, s1ap_handle);
}
}
SctpPort=gbl_s1apSctpPort;
if (SctpPort != 0) {
dissector_add_uint("sctp.port", SctpPort, s1ap_handle);
}
}
/* If this dissector uses sub-dissector registration add a registration routine.
This format is required because a script is used to find these routines and
create the code that calls these routines.
*/
void
proto_reg_handoff_nasdaq_soup(void)
{
nasdaq_soup_handle = create_dissector_handle(dissect_nasdaq_soup, proto_nasdaq_soup);
nasdaq_itch_handle = find_dissector("nasdaq-itch");
dissector_add_handle("tcp.port", nasdaq_soup_handle); /* for "decode-as" */
}
void proto_reg_handoff_uaudp(void)
{
static gboolean prefs_initialized = FALSE;
static dissector_handle_t uaudp_handle;
int i;
if (!prefs_initialized)
{
uaudp_handle = find_dissector("uaudp");
ua_sys_to_term_handle = find_dissector("ua_sys_to_term");
ua_term_to_sys_handle = find_dissector("ua_term_to_sys");
#if 0
uaudp_opcode_dissector_table =
register_dissector_table("uaudp.opcode",
"UAUDP opcode",
FT_UINT8,
BASE_DEC);
#endif
prefs_initialized = TRUE;
}
else
{
for (i=0; i<MAX_TERMINAL_PORTS; i++)
{
if (ports[i].last_port)
dissector_delete_uint("udp.port", ports[i].last_port, uaudp_handle);
}
if (str_to_addr_ip(pref_sys_ip_s, sys_ip))
{
use_sys_ip = TRUE;
}
else
{
use_sys_ip = FALSE;
pref_sys_ip_s = "";
}
}
if (decode_ua)
{
int no_ports_registered = TRUE;
for (i=0; i < MAX_TERMINAL_PORTS; i++)
{
if (ports[i].port)
{
dissector_add_uint("udp.port", ports[i].port, uaudp_handle);
no_ports_registered = FALSE;
}
ports[i].last_port = ports[i].port;
}
if (no_ports_registered)
{
/* If all ports are set to 0, then just register the handle so
* at least "Decode As..." will work. */
dissector_add_handle("udp.port", uaudp_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_handle("sctp.port", x2ap_handle); /* for "decode-as" */
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_tuxedo(void)
{
tuxedo_handle = create_dissector_handle(dissect_tuxedo, proto_tuxedo);
dissector_add_handle("tcp.port", tuxedo_handle);
heur_dissector_add("tcp", dissect_tuxedo_heur, proto_tuxedo);
}
/* If this dissector uses sub-dissector registration add a registration routine.
This format is required because a script is used to find these routines and
create the code that calls these routines.
*/
void
proto_reg_handoff_msrp(void)
{
msrp_handle = find_dissector("msrp");
dissector_add_handle("tcp.port", msrp_handle); /* for "decode-as" */
heur_dissector_add("tcp", dissect_msrp_heur, proto_msrp);
media_type_dissector_table = find_dissector_table("media_type");
}
void
proto_reg_handoff_zrtp(void)
{
dissector_handle_t zrtp_handle;
zrtp_handle = find_dissector("zrtp");
dissector_add_handle("udp.port", zrtp_handle);
}
void proto_reg_handoff_pw_cesopsn(void)
{
data_handle = find_dissector("data");
pw_padding_handle = find_dissector("pw_padding");
dissector_add_uint("mpls.label", MPLS_LABEL_INVALID, find_dissector("pw_cesopsn_mpls"));
dissector_add_handle("udp.port", find_dissector("pw_cesopsn_udp")); /* For Decode-As */
return;
}
void
proto_reg_handoff_btmcap(void)
{
dissector_handle_t btmcap_handle;
btmcap_handle = find_dissector("btmcap");
dissector_add_uint("btl2cap.service", BTSDP_MCAP_CONTROL_CHANNEL_PROTOCOL_UUID, btmcap_handle);
dissector_add_uint("btl2cap.service", BTSDP_MCAP_DATA_CHANNEL_PROTOCOL_UUID, btmcap_handle);
dissector_add_uint("btl2cap.service", BTSDP_HDP_SERVICE_UUID, btmcap_handle);
dissector_add_uint("btl2cap.service", BTSDP_HDP_SOURCE_SERVICE_UUID, btmcap_handle);
dissector_add_uint("btl2cap.service", BTSDP_HDP_SINK_SERVICE_UUID, btmcap_handle);
/* dynamic PSM */
dissector_add_handle("btl2cap.psm", btmcap_handle);
dissector_add_handle("btl2cap.cid", btmcap_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_handle("udp.port", vxlan_handle); /* For 'Decode As' */
}
void
proto_reg_handoff_bthfp(void)
{
dissector_handle_t bthfp_handle;
bthfp_handle = find_dissector("bthfp");
dissector_add_uint("btrfcomm.service", BTSDP_HFP_SERVICE_UUID, bthfp_handle);
dissector_add_uint("btrfcomm.service", BTSDP_HFP_GW_SERVICE_UUID, bthfp_handle);
dissector_add_handle("btrfcomm.channel", bthfp_handle);
}
/*--- proto_reg_handoff_nbap ---------------------------------------*/
void
proto_reg_handoff_nbap(void)
{
dissector_handle_t nbap_handle;
nbap_handle = find_dissector("nbap");
/*dissector_add("sctp.ppi", Add ppid here, nbap_handle); */
dissector_add_handle("sctp.port", nbap_handle); /* for "decode-as" */
#include "packet-nbap-dis-tab.c"
}
void
proto_reg_handoff_swift(void)
{
dissector_handle_t swift_handle;
swift_handle = find_dissector("swift");
/* Allow "Decode As" with any UDP packet. */
dissector_add_handle("udp.port", swift_handle);
/* Add our heuristic packet finder. */
heur_dissector_add("udp", dissect_swift_heur, proto_swift);
}
/*
* This format is required because a script is used to find these
* routines and create the code that calls these routines.
*/
void
proto_reg_handoff_fcip (void)
{
dissector_handle_t fcip_handle;
heur_dissector_add("tcp", dissect_fcip_heur, proto_fcip);
fcip_handle = create_dissector_handle(dissect_fcip_handle, proto_fcip);
dissector_add_handle("tcp.port", fcip_handle);
data_handle = find_dissector("data");
fc_handle = find_dissector("fc");
}
void
proto_reg_handoff_pana(void)
{
dissector_handle_t pana_handle;
heur_dissector_add("udp", dissect_pana, proto_pana);
pana_handle = new_create_dissector_handle(dissect_pana, proto_pana);
dissector_add_handle("udp.port", pana_handle);
eap_handle = find_dissector("eap");
/** if(!eap_handle) fprintf(stderr,"PANA warning: EAP dissector not found\n"); **/
}
void
proto_reg_handoff_interlink(void)
{
dissector_handle_t interlink_handle;
interlink_handle = find_dissector("interlink");
/* Allow "Decode As" with any UDP packet. */
dissector_add_handle("udp.port", interlink_handle);
/* Add our heuristic packet finder. */
heur_dissector_add("udp", dissect_interlink_heur, proto_interlink);
data_handle = find_dissector("data");
}
void proto_reg_handoff_op_uavtalk(void)
{
static dissector_handle_t op_uavtalk_handle;
op_uavtalk_handle = new_create_dissector_handle(dissect_op_uavtalk, proto_op_uavtalk);
dissector_add_handle("udp.port", op_uavtalk_handle); /* for "decode as" */
if (global_op_uavtalk_port != 0) {
dissector_add_uint("udp.port", global_op_uavtalk_port, op_uavtalk_handle);
}
/* Lookup the default dissector for raw data */
data_handle = find_dissector("data");
}
void
proto_reg_handoff_btbnep(void)
{
dissector_handle_t btbnep_handle;
btbnep_handle = find_dissector("btbnep");
eth_handle = find_dissector("eth");
data_handle = find_dissector("data");
dissector_add_uint("btl2cap.service", BTSDP_PAN_GN_SERVICE_UUID, btbnep_handle);
dissector_add_uint("btl2cap.service", BTSDP_PAN_NAP_SERVICE_UUID, btbnep_handle);
dissector_add_uint("btl2cap.service", BTSDP_PAN_GN_SERVICE_UUID, btbnep_handle);
dissector_add_uint("btl2cap.psm", BTL2CAP_PSM_BNEP, btbnep_handle);
dissector_add_handle("btl2cap.cid", btbnep_handle);
}
void
proto_reg_handoff_bt_dht(void)
{
static gboolean prefs_initialized = FALSE;
/* "Decode As" is always available;
* Heuristic dissection in disabled by default since the heuristic is quite weak.
*/
if (!prefs_initialized) {
heur_dissector_add("udp", dissect_bt_dht_heur, proto_bt_dht);
bt_dht_handle = new_create_dissector_handle(dissect_bt_dht, proto_bt_dht);
dissector_add_handle("udp.port", bt_dht_handle); /* for "decode_as" */
prefs_initialized = TRUE;
}
heur_dissector_set_enabled("udp", dissect_bt_dht_heur, proto_bt_dht, bt_dht_enable_heuristic_dissection);
}
void
proto_reg_handoff_hci_usb(void)
{
bthci_cmd_handle = find_dissector("bthci_cmd");
bthci_evt_handle = find_dissector("bthci_evt");
bthci_acl_handle = find_dissector("bthci_acl");
bthci_sco_handle = find_dissector("bthci_sco");
dissector_add_uint("usb.product", (0x0a5c << 16) | 0x21e8, hci_usb_handle);
dissector_add_uint("usb.product", (0x1131 << 16) | 0x1001, hci_usb_handle);
dissector_add_uint("usb.product", (0x050d << 16) | 0x0081, hci_usb_handle);
dissector_add_uint("usb.product", (0x0a5c << 16) | 0x2198, hci_usb_handle);
dissector_add_uint("usb.product", (0x0a5c << 16) | 0x21e8, hci_usb_handle);
dissector_add_uint("usb.product", (0x04bf << 16) | 0x0320, hci_usb_handle);
dissector_add_uint("usb.product", (0x13d3 << 16) | 0x3375, hci_usb_handle);
dissector_add_uint("usb.protocol", 0xE00101, hci_usb_handle);
dissector_add_uint("usb.protocol", 0xE00104, hci_usb_handle);
dissector_add_handle("usb.device", hci_usb_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_handle("udp.port", cwids_handle);
ieee80211_handle = find_dissector("wlan");
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_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_handle("udp.port", newmail_handle); /* for 'decode-as' */
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;
}
