/*FUNCTION:------------------------------------------------------
* NAME
* zbee_security_register
* DESCRIPTION
* Called to initialize the security dissectors. Roughly the
* equivalent of proto_register_*
* PARAMETERS
* module_t prefs - Prefs module to load preferences under.
* RETURNS
* none
*---------------------------------------------------------------
*/
void zbee_security_register(module_t *prefs, int proto)
{
static hf_register_info hf[] = {
{ &hf_zbee_sec_level,
{ "Level", "zbee.sec.level", FT_UINT8, BASE_HEX, VALS(zbee_sec_level_names), ZBEE_SEC_CONTROL_LEVEL,
NULL, HFILL }},
{ &hf_zbee_sec_key,
{ "Key", "zbee.sec.key", FT_UINT8, BASE_HEX, VALS(zbee_sec_key_names), ZBEE_SEC_CONTROL_KEY,
NULL, HFILL }},
{ &hf_zbee_sec_nonce,
{ "Extended Nonce", "zbee.sec.ext_nonce", FT_BOOLEAN, 8, NULL, ZBEE_SEC_CONTROL_NONCE,
NULL, HFILL }},
{ &hf_zbee_sec_counter,
{ "Frame Counter", "zbee.sec.counter", FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_zbee_sec_src,
{ "Source", "zbee.sec.src", FT_UINT64, BASE_HEX, NULL, 0x0,
NULL, HFILL }},
{ &hf_zbee_sec_key_seqno,
{ "Key Sequence Number", "zbee.sec.key_seqno", FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_zbee_sec_mic,
{ "Message Integrity Code", "zbee.sec.mic", FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL }}
};
static gint *ett[] = {
&ett_zbee_sec,
&ett_zbee_sec_control
};
/* If no prefs module was supplied, register our own. */
if (prefs == NULL) {
prefs = prefs_register_protocol(proto, zbee_security_parse_prefs);
}
/* Register preferences */
prefs_register_enum_preference(prefs, "seclevel", "Security Level",
"Specifies the security level to use in the decryption process. This value is ignored for ZigBee 2004 and unsecured networks.",
&gPREF_zbee_sec_level, zbee_sec_level_enums, FALSE);
prefs_register_string_preference(prefs, "nwkkey", "Network Key",
"Specifies the network key to use for decryption.",
&gPREF_zbee_sec_nwk_key);
prefs_register_string_preference(prefs, "tcaddr", "Trust Center Address",
"The Extended address of the trust center.",
&gPREF_zbee_sec_tcaddr);
prefs_register_string_preference(prefs, "tclinkkey", "Trust Center Link Key",
"Specifies the trust center link key to use for decryption.",
&gPREF_zbee_sec_tclink_key);
proto_register_field_array(proto, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
} /* zbee_security_register */
/*--- proto_register_pkcs12 ----------------------------------------------*/
void proto_register_pkcs12(void) {
/* List of fields */
static hf_register_info hf[] = {
{ &hf_pkcs12_X509Certificate_PDU,
{ "X509Certificate", "pkcs12.X509Certificate",
FT_NONE, BASE_NONE, NULL, 0,
"pkcs12.X509Certificate", HFILL }},
#include "packet-pkcs12-hfarr.c"
};
/* List of subtrees */
static gint *ett[] = {
&ett_decrypted_pbe,
#include "packet-pkcs12-ettarr.c"
};
module_t *pkcs12_module;
/* Register protocol */
proto_pkcs12 = proto_register_protocol(PNAME, PSNAME, PFNAME);
/* Register fields and subtrees */
proto_register_field_array(proto_pkcs12, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
/* Register preferences */
pkcs12_module = prefs_register_protocol(proto_pkcs12, NULL);
prefs_register_string_preference(pkcs12_module, "password",
"Password to decrypt the file with",
"The password to used to decrypt the encrypted elements within"
" the PKCS#12 file", &password);
prefs_register_bool_preference(pkcs12_module, "try_null_password",
"Try to decrypt with a empty password",
"Whether to try and decrypt the encrypted data within the"
" PKCS#12 with a NULL password", &try_null_password);
register_ber_syntax_dissector("PKCS#12", proto_pkcs12, dissect_PFX_PDU);
register_ber_oid_syntax(".p12", NULL, "PKCS#12");
register_ber_oid_syntax(".pfx", NULL, "PKCS#12");
}
void
proto_register_tacplus(void)
{
static hf_register_info hf[] = {
{ &hf_tacplus_response,
{ "Response", "tacplus.response",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if TACACS+ response", HFILL }},
{ &hf_tacplus_request,
{ "Request", "tacplus.request",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if TACACS+ request", HFILL }},
{ &hf_tacplus_majvers,
{ "Major version", "tacplus.majvers",
FT_UINT8, BASE_DEC, NULL, 0x0,
"Major version number", HFILL }},
{ &hf_tacplus_minvers,
{ "Minor version", "tacplus.minvers",
FT_UINT8, BASE_DEC, NULL, 0x0,
"Minor version number", HFILL }},
{ &hf_tacplus_type,
{ "Type", "tacplus.type",
FT_UINT8, BASE_DEC, VALS(tacplus_type_vals), 0x0,
NULL, HFILL }},
{ &hf_tacplus_seqno,
{ "Sequence number", "tacplus.seqno",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_flags,
{ "Flags", "tacplus.flags",
FT_UINT8, BASE_HEX, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_flags_payload_type,
{ "Unencrypted", "tacplus.flags.unencrypted",
FT_BOOLEAN, 8, TFS(&tfs_set_notset), FLAGS_UNENCRYPTED,
"Is payload unencrypted?", HFILL }},
{ &hf_tacplus_flags_connection_type,
{ "Single Connection", "tacplus.flags.singleconn",
FT_BOOLEAN, 8, TFS(&tfs_set_notset), FLAGS_SINGLE,
"Is this a single connection?", HFILL }},
{ &hf_tacplus_acct_flags,
{ "Flags", "tacplus.acct.flags",
FT_UINT8, BASE_HEX, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_session_id,
{ "Session ID", "tacplus.session_id",
FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_packet_len,
{ "Packet length", "tacplus.packet_len",
FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }}
};
static gint *ett[] = {
&ett_tacplus,
&ett_tacplus_flags,
&ett_tacplus_acct_flags,
&ett_tacplus_body,
&ett_tacplus_body_chap,
};
module_t *tacplus_module;
proto_tacplus = proto_register_protocol("TACACS+", "TACACS+", "tacplus");
proto_register_field_array(proto_tacplus, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
tacplus_module = prefs_register_protocol (proto_tacplus, tacplus_pref_cb );
prefs_register_bool_preference(tacplus_module, "desegment", "Reassemble TACACS+ messages spanning multiple TCP segments.", "Whether the TACACS+ dissector should reassemble messages spanning multiple TCP segments. To use this option, you must also enable \"Allow subdissectors to reassemble TCP streams\" in the TCP protocol settings.", &tacplus_preference_desegment);
prefs_register_string_preference ( tacplus_module, "key",
"TACACS+ Encryption Key", "TACACS+ Encryption Key", &tacplus_opt_key );
}
void proto_register_uaudp(void)
{
module_t *uaudp_module;
int i;
/* Setup list of header fields. See Section 1.6.1 for details */
static hf_register_info hf_uaudp[] = {
{
&hf_uaudp_opcode,
{
"Opcode",
"uaudp.opcode",
FT_UINT8,
BASE_DEC | BASE_EXT_STRING,
&uaudp_opcode_str_ext,
0x0,
"UA/UDP Opcode",
HFILL
}
},
{
&hf_uaudp_version,
{
"Version",
"uaudp.version",
FT_UINT8,
BASE_DEC,
NULL, 0x0,
"UA/UDP Version",
HFILL
}
},
{
&hf_uaudp_window_size,
{
"Window Size",
"uaudp.window_size",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
"UA/UDP Window Size",
HFILL
}
},
{
&hf_uaudp_mtu,
{
"MTU",
"uaudp.mtu",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
"UA/UDP MTU",
HFILL
}
},
{
&hf_uaudp_udp_lost,
{
"UDP Lost",
"uaudp.udp_lost",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
"UA/UDP Lost",
HFILL
}
},
{
&hf_uaudp_udp_lost_reinit,
{
"UDP lost reinit",
"uaudp.udp_lost_reinit",
FT_UINT8,
BASE_DEC,
NULL, 0x0,
"UA/UDP Lost Re-Init",
HFILL
}
},
{
&hf_uaudp_keepalive,
{
"Keepalive",
"uaudp.keepalive",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
"UA/UDP Keepalive",
HFILL
}
},
{
&hf_uaudp_qos_ip_tos,
{
"QoS IP TOS",
"uaudp.qos_ip_tos",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
"UA/UDP QoS IP TOS",
HFILL
}
},
{
&hf_uaudp_qos_8021_vlid,
{
"QoS 802.1 VLID",
"uaudp.qos_8021_vlid",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
"UA/UDP QoS 802.1 VLID",
HFILL
}
},
{
&hf_uaudp_qos_8021_pri,
{
"QoS 802.1 PRI",
"uaudp.qos_8021_pri",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
"UA/UDP QoS 802.1 PRI",
HFILL
}
},
{
&hf_uaudp_expseq,
{
"Sequence Number (expected)",
"uaudp.expseq",
FT_UINT16,
BASE_DEC,
NULL,
0x0,
"UA/UDP Expected Sequence Number",
HFILL
}
},
{
&hf_uaudp_sntseq,
{
"Sequence Number (sent)",
"uaudp.sntseq",
FT_UINT16,
BASE_DEC,
NULL,
0x0,
"UA/UDP Sent Sequence Number",
HFILL
}
},
};
/* Setup protocol subtree array */
static gint *ett[] =
{
&ett_uaudp,
};
/* Register the protocol name and description */
proto_uaudp = proto_register_protocol("UA/UDP Encapsulation Protocol",
"UAUDP",
"uaudp");
uaudp_handle = register_dissector("uaudp", dissect_uaudp, proto_uaudp);
#if 0 /* XXX: Not used ?? */
register_dissector("uaudp_dir_unknown", dissect_uaudp_dir_unknown, proto_uaudp);
register_dissector("uaudp_term_to_serv", dissect_uaudp_term_to_serv, proto_uaudp);
register_dissector("uaudp_serv_to_term", dissect_uaudp_serv_to_term, proto_uaudp);
#endif
proto_register_field_array(proto_uaudp, hf_uaudp, array_length(hf_uaudp));
proto_register_subtree_array(ett, array_length(ett));
/* Register preferences */
uaudp_module = prefs_register_protocol(proto_uaudp, proto_reg_handoff_uaudp);
#if 0
prefs_register_bool_preference(uaudp_module, "enable",
"Enable UA/UDP decoding based on preferences",
"Enable UA/UDP decoding based on preferences",
&decode_ua);
#endif
for (i=0; i<MAX_TERMINAL_PORTS; i++) {
prefs_register_uint_preference(uaudp_module,
ports[i].name,
ports[i].text,
ports[i].text,
10,
&ports[i].port);
}
prefs_register_string_preference(uaudp_module, "system_ip",
"System IP Address (optional)",
"IPv4 address of the DHS3 system."
" (Used only in case of identical source and destination ports)",
&pref_sys_ip_s);
#if 0
/* Register tap */
uaudp_tap = register_tap("uaudp");*/
#endif
}
void
proto_register_tacplus(void)
{
static hf_register_info hf[] = {
{ &hf_tacplus_response,
{ "Response", "tacplus.response",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if TACACS+ response", HFILL }},
{ &hf_tacplus_request,
{ "Request", "tacplus.request",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if TACACS+ request", HFILL }},
{ &hf_tacplus_majvers,
{ "Major version", "tacplus.majvers",
FT_UINT8, BASE_DEC, NULL, 0x0,
"Major version number", HFILL }},
{ &hf_tacplus_minvers,
{ "Minor version", "tacplus.minvers",
FT_UINT8, BASE_DEC, NULL, 0x0,
"Minor version number", HFILL }},
{ &hf_tacplus_type,
{ "Type", "tacplus.type",
FT_UINT8, BASE_DEC, VALS(tacplus_type_vals), 0x0,
NULL, HFILL }},
{ &hf_tacplus_seqno,
{ "Sequence number", "tacplus.seqno",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_flags,
{ "Flags", "tacplus.flags",
FT_UINT8, BASE_HEX, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_flags_payload_type,
{ "Unencrypted", "tacplus.flags.unencrypted",
FT_BOOLEAN, 8, TFS(&tfs_set_notset), FLAGS_UNENCRYPTED,
"Is payload unencrypted?", HFILL }},
{ &hf_tacplus_flags_connection_type,
{ "Single Connection", "tacplus.flags.singleconn",
FT_BOOLEAN, 8, TFS(&tfs_set_notset), FLAGS_SINGLE,
"Is this a single connection?", HFILL }},
{ &hf_tacplus_acct_flags,
{ "Flags", "tacplus.acct.flags",
FT_UINT8, BASE_HEX, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_acct_flags_more,
{ "More", "tacplus.acct.flags.more",
FT_BOOLEAN, 8, TFS(&tfs_set_notset), TAC_PLUS_ACCT_FLAG_MORE,
NULL, HFILL }},
{ &hf_tacplus_acct_flags_start,
{ "Start", "tacplus.acct.flags.start",
FT_BOOLEAN, 8, TFS(&tfs_set_notset), TAC_PLUS_ACCT_FLAG_START,
NULL, HFILL }},
{ &hf_tacplus_acct_flags_stop,
{ "Stop", "tacplus.acct.flags.stop",
FT_BOOLEAN, 8, TFS(&tfs_set_notset), TAC_PLUS_ACCT_FLAG_STOP,
NULL, HFILL }},
{ &hf_tacplus_acct_flags_watchdog,
{ "Watchdog", "tacplus.acct.flags.watchdog",
FT_BOOLEAN, 8, TFS(&tfs_set_notset), TAC_PLUS_ACCT_FLAG_WATCHDOG,
NULL, HFILL }},
{ &hf_tacplus_session_id,
{ "Session ID", "tacplus.session_id",
FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_packet_len,
{ "Packet length", "tacplus.packet_len",
FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_auth_password,
{ "Password", "tacplus.auth_password",
FT_STRINGZ, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_port,
{ "Port", "tacplus.port",
FT_STRINGZ, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_remote_address,
{ "Remote Address", "tacplus.remote_address",
FT_STRINGZ, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_chap_challenge,
{ "Challenge", "tacplus.chap.challenge",
FT_STRINGZ, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_chap_response,
{ "Response", "tacplus.chap.response",
FT_STRINGZ, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_mschap_challenge,
{ "Challenge", "tacplus.mschap.challenge",
FT_STRINGZ, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_mschap_response,
{ "Response", "tacplus.mschap.response",
FT_STRINGZ, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_arap_nas_challenge,
{ "Nas Challenge", "tacplus.arap.nas_challenge",
FT_STRINGZ, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_arap_remote_challenge,
{ "Remote Challenge", "tacplus.arap.remote_challenge",
FT_STRINGZ, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_arap_remote_response,
{ "Remote Response", "tacplus.arap.remote_response",
FT_STRINGZ, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_privilege_level,
{ "Privilege Level", "tacplus.privilege_level",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_authentication_type,
{ "Authentication type", "tacplus.authentication_type",
FT_UINT8, BASE_DEC, VALS(tacplus_authen_type_vals), 0x0,
NULL, HFILL }},
{ &hf_tacplus_service,
{ "Service", "tacplus.service",
FT_UINT8, BASE_DEC, VALS(tacplus_authen_service_vals), 0x0,
NULL, HFILL }},
{ &hf_tacplus_user_len,
{ "User len", "tacplus.user_len",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_user,
{ "User", "tacplus.user",
FT_STRINGZ, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_port_len,
{ "Port len", "tacplus.port_len",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_remote_address_len,
{ "Remaddr len", "tacplus.address_len",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_arg_length,
{ "Length", "tacplus.arg_length",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_arg_value,
{ "Value", "tacplus.arg_value",
FT_STRINGZ, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_chap_id,
{ "ID", "tacplus.chap.id",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_mschap_id,
{ "ID", "tacplus.mschap.id",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_authen_action,
{ "Action", "tacplus.authen_action",
FT_UINT8, BASE_DEC, VALS(tacplus_authen_action_vals), 0x0,
NULL, HFILL }},
{ &hf_tacplus_body_authen_req_cont_flags,
{ "Flags", "tacplus.body_authen_req_cont.flags",
FT_UINT8, BASE_HEX, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_body_authen_req_cont_user_length,
{ "User length", "tacplus.body_authen_req_cont.user_length",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_body_authen_req_cont_data_length,
{ "Data length", "tacplus.body_authen_req_cont.data_length",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_body_authen_req_cont_user,
{ "User", "tacplus.body_authen_req_cont.user",
FT_STRING, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_body_authen_rep_status,
{ "Status", "tacplus.body_authen_rep.status",
FT_UINT8, BASE_HEX, VALS(tacplus_reply_status_vals), 0x0,
NULL, HFILL }},
{ &hf_tacplus_body_authen_rep_flags,
{ "Flags", "tacplus.body_authen_rep.flags",
FT_UINT8, BASE_HEX, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_body_authen_rep_server_msg_len,
{ "Server message length", "tacplus.body_authen_rep.server_msg_len",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_body_authen_rep_server_msg,
{ "Server message", "tacplus.body_authen_rep.server_msg",
FT_STRING, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_body_authen_rep_server_data_len,
{ "Data length", "tacplus.body_authen_rep_server.data_len",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_body_author_req_auth_method,
{ "Auth Method", "tacplus.body_author_req.auth_method",
FT_UINT8, BASE_HEX, VALS(tacplus_authen_method), 0x0,
NULL, HFILL }},
{ &hf_tacplus_body_author_req_arg_count,
{ "Arg count", "tacplus.body_author_req.arg_count",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_body_author_rep_auth_status,
{ "Auth Status", "tacplus.body_author_rep.auth_status",
FT_UINT8, BASE_HEX, VALS(tacplus_author_status), 0x0,
NULL, HFILL }},
{ &hf_tacplus_body_author_rep_server_msg_len,
{ "Server Msg length", "tacplus.body_author_rep_server.msg_len",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_body_author_rep_server_data_len,
{ "Data length", "tacplus.body_author_rep_server.data_len",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_body_author_rep_arg_count,
{ "Arg count", "tacplus.body_author_rep.arg_count",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_acct_authen_method,
{ "Auth Method", "tacplus.acct.auth_method",
FT_UINT8, BASE_HEX, VALS(tacplus_authen_method), 0x0,
NULL, HFILL }},
{ &hf_tacplus_acct_arg_count,
{ "Arg count", "tacplus.acct.arg_count",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_body_acct_status,
{ "Status", "tacplus.body_acct.status",
FT_UINT8, BASE_HEX, VALS(tacplus_acct_status), 0x0,
NULL, HFILL }},
{ &hf_tacplus_body_acct_server_msg_len,
{ "Server Msg length", "tacplus.body_acct.msg_len",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_body_acct_data_len,
{ "Data length", "tacplus.body_acct.data_len",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_body_acct_server_msg,
{ "Server message", "tacplus.body_acct.server_msg",
FT_STRING, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_tacplus_body_acct_data,
{ "Data", "tacplus.body_acct.data",
FT_STRING, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
};
static gint *ett[] = {
&ett_tacplus,
&ett_tacplus_flags,
&ett_tacplus_acct_flags,
&ett_tacplus_body,
&ett_tacplus_body_chap,
};
static ei_register_info ei[] = {
{ &ei_tacplus_packet_len_invalid, { "tacplus.packet_len.invalid", PI_PROTOCOL, PI_WARN, "Invalid length", EXPFILL }},
};
module_t *tacplus_module;
expert_module_t* expert_tacplus;
proto_tacplus = proto_register_protocol("TACACS+", "TACACS+", "tacplus");
proto_register_field_array(proto_tacplus, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
expert_tacplus = expert_register_protocol(proto_tacplus);
expert_register_field_array(expert_tacplus, ei, array_length(ei));
tacplus_module = prefs_register_protocol (proto_tacplus, tacplus_pref_cb );
prefs_register_bool_preference(tacplus_module, "desegment", "Reassemble TACACS+ messages spanning multiple TCP segments.", "Whether the TACACS+ dissector should reassemble messages spanning multiple TCP segments. To use this option, you must also enable \"Allow subdissectors to reassemble TCP streams\" in the TCP protocol settings.", &tacplus_preference_desegment);
prefs_register_string_preference ( tacplus_module, "key",
"TACACS+ Encryption Key", "TACACS+ Encryption Key", &tacplus_opt_key );
}
/*! \brief Register the plugin with Wireshark.
* This function is called by Wireshark
*/
void proto_register_fast ()
{
/* Header fields which always exist. */
static hf_register_info hf[] =
{
{ &hf_fast[FieldTypeUInt32], { "uInt32", "fast.uint32", FT_NONE, BASE_NONE, NULL, 0, "", HFILL } },
{ &hf_fast[FieldTypeUInt64], { "uInt64", "fast.uint64", FT_NONE, BASE_NONE, NULL, 0, "", HFILL } },
{ &hf_fast[FieldTypeInt32], { "int32", "fast.int32", FT_NONE, BASE_NONE, NULL, 0, "", HFILL } },
{ &hf_fast[FieldTypeInt64], { "int64", "fast.int64", FT_NONE, BASE_NONE, NULL, 0, "", HFILL } },
{ &hf_fast[FieldTypeDecimal], { "decimal", "fast.decimal", FT_NONE, BASE_NONE, NULL, 0, "", HFILL } },
{ &hf_fast[FieldTypeAsciiString], { "ascii", "fast.ascii", FT_NONE, BASE_NONE, NULL, 0, "", HFILL } },
{ &hf_fast[FieldTypeUnicodeString], { "unicode", "fast.unicode", FT_NONE, BASE_NONE, NULL, 0, "", HFILL } },
{ &hf_fast[FieldTypeByteVector], { "byteVector", "fast.bytevector", FT_NONE, BASE_NONE, NULL, 0, "", HFILL } },
{ &hf_fast[FieldTypeGroup], { "group", "fast.group", FT_NONE, BASE_NONE, NULL, 0, "", HFILL } },
{ &hf_fast[FieldTypeSequence], { "sequence", "fast.sequence", FT_NONE, BASE_NONE, NULL, 0, "", HFILL } },
{ &hf_fast[FieldTypeError], { "error", "fast.ERROR", FT_NONE, BASE_NONE, NULL, 0, "Dynamic error in packet", HFILL } },
{ &hf_fast_tid, { "tid", "fast.tid", FT_NONE, BASE_NONE, NULL, 0, "", HFILL } }
};
static enum_val_t radio_buttons[] =
{
{ "Generic", "Generic", GenericImplem },
{ "CME", "CME", CMEImplem },
{ "UMDF", "UMDF", UMDFImplem },
{ 0, 0, 0 }
};
static enum_val_t protocol_buttons[] =
{
{ "UDP", "UDP", UDPImplem },
{ "TCP", "TCP", TCPImplem },
{ 0, 0, 0 }
};
/* Subtree array. */
static gint *ett[] = {
&ett_fast
};
module_t* module;
if (proto_fast != -1) return;
/* Register long, short, and abbreviated forms of the protocol name. */
proto_fast =
proto_register_protocol("FAST (FIX Adapted for STreaming) Protocol",
"FAST",
"fast");
/* Register header fields and subtree. */
proto_register_field_array(proto_fast, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
/* registers our module's dissector registration hook */
module = prefs_register_protocol(proto_fast,
proto_reg_handoff_fast);
/*** register plugin preferences ***/
prefs_register_bool_preference(module,
"enabled",
"Plugin Enabled",
"Check if you want the plugin to capture and dissect packets",
&enabled);
prefs_register_uint_preference(module,
"port",
"Listen port",
"Enter a valid port number (1024-65535)",
10,
&config_port_number);
prefs_register_enum_preference(module,
"protocol",
"Protocol",
"Network Protocol",
&protocol,
protocol_buttons,
FALSE);
prefs_register_string_preference(module,
"template",
"XML template file",
"Enter a valid filesystem path",
&config_template_xml_path);
prefs_register_bool_preference(module,
"show_empty",
"Show empty optional fields",
"Check if you want to see fields that are empty and were not sent in the packet",
&show_empty_optional_fields);
prefs_register_bool_preference(module,
"sci_notation",
"Show all decimals in scientific notation",
"Check if you want to see all decimal fields in scientific notation",
&sciNotation);
prefs_register_enum_preference(module,
"implementation",
"FAST Implementation",
"Select the specific implementation of FAST",
&implementation,
radio_buttons,
FALSE);
prefs_register_bool_preference(module,
"show_field_dictionaries",
"Show each field's dictionary",
"Show each field's dictionary",
&showFieldDictionaries);
prefs_register_bool_preference(module,
"show_field_keys",
"Show each field's dictionary key",
"Show each field's dictionary key",
&showFieldKeys);
prefs_register_bool_preference(module,
"show_field_operators",
"Show each field's operator (if any)",
"Show each field's operator (if any)",
&showFieldOperators);
prefs_register_bool_preference(module,
"show_field_mandatoriness",
"Show if each field is mandatory",
"Show if each field is mandatory",
&showFieldMandatoriness);
prefs_register_bool_preference(module,
"enable_dialogs",
"Enable error dialogs",
"Shows global and static errors in dialog windows\ntshark WILL NOT function with this enabled",
&showDialogWindows);
prefs_register_bool_preference(module,
"enable_logging",
"Enable logging to file",
"Logs all errors to error_log.txt",
&logErrors);
register_dissector("fast", &dissect_fast, proto_fast);
}
void proto_register_uasip(void)
{
module_t *uasip_module;
static hf_register_info hf_uasip[] = {
{
&hf_uasip_opcode,
{
"Opcode",
"uasip.opcode",
FT_UINT8,
BASE_DEC | BASE_EXT_STRING,
&uaudp_opcode_str_ext,
0x0,
"UA/SIP Opcode",
HFILL
}
},
{
&hf_uasip_version,
{
"Version",
"uasip.version",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
"UA/SIP Version",
HFILL
}
},
{
&hf_uasip_window_size,
{
"Window Size",
"uasip.window_size",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
"UA/SIP Window Size",
HFILL
}
},
{
&hf_uasip_mtu,
{
"MTU",
"uasip.mtu",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
"UA/SIP MTU",
HFILL
}
},
{
&hf_uasip_udp_lost,
{
"UDP Lost",
"uasip.udp_lost",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
"UA/SIP Lost",
HFILL
}
},
{
&hf_uasip_udp_lost_reinit,
{
"UDP lost reinit",
"uasip.udp_lost_reinit",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
"UA/SIP Lost Re-Init",
HFILL
}
},
{
&hf_uasip_keepalive,
{
"Keepalive",
"uasip.keepalive",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
"UA/SIP Keepalive",
HFILL
}
},
{
&hf_uasip_qos_ip_tos,
{
"QoS IP TOS",
"uasip.qos_ip_tos",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
"UA/SIP QoS IP TOS",
HFILL
}
},
{
&hf_uasip_qos_8021_vlid,
{
"QoS 802.1 VLID",
"uasip.qos_8021_vlid",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
"UA/SIP QoS 802.1 VLID",
HFILL
}
},
{
&hf_uasip_qos_8021_pri,
{
"QoS 802.1 PRI",
"uasip.qos_8021_pri",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
"UA/SIP QoS 802.1 PRI",
HFILL
}
},
{
&hf_uasip_expseq,
{
"Sequence Number (expected)",
"uasip.expseq",
FT_UINT16,
BASE_DEC,
NULL,
0x0,
"UA/SIP Expected Sequence Number",
HFILL
}
},
{
&hf_uasip_sntseq,
{
"Sequence Number (sent)",
"uasip.sntseq",
FT_UINT16,
BASE_DEC,
NULL,
0x0,
"UA/SIP Sent Sequence Number",
HFILL
}
},
};
static gint *ett[] =
{
&ett_uasip,
};
proto_uasip = proto_register_protocol("UA/SIP Protocol", "UASIP", "uasip");
uasip_handle = register_dissector("uasip", dissect_uasip, proto_uasip);
proto_register_field_array(proto_uasip, hf_uasip, array_length(hf_uasip));
proto_register_subtree_array(ett, array_length(ett));
uasip_module = prefs_register_protocol(proto_uasip, proto_reg_handoff_uasip);
prefs_register_bool_preference(uasip_module, "aplication_octet_stream", "Try to decode application/octet-stream as UASIP", "UA SIP Protocol enabled", &uasip_enabled);
prefs_register_bool_preference(uasip_module, "noesip", "Try to decode SIP NOE", "NOE SIP Protocol", &noesip_enabled);
prefs_register_string_preference(uasip_module, "proxy_ipaddr", "Proxy IP Address",
"IPv4 address of the proxy (Invalid values will be ignored)",
&pref_proxy_ipaddr_s);
#if 0
uasip_tap = register_tap("uasip");
#endif
}
