/*--- proto_register_disp -------------------------------------------*/
void proto_register_disp(void) {
/* List of fields */
static hf_register_info hf[] =
{
#include "packet-disp-hfarr.c"
};
/* List of subtrees */
static gint *ett[] = {
&ett_disp,
#include "packet-disp-ettarr.c"
};
module_t *disp_module;
/* Register protocol */
proto_disp = proto_register_protocol(PNAME, PSNAME, PFNAME);
register_dissector("disp", dissect_disp, proto_disp);
/* Register fields and subtrees */
proto_register_field_array(proto_disp, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
/* Register our configuration options for DISP, particularly our port */
disp_module = prefs_register_protocol_subtree("OSI/X.500", proto_disp, prefs_register_disp);
prefs_register_uint_preference(disp_module, "tcp.port", "DISP TCP Port",
"Set the port for DISP operations (if other"
" than the default of 102)",
10, &global_disp_tcp_port);
}
/*--- proto_register_p7 -------------------------------------------*/
void proto_register_p7(void) {
/* List of fields */
static hf_register_info hf[] =
{
#include "packet-p7-hfarr.c"
};
/* List of subtrees */
static gint *ett[] = {
&ett_p7,
#include "packet-p7-ettarr.c"
};
module_t *p7_module;
/* Register protocol */
proto_p7 = proto_register_protocol(PNAME, PSNAME, PFNAME);
/* Register fields and subtrees */
proto_register_field_array(proto_p7, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
/* Register our configuration options for P7, particularly our port */
p7_module = prefs_register_protocol_subtree("OSI/X.400", proto_p7, prefs_register_p7);
prefs_register_uint_preference(p7_module, "tcp.port", "P7 TCP Port",
"Set the port for P7 operations (if other"
" than the default of 102)",
10, &global_p7_tcp_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);
}
/*--- proto_register_dsp -------------------------------------------*/
void proto_register_dsp(void) {
/* List of fields */
static hf_register_info hf[] =
{
#include "packet-dsp-hfarr.c"
};
/* List of subtrees */
static gint *ett[] = {
&ett_dsp,
#include "packet-dsp-ettarr.c"
};
static ei_register_info ei[] = {
{ &ei_dsp_unsupported_opcode, { "dsp.unsupported_opcode", PI_UNDECODED, PI_WARN, "Unsupported DSP opcode", EXPFILL }},
{ &ei_dsp_unsupported_errcode, { "dsp.unsupported_errcode", PI_UNDECODED, PI_WARN, "Unsupported DSP errcode", EXPFILL }},
{ &ei_dsp_unsupported_pdu, { "dsp.unsupported_pdu", PI_UNDECODED, PI_WARN, "Unsupported DSP PDU", EXPFILL }},
{ &ei_dsp_zero_pdu, { "dsp.zero_pdu", PI_PROTOCOL, PI_ERROR, "Internal error, zero-byte DSP PDU", EXPFILL }},
};
module_t *dsp_module;
expert_module_t* expert_dsp;
/* Register protocol */
proto_dsp = proto_register_protocol(PNAME, PSNAME, PFNAME);
new_register_dissector("dsp", dissect_dsp, proto_dsp);
/* Register fields and subtrees */
proto_register_field_array(proto_dsp, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
expert_dsp = expert_register_protocol(proto_dsp);
expert_register_field_array(expert_dsp, ei, array_length(ei));
/* Register our configuration options for DSP, particularly our port */
dsp_module = prefs_register_protocol_subtree("OSI/X.500", proto_dsp, prefs_register_dsp);
prefs_register_uint_preference(dsp_module, "tcp.port", "DSP TCP Port",
"Set the port for DSP operations (if other"
" than the default of 102)",
10, &global_dsp_tcp_port);
}
/*--- proto_register_dap -------------------------------------------*/
void proto_register_dap(void) {
/* List of fields */
static hf_register_info hf[] =
{
#include "packet-dap-hfarr.c"
};
/* List of subtrees */
static gint *ett[] = {
&ett_dap,
#include "packet-dap-ettarr.c"
};
static ei_register_info ei[] = {
{ &ei_dap_anonymous, { "dap.anonymous", PI_PROTOCOL, PI_NOTE, "Anonymous", EXPFILL }},
};
module_t *dap_module;
expert_module_t* expert_dap;
/* Register protocol */
proto_dap = proto_register_protocol(PNAME, PSNAME, PFNAME);
/* Register fields and subtrees */
proto_register_field_array(proto_dap, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
expert_dap = expert_register_protocol(proto_dap);
expert_register_field_array(expert_dap, ei, array_length(ei));
/* Register our configuration options for DAP, particularly our port */
dap_module = prefs_register_protocol_subtree("OSI/X.500", proto_dap, NULL);
prefs_register_obsolete_preference(dap_module, "tcp.port");
prefs_register_static_text_preference(dap_module, "tcp_port_info",
"The TCP ports used by the DAP protocol should be added to the TPKT preference \"TPKT TCP ports\", or the IDMP preference \"IDMP TCP Port\", or by selecting \"TPKT\" as the \"Transport\" protocol in the \"Decode As\" dialog.",
"DAP TCP Port preference moved information");
}
/*--- proto_register_p1 -------------------------------------------*/
void proto_register_p1(void) {
/* List of fields */
static hf_register_info hf[] =
{
/* "Created by defining PDU in .cnf */
{ &hf_p1_MTABindArgument_PDU,
{ "MTABindArgument", "p1.MTABindArgument",
FT_UINT32, BASE_DEC, VALS(p1_MTABindArgument_vals), 0,
"p1.MTABindArgument", HFILL }},
{ &hf_p1_MTABindResult_PDU,
{ "MTABindResult", "p1.MTABindResult",
FT_UINT32, BASE_DEC, VALS(p1_MTABindResult_vals), 0,
"p1.MTABindResult", HFILL }},
{ &hf_p1_MTABindError_PDU,
{ "MTABindError", "p1.MTABindError",
FT_UINT32, BASE_DEC, VALS(p1_MTABindError_vals), 0,
"p1.MTABindError", HFILL }},
{ &hf_p1_MTS_APDU_PDU,
{ "MTS-APDU", "p1.MTS_APDU",
FT_UINT32, BASE_DEC, VALS(p1_MTS_APDU_vals), 0,
"p1.MTS_APDU", HFILL }},
#include "packet-p1-hfarr.c"
};
/* List of subtrees */
static gint *ett[] = {
&ett_p1,
&ett_p3,
&ett_p1_content_unknown,
&ett_p1_bilateral_information,
&ett_p1_additional_information,
&ett_p1_unknown_standard_extension,
&ett_p1_unknown_extension_attribute_type,
&ett_p1_unknown_tokendata_type,
#include "packet-p1-ettarr.c"
};
static ei_register_info ei[] = {
{ &ei_p1_unknown_extension_attribute_type, { "p1.unknown.extension_attribute_type", PI_UNDECODED, PI_WARN, "Unknown extension-attribute-type", EXPFILL }},
{ &ei_p1_unknown_standard_extension, { "p1.unknown.standard_extension", PI_UNDECODED, PI_WARN, "Unknown standard-extension", EXPFILL }},
{ &ei_p1_unknown_built_in_content_type, { "p1.unknown.built_in_content_type", PI_UNDECODED, PI_WARN, "P1 Unknown Content (unknown built-in content-type)", EXPFILL }},
{ &ei_p1_unknown_tokendata_type, { "p1.unknown.tokendata_type", PI_UNDECODED, PI_WARN, "Unknown tokendata-type", EXPFILL }},
{ &ei_p1_unsupported_pdu, { "p1.unsupported_pdu", PI_UNDECODED, PI_WARN, "Unsupported P1 PDU", EXPFILL }},
{ &ei_p1_zero_pdu, { "p1.zero_pdu", PI_PROTOCOL, PI_ERROR, "Internal error, zero-byte P1 PDU", EXPFILL }},
};
expert_module_t* expert_p1;
module_t *p1_module;
/* Register protocol */
proto_p1 = proto_register_protocol(PNAME, PSNAME, PFNAME);
new_register_dissector("p1", dissect_p1, proto_p1);
proto_p3 = proto_register_protocol("X.411 Message Access Service", "P3", "p3");
/* Register fields and subtrees */
proto_register_field_array(proto_p1, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
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);
p1_extension_attribute_dissector_table = register_dissector_table("p1.extension-attribute", "P1-EXTENSION-ATTRIBUTE", FT_UINT32, BASE_DEC);
p1_tokendata_dissector_table = register_dissector_table("p1.tokendata", "P1-TOKENDATA", FT_UINT32, BASE_DEC);
/* Register our configuration options for P1, particularly our port */
p1_module = prefs_register_protocol_subtree("OSI/X.400", proto_p1, prefs_register_p1);
prefs_register_uint_preference(p1_module, "tcp.port", "P1 TCP Port",
"Set the port for P1 operations (if other"
" than the default of 102)",
10, &global_p1_tcp_port);
register_ber_syntax_dissector("P1 Message", proto_p1, dissect_p1_mts_apdu);
#include "packet-p1-syn-reg.c"
}
/*--- proto_register_rtse -------------------------------------------*/
void proto_register_rtse(void) {
/* List of fields */
static hf_register_info hf[] =
{
/* Fragment entries */
{ &hf_rtse_segment_data,
{ "RTSE segment data", "rtse.segment", FT_NONE, BASE_NONE,
NULL, 0x00, NULL, HFILL } },
{ &hf_rtse_fragments,
{ "RTSE fragments", "rtse.fragments", FT_NONE, BASE_NONE,
NULL, 0x00, NULL, HFILL } },
{ &hf_rtse_fragment,
{ "RTSE fragment", "rtse.fragment", FT_FRAMENUM, BASE_NONE,
NULL, 0x00, NULL, HFILL } },
{ &hf_rtse_fragment_overlap,
{ "RTSE fragment overlap", "rtse.fragment.overlap", FT_BOOLEAN,
BASE_NONE, NULL, 0x0, NULL, HFILL } },
{ &hf_rtse_fragment_overlap_conflicts,
{ "RTSE fragment overlapping with conflicting data",
"rtse.fragment.overlap.conflicts", FT_BOOLEAN, BASE_NONE,
NULL, 0x0, NULL, HFILL } },
{ &hf_rtse_fragment_multiple_tails,
{ "RTSE has multiple tail fragments",
"rtse.fragment.multiple_tails", FT_BOOLEAN, BASE_NONE,
NULL, 0x0, NULL, HFILL } },
{ &hf_rtse_fragment_too_long_fragment,
{ "RTSE fragment too long", "rtse.fragment.too_long_fragment",
FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } },
{ &hf_rtse_fragment_error,
{ "RTSE defragmentation error", "rtse.fragment.error", FT_FRAMENUM,
BASE_NONE, NULL, 0x00, NULL, HFILL } },
{ &hf_rtse_fragment_count,
{ "RTSE fragment count", "rtse.fragment.count", FT_UINT32, BASE_DEC,
NULL, 0x00, NULL, HFILL } },
{ &hf_rtse_reassembled_in,
{ "Reassembled RTSE in frame", "rtse.reassembled.in", FT_FRAMENUM, BASE_NONE,
NULL, 0x00, "This RTSE packet is reassembled in this frame", HFILL } },
{ &hf_rtse_reassembled_length,
{ "Reassembled RTSE length", "rtse.reassembled.length", FT_UINT32, BASE_DEC,
NULL, 0x00, "The total length of the reassembled payload", HFILL } },
#include "packet-rtse-hfarr.c"
};
/* List of subtrees */
static gint *ett[] = {
&ett_rtse,
&ett_rtse_unknown,
&ett_rtse_fragment,
&ett_rtse_fragments,
#include "packet-rtse-ettarr.c"
};
module_t *rtse_module;
/* Register protocol */
proto_rtse = proto_register_protocol(PNAME, PSNAME, PFNAME);
register_dissector("rtse", dissect_rtse, proto_rtse);
/* Register fields and subtrees */
proto_register_field_array(proto_rtse, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
register_init_routine (&rtse_reassemble_init);
rtse_module = prefs_register_protocol_subtree("OSI", proto_rtse, NULL);
prefs_register_bool_preference(rtse_module, "reassemble",
"Reassemble segmented RTSE datagrams",
"Whether segmented RTSE datagrams should be reassembled."
" To use this option, you must also enable"
" \"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);
oid_table=g_hash_table_new(g_str_hash, g_str_equal);
}
/*--- proto_register_p1 -------------------------------------------*/
void proto_register_p1(void) {
/* List of fields */
static hf_register_info hf[] =
{
/* "Created by defining PDU in .cnf */
{ &hf_p1_MTABindArgument_PDU,
{ "MTABindArgument", "p1.MTABindArgument",
FT_UINT32, BASE_DEC, VALS(p1_MTABindArgument_vals), 0,
"p1.MTABindArgument", HFILL }},
{ &hf_p1_MTABindResult_PDU,
{ "MTABindResult", "p1.MTABindResult",
FT_UINT32, BASE_DEC, VALS(p1_MTABindResult_vals), 0,
"p1.MTABindResult", HFILL }},
{ &hf_p1_MTABindError_PDU,
{ "MTABindError", "p1.MTABindError",
FT_UINT32, BASE_DEC, VALS(p1_MTABindError_vals), 0,
"p1.MTABindError", HFILL }},
{ &hf_p1_MTS_APDU_PDU,
{ "MTS-APDU", "p1.MTS_APDU",
FT_UINT32, BASE_DEC, VALS(p1_MTS_APDU_vals), 0,
"p1.MTS_APDU", HFILL }},
#include "packet-p1-hfarr.c"
};
/* List of subtrees */
static gint *ett[] = {
&ett_p1,
&ett_p3,
&ett_p1_content_unknown,
&ett_p1_bilateral_information,
&ett_p1_additional_information,
&ett_p1_unknown_standard_extension,
&ett_p1_unknown_extension_attribute_type,
&ett_p1_unknown_tokendata_type,
#include "packet-p1-ettarr.c"
};
module_t *p1_module;
/* Register protocol */
proto_p1 = proto_register_protocol(PNAME, PSNAME, PFNAME);
register_dissector("p1", dissect_p1, proto_p1);
proto_p3 = proto_register_protocol("X.411 Message Access Service", "P3", "p3");
/* Register fields and subtrees */
proto_register_field_array(proto_p1, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
p1_extension_dissector_table = register_dissector_table("p1.extension", "P1-EXTENSION", FT_UINT32, BASE_DEC);
p1_extension_attribute_dissector_table = register_dissector_table("p1.extension-attribute", "P1-EXTENSION-ATTRIBUTE", FT_UINT32, BASE_DEC);
p1_tokendata_dissector_table = register_dissector_table("p1.tokendata", "P1-TOKENDATA", FT_UINT32, BASE_DEC);
/* Register our configuration options for P1, particularly our port */
p1_module = prefs_register_protocol_subtree("OSI/X.400", proto_p1, prefs_register_p1);
prefs_register_uint_preference(p1_module, "tcp.port", "P1 TCP Port",
"Set the port for P1 operations (if other"
" than the default of 102)",
10, &global_p1_tcp_port);
register_ber_syntax_dissector("P1 Message", proto_p1, dissect_p1_mts_apdu);
}
void
proto_register_sbc(void)
{
module_t *module;
expert_module_t* expert_sbc;
static hf_register_info hf[] = {
{ &hf_sbc_fragmented,
{ "Fragmented", "sbc.fragmented",
FT_BOOLEAN, 8, NULL, 0x80,
NULL, HFILL }
},
{ &hf_sbc_starting_packet,
{ "Starting Packet", "sbc.starting_packet",
FT_BOOLEAN, 8, NULL, 0x40,
NULL, HFILL }
},
{ &hf_sbc_last_packet,
{ "Last Packet", "sbc.last_packet",
FT_BOOLEAN, 8, NULL, 0x20,
NULL, HFILL }
},
{ &hf_sbc_rfa,
{ "RFA", "sbc.rfa",
FT_BOOLEAN, 8, NULL, 0x10,
NULL, HFILL }
},
{ &hf_sbc_number_of_frames,
{ "Number of Frames", "sbc.number_of_frames",
FT_UINT8, BASE_DEC, NULL, 0x0F,
NULL, HFILL }
},
{ &hf_sbc_syncword,
{ "Sync Word", "sbc.syncword",
FT_UINT8, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_sbc_sampling_frequency,
{ "Sampling Frequency", "sbc.sampling_frequency",
FT_UINT8, BASE_HEX, VALS(sampling_frequency_vals), 0xC0,
NULL, HFILL }
},
{ &hf_sbc_blocks,
{ "Blocks", "sbc.blocks",
FT_UINT8, BASE_HEX, VALS(blocks_vals), 0x30,
NULL, HFILL }
},
{ &hf_sbc_channel_mode,
{ "Channel Mode", "sbc.channel_mode",
FT_UINT8, BASE_HEX, VALS(channel_mode_vals), 0x0C,
NULL, HFILL }
},
{ &hf_sbc_allocation_method,
{ "Allocation Method", "sbc.allocation_method",
FT_UINT8, BASE_HEX, VALS(allocation_method_vals), 0x02,
NULL, HFILL }
},
{ &hf_sbc_subbands,
{ "Subbands", "sbc.subbands",
FT_UINT8, BASE_HEX, VALS(subbands_vals), 0x01,
NULL, HFILL }
},
{ &hf_sbc_bitpool,
{ "Bitpool", "sbc.bitpool",
FT_UINT8, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_sbc_crc_check,
{ "CRC Check", "sbc.crc_check",
FT_UINT8, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_sbc_expected_data_speed,
{ "Expected data speed", "sbc.expected_speed_data",
FT_UINT32, BASE_DEC|BASE_UNIT_STRING, &units_kibps, 0x00,
NULL, HFILL }
},
{ &hf_sbc_frame_duration,
{ "Frame Duration", "sbc.frame_duration",
FT_DOUBLE, BASE_NONE|BASE_UNIT_STRING, &units_milliseconds, 0x00,
NULL, HFILL }
},
{ &hf_sbc_cumulative_frame_duration,
{ "Cumulative Frame Duration", "sbc.cumulative_frame_duration",
FT_DOUBLE, BASE_NONE|BASE_UNIT_STRING, &units_milliseconds, 0x00,
NULL, HFILL }
},
{ &hf_sbc_delta_time,
{ "Delta time", "sbc.delta_time",
FT_DOUBLE, BASE_NONE|BASE_UNIT_STRING, &units_milliseconds, 0x00,
NULL, HFILL }
},
{ &hf_sbc_delta_time_from_the_beginning,
{ "Delta time from the beginning", "sbc.delta_time_from_the_beginning",
FT_DOUBLE, BASE_NONE|BASE_UNIT_STRING, &units_milliseconds, 0x00,
NULL, HFILL }
},
{ &hf_sbc_cumulative_duration,
{ "Cumulative Music Duration", "sbc.cumulative_music_duration",
FT_DOUBLE, BASE_NONE|BASE_UNIT_STRING, &units_milliseconds, 0x00,
NULL, HFILL }
},
{ &hf_sbc_avrcp_song_position,
{ "AVRCP Song Position", "sbc.avrcp_song_position",
FT_DOUBLE, BASE_NONE|BASE_UNIT_STRING, &units_milliseconds, 0x00,
NULL, HFILL }
},
{ &hf_sbc_diff,
{ "Diff", "sbc.diff",
FT_DOUBLE, BASE_NONE|BASE_UNIT_STRING, &units_milliseconds, 0x00,
NULL, HFILL }
},
{ &hf_sbc_data,
{ "Frame Data", "sbc.data",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
};
static gint *ett[] = {
&ett_sbc,
&ett_sbc_list,
};
static ei_register_info ei[] = {
{ &ei_sbc_syncword, { "sbc.syncword.unexpected", PI_PROTOCOL, PI_WARN, "Unexpected syncword", EXPFILL }},
};
proto_sbc = proto_register_protocol("Bluetooth SBC Codec", "SBC", "sbc");
proto_register_field_array(proto_sbc, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
expert_sbc = expert_register_protocol(proto_sbc);
expert_register_field_array(expert_sbc, ei, array_length(ei));
register_dissector("sbc", dissect_sbc, proto_sbc);
module = prefs_register_protocol_subtree("Bluetooth", proto_sbc, NULL);
prefs_register_static_text_preference(module, "a2dp.version",
"Bluetooth Audio Codec SBC version based on A2DP 1.3",
"Version of codec supported by this dissector.");
}
/*--- proto_register_rtse -------------------------------------------*/
void proto_register_rtse(void) {
/* List of fields */
static hf_register_info hf[] =
{
/* Fragment entries */
{ &hf_rtse_segment_data,
{ "RTSE segment data", "rtse.segment", FT_NONE, BASE_NONE,
NULL, 0x00, NULL, HFILL } },
{ &hf_rtse_fragments,
{ "RTSE fragments", "rtse.fragments", FT_NONE, BASE_NONE,
NULL, 0x00, NULL, HFILL } },
{ &hf_rtse_fragment,
{ "RTSE fragment", "rtse.fragment", FT_FRAMENUM, BASE_NONE,
NULL, 0x00, NULL, HFILL } },
{ &hf_rtse_fragment_overlap,
{ "RTSE fragment overlap", "rtse.fragment.overlap", FT_BOOLEAN,
BASE_NONE, NULL, 0x0, NULL, HFILL } },
{ &hf_rtse_fragment_overlap_conflicts,
{ "RTSE fragment overlapping with conflicting data",
"rtse.fragment.overlap.conflicts", FT_BOOLEAN, BASE_NONE,
NULL, 0x0, NULL, HFILL } },
{ &hf_rtse_fragment_multiple_tails,
{ "RTSE has multiple tail fragments",
"rtse.fragment.multiple_tails", FT_BOOLEAN, BASE_NONE,
NULL, 0x0, NULL, HFILL } },
{ &hf_rtse_fragment_too_long_fragment,
{ "RTSE fragment too long", "rtse.fragment.too_long_fragment",
FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } },
{ &hf_rtse_fragment_error,
{ "RTSE defragmentation error", "rtse.fragment.error", FT_FRAMENUM,
BASE_NONE, NULL, 0x00, NULL, HFILL } },
{ &hf_rtse_fragment_count,
{ "RTSE fragment count", "rtse.fragment.count", FT_UINT32, BASE_DEC,
NULL, 0x00, NULL, HFILL } },
{ &hf_rtse_reassembled_in,
{ "Reassembled RTSE in frame", "rtse.reassembled.in", FT_FRAMENUM, BASE_NONE,
NULL, 0x00, "This RTSE packet is reassembled in this frame", HFILL } },
{ &hf_rtse_reassembled_length,
{ "Reassembled RTSE length", "rtse.reassembled.length", FT_UINT32, BASE_DEC,
NULL, 0x00, "The total length of the reassembled payload", HFILL } },
#include "packet-rtse-hfarr.c"
};
/* List of subtrees */
static gint *ett[] = {
&ett_rtse,
&ett_rtse_unknown,
&ett_rtse_fragment,
&ett_rtse_fragments,
#include "packet-rtse-ettarr.c"
};
static ei_register_info ei[] = {
{ &ei_rtse_dissector_oid_not_implemented, { "rtse.dissector_oid_not_implemented", PI_UNDECODED, PI_WARN, "RTSE: Dissector for OID not implemented", EXPFILL }},
{ &ei_rtse_unknown_rtse_pdu, { "rtse.unknown_rtse_pdu", PI_UNDECODED, PI_WARN, "Unknown RTSE PDU", EXPFILL }},
{ &ei_rtse_abstract_syntax, { "rtse.bad_abstract_syntax", PI_PROTOCOL, PI_WARN, "Unable to determine abstract syntax for indirect reference", EXPFILL }},
};
expert_module_t* expert_rtse;
module_t *rtse_module;
/* Register protocol */
proto_rtse = proto_register_protocol(PNAME, PSNAME, PFNAME);
register_dissector("rtse", dissect_rtse, proto_rtse);
/* Register fields and subtrees */
proto_register_field_array(proto_rtse, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
expert_rtse = expert_register_protocol(proto_rtse);
expert_register_field_array(expert_rtse, ei, array_length(ei));
register_init_routine (&rtse_reassemble_init);
register_cleanup_routine (&rtse_reassemble_cleanup);
rtse_module = prefs_register_protocol_subtree("OSI", proto_rtse, NULL);
prefs_register_bool_preference(rtse_module, "reassemble",
"Reassemble segmented RTSE datagrams",
"Whether segmented RTSE datagrams should be reassembled."
" To use this option, you must also enable"
" \"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);
oid_table=g_hash_table_new(g_str_hash, g_str_equal);
}
void
proto_register_hci_usb(void)
{
module_t *module;
static hf_register_info hf[] = {
{ &hf_msg_fragments,
{ "Message fragments", "hci_usb.msg.fragments",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_fragment,
{ "Message fragment", "hci_usb.msg.fragment",
FT_FRAMENUM, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_fragment_overlap,
{ "Message fragment overlap", "hci_usb.msg.fragment.overlap",
FT_BOOLEAN, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_fragment_overlap_conflicts,
{ "Message fragment overlapping with conflicting data", "hci_usb.msg.fragment.overlap.conflicts",
FT_BOOLEAN, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_fragment_multiple_tails,
{ "Message has multiple tail fragments", "hci_usb.msg.fragment.multiple_tails",
FT_BOOLEAN, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_fragment_too_long_fragment,
{ "Message fragment too long", "hci_usb.msg.fragment.too_long_fragment",
FT_BOOLEAN, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_fragment_error,
{ "Message defragmentation error", "hci_usb.msg.fragment.error",
FT_FRAMENUM, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_fragment_count,
{ "Message fragment count", "hci_usb.msg.fragment.count",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_reassembled_in,
{ "Reassembled in", "hci_usb.msg.reassembled.in",
FT_FRAMENUM, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_reassembled_length,
{ "Reassembled MP2T length", "hci_usb.msg.reassembled.length",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthci_usb_packet_fragment,
{ "Packet Fragment", "hci_usb.packet.fragment",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthci_usb_packet_complete,
{ "Packet Complete", "hci_usb.packet.complete",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthci_usb_packet_unknown_fragment,
{ "Unknown Packet Fragment", "hci_usb.packet.unknown_fragment",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthci_usb_setup_request,
{ "bRequest", "hci_usb.setup.bRequest",
FT_UINT8, BASE_DEC | BASE_EXT_STRING, &request_vals_ext, 0x0,
NULL, HFILL }},
{ &hf_bthci_usb_setup_value,
{ "wValue", "hci_usb.setup.wValue",
FT_UINT16, BASE_HEX, NULL, 0x0,
NULL, HFILL }},
{ &hf_bthci_usb_setup_adapter_id,
{ "Adapter ID", "hci_usb.setup.adapter_id",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_bthci_usb_setup_length,
{ "wLength", "hci_usb.setup.wLength",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_bthci_usb_data,
{ "Unknown Data", "hci_usb.data",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
}
};
static gint *ett[] = {
&ett_hci_usb,
&ett_hci_usb_msg_fragment,
&ett_hci_usb_msg_fragments,
};
reassembly_table_register(&hci_usb_reassembly_table,
&addresses_reassembly_table_functions);
fragment_info_table = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
proto_hci_usb = proto_register_protocol("Bluetooth HCI USB Transport", "HCI_USB", "hci_usb");
proto_register_field_array(proto_hci_usb, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
hci_usb_handle = register_dissector("hci_usb", dissect_hci_usb, proto_hci_usb);
module = prefs_register_protocol_subtree("Bluetooth", proto_hci_usb, NULL);
prefs_register_static_text_preference(module, "bthci_usb.version",
"Bluetooth HCI USB Transport from Core 4.0",
"Version of protocol supported by this dissector.");
}
