/*--- proto_register_sbc_ap -------------------------------------------*/
void proto_register_sbc_ap(void) {
/* List of fields */
static hf_register_info hf[] = {
#include "packet-sbc-ap-hfarr.c"
};
/* List of subtrees */
static gint *ett[] = {
&ett_sbc_ap,
#include "packet-sbc-ap-ettarr.c"
};
/* Register protocol */
proto_sbc_ap = proto_register_protocol(PNAME, PSNAME, PFNAME);
/* Register fields and subtrees */
proto_register_field_array(proto_sbc_ap, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
/* Register dissector tables */
sbc_ap_ies_dissector_table = register_dissector_table("sbc_ap.ies", "SBC-AP-PROTOCOL-IES", FT_UINT32, BASE_DEC);
sbc_ap_extension_dissector_table = register_dissector_table("sbc_ap.extension", "SBC-AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC);
sbc_ap_proc_imsg_dissector_table = register_dissector_table("sbc_ap.proc.imsg", "SBC-AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC);
sbc_ap_proc_sout_dissector_table = register_dissector_table("sbc_ap.proc.sout", "SBC-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC);
sbc_ap_proc_uout_dissector_table = register_dissector_table("sbc_ap.proc.uout", "SBC-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC);
}
/*--- proto_register_lppa -------------------------------------------*/
void proto_register_lppa(void) {
/* List of fields */
static hf_register_info hf[] = {
#include "packet-lppa-hfarr.c"
};
/* List of subtrees */
static gint *ett[] = {
&ett_lppa,
#include "packet-lppa-ettarr.c"
};
/* Register protocol */
proto_lppa = proto_register_protocol(PNAME, PSNAME, PFNAME);
register_dissector("lppa", dissect_LPPA_PDU_PDU, proto_lppa);
/* Register fields and subtrees */
proto_register_field_array(proto_lppa, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
/* Register dissector tables */
lppa_ies_dissector_table = register_dissector_table("lppa.ies", "LPPA-PROTOCOL-IES", proto_lppa, FT_UINT32, BASE_DEC);
lppa_proc_imsg_dissector_table = register_dissector_table("lppa.proc.imsg", "LPPA-ELEMENTARY-PROCEDURE InitiatingMessage", proto_lppa, FT_UINT32, BASE_DEC);
lppa_proc_sout_dissector_table = register_dissector_table("lppa.proc.sout", "LPPA-ELEMENTARY-PROCEDURE SuccessfulOutcome", proto_lppa, FT_UINT32, BASE_DEC);
lppa_proc_uout_dissector_table = register_dissector_table("lppa.proc.uout", "LPPA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", proto_lppa, FT_UINT32, BASE_DEC);
}
void
proto_register_osi(void)
{
module_t *osi_module;
/* 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.
all protocols that require inclusion of the NLPID
should register here
*/
osinl_incl_subdissector_table = register_dissector_table("osinl.incl",
"OSI incl NLPID", FT_UINT8, BASE_HEX);
/* 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);
proto_osi = proto_register_protocol("OSI", "OSI", "osi");
/* Preferences how OSI protocols should be dissected */
osi_module = prefs_register_protocol(proto_osi, proto_reg_handoff_osi);
prefs_register_uint_preference(osi_module, "tpkt_port",
"TCP port for OSI over TPKT",
"TCP port for OSI over TPKT",
10, &global_tcp_port_osi_over_tpkt);
prefs_register_bool_preference(osi_module, "tpkt_reassemble",
"Reassemble segmented TPKT datagrams",
"Whether segmented TPKT datagrams should be reassembled",
&tpkt_desegment);
}
/*--- proto_register_x2ap -------------------------------------------*/
void proto_register_x2ap(void) {
/* List of fields */
static hf_register_info hf[] = {
{ &hf_x2ap_transportLayerAddressIPv4,
{ "transportLayerAddress(IPv4)", "x2ap.transportLayerAddressIPv4",
FT_IPv4, BASE_NONE, NULL, 0,
NULL, HFILL }},
{ &hf_x2ap_transportLayerAddressIPv6,
{ "transportLayerAddress(IPv6)", "x2ap.transportLayerAddressIPv6",
FT_IPv6, BASE_NONE, NULL, 0,
NULL, HFILL }},
#include "packet-x2ap-hfarr.c"
};
/* List of subtrees */
static gint *ett[] = {
&ett_x2ap,
&ett_x2ap_TransportLayerAddress,
#include "packet-x2ap-ettarr.c"
};
module_t *x2ap_module;
/* Register protocol */
proto_x2ap = proto_register_protocol(PNAME, PSNAME, PFNAME);
/* Register fields and subtrees */
proto_register_field_array(proto_x2ap, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
/* Register dissector */
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);
x2ap_extension_dissector_table = register_dissector_table("x2ap.extension", "X2AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC);
x2ap_proc_imsg_dissector_table = register_dissector_table("x2ap.proc.imsg", "X2AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC);
x2ap_proc_sout_dissector_table = register_dissector_table("x2ap.proc.sout", "X2AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC);
x2ap_proc_uout_dissector_table = register_dissector_table("x2ap.proc.uout", "X2AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC);
/* Register configuration options for ports */
x2ap_module = prefs_register_protocol(proto_x2ap, proto_reg_handoff_x2ap);
prefs_register_uint_preference(x2ap_module, "sctp.port",
"X2AP SCTP Port",
"Set the SCTP port for X2AP messages",
10,
&gbl_x2apSctpPort);
}
/* Register the protocol with Wireshark */
void
proto_register_slow_protocols(void)
{
/* Setup list of header fields */
static hf_register_info hf[] = {
{ &hf_slow_subtype,
{ "Slow Protocols subtype", "slow.subtype",
FT_UINT8, BASE_HEX, VALS(subtype_vals), 0x0,
NULL, HFILL }},
};
/* Setup protocol subtree array */
static gint *ett[] = {
&ett_slow,
};
/* Register the protocol name and description */
proto_slow = proto_register_protocol("Slow Protocols", "802.3 Slow protocols", "slow");
/* Required function calls to register the header fields and subtrees used */
proto_register_field_array(proto_slow, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
/* subdissector code */
slow_protocols_dissector_table = register_dissector_table("slow.subtype",
"Slow protocol subtype",
FT_UINT8, BASE_DEC);
}
void
proto_register_hci_h4(void)
{
static hf_register_info hf[] = {
{ &hf_hci_h4_type,
{ "HCI Packet Type", "hci_h4.type",
FT_UINT8, BASE_HEX, VALS(hci_h4_type_vals), 0x0,
NULL, HFILL }},
{ &hf_hci_h4_direction,
{ "Direction", "hci_h4.direction",
FT_UINT8, BASE_HEX, VALS(hci_h4_direction_vals), 0x0,
"HCI Packet Direction Sent/Rcvd", HFILL }},
};
static gint *ett[] = {
&ett_hci_h4,
};
proto_hci_h4 = proto_register_protocol("Bluetooth HCI H4",
"HCI_H4", "hci_h4");
register_dissector("hci_h4", dissect_hci_h4, proto_hci_h4);
proto_register_field_array(proto_hci_h4, hf, array_length(hf));
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);
}
void proto_reg_handoff_uaudp(void)
{
static gboolean prefs_initialized = FALSE;
static dissector_handle_t uaudp_handle;
int i;
if (!prefs_initialized)
{
uaudp_handle = find_dissector("uaudp");
ua_sys_to_term_handle = find_dissector("ua_sys_to_term");
ua_term_to_sys_handle = find_dissector("ua_term_to_sys");
#if 0
uaudp_opcode_dissector_table =
register_dissector_table("uaudp.opcode",
"UAUDP opcode",
FT_UINT8,
BASE_DEC);
#endif
prefs_initialized = TRUE;
}
else
{
for (i=0; i<MAX_TERMINAL_PORTS; i++)
{
if (ports[i].last_port)
dissector_delete_uint("udp.port", ports[i].last_port, uaudp_handle);
}
if (str_to_addr_ip(pref_sys_ip_s, sys_ip))
{
use_sys_ip = TRUE;
}
else
{
use_sys_ip = FALSE;
pref_sys_ip_s = "";
}
}
if (decode_ua)
{
int no_ports_registered = TRUE;
for (i=0; i < MAX_TERMINAL_PORTS; i++)
{
if (ports[i].port)
{
dissector_add_uint("udp.port", ports[i].port, uaudp_handle);
no_ports_registered = FALSE;
}
ports[i].last_port = ports[i].port;
}
if (no_ports_registered)
{
/* If all ports are set to 0, then just register the handle so
* at least "Decode As..." will work. */
dissector_add_handle("udp.port", uaudp_handle);
}
}
}
void
proto_register_ethertype(void)
{
/* subdissector code */
ethertype_dissector_table = register_dissector_table("ethertype",
"Ethertype", FT_UINT16, BASE_HEX);
}
void
proto_register_hpext(void)
{
#ifndef HAVE_HFI_SECTION_INIT
static header_field_info *hfi[] = {
&hfi_hpext_dxsap,
&hfi_hpext_sxsap,
};
#endif
static gint *ett[] = {
&ett_hpext
};
int proto_hpext;
proto_hpext = proto_register_protocol(
"HP Extended Local-Link Control", "HPEXT", "hpext");
hfi_hpext = proto_registrar_get_nth(proto_hpext);
proto_register_fields(proto_hpext, hfi, array_length(hfi));
proto_register_subtree_array(ett, array_length(ett));
/* subdissector code */
subdissector_table = register_dissector_table("hpext.dxsap",
"HPEXT XSAP", FT_UINT16, BASE_HEX);
hpext_handle = register_dissector("hpext", dissect_hpext, proto_hpext);
}
void proto_reg_handoff_ua_msg(void)
{
#if 0 /* Future */
dissector_handle_t handle_ua_msg;
/* hooking of UA on UAUDP */
/* XXX: The following is NG since the same 'pattern' is added twice */
handle_ua_msg = find_dissector("ua_sys_to_term");
dissector_add_uint("uaudp.opcode", UAUDP_DATA, handle_ua_msg);
handle_ua_msg = find_dissector("ua_term_to_sys");
dissector_add_uint("uaudp.opcode", UAUDP_DATA, handle_ua_msg);
/* For hooking dissectors to UA */
ua_opcode_dissector_table =
register_dissector_table("ua.opcode",
"ua.opcode",
FT_UINT8,
BASE_HEX);
#endif
noe_handle = find_dissector("noe");
ua3g_handle = find_dissector("ua3g");
}
void
proto_register_arcnet (void)
{
/* Setup list of header fields See Section 1.6.1 for details*/
static hf_register_info hf[] = {
{&hf_arcnet_src,
{"Source", "arcnet.src",
FT_UINT8, BASE_HEX, NULL, 0,
"Source ID", HFILL}
},
{&hf_arcnet_dst,
{"Dest", "arcnet.dst",
FT_UINT8, BASE_HEX, NULL, 0,
"Dest ID", HFILL}
},
{&hf_arcnet_offset,
{"Offset", "arcnet.offset",
FT_BYTES, BASE_NONE, NULL, 0,
NULL, HFILL}
},
{&hf_arcnet_protID,
{"Protocol ID", "arcnet.protID",
FT_UINT8, BASE_HEX, VALS(arcnet_prot_id_vals), 0,
"Proto type", HFILL}
},
{&hf_arcnet_split_flag,
{"Split Flag", "arcnet.split_flag",
FT_UINT8, BASE_DEC, NULL, 0,
NULL, HFILL}
},
{&hf_arcnet_exception_flag,
{"Exception Flag", "arcnet.exception_flag",
FT_UINT8, BASE_HEX, NULL, 0,
NULL, HFILL}
},
{&hf_arcnet_sequence,
{"Sequence", "arcnet.sequence",
FT_UINT16, BASE_DEC, NULL, 0,
"Sequence number", HFILL}
},
};
/* Setup protocol subtree array */
static gint *ett[] = {
&ett_arcnet,
};
arcnet_dissector_table = register_dissector_table ("arcnet.protocol_id",
"ARCNET Protocol ID",
FT_UINT8, BASE_HEX);
/* Register the protocol name and description */
proto_arcnet = proto_register_protocol ("ARCNET", "ARCNET", "arcnet");
/* Required function calls to register the header fields and subtrees used */
proto_register_field_array (proto_arcnet, hf, array_length (hf));
proto_register_subtree_array (ett, array_length (ett));
}
/*--- proto_register_cmip ----------------------------------------------*/
void proto_register_cmip(void) {
/* List of fields */
static hf_register_info hf[] = {
{ &hf_cmip_actionType_OID,
{ "actionType", "cmip.actionType_OID",
FT_STRING, BASE_NONE, NULL, 0,
NULL, HFILL }},
{ &hf_cmip_eventType_OID,
{ "eventType", "cmip.eventType_OID",
FT_STRING, BASE_NONE, NULL, 0,
NULL, HFILL }},
{ &hf_cmip_attributeId_OID,
{ "attributeId", "cmip.attributeId_OID",
FT_STRING, BASE_NONE, NULL, 0,
NULL, HFILL }},
{ &hf_cmip_errorId_OID,
{ "errorId", "cmip.errorId_OID",
FT_STRING, BASE_NONE, NULL, 0,
NULL, HFILL }},
{ &hf_DiscriminatorConstruct,
{ "DiscriminatorConstruct", "cmip.DiscriminatorConstruct",
FT_UINT32, BASE_DEC, NULL, 0,
NULL, HFILL }},
{ &hf_Destination,
{ "Destination", "cmip.Destination",
FT_UINT32, BASE_DEC, NULL, 0,
NULL, HFILL }},
{ &hf_NameBinding,
{ "NameBinding", "cmip.NameBinding",
FT_STRING, BASE_NONE, NULL, 0,
NULL, HFILL }},
{ &hf_ObjectClass,
{ "ObjectClass", "cmip.ObjectClass",
FT_UINT32, BASE_DEC, VALS(cmip_ObjectClass_vals), 0,
NULL, HFILL }},
#include "packet-cmip-hfarr.c"
};
/* List of subtrees */
static gint *ett[] = {
&ett_cmip,
#include "packet-cmip-ettarr.c"
};
/* Register protocol */
proto_cmip = proto_register_protocol(PNAME, PSNAME, PFNAME);
new_register_dissector("cmip", dissect_cmip, proto_cmip);
/* Register fields and subtrees */
proto_register_field_array(proto_cmip, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
#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);
}
/*--- proto_register_s1ap -------------------------------------------*/
void proto_register_s1ap(void) {
/* List of fields */
static hf_register_info hf[] = {
{ &hf_s1ap_transportLayerAddressIPv4,
{ "transportLayerAddress(IPv4)", "s1ap.transportLayerAddressIPv4",
FT_IPv4, BASE_NONE, NULL, 0,
NULL, HFILL }},
{ &hf_s1ap_transportLayerAddressIPv6,
{ "transportLayerAddress(IPv6)", "s1ap.transportLayerAddressIPv6",
FT_IPv6, BASE_NONE, NULL, 0,
NULL, HFILL }},
#include "packet-s1ap-hfarr.c"
};
/* List of subtrees */
static gint *ett[] = {
&ett_s1ap,
&ett_s1ap_TransportLayerAddress,
&ett_s1ap_ToTargetTransparentContainer,
&ett_s1ap_ToSourceTransparentContainer,
&ett_s1ap_RRCContainer,
&ett_s1ap_UERadioCapability,
&ett_s1ap_RIMInformation,
#include "packet-s1ap-ettarr.c"
};
module_t *s1ap_module;
/* Register protocol */
proto_s1ap = proto_register_protocol(PNAME, PSNAME, PFNAME);
/* Register fields and subtrees */
proto_register_field_array(proto_s1ap, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
/* Register dissector */
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);
s1ap_ies_p1_dissector_table = register_dissector_table("s1ap.ies.pair.first", "S1AP-PROTOCOL-IES-PAIR FirstValue", FT_UINT32, BASE_DEC);
s1ap_ies_p2_dissector_table = register_dissector_table("s1ap.ies.pair.second", "S1AP-PROTOCOL-IES-PAIR SecondValue", FT_UINT32, BASE_DEC);
s1ap_extension_dissector_table = register_dissector_table("s1ap.extension", "S1AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC);
s1ap_proc_imsg_dissector_table = register_dissector_table("s1ap.proc.imsg", "S1AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC);
s1ap_proc_sout_dissector_table = register_dissector_table("s1ap.proc.sout", "S1AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC);
s1ap_proc_uout_dissector_table = register_dissector_table("s1ap.proc.uout", "S1AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC);
/* Register configuration options for ports */
s1ap_module = prefs_register_protocol(proto_s1ap, proto_reg_handoff_s1ap);
prefs_register_uint_preference(s1ap_module, "sctp.port",
"S1AP SCTP Port",
"Set the SCTP port for S1AP messages",
10,
&gbl_s1apSctpPort);
prefs_register_bool_preference(s1ap_module, "dissect_container", "Dissect TransparentContainer", "Dissect TransparentContainers that are opaque to S1AP", &g_s1ap_dissect_container);
}
/*--- proto_register_nbap -------------------------------------------*/
void proto_register_nbap(void) {
/* List of fields */
static hf_register_info hf[] = {
{ &hf_nbap_transportLayerAddress_ipv4,
{ "transportLayerAddress IPv4", "nbap.transportLayerAddress_ipv4",
FT_IPv4, BASE_NONE, NULL, 0,
NULL, HFILL }},
{ &hf_nbap_transportLayerAddress_ipv6,
{ "transportLayerAddress IPv6", "nbap.transportLayerAddress_ipv6",
FT_IPv6, BASE_NONE, NULL, 0,
NULL, HFILL }},
#include "packet-nbap-hfarr.c"
};
/* List of subtrees */
static gint *ett[] = {
&ett_nbap,
&ett_nbap_TransportLayerAddress,
#include "packet-nbap-ettarr.c"
};
/* Register protocol */
proto_nbap = proto_register_protocol(PNAME, PSNAME, PFNAME);
/* Register fields and subtrees */
proto_register_field_array(proto_nbap, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
/* Register dissector */
register_dissector("nbap", dissect_nbap, proto_nbap);
/* Register dissector tables */
nbap_ies_dissector_table = register_dissector_table("nbap.ies", "NBAP-PROTOCOL-IES", FT_UINT32, BASE_DEC);
nbap_extension_dissector_table = register_dissector_table("nbap.extension", "NBAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC);
nbap_proc_imsg_dissector_table = register_dissector_table("nbap.proc.imsg", "NBAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_STRING, BASE_NONE);
nbap_proc_sout_dissector_table = register_dissector_table("nbap.proc.sout", "NBAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_STRING, BASE_NONE);
nbap_proc_uout_dissector_table = register_dissector_table("nbap.proc.uout", "NBAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_STRING, BASE_NONE);
}
void
proto_register_interlink(void)
{
static hf_register_info hf[] = {
{ &hf_interlink_id, {
"Magic ID", "interlink.id", FT_STRING,
BASE_NONE, NULL, 0, NULL, HFILL }},
{ &hf_interlink_version, {
"Version", "interlink.version", FT_UINT16,
BASE_DEC, NULL, 0, NULL, HFILL }},
{ &hf_interlink_cmd, {
"Command", "interlink.cmd", FT_UINT16,
BASE_DEC, VALS(names_cmd), 0, NULL, HFILL }},
{ &hf_interlink_seq, {
"Sequence", "interlink.seq", FT_UINT16,
BASE_DEC, NULL, 0, NULL, HFILL }},
{ &hf_interlink_flags, {
"Flags", "interlink.flags", FT_UINT16,
BASE_HEX, NULL, 0, NULL, HFILL }},
{ &hf_interlink_flags_req_ack, {
"REQ_ACK", "interlink.flags.req_ack", FT_BOOLEAN,
16, TFS(&flags_set_notset), 0x01, NULL, HFILL }},
{ &hf_interlink_flags_inc_ack_port, {
"INC_ACK_PORT", "interlink.flags.inc_ack_port", FT_BOOLEAN,
16, TFS(&flags_set_notset), 0x02, NULL, HFILL }},
{ &hf_interlink_block_type, {
"Type", "interlink.type", FT_UINT8,
BASE_DEC, NULL, 0, NULL, HFILL }},
{ &hf_interlink_block_version, {
"Version", "interlink.block_version", FT_UINT8,
BASE_DEC, NULL, 0, NULL, HFILL }},
{ &hf_interlink_block_length, {
"Length", "interlink.length", FT_UINT16,
BASE_DEC, NULL, 0, NULL, HFILL }},
};
static gint *ett[] = {
&ett_interlink,
&ett_interlink_header,
&ett_interlink_flags,
&ett_interlink_block,
};
proto_interlink = proto_register_protocol("Interlink Protocol",
"Interlink",
"interlink");
proto_register_field_array(proto_interlink, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
register_dissector("interlink", dissect_interlink, proto_interlink);
/* 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);
}
void
proto_register_mpeg_sect(void)
{
static hf_register_info hf[] = {
{ &hf_mpeg_sect_table_id, {
"Table ID", "mpeg_sect.tid",
FT_UINT8, BASE_HEX, VALS(mpeg_sect_table_id_vals), 0, NULL, HFILL
} },
{ &hf_mpeg_sect_syntax_indicator, {
"Syntax indicator", "mpeg_sect.syntax_indicator",
FT_UINT16, BASE_DEC, NULL, MPEG_SECT_SYNTAX_INDICATOR_MASK, NULL, HFILL
} },
{ &hf_mpeg_sect_reserved, {
"Reserved", "mpeg_sect.reserved",
FT_UINT16, BASE_HEX, NULL, MPEG_SECT_RESERVED_MASK, NULL, HFILL
} },
{ &hf_mpeg_sect_length, {
"Length", "mpeg_sect.len",
FT_UINT16, BASE_DEC, NULL, MPEG_SECT_LENGTH_MASK, NULL, HFILL
} },
{ &hf_mpeg_sect_crc, {
"CRC 32", "mpeg_sect.crc",
FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL
} }
};
static gint *ett[] = {
&ett_mpeg_sect
};
module_t *mpeg_sect_module;
proto_mpeg_sect = proto_register_protocol("MPEG2 Section", "MPEG SECT", "mpeg_sect");
register_dissector("mpeg_sect", dissect_mpeg_sect, proto_mpeg_sect);
proto_register_field_array(proto_mpeg_sect, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
mpeg_sect_module = prefs_register_protocol(proto_mpeg_sect, NULL);
prefs_register_bool_preference(mpeg_sect_module,
"verify_crc",
"Verify the section CRC",
"Whether the section dissector should verify the CRC",
&mpeg_sect_check_crc);
mpeg_sect_tid_dissector_table = register_dissector_table("mpeg_sect.tid",
"MPEG SECT Table ID",
FT_UINT8, BASE_HEX);
}
/* Register Wimax Mac Payload Protocol and Dissector */
void proto_register_mac_mgmt_msg(void)
{
/* Payload display */
static hf_register_info hf[] =
{
{
&hf_mac_mgmt_msg_type,
{
"MAC Management Message Type", "wmx.macmgtmsgtype",
FT_UINT8, BASE_DEC | BASE_EXT_STRING, &mgt_msg_abbrv_vals_ext, 0x0,
NULL, HFILL
}
},
{
&hf_mac_mgmt_msg_values,
{
"Values", "wmx.values",
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL
}
},
};
/* Setup protocol subtree array */
static gint *ett[] =
{
&ett_mac_mgmt_msg_decoder,
};
static ei_register_info ei[] = {
{ &ei_empty_payload, { "wmx.empty_payload", PI_PROTOCOL, PI_ERROR, "Error: Mac payload tvb is empty !", EXPFILL }},
};
expert_module_t* expert_mac_mgmt;
proto_mac_mgmt_msg_decoder = proto_register_protocol (
"WiMax MAC Management Message", /* name */
"MGMT MSG", /* short name */
"wmx.mgmt" /* abbrev */
);
proto_register_field_array(proto_mac_mgmt_msg_decoder, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
expert_mac_mgmt = expert_register_protocol(proto_mac_mgmt_msg_decoder);
expert_register_field_array(expert_mac_mgmt, ei, array_length(ei));
subdissector_message_table = register_dissector_table("wmx.mgmtmsg",
"WiMax MAC Management Message", FT_UINT8, BASE_DEC);
/* Register dissector by name */
register_dissector("wmx_mac_mgmt_msg_decoder", dissect_mac_mgmt_msg_decoder,
proto_mac_mgmt_msg_decoder);
}
/*--- proto_register_ros -------------------------------------------*/
void proto_register_ros(void) {
/* List of fields */
static hf_register_info hf[] =
{
{ &hf_ros_response_in,
{ "Response In", "ros.response_in",
FT_FRAMENUM, BASE_NONE, NULL, 0x0,
"The response to this remote operation invocation is in this frame", HFILL }},
{ &hf_ros_response_to,
{ "Response To", "ros.response_to",
FT_FRAMENUM, BASE_NONE, NULL, 0x0,
"This is a response to the remote operation invocation in this frame", HFILL }},
{ &hf_ros_time,
{ "Time", "ros.time",
FT_RELATIVE_TIME, BASE_NONE, NULL, 0x0,
"The time between the Invoke and the Response", HFILL }},
#include "packet-ros-hfarr.c"
};
/* List of subtrees */
static gint *ett[] = {
&ett_ros,
&ett_ros_unknown,
#include "packet-ros-ettarr.c"
};
static ei_register_info ei[] = {
{ &ei_ros_dissector_oid_not_implemented, { "ros.dissector_oid_not_implemented", PI_UNDECODED, PI_WARN, "ROS: Dissector for OID not implemented", EXPFILL }},
{ &ei_ros_unknown_ros_pdu, { "ros.unknown_ros_pdu", PI_UNDECODED, PI_WARN, "Unknown ROS PDU", EXPFILL }},
};
expert_module_t* expert_ros;
/* Register protocol */
proto_ros = proto_register_protocol(PNAME, PSNAME, PFNAME);
new_register_dissector("ros", dissect_ros, proto_ros);
/* Register fields and subtrees */
proto_register_field_array(proto_ros, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
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);
oid_table=g_hash_table_new(g_str_hash, g_str_equal);
protocol_table=g_hash_table_new(g_str_hash, g_str_equal);
ros_handle = find_dissector("ros");
register_init_routine(ros_reinit);
}
void proto_register_op_uavtalk(void)
{
module_t *op_uavtalk_module;
static hf_register_info hf[] = {
{ &hf_op_uavtalk_sync,
{ "Sync Byte", "uavtalk.sync", FT_UINT8,
BASE_HEX, NULL, 0x0, NULL, HFILL }
},
{ &hf_op_uavtalk_version,
{ "Version", "uavtalk.ver", FT_UINT8,
BASE_DEC, NULL, 0xf8, NULL, HFILL }
},
{ &hf_op_uavtalk_type,
{ "Type", "uavtalk.type", FT_UINT8,
BASE_HEX, VALS(uavtalk_packet_types), 0x07, NULL, HFILL }
},
{ &hf_op_uavtalk_len,
{ "Length", "uavtalk.len", FT_UINT16,
BASE_DEC, NULL, 0x0, NULL, HFILL }
},
{ &hf_op_uavtalk_objid,
{ "ObjID", "uavtalk.objid", FT_UINT32,
BASE_HEX, NULL, 0x0, NULL, HFILL }
},
{ &hf_op_uavtalk_crc8,
{ "Crc8", "uavtalk.crc8", FT_UINT8,
BASE_HEX, NULL, 0x0, NULL, HFILL }
},
};
/* Setup protocol subtree array */
static gint *ett[] = {
&ett_op_uavtalk
};
proto_op_uavtalk = proto_register_protocol("OpenPilot UAVTalk Protocol",
"UAVTALK",
"uavtalk");
/* Allow subdissectors for each objid to bind for decoding */
uavtalk_subdissector_table = register_dissector_table("uavtalk.objid", "UAVObject ID", FT_UINT32, BASE_HEX);
proto_register_subtree_array(ett, array_length(ett));
proto_register_field_array(proto_op_uavtalk, hf, array_length(hf));
op_uavtalk_module = prefs_register_protocol(proto_op_uavtalk, proto_reg_handoff_op_uavtalk);
prefs_register_uint_preference(op_uavtalk_module, "udp.port", "UAVTALK UDP port",
"UAVTALK port (default 9000)", 10, &global_op_uavtalk_port);
}
/*--- proto_register_m3ap -------------------------------------------*/
void proto_register_m3ap(void) {
/* List of fields */
static hf_register_info hf[] = {
{ &hf_m3ap_Absolute_Time_ofMBMS_Data_value,
{ "Absolute-Time-ofMBMS-Data-value", "m3ap.Absolute_Time_ofMBMS_Data_value",
FT_STRING, BASE_NONE, NULL, 0,
NULL, HFILL }
},
{ &hf_m3ap_IPAddress,
{ "IPAddress", "m3ap.IPAddress",
FT_IPv6, BASE_NONE, NULL, 0,
NULL, HFILL }
},
#include "packet-m3ap-hfarr.c"
};
/* List of subtrees */
static gint *ett[] = {
&ett_m3ap,
#include "packet-m3ap-ettarr.c"
};
/* Register protocol */
proto_m3ap = proto_register_protocol(PNAME, PSNAME, PFNAME);
/* Register fields and subtrees */
proto_register_field_array(proto_m3ap, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
/* Register dissector tables */
m3ap_ies_dissector_table = register_dissector_table("m3ap.ies", "M3AP-PROTOCOL-IES", FT_UINT32, BASE_DEC);
m3ap_extension_dissector_table = register_dissector_table("m3ap.extension", "M3AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC);
m3ap_proc_imsg_dissector_table = register_dissector_table("m3ap.proc.imsg", "M3AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC);
m3ap_proc_sout_dissector_table = register_dissector_table("m3ap.proc.sout", "M3AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC);
m3ap_proc_uout_dissector_table = register_dissector_table("m3ap.proc.uout", "M3AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC);
}
void
proto_register_sita(void)
{
static hf_register_info hf[] = {
{ &hf_proto, { "Protocol", "sita.errors.protocol", FT_UINT8, BASE_HEX, VALS(tfs_sita_proto), 0, "Protocol value", HFILL }},
{ &hf_dir, { "Direction", "sita.flags.flags", FT_BOOLEAN, 8, TFS(&tfs_sita_flags), SITA_FRAME_DIR, "TRUE 'from Remote', FALSE 'from Local'", HFILL }},
{ &hf_droppedframe, { "No Buffers", "sita.flags.droppedframe", FT_BOOLEAN, 8, TFS(&tfs_sita_error), SITA_ERROR_NO_BUFFER, "TRUE if Buffer Failure", HFILL }},
{ &hf_framing, { "Framing", "sita.errors.framing", FT_BOOLEAN, 8, TFS(&tfs_sita_error), SITA_ERROR_RX_FRAMING, "TRUE if Framing Error", HFILL }},
{ &hf_parity, { "Parity", "sita.errors.parity", FT_BOOLEAN, 8, TFS(&tfs_sita_error), SITA_ERROR_RX_PARITY, "TRUE if Parity Error", HFILL }},
{ &hf_collision, { "Collision", "sita.errors.collision", FT_BOOLEAN, 8, TFS(&tfs_sita_error), SITA_ERROR_RX_COLLISION, "TRUE if Collision", HFILL }},
{ &hf_longframe, { "Long Frame", "sita.errors.longframe", FT_BOOLEAN, 8, TFS(&tfs_sita_error), SITA_ERROR_RX_FRAME_LONG, "TRUE if Long Frame Received", HFILL }},
{ &hf_shortframe, { "Short Frame", "sita.errors.shortframe", FT_BOOLEAN, 8, TFS(&tfs_sita_error), SITA_ERROR_RX_FRAME_SHORT, "TRUE if Short Frame", HFILL }},
{ &hf_nonaligned, { "NonAligned", "sita.errors.nonaligned", FT_BOOLEAN, 8, TFS(&tfs_sita_error), SITA_ERROR_RX_NONOCTET_ALIGNED, "TRUE if NonAligned Frame", HFILL }},
{ &hf_abort, { "Abort", "sita.errors.abort", FT_BOOLEAN, 8, TFS(&tfs_sita_received), SITA_ERROR_RX_ABORT, "TRUE if Abort Received", HFILL }},
{ &hf_lostcd, { "Carrier", "sita.errors.lostcd", FT_BOOLEAN, 8, TFS(&tfs_sita_lost), SITA_ERROR_RX_CD_LOST, "TRUE if Carrier Lost", HFILL }},
{ &hf_rxdpll, { "DPLL", "sita.errors.rxdpll", FT_BOOLEAN, 8, TFS(&tfs_sita_error), SITA_ERROR_RX_DPLL, "TRUE if DPLL Error", HFILL }},
{ &hf_overrun, { "Overrun", "sita.errors.overrun", FT_BOOLEAN, 8, TFS(&tfs_sita_error), SITA_ERROR_RX_OVERRUN, "TRUE if Overrun Error", HFILL }},
{ &hf_length, { "Length", "sita.errors.length", FT_BOOLEAN, 8, TFS(&tfs_sita_violation),SITA_ERROR_RX_FRAME_LEN_VIOL, "TRUE if Length Violation", HFILL }},
{ &hf_crc, { "CRC", "sita.errors.crc", FT_BOOLEAN, 8, TFS(&tfs_sita_error), SITA_ERROR_RX_CRC, "TRUE if CRC Error", HFILL }},
{ &hf_break, { "Break", "sita.errors.break", FT_BOOLEAN, 8, TFS(&tfs_sita_received), SITA_ERROR_RX_BREAK, "TRUE if Break Received", HFILL }},
{ &hf_underrun, { "Underrun", "sita.errors.underrun", FT_BOOLEAN, 8, TFS(&tfs_sita_error), SITA_ERROR_TX_UNDERRUN, "TRUE if Tx Underrun", HFILL }},
{ &hf_lostcts, { "Clear To Send", "sita.errors.lostcts", FT_BOOLEAN, 8, TFS(&tfs_sita_lost), SITA_ERROR_TX_CTS_LOST, "TRUE if Clear To Send Lost", HFILL }},
{ &hf_uarterror, { "UART", "sita.errors.uarterror", FT_BOOLEAN, 8, TFS(&tfs_sita_error), SITA_ERROR_TX_UART_ERROR, "TRUE if UART Error", HFILL }},
{ &hf_rtxlimit, { "Retx Limit", "sita.errors.rtxlimit", FT_BOOLEAN, 8, TFS(&tfs_sita_exceeded), SITA_ERROR_TX_RETX_LIMIT, "TRUE if Retransmit Limit reached", HFILL }},
{ &hf_dsr, { "DSR", "sita.signals.dsr", FT_BOOLEAN, 8, TFS(&tfs_sita_on_off), SITA_SIG_DSR, "TRUE if Data Set Ready", HFILL }},
{ &hf_dtr, { "DTR", "sita.signals.dtr", FT_BOOLEAN, 8, TFS(&tfs_sita_on_off), SITA_SIG_DTR, "TRUE if Data Terminal Ready", HFILL }},
{ &hf_cts, { "CTS", "sita.signals.cts", FT_BOOLEAN, 8, TFS(&tfs_sita_on_off), SITA_SIG_CTS, "TRUE if Clear To Send", HFILL }},
{ &hf_rts, { "RTS", "sita.signals.rts", FT_BOOLEAN, 8, TFS(&tfs_sita_on_off), SITA_SIG_RTS, "TRUE if Request To Send", HFILL }},
{ &hf_dcd, { "DCD", "sita.signals.dcd", FT_BOOLEAN, 8, TFS(&tfs_sita_on_off), SITA_SIG_DCD, "TRUE if Data Carrier Detect", HFILL }},
};
static gint *ett[] = {
&ett_sita,
&ett_sita_flags,
&ett_sita_signals,
&ett_sita_errors1,
&ett_sita_errors2,
};
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);
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);
}
/*--- proto_register_pcap -------------------------------------------*/
void proto_register_pcap(void) {
/* List of fields */
static hf_register_info hf[] = {
#include "packet-pcap-hfarr.c"
};
/* List of subtrees */
static gint *ett[] = {
&ett_pcap,
#include "packet-pcap-ettarr.c"
};
module_t *pcap_module;
/* Register protocol */
proto_pcap = proto_register_protocol(PNAME, PSNAME, PFNAME);
/* Register fields and subtrees */
proto_register_field_array(proto_pcap, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
pcap_module = prefs_register_protocol(proto_pcap, proto_reg_handoff_pcap);
/* Register dissector */
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);
pcap_ies_p1_dissector_table = register_dissector_table("pcap.ies.pair.first", "PCAP-PROTOCOL-IES-PAIR FirstValue", FT_UINT32, BASE_DEC);
pcap_ies_p2_dissector_table = register_dissector_table("pcap.ies.pair.second", "PCAP-PROTOCOL-IES-PAIR SecondValue", FT_UINT32, BASE_DEC);
pcap_extension_dissector_table = register_dissector_table("pcap.extension", "PCAP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC);
pcap_proc_imsg_dissector_table = register_dissector_table("pcap.proc.imsg", "PCAP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC);
pcap_proc_sout_dissector_table = register_dissector_table("pcap.proc.sout", "PCAP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC);
pcap_proc_uout_dissector_table = register_dissector_table("pcap.proc.uout", "PCAP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC);
pcap_proc_out_dissector_table = register_dissector_table("pcap.proc.out", "PCAP-ELEMENTARY-PROCEDURE Outcome", FT_UINT32, BASE_DEC);
/* Preferences */
/* Set default SSNs */
range_convert_str(&global_ssn_range, "", MAX_SSN);
prefs_register_range_preference(pcap_module, "ssn", "SCCP SSNs",
"SCCP (and SUA) SSNs to decode as PCAP",
&global_ssn_range, MAX_SSN);
}
/*--- proto_register_rua -------------------------------------------*/
void proto_register_rua(void) {
module_t *rua_module;
/* List of fields */
static hf_register_info hf[] = {
#include "packet-rua-hfarr.c"
};
/* List of subtrees */
static gint *ett[] = {
&ett_rua,
#include "packet-rua-ettarr.c"
};
/* Register protocol */
proto_rua = proto_register_protocol(PNAME, PSNAME, PFNAME);
/* Register fields and subtrees */
proto_register_field_array(proto_rua, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
/* Register dissector */
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);
rua_extension_dissector_table = register_dissector_table("rua.extension", "RUA-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC);
rua_proc_imsg_dissector_table = register_dissector_table("rua.proc.imsg", "RUA-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC);
rua_proc_sout_dissector_table = register_dissector_table("rua.proc.sout", "RUA-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC);
rua_proc_uout_dissector_table = register_dissector_table("rua.proc.uout", "RUA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC);
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);
}
/*--- proto_register_dop -------------------------------------------*/
void proto_register_dop(void) {
/* List of fields */
static hf_register_info hf[] =
{
#include "packet-dop-hfarr.c"
};
/* List of subtrees */
static gint *ett[] = {
&ett_dop,
&ett_dop_unknown,
#include "packet-dop-ettarr.c"
};
static ei_register_info ei[] = {
{ &ei_dop_unknown_binding_parameter, { "dop.unknown_binding_parameter", PI_UNDECODED, PI_WARN, "Unknown binding-parameter", EXPFILL }},
};
expert_module_t* expert_dop;
module_t *dop_module;
/* Register protocol */
proto_dop = proto_register_protocol(PNAME, PSNAME, PFNAME);
new_register_dissector("dop", dissect_dop, proto_dop);
dop_dissector_table = register_dissector_table("dop.oid", "DOP OID Dissectors", FT_STRING, BASE_NONE);
/* Register fields and subtrees */
proto_register_field_array(proto_dop, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
expert_dop = expert_register_protocol(proto_dop);
expert_register_field_array(expert_dop, ei, array_length(ei));
/* Register our configuration options for DOP, particularly our port */
dop_module = prefs_register_protocol_subtree("OSI/X.500", proto_dop, prefs_register_dop);
prefs_register_uint_preference(dop_module, "tcp.port", "DOP TCP Port",
"Set the port for DOP operations (if other"
" than the default of 102)",
10, &global_dop_tcp_port);
}
void
proto_register_frame(void)
{
wtap_encap_dissector_table = register_dissector_table("wtap_encap",
"Wiretap encapsulation type", FT_UINT32, BASE_DEC);
proto_frame = proto_register_protocol("Frame", "Frame", "frame");
proto_pkt_comment = proto_register_protocol("Packet comments", "Pkt_Comment", "pkt_comment");
register_dissector("frame",dissect_frame,proto_frame);
/* You can't disable dissection of "Frame", as that would be
tantamount to not doing any dissection whatsoever. */
proto_set_cant_toggle(proto_frame);
frame_tap=register_tap("frame");
}
void
proto_register_ethertype(void)
{
/* Decode As handling */
static build_valid_func eth_da_build_value[1] = {eth_value};
static decode_as_value_t eth_da_values = {eth_prompt, 1, eth_da_build_value};
static decode_as_t ethertype_da = {"ethertype", "Link", "ethertype", 1, 0, ð_da_values, NULL, NULL,
decode_as_default_populate_list, decode_as_default_reset, decode_as_default_change, NULL};
proto_ethertype = proto_register_protocol("Ethertype", "Ethertype", "ethertype");
new_register_dissector("ethertype", dissect_ethertype, proto_ethertype);
/* subdissector code */
ethertype_dissector_table = register_dissector_table("ethertype",
"Ethertype", FT_UINT16, BASE_HEX);
register_decode_as(ðertype_da);
}
/*
* Add an entry for a new OUI.
*/
void
llc_add_oui(guint32 oui, const char *table_name, const char *table_ui_name,
hf_register_info *hf_item, const int proto)
{
oui_info_t *new_info;
new_info = wmem_new(wmem_epan_scope(), oui_info_t);
new_info->table = register_dissector_table(table_name,
table_ui_name, proto, FT_UINT16, BASE_HEX);
new_info->field_info = hf_item;
/*
* Create the hash table for OUI information, if it doesn't
* already exist.
*/
if (oui_info_table == NULL) {
oui_info_table = wmem_map_new(wmem_epan_scope(), g_direct_hash,
g_direct_equal);
}
wmem_map_insert(oui_info_table, GUINT_TO_POINTER(oui), new_info);
}
void
proto_register_bctp (void)
{
static hf_register_info hf[] = {
{&hf_bctp_bvei, {"BVEI", "bctp.bvei", FT_UINT16, BASE_HEX, VALS(bvei_vals), 0x4000, "BCTP Version Error Indicator", HFILL }},
{&hf_bctp_bvi, {"BVI", "bctp.bvi", FT_UINT16, BASE_HEX, NULL, 0x1F00, "BCTP Version Indicator", HFILL }},
{&hf_bctp_tpei, {"TPEI", "bctp.tpei", FT_UINT16, BASE_HEX, NULL, 0x0040, "Tunneled Protocol Error Indicator", HFILL }},
{&hf_bctp_tpi, {"TPI", "bctp.tpi", FT_UINT16, BASE_HEX, NULL, 0x003F, "Tunneled Protocol Indicator", HFILL }},
};
static gint *ett[] = {
&ett_bctp
};
proto_bctp = proto_register_protocol(PNAME, PSNAME, PFNAME);
proto_register_field_array(proto_bctp, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
register_dissector("bctp", dissect_bctp, proto_bctp);
bctp_dissector_table = register_dissector_table("bctp.tpi", "BCTP Tunneled Protocol Indicator", FT_UINT32, BASE_DEC);
}
/*
* Add an entry for a new OUI.
*/
void
ieee802a_add_oui(guint32 oui, const char *table_name, const char *table_ui_name,
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, proto, FT_UINT16, BASE_HEX);
new_info->field_info = hf_item;
/*
* Create the hash table for OUI information, if it doesn't
* already exist.
*/
if (oui_info_table == NULL) {
oui_info_table = g_hash_table_new_full(g_direct_hash,
g_direct_equal, NULL, g_free);
}
g_hash_table_insert(oui_info_table, GUINT_TO_POINTER(oui), new_info);
}
/*
* Add an entry for a new OUI.
*/
void
llc_add_oui(guint32 oui, const char *table_name, const char *table_ui_name,
hf_register_info *hf_item)
{
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);
new_info->field_info = hf_item;
/*
* Create the hash table for OUI information, if it doesn't
* already exist.
*/
if (oui_info_table == NULL) {
oui_info_table = g_hash_table_new(g_direct_hash,
g_direct_equal);
}
g_hash_table_insert(oui_info_table, GUINT_TO_POINTER(oui), new_info);
}
