/*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 }