void proto_register_inap(void) {
module_t *inap_module;
/* List of fields */
static hf_register_info hf[] = {
#include "packet-inap-hfarr.c"
};
/* List of subtrees */
static gint *ett[] = {
&ett_inap,
&ett_inapisup_parameter,
&ett_inap_HighLayerCompatibility,
#include "packet-inap-ettarr.c"
};
static ei_register_info ei[] = {
{ &ei_inap_unknown_invokeData, { "inap.unknown.invokeData", PI_MALFORMED, PI_WARN, "Unknown invokeData", EXPFILL }},
{ &ei_inap_unknown_returnResultData, { "inap.unknown.returnResultData", PI_MALFORMED, PI_WARN, "Unknown returnResultData", EXPFILL }},
{ &ei_inap_unknown_returnErrorData, { "inap.unknown.returnErrorData", PI_MALFORMED, PI_WARN, "Unknown returnResultData", EXPFILL }},
};
expert_module_t* expert_inap;
/* Register protocol */
proto_inap = proto_register_protocol(PNAME, PSNAME, PFNAME);
register_dissector("inap", dissect_inap, proto_inap);
/* Register fields and subtrees */
proto_register_field_array(proto_inap, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
expert_inap = expert_register_protocol(proto_inap);
expert_register_field_array(expert_inap, ei, array_length(ei));
/* Set default SSNs */
range_convert_str(&global_ssn_range, "106,241", MAX_SSN);
inap_module = prefs_register_protocol(proto_inap, proto_reg_handoff_inap);
prefs_register_obsolete_preference(inap_module, "tcap.itu_ssn");
prefs_register_obsolete_preference(inap_module, "tcap.itu_ssn1");
prefs_register_range_preference(inap_module, "ssn", "TCAP SSNs",
"TCAP Subsystem numbers used for INAP",
&global_ssn_range, MAX_SSN);
}
void proto_register_inap(void) {
module_t *inap_module;
/* List of fields */
static hf_register_info hf[] = {
#include "packet-inap-hfarr.c"
};
/* List of subtrees */
static gint *ett[] = {
&ett_inap,
&ett_inapisup_parameter,
&ett_inap_HighLayerCompatibility,
#include "packet-inap-ettarr.c"
};
/* Register protocol */
proto_inap = proto_register_protocol(PNAME, PSNAME, PFNAME);
register_dissector("inap", dissect_inap, proto_inap);
/* Register fields and subtrees */
proto_register_field_array(proto_inap, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
/* Set default SSNs */
range_convert_str(&global_ssn_range, "106,241", MAX_SSN);
inap_module = prefs_register_protocol(proto_inap, proto_reg_handoff_inap);
prefs_register_obsolete_preference(inap_module, "tcap.itu_ssn");
prefs_register_obsolete_preference(inap_module, "tcap.itu_ssn1");
prefs_register_range_preference(inap_module, "ssn", "TCAP SSNs",
"TCAP Subsystem numbers used for INAP",
&global_ssn_range, MAX_SSN);
}
/*--- 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");
}
/* Register the protocol with Wireshark */
void
proto_register_ltp(void)
{
module_t *ltp_module;
static hf_register_info hf[] = {
{&hf_ltp_version,
{"LTP Version","ltp.version",
FT_UINT8,BASE_DEC,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_type,
{"LTP Type","ltp.type",
FT_UINT8,BASE_HEX,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_session_id,
{"Session ID","ltp.session",
FT_NONE,BASE_NONE,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_session_orig,
{"Session originator","ltp.session.orig",
FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_session_no,
{"Session number","ltp.session.number",
FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_hdr_extn_cnt,
{"Header Extension Count","ltp.hdr.extn.cnt",
FT_UINT8,BASE_DEC,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_trl_extn_cnt,
{"Trailer Extension Count","ltp.trl.extn.cnt",
FT_UINT8,BASE_DEC,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_data_clid,
{"Client service ID","ltp.data.client.id",
FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_data_offset,
{"Offset","ltp.data.offset",
FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_data_length,
{"Length","ltp.data.length",
FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_data_chkp,
{"Checkpoint serial number","ltp.data.chkp",
FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_data_rpt,
{"Report serial number","ltp.data.rpt",
FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_data_clidata,
{"Client service data","ltp.data.data",
FT_BYTES,BASE_NONE,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_rpt_sno,
{"Report serial number","ltp.rpt.sno",
FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_rpt_chkp,
{"Checkpoint serial number","ltp.rpt.chkp",
FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_rpt_ub,
{"Upper bound","ltp.rpt.ub",
FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_rpt_lb,
{"Lower bound","ltp.rpt.lb",
FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_rpt_clm_cnt,
{"Reception claim count","ltp.rpt.clm.cnt",
FT_UINT8,BASE_DEC,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_rpt_clm_off,
{"Offset","ltp.rpt.clm.off",
FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_rpt_clm_len,
{"Length","ltp.rpt.clm.len",
FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_rpt_ack_sno,
{"Report serial number","ltp.rpt.ack.sno",
FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_cancel_code,
{"Cancel code","ltp.cancel.code",
FT_UINT8,BASE_HEX,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_hdr_extn_tag,
{"Extension tag","ltp.hdr.extn.tag",
FT_UINT8,BASE_HEX,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_hdr_extn_len,
{"Length","ltp.hdr.extn.len",
FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_hdr_extn_val,
{"Value","ltp.hdr.extn.val",
FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_trl_extn_tag,
{"Extension tag","ltp.trl.extn.tag",
FT_UINT8,BASE_HEX,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_trl_extn_len,
{"Length","ltp.trl.extn.len",
FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_trl_extn_val,
{"Value","ltp.trl.extn.val",
FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_fragments,
{"LTP Fragments", "ltp.fragments",
FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_fragment,
{"LTP Fragment", "ltp.fragment",
FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_fragment_overlap,
{"LTP fragment overlap", "ltp.fragment.overlap",
FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_fragment_overlap_conflicts,
{"LTP fragment overlapping with conflicting data",
"ltp.fragment.overlap.conflicts",
FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_fragment_multiple_tails,
{"LTP has multiple tails", "ltp.fragment.multiple_tails",
FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_fragment_too_long_fragment,
{"LTP fragment too long", "ltp.fragment.too_long_fragment",
FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_fragment_error,
{"LTP defragmentation error", "ltp.fragment.error",
FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_fragment_count,
{"LTP fragment count", "ltp.fragment.count",
FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_reassembled_in,
{"LTP reassembled in", "ltp.reassembled.in",
FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL}
},
{&hf_ltp_reassembled_length,
{"LTP reassembled length", "ltp.reassembled.length",
FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}
}
};
/* Setup protocol subtree array */
static gint *ett[] = {
&ett_ltp,
&ett_ltp_hdr,
&ett_hdr_session,
&ett_hdr_extn,
&ett_data_segm,
&ett_data_data_segm,
&ett_rpt_segm,
&ett_rpt_clm,
&ett_rpt_ack_segm,
&ett_session_mgmt,
&ett_trl_extn,
&ett_ltp_fragment,
&ett_ltp_fragments
};
/* Register the protocol name and description */
proto_ltp = proto_register_protocol("Licklider Transmission Protocol",
"LTP", "ltp");
proto_register_field_array(proto_ltp, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
ltp_module = prefs_register_protocol(proto_ltp, proto_reg_handoff_ltp);
prefs_register_obsolete_preference(ltp_module, "udp.port");
prefs_register_uint_preference(ltp_module, "port", "LTP Port",
"The UDP or DCCP port to accept LTP Connections",
10, <p_port);
register_init_routine(ltp_defragment_init);
}
void
proto_register_nsip(void)
{
static hf_register_info hf[] = {
{ &hf_nsip_cause,
{ "Cause", "nsip.cause",
FT_UINT8, BASE_OCT, VALS(tab_nsip_cause_values), 0x0,
NULL, HFILL }
},
{ &hf_nsip_ns_vci,
{ "NS-VCI", "nsip.ns_vci",
FT_UINT16, BASE_HEX, NULL, 0x0,
"Network Service Virtual Link Identifier", HFILL }
},
{ &hf_nsip_pdu_type,
{ "PDU type", "nsip.pdu_type",
FT_UINT8, BASE_OCT, VALS(tab_nsip_pdu_types), 0x0,
"PDU type information element", HFILL }
},
{ &hf_nsip_bvci,
{ "BVCI", "nsip.bvci",
FT_UINT16, BASE_DEC, NULL, 0x0,
"BSSGP Virtual Connection Identifier", HFILL }
},
{ &hf_nsip_nsei,
{ "NSEI", "nsip.nsei",
FT_UINT16, BASE_DEC, NULL, 0x0,
"Network Service Entity Identifier", HFILL }
},
#if 0
{ &hf_nsip_ip4_elements,
{ "IP4 elements", "nsip.ip4_elements",
FT_NONE, BASE_NONE, NULL, 0x0,
"List of IP4 elements", HFILL }
},
#endif
#if 0
{ &hf_nsip_ip6_elements,
{ "IP6 elements", "nsip.ip6_elements",
FT_NONE, BASE_NONE, NULL, 0x0,
"List of IP6 elements", HFILL }
},
#endif
{ &hf_nsip_max_num_ns_vc,
{ "Maximum number of NS-VCs", "nsip.max_num_ns_vc",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
{ &hf_nsip_num_ip4_endpoints,
{ "Number of IP4 endpoints", "nsip.num_ip4_endpoints",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
{ &hf_nsip_num_ip6_endpoints,
{ "Number of IP6 endpoints", "nsip.num_ip6_endpoints",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
{ &hf_nsip_reset_flag,
{ "Reset flag", "nsip.reset_flag.flag",
FT_BOOLEAN, 8, TFS(&tfs_set_notset), NSIP_MASK_RESET_FLAG,
NULL, HFILL }
},
{ &hf_nsip_reset_flag_spare,
{ "Reset flag spare bits", "nsip.reset_flag.spare",
FT_UINT8, BASE_HEX, NULL, NSIP_MASK_RESET_FLAG_SPARE,
NULL, HFILL }
},
{ &hf_nsip_ip_address_type,
{ "IP Address Type", "nsip.ip_address_type",
FT_UINT8, BASE_DEC, VALS(ip_address_type_vals), 0x0,
NULL, HFILL }
},
{ &hf_nsip_ip_address_ipv4,
{ "IP Address", "nsip.ipv4_address",
FT_IPv4, BASE_NONE, NULL, 0x0,
NULL, HFILL }
},
{ &hf_nsip_ip_address_ipv6,
{ "IP Address", "nsip.ipv6_address",
FT_IPv6, BASE_NONE, NULL, 0x0,
NULL, HFILL }
},
{ &hf_nsip_end_flag,
{ "End flag", "nsip.end_flag.flag",
FT_BOOLEAN, 8, TFS(&tfs_set_notset), NSIP_MASK_END_FLAG,
NULL, HFILL }
},
{ &hf_nsip_end_flag_spare,
{ "End flag spare bits", "nsip.end_flag.spare",
FT_UINT8, BASE_HEX, NULL, NSIP_MASK_END_FLAG_SPARE,
NULL, HFILL }
},
{ &hf_nsip_control_bits_r,
{ "Request change flow", "nsip.control_bits.r",
FT_BOOLEAN, 8, TFS(&tfs_set_notset), NSIP_MASK_CONTROL_BITS_R,
NULL, HFILL }
},
{ &hf_nsip_control_bits_c,
{ "Confirm change flow", "nsip.control_bits.c",
FT_BOOLEAN, 8, TFS(&tfs_set_notset), NSIP_MASK_CONTROL_BITS_C,
NULL, HFILL }
},
{ &hf_nsip_control_bits_spare,
{ "Spare bits", "nsip.control_bits.spare",
FT_UINT8, BASE_HEX, NULL, NSIP_MASK_CONTROL_BITS_SPARE,
NULL, HFILL }
},
{ &hf_nsip_transaction_id,
{ "Transaction ID", "nsip.transaction_id",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
#if 0
{ &hf_nsip_ip_element_ip_address_ipv4,
{ "IP Address", "nsip.ip_element.ipv4_address",
FT_IPv4, BASE_NONE, NULL, 0x0,
NULL, HFILL }
},
#endif
#if 0
{ &hf_nsip_ip_element_ip_address_ipv6,
{ "IP Address", "nsip.ip_element.ipv6_address",
FT_IPv6, BASE_NONE, NULL, 0x0,
NULL, HFILL }
},
#endif
{ &hf_nsip_ip_element_udp_port,
{ "UDP Port", "nsip.ip_element.udp_port",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
{ &hf_nsip_ip_element_signalling_weight,
{ "Signalling Weight", "nsip.ip_element.signalling_weight",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
{ &hf_nsip_ip_element_data_weight,
{ "Data Weight", "nsip.ip_element.data_weight",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
};
/* Setup protocol subtree array */
static gint *ett[] = {
&ett_nsip,
&ett_nsip_control_bits,
&ett_nsip_reset_flag,
&ett_nsip_end_flag,
&ett_nsip_ip_element,
&ett_nsip_ip_element_list,
};
module_t *nsip_module;
/* Register the protocol name and description */
proto_nsip = proto_register_protocol("GPRS Network Service",
"GPRS-NS", "gprs-ns");
/* Required function calls to register the header fields and
subtrees used */
proto_register_field_array(proto_nsip, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
register_dissector("gprs_ns", dissect_nsip, proto_nsip);
/* Set default UDP ports */
range_convert_str(&global_nsip_udp_port_range, DEFAULT_NSIP_PORT_RANGE, MAX_UDP_PORT);
/* Register configuration options */
nsip_module = prefs_register_protocol(proto_nsip, proto_reg_handoff_nsip);
prefs_register_obsolete_preference(nsip_module, "udp.port1");
prefs_register_obsolete_preference(nsip_module, "udp.port2");
prefs_register_range_preference(nsip_module, "udp.ports", "GPRS-NS UDP ports",
"UDP ports to be decoded as GPRS-NS (default: "
DEFAULT_NSIP_PORT_RANGE ")",
&global_nsip_udp_port_range, MAX_UDP_PORT);
}
void
proto_register_tcap(void)
{
/* Setup list of header fields See Section 1.6.1 for details*/
static hf_register_info hf[] = {
{ &hf_tcap_tag,
{ "Tag", "tcap.msgtype",
FT_UINT8, BASE_HEX, NULL, 0,
NULL, HFILL }
},
{ &hf_tcap_length,
{ "Length", "tcap.len",
FT_UINT8, BASE_DEC, NULL, 0,
NULL, HFILL }
},
{ &hf_tcap_data,
{ "Data", "tcap.data",
FT_BYTES, BASE_NONE, NULL, 0,
NULL, HFILL }
},
{ &hf_tcap_tid,
{ "Transaction Id", "tcap.tid",
FT_BYTES, BASE_NONE, NULL, 0,
NULL, HFILL }
},
/* Tcap Service Response Time */
{ &hf_tcapsrt_SessionId,
{ "Session Id",
"tcap.srt.session_id",
FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
{ &hf_tcapsrt_BeginSession,
{ "Begin Session",
"tcap.srt.begin",
FT_FRAMENUM, BASE_NONE, NULL, 0x0,
"SRT Begin of Session", HFILL }
},
{ &hf_tcapsrt_EndSession,
{ "End Session",
"tcap.srt.end",
FT_FRAMENUM, BASE_NONE, NULL, 0x0,
"SRT End of Session", HFILL }
},
{ &hf_tcapsrt_SessionTime,
{ "Session duration",
"tcap.srt.sessiontime",
FT_RELATIVE_TIME, BASE_NONE, NULL, 0x0,
"Duration of the TCAP session", HFILL }
},
{ &hf_tcapsrt_Duplicate,
{ "Session Duplicate",
"tcap.srt.duplicate",
FT_FRAMENUM, BASE_NONE, NULL, 0x0,
"SRT Duplicated with Session", HFILL }
},
#include "packet-tcap-hfarr.c"
};
/* Setup protocol subtree array */
static gint *ett[] = {
&ett_tcap,
&ett_param,
&ett_otid,
&ett_dtid,
&ett_tcap_stat,
#include "packet-tcap-ettarr.c"
};
/*static enum_val_t tcap_options[] = {
{ "itu", "ITU", ITU_TCAP_STANDARD },
{ "ansi", "ANSI", ANSI_TCAP_STANDARD },
{ NULL, NULL, 0 }
};*/
module_t *tcap_module;
/* Register the protocol name and description */
proto_tcap = proto_register_protocol(PNAME, PSNAME, PFNAME);
/* Required function calls to register the header fields and subtrees used */
proto_register_field_array(proto_tcap, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
tcap_module = prefs_register_protocol(proto_tcap, NULL);
#if 0
prefs_register_enum_preference(tcap_module, "standard", "ITU TCAP standard",
"The SS7 standard used in ITU TCAP packets",
&tcap_standard, tcap_options, FALSE);
#else
prefs_register_obsolete_preference(tcap_module, "standard");
#endif
#if 0
prefs_register_bool_preference(tcap_module, "lock_info_col", "Lock Info column",
"Always show TCAP in Info column",
&lock_info_col);
#else
prefs_register_obsolete_preference(tcap_module, "lock_info_col");
#endif
/* Set default SSNs */
range_convert_str(&global_ssn_range, "", MAX_SSN);
ssn_range = range_empty();
prefs_register_range_preference(tcap_module, "ssn", "SCCP SSNs",
"SCCP (and SUA) SSNs to decode as TCAP",
&global_ssn_range, MAX_SSN);
prefs_register_bool_preference(tcap_module, "srt",
"Service Response Time Analyse",
"Activate the analyse for Response Time",
>cap_HandleSRT);
prefs_register_bool_preference(tcap_module, "persistentsrt",
"Persistent stats for SRT",
"Statistics for Response Time",
>cap_PersistentSRT);
prefs_register_uint_preference(tcap_module, "repetitiontimeout",
"Repetition timeout",
"Maximal delay for message repetion",
10, >cap_RepetitionTimeout);
prefs_register_uint_preference(tcap_module, "losttimeout",
"lost timeout",
"Maximal delay for message lost",
10, >cap_LostTimeout);
ansi_sub_dissectors = g_hash_table_new(g_direct_hash,g_direct_equal);
itu_sub_dissectors = g_hash_table_new(g_direct_hash,g_direct_equal);
/* 'globally' register dissector */
register_dissector("tcap", dissect_tcap, proto_tcap);
tcap_handle = create_dissector_handle(dissect_tcap, proto_tcap);
register_init_routine(&init_tcap);
}
void
proto_register_bthcrp(void)
{
module_t *module;
expert_module_t* expert_bthcrp;
static hf_register_info hf[] = {
{ &hf_bthcrp_control_pdu_id,
{ "Control PDU ID", "bthcrp.control.pdu_id",
FT_UINT16, BASE_HEX, VALS(control_pdu_id_vals), 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_transaction_id,
{ "Transaction ID", "bthcrp.control.transaction_id",
FT_UINT16, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_parameter_length,
{ "Parameter Length", "bthcrp.control.parameter_length",
FT_UINT16, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_status,
{ "Status", "bthcrp.control.status",
FT_UINT16, BASE_HEX, VALS(status_vals), 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_notification_pdu_id,
{ "Notification PDU ID", "bthcrp.notification.pdu_id",
FT_UINT16, BASE_HEX, VALS(notification_pdu_id_vals), 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_callback_context_id,
{ "Callback Context ID", "bthcrp.callback.context_id",
FT_UINT32, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_callback_timeout,
{ "Callback Timeout", "bthcrp.callback.timeout",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_timeout,
{ "Timeout", "bthcrp.timeout",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_register,
{ "Register", "bthcrp.register",
FT_UINT8, BASE_HEX, VALS(register_vals), 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_1284_id,
{ "1284 ID", "bthcrp.1284_id",
FT_STRING, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_start_byte,
{ "Start Byte", "bthcrp.start_byte",
FT_UINT16, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_number_of_bytes,
{ "Number Of Bytes", "bthcrp.number_of_bytes",
FT_UINT16, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_client_credit_granted,
{ "Client Credit Granted", "bthcrp.client_credit_granted",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_server_credit_granted,
{ "Server Credit Granted", "bthcrp.server_credit_granted",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_client_credit_return,
{ "Client Credit Return", "bthcrp.client_credit_return",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_server_credit_return,
{ "Server Credit Return", "bthcrp.server_credit_return",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_client_credit_query,
{ "Client Credit Query", "bthcrp.client_credit_query",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_server_credit_query,
{ "Server Credit Query", "bthcrp.server_credit_query",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_status_reserved_76,
{ "Reserved", "bthcrp.status.reserved76",
FT_UINT8, BASE_DEC, NULL, 0xC0,
NULL, HFILL }
},
{ &hf_bthcrp_control_status_paper_empty,
{ "Paper Empty", "bthcrp.status.paper_empty",
FT_BOOLEAN, 8, NULL, 0x20,
NULL, HFILL }
},
{ &hf_bthcrp_control_status_select,
{ "Select", "bthcrp.status.select",
FT_BOOLEAN, 8, NULL, 0x10,
NULL, HFILL }
},
{ &hf_bthcrp_control_status_not_error,
{ "Not Error", "bthcrp.status.not_error",
FT_BOOLEAN, 8, NULL, 0x08,
NULL, HFILL }
},
{ &hf_bthcrp_control_status_reserved_20,
{ "Reserved", "bthcrp.status.reserved210",
FT_UINT8, BASE_HEX, NULL, 0x07,
NULL, HFILL }
},
{ &hf_bthcrp_data,
{ "Data", "bthcrp.data",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
}
};
static gint *ett[] = {
&ett_bthcrp
};
static ei_register_info ei[] = {
{ &ei_bthcrp_control_parameter_length, { "bthcrp.control_parameter_length.bad", PI_PROTOCOL, PI_WARN, "Length bad", EXPFILL }},
{ &ei_bthcrp_unexpected_data, { "bthcrp.unexpected_data", PI_PROTOCOL, PI_WARN, "Unexpected data", EXPFILL }},
};
proto_bthcrp = proto_register_protocol("Bluetooth HCRP Profile", "BT HCRP", "bthcrp");
bthcrp_handle = register_dissector("bthcrp", dissect_bthcrp, proto_bthcrp);
proto_register_field_array(proto_bthcrp, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
expert_bthcrp = expert_register_protocol(proto_bthcrp);
expert_register_field_array(expert_bthcrp, ei, array_length(ei));
module = prefs_register_protocol(proto_bthcrp, NULL);
prefs_register_static_text_preference(module, "hcrp.version",
"Bluetooth Profile HCRP version: 1.2",
"Version of profile supported by this dissector.");
prefs_register_obsolete_preference(module, "hcrp.is_client");
prefs_register_enum_preference(module, "hcrp.force_client", "Force Client",
"If \"yes\" localhost will be treat as Client, \"no\" as Server",
&force_client, force_client_enum, FALSE);
prefs_register_uint_preference(module, "hcrp.control.psm", "L2CAP PSM for Control",
"L2CAP PSM for Control",
10, &psm_control);
prefs_register_uint_preference(module, "hcrp.data.psm", "L2CAP PSM for Data",
"L2CAP PSM for Data",
10, &psm_data_stream);
prefs_register_uint_preference(module, "hcrp.notification.psm", "L2CAP PSM for Notification",
"L2CAP PSM for Notification",
10, &psm_notification);
}
/* Register all the bits needed with the filtering engine */
void proto_register_actrace(void)
{
static hf_register_info hf[] =
{
/* CAS */
{ &hf_actrace_cas_time,
{ "Time", "actrace.cas.time", FT_INT32, BASE_DEC, NULL, 0x0,
"Capture Time", HFILL }},
{ &hf_actrace_cas_source,
{ "Source", "actrace.cas.source", FT_INT32, BASE_DEC, VALS(actrace_cas_source_vals), 0x0,
NULL, HFILL }},
{ &hf_actrace_cas_current_state,
{ "Current State", "actrace.cas.curr_state", FT_INT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_actrace_cas_event,
{ "Event", "actrace.cas.event", FT_INT32, BASE_DEC|BASE_EXT_STRING, &actrace_cas_event_vals_ext, 0x0,
"New Event", HFILL }},
{ &hf_actrace_cas_next_state,
{ "Next State", "actrace.cas.next_state", FT_INT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_actrace_cas_function,
{ "Function", "actrace.cas.function", FT_INT32, BASE_DEC|BASE_EXT_STRING, &actrace_cas_function_vals_ext, 0x0,
NULL, HFILL }},
{ &hf_actrace_cas_par0,
{ "Parameter 0", "actrace.cas.par0", FT_INT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_actrace_cas_par1,
{ "Parameter 1", "actrace.cas.par1", FT_INT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_actrace_cas_par2,
{ "Parameter 2", "actrace.cas.par2", FT_INT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_actrace_cas_trunk,
{ "Trunk Number", "actrace.cas.trunk", FT_INT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_actrace_cas_bchannel,
{ "BChannel", "actrace.cas.bchannel", FT_INT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_actrace_cas_connection_id,
{ "Connection ID", "actrace.cas.conn_id", FT_INT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
/* ISDN */
{ &hf_actrace_isdn_trunk,
{ "Trunk Number", "actrace.isdn.trunk", FT_INT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_actrace_isdn_direction,
{ "Direction", "actrace.isdn.dir", FT_INT32, BASE_DEC, VALS(actrace_isdn_direction_vals), 0x0,
NULL, HFILL }},
{ &hf_actrace_isdn_length,
{ "Length", "actrace.isdn.length", FT_INT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
};
static gint *ett[] =
{
&ett_actrace,
};
module_t *actrace_module;
/* Register protocol */
proto_actrace = proto_register_protocol("AudioCodes Trunk Trace", "ACtrace", "actrace");
proto_register_field_array(proto_actrace, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
/* Register our configuration options */
actrace_module = prefs_register_protocol(proto_actrace, proto_reg_handoff_actrace);
prefs_register_uint_preference(actrace_module, "udp_port",
"AudioCodes Trunk Trace UDP port",
"Set the UDP port for AudioCodes Trunk Traces."
"Use http://x.x.x.x/TrunkTraces to enable the traces in the Blade",
10, &global_actrace_udp_port);
prefs_register_obsolete_preference(actrace_module, "display_dissect_tree");
actrace_tap = register_tap("actrace");
}
