From e37275bfdee7a0ea4745def144d4a0e5c62e282d Mon Sep 17 00:00:00 2001 From: Michael Mann Date: Sun, 13 Mar 2016 07:51:45 -0400 Subject: Associate dissector tables and heuristic subdissector lists with a protocol. This will make it easier to determine protocol dependencies. Some LLC OUI dissector tables didn't have an associated protocol, so they were left without one (-1 used) Change-Id: I6339f16476510ef3f393d6fb5d8946419bfb4b7d Reviewed-on: https://code.wireshark.org/review/14446 Reviewed-by: Michael Mann --- epan/dissectors/CMakeLists.txt | 1 - epan/dissectors/Makefile.common | 1 - .../asn1/ansi_map/packet-ansi_map-template.c | 6 +- .../asn1/ansi_tcap/packet-ansi_tcap-template.c | 2 +- .../asn1/atn-ulcs/packet-atn-ulcs-template.c | 2 +- epan/dissectors/asn1/camel/packet-camel-template.c | 6 +- epan/dissectors/asn1/cmip/packet-cmip-template.c | 2 +- .../asn1/credssp/packet-credssp-template.c | 2 +- epan/dissectors/asn1/dop/packet-dop-template.c | 2 +- .../asn1/gsm_map/packet-gsm_map-template.c | 6 +- epan/dissectors/asn1/h225/packet-h225-template.c | 10 +-- epan/dissectors/asn1/h245/packet-h245-template.c | 8 +- epan/dissectors/asn1/h248/packet-h248-template.c | 2 +- epan/dissectors/asn1/h450/packet-h450-template.c | 12 +-- epan/dissectors/asn1/hnbap/packet-hnbap-template.c | 10 +-- epan/dissectors/asn1/lcsap/packet-lcsap-template.c | 10 +-- epan/dissectors/asn1/ldap/packet-ldap-template.c | 2 +- epan/dissectors/asn1/lppa/packet-lppa-template.c | 8 +- epan/dissectors/asn1/m3ap/packet-m3ap-template.c | 10 +-- .../asn1/mpeg-pes/packet-mpeg-pes-template.c | 2 +- epan/dissectors/asn1/nbap/packet-nbap-template.c | 10 +-- epan/dissectors/asn1/p1/packet-p1-template.c | 6 +- epan/dissectors/asn1/pcap/packet-pcap-template.c | 16 ++-- epan/dissectors/asn1/q932/packet-q932-template.c | 18 ++-- epan/dissectors/asn1/qsig/packet-qsig-template.c | 2 +- epan/dissectors/asn1/ranap/packet-ranap-template.c | 20 ++--- epan/dissectors/asn1/rnsap/packet-rnsap-template.c | 10 +-- epan/dissectors/asn1/ros/packet-ros-template.c | 2 +- epan/dissectors/asn1/rtse/packet-rtse-template.c | 2 +- epan/dissectors/asn1/rua/packet-rua-template.c | 10 +-- epan/dissectors/asn1/s1ap/packet-s1ap-template.c | 14 +-- epan/dissectors/asn1/sabp/packet-sabp-template.c | 10 +-- .../asn1/sbc-ap/packet-sbc-ap-template.c | 10 +-- epan/dissectors/asn1/snmp/packet-snmp-template.c | 2 +- epan/dissectors/asn1/t124/packet-t124-template.c | 4 +- epan/dissectors/asn1/t125/packet-t125-template.c | 2 +- epan/dissectors/asn1/x2ap/packet-x2ap-template.c | 10 +-- epan/dissectors/file-file.c | 6 +- epan/dissectors/packet-aeron.c | 2 +- epan/dissectors/packet-ansi_637.c | 2 +- epan/dissectors/packet-ansi_a.c | 6 +- epan/dissectors/packet-ansi_map.c | 6 +- epan/dissectors/packet-ansi_tcap.c | 2 +- epan/dissectors/packet-arcnet.c | 7 +- epan/dissectors/packet-aruba-erm.c | 2 +- epan/dissectors/packet-atalk.c | 2 +- epan/dissectors/packet-atm.c | 4 +- epan/dissectors/packet-atn-ulcs.c | 2 +- epan/dissectors/packet-ax25.c | 2 +- epan/dissectors/packet-bacapp.c | 2 +- epan/dissectors/packet-bacnet.c | 2 +- epan/dissectors/packet-bctp.c | 2 +- epan/dissectors/packet-ber.c | 4 +- epan/dissectors/packet-bitcoin.c | 2 +- epan/dissectors/packet-bluetooth.c | 54 +++++++++++- epan/dissectors/packet-bssap.c | 4 +- epan/dissectors/packet-bt-oui.c | 99 ---------------------- epan/dissectors/packet-btatt.c | 2 +- epan/dissectors/packet-bthci_cmd.c | 6 +- epan/dissectors/packet-btl2cap.c | 4 +- epan/dissectors/packet-btrfcomm.c | 2 +- epan/dissectors/packet-bvlc.c | 2 +- epan/dissectors/packet-c15ch.c | 8 +- epan/dissectors/packet-camel.c | 6 +- epan/dissectors/packet-ccsds.c | 2 +- epan/dissectors/packet-chdlc.c | 2 +- epan/dissectors/packet-cimetrics.c | 2 +- epan/dissectors/packet-cip.c | 6 +- epan/dissectors/packet-cisco-oui.c | 2 +- epan/dissectors/packet-clnp.c | 2 +- epan/dissectors/packet-cmip.c | 2 +- epan/dissectors/packet-cnip.c | 2 +- epan/dissectors/packet-corosync-totemsrp.c | 2 +- epan/dissectors/packet-credssp.c | 2 +- epan/dissectors/packet-db-lsp.c | 2 +- epan/dissectors/packet-dccp.c | 4 +- epan/dissectors/packet-dcerpc.c | 2 +- epan/dissectors/packet-dcp-etsi.c | 6 +- epan/dissectors/packet-diameter.c | 8 +- epan/dissectors/packet-dmx.c | 2 +- epan/dissectors/packet-dns.c | 2 +- epan/dissectors/packet-dop.c | 2 +- epan/dissectors/packet-dtls.c | 4 +- epan/dissectors/packet-dvbci.c | 2 +- epan/dissectors/packet-eapol.c | 2 +- epan/dissectors/packet-ecp-oui.c | 6 +- epan/dissectors/packet-enc.c | 2 +- epan/dissectors/packet-enip.c | 6 +- epan/dissectors/packet-epl.c | 6 +- epan/dissectors/packet-erf.c | 2 +- epan/dissectors/packet-eth.c | 4 +- epan/dissectors/packet-ethertype.c | 2 +- epan/dissectors/packet-extreme.c | 25 +++--- epan/dissectors/packet-fc.c | 2 +- epan/dissectors/packet-fcct.c | 2 +- epan/dissectors/packet-flexray.c | 2 +- epan/dissectors/packet-flip.c | 2 +- epan/dissectors/packet-force10-oui.c | 2 +- epan/dissectors/packet-foundry.c | 24 +++--- epan/dissectors/packet-fr.c | 4 +- epan/dissectors/packet-frame.c | 12 +-- epan/dissectors/packet-gfp.c | 2 +- epan/dissectors/packet-gprs-llc.c | 2 +- epan/dissectors/packet-gre.c | 2 +- epan/dissectors/packet-gsm_a_dtap.c | 2 +- epan/dissectors/packet-gsm_a_gm.c | 2 +- epan/dissectors/packet-gsm_ipa.c | 2 +- epan/dissectors/packet-gsm_map.c | 6 +- epan/dissectors/packet-gsm_sms.c | 2 +- epan/dissectors/packet-gsm_sms_ud.c | 2 +- epan/dissectors/packet-gsmtap.c | 2 +- epan/dissectors/packet-gtp.c | 4 +- epan/dissectors/packet-gtpv2.c | 2 +- epan/dissectors/packet-h225.c | 10 +-- epan/dissectors/packet-h245.c | 8 +- epan/dissectors/packet-h248.c | 2 +- epan/dissectors/packet-h450.c | 12 +-- epan/dissectors/packet-hci_h1.c | 2 +- epan/dissectors/packet-hci_h4.c | 2 +- epan/dissectors/packet-hnbap.c | 10 +-- epan/dissectors/packet-hpext.c | 2 +- epan/dissectors/packet-hpfeeds.c | 2 +- epan/dissectors/packet-hpteam.c | 2 +- epan/dissectors/packet-http.c | 6 +- epan/dissectors/packet-i2c.c | 2 +- epan/dissectors/packet-iana-oui.c | 2 +- epan/dissectors/packet-iax2.c | 4 +- epan/dissectors/packet-idp.c | 2 +- epan/dissectors/packet-ieee1722.c | 2 +- epan/dissectors/packet-ieee802154.c | 6 +- epan/dissectors/packet-ieee802a.c | 4 +- epan/dissectors/packet-ieee802a.h | 2 +- epan/dissectors/packet-igmp.c | 2 +- epan/dissectors/packet-infiniband.c | 4 +- epan/dissectors/packet-interlink.c | 2 +- epan/dissectors/packet-ip.c | 4 +- epan/dissectors/packet-ipmi-trace.c | 2 +- epan/dissectors/packet-ipv6.c | 2 +- epan/dissectors/packet-ipx.c | 6 +- epan/dissectors/packet-isi.c | 2 +- epan/dissectors/packet-isis.c | 2 +- epan/dissectors/packet-iso14443.c | 2 +- epan/dissectors/packet-iwarp-ddp-rdmap.c | 2 +- epan/dissectors/packet-j1939.c | 2 +- epan/dissectors/packet-juniper.c | 2 +- epan/dissectors/packet-kdsp.c | 2 +- epan/dissectors/packet-l2tp.c | 4 +- epan/dissectors/packet-lapd.c | 4 +- epan/dissectors/packet-lapdm.c | 2 +- epan/dissectors/packet-lapsat.c | 2 +- epan/dissectors/packet-lbmc.c | 2 +- epan/dissectors/packet-lcsap.c | 10 +-- epan/dissectors/packet-ldap.c | 2 +- epan/dissectors/packet-llc.c | 8 +- epan/dissectors/packet-llc.h | 2 +- epan/dissectors/packet-lldp.c | 2 +- epan/dissectors/packet-lppa.c | 8 +- epan/dissectors/packet-m3ap.c | 10 +-- epan/dissectors/packet-mausb.c | 22 ++--- epan/dissectors/packet-mbim.c | 2 +- epan/dissectors/packet-mbtcp.c | 4 +- epan/dissectors/packet-media.c | 2 +- epan/dissectors/packet-meta.c | 2 +- epan/dissectors/packet-mime-encap.c | 2 +- epan/dissectors/packet-mip.c | 2 +- epan/dissectors/packet-mip6.c | 2 +- epan/dissectors/packet-moldudp64.c | 2 +- epan/dissectors/packet-mp2t.c | 2 +- epan/dissectors/packet-mpeg-pes.c | 2 +- epan/dissectors/packet-mpeg-sect.c | 2 +- epan/dissectors/packet-mpls.c | 11 +-- epan/dissectors/packet-mq.c | 2 +- epan/dissectors/packet-mstp.c | 2 +- epan/dissectors/packet-mtp3.c | 2 +- epan/dissectors/packet-multipart.c | 2 +- epan/dissectors/packet-nbap.c | 10 +-- epan/dissectors/packet-netbios.c | 2 +- epan/dissectors/packet-netlink.c | 2 +- epan/dissectors/packet-nfs.c | 2 +- epan/dissectors/packet-nt-oui.c | 2 +- epan/dissectors/packet-null.c | 2 +- epan/dissectors/packet-obex.c | 2 +- epan/dissectors/packet-opensafety.c | 2 +- epan/dissectors/packet-osi.c | 9 +- epan/dissectors/packet-ositp.c | 10 +-- epan/dissectors/packet-p1.c | 6 +- epan/dissectors/packet-pcap.c | 16 ++-- epan/dissectors/packet-pcapng_block.c | 2 +- epan/dissectors/packet-pcli.c | 2 +- epan/dissectors/packet-per.c | 2 +- epan/dissectors/packet-pgm.c | 4 +- epan/dissectors/packet-ppp.c | 2 +- epan/dissectors/packet-q931.c | 6 +- epan/dissectors/packet-q932.c | 18 ++-- epan/dissectors/packet-qsig.c | 2 +- epan/dissectors/packet-raknet.c | 2 +- epan/dissectors/packet-ranap.c | 20 ++--- epan/dissectors/packet-rmcp.c | 2 +- epan/dissectors/packet-rnsap.c | 10 +-- epan/dissectors/packet-ros.c | 2 +- epan/dissectors/packet-rpc.c | 4 +- epan/dissectors/packet-rtacser.c | 2 +- epan/dissectors/packet-rtcp.c | 6 +- epan/dissectors/packet-rtitcp.c | 2 +- epan/dissectors/packet-rtp.c | 8 +- epan/dissectors/packet-rtps.c | 2 +- epan/dissectors/packet-rtse.c | 2 +- epan/dissectors/packet-rtsp.c | 2 +- epan/dissectors/packet-rua.c | 10 +-- epan/dissectors/packet-s1ap.c | 14 +-- epan/dissectors/packet-s5066sis.c | 2 +- epan/dissectors/packet-sabp.c | 10 +-- epan/dissectors/packet-sbc-ap.c | 10 +-- epan/dissectors/packet-sccp.c | 4 +- epan/dissectors/packet-sctp.c | 6 +- epan/dissectors/packet-sdp.c | 2 +- epan/dissectors/packet-sercosiii.c | 2 +- epan/dissectors/packet-sflow.c | 2 +- epan/dissectors/packet-sip.c | 4 +- epan/dissectors/packet-sita.c | 2 +- epan/dissectors/packet-sll.c | 2 +- epan/dissectors/packet-slowprotocols.c | 2 +- epan/dissectors/packet-smb-direct.c | 2 +- epan/dissectors/packet-smb-pipe.c | 13 +-- epan/dissectors/packet-smb2.c | 2 +- epan/dissectors/packet-snmp.c | 2 +- epan/dissectors/packet-socketcan.c | 2 +- epan/dissectors/packet-soupbintcp.c | 2 +- epan/dissectors/packet-spp.c | 2 +- epan/dissectors/packet-ssl.c | 4 +- epan/dissectors/packet-stun.c | 2 +- epan/dissectors/packet-sua.c | 4 +- epan/dissectors/packet-t124.c | 4 +- epan/dissectors/packet-t125.c | 2 +- epan/dissectors/packet-tali.c | 2 +- epan/dissectors/packet-tcp.c | 4 +- epan/dissectors/packet-teredo.c | 2 +- epan/dissectors/packet-tipc.c | 6 +- epan/dissectors/packet-turnchannel.c | 2 +- epan/dissectors/packet-udp.c | 4 +- epan/dissectors/packet-usb.c | 20 ++--- epan/dissectors/packet-vines.c | 8 +- epan/dissectors/packet-websocket.c | 4 +- epan/dissectors/packet-wlccp.c | 25 ++---- epan/dissectors/packet-wsp.c | 2 +- epan/dissectors/packet-x25.c | 4 +- epan/dissectors/packet-x2ap.c | 10 +-- epan/dissectors/packet-zbee-aps.c | 2 +- epan/dissectors/packet-zbee-zcl.c | 2 +- epan/packet.c | 14 ++- epan/packet.h | 6 +- epan/wslua/wslua_dissector.c | 3 +- 252 files changed, 629 insertions(+), 697 deletions(-) delete mode 100644 epan/dissectors/packet-bt-oui.c (limited to 'epan') diff --git a/epan/dissectors/CMakeLists.txt b/epan/dissectors/CMakeLists.txt index 0d09c6270d..9be2a0d2a2 100644 --- a/epan/dissectors/CMakeLists.txt +++ b/epan/dissectors/CMakeLists.txt @@ -389,7 +389,6 @@ set(DISSECTOR_SRC packet-btsap.c packet-btsdp.c packet-btsmp.c - packet-bt-oui.c packet-bvlc.c packet-bzr.c packet-c15ch.c diff --git a/epan/dissectors/Makefile.common b/epan/dissectors/Makefile.common index 69efb15a17..8b4cab06ca 100644 --- a/epan/dissectors/Makefile.common +++ b/epan/dissectors/Makefile.common @@ -372,7 +372,6 @@ DISSECTOR_SRC = \ packet-btsap.c \ packet-btsdp.c \ packet-btsmp.c \ - packet-bt-oui.c \ packet-bvlc.c \ packet-bzr.c \ packet-c15ch.c \ diff --git a/epan/dissectors/asn1/ansi_map/packet-ansi_map-template.c b/epan/dissectors/asn1/ansi_map/packet-ansi_map-template.c index e32291d9bf..265191922b 100644 --- a/epan/dissectors/asn1/ansi_map/packet-ansi_map-template.c +++ b/epan/dissectors/asn1/ansi_map/packet-ansi_map-template.c @@ -5463,15 +5463,15 @@ void proto_register_ansi_map(void) { register_dissector("ansi_map", dissect_ansi_map, proto_ansi_map); is637_tele_id_dissector_table = - register_dissector_table("ansi_map.tele_id", "IS-637 Teleservice ID", + register_dissector_table("ansi_map.tele_id", "IS-637 Teleservice ID", proto_ansi_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); is683_dissector_table = - register_dissector_table("ansi_map.ota", "IS-683-A (OTA)", + register_dissector_table("ansi_map.ota", "IS-683-A (OTA)", proto_ansi_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); is801_dissector_table = - register_dissector_table("ansi_map.pld", "IS-801 (PLD)", + register_dissector_table("ansi_map.pld", "IS-801 (PLD)", proto_ansi_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); ansi_map_tap = register_tap("ansi_map"); diff --git a/epan/dissectors/asn1/ansi_tcap/packet-ansi_tcap-template.c b/epan/dissectors/asn1/ansi_tcap/packet-ansi_tcap-template.c index 93d13dc362..938021845d 100644 --- a/epan/dissectors/asn1/ansi_tcap/packet-ansi_tcap-template.c +++ b/epan/dissectors/asn1/ansi_tcap/packet-ansi_tcap-template.c @@ -517,7 +517,7 @@ proto_register_ansi_tcap(void) register_dissector("ansi_tcap", dissect_ansi_tcap, proto_ansi_tcap); /* Note the high bit should be masked off when registering in this table (0x7fff)*/ - ansi_tcap_national_opcode_table = register_dissector_table("ansi_tcap.nat.opcode", "ANSI TCAP National Opcodes", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ansi_tcap_national_opcode_table = register_dissector_table("ansi_tcap.nat.opcode", "ANSI TCAP National Opcodes", proto_ansi_tcap, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_ansi_tcap, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); diff --git a/epan/dissectors/asn1/atn-ulcs/packet-atn-ulcs-template.c b/epan/dissectors/asn1/atn-ulcs/packet-atn-ulcs-template.c index 446c33f023..b25d061bdb 100644 --- a/epan/dissectors/asn1/atn-ulcs/packet-atn-ulcs-template.c +++ b/epan/dissectors/asn1/atn-ulcs/packet-atn-ulcs-template.c @@ -870,7 +870,7 @@ void proto_register_atn_ulcs (void) atn_cpdlc_handle = find_dissector("atn-cpdlc"); /* initiate sub dissector list */ - atn_ulcs_heur_subdissector_list = register_heur_dissector_list("atn-ulcs"); + atn_ulcs_heur_subdissector_list = register_heur_dissector_list("atn-ulcs", proto_atn_ulcs); /* init aare/aare data */ aarq_data_tree = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); diff --git a/epan/dissectors/asn1/camel/packet-camel-template.c b/epan/dissectors/asn1/camel/packet-camel-template.c index 6e6cd6d6b8..c0674164bc 100644 --- a/epan/dissectors/asn1/camel/packet-camel-template.c +++ b/epan/dissectors/asn1/camel/packet-camel-template.c @@ -1563,13 +1563,13 @@ void proto_register_camel(void) { /* Register dissector tables */ camel_rose_ctx.arg_local_dissector_table = register_dissector_table("camel.ros.local.arg", - "CAMEL Operation Argument (local opcode)", + "CAMEL Operation Argument (local opcode)", proto_camel, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); camel_rose_ctx.res_local_dissector_table = register_dissector_table("camel.ros.local.res", - "CAMEL Operation Result (local opcode)", + "CAMEL Operation Result (local opcode)", proto_camel, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); camel_rose_ctx.err_local_dissector_table = register_dissector_table("camel.ros.local.err", - "CAMEL Error (local opcode)", + "CAMEL Error (local opcode)", proto_camel, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Register our configuration options, particularly our SSNs */ diff --git a/epan/dissectors/asn1/cmip/packet-cmip-template.c b/epan/dissectors/asn1/cmip/packet-cmip-template.c index 6ecbaf9918..dbe11fa9ac 100644 --- a/epan/dissectors/asn1/cmip/packet-cmip-template.c +++ b/epan/dissectors/asn1/cmip/packet-cmip-template.c @@ -198,7 +198,7 @@ void proto_register_cmip(void) { #include "packet-cmip-dis-tab.c" oid_add_from_string("discriminatorId(1)","2.9.3.2.7.1"); - attribute_id_dissector_table = register_dissector_table("cmip.attribute_id", "CMIP Attribute Id", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + attribute_id_dissector_table = register_dissector_table("cmip.attribute_id", "CMIP Attribute Id", proto_cmip, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/asn1/credssp/packet-credssp-template.c b/epan/dissectors/asn1/credssp/packet-credssp-template.c index 0da2930ffe..2207a31194 100644 --- a/epan/dissectors/asn1/credssp/packet-credssp-template.c +++ b/epan/dissectors/asn1/credssp/packet-credssp-template.c @@ -168,7 +168,7 @@ void proto_register_credssp(void) { proto_register_subtree_array(ett, array_length(ett)); /* heuristic dissectors for any premable e.g. CredSSP before RDP */ - credssp_heur_subdissector_list = register_heur_dissector_list("credssp"); + credssp_heur_subdissector_list = register_heur_dissector_list("credssp", proto_credssp); } diff --git a/epan/dissectors/asn1/dop/packet-dop-template.c b/epan/dissectors/asn1/dop/packet-dop-template.c index 1cf698a20d..2a94cdf4ca 100644 --- a/epan/dissectors/asn1/dop/packet-dop-template.c +++ b/epan/dissectors/asn1/dop/packet-dop-template.c @@ -263,7 +263,7 @@ void proto_register_dop(void) { register_dissector("dop", dissect_dop, proto_dop); - dop_dissector_table = register_dissector_table("dop.oid", "DOP OID Dissectors", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + dop_dissector_table = register_dissector_table("dop.oid", "DOP OID Dissectors", proto_dop, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Register fields and subtrees */ proto_register_field_array(proto_dop, hf, array_length(hf)); diff --git a/epan/dissectors/asn1/gsm_map/packet-gsm_map-template.c b/epan/dissectors/asn1/gsm_map/packet-gsm_map-template.c index 15ca5a33f7..15178d1ef2 100644 --- a/epan/dissectors/asn1/gsm_map/packet-gsm_map-template.c +++ b/epan/dissectors/asn1/gsm_map/packet-gsm_map-template.c @@ -3136,9 +3136,9 @@ void proto_register_gsm_map(void) { expert_gsm_map = expert_register_protocol(proto_gsm_map); expert_register_field_array(expert_gsm_map, ei, array_length(ei)); - map_prop_arg_opcode_table = register_dissector_table("gsm_map.prop.arg.opcode", "GSM_MAP Proprietary Arg Opcodes", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - map_prop_res_opcode_table = register_dissector_table("gsm_map.prop.res.opcode", "GSM_MAP Proprietary Res Opcodes", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - map_prop_err_opcode_table = register_dissector_table("gsm_map.prop.err.opcode", "GSM_MAP Proprietary Err Opcodes", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + map_prop_arg_opcode_table = register_dissector_table("gsm_map.prop.arg.opcode", "GSM_MAP Proprietary Arg Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + map_prop_res_opcode_table = register_dissector_table("gsm_map.prop.res.opcode", "GSM_MAP Proprietary Res Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + map_prop_err_opcode_table = register_dissector_table("gsm_map.prop.err.opcode", "GSM_MAP Proprietary Err Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); gsm_map_tap = register_tap("gsm_map"); diff --git a/epan/dissectors/asn1/h225/packet-h225-template.c b/epan/dissectors/asn1/h225/packet-h225-template.c index 1fbfe4a07a..d92f27cb97 100644 --- a/epan/dissectors/asn1/h225/packet-h225-template.c +++ b/epan/dissectors/asn1/h225/packet-h225-template.c @@ -912,11 +912,11 @@ void proto_register_h225(void) { register_dissector("h323ui",dissect_h225_H323UserInformation, proto_h225); register_dissector("h225.ras", dissect_h225_h225_RasMessage, proto_h225); - nsp_object_dissector_table = register_dissector_table("h225.nsp.object", "H.225 NonStandardParameter (object)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - nsp_h221_dissector_table = register_dissector_table("h225.nsp.h221", "H.225 NonStandardParameter (h221)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - tp_dissector_table = register_dissector_table("h225.tp", "H.225 TunnelledProtocol", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - gef_name_dissector_table = register_dissector_table("h225.gef.name", "H.225 Generic Extensible Framework (names)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - gef_content_dissector_table = register_dissector_table("h225.gef.content", "H.225 Generic Extensible Framework", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nsp_object_dissector_table = register_dissector_table("h225.nsp.object", "H.225 NonStandardParameter (object)", proto_h225, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nsp_h221_dissector_table = register_dissector_table("h225.nsp.h221", "H.225 NonStandardParameter (h221)", proto_h225, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + tp_dissector_table = register_dissector_table("h225.tp", "H.225 TunnelledProtocol", proto_h225, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + gef_name_dissector_table = register_dissector_table("h225.gef.name", "H.225 Generic Extensible Framework (names)", proto_h225, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + gef_content_dissector_table = register_dissector_table("h225.gef.content", "H.225 Generic Extensible Framework", proto_h225, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); register_init_routine(&h225_init_routine); register_cleanup_routine(&h225_cleanup_routine); diff --git a/epan/dissectors/asn1/h245/packet-h245-template.c b/epan/dissectors/asn1/h245/packet-h245-template.c index 33ed26bd3a..426625fbea 100644 --- a/epan/dissectors/asn1/h245/packet-h245-template.c +++ b/epan/dissectors/asn1/h245/packet-h245-template.c @@ -541,10 +541,10 @@ void proto_register_h245(void) { register_dissector("h245dg", dissect_h245_h245, proto_h245); register_dissector("h245", dissect_h245, proto_h245); - nsp_object_dissector_table = register_dissector_table("h245.nsp.object", "H.245 NonStandardParameter (object)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - nsp_h221_dissector_table = register_dissector_table("h245.nsp.h221", "H.245 NonStandardParameter (h221)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - gef_name_dissector_table = register_dissector_table("h245.gef.name", "H.245 Generic Extensible Framework (names)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - gef_content_dissector_table = register_dissector_table("h245.gef.content", "H.245 Generic Extensible Framework", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nsp_object_dissector_table = register_dissector_table("h245.nsp.object", "H.245 NonStandardParameter (object)", proto_h245, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nsp_h221_dissector_table = register_dissector_table("h245.nsp.h221", "H.245 NonStandardParameter (h221)", proto_h245, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + gef_name_dissector_table = register_dissector_table("h245.gef.name", "H.245 Generic Extensible Framework (names)", proto_h245, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + gef_content_dissector_table = register_dissector_table("h245.gef.content", "H.245 Generic Extensible Framework", proto_h245, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); h245_tap = register_tap("h245"); h245dg_tap = register_tap("h245dg"); diff --git a/epan/dissectors/asn1/h248/packet-h248-template.c b/epan/dissectors/asn1/h248/packet-h248-template.c index 58e9112a13..0d173d2983 100644 --- a/epan/dissectors/asn1/h248/packet-h248-template.c +++ b/epan/dissectors/asn1/h248/packet-h248-template.c @@ -1623,7 +1623,7 @@ void proto_register_h248(void) { expert_h248 = expert_register_protocol(proto_h248); expert_register_field_array(expert_h248, ei, array_length(ei)); - subdissector_table = register_dissector_table("h248.magic_num", "H248 Magic Num", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + subdissector_table = register_dissector_table("h248.magic_num", "H248 Magic Num", proto_h248, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); h248_module = prefs_register_protocol(proto_h248, proto_reg_handoff_h248); prefs_register_bool_preference(h248_module, "ctx_info", diff --git a/epan/dissectors/asn1/h450/packet-h450-template.c b/epan/dissectors/asn1/h450/packet-h450-template.c index ffb0de0157..7c0ee14b74 100644 --- a/epan/dissectors/asn1/h450/packet-h450-template.c +++ b/epan/dissectors/asn1/h450/packet-h450-template.c @@ -289,12 +289,12 @@ void proto_register_h450(void) { rose_ctx_init(&h450_rose_ctx); /* Register dissector tables */ - h450_rose_ctx.arg_global_dissector_table = register_dissector_table("h450.ros.global.arg", "H.450 Operation Argument (global opcode)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - h450_rose_ctx.res_global_dissector_table = register_dissector_table("h450.ros.global.res", "H.450 Operation Result (global opcode)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - h450_rose_ctx.arg_local_dissector_table = register_dissector_table("h450.ros.local.arg", "H.450 Operation Argument (local opcode)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - h450_rose_ctx.res_local_dissector_table = register_dissector_table("h450.ros.local.res", "H.450 Operation Result (local opcode)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - h450_rose_ctx.err_global_dissector_table = register_dissector_table("h450.ros.global.err", "H.450 Error (global opcode)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - h450_rose_ctx.err_local_dissector_table = register_dissector_table("h450.ros.local.err", "H.450 Error (local opcode)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + h450_rose_ctx.arg_global_dissector_table = register_dissector_table("h450.ros.global.arg", "H.450 Operation Argument (global opcode)", proto_h450, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + h450_rose_ctx.res_global_dissector_table = register_dissector_table("h450.ros.global.res", "H.450 Operation Result (global opcode)", proto_h450, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + h450_rose_ctx.arg_local_dissector_table = register_dissector_table("h450.ros.local.arg", "H.450 Operation Argument (local opcode)", proto_h450, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + h450_rose_ctx.res_local_dissector_table = register_dissector_table("h450.ros.local.res", "H.450 Operation Result (local opcode)", proto_h450, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + h450_rose_ctx.err_global_dissector_table = register_dissector_table("h450.ros.global.err", "H.450 Error (global opcode)", proto_h450, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + h450_rose_ctx.err_local_dissector_table = register_dissector_table("h450.ros.local.err", "H.450 Error (local opcode)", proto_h450, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/asn1/hnbap/packet-hnbap-template.c b/epan/dissectors/asn1/hnbap/packet-hnbap-template.c index a415d906ba..70458d9a87 100644 --- a/epan/dissectors/asn1/hnbap/packet-hnbap-template.c +++ b/epan/dissectors/asn1/hnbap/packet-hnbap-template.c @@ -166,11 +166,11 @@ module_t *hnbap_module; register_dissector("hnbap", dissect_hnbap, proto_hnbap); /* Register dissector tables */ - hnbap_ies_dissector_table = register_dissector_table("hnbap.ies", "HNBAP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - hnbap_extension_dissector_table = register_dissector_table("hnbap.extension", "HNBAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - hnbap_proc_imsg_dissector_table = register_dissector_table("hnbap.proc.imsg", "HNBAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - hnbap_proc_sout_dissector_table = register_dissector_table("hnbap.proc.sout", "HNBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - hnbap_proc_uout_dissector_table = register_dissector_table("hnbap.proc.uout", "HNBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + hnbap_ies_dissector_table = register_dissector_table("hnbap.ies", "HNBAP-PROTOCOL-IES", proto_hnbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + hnbap_extension_dissector_table = register_dissector_table("hnbap.extension", "HNBAP-PROTOCOL-EXTENSION", proto_hnbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + hnbap_proc_imsg_dissector_table = register_dissector_table("hnbap.proc.imsg", "HNBAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_hnbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + hnbap_proc_sout_dissector_table = register_dissector_table("hnbap.proc.sout", "HNBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_hnbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + hnbap_proc_uout_dissector_table = register_dissector_table("hnbap.proc.uout", "HNBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_hnbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); hnbap_module = prefs_register_protocol(proto_hnbap, proto_reg_handoff_hnbap); prefs_register_uint_preference(hnbap_module, "port", "HNBAP SCTP Port", "Set the port for HNBAP messages (Default of 29169)", 10, &global_sctp_port); diff --git a/epan/dissectors/asn1/lcsap/packet-lcsap-template.c b/epan/dissectors/asn1/lcsap/packet-lcsap-template.c index 9206c92fa0..22e44f34b1 100644 --- a/epan/dissectors/asn1/lcsap/packet-lcsap-template.c +++ b/epan/dissectors/asn1/lcsap/packet-lcsap-template.c @@ -314,13 +314,13 @@ void proto_register_lcsap(void) { register_dissector("lcsap", dissect_lcsap, proto_lcsap); /* Register dissector tables */ - lcsap_ies_dissector_table = register_dissector_table("lcsap.ies", "LCS-AP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lcsap_ies_dissector_table = register_dissector_table("lcsap.ies", "LCS-AP-PROTOCOL-IES", proto_lcsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lcsap_extension_dissector_table = register_dissector_table("lcsap.extension", "LCS-AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lcsap_proc_imsg_dissector_table = register_dissector_table("lcsap.proc.imsg", "LCS-AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lcsap_proc_sout_dissector_table = register_dissector_table("lcsap.proc.sout", "LCS-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lcsap_proc_uout_dissector_table = register_dissector_table("lcsap.proc.uout", "LCS-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lcsap_extension_dissector_table = register_dissector_table("lcsap.extension", "LCS-AP-PROTOCOL-EXTENSION", proto_lcsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lcsap_proc_imsg_dissector_table = register_dissector_table("lcsap.proc.imsg", "LCS-AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_lcsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lcsap_proc_sout_dissector_table = register_dissector_table("lcsap.proc.sout", "LCS-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_lcsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lcsap_proc_uout_dissector_table = register_dissector_table("lcsap.proc.uout", "LCS-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_lcsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Register configuration options for ports */ lcsap_module = prefs_register_protocol(proto_lcsap, proto_reg_handoff_lcsap); diff --git a/epan/dissectors/asn1/ldap/packet-ldap-template.c b/epan/dissectors/asn1/ldap/packet-ldap-template.c index a5284463e7..a653edc2e4 100644 --- a/epan/dissectors/asn1/ldap/packet-ldap-template.c +++ b/epan/dissectors/asn1/ldap/packet-ldap-template.c @@ -2273,7 +2273,7 @@ void proto_register_ldap(void) { register_cleanup_routine(ldap_cleanup); ldap_tap=register_tap("ldap"); - ldap_name_dissector_table = register_dissector_table("ldap.name", "LDAP Attribute Type Dissectors", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ldap_name_dissector_table = register_dissector_table("ldap.name", "LDAP Attribute Type Dissectors", proto_cldap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); register_srt_table(proto_ldap, NULL, 1, ldapstat_packet, ldapstat_init, NULL); } diff --git a/epan/dissectors/asn1/lppa/packet-lppa-template.c b/epan/dissectors/asn1/lppa/packet-lppa-template.c index 23bce0b983..479d0d8c21 100644 --- a/epan/dissectors/asn1/lppa/packet-lppa-template.c +++ b/epan/dissectors/asn1/lppa/packet-lppa-template.c @@ -111,10 +111,10 @@ void proto_register_lppa(void) { proto_register_subtree_array(ett, array_length(ett)); /* Register dissector tables */ - lppa_ies_dissector_table = register_dissector_table("lppa.ies", "LPPA-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lppa_proc_imsg_dissector_table = register_dissector_table("lppa.proc.imsg", "LPPA-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lppa_proc_sout_dissector_table = register_dissector_table("lppa.proc.sout", "LPPA-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lppa_proc_uout_dissector_table = register_dissector_table("lppa.proc.uout", "LPPA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lppa_ies_dissector_table = register_dissector_table("lppa.ies", "LPPA-PROTOCOL-IES", proto_lppa, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lppa_proc_imsg_dissector_table = register_dissector_table("lppa.proc.imsg", "LPPA-ELEMENTARY-PROCEDURE InitiatingMessage", proto_lppa, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lppa_proc_sout_dissector_table = register_dissector_table("lppa.proc.sout", "LPPA-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_lppa, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lppa_proc_uout_dissector_table = register_dissector_table("lppa.proc.uout", "LPPA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_lppa, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); } /*--- proto_reg_handoff_lppa ---------------------------------------*/ diff --git a/epan/dissectors/asn1/m3ap/packet-m3ap-template.c b/epan/dissectors/asn1/m3ap/packet-m3ap-template.c index 98cceefbc3..91ad65c201 100644 --- a/epan/dissectors/asn1/m3ap/packet-m3ap-template.c +++ b/epan/dissectors/asn1/m3ap/packet-m3ap-template.c @@ -183,11 +183,11 @@ void proto_register_m3ap(void) { expert_register_field_array(expert_m3ap, ei, array_length(ei)); /* Register dissector tables */ - m3ap_ies_dissector_table = register_dissector_table("m3ap.ies", "M3AP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - m3ap_extension_dissector_table = register_dissector_table("m3ap.extension", "M3AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - m3ap_proc_imsg_dissector_table = register_dissector_table("m3ap.proc.imsg", "M3AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - m3ap_proc_sout_dissector_table = register_dissector_table("m3ap.proc.sout", "M3AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - m3ap_proc_uout_dissector_table = register_dissector_table("m3ap.proc.uout", "M3AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + m3ap_ies_dissector_table = register_dissector_table("m3ap.ies", "M3AP-PROTOCOL-IES", proto_m3ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + m3ap_extension_dissector_table = register_dissector_table("m3ap.extension", "M3AP-PROTOCOL-EXTENSION", proto_m3ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + m3ap_proc_imsg_dissector_table = register_dissector_table("m3ap.proc.imsg", "M3AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_m3ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + m3ap_proc_sout_dissector_table = register_dissector_table("m3ap.proc.sout", "M3AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_m3ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + m3ap_proc_uout_dissector_table = register_dissector_table("m3ap.proc.uout", "M3AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_m3ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/asn1/mpeg-pes/packet-mpeg-pes-template.c b/epan/dissectors/asn1/mpeg-pes/packet-mpeg-pes-template.c index a5f0defd2b..984226a60a 100644 --- a/epan/dissectors/asn1/mpeg-pes/packet-mpeg-pes-template.c +++ b/epan/dissectors/asn1/mpeg-pes/packet-mpeg-pes-template.c @@ -655,7 +655,7 @@ proto_register_mpeg_pes(void) proto_mpeg = proto_register_protocol( "Moving Picture Experts Group", "MPEG", "mpeg"); register_dissector("mpeg", dissect_mpeg, proto_mpeg); - heur_subdissector_list = register_heur_dissector_list("mpeg"); + heur_subdissector_list = register_heur_dissector_list("mpeg", proto_mpeg); proto_mpeg_pes = proto_register_protocol( "Packetized Elementary Stream", "MPEG PES", "mpeg-pes"); diff --git a/epan/dissectors/asn1/nbap/packet-nbap-template.c b/epan/dissectors/asn1/nbap/packet-nbap-template.c index 46ca231ea7..0e977447e5 100644 --- a/epan/dissectors/asn1/nbap/packet-nbap-template.c +++ b/epan/dissectors/asn1/nbap/packet-nbap-template.c @@ -537,11 +537,11 @@ void proto_register_nbap(void) } /* Register dissector tables */ - nbap_ies_dissector_table = register_dissector_table("nbap.ies", "NBAP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - nbap_extension_dissector_table = register_dissector_table("nbap.extension", "NBAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - nbap_proc_imsg_dissector_table = register_dissector_table("nbap.proc.imsg", "NBAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - nbap_proc_sout_dissector_table = register_dissector_table("nbap.proc.sout", "NBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - nbap_proc_uout_dissector_table = register_dissector_table("nbap.proc.uout", "NBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nbap_ies_dissector_table = register_dissector_table("nbap.ies", "NBAP-PROTOCOL-IES", proto_nbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nbap_extension_dissector_table = register_dissector_table("nbap.extension", "NBAP-PROTOCOL-EXTENSION", proto_nbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nbap_proc_imsg_dissector_table = register_dissector_table("nbap.proc.imsg", "NBAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_nbap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nbap_proc_sout_dissector_table = register_dissector_table("nbap.proc.sout", "NBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_nbap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nbap_proc_uout_dissector_table = register_dissector_table("nbap.proc.uout", "NBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_nbap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); register_init_routine(nbap_init); register_cleanup_routine(nbap_cleanup); diff --git a/epan/dissectors/asn1/p1/packet-p1-template.c b/epan/dissectors/asn1/p1/packet-p1-template.c index 1d1714fe75..6c807d0ea0 100644 --- a/epan/dissectors/asn1/p1/packet-p1-template.c +++ b/epan/dissectors/asn1/p1/packet-p1-template.c @@ -373,9 +373,9 @@ void proto_register_p1(void) { expert_p1 = expert_register_protocol(proto_p1); expert_register_field_array(expert_p1, ei, array_length(ei)); - p1_extension_dissector_table = register_dissector_table("p1.extension", "P1-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - p1_extension_attribute_dissector_table = register_dissector_table("p1.extension-attribute", "P1-EXTENSION-ATTRIBUTE", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - p1_tokendata_dissector_table = register_dissector_table("p1.tokendata", "P1-TOKENDATA", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + p1_extension_dissector_table = register_dissector_table("p1.extension", "P1-EXTENSION", proto_p1, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + p1_extension_attribute_dissector_table = register_dissector_table("p1.extension-attribute", "P1-EXTENSION-ATTRIBUTE", proto_p1, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + p1_tokendata_dissector_table = register_dissector_table("p1.tokendata", "P1-TOKENDATA", proto_p1, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Register our configuration options for P1, particularly our port */ diff --git a/epan/dissectors/asn1/pcap/packet-pcap-template.c b/epan/dissectors/asn1/pcap/packet-pcap-template.c index f8b5bd159f..68cb625e78 100644 --- a/epan/dissectors/asn1/pcap/packet-pcap-template.c +++ b/epan/dissectors/asn1/pcap/packet-pcap-template.c @@ -191,14 +191,14 @@ void proto_register_pcap(void) { register_dissector("pcap", dissect_pcap, proto_pcap); /* Register dissector tables */ - pcap_ies_dissector_table = register_dissector_table("pcap.ies", "PCAP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_ies_p1_dissector_table = register_dissector_table("pcap.ies.pair.first", "PCAP-PROTOCOL-IES-PAIR FirstValue", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_ies_p2_dissector_table = register_dissector_table("pcap.ies.pair.second", "PCAP-PROTOCOL-IES-PAIR SecondValue", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_extension_dissector_table = register_dissector_table("pcap.extension", "PCAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_proc_imsg_dissector_table = register_dissector_table("pcap.proc.imsg", "PCAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_proc_sout_dissector_table = register_dissector_table("pcap.proc.sout", "PCAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_proc_uout_dissector_table = register_dissector_table("pcap.proc.uout", "PCAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_proc_out_dissector_table = register_dissector_table("pcap.proc.out", "PCAP-ELEMENTARY-PROCEDURE Outcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_ies_dissector_table = register_dissector_table("pcap.ies", "PCAP-PROTOCOL-IES", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_ies_p1_dissector_table = register_dissector_table("pcap.ies.pair.first", "PCAP-PROTOCOL-IES-PAIR FirstValue", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_ies_p2_dissector_table = register_dissector_table("pcap.ies.pair.second", "PCAP-PROTOCOL-IES-PAIR SecondValue", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_extension_dissector_table = register_dissector_table("pcap.extension", "PCAP-PROTOCOL-EXTENSION", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_proc_imsg_dissector_table = register_dissector_table("pcap.proc.imsg", "PCAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_proc_sout_dissector_table = register_dissector_table("pcap.proc.sout", "PCAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_proc_uout_dissector_table = register_dissector_table("pcap.proc.uout", "PCAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_proc_out_dissector_table = register_dissector_table("pcap.proc.out", "PCAP-ELEMENTARY-PROCEDURE Outcome", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Preferences */ diff --git a/epan/dissectors/asn1/q932/packet-q932-template.c b/epan/dissectors/asn1/q932/packet-q932-template.c index 2386e36bfa..29d4454bee 100644 --- a/epan/dissectors/asn1/q932/packet-q932-template.c +++ b/epan/dissectors/asn1/q932/packet-q932-template.c @@ -348,17 +348,17 @@ void proto_register_q932(void) { rose_ctx_init(&q932_rose_ctx); /* Register dissector tables */ - q932_rose_ctx.arg_global_dissector_table = register_dissector_table("q932.ros.global.arg", "Q.932 Operation Argument (global opcode)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - q932_rose_ctx.res_global_dissector_table = register_dissector_table("q932.ros.global.res", "Q.932 Operation Result (global opcode)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - q932_rose_ctx.err_global_dissector_table = register_dissector_table("q932.ros.global.err", "Q.932 Error (global opcode)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + q932_rose_ctx.arg_global_dissector_table = register_dissector_table("q932.ros.global.arg", "Q.932 Operation Argument (global opcode)", proto_q932, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + q932_rose_ctx.res_global_dissector_table = register_dissector_table("q932.ros.global.res", "Q.932 Operation Result (global opcode)", proto_q932, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + q932_rose_ctx.err_global_dissector_table = register_dissector_table("q932.ros.global.err", "Q.932 Error (global opcode)", proto_q932, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - qsig_arg_local_dissector_table = register_dissector_table("q932.ros.local.arg", "Q.932 Operation Argument (local opcode)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - qsig_res_local_dissector_table = register_dissector_table("q932.ros.local.res", "Q.932 Operation Result (local opcode)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - qsig_err_local_dissector_table = register_dissector_table("q932.ros.local.err", "Q.932 Error (local opcode)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + qsig_arg_local_dissector_table = register_dissector_table("q932.ros.local.arg", "Q.932 Operation Argument (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + qsig_res_local_dissector_table = register_dissector_table("q932.ros.local.res", "Q.932 Operation Result (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + qsig_err_local_dissector_table = register_dissector_table("q932.ros.local.err", "Q.932 Error (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - etsi_arg_local_dissector_table = register_dissector_table("q932.ros.etsi.local.arg", "Q.932 ETSI Operation Argument (local opcode)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - etsi_res_local_dissector_table = register_dissector_table("q932.ros.etsi.local.res", "Q.932 ETSI Operation Result (local opcode)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - etsi_err_local_dissector_table = register_dissector_table("q932.ros.etsi.local.err", "Q.932 ETSI Error (local opcode)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + etsi_arg_local_dissector_table = register_dissector_table("q932.ros.etsi.local.arg", "Q.932 ETSI Operation Argument (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + etsi_res_local_dissector_table = register_dissector_table("q932.ros.etsi.local.res", "Q.932 ETSI Operation Result (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + etsi_err_local_dissector_table = register_dissector_table("q932.ros.etsi.local.err", "Q.932 ETSI Error (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); q932_module = prefs_register_protocol(proto_q932, proto_reg_handoff_q932); diff --git a/epan/dissectors/asn1/qsig/packet-qsig-template.c b/epan/dissectors/asn1/qsig/packet-qsig-template.c index 068673f9c0..a0c53527e1 100644 --- a/epan/dissectors/asn1/qsig/packet-qsig-template.c +++ b/epan/dissectors/asn1/qsig/packet-qsig-template.c @@ -693,7 +693,7 @@ void proto_register_qsig(void) { expert_register_field_array(expert_qsig, ei, array_length(ei)); /* Register dissector tables */ - extension_dissector_table = register_dissector_table("qsig.ext", "QSIG Extension", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + extension_dissector_table = register_dissector_table("qsig.ext", "QSIG Extension", proto_qsig, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); qsig_init_tables(); } diff --git a/epan/dissectors/asn1/ranap/packet-ranap-template.c b/epan/dissectors/asn1/ranap/packet-ranap-template.c index 1e455885fc..6a63aa4f7e 100644 --- a/epan/dissectors/asn1/ranap/packet-ranap-template.c +++ b/epan/dissectors/asn1/ranap/packet-ranap-template.c @@ -346,16 +346,16 @@ void proto_register_ranap(void) { register_dissector("ranap", dissect_ranap, proto_ranap); /* Register dissector tables */ - ranap_ies_dissector_table = register_dissector_table("ranap.ies", "RANAP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_ies_p1_dissector_table = register_dissector_table("ranap.ies.pair.first", "RANAP-PROTOCOL-IES-PAIR FirstValue", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_ies_p2_dissector_table = register_dissector_table("ranap.ies.pair.second", "RANAP-PROTOCOL-IES-PAIR SecondValue", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_extension_dissector_table = register_dissector_table("ranap.extension", "RANAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_proc_imsg_dissector_table = register_dissector_table("ranap.proc.imsg", "RANAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_proc_sout_dissector_table = register_dissector_table("ranap.proc.sout", "RANAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_proc_uout_dissector_table = register_dissector_table("ranap.proc.uout", "RANAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_proc_out_dissector_table = register_dissector_table("ranap.proc.out", "RANAP-ELEMENTARY-PROCEDURE Outcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - - nas_pdu_dissector_table = register_dissector_table("ranap.nas_pdu", "RANAP NAS PDU", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_ies_dissector_table = register_dissector_table("ranap.ies", "RANAP-PROTOCOL-IES", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_ies_p1_dissector_table = register_dissector_table("ranap.ies.pair.first", "RANAP-PROTOCOL-IES-PAIR FirstValue", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_ies_p2_dissector_table = register_dissector_table("ranap.ies.pair.second", "RANAP-PROTOCOL-IES-PAIR SecondValue", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_extension_dissector_table = register_dissector_table("ranap.extension", "RANAP-PROTOCOL-EXTENSION", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_proc_imsg_dissector_table = register_dissector_table("ranap.proc.imsg", "RANAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_proc_sout_dissector_table = register_dissector_table("ranap.proc.sout", "RANAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_proc_uout_dissector_table = register_dissector_table("ranap.proc.uout", "RANAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_proc_out_dissector_table = register_dissector_table("ranap.proc.out", "RANAP-ELEMENTARY-PROCEDURE Outcome", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + + nas_pdu_dissector_table = register_dissector_table("ranap.nas_pdu", "RANAP NAS PDU", proto_ranap, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); ranap_module = prefs_register_protocol(proto_ranap, proto_reg_handoff_ranap); prefs_register_uint_preference(ranap_module, "sccp_ssn", "SCCP SSN for RANAP", diff --git a/epan/dissectors/asn1/rnsap/packet-rnsap-template.c b/epan/dissectors/asn1/rnsap/packet-rnsap-template.c index afef4396f1..5903a0cdfd 100644 --- a/epan/dissectors/asn1/rnsap/packet-rnsap-template.c +++ b/epan/dissectors/asn1/rnsap/packet-rnsap-template.c @@ -161,11 +161,11 @@ void proto_register_rnsap(void) { register_dissector("rnsap", dissect_rnsap, proto_rnsap); /* Register dissector tables */ - rnsap_ies_dissector_table = register_dissector_table("rnsap.ies", "RNSAP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rnsap_extension_dissector_table = register_dissector_table("rnsap.extension", "RNSAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rnsap_proc_imsg_dissector_table = register_dissector_table("rnsap.proc.imsg", "RNSAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rnsap_proc_sout_dissector_table = register_dissector_table("rnsap.proc.sout", "RNSAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rnsap_proc_uout_dissector_table = register_dissector_table("rnsap.proc.uout", "RNSAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rnsap_ies_dissector_table = register_dissector_table("rnsap.ies", "RNSAP-PROTOCOL-IES", proto_rnsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rnsap_extension_dissector_table = register_dissector_table("rnsap.extension", "RNSAP-PROTOCOL-EXTENSION", proto_rnsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rnsap_proc_imsg_dissector_table = register_dissector_table("rnsap.proc.imsg", "RNSAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_rnsap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rnsap_proc_sout_dissector_table = register_dissector_table("rnsap.proc.sout", "RNSAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_rnsap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rnsap_proc_uout_dissector_table = register_dissector_table("rnsap.proc.uout", "RNSAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_rnsap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/asn1/ros/packet-ros-template.c b/epan/dissectors/asn1/ros/packet-ros-template.c index 6f7cc417b5..8fc97cada7 100644 --- a/epan/dissectors/asn1/ros/packet-ros-template.c +++ b/epan/dissectors/asn1/ros/packet-ros-template.c @@ -513,7 +513,7 @@ void proto_register_ros(void) { expert_ros = expert_register_protocol(proto_ros); expert_register_field_array(expert_ros, ei, array_length(ei)); - ros_oid_dissector_table = register_dissector_table("ros.oid", "ROS OID Dissectors", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + ros_oid_dissector_table = register_dissector_table("ros.oid", "ROS OID Dissectors", proto_ros, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); oid_table=g_hash_table_new(g_str_hash, g_str_equal); protocol_table=g_hash_table_new(g_str_hash, g_str_equal); diff --git a/epan/dissectors/asn1/rtse/packet-rtse-template.c b/epan/dissectors/asn1/rtse/packet-rtse-template.c index 4cbba302c0..90681e46a6 100644 --- a/epan/dissectors/asn1/rtse/packet-rtse-template.c +++ b/epan/dissectors/asn1/rtse/packet-rtse-template.c @@ -402,7 +402,7 @@ void proto_register_rtse(void) { " \"Allow subdissectors to reassemble TCP streams\"" " in the TCP protocol settings.", &rtse_reassemble); - rtse_oid_dissector_table = register_dissector_table("rtse.oid", "RTSE OID Dissectors", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + rtse_oid_dissector_table = register_dissector_table("rtse.oid", "RTSE OID Dissectors", proto_rtse, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); oid_table=g_hash_table_new(g_str_hash, g_str_equal); diff --git a/epan/dissectors/asn1/rua/packet-rua-template.c b/epan/dissectors/asn1/rua/packet-rua-template.c index afb4d6e718..7b53c09059 100644 --- a/epan/dissectors/asn1/rua/packet-rua-template.c +++ b/epan/dissectors/asn1/rua/packet-rua-template.c @@ -151,11 +151,11 @@ module_t *rua_module; register_dissector("rua", dissect_rua, proto_rua); /* Register dissector tables */ - rua_ies_dissector_table = register_dissector_table("rua.ies", "RUA-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rua_extension_dissector_table = register_dissector_table("rua.extension", "RUA-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rua_proc_imsg_dissector_table = register_dissector_table("rua.proc.imsg", "RUA-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rua_proc_sout_dissector_table = register_dissector_table("rua.proc.sout", "RUA-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rua_proc_uout_dissector_table = register_dissector_table("rua.proc.uout", "RUA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rua_ies_dissector_table = register_dissector_table("rua.ies", "RUA-PROTOCOL-IES", proto_rua, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rua_extension_dissector_table = register_dissector_table("rua.extension", "RUA-PROTOCOL-EXTENSION", proto_rua, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rua_proc_imsg_dissector_table = register_dissector_table("rua.proc.imsg", "RUA-ELEMENTARY-PROCEDURE InitiatingMessage", proto_rua, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rua_proc_sout_dissector_table = register_dissector_table("rua.proc.sout", "RUA-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_rua, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rua_proc_uout_dissector_table = register_dissector_table("rua.proc.uout", "RUA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_rua, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); rua_module = prefs_register_protocol(proto_rua, proto_reg_handoff_rua); prefs_register_uint_preference(rua_module, "port", "RUA SCTP Port", "Set the port for RUA messages (Default of 29169)", 10, &global_sctp_port); diff --git a/epan/dissectors/asn1/s1ap/packet-s1ap-template.c b/epan/dissectors/asn1/s1ap/packet-s1ap-template.c index 4436def0bf..baef829615 100644 --- a/epan/dissectors/asn1/s1ap/packet-s1ap-template.c +++ b/epan/dissectors/asn1/s1ap/packet-s1ap-template.c @@ -277,13 +277,13 @@ void proto_register_s1ap(void) { register_dissector("s1ap", dissect_s1ap, proto_s1ap); /* Register dissector tables */ - s1ap_ies_dissector_table = register_dissector_table("s1ap.ies", "S1AP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - s1ap_ies_p1_dissector_table = register_dissector_table("s1ap.ies.pair.first", "S1AP-PROTOCOL-IES-PAIR FirstValue", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - s1ap_ies_p2_dissector_table = register_dissector_table("s1ap.ies.pair.second", "S1AP-PROTOCOL-IES-PAIR SecondValue", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - s1ap_extension_dissector_table = register_dissector_table("s1ap.extension", "S1AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - s1ap_proc_imsg_dissector_table = register_dissector_table("s1ap.proc.imsg", "S1AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - s1ap_proc_sout_dissector_table = register_dissector_table("s1ap.proc.sout", "S1AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - s1ap_proc_uout_dissector_table = register_dissector_table("s1ap.proc.uout", "S1AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + s1ap_ies_dissector_table = register_dissector_table("s1ap.ies", "S1AP-PROTOCOL-IES", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + s1ap_ies_p1_dissector_table = register_dissector_table("s1ap.ies.pair.first", "S1AP-PROTOCOL-IES-PAIR FirstValue", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + s1ap_ies_p2_dissector_table = register_dissector_table("s1ap.ies.pair.second", "S1AP-PROTOCOL-IES-PAIR SecondValue", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + s1ap_extension_dissector_table = register_dissector_table("s1ap.extension", "S1AP-PROTOCOL-EXTENSION", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + s1ap_proc_imsg_dissector_table = register_dissector_table("s1ap.proc.imsg", "S1AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + s1ap_proc_sout_dissector_table = register_dissector_table("s1ap.proc.sout", "S1AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + s1ap_proc_uout_dissector_table = register_dissector_table("s1ap.proc.uout", "S1AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Register configuration options for ports */ s1ap_module = prefs_register_protocol(proto_s1ap, proto_reg_handoff_s1ap); diff --git a/epan/dissectors/asn1/sabp/packet-sabp-template.c b/epan/dissectors/asn1/sabp/packet-sabp-template.c index a86c865a7f..8092845ca5 100644 --- a/epan/dissectors/asn1/sabp/packet-sabp-template.c +++ b/epan/dissectors/asn1/sabp/packet-sabp-template.c @@ -271,11 +271,11 @@ void proto_register_sabp(void) { register_dissector("sabp.tcp", dissect_sabp_tcp, proto_sabp); /* Register dissector tables */ - sabp_ies_dissector_table = register_dissector_table("sabp.ies", "SABP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sabp_extension_dissector_table = register_dissector_table("sabp.extension", "SABP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sabp_proc_imsg_dissector_table = register_dissector_table("sabp.proc.imsg", "SABP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sabp_proc_sout_dissector_table = register_dissector_table("sabp.proc.sout", "SABP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sabp_proc_uout_dissector_table = register_dissector_table("sabp.proc.uout", "SABP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sabp_ies_dissector_table = register_dissector_table("sabp.ies", "SABP-PROTOCOL-IES", proto_sabp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sabp_extension_dissector_table = register_dissector_table("sabp.extension", "SABP-PROTOCOL-EXTENSION", proto_sabp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sabp_proc_imsg_dissector_table = register_dissector_table("sabp.proc.imsg", "SABP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_sabp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sabp_proc_sout_dissector_table = register_dissector_table("sabp.proc.sout", "SABP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_sabp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sabp_proc_uout_dissector_table = register_dissector_table("sabp.proc.uout", "SABP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_sabp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/asn1/sbc-ap/packet-sbc-ap-template.c b/epan/dissectors/asn1/sbc-ap/packet-sbc-ap-template.c index 43fed62048..31f7a515ec 100644 --- a/epan/dissectors/asn1/sbc-ap/packet-sbc-ap-template.c +++ b/epan/dissectors/asn1/sbc-ap/packet-sbc-ap-template.c @@ -165,11 +165,11 @@ void proto_register_sbc_ap(void) { /* Register dissector tables */ - sbc_ap_ies_dissector_table = register_dissector_table("sbc_ap.ies", "SBC-AP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sbc_ap_extension_dissector_table = register_dissector_table("sbc_ap.extension", "SBC-AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sbc_ap_proc_imsg_dissector_table = register_dissector_table("sbc_ap.proc.imsg", "SBC-AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sbc_ap_proc_sout_dissector_table = register_dissector_table("sbc_ap.proc.sout", "SBC-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sbc_ap_proc_uout_dissector_table = register_dissector_table("sbc_ap.proc.uout", "SBC-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sbc_ap_ies_dissector_table = register_dissector_table("sbc_ap.ies", "SBC-AP-PROTOCOL-IES", proto_sbc_ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sbc_ap_extension_dissector_table = register_dissector_table("sbc_ap.extension", "SBC-AP-PROTOCOL-EXTENSION", proto_sbc_ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sbc_ap_proc_imsg_dissector_table = register_dissector_table("sbc_ap.proc.imsg", "SBC-AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_sbc_ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sbc_ap_proc_sout_dissector_table = register_dissector_table("sbc_ap.proc.sout", "SBC-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_sbc_ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sbc_ap_proc_uout_dissector_table = register_dissector_table("sbc_ap.proc.uout", "SBC-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_sbc_ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/asn1/snmp/packet-snmp-template.c b/epan/dissectors/asn1/snmp/packet-snmp-template.c index f5a6b6eda8..b76b79a159 100644 --- a/epan/dissectors/asn1/snmp/packet-snmp-template.c +++ b/epan/dissectors/asn1/snmp/packet-snmp-template.c @@ -2576,7 +2576,7 @@ void proto_register_snmp(void) { "MIB settings can be changed in the Name Resolution preferences"); #endif - value_sub_dissectors_table = register_dissector_table("snmp.variable_oid","SNMP Variable OID", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + value_sub_dissectors_table = register_dissector_table("snmp.variable_oid","SNMP Variable OID", proto_snmp, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); register_init_routine(init_ue_cache); register_cleanup_routine(cleanup_ue_cache); diff --git a/epan/dissectors/asn1/t124/packet-t124-template.c b/epan/dissectors/asn1/t124/packet-t124-template.c index db299b544c..79c449a5c3 100644 --- a/epan/dissectors/asn1/t124/packet-t124-template.c +++ b/epan/dissectors/asn1/t124/packet-t124-template.c @@ -203,8 +203,8 @@ void proto_register_t124(void) { proto_register_field_array(proto_t124, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - t124_ns_dissector_table = register_dissector_table("t124.ns", "T.124 H.221 Non Standard Dissectors", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - t124_sd_dissector_table = register_dissector_table("t124.sd", "T.124 H.221 Send Data Dissectors", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + t124_ns_dissector_table = register_dissector_table("t124.ns", "T.124 H.221 Non Standard Dissectors", proto_t124, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + t124_sd_dissector_table = register_dissector_table("t124.sd", "T.124 H.221 Send Data Dissectors", proto_t124, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); register_dissector("t124", dissect_t124, proto_t124); diff --git a/epan/dissectors/asn1/t125/packet-t125-template.c b/epan/dissectors/asn1/t125/packet-t125-template.c index b51c37e507..7efb49ed1f 100644 --- a/epan/dissectors/asn1/t125/packet-t125-template.c +++ b/epan/dissectors/asn1/t125/packet-t125-template.c @@ -137,7 +137,7 @@ void proto_register_t125(void) { proto_register_field_array(proto_t125, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - t125_heur_subdissector_list= register_heur_dissector_list("t125"); + t125_heur_subdissector_list= register_heur_dissector_list("t125", proto_t125); register_dissector("t125", dissect_t125, proto_t125); } diff --git a/epan/dissectors/asn1/x2ap/packet-x2ap-template.c b/epan/dissectors/asn1/x2ap/packet-x2ap-template.c index e6c7984515..7e5e149307 100644 --- a/epan/dissectors/asn1/x2ap/packet-x2ap-template.c +++ b/epan/dissectors/asn1/x2ap/packet-x2ap-template.c @@ -164,11 +164,11 @@ void proto_register_x2ap(void) { register_dissector("x2ap", dissect_x2ap, proto_x2ap); /* Register dissector tables */ - x2ap_ies_dissector_table = register_dissector_table("x2ap.ies", "X2AP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - x2ap_extension_dissector_table = register_dissector_table("x2ap.extension", "X2AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - x2ap_proc_imsg_dissector_table = register_dissector_table("x2ap.proc.imsg", "X2AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - x2ap_proc_sout_dissector_table = register_dissector_table("x2ap.proc.sout", "X2AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - x2ap_proc_uout_dissector_table = register_dissector_table("x2ap.proc.uout", "X2AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + x2ap_ies_dissector_table = register_dissector_table("x2ap.ies", "X2AP-PROTOCOL-IES", proto_x2ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + x2ap_extension_dissector_table = register_dissector_table("x2ap.extension", "X2AP-PROTOCOL-EXTENSION", proto_x2ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + x2ap_proc_imsg_dissector_table = register_dissector_table("x2ap.proc.imsg", "X2AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_x2ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + x2ap_proc_sout_dissector_table = register_dissector_table("x2ap.proc.sout", "X2AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_x2ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + x2ap_proc_uout_dissector_table = register_dissector_table("x2ap.proc.uout", "X2AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_x2ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Register configuration options for ports */ x2ap_module = prefs_register_protocol(proto_x2ap, proto_reg_handoff_x2ap); diff --git a/epan/dissectors/file-file.c b/epan/dissectors/file-file.c index d15890de94..625a908e0c 100644 --- a/epan/dissectors/file-file.c +++ b/epan/dissectors/file-file.c @@ -398,14 +398,14 @@ proto_register_file(void) module_t *file_module; #endif - file_encap_dissector_table = register_dissector_table("ftap_encap", - "Filetap encapsulation type", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - proto_file = proto_register_protocol("File", "File", "file"); proto_register_field_array(proto_file, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); register_dissector("file",dissect_file_record,proto_file); + file_encap_dissector_table = register_dissector_table("ftap_encap", + "Filetap encapsulation type", proto_file, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + /* You can't disable dissection of "Frame", as that would be tantamount to not doing any dissection whatsoever. */ proto_set_cant_toggle(proto_file); diff --git a/epan/dissectors/packet-aeron.c b/epan/dissectors/packet-aeron.c index 86fa70bc63..20a05657ac 100644 --- a/epan/dissectors/packet-aeron.c +++ b/epan/dissectors/packet-aeron.c @@ -3103,7 +3103,7 @@ void proto_register_aeron(void) expert_aeron = expert_register_protocol(proto_aeron); expert_register_field_array(expert_aeron, ei, array_length(ei)); aeron_module = prefs_register_protocol(proto_aeron, proto_reg_handoff_aeron); - aeron_heuristic_subdissector_list = register_heur_dissector_list("aeron_msg_payload"); + aeron_heuristic_subdissector_list = register_heur_dissector_list("aeron_msg_payload", proto_aeron); prefs_register_bool_preference(aeron_module, "sequence_analysis", diff --git a/epan/dissectors/packet-ansi_637.c b/epan/dissectors/packet-ansi_637.c index fe2ac44b8f..2f2d5644eb 100644 --- a/epan/dissectors/packet-ansi_637.c +++ b/epan/dissectors/packet-ansi_637.c @@ -3346,7 +3346,7 @@ proto_register_ansi_637(void) tele_dissector_table = register_dissector_table("ansi_637.tele_id", - "ANSI IS-637-A Teleservice ID", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "ANSI IS-637-A Teleservice ID", proto_ansi_637_tele, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-ansi_a.c b/epan/dissectors/packet-ansi_a.c index 0cf5b8a353..e8673c07e6 100644 --- a/epan/dissectors/packet-ansi_a.c +++ b/epan/dissectors/packet-ansi_a.c @@ -12865,15 +12865,15 @@ proto_register_ansi_a(void) is637_dissector_table = register_dissector_table("ansi_a.sms", "IS-637-A (SMS)", - FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_a_bsmap, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); is683_dissector_table = register_dissector_table("ansi_a.ota", "IS-683-A (OTA)", - FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_a_bsmap, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); is801_dissector_table = register_dissector_table("ansi_a.pld", "IS-801 (PLD)", - FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_a_bsmap, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); proto_register_subtree_array(ett, ett_len / (int) sizeof(gint *)); diff --git a/epan/dissectors/packet-ansi_map.c b/epan/dissectors/packet-ansi_map.c index 6b7da6e52b..df9736a472 100644 --- a/epan/dissectors/packet-ansi_map.c +++ b/epan/dissectors/packet-ansi_map.c @@ -19533,15 +19533,15 @@ void proto_register_ansi_map(void) { register_dissector("ansi_map", dissect_ansi_map, proto_ansi_map); is637_tele_id_dissector_table = - register_dissector_table("ansi_map.tele_id", "IS-637 Teleservice ID", + register_dissector_table("ansi_map.tele_id", "IS-637 Teleservice ID", proto_ansi_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); is683_dissector_table = - register_dissector_table("ansi_map.ota", "IS-683-A (OTA)", + register_dissector_table("ansi_map.ota", "IS-683-A (OTA)", proto_ansi_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); is801_dissector_table = - register_dissector_table("ansi_map.pld", "IS-801 (PLD)", + register_dissector_table("ansi_map.pld", "IS-801 (PLD)", proto_ansi_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); ansi_map_tap = register_tap("ansi_map"); diff --git a/epan/dissectors/packet-ansi_tcap.c b/epan/dissectors/packet-ansi_tcap.c index 6e5960104d..62942f2cc1 100644 --- a/epan/dissectors/packet-ansi_tcap.c +++ b/epan/dissectors/packet-ansi_tcap.c @@ -1814,7 +1814,7 @@ proto_register_ansi_tcap(void) register_dissector("ansi_tcap", dissect_ansi_tcap, proto_ansi_tcap); /* Note the high bit should be masked off when registering in this table (0x7fff)*/ - ansi_tcap_national_opcode_table = register_dissector_table("ansi_tcap.nat.opcode", "ANSI TCAP National Opcodes", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ansi_tcap_national_opcode_table = register_dissector_table("ansi_tcap.nat.opcode", "ANSI TCAP National Opcodes", proto_ansi_tcap, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_ansi_tcap, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); diff --git a/epan/dissectors/packet-arcnet.c b/epan/dissectors/packet-arcnet.c index 3c60c40b62..9338a393b8 100644 --- a/epan/dissectors/packet-arcnet.c +++ b/epan/dissectors/packet-arcnet.c @@ -385,10 +385,6 @@ proto_register_arcnet (void) &ett_arcnet, }; - arcnet_dissector_table = register_dissector_table ("arcnet.protocol_id", - "ARCNET Protocol ID", - FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - /* Register the protocol name and description */ proto_arcnet = proto_register_protocol ("ARCNET", "ARCNET", "arcnet"); @@ -396,6 +392,9 @@ proto_register_arcnet (void) proto_register_field_array (proto_arcnet, hf, array_length (hf)); proto_register_subtree_array (ett, array_length (ett)); + arcnet_dissector_table = register_dissector_table ("arcnet.protocol_id", "ARCNET Protocol ID", + proto_arcnet, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + arcnet_address_type = address_type_dissector_register("AT_ARCNET", "ARCNET Address", arcnet_to_str, arcnet_str_len, arcnet_col_filter_str, arcnet_len, NULL, NULL); } diff --git a/epan/dissectors/packet-aruba-erm.c b/epan/dissectors/packet-aruba-erm.c index 65540b4b23..de217b7007 100644 --- a/epan/dissectors/packet-aruba-erm.c +++ b/epan/dissectors/packet-aruba-erm.c @@ -460,7 +460,7 @@ proto_register_aruba_erm(void) expert_register_field_array(expert_aruba_erm, ei, array_length(ei)); aruba_erm_subdissector_table = register_dissector_table( - "aruba_erm.type", "Aruba ERM Type", + "aruba_erm.type", "Aruba ERM Type", proto_aruba_erm, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_decode_as(&aruba_erm_payload_da); diff --git a/epan/dissectors/packet-atalk.c b/epan/dissectors/packet-atalk.c index 5c1b11174b..85965e44b6 100644 --- a/epan/dissectors/packet-atalk.c +++ b/epan/dissectors/packet-atalk.c @@ -2074,7 +2074,7 @@ proto_register_atalk(void) proto_register_subtree_array(ett, array_length(ett)); /* subdissector code */ - ddp_dissector_table = register_dissector_table("ddp.type", "DDP packet type", + ddp_dissector_table = register_dissector_table("ddp.type", "DDP packet type", proto_ddp, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); atalk_address_type = address_type_dissector_register("AT_ATALK", "Appletalk DDP", atalk_to_str, atalk_str_len, atalk_col_filter_str, atalk_len, NULL, NULL); diff --git a/epan/dissectors/packet-atm.c b/epan/dissectors/packet-atm.c index 7634a7586b..bbf65e7076 100644 --- a/epan/dissectors/packet-atm.c +++ b/epan/dissectors/packet-atm.c @@ -1980,8 +1980,8 @@ proto_register_atm(void) proto_atm_lane = proto_register_protocol("ATM LAN Emulation", "ATM LANE", "lane"); - atm_type_aal2_table = register_dissector_table("atm.aal2.type", "ATM AAL_2 type subdissector", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - atm_type_aal5_table = register_dissector_table("atm.aal5.type", "ATM AAL_5 type subdissector", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + atm_type_aal2_table = register_dissector_table("atm.aal2.type", "ATM AAL_2 type subdissector", proto_atm, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + atm_type_aal5_table = register_dissector_table("atm.aal5.type", "ATM AAL_5 type subdissector", proto_atm, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_capture_dissector_table("atm.aal5.type", "ATM AAL_5"); register_capture_dissector_table("atm_lane", "ATM LAN Emulation"); diff --git a/epan/dissectors/packet-atn-ulcs.c b/epan/dissectors/packet-atn-ulcs.c index f001e3179a..d91d024a42 100644 --- a/epan/dissectors/packet-atn-ulcs.c +++ b/epan/dissectors/packet-atn-ulcs.c @@ -2596,7 +2596,7 @@ void proto_register_atn_ulcs (void) atn_cpdlc_handle = find_dissector("atn-cpdlc"); /* initiate sub dissector list */ - atn_ulcs_heur_subdissector_list = register_heur_dissector_list("atn-ulcs"); + atn_ulcs_heur_subdissector_list = register_heur_dissector_list("atn-ulcs", proto_atn_ulcs); /* init aare/aare data */ aarq_data_tree = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); diff --git a/epan/dissectors/packet-ax25.c b/epan/dissectors/packet-ax25.c index c9591df9fe..7eadce8e1d 100644 --- a/epan/dissectors/packet-ax25.c +++ b/epan/dissectors/packet-ax25.c @@ -411,7 +411,7 @@ proto_register_ax25(void) proto_register_subtree_array(ett, array_length(ett ) ); /* Register dissector table for protocol IDs */ - ax25_dissector_table = register_dissector_table("ax25.pid", "AX.25 protocol ID", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + ax25_dissector_table = register_dissector_table("ax25.pid", "AX.25 protocol ID", proto_ax25, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_capture_dissector_table("ax25.pid", "AX.25"); } diff --git a/epan/dissectors/packet-bacapp.c b/epan/dissectors/packet-bacapp.c index e392b73afc..ac831dc877 100644 --- a/epan/dissectors/packet-bacapp.c +++ b/epan/dissectors/packet-bacapp.c @@ -11316,7 +11316,7 @@ proto_register_bacapp(void) register_cleanup_routine(&bacapp_cleanup_routine); bacapp_dissector_table = register_dissector_table("bacapp.vendor_identifier", - "BACapp Vendor Identifier", + "BACapp Vendor Identifier", proto_bacapp, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Register BACnet Statistic trees */ diff --git a/epan/dissectors/packet-bacnet.c b/epan/dissectors/packet-bacnet.c index 194d243413..20f202d89a 100644 --- a/epan/dissectors/packet-bacnet.c +++ b/epan/dissectors/packet-bacnet.c @@ -621,7 +621,7 @@ proto_register_bacnet(void) register_dissector("bacnet", dissect_bacnet, proto_bacnet); bacnet_dissector_table = register_dissector_table("bacnet.vendor", - "BACnet Vendor Identifier", + "BACnet Vendor Identifier", proto_bacnet, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-bctp.c b/epan/dissectors/packet-bctp.c index 9e6bcd144b..a46685873e 100644 --- a/epan/dissectors/packet-bctp.c +++ b/epan/dissectors/packet-bctp.c @@ -108,7 +108,7 @@ proto_register_bctp (void) register_dissector("bctp", dissect_bctp, proto_bctp); - bctp_dissector_table = register_dissector_table("bctp.tpi", "BCTP Tunneled Protocol Indicator", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + bctp_dissector_table = register_dissector_table("bctp.tpi", "BCTP Tunneled Protocol Indicator", proto_bctp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-ber.c b/epan/dissectors/packet-ber.c index 43dffa438c..6ef738b436 100644 --- a/epan/dissectors/packet-ber.c +++ b/epan/dissectors/packet-ber.c @@ -4573,8 +4573,8 @@ proto_register_ber(void) " and the syntax of any associated values", users_uat); - ber_oid_dissector_table = register_dissector_table("ber.oid", "BER OID Dissectors", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ber_syntax_dissector_table = register_dissector_table("ber.syntax", "BER syntax", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ber_oid_dissector_table = register_dissector_table("ber.oid", "BER OID Dissectors", proto_ber, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ber_syntax_dissector_table = register_dissector_table("ber.syntax", "BER syntax", proto_ber, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); syntax_table = g_hash_table_new(g_str_hash, g_str_equal); /* oid to syntax */ register_ber_syntax_dissector("ASN.1", proto_ber, dissect_ber_syntax); diff --git a/epan/dissectors/packet-bitcoin.c b/epan/dissectors/packet-bitcoin.c index 091582c1a9..4c00209bff 100644 --- a/epan/dissectors/packet-bitcoin.c +++ b/epan/dissectors/packet-bitcoin.c @@ -1861,7 +1861,7 @@ proto_register_bitcoin(void) expert_bitcoin = expert_register_protocol(proto_bitcoin); expert_register_field_array(expert_bitcoin, ei, array_length(ei)); - bitcoin_command_table = register_dissector_table("bitcoin.command", "Bitcoin Command", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + bitcoin_command_table = register_dissector_table("bitcoin.command", "Bitcoin Command", proto_bitcoin, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); bitcoin_handle = register_dissector("bitcoin", dissect_bitcoin, proto_bitcoin); diff --git a/epan/dissectors/packet-bluetooth.c b/epan/dissectors/packet-bluetooth.c index ed4f07acae..002a8d7f39 100644 --- a/epan/dissectors/packet-bluetooth.c +++ b/epan/dissectors/packet-bluetooth.c @@ -3,6 +3,10 @@ * * Copyright 2014, Michal Labedzki for Tieto Corporation * + * Dissector for Bluetooth High Speed over wireless + * Copyright 2012 intel Corp. + * Written by Andrei Emeltchenko at intel dot com + * * Wireshark - Network traffic analyzer * By Gerald Combs * Copyright 1998 Gerald Combs @@ -31,6 +35,8 @@ #include #include #include +#include "packet-llc.h" +#include #include "packet-bluetooth.h" @@ -43,6 +49,8 @@ static int hf_bluetooth_str_src = -1; static int hf_bluetooth_str_dst = -1; static int hf_bluetooth_str_addr = -1; +static int hf_llc_bluetooth_pid = -1; + static gint ett_bluetooth = -1; static dissector_handle_t btle_handle; @@ -1399,6 +1407,28 @@ const value_string bluetooth_address_type_vals[] = { { 0, NULL } }; +/* + * BLUETOOTH SPECIFICATION Version 4.0 [Vol 5] defines that + * before transmission, the PAL shall remove the HCI header, + * add LLC and SNAP headers and insert an 802.11 MAC header. + * Protocol identifier are described in Table 5.2. + */ + +#define AMP_U_L2CAP 0x0001 +#define AMP_C_ACTIVITY_REPORT 0x0002 +#define AMP_C_SECURITY_FRAME 0x0003 +#define AMP_C_LINK_SUP_REQUEST 0x0004 +#define AMP_C_LINK_SUP_REPLY 0x0005 + +static const value_string bluetooth_pid_vals[] = { + { AMP_U_L2CAP, "AMP_U L2CAP ACL data" }, + { AMP_C_ACTIVITY_REPORT, "AMP-C Activity Report" }, + { AMP_C_SECURITY_FRAME, "AMP-C Security frames" }, + { AMP_C_LINK_SUP_REQUEST, "AMP-C Link supervision request" }, + { AMP_C_LINK_SUP_REPLY, "AMP-C Link supervision reply" }, + { 0, NULL } +}; + guint32 max_disconnect_in_frame = G_MAXUINT32; @@ -1960,6 +1990,14 @@ proto_register_bluetooth(void) }, }; + static hf_register_info oui_hf[] = { + { &hf_llc_bluetooth_pid, + { "PID", "llc.bluetooth_pid", + FT_UINT16, BASE_HEX, VALS(bluetooth_pid_vals), 0x0, + "Protocol ID", HFILL } + } + }; + static gint *ett[] = { &ett_bluetooth, }; @@ -1980,7 +2018,7 @@ proto_register_bluetooth(void) proto_register_subtree_array(ett, array_length(ett)); bluetooth_table = register_dissector_table("bluetooth.encap", - "Bluetooth Encapsulation", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "Bluetooth Encapsulation", proto_bluetooth, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); chandle_sessions = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); chandle_to_bdaddr = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); @@ -1991,14 +2029,15 @@ proto_register_bluetooth(void) localhost_name = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); hci_vendors = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); - hci_vendor_table = register_dissector_table("bluetooth.vendor", "HCI Vendor", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + hci_vendor_table = register_dissector_table("bluetooth.vendor", "HCI Vendor", proto_bluetooth, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); bluetooth_uuids = wmem_tree_new(wmem_epan_scope()); bluetooth_tap = register_tap("bluetooth"); bluetooth_device_tap = register_tap("bluetooth.device"); bluetooth_hci_summary_tap = register_tap("bluetooth.hci_summary"); - bluetooth_uuid_table = register_dissector_table("bluetooth.uuid", "BT Service UUID", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + bluetooth_uuid_table = register_dissector_table("bluetooth.uuid", "BT Service UUID", proto_bluetooth, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + llc_add_oui(OUI_BLUETOOTH, "llc.bluetooth_pid", "LLC Bluetooth OUI PID", oui_hf, proto_bluetooth); register_conversation_table(proto_bluetooth, TRUE, bluetooth_conversation_packet, bluetooth_hostlist_packet); @@ -2012,6 +2051,8 @@ proto_reg_handoff_bluetooth(void) dissector_handle_t bluetooth_bthci_handle = create_dissector_handle(dissect_bluetooth_bthci, proto_bluetooth); dissector_handle_t bluetooth_btmon_handle = create_dissector_handle(dissect_bluetooth_btmon, proto_bluetooth); dissector_handle_t bluetooth_usb_handle = create_dissector_handle(dissect_bluetooth_usb, proto_bluetooth); + dissector_handle_t eapol_handle; + dissector_handle_t btl2cap_handle; btle_handle = find_dissector("btle"); data_handle = find_dissector("data"); @@ -2042,6 +2083,13 @@ proto_reg_handoff_bluetooth(void) wmem_tree_insert_string(bluetooth_uuids, "00000001-0000-1000-8000-0002EE000002", "SyncML Server", 0); wmem_tree_insert_string(bluetooth_uuids, "00000002-0000-1000-8000-0002EE000002", "SyncML Client", 0); + + eapol_handle = find_dissector("eapol"); + btl2cap_handle = find_dissector("btl2cap"); + + dissector_add_uint("llc.bluetooth_pid", AMP_C_SECURITY_FRAME, eapol_handle); + dissector_add_uint("llc.bluetooth_pid", AMP_U_L2CAP, btl2cap_handle); + /* TODO: Add UUID128 verion of UUID16; UUID32? UUID16? */ } diff --git a/epan/dissectors/packet-bssap.c b/epan/dissectors/packet-bssap.c index 83e74eecbb..94e13d6b13 100644 --- a/epan/dissectors/packet-bssap.c +++ b/epan/dissectors/packet-bssap.c @@ -2546,8 +2546,8 @@ proto_register_bssap(void) "Subsystem number used for BSSAP", "Set Subsystem number used for BSSAP/BSSAP+", 10, &global_bssap_ssn); - bssap_dissector_table = register_dissector_table("bssap.pdu_type", "BSSAP Message Type", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - bsap_dissector_table = register_dissector_table("bsap.pdu_type", "BSAP Message Type", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + bssap_dissector_table = register_dissector_table("bssap.pdu_type", "BSSAP Message Type", proto_bssap, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + bsap_dissector_table = register_dissector_table("bsap.pdu_type", "BSAP Message Type", proto_bssap, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-bt-oui.c b/epan/dissectors/packet-bt-oui.c deleted file mode 100644 index 6388b08c82..0000000000 --- a/epan/dissectors/packet-bt-oui.c +++ /dev/null @@ -1,99 +0,0 @@ -/* packet-bt-oui.c - * Dissector for Bluetooth High Speed over wireless - * Copyright 2012 intel Corp. - * Written by Andrei Emeltchenko at intel dot com - * - * Wireshark - Network traffic analyzer - * By Gerald Combs - * 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. - */ - -#include "config.h" - -#include -#include "packet-llc.h" -#include - -static int hf_llc_bluetooth_pid = -1; - -/* - * BLUETOOTH SPECIFICATION Version 4.0 [Vol 5] defines that - * before transmission, the PAL shall remove the HCI header, - * add LLC and SNAP headers and insert an 802.11 MAC header. - * Protocol identifier are described in Table 5.2. - */ - -#define AMP_U_L2CAP 0x0001 -#define AMP_C_ACTIVITY_REPORT 0x0002 -#define AMP_C_SECURITY_FRAME 0x0003 -#define AMP_C_LINK_SUP_REQUEST 0x0004 -#define AMP_C_LINK_SUP_REPLY 0x0005 - -static const value_string bluetooth_pid_vals[] = { - { AMP_U_L2CAP, "AMP_U L2CAP ACL data" }, - { AMP_C_ACTIVITY_REPORT, "AMP-C Activity Report" }, - { AMP_C_SECURITY_FRAME, "AMP-C Security frames" }, - { AMP_C_LINK_SUP_REQUEST, "AMP-C Link supervision request" }, - { AMP_C_LINK_SUP_REPLY, "AMP-C Link supervision reply" }, - { 0, NULL } -}; - -void proto_register_bt_oui(void); -void proto_reg_handoff_bt_oui(void); - -/* - * NOTE: there's no dissector here, just registration routines to set - * up the dissector table for the Bluetooth OUI - */ - -void proto_reg_handoff_bt_oui(void) -{ - dissector_handle_t eapol_handle; - dissector_handle_t btl2cap_handle; - - eapol_handle = find_dissector("eapol"); - btl2cap_handle = find_dissector("btl2cap"); - - dissector_add_uint("llc.bluetooth_pid", AMP_C_SECURITY_FRAME, eapol_handle); - dissector_add_uint("llc.bluetooth_pid", AMP_U_L2CAP, btl2cap_handle); -} - - -void proto_register_bt_oui(void) -{ - static hf_register_info hf[] = { - { &hf_llc_bluetooth_pid, - { "PID", "llc.bluetooth_pid", FT_UINT16, BASE_HEX, - VALS(bluetooth_pid_vals), 0x0, "Protocol ID", HFILL } - } - }; - - llc_add_oui(OUI_BLUETOOTH, "llc.bluetooth_pid", "LLC Bluetooth OUI PID", hf); -} - -/* - * Editor modelines - http://www.wireshark.org/tools/modelines.html - * - * Local variables: - * c-basic-offset: 8 - * tab-width: 8 - * indent-tabs-mode: t - * End: - * - * vi: set shiftwidth=8 tabstop=8 noexpandtab: - * :indentSize=8:tabSize=8:noTabs=false: - */ diff --git a/epan/dissectors/packet-btatt.c b/epan/dissectors/packet-btatt.c index c17f47b095..c02c5ce8a1 100644 --- a/epan/dissectors/packet-btatt.c +++ b/epan/dissectors/packet-btatt.c @@ -14021,7 +14021,7 @@ proto_register_btatt(void) btatt_handle = register_dissector("btatt", dissect_btatt, proto_btatt); - att_handle_dissector_table = register_dissector_table("btatt.handle", "BT ATT Handle", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + att_handle_dissector_table = register_dissector_table("btatt.handle", "BT ATT Handle", proto_btatt, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_btatt, hf, array_length(hf)); diff --git a/epan/dissectors/packet-bthci_cmd.c b/epan/dissectors/packet-bthci_cmd.c index a2cef60a1c..e6da159800 100644 --- a/epan/dissectors/packet-bthci_cmd.c +++ b/epan/dissectors/packet-bthci_cmd.c @@ -4961,7 +4961,7 @@ proto_register_bthci_cmd(void) bthci_cmds = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); - vendor_dissector_table = register_dissector_table("bthci_cmd.vendor", "BT HCI Vendor", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + vendor_dissector_table = register_dissector_table("bthci_cmd.vendor", "BT HCI Vendor", proto_bthci_cmd, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); module = prefs_register_protocol(proto_bthci_cmd, NULL); prefs_register_static_text_preference(module, "hci_cmd.version", @@ -6554,8 +6554,8 @@ proto_register_btcommon(void) btcommon_cod_handle = register_dissector("btcommon.cod", dissect_btcommon_cod, proto_btcommon); btcommon_le_channel_map_handle = register_dissector("btcommon.le_channel_map", dissect_btcommon_le_channel_map, proto_btcommon); - bluetooth_eir_ad_manufacturer_company_id = register_dissector_table("btcommon.eir_ad.manufacturer_company_id", "BT EIR/AD Manufacturer Company ID", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - bluetooth_eir_ad_tds_organization_id = register_dissector_table("btcommon.eir_ad.tds_organization_id", "BT EIR/AD TDS Organization ID", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + bluetooth_eir_ad_manufacturer_company_id = register_dissector_table("btcommon.eir_ad.manufacturer_company_id", "BT EIR/AD Manufacturer Company ID", proto_btcommon, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + bluetooth_eir_ad_tds_organization_id = register_dissector_table("btcommon.eir_ad.tds_organization_id", "BT EIR/AD TDS Organization ID", proto_btcommon, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_decode_as(&bluetooth_eir_ad_manufacturer_company_id_da); register_decode_as(&bluetooth_eir_ad_tds_organization_id_da); diff --git a/epan/dissectors/packet-btl2cap.c b/epan/dissectors/packet-btl2cap.c index 888c283df3..d30f3407ea 100644 --- a/epan/dissectors/packet-btl2cap.c +++ b/epan/dissectors/packet-btl2cap.c @@ -2830,8 +2830,8 @@ proto_register_btl2cap(void) register_dissector("btl2cap", dissect_btl2cap, proto_btl2cap); /* subdissector code */ - l2cap_psm_dissector_table = register_dissector_table("btl2cap.psm", "BT L2CAP PSM", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - l2cap_cid_dissector_table = register_dissector_table("btl2cap.cid", "BT L2CAP CID", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + l2cap_psm_dissector_table = register_dissector_table("btl2cap.psm", "BT L2CAP PSM", proto_btl2cap, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + l2cap_cid_dissector_table = register_dissector_table("btl2cap.cid", "BT L2CAP CID", proto_btl2cap, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_btl2cap, hf, array_length(hf)); diff --git a/epan/dissectors/packet-btrfcomm.c b/epan/dissectors/packet-btrfcomm.c index 5c12b890dd..6bab3c8b13 100644 --- a/epan/dissectors/packet-btrfcomm.c +++ b/epan/dissectors/packet-btrfcomm.c @@ -1140,7 +1140,7 @@ proto_register_btrfcomm(void) service_directions = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); - rfcomm_dlci_dissector_table = register_dissector_table("btrfcomm.dlci", "BT RFCOMM Directed Channel", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + rfcomm_dlci_dissector_table = register_dissector_table("btrfcomm.dlci", "BT RFCOMM Directed Channel", proto_btrfcomm, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); module = prefs_register_protocol(proto_btrfcomm, NULL); prefs_register_static_text_preference(module, "rfcomm.version", diff --git a/epan/dissectors/packet-bvlc.c b/epan/dissectors/packet-bvlc.c index 3da6bf0b5c..51bbf0b613 100644 --- a/epan/dissectors/packet-bvlc.c +++ b/epan/dissectors/packet-bvlc.c @@ -408,7 +408,7 @@ proto_register_bvlc(void) register_dissector("bvlc", dissect_bvlc, proto_bvlc); bvlc_dissector_table = register_dissector_table("bvlc.function", - "BVLC Function", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "BVLC Function", proto_bvlc, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-c15ch.c b/epan/dissectors/packet-c15ch.c index f72050ab15..90e5461dc4 100644 --- a/epan/dissectors/packet-c15ch.c +++ b/epan/dissectors/packet-c15ch.c @@ -11972,7 +11972,7 @@ void proto_register_c15ch(void) ); proto_register_field_array(proto_c15ch_second_level, hf_second_level, array_length(hf_second_level)); proto_register_subtree_array(ett_second_level, array_length(ett_second_level)); - c15ch_dissector_table = register_dissector_table("c15", "C15", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + c15ch_dissector_table = register_dissector_table("c15", "C15", proto_c15ch, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* third level */ /* tone */ @@ -11983,7 +11983,7 @@ void proto_register_c15ch(void) ); proto_register_field_array(proto_c15ch_third_level_tone, hf_third_level_tone, array_length(hf_third_level_tone)); proto_register_subtree_array(ett_third_level_tone, array_length(ett_third_level_tone)); - c15ch_tone_dissector_table = register_dissector_table("c15.tone", "C15.TONE", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + c15ch_tone_dissector_table = register_dissector_table("c15.tone", "C15.TONE", proto_c15ch_third_level_tone, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* inc gwe */ proto_c15ch_third_level_inc_gwe = proto_register_protocol( @@ -11993,7 +11993,7 @@ void proto_register_c15ch(void) ); proto_register_field_array(proto_c15ch_third_level_inc_gwe, hf_third_level_inc_gwe, array_length(hf_third_level_inc_gwe)); proto_register_subtree_array(ett_third_level_inc_gwe, array_length(ett_third_level_inc_gwe)); - c15ch_inc_gwe_dissector_table = register_dissector_table("c15.inc_gwe", "C15.INC_GWE", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + c15ch_inc_gwe_dissector_table = register_dissector_table("c15.inc_gwe", "C15.INC_GWE", proto_c15ch_third_level_inc_gwe, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* out gwe */ proto_c15ch_third_level_out_gwe = proto_register_protocol( @@ -12003,7 +12003,7 @@ void proto_register_c15ch(void) ); proto_register_field_array(proto_c15ch_third_level_out_gwe, hf_third_level_out_gwe, array_length(hf_third_level_out_gwe)); proto_register_subtree_array(ett_third_level_out_gwe, array_length(ett_third_level_out_gwe)); - c15ch_out_gwe_dissector_table = register_dissector_table("c15.out_gwe", "C15.out_gwe", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + c15ch_out_gwe_dissector_table = register_dissector_table("c15.out_gwe", "C15.out_gwe", proto_c15ch_third_level_out_gwe, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-camel.c b/epan/dissectors/packet-camel.c index 742802d812..942ab8bb25 100644 --- a/epan/dissectors/packet-camel.c +++ b/epan/dissectors/packet-camel.c @@ -10682,13 +10682,13 @@ void proto_register_camel(void) { /* Register dissector tables */ camel_rose_ctx.arg_local_dissector_table = register_dissector_table("camel.ros.local.arg", - "CAMEL Operation Argument (local opcode)", + "CAMEL Operation Argument (local opcode)", proto_camel, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); camel_rose_ctx.res_local_dissector_table = register_dissector_table("camel.ros.local.res", - "CAMEL Operation Result (local opcode)", + "CAMEL Operation Result (local opcode)", proto_camel, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); camel_rose_ctx.err_local_dissector_table = register_dissector_table("camel.ros.local.err", - "CAMEL Error (local opcode)", + "CAMEL Error (local opcode)", proto_camel, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Register our configuration options, particularly our SSNs */ diff --git a/epan/dissectors/packet-ccsds.c b/epan/dissectors/packet-ccsds.c index f857499f99..923555649c 100644 --- a/epan/dissectors/packet-ccsds.c +++ b/epan/dissectors/packet-ccsds.c @@ -718,7 +718,7 @@ proto_register_ccsds(void) &global_dissect_checkword, dissect_checkword, FALSE); /* Dissector table for sub-dissetors */ - ccsds_dissector_table = register_dissector_table("ccsds.apid", "CCSDS apid", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + ccsds_dissector_table = register_dissector_table("ccsds.apid", "CCSDS apid", proto_ccsds, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-chdlc.c b/epan/dissectors/packet-chdlc.c index 72284984c3..06392c31b1 100644 --- a/epan/dissectors/packet-chdlc.c +++ b/epan/dissectors/packet-chdlc.c @@ -232,7 +232,7 @@ proto_register_chdlc(void) /* subdissector code */ subdissector_table = register_dissector_table("chdlc.protocol", - "Cisco HDLC protocol", + "Cisco HDLC protocol", proto_chdlc, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_dissector("chdlc", dissect_chdlc, proto_chdlc); diff --git a/epan/dissectors/packet-cimetrics.c b/epan/dissectors/packet-cimetrics.c index 0d780088e9..fe19276e8e 100644 --- a/epan/dissectors/packet-cimetrics.c +++ b/epan/dissectors/packet-cimetrics.c @@ -118,7 +118,7 @@ proto_register_cimetrics(void) proto_cimetrics_mstp); llc_add_oui(OUI_CIMETRICS, "llc.cimetrics_pid", - "LLC Cimetrics OUI PID", hf2); + "LLC Cimetrics OUI PID", hf2, proto_cimetrics_mstp); } void diff --git a/epan/dissectors/packet-cip.c b/epan/dissectors/packet-cip.c index 4541bd01df..bbb07fbe25 100644 --- a/epan/dissectors/packet-cip.c +++ b/epan/dissectors/packet-cip.c @@ -7987,9 +7987,9 @@ proto_register_cip(void) &cip_enhanced_info_column); subdissector_class_table = register_dissector_table("cip.class.iface", - "CIP Class Interface Handle", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "CIP Class Interface Handle", proto_cip, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); subdissector_symbol_table = register_dissector_table("cip.data_segment.iface", - "CIP Data Segment Interface Handle", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "CIP Data Segment Interface Handle", proto_cip, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Register the protocol name and description */ proto_cip_class_generic = proto_register_protocol("CIP Class Generic", @@ -8013,7 +8013,7 @@ proto_register_cip(void) /* Register a heuristic dissector on the service of the message so objects * can override the dissector for common services */ - heur_subdissector_service = register_heur_dissector_list("cip.sc"); + heur_subdissector_service = register_heur_dissector_list("cip.sc", proto_cip); build_get_attr_all_table(); } /* end of proto_register_cip() */ diff --git a/epan/dissectors/packet-cisco-oui.c b/epan/dissectors/packet-cisco-oui.c index 2a986a1f18..4f18a73506 100644 --- a/epan/dissectors/packet-cisco-oui.c +++ b/epan/dissectors/packet-cisco-oui.c @@ -70,7 +70,7 @@ proto_register_cisco_oui(void) } }; - llc_add_oui(OUI_CISCO, "llc.cisco_pid", "LLC Cisco OUI PID", hf); + llc_add_oui(OUI_CISCO, "llc.cisco_pid", "LLC Cisco OUI PID", hf, -1); } /* diff --git a/epan/dissectors/packet-clnp.c b/epan/dissectors/packet-clnp.c index 5dfcff9a45..c5d39ac5c7 100644 --- a/epan/dissectors/packet-clnp.c +++ b/epan/dissectors/packet-clnp.c @@ -737,7 +737,7 @@ proto_register_clnp(void) expert_clnp = expert_register_protocol(proto_clnp); expert_register_field_array(expert_clnp, ei, array_length(ei)); clnp_handle = register_dissector("clnp", dissect_clnp, proto_clnp); - clnp_heur_subdissector_list = register_heur_dissector_list("clnp"); + clnp_heur_subdissector_list = register_heur_dissector_list("clnp", proto_clnp); register_init_routine(clnp_reassemble_init); register_cleanup_routine(clnp_reassemble_cleanup); diff --git a/epan/dissectors/packet-cmip.c b/epan/dissectors/packet-cmip.c index 72752b7ab7..d660d22bc0 100644 --- a/epan/dissectors/packet-cmip.c +++ b/epan/dissectors/packet-cmip.c @@ -5895,7 +5895,7 @@ void proto_register_cmip(void) { #line 199 "./asn1/cmip/packet-cmip-template.c" oid_add_from_string("discriminatorId(1)","2.9.3.2.7.1"); - attribute_id_dissector_table = register_dissector_table("cmip.attribute_id", "CMIP Attribute Id", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + attribute_id_dissector_table = register_dissector_table("cmip.attribute_id", "CMIP Attribute Id", proto_cmip, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-cnip.c b/epan/dissectors/packet-cnip.c index 26b3a0f00c..ed959304e8 100644 --- a/epan/dissectors/packet-cnip.c +++ b/epan/dissectors/packet-cnip.c @@ -235,7 +235,7 @@ void proto_register_cnip(void) /* Register table for subdissectors */ cnip_dissector_table = register_dissector_table("cnip.protocol", - "CN/IP Protocol", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "CN/IP Protocol", proto_cnip, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void proto_reg_handoff_cnip(void) diff --git a/epan/dissectors/packet-corosync-totemsrp.c b/epan/dissectors/packet-corosync-totemsrp.c index 472c1bd877..1b65a4ae2d 100644 --- a/epan/dissectors/packet-corosync-totemsrp.c +++ b/epan/dissectors/packet-corosync-totemsrp.c @@ -1159,7 +1159,7 @@ proto_register_corosync_totemsrp(void) proto_register_field_array(proto_corosync_totemsrp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - heur_subdissector_list = register_heur_dissector_list("corosync_totemsrp.mcast"); + heur_subdissector_list = register_heur_dissector_list("corosync_totemsrp.mcast", proto_corosync_totemsrp); register_dissector( "corosync_totemsrp", dissect_corosync_totemsrp, proto_corosync_totemsrp); } diff --git a/epan/dissectors/packet-credssp.c b/epan/dissectors/packet-credssp.c index dd1bf4ec27..e105c5091e 100644 --- a/epan/dissectors/packet-credssp.c +++ b/epan/dissectors/packet-credssp.c @@ -544,7 +544,7 @@ void proto_register_credssp(void) { proto_register_subtree_array(ett, array_length(ett)); /* heuristic dissectors for any premable e.g. CredSSP before RDP */ - credssp_heur_subdissector_list = register_heur_dissector_list("credssp"); + credssp_heur_subdissector_list = register_heur_dissector_list("credssp", proto_credssp); } diff --git a/epan/dissectors/packet-db-lsp.c b/epan/dissectors/packet-db-lsp.c index 4e1acf1cdf..85b19e612d 100644 --- a/epan/dissectors/packet-db-lsp.c +++ b/epan/dissectors/packet-db-lsp.c @@ -240,7 +240,7 @@ proto_register_db_lsp (void) register_dissector ("db-lsp.tcp", dissect_db_lsp_tcp, proto_db_lsp); register_dissector ("db-lsp.udp", dissect_db_lsp_disc, proto_db_lsp_disc); - heur_subdissector_list = register_heur_dissector_list("db-lsp"); + heur_subdissector_list = register_heur_dissector_list("db-lsp", proto_db_lsp); proto_register_field_array (proto_db_lsp, hf, array_length (hf)); proto_register_subtree_array (ett, array_length (ett)); diff --git a/epan/dissectors/packet-dccp.c b/epan/dissectors/packet-dccp.c index 8721c6a278..ecc4610a4c 100644 --- a/epan/dissectors/packet-dccp.c +++ b/epan/dissectors/packet-dccp.c @@ -1296,9 +1296,9 @@ proto_register_dccp(void) /* subdissectors */ dccp_subdissector_table = - register_dissector_table("dccp.port", "DCCP port", FT_UINT16, + register_dissector_table("dccp.port", "DCCP port", proto_dccp, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - heur_subdissector_list = register_heur_dissector_list("dccp"); + heur_subdissector_list = register_heur_dissector_list("dccp", proto_dccp); /* reg preferences */ dccp_module = prefs_register_protocol(proto_dccp, NULL); diff --git a/epan/dissectors/packet-dcerpc.c b/epan/dissectors/packet-dcerpc.c index cc41270723..9a1447e7b0 100644 --- a/epan/dissectors/packet-dcerpc.c +++ b/epan/dissectors/packet-dcerpc.c @@ -6945,7 +6945,7 @@ proto_register_dcerpc(void) expert_dcerpc = expert_register_protocol(proto_dcerpc); expert_register_field_array(expert_dcerpc, ei, array_length(ei)); - uuid_dissector_table = register_dissector_table("dcerpc.uuid", "DCE/RPC UUIDs", FT_GUID, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + uuid_dissector_table = register_dissector_table("dcerpc.uuid", "DCE/RPC UUIDs", proto_dcerpc, FT_GUID, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_init_routine(dcerpc_init_protocol); register_cleanup_routine(dcerpc_cleanup_protocol); diff --git a/epan/dissectors/packet-dcp-etsi.c b/epan/dissectors/packet-dcp-etsi.c index 0eca1ebeef..4eaa5bebc6 100644 --- a/epan/dissectors/packet-dcp-etsi.c +++ b/epan/dissectors/packet-dcp-etsi.c @@ -892,12 +892,12 @@ proto_register_dcp_etsi (void) /* subdissector code */ dcp_dissector_table = register_dissector_table("dcp-etsi.sync", - "DCP Sync", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "DCP Sync", proto_dcp_etsi, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); af_dissector_table = register_dissector_table("dcp-af.pt", - "DCP-AF Payload Type", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "DCP-AF Payload Type", proto_dcp_etsi, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); tpl_dissector_table = register_dissector_table("dcp-tpl.ptr", - "DCP-TPL Protocol Type & Revision", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "DCP-TPL Protocol Type & Revision", proto_dcp_etsi, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_init_routine(dcp_init_protocol); register_cleanup_routine(dcp_cleanup_protocol); diff --git a/epan/dissectors/packet-diameter.c b/epan/dissectors/packet-diameter.c index 2b7ff03b03..fbc15e1bce 100644 --- a/epan/dissectors/packet-diameter.c +++ b/epan/dissectors/packet-diameter.c @@ -2285,11 +2285,11 @@ real_proto_register_diameter(void) register_dissector("diameter", dissect_diameter, proto_diameter); /* Register dissector table(s) to do sub dissection of AVPs (OctetStrings) */ - diameter_dissector_table = register_dissector_table("diameter.base", "DIAMETER_BASE_AVPS", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - diameter_3gpp_avp_dissector_table = register_dissector_table("diameter.3gpp", "DIAMETER_3GPP_AVPS", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - diameter_ericsson_avp_dissector_table = register_dissector_table("diameter.ericsson", "DIAMETER_ERICSSON_AVPS", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + diameter_dissector_table = register_dissector_table("diameter.base", "DIAMETER_BASE_AVPS", proto_diameter, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + diameter_3gpp_avp_dissector_table = register_dissector_table("diameter.3gpp", "DIAMETER_3GPP_AVPS", proto_diameter, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + diameter_ericsson_avp_dissector_table = register_dissector_table("diameter.ericsson", "DIAMETER_ERICSSON_AVPS", proto_diameter, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - diameter_expr_result_vnd_table = register_dissector_table("diameter.vnd_exp_res", "DIAMETER Experimental-Result-Code", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + diameter_expr_result_vnd_table = register_dissector_table("diameter.vnd_exp_res", "DIAMETER Experimental-Result-Code", proto_diameter, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Set default TCP ports */ range_convert_str(&global_diameter_tcp_port_range, DEFAULT_DIAMETER_PORT_RANGE, MAX_UDP_PORT); diff --git a/epan/dissectors/packet-dmx.c b/epan/dissectors/packet-dmx.c index 7795a57863..e75f89284d 100644 --- a/epan/dissectors/packet-dmx.c +++ b/epan/dissectors/packet-dmx.c @@ -441,7 +441,7 @@ proto_register_dmx(void) proto_register_field_array(proto_dmx, hf, array_length(hf)); register_dissector("dmx", dissect_dmx, proto_dmx); - dmx_dissector_table = register_dissector_table("dmx", "DMX Start Code", + dmx_dissector_table = register_dissector_table("dmx", "DMX Start Code", proto_dmx, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-dns.c b/epan/dissectors/packet-dns.c index 6a6a72ef05..67ab22605b 100644 --- a/epan/dissectors/packet-dns.c +++ b/epan/dissectors/packet-dns.c @@ -5613,7 +5613,7 @@ proto_register_dns(void) "DNS address resolution settings can be changed in the Name Resolution preferences", "DNS address resolution settings can be changed in the Name Resolution preferences"); - dns_tsig_dissector_table = register_dissector_table("dns.tsig.mac", "DNS TSIG MAC Dissectors", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + dns_tsig_dissector_table = register_dissector_table("dns.tsig.mac", "DNS TSIG MAC Dissectors", proto_dns, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); dns_handle = register_dissector("dns", dissect_dns, proto_dns); diff --git a/epan/dissectors/packet-dop.c b/epan/dissectors/packet-dop.c index ca886db20c..b7dc6072d5 100644 --- a/epan/dissectors/packet-dop.c +++ b/epan/dissectors/packet-dop.c @@ -3056,7 +3056,7 @@ void proto_register_dop(void) { register_dissector("dop", dissect_dop, proto_dop); - dop_dissector_table = register_dissector_table("dop.oid", "DOP OID Dissectors", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + dop_dissector_table = register_dissector_table("dop.oid", "DOP OID Dissectors", proto_dop, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Register fields and subtrees */ proto_register_field_array(proto_dop, hf, array_length(hf)); diff --git a/epan/dissectors/packet-dtls.c b/epan/dissectors/packet-dtls.c index de4b091132..e6ae754201 100644 --- a/epan/dissectors/packet-dtls.c +++ b/epan/dissectors/packet-dtls.c @@ -1777,7 +1777,7 @@ proto_register_dtls(void) proto_dtls = proto_register_protocol("Datagram Transport Layer Security", "DTLS", "dtls"); - dtls_associations = register_dissector_table("dtls.port", "DTLS UDP Dissector", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + dtls_associations = register_dissector_table("dtls.port", "DTLS UDP Dissector", proto_dtls, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Required function calls to register the header fields and * subtrees used */ @@ -1842,7 +1842,7 @@ proto_register_dtls(void) ssl_debug_printf("proto_register_dtls: registered tap %s:%d\n", "dtls", dtls_tap); - heur_subdissector_list = register_heur_dissector_list("dtls"); + heur_subdissector_list = register_heur_dissector_list("dtls", proto_dtls); } diff --git a/epan/dissectors/packet-dvbci.c b/epan/dissectors/packet-dvbci.c index 650086849d..07f6603d2a 100644 --- a/epan/dissectors/packet-dvbci.c +++ b/epan/dissectors/packet-dvbci.c @@ -6337,7 +6337,7 @@ proto_register_dvbci(void) &dvbci_dissect_lsc_msg); sas_msg_dissector_table = register_dissector_table("dvb-ci.sas.app_id_str", - "SAS application id", FT_STRING, STR_ASCII, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "SAS application id", proto_dvbci, FT_STRING, STR_ASCII, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_init_routine(dvbci_init); register_cleanup_routine(dvbci_cleanup); diff --git a/epan/dissectors/packet-eapol.c b/epan/dissectors/packet-eapol.c index 164c79f7d9..8846ef7d2d 100644 --- a/epan/dissectors/packet-eapol.c +++ b/epan/dissectors/packet-eapol.c @@ -308,7 +308,7 @@ proto_register_eapol(void) eapol_keydes_type_dissector_table = register_dissector_table("eapol.keydes.type", "EAPOL Key Descriptor Type", - FT_UINT8, + proto_eapol, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-ecp-oui.c b/epan/dissectors/packet-ecp-oui.c index 329392f46e..31309a551a 100644 --- a/epan/dissectors/packet-ecp-oui.c +++ b/epan/dissectors/packet-ecp-oui.c @@ -431,13 +431,13 @@ void proto_register_ecp_oui(void) &ett_802_1qbg_capabilities_flags, }; - ieee802a_add_oui(OUI_IEEE_802_1QBG, "ieee802a.ecp_pid", - "IEEE802a ECP PID", &hf_reg); - proto_ecp = proto_register_protocol("ECP Protocol", "ECP", "ecp"); proto_register_field_array(proto_ecp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + ieee802a_add_oui(OUI_IEEE_802_1QBG, "ieee802a.ecp_pid", + "IEEE802a ECP PID", &hf_reg, proto_ecp); + register_dissector("ecp", dissect_ecp, proto_ecp); } diff --git a/epan/dissectors/packet-enc.c b/epan/dissectors/packet-enc.c index 35f3ee5d1e..fb4aef0f17 100644 --- a/epan/dissectors/packet-enc.c +++ b/epan/dissectors/packet-enc.c @@ -160,7 +160,7 @@ proto_register_enc(void) proto_register_field_array(proto_enc, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - enc_dissector_table = register_dissector_table("enc", "OpenBSD Encapsulating device", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + enc_dissector_table = register_dissector_table("enc", "OpenBSD Encapsulating device", proto_enc, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_capture_dissector_table("enc", "ENC"); } diff --git a/epan/dissectors/packet-enip.c b/epan/dissectors/packet-enip.c index d008719e2c..c76e311e4a 100644 --- a/epan/dissectors/packet-enip.c +++ b/epan/dissectors/packet-enip.c @@ -4375,12 +4375,12 @@ proto_register_enip(void) prefs_register_obsolete_preference(enip_module, "default_io_dissector"); subdissector_sud_table = register_dissector_table("enip.sud.iface", - "ENIP SendUnitData.Interface Handle", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "ENIP SendUnitData.Interface Handle", proto_enip, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); subdissector_srrd_table = register_dissector_table("enip.srrd.iface", - "ENIP SendRequestReplyData.Interface Handle", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "ENIP SendRequestReplyData.Interface Handle", proto_enip, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - subdissector_io_table = register_dissector_table("enip.io", "ENIP IO dissector", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + subdissector_io_table = register_dissector_table("enip.io", "ENIP IO dissector", proto_enip, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_init_routine(&enip_init_protocol); register_cleanup_routine(&enip_cleanup_protocol); diff --git a/epan/dissectors/packet-epl.c b/epan/dissectors/packet-epl.c index 0b096a32c5..2d9391b41c 100644 --- a/epan/dissectors/packet-epl.c +++ b/epan/dissectors/packet-epl.c @@ -4350,10 +4350,10 @@ proto_register_epl(void) proto_epl = proto_register_protocol("Ethernet POWERLINK", "EPL", "epl"); /* subdissector code */ - heur_epl_subdissector_list = register_heur_dissector_list("epl"); - heur_epl_data_subdissector_list = register_heur_dissector_list("epl_data"); + heur_epl_subdissector_list = register_heur_dissector_list("epl", proto_epl); + heur_epl_data_subdissector_list = register_heur_dissector_list("epl_data", proto_epl); epl_asnd_dissector_table = register_dissector_table("epl.asnd", - "Manufacturer specific ASND service", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "Manufacturer specific ASND service", proto_epl, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Registering protocol to be called by another dissector */ epl_handle = register_dissector("epl", dissect_epl, proto_epl); diff --git a/epan/dissectors/packet-erf.c b/epan/dissectors/packet-erf.c index 10231c9f81..79a6308f8d 100644 --- a/epan/dissectors/packet-erf.c +++ b/epan/dissectors/packet-erf.c @@ -1882,7 +1882,7 @@ proto_register_erf(void) "Whether the FCS is present in Ethernet packets", &erf_ethfcs); - erf_dissector_table = register_dissector_table("erf.types.type", "Type", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + erf_dissector_table = register_dissector_table("erf.types.type", "Type", proto_erf, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-eth.c b/epan/dissectors/packet-eth.c index a92addb301..90ad6f09a6 100644 --- a/epan/dissectors/packet-eth.c +++ b/epan/dissectors/packet-eth.c @@ -961,8 +961,8 @@ proto_register_eth(void) expert_register_field_array(expert_eth, ei, array_length(ei)); /* subdissector code */ - heur_subdissector_list = register_heur_dissector_list("eth"); - eth_trailer_subdissector_list = register_heur_dissector_list("eth.trailer"); + heur_subdissector_list = register_heur_dissector_list("eth", proto_eth); + eth_trailer_subdissector_list = register_heur_dissector_list("eth.trailer", proto_eth); /* Register configuration preferences */ eth_module = prefs_register_protocol(proto_eth, NULL); diff --git a/epan/dissectors/packet-ethertype.c b/epan/dissectors/packet-ethertype.c index 9f4de890b0..4b177417d5 100644 --- a/epan/dissectors/packet-ethertype.c +++ b/epan/dissectors/packet-ethertype.c @@ -352,7 +352,7 @@ proto_register_ethertype(void) /* subdissector code */ ethertype_dissector_table = register_dissector_table("ethertype", - "Ethertype", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "Ethertype", proto_ethertype, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_capture_dissector_table("ethertype", "Ethertype"); register_decode_as(ðertype_da); diff --git a/epan/dissectors/packet-extreme.c b/epan/dissectors/packet-extreme.c index 936f20d80b..a25f01ca4f 100644 --- a/epan/dissectors/packet-extreme.c +++ b/epan/dissectors/packet-extreme.c @@ -150,7 +150,6 @@ These are the structures you will see most often in EDP frames. void proto_register_edp(void); void proto_reg_handoff_edp(void); -void proto_register_extreme_oui(void); static int hf_llc_extreme_pid = -1; @@ -1448,6 +1447,14 @@ proto_register_edp(void) { "End", "edp.null", FT_PROTOCOL, BASE_NONE, NULL, 0x0, "Last element", HFILL }}, }; + + static hf_register_info extreme_hf[] = { + { &hf_llc_extreme_pid, + { "PID", "llc.extreme_pid", FT_UINT16, BASE_HEX, + VALS(extreme_pid_vals), 0x0, NULL, HFILL } + } + }; + static gint *ett[] = { &ett_edp, &ett_edp_checksum, @@ -1477,6 +1484,9 @@ proto_register_edp(void) proto_register_subtree_array(ett, array_length(ett)); expert_edp = expert_register_protocol(proto_edp); expert_register_field_array(expert_edp, ei, array_length(ei)); + + llc_add_oui(OUI_EXTREME, "llc.extreme_pid", "LLC Extreme OUI PID", extreme_hf, proto_edp); + } void @@ -1488,19 +1498,6 @@ proto_reg_handoff_edp(void) dissector_add_uint("llc.extreme_pid", 0x00bb, edp_handle); } -void -proto_register_extreme_oui(void) -{ - static hf_register_info hf[] = { - { &hf_llc_extreme_pid, - { "PID", "llc.extreme_pid", FT_UINT16, BASE_HEX, - VALS(extreme_pid_vals), 0x0, NULL, HFILL } - } - }; - - llc_add_oui(OUI_EXTREME, "llc.extreme_pid", "LLC Extreme OUI PID", hf); -} - /* * Editor modelines - http://www.wireshark.org/tools/modelines.html * diff --git a/epan/dissectors/packet-fc.c b/epan/dissectors/packet-fc.c index 277c739652..0dd06499a1 100644 --- a/epan/dissectors/packet-fc.c +++ b/epan/dissectors/packet-fc.c @@ -1578,7 +1578,7 @@ proto_register_fc(void) */ fcftype_dissector_table = register_dissector_table ("fc.ftype", "FC Frame Type", - FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_fc, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Register preferences */ fc_module = prefs_register_protocol (proto_fc, NULL); diff --git a/epan/dissectors/packet-fcct.c b/epan/dissectors/packet-fcct.c index accd4d6d88..4adeb16f97 100644 --- a/epan/dissectors/packet-fcct.c +++ b/epan/dissectors/packet-fcct.c @@ -276,7 +276,7 @@ proto_register_fcct(void) fcct_gserver_table = register_dissector_table ("fcct.server", "FCCT Server", - FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_fcct, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-flexray.c b/epan/dissectors/packet-flexray.c index b43c12cb11..98f22418d9 100644 --- a/epan/dissectors/packet-flexray.c +++ b/epan/dissectors/packet-flexray.c @@ -461,7 +461,7 @@ proto_register_flexray(void) register_decode_as(&flexray_da); subdissector_table = register_dissector_table("flexray.subdissector", - "FLEXRAY next level dissector", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "FLEXRAY next level dissector", proto_flexray, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-flip.c b/epan/dissectors/packet-flip.c index e75eef824b..1e5fb1d68a 100644 --- a/epan/dissectors/packet-flip.c +++ b/epan/dissectors/packet-flip.c @@ -468,7 +468,7 @@ proto_register_flip(void) proto_register_field_array(proto_flip, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - subdissector_table = register_dissector_table("flip.payload", "FLIP subdissector", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + subdissector_table = register_dissector_table("flip.payload", "FLIP subdissector", proto_flip, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); flip_module = prefs_register_protocol(proto_flip, NULL); diff --git a/epan/dissectors/packet-force10-oui.c b/epan/dissectors/packet-force10-oui.c index 7cbf972fa8..4c68f25c3d 100644 --- a/epan/dissectors/packet-force10-oui.c +++ b/epan/dissectors/packet-force10-oui.c @@ -48,7 +48,7 @@ proto_register_force10_oui(void) } }; - llc_add_oui(OUI_FORCE10, "llc.force10_pid", "LLC FORCE10 OUI PID", hf); + llc_add_oui(OUI_FORCE10, "llc.force10_pid", "LLC FORCE10 OUI PID", hf, -1); } /* diff --git a/epan/dissectors/packet-foundry.c b/epan/dissectors/packet-foundry.c index 3fead09505..3c9a92858a 100644 --- a/epan/dissectors/packet-foundry.c +++ b/epan/dissectors/packet-foundry.c @@ -33,7 +33,6 @@ void proto_register_fdp(void); void proto_reg_handoff_fdp(void); -void proto_register_foundry_oui(void); static int hf_llc_foundry_pid = -1; @@ -429,6 +428,14 @@ proto_register_fdp(void) 0x0, NULL, HFILL }}, }; + + static hf_register_info oui_hf[] = { + { &hf_llc_foundry_pid, + { "PID", "llc.foundry_pid", FT_UINT16, BASE_HEX, + VALS(foundry_pid_vals), 0x0, NULL, HFILL } + } + }; + static gint *ett[] = { &ett_fdp, &ett_fdp_tlv_header, @@ -451,6 +458,8 @@ proto_register_fdp(void) proto_register_subtree_array(ett, array_length(ett)); expert_fdp = expert_register_protocol(proto_fdp); expert_register_field_array(expert_fdp, ei, array_length(ei)); + + llc_add_oui(OUI_FOUNDRY, "llc.foundry_pid", "LLC Foundry OUI PID", oui_hf, proto_fdp); } void @@ -462,19 +471,6 @@ proto_reg_handoff_fdp(void) dissector_add_uint("llc.foundry_pid", 0x2000, fdp_handle); } -void -proto_register_foundry_oui(void) -{ - static hf_register_info hf[] = { - { &hf_llc_foundry_pid, - { "PID", "llc.foundry_pid", FT_UINT16, BASE_HEX, - VALS(foundry_pid_vals), 0x0, NULL, HFILL } - } - }; - - llc_add_oui(OUI_FOUNDRY, "llc.foundry_pid", "LLC Foundry OUI PID", hf); -} - /* * Editor modelines - http://www.wireshark.org/tools/modelines.html * diff --git a/epan/dissectors/packet-fr.c b/epan/dissectors/packet-fr.c index 60ce77ea11..7e1f976946 100644 --- a/epan/dissectors/packet-fr.c +++ b/epan/dissectors/packet-fr.c @@ -969,9 +969,9 @@ proto_register_fr(void) expert_register_field_array(expert_fr, ei, array_length(ei)); fr_subdissector_table = register_dissector_table("fr.nlpid", - "Frame Relay NLPID", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "Frame Relay NLPID", proto_fr, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); fr_osinl_subdissector_table = register_dissector_table("fr.osinl", - "Frame Relay OSI NLPID", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "Frame Relay OSI NLPID", proto_fr, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_dissector("fr_uncompressed", dissect_fr_uncompressed, proto_fr); register_dissector("fr", dissect_fr, proto_fr); diff --git a/epan/dissectors/packet-frame.c b/epan/dissectors/packet-frame.c index 1e71cf9eaa..a3466505a4 100644 --- a/epan/dissectors/packet-frame.c +++ b/epan/dissectors/packet-frame.c @@ -883,12 +883,6 @@ proto_register_frame(void) arr[encap_count].strptr = NULL; } - wtap_encap_dissector_table = register_dissector_table("wtap_encap", - "Wiretap encapsulation type", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - wtap_fts_rec_dissector_table = register_dissector_table("wtap_fts_rec", - "Wiretap file type for file-type-specific records", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - register_capture_dissector_table("wtap_encap", "Wiretap encapsulation type"); - proto_frame = proto_register_protocol("Frame", "Frame", "frame"); proto_pkt_comment = proto_register_protocol("Packet comments", "Pkt_Comment", "pkt_comment"); proto_register_field_array(proto_frame, hf, array_length(hf)); @@ -898,6 +892,12 @@ proto_register_frame(void) expert_register_field_array(expert_frame, ei, array_length(ei)); register_dissector("frame",dissect_frame,proto_frame); + wtap_encap_dissector_table = register_dissector_table("wtap_encap", + "Wiretap encapsulation type", proto_frame, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + wtap_fts_rec_dissector_table = register_dissector_table("wtap_fts_rec", + "Wiretap file type for file-type-specific records", proto_frame, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + register_capture_dissector_table("wtap_encap", "Wiretap encapsulation type"); + /* You can't disable dissection of "Frame", as that would be tantamount to not doing any dissection whatsoever. */ proto_set_cant_toggle(proto_frame); diff --git a/epan/dissectors/packet-gfp.c b/epan/dissectors/packet-gfp.c index 57b441dc4f..e7ffb9582c 100644 --- a/epan/dissectors/packet-gfp.c +++ b/epan/dissectors/packet-gfp.c @@ -621,7 +621,7 @@ proto_register_gfp(void) /* Subdissectors for payload */ gfp_dissector_table = register_dissector_table("gfp.upi", "GFP UPI (for Client Data frames)", - FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_gfp, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Don't register a preferences module yet since there are no prefs in * order to avoid a warning. (See section 2.6 of README.dissector diff --git a/epan/dissectors/packet-gprs-llc.c b/epan/dissectors/packet-gprs-llc.c index 0c0acb8462..b424cfa123 100644 --- a/epan/dissectors/packet-gprs-llc.c +++ b/epan/dissectors/packet-gprs-llc.c @@ -1326,7 +1326,7 @@ proto_register_llcgprs(void) /* Register the protocol name and description */ proto_llcgprs = proto_register_protocol("Logical Link Control GPRS", "GPRS-LLC", "llcgprs"); - llcgprs_subdissector_table = register_dissector_table("llcgprs.sapi", "GPRS LLC SAPI", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + llcgprs_subdissector_table = register_dissector_table("llcgprs.sapi", "GPRS LLC SAPI", proto_llcgprs, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_llcgprs, hf, array_length(hf)); diff --git a/epan/dissectors/packet-gre.c b/epan/dissectors/packet-gre.c index ae0e7a12e8..9953608df2 100644 --- a/epan/dissectors/packet-gre.c +++ b/epan/dissectors/packet-gre.c @@ -746,7 +746,7 @@ proto_register_gre(void) /* subdissector code */ gre_dissector_table = register_dissector_table("gre.proto", - "GRE protocol type", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + "GRE protocol type", proto_gre, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-gsm_a_dtap.c b/epan/dissectors/packet-gsm_a_dtap.c index a7be914e82..952b7e7087 100644 --- a/epan/dissectors/packet-gsm_a_dtap.c +++ b/epan/dissectors/packet-gsm_a_dtap.c @@ -8312,7 +8312,7 @@ proto_register_gsm_a_dtap(void) /* subdissector code */ register_dissector("gsm_a_dtap", dissect_dtap, proto_a_dtap); u2u_dissector_table = register_dissector_table("gsm_a.dtap.u2u_prot_discr", "GSM User to User Signalling", - FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_a_dtap, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-gsm_a_gm.c b/epan/dissectors/packet-gsm_a_gm.c index 18ae55686b..e9b2c0f753 100644 --- a/epan/dissectors/packet-gsm_a_gm.c +++ b/epan/dissectors/packet-gsm_a_gm.c @@ -8686,7 +8686,7 @@ proto_register_gsm_a_gm(void) /* subdissector code */ gprs_sm_pco_subdissector_table = register_dissector_table("sm_pco.protocol", - "GPRS SM PCO PPP protocol", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "GPRS SM PCO PPP protocol", proto_a_gm, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-gsm_ipa.c b/epan/dissectors/packet-gsm_ipa.c index a13a8cbfad..7385a9acfc 100644 --- a/epan/dissectors/packet-gsm_ipa.c +++ b/epan/dissectors/packet-gsm_ipa.c @@ -454,7 +454,7 @@ void proto_register_ipa(void) /* Register table for subdissectors */ osmo_dissector_table = register_dissector_table("ipa.osmo.protocol", - "GSM over IP ip.access Protocol", + "GSM over IP ip.access Protocol", proto_ipa, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); diff --git a/epan/dissectors/packet-gsm_map.c b/epan/dissectors/packet-gsm_map.c index 8a06a42170..34256da4af 100644 --- a/epan/dissectors/packet-gsm_map.c +++ b/epan/dissectors/packet-gsm_map.c @@ -31102,9 +31102,9 @@ void proto_register_gsm_map(void) { expert_gsm_map = expert_register_protocol(proto_gsm_map); expert_register_field_array(expert_gsm_map, ei, array_length(ei)); - map_prop_arg_opcode_table = register_dissector_table("gsm_map.prop.arg.opcode", "GSM_MAP Proprietary Arg Opcodes", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - map_prop_res_opcode_table = register_dissector_table("gsm_map.prop.res.opcode", "GSM_MAP Proprietary Res Opcodes", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - map_prop_err_opcode_table = register_dissector_table("gsm_map.prop.err.opcode", "GSM_MAP Proprietary Err Opcodes", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + map_prop_arg_opcode_table = register_dissector_table("gsm_map.prop.arg.opcode", "GSM_MAP Proprietary Arg Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + map_prop_res_opcode_table = register_dissector_table("gsm_map.prop.res.opcode", "GSM_MAP Proprietary Res Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + map_prop_err_opcode_table = register_dissector_table("gsm_map.prop.err.opcode", "GSM_MAP Proprietary Err Opcodes", proto_gsm_map, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); gsm_map_tap = register_tap("gsm_map"); diff --git a/epan/dissectors/packet-gsm_sms.c b/epan/dissectors/packet-gsm_sms.c index b73560485b..cfccec95b7 100644 --- a/epan/dissectors/packet-gsm_sms.c +++ b/epan/dissectors/packet-gsm_sms.c @@ -3330,7 +3330,7 @@ proto_register_gsm_sms(void) expert_register_field_array(expert_gsm_sms, ei, array_length(ei)); gsm_sms_dissector_tbl = register_dissector_table("gsm_sms.udh.port", - "GSM SMS port IE in UDH", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "GSM SMS port IE in UDH", proto_gsm_sms, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); gsm_sms_module = prefs_register_protocol (proto_gsm_sms, NULL); diff --git a/epan/dissectors/packet-gsm_sms_ud.c b/epan/dissectors/packet-gsm_sms_ud.c index 370538956f..915419ae39 100644 --- a/epan/dissectors/packet-gsm_sms_ud.c +++ b/epan/dissectors/packet-gsm_sms_ud.c @@ -629,7 +629,7 @@ proto_register_gsm_sms_ud(void) /* Subdissector code */ gsm_sms_dissector_table = register_dissector_table("gsm_sms_ud.udh.port", - "GSM SMS port IE in UDH", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "GSM SMS port IE in UDH", proto_gsm_sms_ud, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Preferences for GSM SMS UD */ gsm_sms_ud_module = prefs_register_protocol(proto_gsm_sms_ud, NULL); diff --git a/epan/dissectors/packet-gsmtap.c b/epan/dissectors/packet-gsmtap.c index 2fa76b5bd4..04dc757018 100644 --- a/epan/dissectors/packet-gsmtap.c +++ b/epan/dissectors/packet-gsmtap.c @@ -775,7 +775,7 @@ proto_register_gsmtap(void) proto_register_subtree_array(ett, array_length(ett)); gsmtap_dissector_table = register_dissector_table("gsmtap.type", - "GSMTAP type", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "GSMTAP type", proto_gsmtap, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-gtp.c b/epan/dissectors/packet-gtp.c index 41dca2176c..87e6516eca 100644 --- a/epan/dissectors/packet-gtp.c +++ b/epan/dissectors/packet-gtp.c @@ -10146,8 +10146,8 @@ proto_register_gtp(void) register_dissector("gtp", dissect_gtp, proto_gtp); register_dissector("gtpprime", dissect_gtpprime, proto_gtpprime); - gtp_priv_ext_dissector_table = register_dissector_table("gtp.priv_ext", "GTP PRIVATE EXT", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - gtp_cdr_fmt_dissector_table = register_dissector_table("gtp.cdr_fmt", "GTP DATA RECORD TYPE", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + gtp_priv_ext_dissector_table = register_dissector_table("gtp.priv_ext", "GTP PRIVATE EXT", proto_gtp, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + gtp_cdr_fmt_dissector_table = register_dissector_table("gtp.cdr_fmt", "GTP DATA RECORD TYPE", proto_gtp, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_init_routine(gtp_init); register_cleanup_routine(gtp_cleanup); diff --git a/epan/dissectors/packet-gtpv2.c b/epan/dissectors/packet-gtpv2.c index 12647c0e1b..c1afd34497 100644 --- a/epan/dissectors/packet-gtpv2.c +++ b/epan/dissectors/packet-gtpv2.c @@ -8558,7 +8558,7 @@ void proto_register_gtpv2(void) register_dissector("gtpv2", dissect_gtpv2, proto_gtpv2); /* Dissector table for private extensions */ - gtpv2_priv_ext_dissector_table = register_dissector_table("gtpv2.priv_ext", "GTPv2 PRIVATE EXT", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + gtpv2_priv_ext_dissector_table = register_dissector_table("gtpv2.priv_ext", "GTPv2 PRIVATE EXT", proto_gtpv2, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-h225.c b/epan/dissectors/packet-h225.c index 91207d79cc..c1532e8a58 100644 --- a/epan/dissectors/packet-h225.c +++ b/epan/dissectors/packet-h225.c @@ -11663,11 +11663,11 @@ void proto_register_h225(void) { register_dissector("h323ui",dissect_h225_H323UserInformation, proto_h225); register_dissector("h225.ras", dissect_h225_h225_RasMessage, proto_h225); - nsp_object_dissector_table = register_dissector_table("h225.nsp.object", "H.225 NonStandardParameter (object)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - nsp_h221_dissector_table = register_dissector_table("h225.nsp.h221", "H.225 NonStandardParameter (h221)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - tp_dissector_table = register_dissector_table("h225.tp", "H.225 TunnelledProtocol", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - gef_name_dissector_table = register_dissector_table("h225.gef.name", "H.225 Generic Extensible Framework (names)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - gef_content_dissector_table = register_dissector_table("h225.gef.content", "H.225 Generic Extensible Framework", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nsp_object_dissector_table = register_dissector_table("h225.nsp.object", "H.225 NonStandardParameter (object)", proto_h225, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nsp_h221_dissector_table = register_dissector_table("h225.nsp.h221", "H.225 NonStandardParameter (h221)", proto_h225, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + tp_dissector_table = register_dissector_table("h225.tp", "H.225 TunnelledProtocol", proto_h225, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + gef_name_dissector_table = register_dissector_table("h225.gef.name", "H.225 Generic Extensible Framework (names)", proto_h225, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + gef_content_dissector_table = register_dissector_table("h225.gef.content", "H.225 Generic Extensible Framework", proto_h225, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); register_init_routine(&h225_init_routine); register_cleanup_routine(&h225_cleanup_routine); diff --git a/epan/dissectors/packet-h245.c b/epan/dissectors/packet-h245.c index adccf5b22f..ab34418750 100644 --- a/epan/dissectors/packet-h245.c +++ b/epan/dissectors/packet-h245.c @@ -20762,10 +20762,10 @@ void proto_register_h245(void) { register_dissector("h245dg", dissect_h245_h245, proto_h245); register_dissector("h245", dissect_h245, proto_h245); - nsp_object_dissector_table = register_dissector_table("h245.nsp.object", "H.245 NonStandardParameter (object)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - nsp_h221_dissector_table = register_dissector_table("h245.nsp.h221", "H.245 NonStandardParameter (h221)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - gef_name_dissector_table = register_dissector_table("h245.gef.name", "H.245 Generic Extensible Framework (names)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - gef_content_dissector_table = register_dissector_table("h245.gef.content", "H.245 Generic Extensible Framework", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nsp_object_dissector_table = register_dissector_table("h245.nsp.object", "H.245 NonStandardParameter (object)", proto_h245, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nsp_h221_dissector_table = register_dissector_table("h245.nsp.h221", "H.245 NonStandardParameter (h221)", proto_h245, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + gef_name_dissector_table = register_dissector_table("h245.gef.name", "H.245 Generic Extensible Framework (names)", proto_h245, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + gef_content_dissector_table = register_dissector_table("h245.gef.content", "H.245 Generic Extensible Framework", proto_h245, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); h245_tap = register_tap("h245"); h245dg_tap = register_tap("h245dg"); diff --git a/epan/dissectors/packet-h248.c b/epan/dissectors/packet-h248.c index 295eff2cb7..29a2c55753 100644 --- a/epan/dissectors/packet-h248.c +++ b/epan/dissectors/packet-h248.c @@ -6954,7 +6954,7 @@ void proto_register_h248(void) { expert_h248 = expert_register_protocol(proto_h248); expert_register_field_array(expert_h248, ei, array_length(ei)); - subdissector_table = register_dissector_table("h248.magic_num", "H248 Magic Num", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + subdissector_table = register_dissector_table("h248.magic_num", "H248 Magic Num", proto_h248, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); h248_module = prefs_register_protocol(proto_h248, proto_reg_handoff_h248); prefs_register_bool_preference(h248_module, "ctx_info", diff --git a/epan/dissectors/packet-h450.c b/epan/dissectors/packet-h450.c index d519a62665..18a8b3c049 100644 --- a/epan/dissectors/packet-h450.c +++ b/epan/dissectors/packet-h450.c @@ -6491,12 +6491,12 @@ void proto_register_h450(void) { rose_ctx_init(&h450_rose_ctx); /* Register dissector tables */ - h450_rose_ctx.arg_global_dissector_table = register_dissector_table("h450.ros.global.arg", "H.450 Operation Argument (global opcode)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - h450_rose_ctx.res_global_dissector_table = register_dissector_table("h450.ros.global.res", "H.450 Operation Result (global opcode)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - h450_rose_ctx.arg_local_dissector_table = register_dissector_table("h450.ros.local.arg", "H.450 Operation Argument (local opcode)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - h450_rose_ctx.res_local_dissector_table = register_dissector_table("h450.ros.local.res", "H.450 Operation Result (local opcode)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - h450_rose_ctx.err_global_dissector_table = register_dissector_table("h450.ros.global.err", "H.450 Error (global opcode)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - h450_rose_ctx.err_local_dissector_table = register_dissector_table("h450.ros.local.err", "H.450 Error (local opcode)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + h450_rose_ctx.arg_global_dissector_table = register_dissector_table("h450.ros.global.arg", "H.450 Operation Argument (global opcode)", proto_h450, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + h450_rose_ctx.res_global_dissector_table = register_dissector_table("h450.ros.global.res", "H.450 Operation Result (global opcode)", proto_h450, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + h450_rose_ctx.arg_local_dissector_table = register_dissector_table("h450.ros.local.arg", "H.450 Operation Argument (local opcode)", proto_h450, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + h450_rose_ctx.res_local_dissector_table = register_dissector_table("h450.ros.local.res", "H.450 Operation Result (local opcode)", proto_h450, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + h450_rose_ctx.err_global_dissector_table = register_dissector_table("h450.ros.global.err", "H.450 Error (global opcode)", proto_h450, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + h450_rose_ctx.err_local_dissector_table = register_dissector_table("h450.ros.local.err", "H.450 Error (local opcode)", proto_h450, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-hci_h1.c b/epan/dissectors/packet-hci_h1.c index a019d0876b..17dc9ad691 100644 --- a/epan/dissectors/packet-hci_h1.c +++ b/epan/dissectors/packet-hci_h1.c @@ -140,7 +140,7 @@ proto_register_hci_h1(void) proto_register_subtree_array(ett, array_length(ett)); hci_h1_table = register_dissector_table("hci_h1.type", - "HCI h1 pdu type", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "HCI h1 pdu type", proto_hci_h1, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-hci_h4.c b/epan/dissectors/packet-hci_h4.c index c97eee48cb..7a68a13693 100644 --- a/epan/dissectors/packet-hci_h4.c +++ b/epan/dissectors/packet-hci_h4.c @@ -143,7 +143,7 @@ proto_register_hci_h4(void) proto_register_subtree_array(ett, array_length(ett)); hci_h4_table = register_dissector_table("hci_h4.type", - "HCI H4 pdu type", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "HCI H4 pdu type", proto_hci_h4, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-hnbap.c b/epan/dissectors/packet-hnbap.c index 0da1b80058..f134647c9f 100644 --- a/epan/dissectors/packet-hnbap.c +++ b/epan/dissectors/packet-hnbap.c @@ -3296,11 +3296,11 @@ module_t *hnbap_module; register_dissector("hnbap", dissect_hnbap, proto_hnbap); /* Register dissector tables */ - hnbap_ies_dissector_table = register_dissector_table("hnbap.ies", "HNBAP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - hnbap_extension_dissector_table = register_dissector_table("hnbap.extension", "HNBAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - hnbap_proc_imsg_dissector_table = register_dissector_table("hnbap.proc.imsg", "HNBAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - hnbap_proc_sout_dissector_table = register_dissector_table("hnbap.proc.sout", "HNBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - hnbap_proc_uout_dissector_table = register_dissector_table("hnbap.proc.uout", "HNBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + hnbap_ies_dissector_table = register_dissector_table("hnbap.ies", "HNBAP-PROTOCOL-IES", proto_hnbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + hnbap_extension_dissector_table = register_dissector_table("hnbap.extension", "HNBAP-PROTOCOL-EXTENSION", proto_hnbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + hnbap_proc_imsg_dissector_table = register_dissector_table("hnbap.proc.imsg", "HNBAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_hnbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + hnbap_proc_sout_dissector_table = register_dissector_table("hnbap.proc.sout", "HNBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_hnbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + hnbap_proc_uout_dissector_table = register_dissector_table("hnbap.proc.uout", "HNBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_hnbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); hnbap_module = prefs_register_protocol(proto_hnbap, proto_reg_handoff_hnbap); prefs_register_uint_preference(hnbap_module, "port", "HNBAP SCTP Port", "Set the port for HNBAP messages (Default of 29169)", 10, &global_sctp_port); diff --git a/epan/dissectors/packet-hpext.c b/epan/dissectors/packet-hpext.c index 1f3714585e..2ae8b80a06 100644 --- a/epan/dissectors/packet-hpext.c +++ b/epan/dissectors/packet-hpext.c @@ -130,7 +130,7 @@ proto_register_hpext(void) /* subdissector code */ subdissector_table = register_dissector_table("hpext.dxsap", - "HPEXT XSAP", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "HPEXT XSAP", proto_hpext, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); hpext_handle = register_dissector("hpext", dissect_hpext, proto_hpext); } diff --git a/epan/dissectors/packet-hpfeeds.c b/epan/dissectors/packet-hpfeeds.c index 059492f259..7b998e4c26 100644 --- a/epan/dissectors/packet-hpfeeds.c +++ b/epan/dissectors/packet-hpfeeds.c @@ -461,7 +461,7 @@ proto_register_hpfeeds(void) "hpfeeds" /* abbrev */ ); - heur_subdissector_list = register_heur_dissector_list("hpfeeds"); + heur_subdissector_list = register_heur_dissector_list("hpfeeds", proto_hpfeeds); proto_register_field_array(proto_hpfeeds, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); diff --git a/epan/dissectors/packet-hpteam.c b/epan/dissectors/packet-hpteam.c index 0c70d7419b..124950314b 100644 --- a/epan/dissectors/packet-hpteam.c +++ b/epan/dissectors/packet-hpteam.c @@ -125,7 +125,7 @@ void proto_register_hpteam(void) proto_hpteam = proto_register_protocol ("HP NIC Teaming Heartbeat", "HPTEAM", "hpteam"); /*Tied into the LLC dissector so register the OUI with LLC*/ - llc_add_oui(OUI_HP_2, "llc.hpteam_pid", "LLC Hewlett Packard OUI PID", &hf_pid); + llc_add_oui(OUI_HP_2, "llc.hpteam_pid", "LLC Hewlett Packard OUI PID", &hf_pid, proto_hpteam); proto_register_field_array(proto_hpteam, hf_data, array_length(hf_data)); proto_register_subtree_array(ett, array_length(ett)); register_dissector("hpteam", dissect_hpteam, proto_hpteam); diff --git a/epan/dissectors/packet-http.c b/epan/dissectors/packet-http.c index b7261eb8e4..7665b91f57 100644 --- a/epan/dissectors/packet-http.c +++ b/epan/dissectors/packet-http.c @@ -3506,7 +3506,7 @@ proto_register_http(void) * HTTP on a specific non-HTTP port. */ port_subdissector_table = register_dissector_table("http.port", - "TCP port for protocols using HTTP", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "TCP port for protocols using HTTP", proto_http, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* * Dissectors can register themselves in this table. @@ -3515,14 +3515,14 @@ proto_register_http(void) */ media_type_subdissector_table = register_dissector_table("media_type", - "Internet media type", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + "Internet media type", proto_http, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* * Heuristic dissectors SHOULD register themselves in * this table using the standard heur_dissector_add() * function. */ - heur_subdissector_list = register_heur_dissector_list("http"); + heur_subdissector_list = register_heur_dissector_list("http", proto_http); /* * Register for tapping diff --git a/epan/dissectors/packet-i2c.c b/epan/dissectors/packet-i2c.c index 5b5cc4a5d5..dfe7193e6c 100644 --- a/epan/dissectors/packet-i2c.c +++ b/epan/dissectors/packet-i2c.c @@ -256,7 +256,7 @@ proto_register_i2c(void) proto_register_field_array(proto_i2c, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - subdissector_table = register_dissector_table("i2c.message", "I2C messages dissector", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + subdissector_table = register_dissector_table("i2c.message", "I2C messages dissector", proto_i2c, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); m = prefs_register_protocol(proto_i2c, NULL); prefs_register_obsolete_preference(m, "type"); diff --git a/epan/dissectors/packet-iana-oui.c b/epan/dissectors/packet-iana-oui.c index c28deec8ef..a7540956d9 100644 --- a/epan/dissectors/packet-iana-oui.c +++ b/epan/dissectors/packet-iana-oui.c @@ -58,7 +58,7 @@ proto_register_iana_oui(void) } }; - llc_add_oui(OUI_IANA, "llc.iana_pid", "LLC IANA OUI PID", hf); + llc_add_oui(OUI_IANA, "llc.iana_pid", "LLC IANA OUI PID", hf, -1); } /* diff --git a/epan/dissectors/packet-iax2.c b/epan/dissectors/packet-iax2.c index c83f850f37..bd54dbbf8a 100644 --- a/epan/dissectors/packet-iax2.c +++ b/epan/dissectors/packet-iax2.c @@ -3203,9 +3203,9 @@ proto_register_iax2(void) register_dissector("iax2", dissect_iax2, proto_iax2); iax2_codec_dissector_table = register_dissector_table( - "iax2.codec", "IAX codec number", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "iax2.codec", "IAX codec number", proto_iax2, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); iax2_dataformat_dissector_table = register_dissector_table( - "iax2.dataformat", "IAX dataformat number", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "iax2.dataformat", "IAX dataformat number", proto_iax2, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* register our init routine to be called at the start of a capture, to clear out our hash tables etc */ diff --git a/epan/dissectors/packet-idp.c b/epan/dissectors/packet-idp.c index 14b667cb9b..ad4129aa95 100644 --- a/epan/dissectors/packet-idp.c +++ b/epan/dissectors/packet-idp.c @@ -198,7 +198,7 @@ proto_register_idp(void) proto_register_subtree_array(ett, array_length(ett)); idp_type_dissector_table = register_dissector_table("idp.packet_type", - "IDP packet type", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "IDP packet type", proto_idp, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-ieee1722.c b/epan/dissectors/packet-ieee1722.c index 916994d735..48eb0ed78c 100644 --- a/epan/dissectors/packet-ieee1722.c +++ b/epan/dissectors/packet-ieee1722.c @@ -404,7 +404,7 @@ void proto_register_1722(void) /* Sub-dissector for 1772.1 */ avb_dissector_table = register_dissector_table("ieee1722.subtype", - "IEEE1722 AVBTP Subtype", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "IEEE1722 AVBTP Subtype", proto_1722, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void proto_reg_handoff_1722(void) diff --git a/epan/dissectors/packet-ieee802154.c b/epan/dissectors/packet-ieee802154.c index 6c2539a2a7..5fa408bede 100644 --- a/epan/dissectors/packet-ieee802154.c +++ b/epan/dissectors/packet-ieee802154.c @@ -3565,9 +3565,9 @@ void proto_register_ieee802154(void) &ieee802154_extend_auth); /* Register the subdissector list */ - panid_dissector_table = register_dissector_table(IEEE802154_PROTOABBREV_WPAN_PANID, "IEEE 802.15.4 PANID", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - ieee802154_heur_subdissector_list = register_heur_dissector_list(IEEE802154_PROTOABBREV_WPAN); - ieee802154_beacon_subdissector_list = register_heur_dissector_list(IEEE802154_PROTOABBREV_WPAN_BEACON); + panid_dissector_table = register_dissector_table(IEEE802154_PROTOABBREV_WPAN_PANID, "IEEE 802.15.4 PANID", proto_ieee802154, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + ieee802154_heur_subdissector_list = register_heur_dissector_list(IEEE802154_PROTOABBREV_WPAN, proto_ieee802154); + ieee802154_beacon_subdissector_list = register_heur_dissector_list(IEEE802154_PROTOABBREV_WPAN_BEACON, proto_ieee802154); /* Register dissectors with Wireshark. */ register_dissector(IEEE802154_PROTOABBREV_WPAN, dissect_ieee802154, proto_ieee802154); diff --git a/epan/dissectors/packet-ieee802a.c b/epan/dissectors/packet-ieee802a.c index 1b1028c083..56bcf94785 100644 --- a/epan/dissectors/packet-ieee802a.c +++ b/epan/dissectors/packet-ieee802a.c @@ -56,13 +56,13 @@ static GHashTable *oui_info_table = NULL; */ void ieee802a_add_oui(guint32 oui, const char *table_name, const char *table_ui_name, - hf_register_info *hf_item) + hf_register_info *hf_item, const int proto) { oui_info_t *new_info; new_info = (oui_info_t *)g_malloc(sizeof (oui_info_t)); new_info->table = register_dissector_table(table_name, - table_ui_name, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + table_ui_name, proto, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); new_info->field_info = hf_item; /* diff --git a/epan/dissectors/packet-ieee802a.h b/epan/dissectors/packet-ieee802a.h index 189740a31c..b37b147d2e 100644 --- a/epan/dissectors/packet-ieee802a.h +++ b/epan/dissectors/packet-ieee802a.h @@ -28,6 +28,6 @@ * Add an entry for a new OUI. */ WS_DLL_PUBLIC -void ieee802a_add_oui(guint32, const char *, const char *, hf_register_info *); +void ieee802a_add_oui(guint32, const char *, const char *, hf_register_info *, const int); #endif diff --git a/epan/dissectors/packet-igmp.c b/epan/dissectors/packet-igmp.c index 2b99620777..6e9d20da75 100644 --- a/epan/dissectors/packet-igmp.c +++ b/epan/dissectors/packet-igmp.c @@ -1109,7 +1109,7 @@ proto_register_igmp(void) proto_register_field_array(proto_igmp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - subdissector_table = register_dissector_table("igmp.type", "IGMP commands", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + subdissector_table = register_dissector_table("igmp.type", "IGMP commands", proto_igmp, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-infiniband.c b/epan/dissectors/packet-infiniband.c index 2159e15c30..bb977b31c9 100644 --- a/epan/dissectors/packet-infiniband.c +++ b/epan/dissectors/packet-infiniband.c @@ -7401,8 +7401,8 @@ void proto_register_infiniband(void) proto_register_subtree_array(ett, array_length(ett)); /* register the subdissector tables */ - heur_dissectors_payload = register_heur_dissector_list("infiniband.payload"); - heur_dissectors_cm_private = register_heur_dissector_list("infiniband.mad.cm.private"); + heur_dissectors_payload = register_heur_dissector_list("infiniband.payload", proto_infiniband); + heur_dissectors_cm_private = register_heur_dissector_list("infiniband.mad.cm.private", proto_infiniband); /* register dissection preferences */ infiniband_module = prefs_register_protocol(proto_infiniband, proto_reg_handoff_infiniband); diff --git a/epan/dissectors/packet-interlink.c b/epan/dissectors/packet-interlink.c index 726e495d30..983b3e21d6 100644 --- a/epan/dissectors/packet-interlink.c +++ b/epan/dissectors/packet-interlink.c @@ -219,7 +219,7 @@ proto_register_interlink(void) /* Probably someone will write sub-dissectors. You can never know. */ subdissector_table = register_dissector_table("interlink.type_version", - "Interlink type_version", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "Interlink type_version", proto_interlink, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-ip.c b/epan/dissectors/packet-ip.c index 078c6fb6c3..aa0368b328 100644 --- a/epan/dissectors/packet-ip.c +++ b/epan/dissectors/packet-ip.c @@ -3122,8 +3122,8 @@ proto_register_ip(void) /* subdissector code */ ip_dissector_table = register_dissector_table("ip.proto", "IP protocol", - FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - heur_subdissector_list = register_heur_dissector_list("ip"); + proto_ip, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + heur_subdissector_list = register_heur_dissector_list("ip", proto_ip); register_capture_dissector_table("ip.proto", "IP protocol"); /* Register configuration options */ diff --git a/epan/dissectors/packet-ipmi-trace.c b/epan/dissectors/packet-ipmi-trace.c index bec437a2ee..cbe96a70f1 100644 --- a/epan/dissectors/packet-ipmi-trace.c +++ b/epan/dissectors/packet-ipmi-trace.c @@ -441,7 +441,7 @@ proto_register_ipmi_trace(void) /* register dissector table for IPMI messaging protocols */ proto_dissector_table = register_dissector_table("ipmi.protocol", - "IPMI Channel Protocol Type", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "IPMI Channel Protocol Type", proto_ipmi_trace, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-ipv6.c b/epan/dissectors/packet-ipv6.c index ac94521350..52e1961674 100644 --- a/epan/dissectors/packet-ipv6.c +++ b/epan/dissectors/packet-ipv6.c @@ -3503,7 +3503,7 @@ proto_register_ipv6(void) proto_register_field_array(proto_ipv6_shim6, hf_ipv6_shim6, array_length(hf_ipv6_shim6)); proto_register_field_array(proto_ipv6_dstopts, hf_ipv6_dstopts, array_length(hf_ipv6_dstopts)); - ipv6_next_header_dissector_table = register_dissector_table("ipv6.nxt", "IPv6 Next Header", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + ipv6_next_header_dissector_table = register_dissector_table("ipv6.nxt", "IPv6 Next Header", proto_ipv6, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_capture_dissector_table("ipv6.nxt", "IPv6 Next Header"); /* Register configuration options */ diff --git a/epan/dissectors/packet-ipx.c b/epan/dissectors/packet-ipx.c index 592fa6266d..85eb2fff5b 100644 --- a/epan/dissectors/packet-ipx.c +++ b/epan/dissectors/packet-ipx.c @@ -1575,11 +1575,11 @@ proto_register_ipx(void) proto_register_subtree_array(ett, array_length(ett)); ipx_type_dissector_table = register_dissector_table("ipx.packet_type", - "IPX packet type", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "IPX packet type", proto_ipx, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); ipx_socket_dissector_table = register_dissector_table("ipx.socket", - "IPX socket", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "IPX socket", proto_ipx, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); spx_socket_dissector_table = register_dissector_table("spx.socket", - "SPX socket", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "SPX socket", proto_spx, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_init_routine(&spx_init_protocol); register_postseq_cleanup_routine(&spx_postseq_cleanup); diff --git a/epan/dissectors/packet-isi.c b/epan/dissectors/packet-isi.c index c3f98504bc..6e2b1519ab 100644 --- a/epan/dissectors/packet-isi.c +++ b/epan/dissectors/packet-isi.c @@ -2129,7 +2129,7 @@ proto_register_isi(void) expert_register_field_array(expert_isi, ei, array_length(ei)); /* create new dissector table for isi resource */ - isi_resource_dissector_table = register_dissector_table("isi.resource", "ISI resource", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + isi_resource_dissector_table = register_dissector_table("isi.resource", "ISI resource", proto_isi, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); } /* Handler registration */ diff --git a/epan/dissectors/packet-isis.c b/epan/dissectors/packet-isis.c index 34cf086b58..ec21ce96fb 100644 --- a/epan/dissectors/packet-isis.c +++ b/epan/dissectors/packet-isis.c @@ -212,7 +212,7 @@ proto_register_isis(void) isis_handle = register_dissector("isis", dissect_isis, proto_isis); isis_dissector_table = register_dissector_table("isis.type", - "ISIS Type", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + "ISIS Type", proto_isis, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-iso14443.c b/epan/dissectors/packet-iso14443.c index af72ca5710..838467eee7 100644 --- a/epan/dissectors/packet-iso14443.c +++ b/epan/dissectors/packet-iso14443.c @@ -1508,7 +1508,7 @@ proto_register_iso14443(void) iso14443_cmd_type_table = register_dissector_table( "iso14443.cmd_type", "ISO14443 Command Type", - FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + proto_iso14443, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); iso14443_handle = register_dissector("iso14443", dissect_iso14443, proto_iso14443); diff --git a/epan/dissectors/packet-iwarp-ddp-rdmap.c b/epan/dissectors/packet-iwarp-ddp-rdmap.c index 625f357457..ec65dbb15e 100644 --- a/epan/dissectors/packet-iwarp-ddp-rdmap.c +++ b/epan/dissectors/packet-iwarp-ddp-rdmap.c @@ -891,7 +891,7 @@ proto_register_iwarp_ddp_rdmap(void) proto_register_field_array(proto_iwarp_ddp_rdmap, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - rdmap_heur_subdissector_list = register_heur_dissector_list("iwarp_ddp_rdmap"); + rdmap_heur_subdissector_list = register_heur_dissector_list("iwarp_ddp_rdmap", proto_iwarp_ddp_rdmap); register_dissector("iwarp_ddp_rdmap", dissect_iwarp_ddp_rdmap, proto_iwarp_ddp_rdmap); diff --git a/epan/dissectors/packet-j1939.c b/epan/dissectors/packet-j1939.c index 199f5a63fb..0e4a21e434 100644 --- a/epan/dissectors/packet-j1939.c +++ b/epan/dissectors/packet-j1939.c @@ -348,7 +348,7 @@ void proto_register_j1939(void) proto_register_field_array(proto_j1939, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - subdissector_pgn_table = register_dissector_table("j1939.pgn", "PGN Handle", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + subdissector_pgn_table = register_dissector_table("j1939.pgn", "PGN Handle", proto_j1939, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); j1939_address_type = address_type_dissector_register("AT_J1939", "J1939 Address", J1939_addr_to_str, J1939_addr_str_len, J1939_col_filter_str, J1939_addr_len, NULL, NULL); } diff --git a/epan/dissectors/packet-juniper.c b/epan/dissectors/packet-juniper.c index 80fee3aac0..5d067dc7d6 100644 --- a/epan/dissectors/packet-juniper.c +++ b/epan/dissectors/packet-juniper.c @@ -1416,7 +1416,7 @@ proto_register_juniper(void) expert_juniper = expert_register_protocol(proto_juniper); expert_register_field_array(expert_juniper, ei, array_length(ei)); - payload_table = register_dissector_table("juniper.proto", "Juniper payload dissectors", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + payload_table = register_dissector_table("juniper.proto", "Juniper payload dissectors", proto_juniper, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-kdsp.c b/epan/dissectors/packet-kdsp.c index b304654dfb..9e2ad1b2e0 100644 --- a/epan/dissectors/packet-kdsp.c +++ b/epan/dissectors/packet-kdsp.c @@ -1145,7 +1145,7 @@ proto_register_kdsp(void) expert_kdsp = expert_register_protocol(proto_kdsp); expert_register_field_array(expert_kdsp, ei, array_length(ei)); - subdissector_dlt_table = register_dissector_table("kdsp.cpt.dlt", "KDSP DLT Type", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + subdissector_dlt_table = register_dissector_table("kdsp.cpt.dlt", "KDSP DLT Type", proto_kdsp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); prefs_register_uint_preference(kdsp_module, "tcp.port", "Kismet Drone TCP Port", diff --git a/epan/dissectors/packet-l2tp.c b/epan/dissectors/packet-l2tp.c index 4165759a2f..207b5f3e30 100644 --- a/epan/dissectors/packet-l2tp.c +++ b/epan/dissectors/packet-l2tp.c @@ -3427,8 +3427,8 @@ proto_register_l2tp(void) expert_l2tp = expert_register_protocol(proto_l2tp); expert_register_field_array(expert_l2tp, ei, array_length(ei)); - l2tp_vendor_avp_dissector_table = register_dissector_table("l2tp.vendor_avp", "L2TP vendor AVP dissector table", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - pw_type_table = register_dissector_table("l2tp.pw_type", "L2TPv3 payload type", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + l2tp_vendor_avp_dissector_table = register_dissector_table("l2tp.vendor_avp", "L2TP vendor AVP dissector table", proto_l2tp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + pw_type_table = register_dissector_table("l2tp.pw_type", "L2TPv3 payload type", proto_l2tp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); l2tp_module = prefs_register_protocol(proto_l2tp, NULL); diff --git a/epan/dissectors/packet-lapd.c b/epan/dissectors/packet-lapd.c index eb8612df52..a10c82cb4d 100644 --- a/epan/dissectors/packet-lapd.c +++ b/epan/dissectors/packet-lapd.c @@ -732,10 +732,10 @@ proto_register_lapd(void) register_dissector("lapd", dissect_lapd, proto_lapd); lapd_sapi_dissector_table = register_dissector_table("lapd.sapi", - "LAPD SAPI", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "LAPD SAPI", proto_lapd, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); lapd_gsm_sapi_dissector_table = register_dissector_table("lapd.gsm.sapi", - "LAPD GSM SAPI", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "LAPD GSM SAPI", proto_lapd, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); lapd_module = prefs_register_protocol(proto_lapd, proto_reg_handoff_lapd); diff --git a/epan/dissectors/packet-lapdm.c b/epan/dissectors/packet-lapdm.c index 03a89aacd0..e80a50c55b 100644 --- a/epan/dissectors/packet-lapdm.c +++ b/epan/dissectors/packet-lapdm.c @@ -492,7 +492,7 @@ proto_register_lapdm(void) register_dissector("lapdm", dissect_lapdm, proto_lapdm); - lapdm_sapi_dissector_table = register_dissector_table("lapdm.sapi", "LAPDm SAPI", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + lapdm_sapi_dissector_table = register_dissector_table("lapdm.sapi", "LAPDm SAPI", proto_lapdm, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); lapdm_module = prefs_register_protocol(proto_lapdm, NULL); prefs_register_bool_preference(lapdm_module, "reassemble", diff --git a/epan/dissectors/packet-lapsat.c b/epan/dissectors/packet-lapsat.c index 1fac52be72..0710ef9128 100644 --- a/epan/dissectors/packet-lapsat.c +++ b/epan/dissectors/packet-lapsat.c @@ -765,7 +765,7 @@ proto_register_lapsat(void) register_dissector("lapsat", dissect_lapsat, proto_lapsat); - lapsat_sapi_dissector_table = register_dissector_table("lapsat.sapi", "LAPSat SAPI", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + lapsat_sapi_dissector_table = register_dissector_table("lapsat.sapi", "LAPSat SAPI", proto_lapsat, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_init_routine (lapsat_defragment_init); register_cleanup_routine (lapsat_defragment_cleanup); diff --git a/epan/dissectors/packet-lbmc.c b/epan/dissectors/packet-lbmc.c index f6c8078fb3..b8c94837ae 100644 --- a/epan/dissectors/packet-lbmc.c +++ b/epan/dissectors/packet-lbmc.c @@ -14195,7 +14195,7 @@ void proto_register_lbmc(void) expert_lbmc = expert_register_protocol(proto_lbmc); expert_register_field_array(expert_lbmc, ei, array_length(ei)); - lbmc_heuristic_subdissector_list = register_heur_dissector_list("lbm_msg_payload"); + lbmc_heuristic_subdissector_list = register_heur_dissector_list("lbm_msg_payload", proto_lbmc); prefs_register_protocol(tnw_protocol_handle, NULL); lbmc_module = prefs_register_protocol_subtree("29West", proto_lbmc, proto_reg_handoff_lbmc); diff --git a/epan/dissectors/packet-lcsap.c b/epan/dissectors/packet-lcsap.c index e3d22f2403..8a147bfef3 100644 --- a/epan/dissectors/packet-lcsap.c +++ b/epan/dissectors/packet-lcsap.c @@ -2883,13 +2883,13 @@ void proto_register_lcsap(void) { register_dissector("lcsap", dissect_lcsap, proto_lcsap); /* Register dissector tables */ - lcsap_ies_dissector_table = register_dissector_table("lcsap.ies", "LCS-AP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lcsap_ies_dissector_table = register_dissector_table("lcsap.ies", "LCS-AP-PROTOCOL-IES", proto_lcsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lcsap_extension_dissector_table = register_dissector_table("lcsap.extension", "LCS-AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lcsap_proc_imsg_dissector_table = register_dissector_table("lcsap.proc.imsg", "LCS-AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lcsap_proc_sout_dissector_table = register_dissector_table("lcsap.proc.sout", "LCS-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lcsap_proc_uout_dissector_table = register_dissector_table("lcsap.proc.uout", "LCS-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lcsap_extension_dissector_table = register_dissector_table("lcsap.extension", "LCS-AP-PROTOCOL-EXTENSION", proto_lcsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lcsap_proc_imsg_dissector_table = register_dissector_table("lcsap.proc.imsg", "LCS-AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_lcsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lcsap_proc_sout_dissector_table = register_dissector_table("lcsap.proc.sout", "LCS-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_lcsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lcsap_proc_uout_dissector_table = register_dissector_table("lcsap.proc.uout", "LCS-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_lcsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Register configuration options for ports */ lcsap_module = prefs_register_protocol(proto_lcsap, proto_reg_handoff_lcsap); diff --git a/epan/dissectors/packet-ldap.c b/epan/dissectors/packet-ldap.c index 7f89998d01..6d0e827272 100644 --- a/epan/dissectors/packet-ldap.c +++ b/epan/dissectors/packet-ldap.c @@ -5821,7 +5821,7 @@ void proto_register_ldap(void) { register_cleanup_routine(ldap_cleanup); ldap_tap=register_tap("ldap"); - ldap_name_dissector_table = register_dissector_table("ldap.name", "LDAP Attribute Type Dissectors", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ldap_name_dissector_table = register_dissector_table("ldap.name", "LDAP Attribute Type Dissectors", proto_cldap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); register_srt_table(proto_ldap, NULL, 1, ldapstat_packet, ldapstat_init, NULL); } diff --git a/epan/dissectors/packet-llc.c b/epan/dissectors/packet-llc.c index 4d6a8a69bb..6cf7df684e 100644 --- a/epan/dissectors/packet-llc.c +++ b/epan/dissectors/packet-llc.c @@ -231,13 +231,13 @@ llc_sap_value( gchar *result, guint32 sap ) */ void llc_add_oui(guint32 oui, const char *table_name, const char *table_ui_name, - hf_register_info *hf_item) + hf_register_info *hf_item, const int proto) { oui_info_t *new_info; new_info = (oui_info_t *)g_malloc(sizeof (oui_info_t)); new_info->table = register_dissector_table(table_name, - table_ui_name, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + table_ui_name, proto, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); new_info->field_info = hf_item; /* @@ -819,9 +819,9 @@ proto_register_llc(void) /* subdissector code */ dsap_subdissector_table = register_dissector_table("llc.dsap", - "LLC SAP", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "LLC SAP", proto_llc, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); xid_subdissector_table = register_dissector_table("llc.xid_dsap", - "LLC XID SAP", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "LLC XID SAP", proto_llc, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_capture_dissector_table("llc.dsap", "LLC"); register_dissector("llc", dissect_llc, proto_llc); diff --git a/epan/dissectors/packet-llc.h b/epan/dissectors/packet-llc.h index 11e7418264..24c7b9ba3c 100644 --- a/epan/dissectors/packet-llc.h +++ b/epan/dissectors/packet-llc.h @@ -37,7 +37,7 @@ void dissect_snap(tvbuff_t *, int, packet_info *, proto_tree *, * Add an entry for a new OUI. */ WS_DLL_PUBLIC -void llc_add_oui(guint32, const char *, const char *, hf_register_info *); +void llc_add_oui(guint32, const char *, const char *, hf_register_info *, const int); /* * SNAP information about the PID for a particular OUI: diff --git a/epan/dissectors/packet-lldp.c b/epan/dissectors/packet-lldp.c index c967619e16..5bb12647e9 100644 --- a/epan/dissectors/packet-lldp.c +++ b/epan/dissectors/packet-lldp.c @@ -5095,7 +5095,7 @@ proto_register_lldp(void) /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_lldp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - oui_unique_code_table = register_dissector_table("lldp.orgtlv.oui", "LLDP OUI", FT_UINT24, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE ); + oui_unique_code_table = register_dissector_table("lldp.orgtlv.oui", "LLDP OUI", proto_lldp, FT_UINT24, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE ); expert_lldp = expert_register_protocol(proto_lldp); expert_register_field_array(expert_lldp, ei, array_length(ei)); diff --git a/epan/dissectors/packet-lppa.c b/epan/dissectors/packet-lppa.c index 9080e44240..b43a22d413 100644 --- a/epan/dissectors/packet-lppa.c +++ b/epan/dissectors/packet-lppa.c @@ -2939,10 +2939,10 @@ void proto_register_lppa(void) { proto_register_subtree_array(ett, array_length(ett)); /* Register dissector tables */ - lppa_ies_dissector_table = register_dissector_table("lppa.ies", "LPPA-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lppa_proc_imsg_dissector_table = register_dissector_table("lppa.proc.imsg", "LPPA-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lppa_proc_sout_dissector_table = register_dissector_table("lppa.proc.sout", "LPPA-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - lppa_proc_uout_dissector_table = register_dissector_table("lppa.proc.uout", "LPPA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lppa_ies_dissector_table = register_dissector_table("lppa.ies", "LPPA-PROTOCOL-IES", proto_lppa, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lppa_proc_imsg_dissector_table = register_dissector_table("lppa.proc.imsg", "LPPA-ELEMENTARY-PROCEDURE InitiatingMessage", proto_lppa, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lppa_proc_sout_dissector_table = register_dissector_table("lppa.proc.sout", "LPPA-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_lppa, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + lppa_proc_uout_dissector_table = register_dissector_table("lppa.proc.uout", "LPPA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_lppa, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); } /*--- proto_reg_handoff_lppa ---------------------------------------*/ diff --git a/epan/dissectors/packet-m3ap.c b/epan/dissectors/packet-m3ap.c index 184575613a..ce20fffe37 100644 --- a/epan/dissectors/packet-m3ap.c +++ b/epan/dissectors/packet-m3ap.c @@ -2542,11 +2542,11 @@ void proto_register_m3ap(void) { expert_register_field_array(expert_m3ap, ei, array_length(ei)); /* Register dissector tables */ - m3ap_ies_dissector_table = register_dissector_table("m3ap.ies", "M3AP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - m3ap_extension_dissector_table = register_dissector_table("m3ap.extension", "M3AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - m3ap_proc_imsg_dissector_table = register_dissector_table("m3ap.proc.imsg", "M3AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - m3ap_proc_sout_dissector_table = register_dissector_table("m3ap.proc.sout", "M3AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - m3ap_proc_uout_dissector_table = register_dissector_table("m3ap.proc.uout", "M3AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + m3ap_ies_dissector_table = register_dissector_table("m3ap.ies", "M3AP-PROTOCOL-IES", proto_m3ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + m3ap_extension_dissector_table = register_dissector_table("m3ap.extension", "M3AP-PROTOCOL-EXTENSION", proto_m3ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + m3ap_proc_imsg_dissector_table = register_dissector_table("m3ap.proc.imsg", "M3AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_m3ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + m3ap_proc_sout_dissector_table = register_dissector_table("m3ap.proc.sout", "M3AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_m3ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + m3ap_proc_uout_dissector_table = register_dissector_table("m3ap.proc.uout", "M3AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_m3ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-mausb.c b/epan/dissectors/packet-mausb.c index 54a1e36be2..84ca1f0b0d 100644 --- a/epan/dissectors/packet-mausb.c +++ b/epan/dissectors/packet-mausb.c @@ -37,7 +37,6 @@ void proto_reg_handoff_mausb(void); void proto_register_mausb(void); -void proto_register_wfa_oui(void); /* For SNAP Packets */ static int hf_llc_mausb_pid = -1; @@ -2191,6 +2190,13 @@ proto_register_mausb(void) }, }; + static hf_register_info oui_hf[] = { + { &hf_llc_mausb_pid, + { "PID", "mausb.pid", FT_UINT16, BASE_HEX, + VALS(mausb_pid_string), 0x0, NULL, HFILL } + } + }; + /* Setup protocol subtree array */ static gint *ett[] = { &ett_mausb, @@ -2272,6 +2278,7 @@ proto_register_mausb(void) "Set the port for Media Agnostic Packets", 10, &mausb_udp_port_pref); + llc_add_oui(OUI_WFA, "llc.wfa_pid", "LLC WFA OUI PID", oui_hf, proto_mausb); } void @@ -2307,19 +2314,6 @@ proto_reg_handoff_mausb(void) dissector_add_uint("udp.port", mausb_udp_port_pref, mausb_pkt_handle); } -void -proto_register_wfa_oui(void) -{ - static hf_register_info hf[] = { - { &hf_llc_mausb_pid, - { "PID", "mausb.pid", FT_UINT16, BASE_HEX, - VALS(mausb_pid_string), 0x0, NULL, HFILL } - } - }; - - llc_add_oui(OUI_WFA, "llc.wfa_pid", "LLC WFA OUI PID", hf); -} - /* * Editor modelines - http://www.wireshark.org/tools/modelines.html * diff --git a/epan/dissectors/packet-mbim.c b/epan/dissectors/packet-mbim.c index 5d72ec3b27..35d19592bf 100644 --- a/epan/dissectors/packet-mbim.c +++ b/epan/dissectors/packet-mbim.c @@ -8000,7 +8000,7 @@ proto_register_mbim(void) register_dissector("mbim.descriptor", dissect_mbim_descriptor, proto_mbim); register_dissector("mbim.bulk", dissect_mbim_bulk, proto_mbim); dss_dissector_table = register_dissector_table("mbim.dss_session_id", - "MBIM DSS Session Id", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "MBIM DSS Session Id", proto_mbim, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); mbim_module = prefs_register_protocol(proto_mbim, proto_reg_handoff_mbim); prefs_register_obsolete_preference(mbim_module, "bulk_heuristic"); diff --git a/epan/dissectors/packet-mbtcp.c b/epan/dissectors/packet-mbtcp.c index dbc2058a5f..2cb213f8cb 100644 --- a/epan/dissectors/packet-mbtcp.c +++ b/epan/dissectors/packet-mbtcp.c @@ -1912,8 +1912,8 @@ proto_register_modbus(void) mbrtu_handle = register_dissector("mbrtu", dissect_mbrtu, proto_mbrtu); /* Registering subdissectors table */ - modbus_data_dissector_table = register_dissector_table("modbus.data", "Modbus Data", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - modbus_dissector_table = register_dissector_table("mbtcp.prot_id", "Modbus/TCP protocol identifier", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + modbus_data_dissector_table = register_dissector_table("modbus.data", "Modbus Data", proto_modbus, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + modbus_dissector_table = register_dissector_table("mbtcp.prot_id", "Modbus/TCP protocol identifier", proto_mbtcp, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_mbtcp, mbtcp_hf, array_length(mbtcp_hf)); diff --git a/epan/dissectors/packet-media.c b/epan/dissectors/packet-media.c index 9daead7d85..5e6355f060 100644 --- a/epan/dissectors/packet-media.c +++ b/epan/dissectors/packet-media.c @@ -101,7 +101,7 @@ proto_register_media(void) "media" /* abbrev */ ); register_dissector("media", dissect_media, proto_media); - heur_subdissector_list = register_heur_dissector_list("media"); + heur_subdissector_list = register_heur_dissector_list("media", proto_media); proto_register_field_array(proto_media, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); diff --git a/epan/dissectors/packet-meta.c b/epan/dissectors/packet-meta.c index 16759baf0d..f0e093c189 100644 --- a/epan/dissectors/packet-meta.c +++ b/epan/dissectors/packet-meta.c @@ -797,7 +797,7 @@ proto_register_meta(void) expert_register_field_array(expert_meta, ei, array_length(ei)); meta_dissector_table = register_dissector_table("meta.proto", - "META protocol", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "META protocol", proto_meta, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-mime-encap.c b/epan/dissectors/packet-mime-encap.c index cf867ec7af..a598f9457b 100644 --- a/epan/dissectors/packet-mime-encap.c +++ b/epan/dissectors/packet-mime-encap.c @@ -57,7 +57,7 @@ proto_register_mime_encap(void) proto_mime_encap = proto_register_protocol("MIME file", "MIME_FILE", "mime_dlt"); register_dissector("mime_dlt", dissect_mime_encap, proto_mime_encap); - heur_subdissector_list = register_heur_dissector_list("wtap_file"); + heur_subdissector_list = register_heur_dissector_list("wtap_file", proto_mime_encap); } void diff --git a/epan/dissectors/packet-mip.c b/epan/dissectors/packet-mip.c index c00260edcc..d25a013f13 100644 --- a/epan/dissectors/packet-mip.c +++ b/epan/dissectors/packet-mip.c @@ -1471,7 +1471,7 @@ void proto_register_mip(void) expert_register_field_array(expert_mip, ei, array_length(ei)); mip_nvse_ext_dissector_table = register_dissector_table("mip.nvse_ext", - "MIP Normal Vendor/Organization Specific Extension", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + "MIP Normal Vendor/Organization Specific Extension", proto_mip, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-mip6.c b/epan/dissectors/packet-mip6.c index c216b66e37..ecd79740b1 100644 --- a/epan/dissectors/packet-mip6.c +++ b/epan/dissectors/packet-mip6.c @@ -5422,7 +5422,7 @@ proto_register_mip6(void) expert_mip6 = expert_register_protocol(proto_mip6); expert_register_field_array(expert_mip6, ei, array_length(ei)); - mip6_vsm_dissector_table = register_dissector_table("mip6.vsm", "Mobile IPv6 vendor specific option", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + mip6_vsm_dissector_table = register_dissector_table("mip6.vsm", "Mobile IPv6 vendor specific option", proto_mip6, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-moldudp64.c b/epan/dissectors/packet-moldudp64.c index 00c1a821a7..c8ea55412a 100644 --- a/epan/dissectors/packet-moldudp64.c +++ b/epan/dissectors/packet-moldudp64.c @@ -279,7 +279,7 @@ proto_register_moldudp64(void) proto_moldudp64 = proto_register_protocol("MoldUDP64", "MoldUDP64", "moldudp64"); - moldudp64_payload_table = register_dissector_table("moldudp64.payload", "MoldUDP64 Payload", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + moldudp64_payload_table = register_dissector_table("moldudp64.payload", "MoldUDP64 Payload", proto_moldudp64, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_moldudp64, hf, array_length(hf)); diff --git a/epan/dissectors/packet-mp2t.c b/epan/dissectors/packet-mp2t.c index d1236d430f..a0922c40a0 100644 --- a/epan/dissectors/packet-mp2t.c +++ b/epan/dissectors/packet-mp2t.c @@ -1541,7 +1541,7 @@ proto_register_mp2t(void) mp2t_no_address_type = address_type_dissector_register("AT_MP2T_NONE", "No MP2T Address", none_addr_to_str, none_addr_str_len, NULL, none_addr_len, NULL, NULL); - heur_subdissector_list = register_heur_dissector_list("mp2t.pid"); + heur_subdissector_list = register_heur_dissector_list("mp2t.pid", proto_mp2t); /* Register init of processing of fragmented DEPI packets */ register_init_routine(mp2t_init); register_cleanup_routine(mp2t_cleanup); diff --git a/epan/dissectors/packet-mpeg-pes.c b/epan/dissectors/packet-mpeg-pes.c index 9c2c30e053..c5ce31ce55 100644 --- a/epan/dissectors/packet-mpeg-pes.c +++ b/epan/dissectors/packet-mpeg-pes.c @@ -1312,7 +1312,7 @@ proto_register_mpeg_pes(void) proto_mpeg = proto_register_protocol( "Moving Picture Experts Group", "MPEG", "mpeg"); register_dissector("mpeg", dissect_mpeg, proto_mpeg); - heur_subdissector_list = register_heur_dissector_list("mpeg"); + heur_subdissector_list = register_heur_dissector_list("mpeg", proto_mpeg); proto_mpeg_pes = proto_register_protocol( "Packetized Elementary Stream", "MPEG PES", "mpeg-pes"); diff --git a/epan/dissectors/packet-mpeg-sect.c b/epan/dissectors/packet-mpeg-sect.c index 0f4db406ff..5ab94ef483 100644 --- a/epan/dissectors/packet-mpeg-sect.c +++ b/epan/dissectors/packet-mpeg-sect.c @@ -380,7 +380,7 @@ proto_register_mpeg_sect(void) mpeg_sect_tid_dissector_table = register_dissector_table("mpeg_sect.tid", "MPEG SECT Table ID", - FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_mpeg_sect, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-mpls.c b/epan/dissectors/packet-mpls.c index 4d8aa0af27..5d1cf705b3 100644 --- a/epan/dissectors/packet-mpls.c +++ b/epan/dissectors/packet-mpls.c @@ -587,10 +587,6 @@ proto_register_mpls(void) expert_module_t* expert_mpls; module_t * module_mpls; - /* FF: mpls subdissector table is indexed by label */ - mpls_subdissector_table = register_dissector_table("mpls.label", - "MPLS protocol", - FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); proto_mpls = proto_register_protocol("MultiProtocol Label Switching Header", "MPLS", "mpls"); proto_pw_ach = proto_register_protocol(PW_ACH, @@ -605,7 +601,12 @@ proto_register_mpls(void) register_dissector("mpls", dissect_mpls, proto_mpls); - pw_ach_subdissector_table = register_dissector_table("pwach.channel_type", "PW Associated Channel Type", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + /* FF: mpls subdissector table is indexed by label */ + mpls_subdissector_table = register_dissector_table("mpls.label", + "MPLS protocol", + proto_mpls, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + + pw_ach_subdissector_table = register_dissector_table("pwach.channel_type", "PW Associated Channel Type", proto_pw_ach, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); module_mpls = prefs_register_protocol( proto_mpls, NULL ); diff --git a/epan/dissectors/packet-mq.c b/epan/dissectors/packet-mq.c index 01358fb1f7..69f1aebf62 100644 --- a/epan/dissectors/packet-mq.c +++ b/epan/dissectors/packet-mq.c @@ -4757,7 +4757,7 @@ void proto_register_mq(void) proto_register_field_array(proto_mq, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - mq_heur_subdissector_list = register_heur_dissector_list("mq"); + mq_heur_subdissector_list = register_heur_dissector_list("mq", proto_mq); register_init_routine(mq_init); register_cleanup_routine(mq_cleanup); diff --git a/epan/dissectors/packet-mstp.c b/epan/dissectors/packet-mstp.c index 6102d6d709..eafdd2a260 100644 --- a/epan/dissectors/packet-mstp.c +++ b/epan/dissectors/packet-mstp.c @@ -463,7 +463,7 @@ proto_register_mstp(void) register_dissector("mstp", dissect_mstp_wtap, proto_mstp); subdissector_table = register_dissector_table("mstp.vendor_frame_type", - "MSTP Vendor specific Frametypes", FT_UINT24, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "MSTP Vendor specific Frametypes", proto_mstp, FT_UINT24, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Table_type: (Vendor ID << 16) + Frametype */ mstp_address_type = address_type_dissector_register("AT_MSTP", "BACnet MS/TP Address", mstp_to_str, mstp_str_len, mstp_col_filter_str, mstp_len, NULL, NULL); diff --git a/epan/dissectors/packet-mtp3.c b/epan/dissectors/packet-mtp3.c index f047786318..87ee9657cd 100644 --- a/epan/dissectors/packet-mtp3.c +++ b/epan/dissectors/packet-mtp3.c @@ -1057,7 +1057,7 @@ proto_register_mtp3(void) mtp3_sio_dissector_table = register_dissector_table("mtp3.service_indicator", "MTP3 Service indicator", - FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_mtp3, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); mtp3_tap = register_tap("mtp3"); diff --git a/epan/dissectors/packet-multipart.c b/epan/dissectors/packet-multipart.c index c801df78bd..3870b6f677 100644 --- a/epan/dissectors/packet-multipart.c +++ b/epan/dissectors/packet-multipart.c @@ -1180,7 +1180,7 @@ proto_register_multipart(void) multipart_media_subdissector_table = register_dissector_table( "multipart_media_type", "Internet media type (for multipart processing)", - FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_multipart, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-nbap.c b/epan/dissectors/packet-nbap.c index 86ac8b417b..9f21f0269d 100644 --- a/epan/dissectors/packet-nbap.c +++ b/epan/dissectors/packet-nbap.c @@ -70192,11 +70192,11 @@ void proto_register_nbap(void) } /* Register dissector tables */ - nbap_ies_dissector_table = register_dissector_table("nbap.ies", "NBAP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - nbap_extension_dissector_table = register_dissector_table("nbap.extension", "NBAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - nbap_proc_imsg_dissector_table = register_dissector_table("nbap.proc.imsg", "NBAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - nbap_proc_sout_dissector_table = register_dissector_table("nbap.proc.sout", "NBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - nbap_proc_uout_dissector_table = register_dissector_table("nbap.proc.uout", "NBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nbap_ies_dissector_table = register_dissector_table("nbap.ies", "NBAP-PROTOCOL-IES", proto_nbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nbap_extension_dissector_table = register_dissector_table("nbap.extension", "NBAP-PROTOCOL-EXTENSION", proto_nbap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nbap_proc_imsg_dissector_table = register_dissector_table("nbap.proc.imsg", "NBAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_nbap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nbap_proc_sout_dissector_table = register_dissector_table("nbap.proc.sout", "NBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_nbap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + nbap_proc_uout_dissector_table = register_dissector_table("nbap.proc.uout", "NBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_nbap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); register_init_routine(nbap_init); register_cleanup_routine(nbap_cleanup); diff --git a/epan/dissectors/packet-netbios.c b/epan/dissectors/packet-netbios.c index eeb205de97..7da3f3470b 100644 --- a/epan/dissectors/packet-netbios.c +++ b/epan/dissectors/packet-netbios.c @@ -1470,7 +1470,7 @@ proto_register_netbios(void) expert_register_field_array(expert_netbios, ei, array_length(ei)); - netbios_heur_subdissector_list = register_heur_dissector_list("netbios"); + netbios_heur_subdissector_list = register_heur_dissector_list("netbios", proto_netbios); netbios_module = prefs_register_protocol(proto_netbios, NULL); prefs_register_bool_preference(netbios_module, "defragment", diff --git a/epan/dissectors/packet-netlink.c b/epan/dissectors/packet-netlink.c index 4b9d3e3006..eb09d266b8 100644 --- a/epan/dissectors/packet-netlink.c +++ b/epan/dissectors/packet-netlink.c @@ -413,7 +413,7 @@ proto_register_netlink(void) netlink_dissector_table = register_dissector_table( "netlink.protocol", "Linux netlink protocol type", - FT_UINT16, + proto_netlink, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE ); register_dissector("netlink", dissect_netlink, proto_netlink); diff --git a/epan/dissectors/packet-nfs.c b/epan/dissectors/packet-nfs.c index cdd337d390..f38d7c74cb 100644 --- a/epan/dissectors/packet-nfs.c +++ b/epan/dissectors/packet-nfs.c @@ -13732,7 +13732,7 @@ proto_register_nfs(void) &display_major_nfs4_ops); nfs_fhandle_table = register_dissector_table("nfs_fhandle.type", - "NFS Filehandle types", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "NFS Filehandle types", proto_nfs, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); prefs_register_obsolete_preference(nfs_module, "default_fhandle_type"); diff --git a/epan/dissectors/packet-nt-oui.c b/epan/dissectors/packet-nt-oui.c index 36208f9174..7e70694d3e 100644 --- a/epan/dissectors/packet-nt-oui.c +++ b/epan/dissectors/packet-nt-oui.c @@ -51,7 +51,7 @@ proto_register_nortel_oui(void) } }; - llc_add_oui(OUI_NORTEL, "llc.nortel_pid", "LLC Nortel OUI PID", hf); + llc_add_oui(OUI_NORTEL, "llc.nortel_pid", "LLC Nortel OUI PID", hf, -1); } /* diff --git a/epan/dissectors/packet-null.c b/epan/dissectors/packet-null.c index ac9a239277..0c2ce19424 100644 --- a/epan/dissectors/packet-null.c +++ b/epan/dissectors/packet-null.c @@ -526,7 +526,7 @@ proto_register_null(void) /* subdissector code */ null_dissector_table = register_dissector_table("null.type", - "Null type", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "Null type", proto_null, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-obex.c b/epan/dissectors/packet-obex.c index e7dc2447f3..59c0664a73 100644 --- a/epan/dissectors/packet-obex.c +++ b/epan/dissectors/packet-obex.c @@ -3821,7 +3821,7 @@ proto_register_obex(void) obex_handle = register_dissector("obex", dissect_obex, proto_obex); - obex_profile_table = register_dissector_table("obex.profile", "OBEX Profile", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + obex_profile_table = register_dissector_table("obex.profile", "OBEX Profile", proto_obex, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_obex, hf, array_length(hf)); diff --git a/epan/dissectors/packet-opensafety.c b/epan/dissectors/packet-opensafety.c index 271ae0250c..54126a9bde 100644 --- a/epan/dissectors/packet-opensafety.c +++ b/epan/dissectors/packet-opensafety.c @@ -2754,7 +2754,7 @@ proto_register_opensafety(void) opensafety_module = prefs_register_protocol(proto_opensafety, apply_prefs); /* Register data dissector */ - heur_opensafety_spdo_subdissector_list = register_heur_dissector_list("opensafety.spdo"); + heur_opensafety_spdo_subdissector_list = register_heur_dissector_list("opensafety.spdo", proto_opensafety); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_opensafety, hf, array_length(hf)); diff --git a/epan/dissectors/packet-osi.c b/epan/dissectors/packet-osi.c index 5a1ea2b5ae..9c00ddea41 100644 --- a/epan/dissectors/packet-osi.c +++ b/epan/dissectors/packet-osi.c @@ -576,6 +576,9 @@ proto_register_osi(void) }; module_t *osi_module; + proto_osi = proto_register_protocol("OSI", "OSI", "osi"); + proto_register_field_array(proto_osi, hf, array_length(hf)); + /* There's no "OSI" protocol *per se*, but we do register a dissector table so various protocols running at the network layer can register themselves. @@ -583,16 +586,14 @@ proto_register_osi(void) should register here */ osinl_incl_subdissector_table = register_dissector_table("osinl.incl", - "OSI incl NLPID", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "OSI incl NLPID", proto_osi, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* This dissector table is for those protocols whose PDUs * aren't* defined to begin with an NLPID. * (typically non OSI protocols like IP,IPv6,PPP */ osinl_excl_subdissector_table = register_dissector_table("osinl.excl", - "OSI excl NLPID", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "OSI excl NLPID", proto_osi, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - proto_osi = proto_register_protocol("OSI", "OSI", "osi"); - proto_register_field_array(proto_osi, hf, array_length(hf)); /* Preferences how OSI protocols should be dissected */ osi_module = prefs_register_protocol(proto_osi, proto_reg_handoff_osi); diff --git a/epan/dissectors/packet-ositp.c b/epan/dissectors/packet-ositp.c index 72f05db85f..344e26b8c7 100644 --- a/epan/dissectors/packet-ositp.c +++ b/epan/dissectors/packet-ositp.c @@ -2423,14 +2423,14 @@ void proto_register_cotp(void) "settings.", &cotp_decode_atn); /* For handling protocols hijacking the variable part of CR or CC PDUs */ - cotp_cr_heur_subdissector_list = register_heur_dissector_list("cotp_cr"); - cotp_cc_heur_subdissector_list = register_heur_dissector_list("cotp_cc"); + cotp_cr_heur_subdissector_list = register_heur_dissector_list("cotp_cr", proto_cotp); + cotp_cc_heur_subdissector_list = register_heur_dissector_list("cotp_cc", proto_cotp); /* subdissector code in inactive subset */ - cotp_is_heur_subdissector_list = register_heur_dissector_list("cotp_is"); + cotp_is_heur_subdissector_list = register_heur_dissector_list("cotp_is", proto_cotp); /* other COTP/ISO 8473 subdissectors */ - cotp_heur_subdissector_list = register_heur_dissector_list("cotp"); + cotp_heur_subdissector_list = register_heur_dissector_list("cotp", proto_cotp); /* XXX - what about CLTP and proto_cltp? */ register_dissector("ositp", dissect_ositp, proto_cotp); @@ -2458,7 +2458,7 @@ void proto_register_cltp(void) proto_register_field_array(proto_cltp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - cltp_heur_subdissector_list = register_heur_dissector_list("cltp"); + cltp_heur_subdissector_list = register_heur_dissector_list("cltp", proto_cltp); } void diff --git a/epan/dissectors/packet-p1.c b/epan/dissectors/packet-p1.c index df9c81ade5..dd8e972f8a 100644 --- a/epan/dissectors/packet-p1.c +++ b/epan/dissectors/packet-p1.c @@ -11105,9 +11105,9 @@ void proto_register_p1(void) { expert_p1 = expert_register_protocol(proto_p1); expert_register_field_array(expert_p1, ei, array_length(ei)); - p1_extension_dissector_table = register_dissector_table("p1.extension", "P1-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - p1_extension_attribute_dissector_table = register_dissector_table("p1.extension-attribute", "P1-EXTENSION-ATTRIBUTE", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - p1_tokendata_dissector_table = register_dissector_table("p1.tokendata", "P1-TOKENDATA", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + p1_extension_dissector_table = register_dissector_table("p1.extension", "P1-EXTENSION", proto_p1, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + p1_extension_attribute_dissector_table = register_dissector_table("p1.extension-attribute", "P1-EXTENSION-ATTRIBUTE", proto_p1, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + p1_tokendata_dissector_table = register_dissector_table("p1.tokendata", "P1-TOKENDATA", proto_p1, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Register our configuration options for P1, particularly our port */ diff --git a/epan/dissectors/packet-pcap.c b/epan/dissectors/packet-pcap.c index 7e19c0fef2..8baa3f180e 100644 --- a/epan/dissectors/packet-pcap.c +++ b/epan/dissectors/packet-pcap.c @@ -18721,14 +18721,14 @@ void proto_register_pcap(void) { register_dissector("pcap", dissect_pcap, proto_pcap); /* Register dissector tables */ - pcap_ies_dissector_table = register_dissector_table("pcap.ies", "PCAP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_ies_p1_dissector_table = register_dissector_table("pcap.ies.pair.first", "PCAP-PROTOCOL-IES-PAIR FirstValue", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_ies_p2_dissector_table = register_dissector_table("pcap.ies.pair.second", "PCAP-PROTOCOL-IES-PAIR SecondValue", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_extension_dissector_table = register_dissector_table("pcap.extension", "PCAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_proc_imsg_dissector_table = register_dissector_table("pcap.proc.imsg", "PCAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_proc_sout_dissector_table = register_dissector_table("pcap.proc.sout", "PCAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_proc_uout_dissector_table = register_dissector_table("pcap.proc.uout", "PCAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - pcap_proc_out_dissector_table = register_dissector_table("pcap.proc.out", "PCAP-ELEMENTARY-PROCEDURE Outcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_ies_dissector_table = register_dissector_table("pcap.ies", "PCAP-PROTOCOL-IES", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_ies_p1_dissector_table = register_dissector_table("pcap.ies.pair.first", "PCAP-PROTOCOL-IES-PAIR FirstValue", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_ies_p2_dissector_table = register_dissector_table("pcap.ies.pair.second", "PCAP-PROTOCOL-IES-PAIR SecondValue", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_extension_dissector_table = register_dissector_table("pcap.extension", "PCAP-PROTOCOL-EXTENSION", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_proc_imsg_dissector_table = register_dissector_table("pcap.proc.imsg", "PCAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_proc_sout_dissector_table = register_dissector_table("pcap.proc.sout", "PCAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_proc_uout_dissector_table = register_dissector_table("pcap.proc.uout", "PCAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + pcap_proc_out_dissector_table = register_dissector_table("pcap.proc.out", "PCAP-ELEMENTARY-PROCEDURE Outcome", proto_pcap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Preferences */ diff --git a/epan/dissectors/packet-pcapng_block.c b/epan/dissectors/packet-pcapng_block.c index a8a8b1342d..31b83309f8 100644 --- a/epan/dissectors/packet-pcapng_block.c +++ b/epan/dissectors/packet-pcapng_block.c @@ -59,7 +59,7 @@ void proto_register_pcapng_block(void) proto_pcapng_block = proto_register_protocol("PCAP-NG block", "PCAP-NG", "pcapng"); pcapng_block_type_dissector_table = register_dissector_table("pcapng.block_type", - "pcap-ng block type", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "pcap-ng block type", proto_pcapng_block, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-pcli.c b/epan/dissectors/packet-pcli.c index 31729c5355..51a6011afa 100644 --- a/epan/dissectors/packet-pcli.c +++ b/epan/dissectors/packet-pcli.c @@ -271,7 +271,7 @@ proto_register_pcli(void) pcli_subdissector_table = register_dissector_table( "pcli.payload", "PCLI payload dissector", - FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_pcli, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_decode_as(&pcli_payload_da); } diff --git a/epan/dissectors/packet-per.c b/epan/dissectors/packet-per.c index ca02072bbc..979033accd 100644 --- a/epan/dissectors/packet-per.c +++ b/epan/dissectors/packet-per.c @@ -2728,7 +2728,7 @@ proto_register_per(void) "Whether the dissector should put the internal PER data in the tree or if it should hide it", &display_internal_per_fields); - per_oid_dissector_table = register_dissector_table("per.oid", "PER OID Dissectors", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + per_oid_dissector_table = register_dissector_table("per.oid", "PER OID Dissectors", proto_per, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-pgm.c b/epan/dissectors/packet-pgm.c index 2be8d4370c..d46689df20 100644 --- a/epan/dissectors/packet-pgm.c +++ b/epan/dissectors/packet-pgm.c @@ -1402,8 +1402,8 @@ proto_register_pgm(void) /* subdissector code */ subdissector_table = register_dissector_table("pgm.port", - "PGM port", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - heur_subdissector_list = register_heur_dissector_list("pgm"); + "PGM port", proto_pgm, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + heur_subdissector_list = register_heur_dissector_list("pgm", proto_pgm); /* * Register configuration preferences for UDP encapsulation diff --git a/epan/dissectors/packet-ppp.c b/epan/dissectors/packet-ppp.c index e8d914ab94..8940e38bbc 100644 --- a/epan/dissectors/packet-ppp.c +++ b/epan/dissectors/packet-ppp.c @@ -5936,7 +5936,7 @@ proto_register_ppp(void) /* subdissector code */ ppp_subdissector_table = register_dissector_table("ppp.protocol", - "PPP protocol", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "PPP protocol", proto_ppp, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_dissector("ppp_hdlc", dissect_ppp_hdlc, proto_ppp); register_dissector("ppp_lcp_options", dissect_lcp_options, proto_ppp); diff --git a/epan/dissectors/packet-q931.c b/epan/dissectors/packet-q931.c index 654f03c004..fbe317b3f4 100644 --- a/epan/dissectors/packet-q931.c +++ b/epan/dissectors/packet-q931.c @@ -3975,9 +3975,9 @@ proto_register_q931(void) register_dissector("q931.ie.cs7", dissect_q931_ie_cs7, proto_q931); /* subdissector code */ - codeset_dissector_table = register_dissector_table("q931.codeset", "Q.931 Codeset", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ie_dissector_table = register_dissector_table("q931.ie", "Q.931 IE", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - q931_user_heur_subdissector_list = register_heur_dissector_list("q931_user"); + codeset_dissector_table = register_dissector_table("q931.codeset", "Q.931 Codeset", proto_q931, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ie_dissector_table = register_dissector_table("q931.ie", "Q.931 IE", proto_q931, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + q931_user_heur_subdissector_list = register_heur_dissector_list("q931_user", proto_q931); q931_module = prefs_register_protocol(proto_q931, NULL); prefs_register_bool_preference(q931_module, "desegment_h323_messages", diff --git a/epan/dissectors/packet-q932.c b/epan/dissectors/packet-q932.c index 33881270a0..92a748e031 100644 --- a/epan/dissectors/packet-q932.c +++ b/epan/dissectors/packet-q932.c @@ -1096,17 +1096,17 @@ void proto_register_q932(void) { rose_ctx_init(&q932_rose_ctx); /* Register dissector tables */ - q932_rose_ctx.arg_global_dissector_table = register_dissector_table("q932.ros.global.arg", "Q.932 Operation Argument (global opcode)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - q932_rose_ctx.res_global_dissector_table = register_dissector_table("q932.ros.global.res", "Q.932 Operation Result (global opcode)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - q932_rose_ctx.err_global_dissector_table = register_dissector_table("q932.ros.global.err", "Q.932 Error (global opcode)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + q932_rose_ctx.arg_global_dissector_table = register_dissector_table("q932.ros.global.arg", "Q.932 Operation Argument (global opcode)", proto_q932, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + q932_rose_ctx.res_global_dissector_table = register_dissector_table("q932.ros.global.res", "Q.932 Operation Result (global opcode)", proto_q932, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + q932_rose_ctx.err_global_dissector_table = register_dissector_table("q932.ros.global.err", "Q.932 Error (global opcode)", proto_q932, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - qsig_arg_local_dissector_table = register_dissector_table("q932.ros.local.arg", "Q.932 Operation Argument (local opcode)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - qsig_res_local_dissector_table = register_dissector_table("q932.ros.local.res", "Q.932 Operation Result (local opcode)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - qsig_err_local_dissector_table = register_dissector_table("q932.ros.local.err", "Q.932 Error (local opcode)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + qsig_arg_local_dissector_table = register_dissector_table("q932.ros.local.arg", "Q.932 Operation Argument (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + qsig_res_local_dissector_table = register_dissector_table("q932.ros.local.res", "Q.932 Operation Result (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + qsig_err_local_dissector_table = register_dissector_table("q932.ros.local.err", "Q.932 Error (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - etsi_arg_local_dissector_table = register_dissector_table("q932.ros.etsi.local.arg", "Q.932 ETSI Operation Argument (local opcode)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - etsi_res_local_dissector_table = register_dissector_table("q932.ros.etsi.local.res", "Q.932 ETSI Operation Result (local opcode)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); - etsi_err_local_dissector_table = register_dissector_table("q932.ros.etsi.local.err", "Q.932 ETSI Error (local opcode)", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + etsi_arg_local_dissector_table = register_dissector_table("q932.ros.etsi.local.arg", "Q.932 ETSI Operation Argument (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + etsi_res_local_dissector_table = register_dissector_table("q932.ros.etsi.local.res", "Q.932 ETSI Operation Result (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + etsi_err_local_dissector_table = register_dissector_table("q932.ros.etsi.local.err", "Q.932 ETSI Error (local opcode)", proto_q932, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); q932_module = prefs_register_protocol(proto_q932, proto_reg_handoff_q932); diff --git a/epan/dissectors/packet-qsig.c b/epan/dissectors/packet-qsig.c index acbeb5e39d..c0644b5097 100644 --- a/epan/dissectors/packet-qsig.c +++ b/epan/dissectors/packet-qsig.c @@ -16380,7 +16380,7 @@ void proto_register_qsig(void) { expert_register_field_array(expert_qsig, ei, array_length(ei)); /* Register dissector tables */ - extension_dissector_table = register_dissector_table("qsig.ext", "QSIG Extension", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + extension_dissector_table = register_dissector_table("qsig.ext", "QSIG Extension", proto_qsig, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); qsig_init_tables(); } diff --git a/epan/dissectors/packet-raknet.c b/epan/dissectors/packet-raknet.c index 18194b5cff..8657612cc5 100644 --- a/epan/dissectors/packet-raknet.c +++ b/epan/dissectors/packet-raknet.c @@ -645,7 +645,7 @@ proto_register_raknet(void) raknet_dissector_table = register_dissector_table("raknet.packet_id", "RakNet libs packet ids", - FT_UINT8, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + proto_raknet, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* * Raknet subdissector for use by external protocols. */ diff --git a/epan/dissectors/packet-ranap.c b/epan/dissectors/packet-ranap.c index 7d8835b55d..f548699a67 100644 --- a/epan/dissectors/packet-ranap.c +++ b/epan/dissectors/packet-ranap.c @@ -16496,16 +16496,16 @@ void proto_register_ranap(void) { register_dissector("ranap", dissect_ranap, proto_ranap); /* Register dissector tables */ - ranap_ies_dissector_table = register_dissector_table("ranap.ies", "RANAP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_ies_p1_dissector_table = register_dissector_table("ranap.ies.pair.first", "RANAP-PROTOCOL-IES-PAIR FirstValue", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_ies_p2_dissector_table = register_dissector_table("ranap.ies.pair.second", "RANAP-PROTOCOL-IES-PAIR SecondValue", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_extension_dissector_table = register_dissector_table("ranap.extension", "RANAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_proc_imsg_dissector_table = register_dissector_table("ranap.proc.imsg", "RANAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_proc_sout_dissector_table = register_dissector_table("ranap.proc.sout", "RANAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_proc_uout_dissector_table = register_dissector_table("ranap.proc.uout", "RANAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - ranap_proc_out_dissector_table = register_dissector_table("ranap.proc.out", "RANAP-ELEMENTARY-PROCEDURE Outcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - - nas_pdu_dissector_table = register_dissector_table("ranap.nas_pdu", "RANAP NAS PDU", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_ies_dissector_table = register_dissector_table("ranap.ies", "RANAP-PROTOCOL-IES", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_ies_p1_dissector_table = register_dissector_table("ranap.ies.pair.first", "RANAP-PROTOCOL-IES-PAIR FirstValue", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_ies_p2_dissector_table = register_dissector_table("ranap.ies.pair.second", "RANAP-PROTOCOL-IES-PAIR SecondValue", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_extension_dissector_table = register_dissector_table("ranap.extension", "RANAP-PROTOCOL-EXTENSION", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_proc_imsg_dissector_table = register_dissector_table("ranap.proc.imsg", "RANAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_proc_sout_dissector_table = register_dissector_table("ranap.proc.sout", "RANAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_proc_uout_dissector_table = register_dissector_table("ranap.proc.uout", "RANAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + ranap_proc_out_dissector_table = register_dissector_table("ranap.proc.out", "RANAP-ELEMENTARY-PROCEDURE Outcome", proto_ranap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + + nas_pdu_dissector_table = register_dissector_table("ranap.nas_pdu", "RANAP NAS PDU", proto_ranap, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); ranap_module = prefs_register_protocol(proto_ranap, proto_reg_handoff_ranap); prefs_register_uint_preference(ranap_module, "sccp_ssn", "SCCP SSN for RANAP", diff --git a/epan/dissectors/packet-rmcp.c b/epan/dissectors/packet-rmcp.c index ad5fdab0f7..74387e8aa3 100644 --- a/epan/dissectors/packet-rmcp.c +++ b/epan/dissectors/packet-rmcp.c @@ -224,7 +224,7 @@ proto_register_rmcp(void) proto_register_subtree_array(ett, array_length(ett)); rmcp_dissector_table = register_dissector_table( - "rmcp.class", "RMCP Class", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "rmcp.class", "RMCP Class", proto_rmcp, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-rnsap.c b/epan/dissectors/packet-rnsap.c index a72204f122..af8cbeabf0 100644 --- a/epan/dissectors/packet-rnsap.c +++ b/epan/dissectors/packet-rnsap.c @@ -55352,11 +55352,11 @@ void proto_register_rnsap(void) { register_dissector("rnsap", dissect_rnsap, proto_rnsap); /* Register dissector tables */ - rnsap_ies_dissector_table = register_dissector_table("rnsap.ies", "RNSAP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rnsap_extension_dissector_table = register_dissector_table("rnsap.extension", "RNSAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rnsap_proc_imsg_dissector_table = register_dissector_table("rnsap.proc.imsg", "RNSAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rnsap_proc_sout_dissector_table = register_dissector_table("rnsap.proc.sout", "RNSAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rnsap_proc_uout_dissector_table = register_dissector_table("rnsap.proc.uout", "RNSAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rnsap_ies_dissector_table = register_dissector_table("rnsap.ies", "RNSAP-PROTOCOL-IES", proto_rnsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rnsap_extension_dissector_table = register_dissector_table("rnsap.extension", "RNSAP-PROTOCOL-EXTENSION", proto_rnsap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rnsap_proc_imsg_dissector_table = register_dissector_table("rnsap.proc.imsg", "RNSAP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_rnsap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rnsap_proc_sout_dissector_table = register_dissector_table("rnsap.proc.sout", "RNSAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_rnsap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rnsap_proc_uout_dissector_table = register_dissector_table("rnsap.proc.uout", "RNSAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_rnsap, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-ros.c b/epan/dissectors/packet-ros.c index d0c0a180e8..7f40cf4f44 100644 --- a/epan/dissectors/packet-ros.c +++ b/epan/dissectors/packet-ros.c @@ -1279,7 +1279,7 @@ void proto_register_ros(void) { expert_ros = expert_register_protocol(proto_ros); expert_register_field_array(expert_ros, ei, array_length(ei)); - ros_oid_dissector_table = register_dissector_table("ros.oid", "ROS OID Dissectors", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + ros_oid_dissector_table = register_dissector_table("ros.oid", "ROS OID Dissectors", proto_ros, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); oid_table=g_hash_table_new(g_str_hash, g_str_equal); protocol_table=g_hash_table_new(g_str_hash, g_str_equal); diff --git a/epan/dissectors/packet-rpc.c b/epan/dissectors/packet-rpc.c index afcfdc41fe..1225d11ab7 100644 --- a/epan/dissectors/packet-rpc.c +++ b/epan/dissectors/packet-rpc.c @@ -4359,8 +4359,8 @@ proto_register_rpc(void) proto_rpc = proto_register_protocol("Remote Procedure Call", "RPC", "rpc"); - subdissector_call_table = register_custom_dissector_table("rpc.call", "RPC Call Functions", rpc_proc_hash, rpc_proc_equal, DISSECTOR_TABLE_ALLOW_DUPLICATE); - subdissector_reply_table = register_custom_dissector_table("rpc.reply", "RPC Reply Functions", rpc_proc_hash, rpc_proc_equal, DISSECTOR_TABLE_ALLOW_DUPLICATE); + subdissector_call_table = register_custom_dissector_table("rpc.call", "RPC Call Functions", proto_rpc, rpc_proc_hash, rpc_proc_equal, DISSECTOR_TABLE_ALLOW_DUPLICATE); + subdissector_reply_table = register_custom_dissector_table("rpc.reply", "RPC Reply Functions", proto_rpc, rpc_proc_hash, rpc_proc_equal, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* this is a dummy dissector for all those unknown rpc programs */ proto_register_field_array(proto_rpc, hf, array_length(hf)); diff --git a/epan/dissectors/packet-rtacser.c b/epan/dissectors/packet-rtacser.c index 909c962cd6..f1e59e79ea 100644 --- a/epan/dissectors/packet-rtacser.c +++ b/epan/dissectors/packet-rtacser.c @@ -294,7 +294,7 @@ proto_register_rtacser(void) /* Registering protocol to be called by another dissector */ rtacser_handle = register_dissector("rtacser", dissect_rtacser, proto_rtacser); - subdissector_table = register_dissector_table("rtacser.data", "RTAC Serial Data Subdissector", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + subdissector_table = register_dissector_table("rtacser.data", "RTAC Serial Data Subdissector", proto_rtacser, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_rtacser, rtacser_hf, array_length(rtacser_hf)); diff --git a/epan/dissectors/packet-rtcp.c b/epan/dissectors/packet-rtcp.c index 4efd72cf85..eba149fd5e 100644 --- a/epan/dissectors/packet-rtcp.c +++ b/epan/dissectors/packet-rtcp.c @@ -6533,9 +6533,9 @@ proto_register_rtcp(void) 10, &global_rtcp_show_roundtrip_calculation_minimum); /* Register table for sub-dissetors */ - rtcp_dissector_table = register_dissector_table("rtcp.app.name", "RTCP Application Name", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - rtcp_psfb_dissector_table = register_dissector_table("rtcp.psfb.fmt", "RTCP Payload Specific Feedback Message Format", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - rtcp_rtpfb_dissector_table = register_dissector_table("rtcp.rtpfb.fmt", "RTCP Generic RTP Feedback Message Format", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + rtcp_dissector_table = register_dissector_table("rtcp.app.name", "RTCP Application Name", proto_rtcp, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + rtcp_psfb_dissector_table = register_dissector_table("rtcp.psfb.fmt", "RTCP Payload Specific Feedback Message Format", proto_rtcp, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + rtcp_rtpfb_dissector_table = register_dissector_table("rtcp.rtpfb.fmt", "RTCP Generic RTP Feedback Message Format", proto_rtcp, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-rtitcp.c b/epan/dissectors/packet-rtitcp.c index 3508bf9ed4..62bd652882 100755 --- a/epan/dissectors/packet-rtitcp.c +++ b/epan/dissectors/packet-rtitcp.c @@ -967,7 +967,7 @@ proto_register_rtitcp(void) expert_register_field_array(expert_rtitcp, ei, array_length(ei)); */ register_dissector("rtitcp", dissect_rtitcp, proto_rtitcp); - heur_subdissector_list = register_heur_dissector_list("rtitcp"); + heur_subdissector_list = register_heur_dissector_list("rtitcp", proto_rtitcp); } diff --git a/epan/dissectors/packet-rtp.c b/epan/dissectors/packet-rtp.c index b207ada77f..adaeaff29b 100644 --- a/epan/dissectors/packet-rtp.c +++ b/epan/dissectors/packet-rtp.c @@ -3673,15 +3673,15 @@ proto_register_rtp(void) rtp_tap = register_tap("rtp"); rtp_pt_dissector_table = register_dissector_table("rtp.pt", - "RTP payload type", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + "RTP payload type", proto_rtp, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); rtp_dyn_pt_dissector_table = register_dissector_table("rtp_dyn_payload_type", - "Dynamic RTP payload type", FT_STRING, TRUE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + "Dynamic RTP payload type", proto_rtp, FT_STRING, TRUE, DISSECTOR_TABLE_ALLOW_DUPLICATE); rtp_hdr_ext_dissector_table = register_dissector_table("rtp.hdr_ext", - "RTP header extension", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + "RTP header extension", proto_rtp, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); rtp_hdr_ext_rfc5285_dissector_table = register_dissector_table("rtp.ext.rfc5285.id", - "RTP Generic header extension (RFC 5285)", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + "RTP Generic header extension (RFC 5285)", proto_rtp, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); register_dissector("rtp.ext.ed137", dissect_rtp_hdr_ext_ed137, proto_rtp); register_dissector("rtp.ext.ed137a", dissect_rtp_hdr_ext_ed137a, proto_rtp); diff --git a/epan/dissectors/packet-rtps.c b/epan/dissectors/packet-rtps.c index bb6f84a1e2..687c83c236 100644 --- a/epan/dissectors/packet-rtps.c +++ b/epan/dissectors/packet-rtps.c @@ -9765,7 +9765,7 @@ void proto_register_rtps(void) { register_init_routine(rtps_init); rtps_type_name_table = register_dissector_table("rtps.type_name", "RTPS Type Name", - FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_rtps, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-rtse.c b/epan/dissectors/packet-rtse.c index a34ad5cc6b..4a07cd07e5 100644 --- a/epan/dissectors/packet-rtse.c +++ b/epan/dissectors/packet-rtse.c @@ -1063,7 +1063,7 @@ void proto_register_rtse(void) { " \"Allow subdissectors to reassemble TCP streams\"" " in the TCP protocol settings.", &rtse_reassemble); - rtse_oid_dissector_table = register_dissector_table("rtse.oid", "RTSE OID Dissectors", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + rtse_oid_dissector_table = register_dissector_table("rtse.oid", "RTSE OID Dissectors", proto_rtse, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); oid_table=g_hash_table_new(g_str_hash, g_str_equal); diff --git a/epan/dissectors/packet-rtsp.c b/epan/dissectors/packet-rtsp.c index ba06a48ca3..27996976c3 100644 --- a/epan/dissectors/packet-rtsp.c +++ b/epan/dissectors/packet-rtsp.c @@ -1496,7 +1496,7 @@ proto_register_rtsp(void) * this table using the standard heur_dissector_add() * function. */ - heur_subdissector_list = register_heur_dissector_list("rtsp"); + heur_subdissector_list = register_heur_dissector_list("rtsp", proto_rtsp); /* * Register for tapping diff --git a/epan/dissectors/packet-rua.c b/epan/dissectors/packet-rua.c index 2bb834b1cf..ff51a56b7c 100644 --- a/epan/dissectors/packet-rua.c +++ b/epan/dissectors/packet-rua.c @@ -1742,11 +1742,11 @@ module_t *rua_module; register_dissector("rua", dissect_rua, proto_rua); /* Register dissector tables */ - rua_ies_dissector_table = register_dissector_table("rua.ies", "RUA-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rua_extension_dissector_table = register_dissector_table("rua.extension", "RUA-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rua_proc_imsg_dissector_table = register_dissector_table("rua.proc.imsg", "RUA-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rua_proc_sout_dissector_table = register_dissector_table("rua.proc.sout", "RUA-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - rua_proc_uout_dissector_table = register_dissector_table("rua.proc.uout", "RUA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rua_ies_dissector_table = register_dissector_table("rua.ies", "RUA-PROTOCOL-IES", proto_rua, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rua_extension_dissector_table = register_dissector_table("rua.extension", "RUA-PROTOCOL-EXTENSION", proto_rua, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rua_proc_imsg_dissector_table = register_dissector_table("rua.proc.imsg", "RUA-ELEMENTARY-PROCEDURE InitiatingMessage", proto_rua, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rua_proc_sout_dissector_table = register_dissector_table("rua.proc.sout", "RUA-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_rua, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + rua_proc_uout_dissector_table = register_dissector_table("rua.proc.uout", "RUA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_rua, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); rua_module = prefs_register_protocol(proto_rua, proto_reg_handoff_rua); prefs_register_uint_preference(rua_module, "port", "RUA SCTP Port", "Set the port for RUA messages (Default of 29169)", 10, &global_sctp_port); diff --git a/epan/dissectors/packet-s1ap.c b/epan/dissectors/packet-s1ap.c index 5c707e1259..f0976cd9ab 100644 --- a/epan/dissectors/packet-s1ap.c +++ b/epan/dissectors/packet-s1ap.c @@ -15028,13 +15028,13 @@ void proto_register_s1ap(void) { register_dissector("s1ap", dissect_s1ap, proto_s1ap); /* Register dissector tables */ - s1ap_ies_dissector_table = register_dissector_table("s1ap.ies", "S1AP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - s1ap_ies_p1_dissector_table = register_dissector_table("s1ap.ies.pair.first", "S1AP-PROTOCOL-IES-PAIR FirstValue", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - s1ap_ies_p2_dissector_table = register_dissector_table("s1ap.ies.pair.second", "S1AP-PROTOCOL-IES-PAIR SecondValue", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - s1ap_extension_dissector_table = register_dissector_table("s1ap.extension", "S1AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - s1ap_proc_imsg_dissector_table = register_dissector_table("s1ap.proc.imsg", "S1AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - s1ap_proc_sout_dissector_table = register_dissector_table("s1ap.proc.sout", "S1AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - s1ap_proc_uout_dissector_table = register_dissector_table("s1ap.proc.uout", "S1AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + s1ap_ies_dissector_table = register_dissector_table("s1ap.ies", "S1AP-PROTOCOL-IES", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + s1ap_ies_p1_dissector_table = register_dissector_table("s1ap.ies.pair.first", "S1AP-PROTOCOL-IES-PAIR FirstValue", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + s1ap_ies_p2_dissector_table = register_dissector_table("s1ap.ies.pair.second", "S1AP-PROTOCOL-IES-PAIR SecondValue", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + s1ap_extension_dissector_table = register_dissector_table("s1ap.extension", "S1AP-PROTOCOL-EXTENSION", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + s1ap_proc_imsg_dissector_table = register_dissector_table("s1ap.proc.imsg", "S1AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + s1ap_proc_sout_dissector_table = register_dissector_table("s1ap.proc.sout", "S1AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + s1ap_proc_uout_dissector_table = register_dissector_table("s1ap.proc.uout", "S1AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_s1ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Register configuration options for ports */ s1ap_module = prefs_register_protocol(proto_s1ap, proto_reg_handoff_s1ap); diff --git a/epan/dissectors/packet-s5066sis.c b/epan/dissectors/packet-s5066sis.c index b1120e74e9..1ec097017c 100644 --- a/epan/dissectors/packet-s5066sis.c +++ b/epan/dissectors/packet-s5066sis.c @@ -1447,7 +1447,7 @@ proto_register_s5066(void) " This number is registered with IANA.)", 10, &global_s5066_port); - s5066sis_dissector_table = register_dissector_table("s5066sis.ctl.appid", "STANAG 5066 Application Identifier", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + s5066sis_dissector_table = register_dissector_table("s5066sis.ctl.appid", "STANAG 5066 Application Identifier", proto_s5066, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-sabp.c b/epan/dissectors/packet-sabp.c index efdb882b84..20dc8e5089 100644 --- a/epan/dissectors/packet-sabp.c +++ b/epan/dissectors/packet-sabp.c @@ -2273,11 +2273,11 @@ void proto_register_sabp(void) { register_dissector("sabp.tcp", dissect_sabp_tcp, proto_sabp); /* Register dissector tables */ - sabp_ies_dissector_table = register_dissector_table("sabp.ies", "SABP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sabp_extension_dissector_table = register_dissector_table("sabp.extension", "SABP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sabp_proc_imsg_dissector_table = register_dissector_table("sabp.proc.imsg", "SABP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sabp_proc_sout_dissector_table = register_dissector_table("sabp.proc.sout", "SABP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sabp_proc_uout_dissector_table = register_dissector_table("sabp.proc.uout", "SABP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sabp_ies_dissector_table = register_dissector_table("sabp.ies", "SABP-PROTOCOL-IES", proto_sabp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sabp_extension_dissector_table = register_dissector_table("sabp.extension", "SABP-PROTOCOL-EXTENSION", proto_sabp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sabp_proc_imsg_dissector_table = register_dissector_table("sabp.proc.imsg", "SABP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_sabp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sabp_proc_sout_dissector_table = register_dissector_table("sabp.proc.sout", "SABP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_sabp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sabp_proc_uout_dissector_table = register_dissector_table("sabp.proc.uout", "SABP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_sabp, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-sbc-ap.c b/epan/dissectors/packet-sbc-ap.c index 00b32483ac..0cc5368f5b 100644 --- a/epan/dissectors/packet-sbc-ap.c +++ b/epan/dissectors/packet-sbc-ap.c @@ -1459,11 +1459,11 @@ void proto_register_sbc_ap(void) { /* Register dissector tables */ - sbc_ap_ies_dissector_table = register_dissector_table("sbc_ap.ies", "SBC-AP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sbc_ap_extension_dissector_table = register_dissector_table("sbc_ap.extension", "SBC-AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sbc_ap_proc_imsg_dissector_table = register_dissector_table("sbc_ap.proc.imsg", "SBC-AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sbc_ap_proc_sout_dissector_table = register_dissector_table("sbc_ap.proc.sout", "SBC-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - sbc_ap_proc_uout_dissector_table = register_dissector_table("sbc_ap.proc.uout", "SBC-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sbc_ap_ies_dissector_table = register_dissector_table("sbc_ap.ies", "SBC-AP-PROTOCOL-IES", proto_sbc_ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sbc_ap_extension_dissector_table = register_dissector_table("sbc_ap.extension", "SBC-AP-PROTOCOL-EXTENSION", proto_sbc_ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sbc_ap_proc_imsg_dissector_table = register_dissector_table("sbc_ap.proc.imsg", "SBC-AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_sbc_ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sbc_ap_proc_sout_dissector_table = register_dissector_table("sbc_ap.proc.sout", "SBC-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_sbc_ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + sbc_ap_proc_uout_dissector_table = register_dissector_table("sbc_ap.proc.uout", "SBC-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_sbc_ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); } diff --git a/epan/dissectors/packet-sccp.c b/epan/dissectors/packet-sccp.c index 1b92f1842e..2c791ddfda 100644 --- a/epan/dissectors/packet-sccp.c +++ b/epan/dissectors/packet-sccp.c @@ -4087,9 +4087,9 @@ proto_register_sccp(void) expert_sccp = expert_register_protocol(proto_sccp); expert_register_field_array(expert_sccp, ei, array_length(ei)); - sccp_ssn_dissector_table = register_dissector_table("sccp.ssn", "SCCP SSN", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + sccp_ssn_dissector_table = register_dissector_table("sccp.ssn", "SCCP SSN", proto_sccp, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - heur_subdissector_list = register_heur_dissector_list("sccp"); + heur_subdissector_list = register_heur_dissector_list("sccp", proto_sccp); sccp_module = prefs_register_protocol(proto_sccp, proto_reg_handoff_sccp); diff --git a/epan/dissectors/packet-sctp.c b/epan/dissectors/packet-sctp.c index c3c2826b4e..553f87cac4 100644 --- a/epan/dissectors/packet-sctp.c +++ b/epan/dissectors/packet-sctp.c @@ -5030,11 +5030,11 @@ proto_register_sctp(void) sctp_tap = register_tap("sctp"); exported_pdu_tap = find_tap_id(EXPORT_PDU_TAP_NAME_LAYER_3); /* subdissector code */ - sctp_port_dissector_table = register_dissector_table("sctp.port", "SCTP port", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - sctp_ppi_dissector_table = register_dissector_table("sctp.ppi", "SCTP payload protocol identifier", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + sctp_port_dissector_table = register_dissector_table("sctp.port", "SCTP port", proto_sctp, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + sctp_ppi_dissector_table = register_dissector_table("sctp.ppi", "SCTP payload protocol identifier", proto_sctp, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_dissector("sctp", dissect_sctp, proto_sctp); - sctp_heur_subdissector_list = register_heur_dissector_list("sctp"); + sctp_heur_subdissector_list = register_heur_dissector_list("sctp", proto_sctp); register_init_routine(sctp_init); register_cleanup_routine(sctp_cleanup); diff --git a/epan/dissectors/packet-sdp.c b/epan/dissectors/packet-sdp.c index 60843c42f3..aa7a30d368 100644 --- a/epan/dissectors/packet-sdp.c +++ b/epan/dissectors/packet-sdp.c @@ -3080,7 +3080,7 @@ proto_register_sdp(void) expert_register_field_array(expert_sdp, ei, array_length(ei)); key_mgmt_dissector_table = register_dissector_table("key_mgmt", - "Key Management", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "Key Management", proto_sdp, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* * Preferences registration */ diff --git a/epan/dissectors/packet-sercosiii.c b/epan/dissectors/packet-sercosiii.c index b8214b7601..da7eedaa2f 100644 --- a/epan/dissectors/packet-sercosiii.c +++ b/epan/dissectors/packet-sercosiii.c @@ -1622,7 +1622,7 @@ proto_register_sercosiii(void) register_dissector("sercosiii", dissect_siii, proto_siii); /* subdissector code */ - heur_subdissector_list = register_heur_dissector_list("sercosiii"); + heur_subdissector_list = register_heur_dissector_list("sercosiii", proto_siii); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_siii, hf, array_length(hf)); diff --git a/epan/dissectors/packet-sflow.c b/epan/dissectors/packet-sflow.c index 982226c200..68ccf465bd 100644 --- a/epan/dissectors/packet-sflow.c +++ b/epan/dissectors/packet-sflow.c @@ -3636,7 +3636,7 @@ proto_register_sflow(void) { expert_sflow = expert_register_protocol(proto_sflow); expert_register_field_array(expert_sflow, ei, array_length(ei)); - header_subdissector_table = register_dissector_table("sflow_245.header_protocol", "SFLOW header protocol", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + header_subdissector_table = register_dissector_table("sflow_245.header_protocol", "SFLOW header protocol", proto_sflow, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Register our configuration options for sFlow */ sflow_245_module = prefs_register_protocol(proto_sflow, proto_reg_handoff_sflow_245); diff --git a/epan/dissectors/packet-sip.c b/epan/dissectors/packet-sip.c index 629ec361a8..5b33a7cc3f 100644 --- a/epan/dissectors/packet-sip.c +++ b/epan/dissectors/packet-sip.c @@ -6401,11 +6401,11 @@ void proto_register_sip(void) register_init_routine(&sip_init_protocol); register_cleanup_routine(&sip_cleanup_protocol); - heur_subdissector_list = register_heur_dissector_list("sip"); + heur_subdissector_list = register_heur_dissector_list("sip", proto_sip); /* Register for tapping */ sip_tap = register_tap("sip"); - ext_hdr_subdissector_table = register_dissector_table("sip.hdr", "SIP Extension header", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + ext_hdr_subdissector_table = register_dissector_table("sip.hdr", "SIP Extension header", proto_sip, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_stat_tap_table_ui(&sip_stat_table); diff --git a/epan/dissectors/packet-sita.c b/epan/dissectors/packet-sita.c index b4b5b38299..14d067c898 100644 --- a/epan/dissectors/packet-sita.c +++ b/epan/dissectors/packet-sita.c @@ -376,7 +376,7 @@ proto_register_sita(void) }; proto_sita = proto_register_protocol("Societe Internationale de Telecommunications Aeronautiques", "SITA", "sita"); /* name, short name,abbreviation */ - sita_dissector_table = register_dissector_table("sita.proto", "SITA protocol number", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + sita_dissector_table = register_dissector_table("sita.proto", "SITA protocol number", proto_sita, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); proto_register_field_array(proto_sita, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); register_dissector("sita", dissect_sita, proto_sita); diff --git a/epan/dissectors/packet-sll.c b/epan/dissectors/packet-sll.c index 6951387828..642378cb5c 100644 --- a/epan/dissectors/packet-sll.c +++ b/epan/dissectors/packet-sll.c @@ -338,7 +338,7 @@ proto_register_sll(void) sll_linux_dissector_table = register_dissector_table ( "sll.ltype", "Linux SLL protocol type", - FT_UINT16, + proto_sll, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE ); register_capture_dissector_table("sll.ltype", "Linux SLL protocol"); diff --git a/epan/dissectors/packet-slowprotocols.c b/epan/dissectors/packet-slowprotocols.c index f1aa1c65c1..d154bdb61b 100644 --- a/epan/dissectors/packet-slowprotocols.c +++ b/epan/dissectors/packet-slowprotocols.c @@ -137,7 +137,7 @@ proto_register_slow_protocols(void) /* subdissector code */ slow_protocols_dissector_table = register_dissector_table("slow.subtype", "Slow protocol subtype", - FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + proto_slow, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-smb-direct.c b/epan/dissectors/packet-smb-direct.c index 35e28374d4..2c8f88476c 100644 --- a/epan/dissectors/packet-smb-direct.c +++ b/epan/dissectors/packet-smb-direct.c @@ -685,7 +685,7 @@ void proto_register_smb_direct(void) proto_register_subtree_array(ett, array_length(ett)); proto_register_field_array(proto_smb_direct, hf, array_length(hf)); - smb_direct_heur_subdissector_list = register_heur_dissector_list("smb_direct"); + smb_direct_heur_subdissector_list = register_heur_dissector_list("smb_direct", proto_smb_direct); smb_direct_module = prefs_register_protocol(proto_smb_direct, NULL); prefs_register_bool_preference(smb_direct_module, diff --git a/epan/dissectors/packet-smb-pipe.c b/epan/dissectors/packet-smb-pipe.c index 6f32f91f64..d63ed79149 100644 --- a/epan/dissectors/packet-smb-pipe.c +++ b/epan/dissectors/packet-smb-pipe.c @@ -43,7 +43,6 @@ XXX Fixme : shouldn't show [malformed frame] for long packets #include "packet-windows-common.h" void proto_register_pipe_lanman(void); -void proto_register_pipe_dcerpc(void); void proto_register_smb_pipe(void); void proto_reg_handoff_smb_pipe(void); @@ -3441,14 +3440,6 @@ clean_up_and_exit: return TRUE; } -void -proto_register_pipe_dcerpc(void) -{ - smb_transact_heur_subdissector_list = register_heur_dissector_list("smb_transact"); - register_init_routine(smb_dcerpc_reassembly_init); - register_cleanup_routine(smb_dcerpc_reassembly_cleanup); -} - #define CALL_NAMED_PIPE 0x54 #define WAIT_NAMED_PIPE 0x53 #define PEEK_NAMED_PIPE 0x23 @@ -3929,6 +3920,10 @@ proto_register_smb_pipe(void) proto_register_subtree_array(ett, array_length(ett)); expert_smb_pipe = expert_register_protocol(proto_smb_pipe); expert_register_field_array(expert_smb_pipe, ei, array_length(ei)); + + smb_transact_heur_subdissector_list = register_heur_dissector_list("smb_transact", proto_smb_pipe); + register_init_routine(smb_dcerpc_reassembly_init); + register_cleanup_routine(smb_dcerpc_reassembly_cleanup); } void diff --git a/epan/dissectors/packet-smb2.c b/epan/dissectors/packet-smb2.c index f38ed0f557..69dc90e740 100644 --- a/epan/dissectors/packet-smb2.c +++ b/epan/dissectors/packet-smb2.c @@ -9671,7 +9671,7 @@ proto_register_smb2(void) "Reassemble Named Pipes over SMB2", "Whether the dissector should reassemble Named Pipes over SMB2 commands", &smb2_pipe_reassembly); - smb2_pipe_subdissector_list = register_heur_dissector_list("smb2_pipe_subdissectors"); + smb2_pipe_subdissector_list = register_heur_dissector_list("smb2_pipe_subdissectors", proto_smb2); register_init_routine(smb2_pipe_reassembly_init); smb2_tap = register_tap("smb2"); diff --git a/epan/dissectors/packet-snmp.c b/epan/dissectors/packet-snmp.c index 9b04df89a1..10624e5894 100644 --- a/epan/dissectors/packet-snmp.c +++ b/epan/dissectors/packet-snmp.c @@ -4074,7 +4074,7 @@ void proto_register_snmp(void) { "MIB settings can be changed in the Name Resolution preferences"); #endif - value_sub_dissectors_table = register_dissector_table("snmp.variable_oid","SNMP Variable OID", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + value_sub_dissectors_table = register_dissector_table("snmp.variable_oid","SNMP Variable OID", proto_snmp, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); register_init_routine(init_ue_cache); register_cleanup_routine(cleanup_ue_cache); diff --git a/epan/dissectors/packet-socketcan.c b/epan/dissectors/packet-socketcan.c index 3392d800b6..4de41512ae 100644 --- a/epan/dissectors/packet-socketcan.c +++ b/epan/dissectors/packet-socketcan.c @@ -235,7 +235,7 @@ proto_register_socketcan(void) proto_register_subtree_array(ett, array_length(ett)); subdissector_table = register_dissector_table("can.subdissector", - "CAN next level dissector", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "CAN next level dissector", proto_can, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); can_module = prefs_register_protocol(proto_can, NULL); diff --git a/epan/dissectors/packet-soupbintcp.c b/epan/dissectors/packet-soupbintcp.c index 84c7f0366b..2e94e3222b 100644 --- a/epan/dissectors/packet-soupbintcp.c +++ b/epan/dissectors/packet-soupbintcp.c @@ -614,7 +614,7 @@ proto_register_soupbintcp(void) soupbintcp_range = range_empty(); - heur_subdissector_list = register_heur_dissector_list("soupbintcp"); + heur_subdissector_list = register_heur_dissector_list("soupbintcp", proto_soupbintcp); } diff --git a/epan/dissectors/packet-spp.c b/epan/dissectors/packet-spp.c index d63e72a7dd..415b0cd867 100644 --- a/epan/dissectors/packet-spp.c +++ b/epan/dissectors/packet-spp.c @@ -263,7 +263,7 @@ proto_register_spp(void) proto_register_subtree_array(ett, array_length(ett)); spp_socket_dissector_table = register_dissector_table("spp.socket", - "SPP socket", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "SPP socket", proto_spp, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void diff --git a/epan/dissectors/packet-ssl.c b/epan/dissectors/packet-ssl.c index 5394e34150..6d94d2a665 100644 --- a/epan/dissectors/packet-ssl.c +++ b/epan/dissectors/packet-ssl.c @@ -4108,7 +4108,7 @@ proto_register_ssl(void) proto_ssl = proto_register_protocol("Secure Sockets Layer", "SSL", "ssl"); - ssl_associations = register_dissector_table("ssl.port", "SSL TCP Dissector", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + ssl_associations = register_dissector_table("ssl.port", "SSL TCP Dissector", proto_ssl, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* Required function calls to register the header fields and * subtrees used */ @@ -4182,7 +4182,7 @@ proto_register_ssl(void) } /* heuristic dissectors for any premable e.g. CredSSP before RDP */ - ssl_heur_subdissector_list = register_heur_dissector_list("ssl"); + ssl_heur_subdissector_list = register_heur_dissector_list("ssl", proto_ssl); register_dissector("ssl", dissect_ssl, proto_ssl); ssl_handle = find_dissector("ssl"); diff --git a/epan/dissectors/packet-stun.c b/epan/dissectors/packet-stun.c index a3e616bde9..cf2c19d5bf 100644 --- a/epan/dissectors/packet-stun.c +++ b/epan/dissectors/packet-stun.c @@ -1722,7 +1722,7 @@ proto_register_stun(void) proto_register_subtree_array(ett, array_length(ett)); /* heuristic subdissectors (used for the DATA field) */ - heur_subdissector_list = register_heur_dissector_list("stun"); + heur_subdissector_list = register_heur_dissector_list("stun", proto_stun); register_dissector("stun-udp", dissect_stun_udp, proto_stun); register_dissector("stun-heur", dissect_stun_heur, proto_stun); diff --git a/epan/dissectors/packet-sua.c b/epan/dissectors/packet-sua.c index 871d6c610f..1a076b81ce 100644 --- a/epan/dissectors/packet-sua.c +++ b/epan/dissectors/packet-sua.c @@ -2467,8 +2467,8 @@ proto_register_sua(void) "Set the source and destination addresses to the PC or GT digits, depending on the routing indicator." " This may affect TCAP's ability to recognize which messages belong to which TCAP session.", &set_addresses); - heur_subdissector_list = register_heur_dissector_list("sua"); - sua_parameter_table = register_dissector_table("sua.prop.tags", "SUA Proprietary Tags", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + heur_subdissector_list = register_heur_dissector_list("sua", proto_sua); + sua_parameter_table = register_dissector_table("sua.prop.tags", "SUA Proprietary Tags", proto_sua, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); sua_tap = register_tap("sua"); assocs = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); diff --git a/epan/dissectors/packet-t124.c b/epan/dissectors/packet-t124.c index 40a60af72a..f1467f972a 100644 --- a/epan/dissectors/packet-t124.c +++ b/epan/dissectors/packet-t124.c @@ -4012,8 +4012,8 @@ void proto_register_t124(void) { proto_register_field_array(proto_t124, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - t124_ns_dissector_table = register_dissector_table("t124.ns", "T.124 H.221 Non Standard Dissectors", FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); - t124_sd_dissector_table = register_dissector_table("t124.sd", "T.124 H.221 Send Data Dissectors", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); + t124_ns_dissector_table = register_dissector_table("t124.ns", "T.124 H.221 Non Standard Dissectors", proto_t124, FT_STRING, BASE_NONE, DISSECTOR_TABLE_ALLOW_DUPLICATE); + t124_sd_dissector_table = register_dissector_table("t124.sd", "T.124 H.221 Send Data Dissectors", proto_t124, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_ALLOW_DUPLICATE); register_dissector("t124", dissect_t124, proto_t124); diff --git a/epan/dissectors/packet-t125.c b/epan/dissectors/packet-t125.c index c6e2216d21..25ff1f7ecd 100644 --- a/epan/dissectors/packet-t125.c +++ b/epan/dissectors/packet-t125.c @@ -584,7 +584,7 @@ void proto_register_t125(void) { proto_register_field_array(proto_t125, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - t125_heur_subdissector_list= register_heur_dissector_list("t125"); + t125_heur_subdissector_list= register_heur_dissector_list("t125", proto_t125); register_dissector("t125", dissect_t125, proto_t125); } diff --git a/epan/dissectors/packet-tali.c b/epan/dissectors/packet-tali.c index 4708504dfc..b4fba11441 100644 --- a/epan/dissectors/packet-tali.c +++ b/epan/dissectors/packet-tali.c @@ -210,7 +210,7 @@ proto_register_tali(void) proto_register_fields(proto_tali, hfi, array_length(hfi)); proto_register_subtree_array(ett, array_length(ett)); - tali_dissector_table = register_dissector_table("tali.opcode", "Tali OPCODE", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + tali_dissector_table = register_dissector_table("tali.opcode", "Tali OPCODE", proto_tali, FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); tali_module = prefs_register_protocol(proto_tali, NULL); prefs_register_bool_preference(tali_module, "reassemble", diff --git a/epan/dissectors/packet-tcp.c b/epan/dissectors/packet-tcp.c index af5f60983d..3e79addce6 100644 --- a/epan/dissectors/packet-tcp.c +++ b/epan/dissectors/packet-tcp.c @@ -6728,8 +6728,8 @@ proto_register_tcp(void) /* subdissector code */ subdissector_table = register_dissector_table("tcp.port", - "TCP port", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - heur_subdissector_list = register_heur_dissector_list("tcp"); + "TCP port", proto_tcp, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + heur_subdissector_list = register_heur_dissector_list("tcp", proto_tcp); register_capture_dissector_table("tcp.port", "TCP"); diff --git a/epan/dissectors/packet-teredo.c b/epan/dissectors/packet-teredo.c index 0a1b5cdc60..13edd1b526 100644 --- a/epan/dissectors/packet-teredo.c +++ b/epan/dissectors/packet-teredo.c @@ -384,7 +384,7 @@ proto_register_teredo(void) proto_register_subtree_array(ett, array_length(ett)); /* subdissector code */ - teredo_dissector_table = register_dissector_table("teredo","Teredo ", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + teredo_dissector_table = register_dissector_table("teredo", "Teredo", proto_teredo, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); teredo_module = prefs_register_protocol(proto_teredo, NULL); diff --git a/epan/dissectors/packet-tipc.c b/epan/dissectors/packet-tipc.c index 5063581153..cfe55bde1b 100644 --- a/epan/dissectors/packet-tipc.c +++ b/epan/dissectors/packet-tipc.c @@ -3027,15 +3027,15 @@ proto_register_tipc(void) /* this allows e.g. to dissect everything which is TIPC Data */ tipc_user_dissector = register_dissector_table("tipc.usr", - "TIPC user", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "TIPC user", proto_tipc, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* this allows to dissect everything which is TIPC Data and uses a specific * port name type it actually does not really work because the type is not * necessarily set in every data message */ tipc_type_dissector = register_dissector_table("tipcv2.port_name_type", - "TIPC port name type", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "TIPC port name type", proto_tipc, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); /* make heuristic dissectors possible */ - tipc_heur_subdissector_list = register_heur_dissector_list("tipc"); + tipc_heur_subdissector_list = register_heur_dissector_list("tipc", proto_tipc); /* Register by name */ tipc_handle = register_dissector("tipc", dissect_tipc, proto_tipc); diff --git a/epan/dissectors/packet-turnchannel.c b/epan/dissectors/packet-turnchannel.c index c876a96053..9d7b661f23 100644 --- a/epan/dissectors/packet-turnchannel.c +++ b/epan/dissectors/packet-turnchannel.c @@ -189,7 +189,7 @@ proto_register_turnchannel(void) proto_turnchannel); /* subdissectors */ - heur_subdissector_list = register_heur_dissector_list("turnchannel"); + heur_subdissector_list = register_heur_dissector_list("turnchannel", proto_turnchannel); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_turnchannel, hf, array_length(hf)); diff --git a/epan/dissectors/packet-udp.c b/epan/dissectors/packet-udp.c index 5ce9e2d6a2..5b6967e13a 100644 --- a/epan/dissectors/packet-udp.c +++ b/epan/dissectors/packet-udp.c @@ -1177,8 +1177,8 @@ proto_register_udp(void) /* subdissector code */ udp_dissector_table = register_dissector_table("udp.port", - "UDP port", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - heur_subdissector_list = register_heur_dissector_list("udp"); + "UDP port", proto_udp, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + heur_subdissector_list = register_heur_dissector_list("udp", proto_udp); register_capture_dissector_table("udp.port", "UDP"); diff --git a/epan/dissectors/packet-usb.c b/epan/dissectors/packet-usb.c index 46353802c2..ef13887081 100644 --- a/epan/dissectors/packet-usb.c +++ b/epan/dissectors/packet-usb.c @@ -5260,21 +5260,21 @@ proto_register_usb(void) device_to_product_table = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); device_to_protocol_table = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); - device_to_dissector = register_dissector_table("usb.device", "USB device", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - protocol_to_dissector = register_dissector_table("usb.protocol", "USB protocol", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - product_to_dissector = register_dissector_table("usb.product", "USB product", FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + device_to_dissector = register_dissector_table("usb.device", "USB device", proto_usb, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + protocol_to_dissector = register_dissector_table("usb.protocol", "USB protocol", proto_usb, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + product_to_dissector = register_dissector_table("usb.product", "USB product", proto_usb, FT_UINT32, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); usb_bulk_dissector_table = register_dissector_table("usb.bulk", - "USB bulk endpoint", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - heur_bulk_subdissector_list = register_heur_dissector_list("usb.bulk"); + "USB bulk endpoint", proto_usb, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + heur_bulk_subdissector_list = register_heur_dissector_list("usb.bulk", proto_usb); usb_control_dissector_table = register_dissector_table("usb.control", - "USB control endpoint", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - heur_control_subdissector_list = register_heur_dissector_list("usb.control"); + "USB control endpoint", proto_usb, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + heur_control_subdissector_list = register_heur_dissector_list("usb.control", proto_usb); usb_interrupt_dissector_table = register_dissector_table("usb.interrupt", - "USB interrupt endpoint", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - heur_interrupt_subdissector_list = register_heur_dissector_list("usb.interrupt"); + "USB interrupt endpoint", proto_usb, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + heur_interrupt_subdissector_list = register_heur_dissector_list("usb.interrupt", proto_usb); usb_descriptor_dissector_table = register_dissector_table("usb.descriptor", - "USB descriptor", FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "USB descriptor", proto_usb, FT_UINT8, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); usb_module = prefs_register_protocol(proto_usb, NULL); prefs_register_bool_preference(usb_module, "try_heuristics", diff --git a/epan/dissectors/packet-vines.c b/epan/dissectors/packet-vines.c index 9dc9ccc05a..914e0b3b37 100644 --- a/epan/dissectors/packet-vines.c +++ b/epan/dissectors/packet-vines.c @@ -491,7 +491,7 @@ proto_register_vines_llc(void) /* subdissector code */ vines_llc_dissector_table = register_dissector_table("vines_llc.ptype", - "Vines LLC protocol", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "Vines LLC protocol", proto_vines_llc, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); } void @@ -695,7 +695,7 @@ proto_register_vines_ip(void) /* subdissector code */ vines_ip_dissector_table = register_dissector_table("vines_ip.protocol", - "Vines protocol", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "Vines protocol", proto_vines_ip, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); vines_ip_handle = create_dissector_handle(dissect_vines_ip, proto_vines_ip); @@ -995,7 +995,7 @@ proto_register_vines_ipc(void) proto_register_field_array(proto_vines_ipc, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - vines_ipc_heur_subdissector_list = register_heur_dissector_list("vines_ipc"); + vines_ipc_heur_subdissector_list = register_heur_dissector_list("vines_ipc", proto_vines_ipc); } void @@ -1163,7 +1163,7 @@ proto_register_vines_spp(void) proto_register_field_array(proto_vines_spp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - vines_spp_heur_subdissector_list = register_heur_dissector_list("vines_spp"); + vines_spp_heur_subdissector_list = register_heur_dissector_list("vines_spp", proto_vines_spp); } void diff --git a/epan/dissectors/packet-websocket.c b/epan/dissectors/packet-websocket.c index 4fcc76e36a..603b068608 100644 --- a/epan/dissectors/packet-websocket.c +++ b/epan/dissectors/packet-websocket.c @@ -531,10 +531,10 @@ proto_register_websocket(void) * this table using the standard heur_dissector_add() * function. */ - heur_subdissector_list = register_heur_dissector_list("ws"); + heur_subdissector_list = register_heur_dissector_list("ws", proto_websocket); port_subdissector_table = register_dissector_table("ws.port", - "TCP port for protocols using WebSocket", FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + "TCP port for protocols using WebSocket", proto_websocket, FT_UINT16, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); proto_register_field_array(proto_websocket, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); diff --git a/epan/dissectors/packet-wlccp.c b/epan/dissectors/packet-wlccp.c index 9c5d7ad0af..32d0a31fb1 100644 --- a/epan/dissectors/packet-wlccp.c +++ b/epan/dissectors/packet-wlccp.c @@ -66,7 +66,6 @@ void proto_register_wlccp(void); void proto_reg_handoff_wlccp(void); -void proto_register_wlccp_oui(void); /* The UDP port that WLCCP is expected to ride on */ /* WLCCP also uses an LLC OUI type and an ethertype */ @@ -4066,6 +4065,14 @@ proto_register_wlccp(void) }; /* hf_register_info hf */ + static hf_register_info oui_hf[] = { + { &hf_llc_wlccp_pid, + { "PID", "llc.wlccp_pid", + FT_UINT16, BASE_HEX, VALS(cisco_pid_vals), + 0x0, NULL, HFILL } + } + }; + /* Setup protocol subtree array */ static gint *ett[] = { &ett_wlccp, @@ -4095,6 +4102,7 @@ proto_register_wlccp(void) proto_register_field_array(proto_wlccp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); + llc_add_oui(OUI_CISCOWL, "llc.wlccp_pid", "LLC Cisco WLCCP OUI PID", oui_hf, proto_wlccp); } @@ -4112,21 +4120,6 @@ proto_reg_handoff_wlccp(void) } -void -proto_register_wlccp_oui(void) -{ - static hf_register_info hf[] = { - { &hf_llc_wlccp_pid, - { "PID", "llc.wlccp_pid", - FT_UINT16, BASE_HEX, VALS(cisco_pid_vals), - 0x0, NULL, HFILL } - } - }; - - llc_add_oui(OUI_CISCOWL, "llc.wlccp_pid", "LLC Cisco WLCCP OUI PID", hf); - -} - /* * Editor modelines - http://www.wireshark.org/tools/modelines.html * diff --git a/epan/dissectors/packet-wsp.c b/epan/dissectors/packet-wsp.c index 45ea866c7c..fb8609fb0f 100644 --- a/epan/dissectors/packet-wsp.c +++ b/epan/dissectors/packet-wsp.c @@ -7163,7 +7163,7 @@ proto_register_wsp(void) register_dissector("wsp-co", dissect_wsp_fromwap_co, proto_wsp); register_dissector("wsp-cl", dissect_wsp_fromwap_cl, proto_wsp); - heur_subdissector_list = register_heur_dissector_list("wsp"); + heur_subdissector_list = register_heur_dissector_list("wsp", proto_wsp); wsp_fromudp_handle = create_dissector_handle(dissect_wsp_fromudp, proto_wsp); diff --git a/epan/dissectors/packet-x25.c b/epan/dissectors/packet-x25.c index 30c124592b..a42437412d 100644 --- a/epan/dissectors/packet-x25.c +++ b/epan/dissectors/packet-x25.c @@ -2370,8 +2370,8 @@ proto_register_x25(void) expert_register_field_array(expert_x25, ei, array_length(ei)); x25_subdissector_table = register_dissector_table("x.25.spi", - "X.25 secondary protocol identifier", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); - x25_heur_subdissector_list = register_heur_dissector_list("x.25"); + "X.25 secondary protocol identifier", proto_x25, FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + x25_heur_subdissector_list = register_heur_dissector_list("x.25", proto_x25); register_dissector("x.25_dir", dissect_x25_dir, proto_x25); register_dissector("x.25", dissect_x25, proto_x25); diff --git a/epan/dissectors/packet-x2ap.c b/epan/dissectors/packet-x2ap.c index acb82e45f5..9d97b2a2ba 100644 --- a/epan/dissectors/packet-x2ap.c +++ b/epan/dissectors/packet-x2ap.c @@ -7908,11 +7908,11 @@ void proto_register_x2ap(void) { register_dissector("x2ap", dissect_x2ap, proto_x2ap); /* Register dissector tables */ - x2ap_ies_dissector_table = register_dissector_table("x2ap.ies", "X2AP-PROTOCOL-IES", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - x2ap_extension_dissector_table = register_dissector_table("x2ap.extension", "X2AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - x2ap_proc_imsg_dissector_table = register_dissector_table("x2ap.proc.imsg", "X2AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - x2ap_proc_sout_dissector_table = register_dissector_table("x2ap.proc.sout", "X2AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); - x2ap_proc_uout_dissector_table = register_dissector_table("x2ap.proc.uout", "X2AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + x2ap_ies_dissector_table = register_dissector_table("x2ap.ies", "X2AP-PROTOCOL-IES", proto_x2ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + x2ap_extension_dissector_table = register_dissector_table("x2ap.extension", "X2AP-PROTOCOL-EXTENSION", proto_x2ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + x2ap_proc_imsg_dissector_table = register_dissector_table("x2ap.proc.imsg", "X2AP-ELEMENTARY-PROCEDURE InitiatingMessage", proto_x2ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + x2ap_proc_sout_dissector_table = register_dissector_table("x2ap.proc.sout", "X2AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_x2ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); + x2ap_proc_uout_dissector_table = register_dissector_table("x2ap.proc.uout", "X2AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_x2ap, FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE); /* Register configuration options for ports */ x2ap_module = prefs_register_protocol(proto_x2ap, proto_reg_handoff_x2ap); diff --git a/epan/dissectors/packet-zbee-aps.c b/epan/dissectors/packet-zbee-aps.c index 015d7bba53..12365b5200 100644 --- a/epan/dissectors/packet-zbee-aps.c +++ b/epan/dissectors/packet-zbee-aps.c @@ -2131,7 +2131,7 @@ void proto_register_zbee_aps(void) expert_register_field_array(expert_zbee_aps, ei, array_length(ei)); /* Register the APS dissector and subdissector list. */ - zbee_aps_dissector_table = register_dissector_table("zbee.profile", "ZigBee Profile ID", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + zbee_aps_dissector_table = register_dissector_table("zbee.profile", "ZigBee Profile ID", proto_zbee_aps, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); zbee_aps_handle = register_dissector(ZBEE_PROTOABBREV_APS, dissect_zbee_aps, proto_zbee_aps); /* Register the init routine. */ diff --git a/epan/dissectors/packet-zbee-zcl.c b/epan/dissectors/packet-zbee-zcl.c index 3dc926bc1c..d356805cd3 100644 --- a/epan/dissectors/packet-zbee-zcl.c +++ b/epan/dissectors/packet-zbee-zcl.c @@ -2268,7 +2268,7 @@ void proto_register_zbee_zcl(void) proto_register_subtree_array(ett, array_length(ett)); /* Register the ZCL dissector and subdissector list. */ - zbee_zcl_dissector_table = register_dissector_table("zbee.zcl.cluster", "ZigBee ZCL Cluster ID", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); + zbee_zcl_dissector_table = register_dissector_table("zbee.zcl.cluster", "ZigBee ZCL Cluster ID", proto_zbee_zcl, FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); register_dissector(ZBEE_PROTOABBREV_ZCL, dissect_zbee_zcl, proto_zbee_zcl); } /* proto_register_zbee_zcl */ diff --git a/epan/packet.c b/epan/packet.c index 0092097b67..05bae051c2 100644 --- a/epan/packet.c +++ b/epan/packet.c @@ -87,6 +87,9 @@ struct data_source { * "param" is the base in which to display the uint value for that * dissector table, if it's a uint dissector table, or if it's a string * table, TRUE/FALSE to indicate case-insensitive or not. + * + * "protocol" is the protocol associated with the dissector table. Used + * for determining dependencies. */ struct dissector_table { GHashTable *hash_table; @@ -94,6 +97,7 @@ struct dissector_table { const char *ui_name; ftenum_t type; int param; + protocol_t *protocol; GHashFunc hash_func; dissector_table_allow_e allow_dup_proto; /* XXX - Could be converted to a flag-like field */ }; @@ -109,6 +113,7 @@ static GHashTable *registered_dissectors = NULL; * A heuristics dissector list. */ struct heur_dissector_list { + protocol_t *protocol; GSList *dissectors; }; @@ -2033,7 +2038,7 @@ dissector_all_tables_foreach_table (DATFunc_table func, } dissector_table_t -register_dissector_table(const char *name, const char *ui_name, const ftenum_t type, +register_dissector_table(const char *name, const char *ui_name, const int proto, const ftenum_t type, const int param, dissector_table_allow_e allow_dup) { dissector_table_t sub_dissectors; @@ -2085,13 +2090,14 @@ register_dissector_table(const char *name, const char *ui_name, const ftenum_t t sub_dissectors->ui_name = ui_name; sub_dissectors->type = type; sub_dissectors->param = param; + sub_dissectors->protocol = find_protocol_by_id(proto); sub_dissectors->allow_dup_proto = allow_dup; g_hash_table_insert( dissector_tables, (gpointer)name, (gpointer) sub_dissectors ); return sub_dissectors; } dissector_table_t register_custom_dissector_table(const char *name, - const char *ui_name, GHashFunc hash_func, GEqualFunc key_equal_func, dissector_table_allow_e allow_dup) + const char *ui_name, const int proto, GHashFunc hash_func, GEqualFunc key_equal_func, dissector_table_allow_e allow_dup) { dissector_table_t sub_dissectors; @@ -2113,6 +2119,7 @@ dissector_table_t register_custom_dissector_table(const char *name, sub_dissectors->ui_name = ui_name; sub_dissectors->type = FT_BYTES; /* Consider key a "blob" of data, no need to really create new type */ sub_dissectors->param = BASE_NONE; + sub_dissectors->protocol = find_protocol_by_id(proto); sub_dissectors->allow_dup_proto = allow_dup; g_hash_table_insert( dissector_tables, (gpointer)name, (gpointer) sub_dissectors ); return sub_dissectors; @@ -2495,7 +2502,7 @@ dissector_dump_heur_decodes(void) heur_dissector_list_t -register_heur_dissector_list(const char *name) +register_heur_dissector_list(const char *name, const int proto) { heur_dissector_list_t sub_dissectors; @@ -2507,6 +2514,7 @@ register_heur_dissector_list(const char *name) /* Create and register the dissector table for this name; returns */ /* a pointer to the dissector table. */ sub_dissectors = g_slice_new(struct heur_dissector_list); + sub_dissectors->protocol = find_protocol_by_id(proto); sub_dissectors->dissectors = NULL; /* initially empty */ g_hash_table_insert(heur_dissector_lists, (gpointer)name, (gpointer) sub_dissectors); diff --git a/epan/packet.h b/epan/packet.h index f1f0862d7a..1fb6453217 100644 --- a/epan/packet.h +++ b/epan/packet.h @@ -186,14 +186,14 @@ WS_DLL_PUBLIC void dissector_all_tables_foreach_table (DATFunc_table func, * case-sensitive) */ WS_DLL_PUBLIC dissector_table_t register_dissector_table(const char *name, - const char *ui_name, const ftenum_t type, const int param, dissector_table_allow_e allow_dup); + const char *ui_name, const int proto, const ftenum_t type, const int param, dissector_table_allow_e allow_dup); /* * Similar to register_dissector_table, but with a "custom" hash function * to store subdissectors. */ WS_DLL_PUBLIC dissector_table_t register_custom_dissector_table(const char *name, - const char *ui_name, GHashFunc hash_func, GEqualFunc key_equal_func, dissector_table_allow_e allow_dup); + const char *ui_name, const int proto, GHashFunc hash_func, GEqualFunc key_equal_func, dissector_table_allow_e allow_dup); /** Deregister the dissector table by table name. */ void deregister_dissector_table(const char *name); @@ -410,7 +410,7 @@ typedef struct heur_dtbl_entry { * * @param name the name of this protocol */ -WS_DLL_PUBLIC heur_dissector_list_t register_heur_dissector_list(const char *name); +WS_DLL_PUBLIC heur_dissector_list_t register_heur_dissector_list(const char *name, const int proto); typedef void (*DATFunc_heur) (const gchar *table_name, struct heur_dtbl_entry *entry, gpointer user_data); diff --git a/epan/wslua/wslua_dissector.c b/epan/wslua/wslua_dissector.c index f68dfafd2b..e0adf0f8a9 100644 --- a/epan/wslua/wslua_dissector.c +++ b/epan/wslua/wslua_dissector.c @@ -201,7 +201,8 @@ WSLUA_CONSTRUCTOR DissectorTable_new (lua_State *L) { name = g_strdup(name); ui_name = g_strdup(ui_name); - dt->table = register_dissector_table(name, ui_name, type, base, DISSECTOR_TABLE_ALLOW_DUPLICATE); + /* XXX - can't determine dependencies of Lua protocols if they don't provide protocol name */ + dt->table = register_dissector_table(name, ui_name, -1, type, base, DISSECTOR_TABLE_ALLOW_DUPLICATE); dt->name = name; dt->ui_name = ui_name; dt->created = TRUE; -- cgit v1.2.3