void proto_register_spp(void) { static hf_register_info hf_spp[] = { { &hf_spp_connection_control, { "Connection Control", "spp.ctl", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_spp_connection_control_sys, { "System Packet", "spp.ctl.sys", FT_BOOLEAN, 8, NULL, SPP_SYS_PACKET, NULL, HFILL }}, { &hf_spp_connection_control_send_ack, { "Send Ack", "spp.ctl.send_ack", FT_BOOLEAN, 8, NULL, SPP_SEND_ACK, NULL, HFILL }}, { &hf_spp_connection_control_attn, { "Attention", "spp.ctl.attn", FT_BOOLEAN, 8, NULL, SPP_ATTN, NULL, HFILL }}, { &hf_spp_connection_control_eom, { "End of Message", "spp.ctl.eom", FT_BOOLEAN, 8, NULL, SPP_EOM, NULL, HFILL }}, { &hf_spp_datastream_type, { "Datastream Type", "spp.type", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_spp_src_id, { "Source Connection ID", "spp.src", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_spp_dst_id, { "Destination Connection ID", "spp.dst", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_spp_seq_nr, { "Sequence Number", "spp.seq", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_spp_ack_nr, { "Acknowledgment Number", "spp.ack", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_spp_all_nr, { "Allocation Number", "spp.alloc", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, #if 0 { &hf_spp_rexmt_frame, { "Retransmitted Frame Number", "spp.rexmt_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL }}, #endif }; static gint *ett[] = { &ett_spp, &ett_spp_connctrl, }; proto_spp = proto_register_protocol("Sequenced Packet Protocol", "SPP", "spp"); proto_register_field_array(proto_spp, hf_spp, array_length(hf_spp)); proto_register_subtree_array(ett, array_length(ett)); spp_socket_dissector_table = register_dissector_table("spp.socket", "SPP socket", FT_UINT16, BASE_HEX); }
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 }
/* Register Wimax Mac Payload Protocol and Dissector */ void proto_register_mac_mgmt_msg_dcd(void) { /* DCD display */ static hf_register_info hf[] = { { &hf_dcd_message_type, { "MAC Management Message Type", "wmx.macmgtmsgtype.dcd", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_dcd_tlv_t_33_asr, { "ASR (Anchor Switch Report) Slot Length (M) and Switching Period (L)", "wmx.dcd.asr", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_dcd_tlv_t_33_asr_l, { "ASR Switching Period (L)", "wmx.dcd.asr.l", FT_UINT8, BASE_DEC, NULL, 0x0f, NULL, HFILL } }, { &hf_dcd_tlv_t_33_asr_m, { "ASR Slot Length (M)", "wmx.dcd.asr.m", FT_UINT8, BASE_DEC, NULL, 0xf0, NULL, HFILL } }, { &hf_dcd_bs_eirp, { "BS EIRP", "wmx.dcd.bs_eirp", FT_INT16, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_dcd_bs_id, { "Base Station ID", "wmx.dcd.bs_id", FT_ETHER, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_dcd_restart_count, { "BS Restart Count", "wmx.dcd.bs_restart_count", FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_dl_burst_diuc, { "DIUC", "wmx.dcd.burst.diuc", FT_UINT8, BASE_DEC, NULL, 0x0F, NULL, HFILL } }, { &hf_dcd_burst_diuc_entry_threshold, { "DIUC Minimum Entry Threshold (in 0.25 dB units)", "wmx.dcd.burst.diuc_entry_threshold", FT_FLOAT, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_dcd_burst_diuc_exit_threshold, { "DIUC Mandatory Exit Threshold (in 0.25 dB units)", "wmx.dcd.burst.diuc_exit_threshold", FT_FLOAT, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_dcd_burst_fec, { "FEC Code Type", "wmx.dcd.burst.fec", FT_UINT8, BASE_DEC, VALS(vals_dcd_burst_fec_ofdma), 0x00, NULL, HFILL } }, { &hf_dcd_burst_freq, { "Frequency", "wmx.dcd.burst.freq", FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_dl_burst_reserved, { "Reserved", "wmx.dcd.burst.reserved", FT_UINT8, BASE_HEX, NULL, 0xF0, NULL, HFILL } }, { &hf_dcd_burst_tcs, { "TCS", "wmx.dcd.burst.tcs", FT_UINT8, BASE_DEC, VALS(vals_dcd_burst_tcs), 0x00, NULL, HFILL } }, { &hf_dcd_channel_nr, { "Channel Nr", "wmx.dcd.channel_nr", FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_dcd_config_change_count, { "Configuration Change Count", "wmx.dcd.config_change_count", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_dcd_tlv_t_21_default_rssi_and_cinr_averaging_parameter_physical_cinr_measurements, { "Default Averaging Parameter for Physical CINR Measurements (in multiples of 1/16)", "wmx.dcd.default_physical_cinr_meas_averaging_parameter", FT_UINT8, BASE_HEX, NULL, 0xf0, NULL, HFILL } }, { &hf_dcd_tlv_t_21_default_rssi_and_cinr_averaging_parameter, { "Default RSSI and CINR Averaging Parameter", "wmx.dcd.default_rssi_and_cinr_averaging_parameter", FT_UINT8, BASE_HEX, NULL, 0x00, NULL, HFILL } }, { &hf_dcd_tlv_t_21_default_rssi_and_cinr_averaging_parameter_rssi_measurements, { "Default Averaging Parameter for RSSI Measurements (in multiples of 1/16)", "wmx.dcd.default_rssi_meas_averaging_parameter", FT_UINT8, BASE_HEX, NULL, 0x0f, NULL, HFILL } }, { &hf_dcd_tlv_t_22_dl_amc_allocated_physical_bands_bitmap, { "DL AMC Allocated Physical Bands Bitmap", "wmx.dcd.dl_amc_allocated_phy_bands_bitmap", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_dcd_dl_burst_profile_diuc, { "DIUC", "wmx.dcd.dl_burst_profile_diuc", FT_UINT8, BASE_DEC, VALS(diuc_msgs), 0x0F, NULL, HFILL } }, { &hf_dcd_dl_burst_profile_rsv, { "Reserved", "wmx.dcd.dl_burst_profile_rsv", FT_UINT8, BASE_DEC, NULL, 0xF0, NULL, HFILL } }, { &hf_dcd_downlink_channel_id, { "Reserved", "wmx.dcd.dl_channel_id", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_dcd_tlv_t_153_downlink_burst_profile_for_mutiple_fec_types, { "Downlink Burst Profile for Multiple FEC Types","wimax.dcd.dl_burst_profile_multiple_fec_types", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_dcd_tlv_t_34_dl_region_definition, { "DL Region Definition", "wmx.dcd.dl_region_definition", FT_BYTES, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_dcd_tlv_t_34_dl_region_definition_num_region, { "Number of Regions", "wmx.dcd.dl_region_definition.num_region", FT_UINT8, BASE_DEC, NULL, 0xFC, NULL, HFILL } }, { &hf_dcd_tlv_t_34_dl_region_definition_num_subchannels, { "Number of Subchannels", "wmx.dcd.dl_region_definition.num_subchannels", FT_UINT8, BASE_HEX, NULL, 0x00, NULL, HFILL } }, { &hf_dcd_tlv_t_34_dl_region_definition_num_symbols, { "Number of OFDMA Symbols", "wmx.dcd.dl_region_definition.num_symbols", FT_UINT8, BASE_HEX, NULL, 0x00, NULL, HFILL } }, { &hf_dcd_tlv_t_34_dl_region_definition_reserved, { "Reserved", "wmx.dcd.dl_region_definition.reserved", FT_UINT8, BASE_DEC, NULL, 0x03, NULL, HFILL } }, { &hf_dcd_tlv_t_34_dl_region_definition_subchannel_offset, { "Subchannel Offset", "wmx.dcd.dl_region_definition.subchannel_offset", FT_UINT8, BASE_HEX, NULL, 0x00, NULL, HFILL } }, { &hf_dcd_tlv_t_34_dl_region_definition_symbol_offset, { "OFDMA Symbol Offset", "wmx.dcd.dl_region_definition.symbol_offset", FT_UINT8, BASE_HEX, NULL, 0x00, NULL, HFILL } }, #ifndef WIMAX_16D_2004 { &hf_dcd_eirxp, { "EIRXP (IR, max)", "wmx.dcd.eirxp", FT_INT16, BASE_DEC, NULL, 0x00, NULL, HFILL } }, #endif { &hf_dcd_frame_duration, { "Frame Duration", "wmx.dcd.frame_duration", FT_UINT32, BASE_HEX, NULL, 0x00, NULL, HFILL } }, { &hf_dcd_frame_duration_code, { "Frame Duration Code", "wmx.dcd.frame_duration_code", FT_UINT8, BASE_HEX, VALS(vals_dcd_frame_duration), 0x00, NULL, HFILL } }, { &hf_dcd_frame_nr, { "Frame Number", "wmx.dcd.frame_nr", FT_UINT24, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_dcd_frequency, { "Downlink Center Frequency", "wmx.dcd.frequency", FT_UINT32, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_dcd_tlv_t_31_h_add_threshold, { "H_add Threshold", "wmx.dcd.h_add_threshold", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, #ifdef WIMAX_16D_2004 { &hf_dcd_h_arq_ack_delay, { "H-ARQ ACK Delay for DL Burst", "wmx.dcd.h_arq_ack_delay_dl_burst", FT_UINT8, BASE_DEC, NULL, 0x00, "", HFILL } }, #else { &hf_dcd_h_arq_ack_delay, { "H-ARQ ACK Delay for UL Burst", "wmx.dcd.h_arq_ack_delay_ul_burst", FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL } }, #endif { &hf_dcd_tlv_t_32_h_delete_threshold, { "H_delete Threshold", "wmx.dcd.h_delete_threshold", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_dcd_tlv_t_50_ho_type_support, { "HO Type Support", "wmx.dcd.ho_type_support", FT_UINT8, BASE_HEX, NULL, 0x00, NULL, HFILL } }, { &hf_dcd_tlv_t_50_ho_type_support_fbss_ho, { "FBSS HO", "wmx.dcd.ho_type_support.fbss_ho", FT_UINT8, BASE_HEX, VALS(tfs_support), 0x20, NULL, HFILL } }, { &hf_dcd_tlv_t_50_ho_type_support_ho, { "HO", "wmx.dcd.ho_type_support.ho", FT_UINT8, BASE_HEX, VALS(tfs_support), 0x80, NULL, HFILL } }, { &hf_dcd_tlv_t_50_ho_type_support_mdho, { "MDHO", "wmx.dcd.ho_type_support.mdho", FT_UINT8, BASE_HEX, VALS(tfs_support), 0x40, NULL, HFILL } }, { &hf_dcd_tlv_t_50_ho_type_support_reserved, { "Reserved", "wmx.dcd.ho_type_support.reserved", FT_UINT8, BASE_HEX, NULL, 0x1f, NULL, HFILL } }, { &hf_dcd_tlv_t_51_hysteresis_margin, { "Hysteresis Margin", "wmx.dcd.hysteresis_margin", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_dcd_invalid_tlv, { "Invalid TLV", "wmx.dcd.invalid_tlv", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_dcd_mac_version, { "MAC Version", "wmx.dcd.mac_version", FT_UINT8, BASE_DEC, VALS(vals_dcd_mac_version), 0x00, NULL, HFILL } }, { &hf_dcd_tlv_t_20_maximum_retransmission, { "Maximum Retransmission", "wmx.dcd.maximum_retransmission", FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_dcd_tlv_t_60_noise_interference, { "Noise and Interference", "wmx.dcd.noise_interference", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_dcd_tlv_t_35_paging_group_id, { "Paging Group ID", "wmx.dcd.paging_group_id", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_dcd_tlv_t_36_tusc1_permutation_active_subchannels_bitmap, { "TUSC1 permutation active subchannels bitmap", "wmx.dcd.tusc1", FT_UINT16, BASE_HEX, NULL, 0xFF80, NULL, HFILL } }, { &hf_dcd_tlv_t_37_tusc2_permutation_active_subchannels_bitmap, { "TUSC2 permutation active subchannels bitmap", "wmx.dcd.tusc2", FT_UINT16, BASE_HEX, NULL, 0xFFF8, NULL, HFILL } }, { &hf_dcd_tlv_t_45_paging_interval_length, { "Paging Interval Length", "wmx.dcd.paging_interval_length", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_dcd_tlv_t_19_permutation_type_for_broadcast_regions_in_harq_zone, { "Permutation Type for Broadcast Region in HARQ Zone", "wmx.dcd.permutation_type_broadcast_region_in_harq_zone", FT_UINT8, BASE_DEC, VALS(vals_dcd_permutation_type), 0x00, NULL, HFILL } }, { &hf_dcd_phy_type, { "PHY Type", "wmx.dcd.phy_type", FT_UINT8, BASE_HEX, NULL, 0x00, NULL, HFILL } }, { &hf_dcd_power_adjustment, { "Power Adjustment Rule", "wmx.dcd.power_adjustment", FT_UINT8, BASE_HEX, VALS(vals_dcd_power_adjustmnt), 0x00, NULL, HFILL } }, #ifdef WIMAX_16D_2004 { &hf_dcd_rss, { "RSS (IR, max)", "wmx.dcd.rss", FT_INT16, BASE_DEC, NULL, 0x00, "", HFILL } }, #endif { &hf_dcd_rtg, { "RTG", "wmx.dcd.rtg", FT_UINT8, BASE_HEX, NULL, 0x00, NULL, HFILL } }, #ifdef WIMAX_16D_2004 { &hf_dcd_size_cqich_id, { "Size of CQICH-ID Field", "wmx.dcd.size_cqich_id", FT_UINT8, BASE_DEC, VALS(vals_dcd_size_of_cqich_id), 0x00, "", HFILL } }, #endif { &hf_dcd_channel_switch_frame_nr, { "Channel Switch Frame Number", "wmx.dcd.switch_frame", FT_UINT24, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_dcd_tlv_t_52_time_to_trigger_duration, { "Time to Trigger Duration", "wmx.dcd.time_trigger_duration", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_dcd_tlv_t_543_trigger_averaging_duration, { "Trigger Averaging Duration", "wmx.dcd.trigger_averaging_duration", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_dcd_tlv_t_542_trigger_value, { "Trigger Value", "wmx.dcd.trigger_value", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_dcd_ttg, { "TTG", "wmx.dcd.ttg", FT_UINT16, BASE_HEX, NULL, 0x00, NULL, HFILL } }, { &hf_dcd_tlv_t_541_type_function_action, { "Type/Function/Action", "wmx.dcd.type_function_action", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_dcd_tlv_t_541_action, { "Action", "wmx.dcd.type_function_action.action", FT_UINT8, BASE_HEX, VALS(vals_dcd_action), 0x7, NULL, HFILL } }, { &hf_dcd_tlv_t_541_function, { "Function", "wmx.dcd.type_function_action.function", FT_UINT8, BASE_HEX, VALS(vals_dcd_function), 0x38, NULL, HFILL } }, { &hf_dcd_tlv_t_541_type, { "Type", "wmx.dcd.type_function_action.type", FT_UINT8, BASE_HEX, VALS(vals_dcd_type), 0xC0, NULL, HFILL } }, { &hf_dcd_unknown_type, { "Unknown DCD Type", "wmx.dcd.unknown_tlv_value", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } } }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_mac_mgmt_msg_dcd_decoder, }; proto_mac_mgmt_msg_dcd_decoder = proto_register_protocol ( "WiMax DCD/UCD Messages", /* name */ "WiMax DCD/UCD (cd)", /* short name */ "wmx.cd" /* abbrev */ ); proto_register_field_array(proto_mac_mgmt_msg_dcd_decoder, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }
void proto_register_nflog(void) { static hf_register_info hf[] = { /* Header */ { &hf_nflog_family, { "Family", "nflog.family", FT_UINT8, BASE_DEC, VALS(_linux_family_vals), 0x00, NULL, HFILL } }, { &hf_nflog_version, { "Version", "nflog.version", FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_nflog_resid, { "Resource id", "nflog.res_id", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_nflog_encoding, { "Encoding", "nflog.encoding", FT_UINT32, BASE_HEX, VALS(_encoding_vals), 0x00, NULL, HFILL } }, /* TLV */ { &hf_nflog_tlv, { "TLV", "nflog.tlv", FT_BYTES, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_nflog_tlv_length, { "Length", "nflog.tlv_length", FT_UINT16, BASE_DEC, NULL, 0x00, "TLV Length", HFILL } }, { &hf_nflog_tlv_type, { "Type", "nflog.tlv_type", FT_UINT16, BASE_DEC, VALS(nflog_tlv_vals), 0x7fff, "TLV Type", HFILL } }, /* TLV values */ { &hf_nflog_tlv_prefix, { "Prefix", "nflog.prefix", FT_STRINGZ, BASE_NONE, NULL, 0x00, "TLV Prefix Value", HFILL } }, { &hf_nflog_tlv_uid, { "UID", "nflog.uid", FT_INT32, BASE_DEC, NULL, 0x00, "TLV UID Value", HFILL } }, { &hf_nflog_tlv_gid, { "GID", "nflog.gid", FT_INT32, BASE_DEC, NULL, 0x00, "TLV GID Value", HFILL } }, { &hf_nflog_tlv_timestamp, { "Timestamp", "nflog.timestamp", FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL, NULL, 0x00, "TLV Timestamp Value", HFILL } }, { &hf_nflog_tlv_unknown, { "Value", "nflog.tlv_value", FT_BYTES, BASE_NONE, NULL, 0x00, "TLV Value", HFILL } }, }; static gint *ett[] = { &ett_nflog, &ett_nflog_tlv }; module_t *pref; proto_nflog = proto_register_protocol("Linux Netfilter NFLOG", "NFLOG", "nflog"); pref = prefs_register_protocol(proto_nflog, NULL); prefs_register_enum_preference(pref, "byte_order_type", "Byte Order", "Byte Order", &nflog_byte_order, byte_order_types, FALSE); register_dissector("nflog", dissect_nflog, proto_nflog); proto_register_field_array(proto_nflog, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }
/* 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, VALS(actrace_cas_event_vals), 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, VALS(actrace_cas_function_vals), 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"); }
/* Register the protocol with Wireshark */ void proto_register_lanforge(void) { /* Setup list of header fields */ static hf_register_info hf[] = { { &hf_lanforge_crc, { "CRC", "lanforge.CRC", FT_UINT32, BASE_HEX, NULL, 0x0, "The LANforge CRC number", HFILL } }, { &hf_lanforge_magic, { "Magic number", "lanforge.magic", FT_UINT32, BASE_HEX, NULL, 0x0, "The LANforge magic number", HFILL } }, { &hf_lanforge_src_session, { "Source session ID", "lanforge.source-session-id", FT_UINT16, BASE_DEC, NULL, 0x0, "The LANforge source session ID", HFILL } }, { &hf_lanforge_dst_session, { "Dest session ID", "lanforge.dest-session-id", FT_UINT16, BASE_DEC, NULL, 0x0, "The LANforge dest session ID", HFILL } }, { &hf_lanforge_pld_len_l, { "Payload Length(L)", "lanforge.pld-len-L", FT_UINT16, BASE_DEC, NULL, 0x0, "The LANforge payload length (low bytes)", HFILL } }, { &hf_lanforge_pld_len_h, { "Payload Length(H)", "lanforge.pld-len-H", FT_UINT8, BASE_DEC, NULL, 0x0, "The LANforge payload length (high byte)", HFILL } }, { &hf_lanforge_pld_len, { "Payload Length", "lanforge.pld-length", FT_UINT32, BASE_DEC, NULL, 0x0, "The LANforge payload length", HFILL } }, { &hf_lanforge_pld_pattern, { "Payload Pattern", "lanforge.pld-pattern", FT_UINT16, BASE_DEC, NULL, 0x0, "The LANforge payload pattern", HFILL } }, { &hf_lanforge_seq, { "Sequence Number", "lanforge.seqno", FT_UINT32, BASE_DEC, NULL, 0x0, "The LANforge Sequence Number", HFILL } }, { &hf_lanforge_tx_time_s, { "Timestamp Secs", "lanforge.ts-secs", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_lanforge_tx_time_ns, { "Timestamp nsecs", "lanforge.ts-nsecs", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_lanforge_timestamp, { "Timestamp", "lanforge.timestamp", FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL, NULL, 0x0, NULL, HFILL } } }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_lanforge }; /* Register the protocol name and description */ proto_lanforge = proto_register_protocol("LANforge Traffic Generator", "LANforge", "lanforge"); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_lanforge, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }
/* protocol register function */ void proto_register_tfp(void) { /* defining header formats */ static hf_register_info hf_tfp[] = { { &hf_tfp_uid, { "UID (String)", "tfp.uid", FT_STRINGZ, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_tfp_uid_numeric, { "UID (Numeric)", "tfp.uid_numeric", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_tfp_len, { "Length", "tfp.len", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_tfp_fid, { "Function ID", "tfp.fid", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_tfp_seq, { "Sequence Number", "tfp.seq", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_tfp_r, { "Response Expected", "tfp.r", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_tfp_a, { "Authentication", "tfp.a", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_tfp_oo, { "Other Options", "tfp.oo", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_tfp_e, { "Error Code", "tfp.e", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_tfp_future_use, { "Future Use", "tfp.future_use", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_tfp_payload, { "Payload", "tfp.payload", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } } }; /* setup protocol subtree array */ static gint *ett[] = { &ett_tfp }; /* defining the protocol and its names */ proto_tfp = proto_register_protocol ( "Tinkerforge Protocol", "TFP", "tfp" ); proto_register_field_array(proto_tfp, hf_tfp, array_length(hf_tfp)); proto_register_subtree_array(ett, array_length(ett)); }
void proto_register_dmx_chan(void) { static hf_register_info hf[] = { { &hf_dmx_chan_output_data_filter, { "DMX data filter", "dmx_chan.data_filter", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_dmx_chan_output_dmx_data, { "DMX data", "dmx_chan.dmx_data", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }}, }; static gint *ett[] = { &ett_dmx_chan }; module_t *dmx_chan_module; static enum_val_t disp_chan_val_types[] = { { "pro", "Percent", 0 }, { "hex", "Hexadecimal", 1 }, { "dec", "Decimal", 2 }, { NULL, NULL, 0 } }; static enum_val_t disp_chan_nr_types[] = { { "hex", "Hexadecimal", 0 }, { "dec", "Decimal", 1 }, { NULL, NULL, 0 } }; static enum_val_t col_count[] = { { "6", "6", 6 }, { "10", "10", 10 }, { "12", "12", 12 }, { "16", "16", 16 }, { "24", "24", 24 }, { NULL, NULL, 0 } }; proto_dmx_chan = proto_register_protocol("DMX Channels","DMX Channels", "dmx-chan"); proto_register_field_array(proto_dmx_chan, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); register_dissector("dmx-chan", dissect_dmx_chan, proto_dmx_chan); dmx_chan_module = prefs_register_protocol(proto_dmx_chan, NULL); prefs_register_enum_preference(dmx_chan_module, "dmx_disp_chan_val_type", "DMX Display channel value type", "The way DMX values are displayed", &global_disp_chan_val_type, disp_chan_val_types, FALSE); prefs_register_enum_preference(dmx_chan_module, "dmx_disp_chan_nr_type", "DMX Display channel nr. type", "The way DMX channel numbers are displayed", &global_disp_chan_nr_type, disp_chan_nr_types, FALSE); prefs_register_enum_preference(dmx_chan_module, "dmx_disp_col_count", "DMX Display Column Count", "The number of columns for the DMX display", &global_disp_col_count, col_count, FALSE); }
void proto_register_vtp(void) { static hf_register_info hf[] = { { &hf_vtp_version, { "Version", "vtp.version", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_vtp_code, { "Code", "vtp.code", FT_UINT8, BASE_HEX, VALS(type_vals), 0x0, NULL, HFILL }}, { &hf_vtp_followers, { "Followers", "vtp.followers", FT_UINT8, BASE_DEC, NULL, 0x0, "Number of following Subset-Advert messages", HFILL }}, { &hf_vtp_md_len, { "Management Domain Length", "vtp.md_len", FT_UINT8, BASE_DEC, NULL, 0x0, "Length of management domain string", HFILL }}, { &hf_vtp_md, { "Management Domain", "vtp.md", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, { &hf_vtp_conf_rev_num, { "Configuration Revision Number", "vtp.conf_rev_num", FT_UINT32, BASE_DEC, NULL, 0x0, "Revision number of the configuration information", HFILL }}, { &hf_vtp_upd_id, { "Updater Identity", "vtp.upd_id", FT_IPv4, BASE_NONE, NULL, 0x0, "IP address of the updater", HFILL }}, { &hf_vtp_upd_ts, { "Update Timestamp", "vtp.upd_ts", FT_STRING, BASE_NONE, NULL, 0, "Time stamp of the current configuration revision", HFILL }}, { &hf_vtp_md5_digest, { "MD5 Digest", "vtp.md5_digest", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_vtp_seq_num, { "Sequence Number", "vtp.seq_num", FT_UINT8, BASE_DEC, NULL, 0x0, "Order of this frame in the sequence of Subset-Advert frames", HFILL }}, { &hf_vtp_start_value, { "Start Value", "vtp.start_value", FT_UINT16, BASE_HEX, NULL, 0x0, "Virtual LAN ID of first VLAN for which information is requested", HFILL }}, { &hf_vtp_vlan_info_len, { "VLAN Information Length", "vtp.vlan_info.len", FT_UINT8, BASE_DEC, NULL, 0x0, "Length of the VLAN information field", HFILL }}, { &hf_vtp_vlan_status_vlan_susp, { "VLAN suspended", "vtp.vlan_info.status.vlan_susp", FT_BOOLEAN, 8, NULL, VLAN_SUSPENDED, NULL, HFILL }}, { &hf_vtp_vlan_type, { "VLAN Type", "vtp.vlan_info.vlan_type", FT_UINT8, BASE_HEX, VALS(vlan_type_vals), 0x0, "Type of VLAN", HFILL }}, { &hf_vtp_vlan_name_len, { "VLAN Name Length", "vtp.vlan_info.vlan_name_len", FT_UINT8, BASE_DEC, NULL, 0x0, "Length of VLAN name string", HFILL }}, { &hf_vtp_isl_vlan_id, { "ISL VLAN ID", "vtp.vlan_info.isl_vlan_id", FT_UINT16, BASE_HEX, NULL, 0x0, "ID of this VLAN on ISL trunks", HFILL }}, { &hf_vtp_mtu_size, { "MTU Size", "vtp.vlan_info.mtu_size", FT_UINT16, BASE_DEC, NULL, 0x0, "MTU for this VLAN", HFILL }}, { &hf_vtp_802_10_index, { "802.10 Index", "vtp.vlan_info.802_10_index", FT_UINT32, BASE_HEX, NULL, 0x0, "IEEE 802.10 security association identifier for this VLAN", HFILL }}, { &hf_vtp_vlan_name, { "VLAN Name", "vtp.vlan_info.vlan_name", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, { &hf_vtp_vlan_tlvtype, { "Type", "vtp.vlan_info.tlv_type", FT_UINT8, BASE_HEX, VALS(vlan_tlv_type_vals), 0x0, NULL, HFILL }}, { &hf_vtp_vlan_tlvlength, { "Length", "vtp.vlan_info.tlv_len", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_vtp_pruning_first_vid, { "First VLAN ID", "vtp.pruning.first", FT_UINT16, BASE_DEC, NULL, 0x0, "First VLAN ID for which pruning information is present", HFILL }}, { &hf_vtp_pruning_last_vid, { "Last VLAN ID", "vtp.pruning.last", FT_UINT16, BASE_DEC, NULL, 0x0, "Last VLAN ID for which pruning information is present", HFILL }}, { &hf_vtp_pruning_active_vid, { "VLAN", "vtp.pruning.active", FT_UINT16, BASE_DEC, NULL, 0x0, "Active advertised VLAN ID", HFILL }}, }; static gint *ett[] = { &ett_vtp, &ett_vtp_vlan_info, &ett_vtp_vlan_status, &ett_vtp_tlv, &ett_vtp_pruning, }; proto_vtp = proto_register_protocol("VLAN Trunking Protocol", "VTP", "vtp"); proto_register_field_array(proto_vtp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }
void proto_register_docsis_dpvreq (void) { /* Setup list of header fields See Section 1.6.1 for details*/ static hf_register_info hf[] = { {&hf_docsis_dpvreq_tranid, {"Transaction Id", "docsis_dpvreq.tranid", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL} }, {&hf_docsis_dpvreq_dschan, {"Downstream Channel ID", "docsis_dpvreq.dschan", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL} }, {&hf_docsis_dpvreq_flags, {"Flags", "docsis_dpvreq.flags", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL} }, {&hf_docsis_dpvreq_us_sf, {"Upstream Service Flow ID", "docsis_dpvreq.us_sf", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL} }, {&hf_docsis_dpvreq_n, {"N (Measurement avaraging factor)", "docsis_dpvreq.n", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL} }, {&hf_docsis_dpvreq_start, {"Start Reference Point", "docsis_dpvreq.start", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL} }, {&hf_docsis_dpvreq_end, {"End Reference Point", "docsis_dpvreq.end", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL} }, {&hf_docsis_dpvreq_ts_start, {"Timestamp Start", "docsis_dpvreq.ts_start", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL} }, {&hf_docsis_dpvreq_ts_end, {"Timestamp End", "docsis_dpvreq.ts_end", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL} }, }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_docsis_dpvreq, }; /* Register the protocol name and description */ proto_docsis_dpvreq = proto_register_protocol ("DOCSIS Path Verify Request", "DOCSIS DPV-REQ", "docsis_dpvreq"); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array (proto_docsis_dpvreq, hf, array_length (hf)); proto_register_subtree_array (ett, array_length (ett)); register_dissector ("docsis_dpvreq", dissect_dpvreq, proto_docsis_dpvreq); }
void proto_register_zrtp(void) { static hf_register_info hf[] = { {&hf_zrtp_rtpversion, { "RTP Version", "zrtp.rtpversion", FT_UINT8, BASE_DEC, NULL, 0xC0, NULL, HFILL } }, {&hf_zrtp_rtppadding, { "RTP padding", "zrtp.rtppadding", FT_BOOLEAN, 8, NULL, 0x20, NULL, HFILL } }, {&hf_zrtp_rtpextension, { "RTP Extension", "zrtp.rtpextension", FT_BOOLEAN, 8, NULL, 0x10, NULL, HFILL } }, {&hf_zrtp_id, { "ID", "zrtp.id", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_sequence, { "Sequence", "zrtp.sequence", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_cookie, { "Magic Cookie", "zrtp.cookie", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_source_id, { "Source Identifier", "zrtp.source_id", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, /* Message Types */ {&hf_zrtp_signature, { "Signature", "zrtp.signature", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_msg_length, { "Length", "zrtp.length", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_msg_type, { "Type", "zrtp.type", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_msg_version, { "ZRTP protocol version", "zrtp.version", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_msg_client_id, { "Client Identifier", "zrtp.client_source_id", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_msg_hash_image, { "Hash Image", "zrtp.hash_image", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_msg_zid, { "ZID", "zrtp.zid", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_msg_sigcap, { "Sig.capable", "zrtp.sigcap", FT_BOOLEAN, 8, NULL, 0x40, NULL, HFILL } }, {&hf_zrtp_msg_mitm, { "MiTM", "zrtp.mitm", FT_BOOLEAN, 8, NULL, 0x20, NULL, HFILL } }, {&hf_zrtp_msg_passive, { "Passive", "zrtp.passive", FT_BOOLEAN, 8, NULL, 0x10, NULL, HFILL } }, {&hf_zrtp_msg_hash_count, { "Hash Count", "zrtp.hc", FT_UINT8, BASE_DEC, NULL, 0x0F, NULL, HFILL } }, {&hf_zrtp_msg_cipher_count, { "Cipher Count", "zrtp.cc", FT_UINT8, BASE_DEC, NULL, 0xF0, NULL, HFILL } }, {&hf_zrtp_msg_authtag_count, { "Auth tag Count", "zrtp.ac", FT_UINT8, BASE_DEC, NULL, 0x0F, NULL, HFILL } }, {&hf_zrtp_msg_key_count, { "Key Agreement Count", "zrtp.kc", FT_UINT8, BASE_DEC, NULL, 0xF0, NULL, HFILL } }, {&hf_zrtp_msg_sas_count, { "SAS Count", "zrtp.sc", FT_UINT8, BASE_DEC, NULL, 0x0F, NULL, HFILL } }, {&hf_zrtp_msg_hash, { "Hash", "zrtp.hash", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_msg_cipher, { "Cipher", "zrtp.cipher", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_msg_at, { "AT", "zrtp.at", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_msg_keya, { "Key Agreement", "zrtp.keya", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_msg_sas, { "SAS", "zrtp.sas", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_msg_rs1ID, { "rs1ID", "zrtp.rs1id", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_msg_rs2ID, { "rs2ID", "zrtp.rs2id", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_msg_auxs, { "auxs", "zrtp.auxs", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_msg_pbxs, { "pbxs", "zrtp.pbxs", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_msg_hmac, { "HMAC", "zrtp.hmac", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_msg_cfb, { "CFB", "zrtp.cfb", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_msg_error, { "Error", "zrtp.error", FT_UINT32, BASE_DEC, VALS(zrtp_error_vals), 0x0, NULL, HFILL } }, {&hf_zrtp_msg_ping_version, { "Ping Version", "zrtp.ping_version", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_msg_ping_endpointhash, { "Ping Endpoint Hash", "zrtp.ping_endpointhash", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_msg_pingack_endpointhash, { "PingAck Endpoint Hash", "zrtp.pingack_endpointhash", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_msg_ping_ssrc, { "Ping SSRC", "zrtp.ping_ssrc", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_checksum, { "Checksum", "zrtp.checksum", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_checksum_good, { "Good", "zrtp.checksum_good", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "True: checksum matches packet content; False: doesn't match content", HFILL } }, {&hf_zrtp_checksum_bad, { "Bad", "zrtp.checksum_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "True: checksum doesn't match packet content; False: matches content", HFILL } }, {&hf_zrtp_msg_hvi, { "hvi", "zrtp.hvi", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_msg_nonce, { "nonce", "zrtp.nonce", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, {&hf_zrtp_msg_key_id, { "key ID", "zrtp.key_id", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } } }; static gint *ett[] = { &ett_zrtp, &ett_zrtp_msg, &ett_zrtp_msg_data, &ett_zrtp_msg_encrypted, &ett_zrtp_msg_pvr, &ett_zrtp_msg_hc, &ett_zrtp_msg_kc, &ett_zrtp_msg_ac, &ett_zrtp_msg_cc, &ett_zrtp_msg_sc, &ett_zrtp_checksum }; proto_zrtp = proto_register_protocol("ZRTP", "ZRTP", "zrtp"); proto_register_field_array(proto_zrtp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); register_dissector("zrtp", dissect_zrtp, proto_zrtp); }
void proto_register_tzsp(void) { static const value_string msg_type[] = { {0, "Normal"}, {1, "RFC1042 encoded"}, {2, "Bridge-tunnel encoded"}, {4, "802.11 management frame"}, {0, NULL} }; static const true_false_string pcf_flag = { "CF: Frame received during CF period", "Not CF" }; static const true_false_string undecr_flag = { "Encrypted frame could not be decrypted", "Unencrypted" }; static const true_false_string fcs_err_flag = { "FCS error, frame is corrupted", "Frame is valid" }; static const value_string channels[] = { /* 802.11b/g */ { 1, "1 (2.412 GHz)"}, { 2, "2 (2.417 GHz)"}, { 3, "3 (2.422 GHz)"}, { 4, "4 (2.427 GHz)"}, { 5, "5 (2.432 GHz)"}, { 6, "6 (2.437 GHz)"}, { 7, "7 (2.442 GHz)"}, { 8, "8 (2.447 GHz)"}, { 9, "9 (2.452 GHz)"}, { 10, "10 (2.457 GHz)"}, { 11, "11 (2.462 GHz)"}, { 12, "12 (2.467 GHz)"}, { 13, "13 (2.472 GHz)"}, { 14, "14 (2.484 GHz)"}, /* 802.11a */ { 36, "36 (5.180 GHz)"}, { 40, "40 (5.200 GHz)"}, { 44, "44 (5.220 GHz)"}, { 48, "48 (5.240 GHz)"}, { 52, "52 (5.260 GHz)"}, { 56, "56 (5.280 GHz)"}, { 60, "60 (5.300 GHz)"}, { 64, "64 (5.320 GHz)"}, {149, "149 (5.745 GHz)"}, {153, "153 (5.765 GHz)"}, {157, "157 (5.785 GHz)"}, {161, "161 (5.805 GHz)"}, {0, NULL} }; static const value_string rates[] = { /* Old PRISM rates */ {0x0A, "1 Mbit/s"}, {0x14, "2 Mbit/s"}, {0x37, "5.5 Mbit/s"}, {0x6E, "11 Mbit/s"}, /* MicroAP rates */ { 2, "1 Mbit/s"}, { 4, "2 Mbit/s"}, { 11, "5.5 Mbit/s"}, { 12, "6 Mbit/s"}, { 18, "9 Mbit/s"}, { 22, "11 Mbit/s"}, { 24, "12 Mbit/s"}, { 36, "18 Mbit/s"}, { 48, "24 Mbit/s"}, { 72, "36 Mbit/s"}, { 96, "48 Mbit/s"}, {108, "54 Mbit/s"}, {0, NULL} }; static hf_register_info hf[] = { { &hf_tzsp_version, { "Version", "tzsp.version", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_tzsp_type, { "Type", "tzsp.type", FT_UINT8, BASE_DEC, VALS(tzsp_type), 0, NULL, HFILL }}, { &hf_tzsp_encap, { "Encapsulation", "tzsp.encap", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_option_tag, { "Option Tag", "tzsp.option_tag", FT_UINT8, BASE_DEC, VALS(option_tag_vals), 0, NULL, HFILL }}, { &hf_option_length, { "Option Length", "tzsp.option_length", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, #if 0 { &hf_status_field, { "Status", "tzsp.wlan.status", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, #endif { &hf_status_msg_type, { "Type", "tzsp.wlan.status.msg_type", FT_UINT8, BASE_HEX, VALS(msg_type), 0, "Message type", HFILL }}, #if 0 { &hf_status_mac_port, { "Port", "tzsp.wlan.status.mac_port", FT_UINT8, BASE_DEC, NULL, 0, "MAC port", HFILL }}, #endif { &hf_status_pcf, { "PCF", "tzsp.wlan.status.pcf", FT_BOOLEAN, BASE_NONE, TFS (&pcf_flag), 0x0, "Point Coordination Function", HFILL }}, { &hf_status_undecrypted, { "Undecrypted", "tzsp.wlan.status.undecrypted", FT_BOOLEAN, BASE_NONE, TFS (&undecr_flag), 0x0, NULL, HFILL }}, { &hf_status_fcs_error, { "FCS", "tzsp.wlan.status.fcs_err", FT_BOOLEAN, BASE_NONE, TFS (&fcs_err_flag), 0x0, "Frame check sequence", HFILL }}, { &hf_time, { "Time", "tzsp.wlan.time", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, { &hf_silence, { "Silence", "tzsp.wlan.silence", FT_INT8, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_original_length, { "Original Length", "tzsp.original_length", FT_INT16, BASE_DEC, NULL, 0, "OrigLength", HFILL }}, { &hf_signal, { "Signal", "tzsp.wlan.signal", FT_INT8, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_rate, { "Rate", "tzsp.wlan.rate", FT_UINT8, BASE_DEC, VALS(rates), 0, NULL, HFILL }}, { &hf_channel, { "Channel", "tzsp.wlan.channel", FT_UINT8, BASE_DEC, VALS(channels), 0, NULL, HFILL }}, { &hf_unknown, { "Unknown tag", "tzsp.unknown", FT_BYTES, BASE_NONE, NULL, 0, "Unknown", HFILL }}, { &hf_sensormac, { "Sensor Address", "tzsp.sensormac", FT_ETHER, BASE_NONE, NULL, 0, "Sensor MAC", HFILL }} }; static gint *ett[] = { &ett_tzsp, &ett_tag }; proto_tzsp = proto_register_protocol("Tazmen Sniffer Protocol", "TZSP", "tzsp"); proto_register_field_array(proto_tzsp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); tzsp_handle = register_dissector("tzsp", dissect_tzsp, proto_tzsp); }
void proto_register_btbnep(void) { module_t *module; static hf_register_info hf[] = { { &hf_btbnep_bnep_type, { "BNEP Type", "btbnep.bnep_type", FT_UINT8, BASE_HEX, VALS(bnep_type_vals), 0x7F, NULL, HFILL } }, { &hf_btbnep_extension_flag, { "Extension Flag", "btbnep.extension_flag", FT_BOOLEAN, 8, NULL, 0x80, NULL, HFILL } }, { &hf_btbnep_control_type, { "Control Type", "btbnep.control_type", FT_UINT8, BASE_HEX, VALS(control_type_vals), 0x00, NULL, HFILL } }, { &hf_btbnep_extension_type, { "Extension Type", "btbnep.extension_type", FT_UINT8, BASE_HEX, VALS(extension_type_vals), 0x00, NULL, HFILL } }, { &hf_btbnep_extension_length, { "Extension Length", "btbnep.extension_length", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_btbnep_unknown_control_type, { "Unknown Control Type", "btbnep.uknown_control_type", FT_UINT8, BASE_HEX, VALS(control_type_vals), 0x00, NULL, HFILL } }, { &hf_btbnep_uuid_size, { "UIDD Size", "btbnep.uuid_size", FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_btbnep_destination_service_uuid, { "Destination Service UUID", "btbnep.destination_service_uuid", FT_NONE, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_btbnep_source_service_uuid, { "Source Service UUID", "btbnep.source_service_uuid", FT_NONE, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_btbnep_setup_connection_response_message, { "Response Message", "btbnep.setup_connection_response_message", FT_UINT16, BASE_HEX, VALS(setup_connection_response_message_vals), 0x00, NULL, HFILL } }, { &hf_btbnep_filter_net_type_response_message, { "Response Message", "btbnep.filter_net_type_response_message", FT_UINT16, BASE_HEX, VALS(filter_net_type_response_message_vals), 0x00, NULL, HFILL } }, { &hf_btbnep_filter_multi_addr_response_message, { "Response Message", "btbnep.filter_multi_addr_response_message", FT_UINT16, BASE_HEX, VALS(filter_multi_addr_response_message_vals), 0x00, NULL, HFILL } }, { &hf_btbnep_list_length, { "List Length", "btbnep.list_length", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL } }, /* http://www.iana.org/assignments/ethernet-numbers */ { &hf_btbnep_network_type_start, { "Network Protocol Type Range Start", "btbnep.network_type_start", FT_UINT16, BASE_HEX, VALS(etype_vals), 0x00, NULL, HFILL } }, { &hf_btbnep_network_type_end, { "Network Protocol Type Range End", "btbnep.network_type_end", FT_UINT16, BASE_HEX, VALS(etype_vals), 0x00, NULL, HFILL } }, { &hf_btbnep_multicast_address_start, { "Multicast Address Start", "btbnep.multicast_address_start", FT_ETHER, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_btbnep_multicast_address_end, { "Multicast Address End", "btbnep.multicast_address_end", FT_ETHER, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_btbnep_dst, { "Destination", "btbnep.dst", FT_ETHER, BASE_NONE, NULL, 0x0, "Destination Hardware Address", HFILL } }, { &hf_btbnep_src, { "Source", "btbnep.src", FT_ETHER, BASE_NONE, NULL, 0x0, "Source Hardware Address", HFILL } }, { &hf_btbnep_type, { "Type", "btbnep.type", FT_UINT16, BASE_HEX, VALS(etype_vals), 0x0, NULL, HFILL } }, { &hf_btbnep_addr, { "Address", "btbnep.addr", FT_ETHER, BASE_NONE, NULL, 0x0, "Source or Destination Hardware Address", HFILL } }, { &hf_btbnep_lg, { "LG bit", "btbnep.lg", FT_BOOLEAN, 24, TFS(&lg_tfs), 0x020000, "Specifies if this is a locally administered or globally unique (IEEE assigned) address", HFILL } }, { &hf_btbnep_ig, { "IG bit", "btbnep.ig", FT_BOOLEAN, 24, TFS(&ig_tfs), 0x010000, "Specifies if this is an individual (unicast) or group (broadcast/multicast) address", HFILL } } }; static gint *ett[] = { &ett_btbnep, &ett_addr }; proto_btbnep = proto_register_protocol("Bluetooth BNEP Protocol", "BT BNEP", "btbnep"); register_dissector("btbnep", dissect_btbnep, proto_btbnep); proto_register_field_array(proto_btbnep, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); module = prefs_register_protocol(proto_btbnep, NULL); prefs_register_static_text_preference(module, "bnep.version", "Bluetooth Protocol BNEP version: 1.0", "Version of protocol supported by this dissector."); prefs_register_bool_preference(module, "bnep.top_dissect", "Dissecting the top protocols", "Dissecting the top protocols", &top_dissect); }
void proto_register_tte_pcf(void) { static hf_register_info hf[] = { { &hf_tte_pcf, { "Protocol Control Frame", "tte.pcf", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_tte_pcf_ic, { "Integration Cycle", "tte.pcf.ic", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_tte_pcf_mn, { "Membership New", "tte.pcf.mn", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_tte_pcf_res0, { "Reserved 0", "tte.pcf.res0", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_tte_pcf_sp, { "Sync Priority", "tte.pcf.sp", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_tte_pcf_sd, { "Sync Domain", "tte.pcf.sd", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_tte_pcf_type, { "Type", "tte.pcf.type", FT_UINT8, BASE_HEX, VALS(pcf_type_str_vals), 0x0F, NULL, HFILL } }, { &hf_tte_pcf_res1, { "Reserved 1", "tte.pcf.res1", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_tte_pcf_tc, { "Transparent Clock", "tte.pcf.tc", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } } }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_tte_pcf }; /* Register the protocol name and description */ proto_tte_pcf = proto_register_protocol("TTEthernet Protocol Control Frame", "TTE PCF", "tte_pcf"); /* Required function calls to register header fields and subtrees used */ proto_register_field_array(proto_tte_pcf, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); register_dissector("tte_pcf", dissect_tte_pcf, proto_tte_pcf); }
void proto_register_beep(void) { static hf_register_info hf[] = { { &hf_beep_proto_viol, { "Protocol Violation", "beep.violation", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_beep_req, { "Request", "beep.req", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_beep_req_chan, { "Request Channel Number", "beep.req.channel", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_beep_rsp, { "Response", "beep.rsp", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_beep_rsp_chan, { "Response Channel Number", "beep.rsp.channel", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_beep_seq, { "Sequence", "beep.seq", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_beep_seq_chan, { "Sequence Channel Number", "beep.seq.channel", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_beep_end, { "End", "beep.end", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_beep_complete, { "Complete", "beep.more.complete", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_beep_intermediate, { "Intermediate", "beep.more.intermediate", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_beep_msgno, { "Msgno", "beep.msgno", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_beep_ansno, { "Ansno", "beep.ansno", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_beep_seqno, { "Seqno", "beep.seqno", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_beep_size, { "Size", "beep.size", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_beep_channel, { "Channel", "beep.channel", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_beep_negative, { "Negative", "beep.status.negative", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_beep_positive, { "Positive", "beep.status.positive", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_beep_ackno, { "Ackno", "beep.seq.ackno", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_beep_window, { "Window", "beep.seq.window", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, }; static gint *ett[] = { &ett_beep, &ett_mime_header, &ett_header, &ett_trailer, }; module_t *beep_module; proto_beep = proto_register_protocol("Blocks Extensible Exchange Protocol", "BEEP", "beep"); proto_register_field_array(proto_beep, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); register_init_routine(&beep_init_protocol); /* Register our configuration options for BEEP, particularly our port */ beep_module = prefs_register_protocol(proto_beep, proto_reg_handoff_beep); prefs_register_uint_preference(beep_module, "tcp.port", "BEEP TCP Port", "Set the port for BEEP messages (if other" " than the default of 10288)", 10, &global_beep_tcp_port); prefs_register_bool_preference(beep_module, "strict_header_terminator", "BEEP Header Requires CRLF", "Specifies that BEEP requires CRLF as a " "terminator, and not just CR or LF", &global_beep_strict_term); }
void proto_register_pw_satop(void) { static hf_register_info hf[] = { { &hf_cw ,{"Control Word" ,"pwsatop.cw" ,FT_NONE ,BASE_NONE ,NULL ,0 ,NULL ,HFILL }}, {&hf_cw_bits03,{"Bits 0 to 3" ,"pwsatop.cw.bits03" ,FT_UINT8 ,BASE_DEC ,NULL ,0xf0 ,NULL ,HFILL }}, {&hf_cw_l, {"L bit: TDM payload state" ,"pwsatop.cw.lbit" ,FT_UINT8 ,BASE_DEC ,VALS(pwc_vals_cw_l_bit) ,0x08 ,NULL ,HFILL }}, {&hf_cw_r, {"R bit: Local CE-bound IWF" ,"pwsatop.cw.rbit" ,FT_UINT8 ,BASE_DEC ,VALS(pwc_vals_cw_r_bit) ,0x04 ,NULL ,HFILL }}, {&hf_cw_rsv, {"Reserved" ,"pwsatop.cw.rsv" ,FT_UINT8 ,BASE_DEC ,NULL ,0x03 ,NULL ,HFILL }}, {&hf_cw_frg, {"Fragmentation" ,"pwsatop.cw.frag" ,FT_UINT8 ,BASE_DEC ,VALS(pwc_vals_cw_frag) ,0xc0 ,NULL ,HFILL }}, {&hf_cw_len, {"Length" ,"pwsatop.cw.length" ,FT_UINT8 ,BASE_DEC ,NULL ,0x3f ,NULL ,HFILL }}, {&hf_cw_seq, {"Sequence number" ,"pwsatop.cw.seqno" ,FT_UINT16 ,BASE_DEC ,NULL ,0 ,NULL ,HFILL }}, {&hf_payload ,{"TDM payload" ,"pwsatop.payload" ,FT_BYTES ,BASE_NONE ,NULL ,0 ,NULL ,HFILL }}, {&hf_payload_l ,{"TDM payload length" ,"pwsatop.payload.len" ,FT_INT32 ,BASE_DEC ,NULL ,0 ,NULL ,HFILL }} }; static gint *ett_array[] = { &ett }; static ei_register_info ei[] = { { &ei_cw_packet_size_too_small, { "pwsatop.packet_size_too_small", PI_MALFORMED, PI_ERROR, "PW packet size (%d) is too small to carry sensible information", EXPFILL }}, { &ei_cw_bits03, { "pwsatop.cw.bits03.not_zero", PI_MALFORMED, PI_ERROR, "Bits 0..3 of Control Word must be 0", EXPFILL }}, { &ei_cw_rsv, { "pwsatop.cw.rsv.not_zero", PI_MALFORMED, PI_ERROR, "RSV bits of Control Word must be 0", EXPFILL }}, { &ei_cw_frg, { "pwsatop.cw.frag.not_allowed", PI_MALFORMED, PI_ERROR, "Fragmentation of payload is not allowed for SAToP", EXPFILL }}, { &ei_payload_size_invalid, { "pwsatop.payload.size_invalid", PI_MALFORMED, PI_ERROR, "Bad Length: too small", EXPFILL }}, { &ei_payload_size_invalid_undecoded, { "pwsatop.payload.undecoded", PI_UNDECODED, PI_NOTE, "SAToP payload: omitted to conserve bandwidth", EXPFILL }}, }; expert_module_t* expert_pwsatop; proto = proto_register_protocol(pwc_longname_pw_satop, shortname, "pwsatopcw"); proto_register_field_array(proto, hf, array_length(hf)); proto_register_subtree_array(ett_array, array_length(ett_array)); expert_pwsatop = expert_register_protocol(proto); expert_register_field_array(expert_pwsatop, ei, array_length(ei)); register_dissector("pw_satop_mpls", dissect_pw_satop_mpls, proto); register_dissector("pw_satop_udp", dissect_pw_satop_udp, proto); return; }
void proto_register_dmx_sip(void) { static hf_register_info hf[] = { { &hf_dmx_sip_byte_count, { "Byte Count", "dmx_sip.byte_count", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_dmx_sip_control_bit_field, { "Control Bit Field", "dmx_sip.control_bit_field", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_dmx_sip_prev_packet_checksum, { "Checksum of prev. packet", "dmx_sip.prev_packet_checksum", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_dmx_sip_seq_nr, { "SIP sequence nr.", "dmx_sip.seq_nr", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_dmx_sip_dmx_universe_nr, { "DMX512 universe nr.", "dmx_sip.dmx_universe_nr", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_dmx_sip_dmx_proc_level, { "DMX512 processing level", "dmx_sip.dmx_proc_level", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_dmx_sip_dmx_software_version, { "Software Version", "dmx_sip.dmx_software_version", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_dmx_sip_dmx_packet_len, { "Standard Packet Len", "dmx_sip.dmx_packet_len", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_dmx_sip_dmx_nr_packets, { "Number of Packets", "dmx_sip.dmx_nr_packets", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_dmx_sip_orig_dev_id, { "1st Device's ID", "dmx_sip.orig_dev_id", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_dmx_sip_sec_dev_id, { "2nd Device's ID", "dmx_sip.sec_dev_id", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_dmx_sip_third_dev_id, { "3rd Device's ID", "dmx_sip.third_dev_id", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_dmx_sip_fourth_dev_id, { "4th Device's ID", "dmx_sip.fourth_dev_id", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_dmx_sip_fifth_dev_id, { "5th Device's ID", "dmx_sip.fifth_dev_id", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_dmx_sip_reserved, { "Reserved", "dmx_sip.reserved", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_dmx_sip_checksum, { "Checksum", "dmx_sip.checksum", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_dmx_sip_checksum_good, { "Good Checksum", "dmx_sip.checksum_good", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "True: checksum matches packet content; False: doesn't match content", HFILL }}, { &hf_dmx_sip_checksum_bad, { "Bad Checksum", "dmx_sip.checksum_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "True: checksum doesn't match packet content; False: matches content", HFILL }}, { &hf_dmx_sip_trailer, { "Trailer", "dmx_sip.trailer", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, }; static gint *ett[] = { &ett_dmx_sip }; proto_dmx_sip = proto_register_protocol("DMX SIP", "DMX SIP", "dmx-sip"); proto_register_field_array(proto_dmx_sip, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); register_dissector("dmx-sip", dissect_dmx_sip, proto_dmx_sip); }
/* Register the protocol with Wireshark */ void proto_register_xdmcp(void) { /* Setup list of header fields */ static hf_register_info hf[] = { { &hf_xdmcp_version, { "Version", "xdmcp.version", FT_UINT16, BASE_DEC, NULL, 0, "Protocol version", HFILL } }, { &hf_xdmcp_opcode, { "Opcode", "xdmcp.opcode", FT_UINT16, BASE_HEX, VALS(opcode_vals), 0, NULL, HFILL } }, { &hf_xdmcp_length, { "Message length", "xdmcp.length", FT_UINT16, BASE_DEC, NULL, 0, "Length of the remaining message", HFILL } }, { &hf_xdmcp_authentication_name, { "Authentication name", "xdmcp.authentication_name", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_xdmcp_authorization_name, { "Authorization name", "xdmcp.authorization_name", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_xdmcp_hostname, { "Hostname", "xdmcp.hostname", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_xdmcp_status, { "Status", "xdmcp.status", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_xdmcp_session_id, { "Session ID", "xdmcp.session_id", FT_UINT32, BASE_HEX, NULL, 0, "Session identifier", HFILL } }, { &hf_xdmcp_display_number, { "Display number", "xdmcp.display_number", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL } }, }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_xdmcp, &ett_xdmcp_authentication_names, &ett_xdmcp_authorization_names, &ett_xdmcp_connections, &ett_xdmcp_connection }; /* Register the protocol name and description */ proto_xdmcp = proto_register_protocol("X Display Manager Control Protocol", "XDMCP", "xdmcp"); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_xdmcp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }
void proto_register_docsis_dccrsp (void) { /* Setup list of header fields See Section 1.6.1 for details*/ static hf_register_info hf[] = { {&hf_docsis_dccrsp_tran_id , { "Transaction ID", "docsis_dccrsp.tran_id", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, {&hf_docsis_dccrsp_conf_code , { "Confirmation Code", "docsis_dccrsp.conf_code", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, {&hf_docsis_dccrsp_cm_jump_time_length , { "Jump Time Length", "docsis_dccrsp.cm_jump_time_length", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, {&hf_docsis_dccrsp_cm_jump_time_start , { "Jump Time Start", "docsis_dccrsp.cm_jump_time_start", FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL } }, {&hf_docsis_dccrsp_key_seq_num , { "Auth Key Sequence Number", "docsis_dccrsp.key_seq_num", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, {&hf_docsis_dccrsp_hmac_digest , { "HMAC-DigestNumber", "docsis_dccrsp.hmac_digest", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_docsis_dccrsp, &ett_docsis_dccrsp_cm_jump_time, }; /* Register the protocol name and description */ proto_docsis_dccrsp = proto_register_protocol ("DOCSIS Downstream Channel Change Response", "DOCSIS DCC-RSP", "docsis_dccrsp"); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array (proto_docsis_dccrsp, hf, array_length (hf)); proto_register_subtree_array (ett, array_length (ett)); register_dissector ("docsis_dccrsp", dissect_dccrsp, proto_docsis_dccrsp); }
void proto_register_lapdm(void) { static hf_register_info hf[] = { { &hf_lapdm_address, { "Address Field", "lapdm.address_field", FT_UINT8, BASE_HEX, NULL, 0x0, "Address", HFILL }}, { &hf_lapdm_ea, { "EA", "lapdm.ea", FT_UINT8, BASE_DEC, VALS(lapdm_ea_vals), LAPDM_EA, "Address field extension bit", HFILL }}, { &hf_lapdm_cr, { "C/R", "lapdm.cr", FT_UINT8, BASE_DEC, NULL, LAPDM_CR, "Command/response field bit", HFILL }}, { &hf_lapdm_lpd, { "LPD", "lapdm.lpd", FT_UINT8, BASE_DEC, VALS(lapdm_lpd_vals), LAPDM_LPD, "Link Protocol Discriminator", HFILL }}, { &hf_lapdm_sapi, { "SAPI", "lapdm.sapi", FT_UINT8, BASE_DEC, VALS(lapdm_sapi_vals), LAPDM_SAPI, "Service access point identifier", HFILL }}, { &hf_lapdm_control, { "Control Field", "lapdm.control_field", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_lapdm_n_r, { "N(R)", "lapdm.control.n_r", FT_UINT8, BASE_DEC, NULL, XDLC_N_R_MASK, NULL, HFILL }}, { &hf_lapdm_n_s, { "N(S)", "lapdm.control.n_s", FT_UINT8, BASE_DEC, NULL, XDLC_N_S_MASK, NULL, HFILL }}, { &hf_lapdm_p, { "Poll", "lapdm.control.p", FT_BOOLEAN, 8, TFS(&tfs_true_false), XDLC_P_F, NULL, HFILL }}, { &hf_lapdm_f, { "Final", "lapdm.control.f", FT_BOOLEAN, 8, TFS(&tfs_true_false), XDLC_P_F, NULL, HFILL }}, { &hf_lapdm_s_ftype, { "Supervisory frame type", "lapdm.control.s_ftype", FT_UINT8, BASE_HEX, VALS(stype_vals), XDLC_S_FTYPE_MASK, NULL, HFILL }}, { &hf_lapdm_u_modifier_cmd, { "Command", "lapdm.control.u_modifier_cmd", FT_UINT8, BASE_HEX, VALS(modifier_vals_cmd), XDLC_U_MODIFIER_MASK, NULL, HFILL }}, { &hf_lapdm_u_modifier_resp, { "Response", "lapdm.control.u_modifier_resp", FT_UINT8, BASE_HEX, VALS(modifier_vals_resp), XDLC_U_MODIFIER_MASK, NULL, HFILL }}, { &hf_lapdm_ftype_i, { "Frame type", "lapdm.control.ftype", FT_UINT8, BASE_HEX, VALS(ftype_vals), XDLC_I_MASK, NULL, HFILL }}, { &hf_lapdm_ftype_s_u, { "Frame type", "lapdm.control.ftype", FT_UINT8, BASE_HEX, VALS(ftype_vals), XDLC_S_U_MASK, NULL, HFILL }}, { &hf_lapdm_length, { "Length Field", "lapdm.length_field", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_lapdm_el, { "EL", "lapdm.el", FT_UINT8, BASE_DEC, VALS(lapdm_el_vals), LAPDM_EL, "Length indicator field extension bit", HFILL }}, { &hf_lapdm_m, { "M", "lapdm.m", FT_UINT8, BASE_DEC, VALS(lapdm_m_vals), LAPDM_M, "More data bit", HFILL }}, { &hf_lapdm_len, { "Length", "lapdm.length", FT_UINT8, BASE_DEC, NULL, LAPDM_LEN, "Length indicator", HFILL }}, /* Fragment reassembly */ { &hf_lapdm_fragments, { "Message fragments", "lapdm.fragments", FT_NONE, BASE_NONE, NULL, 0x00, "LAPDm Message fragments", HFILL }}, { &hf_lapdm_fragment, { "Message fragment", "lapdm.fragment", FT_FRAMENUM, BASE_NONE, NULL, 0x00, "LAPDm Message fragment", HFILL }}, { &hf_lapdm_fragment_overlap, { "Message fragment overlap", "lapdm.fragment.overlap", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "LAPDm Message fragment overlaps with other fragment(s)", HFILL }}, { &hf_lapdm_fragment_overlap_conflicts, { "Message fragment overlapping with conflicting data", "lapdm.fragment.overlap.conflicts", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "LAPDm Message fragment overlaps with conflicting data", HFILL }}, { &hf_lapdm_fragment_multiple_tails, { "Message has multiple tail fragments", "lapdm.fragment.multiple_tails", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "LAPDm Message fragment has multiple tail fragments", HFILL }}, { &hf_lapdm_fragment_too_long_fragment, { "Message fragment too long", "lapdm.fragment.too_long_fragment", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "LAPDm Message fragment data goes beyond the packet end", HFILL }}, { &hf_lapdm_fragment_error, { "Message defragmentation error", "lapdm.fragment.error", FT_FRAMENUM, BASE_NONE, NULL, 0x00, "LAPDm Message defragmentation error due to illegal fragments", HFILL }}, { &hf_lapdm_fragment_count, { "Message fragment count", "lapdm.fragment.count", FT_UINT32, BASE_DEC, NULL, 0x00, NULL, HFILL }}, { &hf_lapdm_reassembled_in, { "Reassembled in", "lapdm.reassembled.in", FT_FRAMENUM, BASE_NONE, NULL, 0x00, "LAPDm Message has been reassembled in this packet.", HFILL }}, { &hf_lapdm_reassembled_length, { "Reassembled LAPDm length", "lapdm.reassembled.length", FT_UINT32, BASE_DEC, NULL, 0x00, "The total length of the reassembled payload", HFILL }} }; static gint *ett[] = { &ett_lapdm, &ett_lapdm_address, &ett_lapdm_control, &ett_lapdm_length, &ett_lapdm_fragment, &ett_lapdm_fragments }; module_t *lapdm_module; proto_lapdm = proto_register_protocol("Link Access Procedure, Channel Dm (LAPDm)", "LAPDm", "lapdm"); proto_register_field_array (proto_lapdm, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); register_dissector("lapdm", dissect_lapdm, proto_lapdm); lapdm_sapi_dissector_table = register_dissector_table("lapdm.sapi", "LAPDm SAPI", FT_UINT8, BASE_DEC); lapdm_module = prefs_register_protocol(proto_lapdm, NULL); prefs_register_bool_preference(lapdm_module, "reassemble", "Reassemble fragmented LAPDm packets", "Whether the dissector should defragment LAPDm messages spanning multiple packets.", &reassemble_lapdm); register_init_routine (lapdm_defragment_init); }
void proto_register_msdp(void) { static hf_register_info hf[] = { { &hf_msdp_type, { "Type", "msdp.type", FT_UINT8, BASE_DEC, VALS(msdp_types), 0, "MSDP TLV type", HFILL } }, { &hf_msdp_length, { "Length", "msdp.length", FT_UINT16, BASE_DEC, NULL, 0, "MSDP TLV Length", HFILL } }, { &hf_msdp_sa_entry_count, { "Entry Count", "msdp.sa.entry_count", FT_UINT8, BASE_DEC, NULL, 0, "MSDP SA Entry Count", HFILL } }, { &hf_msdp_sa_rp_addr, { "RP Address", "msdp.sa.rp_addr", FT_IPv4, BASE_NONE, NULL, 0, "Active source's RP address", HFILL } }, { &hf_msdp_sa_reserved, { "Reserved", "msdp.sa.reserved", FT_UINT24, BASE_HEX, NULL, 0, "Transmitted as zeros and ignored by a receiver", HFILL } }, { &hf_msdp_sa_sprefix_len, { "Sprefix len", "msdp.sa.sprefix_len", FT_UINT8, BASE_DEC, NULL, 0, "The route prefix length associated with source address", HFILL } }, { &hf_msdp_sa_group_addr, { "Group Address", "msdp.sa.group_addr", FT_IPv4, BASE_NONE, NULL, 0, "The group address the active source has sent data to", HFILL } }, { &hf_msdp_sa_src_addr, { "Source Address", "msdp.sa.src_addr", FT_IPv4, BASE_NONE, NULL, 0, "The IP address of the active source", HFILL } }, { &hf_msdp_sa_req_res, { "Reserved", "msdp.sa_req.res", FT_UINT8, BASE_HEX, NULL, 0, "Transmitted as zeros and ignored by a receiver", HFILL } }, { &hf_msdp_sa_req_group, { "Group Address", "msdp.sa_req.group_addr", FT_IPv4, BASE_NONE, NULL, 0, "The group address the MSDP peer is requesting", HFILL } }, { &hf_msdp_not_o, { "Open-bit", "msdp.not.o", FT_UINT8, BASE_HEX, NULL, 0x80, "If clear, the connection will be closed", HFILL } }, { &hf_msdp_not_error, { "Error Code", "msdp.not.error", FT_UINT8, BASE_DEC, VALS(error_vals), 0x7F, "Indicates the type of Notification", HFILL } }, { &hf_msdp_not_error_sub, { "Error subode", "msdp.not.error_sub", FT_UINT8, BASE_DEC, NULL, 0, "Error subcode", HFILL } }, { &hf_msdp_not_ipv4, { "IPv4 address", "msdp.not.ipv4", FT_IPv4, BASE_NONE, NULL, 0, "Group/RP/Source address in Notification messages", HFILL } }, { &hf_msdp_not_res, { "Reserved", "msdp.not.res", FT_UINT24, BASE_HEX, NULL, 0, "Reserved field in Notification messages", HFILL } }, { &hf_msdp_not_entry_count, { "Entry Count", "msdp.not.entry_count", FT_UINT24, BASE_HEX, NULL, 0, "Entry Count in Notification messages", HFILL } }, { &hf_msdp_not_sprefix_len, { "Sprefix len", "msdp.not.sprefix_len", FT_UINT8, BASE_DEC, NULL, 0, "Source prefix length in Notification messages", HFILL } }, }; static gint *ett[] = { &ett_msdp, &ett_msdp_sa_entry, &ett_msdp_sa_enc_data, &ett_msdp_not_data, }; proto_msdp = proto_register_protocol("Multicast Source Discovery Protocol", "MSDP", "msdp"); proto_register_field_array(proto_msdp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }
/* * proto_register_ts2() * */ void proto_register_ts2(void) { static hf_register_info hf[] = { { &hf_ts2_class, { "Class", "ts2.class", FT_UINT16, BASE_HEX, VALS(classnames), 0x0, NULL, HFILL } }, { &hf_ts2_type, { "Type", "ts2.type", FT_UINT16, BASE_HEX, VALS(typenames), 0x0, NULL, HFILL } }, { &hf_ts2_clientid, { "Client id", "ts2.clientid", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_sessionkey, { "Session Key", "ts2.sessionkey", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_ackto, { "Ping Reply To", "ts2.ping_ackto", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_crc32, { "CRC32 Checksum", "ts2.crc32", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_seqnum, { "Sequence Number", "ts2.sequencenum", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_protocol_string, { "Protocol String", "ts2.protocolstring", FT_UINT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, #if 0 { &hf_ts2_string, { "String", "ts2.string", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, #endif { &hf_ts2_registeredlogin, { "Registered Login", "ts2.registeredlogin", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_name, { "Name", "ts2.name", FT_UINT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_password, { "Password", "ts2.password", FT_UINT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_nick, { "Nick", "ts2.nick", FT_UINT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_badlogin, { "Bad Login", "ts2.badlogin", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_unknown, { "Unknown", "ts2.unknown", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_channel, { "Channel", "ts2.channel", FT_UINT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_subchannel, { "Sub-Channel", "ts2.subchannel", FT_UINT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_channelpassword, { "Channel Password", "ts2.channelpassword", FT_UINT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_emptyspace, { "Empty Space", "ts2.emptyspace", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_fragmentnumber, { "Fragment Number", "ts2.fragmentnumber", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_platform_string, { "Platform String", "ts2.platformstring", FT_UINT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_server_name, { "Server Name", "ts2.servername", FT_UINT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_server_welcome_message, { "Server Welcome Message", "ts2.serverwelcomemessage", FT_UINT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_parent_channel_id, { "Parent Channel ID", "ts2.parentchannelid", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_codec, { "Codec", "ts2.codec", FT_UINT16, BASE_HEX, VALS(codecnames), 0x0, NULL, HFILL } }, { &hf_ts2_channel_flags, { "Channel Flags", "ts2.channelflags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_channel_id, { "Channel Id", "ts2.chanelid", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_channel_name, { "Channel Name", "ts2.chanelname", FT_STRINGZ, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_channel_topic, { "Channel Topic", "ts2.chaneltopic", FT_STRINGZ, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_channel_description, { "Channel Description", "ts2.chaneldescription", FT_STRINGZ, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_player_id, { "Player Id", "ts2.playerid", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_player_status_flags, { "Player Status Flags", "ts2.playerstatusflags", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_number_of_players, { "Number Of Players", "ts2.numberofplayers", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_number_of_channels, { "Number Of Channels", "ts2.numberofchannels", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_resend_count, { "Resend Count", "ts2.resendcount", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_ts2_status_channelcommander, { "Channel Commander", "ts2.playerstatusflags.channelcommander", FT_BOOLEAN, 8, NULL, TS2_STATUS_CHANNELCOMMANDER, NULL, HFILL } }, { &hf_ts2_status_blockwhispers, { "Block Whispers", "ts2.playerstatusflags.blockwhispers", FT_BOOLEAN, 8, NULL, TS2_STATUS_BLOCKWHISPERS, NULL, HFILL } }, { &hf_ts2_status_away, { "Away", "ts2.playerstatusflags.away", FT_BOOLEAN, 8, NULL, TS2_STATUS_AWAY, NULL, HFILL } }, { &hf_ts2_status_mutemicrophone, { "Mute Microphone", "ts2.playerstatusflags.mutemicrophone", FT_BOOLEAN, 8, NULL, TS2_STATUS_MUTEMICROPHONE, NULL, HFILL } }, { &hf_ts2_status_mute, { "Mute", "ts2.playerstatusflags.mute", FT_BOOLEAN, 8, NULL, TS2_STATUS_MUTE, NULL, HFILL } }, { &hf_msg_fragments, {"Message fragments", "ts2.fragments", FT_NONE, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_msg_fragment, {"Message fragment", "ts2.fragment", FT_FRAMENUM, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_msg_fragment_overlap, {"Message fragment overlap", "ts2.fragment.overlap", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_msg_fragment_overlap_conflicts, {"Message fragment overlapping with conflicting data", "ts2.fragment.overlap.conflicts", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_msg_fragment_multiple_tails, {"Message has multiple tail fragments", "ts2.fragment.multiple_tails", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_msg_fragment_too_long_fragment, {"Message fragment too long", "ts2.fragment.too_long_fragment", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_msg_fragment_error, {"Message defragmentation error", "ts2.fragment.error", FT_FRAMENUM, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_msg_fragment_count, {"Message fragment count", "ts2.fragment.count", FT_UINT32, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_msg_reassembled_in, {"Reassembled in", "ts2.reassembled.in", FT_FRAMENUM, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_msg_reassembled_length, {"Reassembled TeamSpeak2 length", "ts2.reassembled.length", FT_UINT32, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_ts2_channel_unregistered, { "Unregistered", "ts2.channelflags.unregistered", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL } }, { &hf_ts2_channel_moderated, { "Moderated", "ts2.channelflags.moderated", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL } }, { &hf_ts2_channel_password, { "Has password", "ts2.channelflags.has_password", FT_BOOLEAN, 8, NULL, 0x04, NULL, HFILL } }, { &hf_ts2_channel_subchannels, { "Has subchannels", "ts2.channelflags.has_subchannels", FT_BOOLEAN, 8, NULL, 0x08, NULL, HFILL } }, { &hf_ts2_channel_default, { "Default", "ts2.channelflags.default", FT_BOOLEAN, 8, NULL, 0x10, NULL, HFILL } }, { &hf_ts2_channel_order, { "Channel order", "ts2.channelorder", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_ts2_max_users, { "Max users", "ts2.maxusers", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL } } }; static gint *ett[] = { &ett_ts2, &ett_msg_fragment, &ett_msg_fragments, &ett_ts2_channel_flags }; /* Setup protocol subtree array */ proto_ts2 = proto_register_protocol ( "Teamspeak2 Protocol", /* name */ "TeamSpeak2", /* short name */ "ts2" /* abbrev */ ); proto_register_field_array(proto_ts2, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); register_init_routine(ts2_init); }
void proto_register_cups(void) { static hf_register_info hf[] = { { &hf_cups_ptype, { "Type", "cups.ptype", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_cups_ptype_default, { "Default printer on network", "cups.ptype.default", FT_BOOLEAN, 32, TFS(&tfs_yes_no), CUPS_PRINTER_DEFAULT, NULL, HFILL }}, { &hf_cups_ptype_implicit, { "Class", "cups.ptype.implicit", FT_BOOLEAN, 32, TFS(&tfs_implicit_explicit), CUPS_PRINTER_IMPLICIT, NULL, HFILL }}, { &hf_cups_ptype_variable, { "Can print variable sizes", "cups.ptype.variable", FT_BOOLEAN, 32, TFS(&tfs_yes_no), CUPS_PRINTER_VARIABLE, NULL, HFILL }}, { &hf_cups_ptype_large, { "Can print up to 36x48 inches", "cups.ptype.large", FT_BOOLEAN, 32, TFS(&tfs_yes_no), CUPS_PRINTER_LARGE, NULL, HFILL }}, { &hf_cups_ptype_medium, { "Can print up to 18x24 inches", "cups.ptype.medium", FT_BOOLEAN, 32, TFS(&tfs_yes_no), CUPS_PRINTER_MEDIUM, NULL, HFILL }}, { &hf_cups_ptype_small, { "Can print up to 9x14 inches", "cups.ptype.small", FT_BOOLEAN, 32, TFS(&tfs_yes_no), CUPS_PRINTER_SMALL, NULL, HFILL }}, { &hf_cups_ptype_sort, { "Can sort", "cups.ptype.sort", FT_BOOLEAN, 32, TFS(&tfs_yes_no), CUPS_PRINTER_SORT, NULL, HFILL }}, { &hf_cups_ptype_bind, { "Can bind", "cups.ptype.bind", FT_BOOLEAN, 32, TFS(&tfs_yes_no), CUPS_PRINTER_BIND, NULL, HFILL }}, { &hf_cups_ptype_cover, { "Can cover", "cups.ptype.cover", FT_BOOLEAN, 32, TFS(&tfs_yes_no), CUPS_PRINTER_COVER, NULL, HFILL }}, { &hf_cups_ptype_punch, { "Can punch holes", "cups.ptype.punch", FT_BOOLEAN, 32, TFS(&tfs_yes_no), CUPS_PRINTER_PUNCH, NULL, HFILL }}, { &hf_cups_ptype_collate, { "Can do fast collating", "cups.ptype.collate", FT_BOOLEAN, 32, TFS(&tfs_yes_no), CUPS_PRINTER_COLLATE, NULL, HFILL }}, { &hf_cups_ptype_copies, { "Can do fast copies", "cups.ptype.copies", FT_BOOLEAN, 32, TFS(&tfs_yes_no), CUPS_PRINTER_COPIES, NULL, HFILL }}, { &hf_cups_ptype_staple, { "Can staple", "cups.ptype.staple", FT_BOOLEAN, 32, TFS(&tfs_yes_no), CUPS_PRINTER_STAPLE, NULL, HFILL }}, { &hf_cups_ptype_duplex, { "Can duplex", "cups.ptype.duplex", FT_BOOLEAN, 32, TFS(&tfs_yes_no), CUPS_PRINTER_DUPLEX, NULL, HFILL }}, { &hf_cups_ptype_color, { "Can print color", "cups.ptype.color", FT_BOOLEAN, 32, TFS(&tfs_yes_no), CUPS_PRINTER_COLOR, NULL, HFILL }}, { &hf_cups_ptype_bw, { "Can print black", "cups.ptype.bw", FT_BOOLEAN, 32, TFS(&tfs_yes_no), CUPS_PRINTER_BW, NULL, HFILL }}, { &hf_cups_ptype_remote, { "Remote", "cups.ptype.remote", FT_BOOLEAN, 32, TFS(&tfs_yes_no), CUPS_PRINTER_REMOTE, NULL, HFILL }}, { &hf_cups_ptype_class, { "Class", "cups.ptype.class", FT_BOOLEAN, 32, TFS(&tfs_printer_class), CUPS_PRINTER_CLASS, NULL, HFILL }}, { &hf_cups_state, { "State", "cups.state", FT_UINT8, BASE_HEX, VALS(cups_state_values), 0x0, NULL, HFILL }} }; static gint *ett[] = { &ett_cups, &ett_cups_ptype }; proto_cups = proto_register_protocol( "Common Unix Printing System (CUPS) Browsing Protocol", "CUPS", "cups"); proto_register_field_array(proto_cups, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }
void proto_register_ismacryp (void) { /* A header field is something you can search/filter on. * * We create a structure to register our fields. It consists of an * array of hf_register_info structures, each of which are of the format * {&(field id), {name, abbrev, type, display, strings, bitmask, blurb, HFILL}}. */ static hf_register_info hf[] = { #if 0 { &hf_ismacryp, { "Data", "ismacryp.data", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }}, #endif #if 0 { &hf_ismacryp_length, { "Total Length", "ismacryp.len", FT_UINT16, BASE_DEC, NULL, 0x0, /* length 2 bytes, print as decimal value */ NULL, HFILL }}, #endif { &hf_ismacryp_header, { "AU Header", "ismacryp.header", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }}, #if 0 { &hf_ismacryp_header_length, { "Header Length", "ismacryp.header.length", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, #endif { &hf_ismacryp_au_headers_length, { "AU Headers Length", "ismacryp.au_headers.length", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_ismacryp_header_byte, { "Header Byte", "ismacryp.header.byte", FT_NONE, BASE_NONE, NULL, 0x0, /* 1 byte */ NULL, HFILL }}, #if 0 { &hf_ismacryp_version, { "Version", "ismacryp.version", FT_UINT8, BASE_HEX, NULL, 0x0, /* version 1 byte */ NULL, HFILL }}, #endif { &hf_ismacryp_message, { "Message", "ismacryp.message", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }}, #if 0 { &hf_ismacryp_message_length, { "Message Length", "ismacryp.message.len", FT_UINT16, BASE_DEC, NULL, 0x0, /* length 2 bytes, print as decimal value */ NULL, HFILL }}, #endif #if 0 { &hf_ismacryp_parameter, { "Parameter", "ismacryp.parameter", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }}, #endif #if 0 { &hf_ismacryp_parameter_length, { "Parameter Length", "ismacryp.parameter.len", FT_UINT16, BASE_DEC, NULL, 0x0, /* length 2 bytes, print as decimal value */ NULL, HFILL }}, #endif { &hf_ismacryp_iv, { "IV", "ismacryp.iv", FT_BYTES, BASE_NONE, NULL, 0x0, /* variable length */ NULL, HFILL }}, { &hf_ismacryp_delta_iv, { "Delta IV", "ismacryp.delta_iv", FT_BYTES, BASE_NONE, NULL, 0x0, /* variable length */ NULL, HFILL }}, { &hf_ismacryp_key_indicator, { "Key Indicator", "ismacryp.key_indicator", FT_BYTES, BASE_NONE, NULL, 0x0, /* variable length */ NULL, HFILL }}, #if 0 { &hf_ismacryp_parameter_value, { "Parameter Value", "ismacryp.parameter.value", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }}, #endif { &hf_ismacryp_au_size, { "AU size", "ismacryp.au.size", FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_ismacryp_au_index, { "AU index", "ismacryp.au.index", FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_ismacryp_au_index_delta, { "AU index delta", "ismacryp.au.index_delta", FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_ismacryp_cts_delta, { "CTS delta", "ismacryp.cts_delta", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_ismacryp_cts_flag, { "CTS flag", "ismacryp.cts_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_ismacryp_dts_delta, { "DTS delta", "ismacryp.dts_delta", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_ismacryp_dts_flag, { "DTS flag", "ismacryp.dts_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_ismacryp_rap_flag, { "RAP flag", "ismacryp.rap_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_ismacryp_stream_state, { "Stream state", "ismacryp.stream_state", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_ismacryp_au_is_encrypted, { "AU_is_encrypted flag", "ismacryp.au_is_encrypted", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_ismacryp_slice_start, { "Slice_start flag", "ismacryp.slice_start", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_ismacryp_slice_end, { "Slice_end flag", "ismacryp.slice_end", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_ismacryp_padding_bitcount, { "Padding_bitcount bits", "ismacryp.padding_bitcount", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_ismacryp_padding, { "Padding bits", "ismacryp.padding", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_ismacryp_reserved_bits, { "Reserved bits", "ismacryp.reserved", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_ismacryp_unused_bits, { "Unused bits", "ismacryp.unused", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }} }; static gint *ett[] = { &ett_ismacryp, &ett_ismacryp_header, &ett_ismacryp_header_byte, &ett_ismacryp_message }; static const enum_val_t version_types[] = { {PROTO_TAG_ISMACRYP_11, "ISMACryp v1.1", V11}, {PROTO_TAG_ISMACRYP_20, "ISMACryp v2.0", V20}, {NULL, NULL, -1} }; static const enum_val_t mode_types[] = { {"aac-hbr", "aac-hbr", AAC_HBR_MODE}, {"mpeg4-video", "mpeg4-video", MPEG4_VIDEO_MODE}, {"avc-video", "avc-video", AVC_VIDEO_MODE}, {NULL, NULL, -1} }; module_t *ismacryp_module; proto_ismacryp = proto_register_protocol ("ISMACryp Protocol", "ISMACRYP", "ismacryp"); proto_register_field_array (proto_ismacryp, hf, array_length (hf)); proto_register_subtree_array (ett, array_length (ett)); /* Register our configuration options for ismacryp */ /* this registers our preferences, function proto_reg_handoff_ismacryp is called when preferences are applied */ ismacryp_module = prefs_register_protocol(proto_ismacryp, proto_reg_handoff_ismacryp); prefs_register_uint_preference(ismacryp_module, "dynamic.payload.type", "ISMACryp dynamic payload type", "The dynamic payload type which will be interpreted as ISMACryp", 10, &pref_dynamic_payload_type); prefs_register_enum_preference(ismacryp_module, "version", "ISMACryp version", "ISMACryp version", &version_type, version_types, TRUE); prefs_register_static_text_preference(ismacryp_module, "text_override", "The following option allows the version to be set manually" " and to override the version if detected from RTP payload type:", "The following option allows the version to be set manually" " and to override the version if detected from RTP payload type:"); prefs_register_bool_preference(ismacryp_module, "override_rtp_pt","Override RTP payload type for version", "Indicates whether or not the ISMACryp version deduced" " from RTP payload type, if present, is used or whether the" " version above is used", &override_flag); /* ISMACryp v11 parameters */ prefs_register_static_text_preference(ismacryp_module, "v11_parameters", "ISMACryp v1.1 parameters:", "ISMACryp v1.1 parameters declared in SDP"); prefs_register_uint_preference(ismacryp_module, "iv_length","ISMACrypIVLength (bytes)", "Set the length of the IV in the ISMACryp AU Header in bytes", 10, &iv_length); prefs_register_uint_preference(ismacryp_module, "delta_iv_length","ISMACrypDeltaIVLength (bytes)", "Set the length of the Delta IV in the ISMACryp AU Header in bytes", 10, &delta_iv_length); prefs_register_uint_preference(ismacryp_module, "key_indicator_length","ISMACrypKeyIndicatorLength (bytes)", "Set the length of the Key Indicator in the ISMACryp AU Header in bytes", 10, &key_indicator_length); prefs_register_bool_preference(ismacryp_module, "key_indicator_per_au_flag","ISMACrypKeyIndicatorPerAU (T/F)", "Indicates whether or not the Key Indicator is present in all AU Headers (T/F)", &key_indicator_per_au_flag); prefs_register_bool_preference(ismacryp_module, "selective_encryption","ISMACrypSelectiveEncryption (T/F)", "Indicates whether or not selective encryption is enabled (T/F)", &selective_encryption); /* ISMACryp v20 parameters */ prefs_register_static_text_preference(ismacryp_module, "v20_parameters", "ISMACryp v2.0 parameters:", "ISMACryp v2.0 parameters declared in SDP"); prefs_register_bool_preference(ismacryp_module, "slice_indication","ISMACrypSliceIndication (T/F)", "Indicates whether or not slice start / end is present (T/F)", &slice_indication); prefs_register_bool_preference(ismacryp_module, "padding_indication","ISMACrypPaddingIndication (T/F)", "Indicates whether or not padding information is present (T/F)", &padding_indication); /* RFC3640 mode - ISMACryp v11 */ prefs_register_static_text_preference(ismacryp_module, "codec_modes", "Codec mode selection (RFC3640 for ISMACryp v1.1 only):", "AU parameters set according to RFC3640 mode or user defined"); prefs_register_enum_preference(ismacryp_module, "rfc3640_mode", "RFC3640 mode", "RFC3640 mode", &mode, mode_types, TRUE); /* User defined mode */ prefs_register_bool_preference(ismacryp_module, "user_mode","User mode (T/F)", "Indicates use of user mode instead of RFC3640 modes (T/F)", &pref_user_mode); /* following preference values only used if user mode is selected above */ prefs_register_static_text_preference(ismacryp_module, "user_defined_modes", "Following parameters only valid and used for user mode:", "AU parameters defined by the user"); /* ideally would grey this out or disable this if in user mode */ prefs_register_uint_preference(ismacryp_module, "au_size_length","User mode: SizeLength (bits)", "Set the length of the AU size in the AU Header in bits", 10, &pref_au_size_length); prefs_register_uint_preference(ismacryp_module, "au_index_length","User mode: IndexLength (bits)", "Set the length of the AU index in the AU Header in bits", 10, &pref_au_index_length); prefs_register_uint_preference(ismacryp_module, "au_index_delta_length","User mode: IndexDeltaLength (bits)", "Set the length of the AU delta index in the AU Header in bits", 10, &pref_au_index_delta_length); prefs_register_uint_preference(ismacryp_module, "cts_delta_length","User mode: CTSDeltaLength (bits)", "Set the length of the CTS delta field in the AU Header in bits", 10, &pref_cts_delta_length); prefs_register_uint_preference(ismacryp_module, "dts_delta_length","User mode: DTSDeltaLength (bits)", "Set the length of the DTS delta field in the AU Header in bits", 10, &pref_dts_delta_length); prefs_register_bool_preference(ismacryp_module, "random_access_indication","User mode: RandomAccessIndication (T/F)", "Indicates whether or not the RAP field is present in the AU Header (T/F)", &pref_random_access_indication); prefs_register_uint_preference(ismacryp_module, "stream_state_indication","User mode: StreamStateIndication (number of bits)", "Indicates the number of bits on which the stream state field is encoded" " in the AU Header (bits)", 10, &pref_stream_state_indication); }
void proto_register_netdump(void) { module_t *netdump_module; /* Setup protocol subtree array */ static gint *ett[] = { &ett_netdump }; static hf_register_info hf[] = { { &hf_netdump_magic_number, { "Netdump Magic Number", "netdump.magic", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_netdump_seq_nr, {"Netdump seq number", "netdump.seq_nr", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL} }, { &hf_netdump_command, {"Netdump command", "netdump.command", FT_UINT32, BASE_DEC, VALS(command_names), 0x0, NULL, HFILL} }, { &hf_netdump_from, {"Netdump from val", "netdump.from", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL} }, { &hf_netdump_to, {"Netdump to val", "netdump.to", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL} }, { &hf_netdump_code, {"Netdump code", "netdump.code", FT_UINT32, BASE_DEC, VALS(reply_code_names), 0x0, NULL, HFILL} }, { &hf_netdump_info, {"Netdump info", "netdump.info", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL} }, { &hf_netdump_payload, {"Netdump payload", "netdump.payload", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL} }, { &hf_netdump_version, {"Netdump version", "netdump.version", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL} } }; proto_netdump = proto_register_protocol ( "Netdump Protocol", /* name */ "Netdump", /* short name */ "netdump" /* abbrev */ ); proto_register_field_array(proto_netdump, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); netdump_module = prefs_register_protocol(proto_netdump, proto_reg_handoff_netdump); /* Register a sample port preference */ prefs_register_uint_preference(netdump_module, "udp.port", "Netdump UDP port", "port if other than the default", 10, &gPORT_PREF); }
/* Register the protocol with Wireshark */ void proto_register_cbs(void) { /* Setup list of header fields */ static hf_register_info hf_cbs[] = { { &hf_gsm_cbs_serial_number, { "GSM CBS Serial Number", "gsm_cbs.serial_number", FT_UINT16, BASE_HEX_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_gsm_cbs_message_code, { "GSM CBS Message Code", "gsm_cbs.message_code", FT_UINT16, BASE_DEC_HEX, NULL, 0x3FF0, NULL, HFILL } }, { &hf_gsm_cbs_geographic_scope, { "GSM CBS Geographic Scope", "gsm_cbs.geographic_scope", FT_UINT16, BASE_DEC, VALS(geographic_scope_values), 0xC000, NULL, HFILL } }, { &hf_gsm_cbs_update_number, { "GSM CBS Update Number", "gsm_cbs.update_number", FT_UINT16, BASE_DEC, NULL, 0x000F, NULL, HFILL } }, { &hf_gsm_cbs_message_identifier, { "GSM CBS Message Identifier", "gsm_cbs.message-identifier", FT_UINT16, BASE_DEC_HEX, NULL, 0x00, NULL, HFILL } }, { &hf_gsm_cbs_total_pages, { "GSM CBS Total Pages", "gsm_cbs.total_pages", FT_UINT8, BASE_DEC, NULL, 0x0F, NULL, HFILL } }, { &hf_gsm_cbs_current_page, { "GSM CBS Current Page", "gsm_cbs.current_page", FT_UINT8, BASE_DEC, NULL, 0xF0, NULL, HFILL } }, /* Fragment fields */ { &hf_gsm_cbs_page_overlap, { "page overlap", "gsm_cbs.page.overlap", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "GSM CBS page overlaps with other fragments", HFILL } }, { &hf_gsm_cbs_page_overlap_conflict, { "Conflicting data in page overlap", "gsm_cbs.page.overlap.conflict", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Overlapping pages contained conflicting data", HFILL } }, { &hf_gsm_cbs_page_multiple_tails, { "Multiple final pages found", "gsm_cbs.page.multipletails", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Several copies of the final page were found when reassembling the message", HFILL } }, { &hf_gsm_cbs_page_too_long_fragment, { "Page too long", "gsm_cbs.page.toolongfragment", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Page contained data past end of packet", HFILL } }, { &hf_gsm_cbs_page_error, { "Reassembly error", "gsm_cbs.fragment.error", FT_FRAMENUM, BASE_NONE, NULL, 0x0, "Reassembly error due to illegal fragments", HFILL } }, { &hf_gsm_cbs_page_count, { "Fragment count", "gsm_cbs.fragment.count", FT_UINT32, BASE_DEC, NULL, 0x0, "Count of Page Fragment", HFILL } }, { &hf_gsm_cbs_message_reassembled_in, { "Reassembled in", "gsm_cbs.reassembled.in", FT_FRAMENUM, BASE_NONE, NULL, 0x0, "CBS pages are reassembled in the given packet", HFILL } }, { &hf_gsm_cbs_message_reassembled_length, { "Reassembled message length", "gsm_cbs.reassembled.length", FT_UINT32, BASE_DEC, NULL, 0x0, "The total length of the reassembled message", HFILL } }, { &hf_gsm_cbs_page_num, { "CBS Page Number", "gsm_cbs.page_number", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_gsm_cbs_pages, { "CBS Pages", "gsm_cbs.pages", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_gsm_cbs_page_content, { "CBS Page Content", "gsm_cbs.page_content", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_gsm_cbs_page_content_padding, { "CBS Page Content Padding", "gsm_cbs.page_content_padding", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_gsm_cbs_message_content, { "CBS Message Content", "gsm_cbs.message_content", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } } }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_cbs_msg, &ett_cbs_serial_no, &ett_cbs_coding, &ett_gsm_cbs_page, &ett_gsm_cbs_page_content, &ett_gsm_cbs_pages, }; static ei_register_info ei[] = { { &ei_gsm_cbs_unhandled_encoding, { "gsm_cbs.unhandled_encoding", PI_PROTOCOL, PI_WARN, "Unhandled encoding", EXPFILL }}, }; expert_module_t* expert_cell_broadcast; /* Register the protocol name and description */ proto_cell_broadcast = proto_register_protocol("GSM Cell Broadcast Service", "GSM Cell Broadcast Service", "gsm_cbs"); proto_register_field_array(proto_cell_broadcast, hf_cbs, array_length(hf_cbs)); register_init_routine(gsm_cbs_message_reassembly_init); /* subdissector code */ register_dissector("gsm_cbs", dissect_gsm_cell_broadcast, proto_cell_broadcast); register_dissector("umts_cell_broadcast", dissect_umts_cell_broadcast_message, proto_cell_broadcast); /* subtree array */ proto_register_subtree_array(ett, array_length(ett)); expert_cell_broadcast = expert_register_protocol(proto_cell_broadcast); expert_register_field_array(expert_cell_broadcast, ei, array_length(ei)); }
void proto_register_ax25_nol3(void) { module_t *ax25_nol3_module; /* Setup list of header fields */ #if 0 /* not used ? */ static hf_register_info hf[] = { { &hf_text, { "Text", "ax25_nol3.text", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, }; #endif static hf_register_info hf_dx[] = { { &hf_dx_report, { "DX", "ax25_nol3.dx", FT_STRING, BASE_NONE, NULL, 0x0, "DX cluster", HFILL } }, }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_ax25_nol3, &ett_dx, }; /* Register the protocol name and description */ proto_ax25_nol3 = proto_register_protocol("AX.25 no Layer 3", "AX.25 no L3", "ax25_nol3"); /* Required function calls to register the header fields and subtrees used */ /* proto_register_field_array( proto_ax25_nol3, hf, array_length(hf ) ); */ proto_register_subtree_array( ett, array_length( ett ) ); /* Register preferences module */ ax25_nol3_module = prefs_register_protocol( proto_ax25_nol3, NULL); /* Register any preference */ prefs_register_bool_preference(ax25_nol3_module, "showaprs", "Decode the APRS info field", "Enable decoding of the payload as APRS.", &gPREF_APRS ); prefs_register_bool_preference(ax25_nol3_module, "showcluster", "Decode DX cluster info field", "Enable decoding of the payload as DX cluster info.", &gPREF_DX ); /* Register the sub-protocol name and description */ proto_dx = proto_register_protocol("DX cluster", "DX", "dx"); /* Register the dissector */ register_dissector( "dx", dissect_dx, proto_dx); /* Register the header fields */ proto_register_field_array( proto_dx, hf_dx, array_length( hf_dx ) ); /* Register the subtrees used */ /* proto_register_subtree_array( ett_dx, array_length( ett_dx ) ); */ }
/* Register the protocol with Wireshark */ void proto_register_docsis_mgmt (void) { static hf_register_info hf[] = { {&hf_docsis_mgt_dst_addr, {"Destination Address", "docsis_mgmt.dst", FT_ETHER, BASE_NONE, NULL, 0x0, NULL, HFILL} }, {&hf_docsis_mgt_src_addr, {"Source Address", "docsis_mgmt.src", FT_ETHER, BASE_NONE, NULL, 0x0, NULL, HFILL} }, {&hf_docsis_mgt_msg_len, {"Message Length - DSAP to End (Bytes)", "docsis_mgmt.msglen", FT_UINT16, BASE_DEC, NULL, 0x0, "Message Length", HFILL} }, {&hf_docsis_mgt_dsap, {"DSAP [0x00]", "docsis_mgmt.dsap", FT_UINT8, BASE_HEX, NULL, 0x0, "Destination SAP", HFILL} }, {&hf_docsis_mgt_ssap, {"SSAP [0x00]", "docsis_mgmt.ssap", FT_UINT8, BASE_HEX, NULL, 0x0, "Source SAP", HFILL} }, {&hf_docsis_mgt_control, {"Control [0x03]", "docsis_mgmt.control", FT_UINT8, BASE_HEX, NULL, 0x0, "Control", HFILL} }, {&hf_docsis_mgt_version, {"Version", "docsis_mgmt.version", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL} }, {&hf_docsis_mgt_type, {"Type", "docsis_mgmt.type", FT_UINT8, BASE_DEC, VALS (mgmt_type_vals), 0x0, NULL, HFILL} }, {&hf_docsis_mgt_rsvd, {"Reserved [0x00]", "docsis_mgmt.rsvd", FT_UINT8, BASE_DEC, NULL, 0x0, "Reserved", HFILL} }, }; static gint *ett[] = { &ett_docsis_mgmt, &ett_mgmt_pay, }; docsis_mgmt_dissector_table = register_dissector_table ("docsis_mgmt", "DOCSIS Mac Management", FT_UINT8, BASE_DEC); proto_docsis_mgmt = proto_register_protocol ("DOCSIS Mac Management", "DOCSIS MAC MGMT", "docsis_mgmt"); proto_register_field_array (proto_docsis_mgmt, hf, array_length (hf)); proto_register_subtree_array (ett, array_length (ett)); register_dissector ("docsis_mgmt", dissect_macmgmt, proto_docsis_mgmt); }
void proto_register_fcsp(void) { /* Setup list of header fields See Section 1.6.1 for details*/ static hf_register_info hf[] = { { &hf_auth_proto_ver, { "Protocol Version", "fcsp.version", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_auth_msg_code, { "Message Code", "fcsp.opcode", FT_UINT8, BASE_HEX, VALS(fcauth_msgcode_vals), 0x0, NULL, HFILL}}, { &hf_auth_flags, { "Flags", "fcsp.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_auth_len, { "Packet Length", "fcsp.len", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_auth_tid, { "Transaction Identifier", "fcsp.tid", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_auth_initiator_wwn, { "Initiator Name (WWN)", "fcsp.initwwn", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL}}, { &hf_auth_initiator_name, { "Initiator Name (Unknown Type)", "fcsp.initname", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL}}, { &hf_auth_initiator_name_type, { "Initiator Name Type", "fcsp.initnametype", FT_UINT16, BASE_HEX, VALS(fcauth_name_type_vals), 0x0, NULL, HFILL}}, { &hf_auth_initiator_name_len, { "Initiator Name Length", "fcsp.initnamelen", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_auth_usable_proto, { "Number of Usable Protocols", "fcsp.usableproto", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_auth_rjt_code, { "Reason Code", "fcsp.rjtcode", FT_UINT8, BASE_DEC, VALS(fcauth_rjtcode_vals), 0x0, NULL, HFILL}}, { &hf_auth_rjt_codedet, { "Reason Code Explanation", "fcsp.rjtcodet", FT_UINT8, BASE_DEC, VALS(fcauth_rjtcode_detail_vals), 0x0, NULL, HFILL}}, { &hf_auth_responder_wwn, { "Responder Name (WWN)", "fcsp.rspwwn", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL}}, { &hf_auth_responder_name, { "Responder Name (Unknown Type)", "fcsp.rspname", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL}}, { &hf_auth_responder_name_type, { "Responder Name Type", "fcsp.rspnametype", FT_UINT16, BASE_HEX, VALS(fcauth_name_type_vals), 0x0, NULL, HFILL}}, { &hf_auth_responder_name_len, { "Responder Name Type", "fcsp.rspnamelen", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL}}, #if 0 { &hf_auth_dhchap_hashid, { "Hash Identifier", "fcsp.dhchap.hashid", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL}}, #endif #if 0 { &hf_auth_dhchap_groupid, { "DH Group Identifier", "fcsp.dhchap.groupid", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL}}, #endif { &hf_auth_dhchap_chal_len, { "Challenge Value Length", "fcsp.dhchap.challen", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_auth_dhchap_val_len, { "DH Value Length", "fcsp.dhchap.vallen", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_auth_dhchap_rsp_len, { "Response Value Length", "fcsp.dhchap.rsplen", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_auth_proto_type, { "Authentication Protocol Type", "fcsp.proto", FT_UINT32, BASE_DEC, VALS(fcauth_proto_type_vals), 0x0, NULL, HFILL}}, { &hf_auth_proto_param_len, { "Protocol Parameters Length", "fcsp.protoparamlen", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_auth_dhchap_param_tag, { "Parameter Tag", "fcsp.dhchap.paramtype", FT_UINT16, BASE_HEX, VALS(fcauth_dhchap_param_vals), 0x0, NULL, HFILL}}, { &hf_auth_dhchap_param_len, { "Parameter Length", "fcsp.dhchap.paramlen", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_auth_dhchap_hash_type, { "Hash Algorithm", "fcsp.dhchap.hashtype", FT_UINT32, BASE_DEC, VALS(fcauth_dhchap_hash_algo_vals), 0x0, NULL, HFILL}}, { &hf_auth_dhchap_group_type, { "DH Group", "fcsp.dhchap.dhgid", FT_UINT32, BASE_DEC, VALS(fcauth_dhchap_dhgid_vals), 0x0, NULL, HFILL}}, { &hf_auth_dhchap_chal_value, { "Challenge Value", "fcsp.dhchap.chalval", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL}}, { &hf_auth_dhchap_dhvalue, { "DH Value", "fcsp.dhchap.dhvalue", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL}}, { &hf_auth_dhchap_rsp_value, { "Response Value", "fcsp.dhchap.rspval", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL}}, }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_fcsp, }; /* Register the protocol name and description */ proto_fcsp = proto_register_protocol("Fibre Channel Security Protocol", "FC-SP", "fcsp"); register_dissector("fcsp", dissect_fcsp, proto_fcsp); proto_register_field_array(proto_fcsp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }
void proto_register_macctrl(void) { static hf_register_info hf[] = { { &hf_macctrl_opcode, { "Opcode", "macc.opcode", FT_UINT16, BASE_HEX, VALS(opcode_vals), 0x0, "MAC Control Opcode", HFILL}}, { &hf_macctrl_timestamp, { "Timestamp", "macc.timestamp", FT_UINT32, BASE_DEC, NULL, 0x0, "MAC Control Timestamp", HFILL }}, { &hf_macctrl_pause_time, { "pause_time", "macc.pause_time", FT_UINT16, BASE_DEC, NULL, 0x0, "MAC control PAUSE frame pause_time", HFILL }}, { &hf_macctrl_cbfc_enbv, { "CBFC Class Enable Vector", "macc.cbfc.enbv", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_macctrl_cbfc_enbv_c0, { "C0", "macc.cbfc.enbv.c0", FT_BOOLEAN, 16, NULL, 0x01, NULL, HFILL }}, { &hf_macctrl_cbfc_enbv_c1, { "C1", "macc.cbfc.enbv.c1", FT_BOOLEAN, 16, NULL, 0x02, NULL, HFILL }}, { &hf_macctrl_cbfc_enbv_c2, { "C2", "macc.cbfc.enbv.c2", FT_BOOLEAN, 16, NULL, 0x04, NULL, HFILL }}, { &hf_macctrl_cbfc_enbv_c3, { "C3", "macc.cbfc.enbv.c3", FT_BOOLEAN, 16, NULL, 0x08, NULL, HFILL }}, { &hf_macctrl_cbfc_enbv_c4, { "C4", "macc.cbfc.enbv.c4", FT_BOOLEAN, 16, NULL, 0x10, NULL, HFILL }}, { &hf_macctrl_cbfc_enbv_c5, { "C5", "macc.cbfc.enbv.c5", FT_BOOLEAN, 16, NULL, 0x20, NULL, HFILL }}, { &hf_macctrl_cbfc_enbv_c6, { "C6", "macc.cbfc.enbv.c6", FT_BOOLEAN, 16, NULL, 0x40, NULL, HFILL }}, { &hf_macctrl_cbfc_enbv_c7, { "C7", "macc.cbfc.enbv.c7", FT_BOOLEAN, 16, NULL, 0x80, NULL, HFILL }}, { &hf_macctrl_cbfc_pause_time_c0, { "C0", "macc.cbfc.pause_time.c0", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL }}, { &hf_macctrl_cbfc_pause_time_c1, { "C1", "macc.cbfc.pause_time.c1", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL }}, { &hf_macctrl_cbfc_pause_time_c2, { "C2", "macc.cbfc.pause_time.c2", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL }}, { &hf_macctrl_cbfc_pause_time_c3, { "C3", "macc.cbfc.pause_time.c3", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL }}, { &hf_macctrl_cbfc_pause_time_c4, { "C4", "macc.cbfc.pause_time.c4", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL }}, { &hf_macctrl_cbfc_pause_time_c5, { "C5", "macc.cbfc.pause_time.c5", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL }}, { &hf_macctrl_cbfc_pause_time_c6, { "C6", "macc.cbfc.pause_time.c6", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL }}, { &hf_macctrl_cbfc_pause_time_c7, { "C7", "macc.cbfc.pause_time.c7", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL }}, { &hf_reg_flags, { "Flags", "macc.reg.flags", FT_UINT8, BASE_HEX, VALS(reg_flags_vals), 0x00, NULL, HFILL }}, { &hf_reg_req_grants, { "Pending Grants", "macc.regreq.grants", FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL }}, { &hf_reg_grants, { "Echoed Pending Grants", "macc.reg.grants", FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL }}, { &hf_reg_port, { "Assigned Port (LLID)", "macc.reg.assignedport", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL }}, { &hf_reg_ack_port, { "Echoed Assigned Port (LLID)", "macc.regack.assignedport", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL }}, { &hf_reg_time, { "Sync Time", "macc.reg.synctime", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL }}, { &hf_reg_ack_time, { "Echoed Sync Time", "macc.regack.synctime", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL }} }; static gint *ett[] = { &ett_macctrl, &ett_macctrl_cbfc_enbv, &ett_macctrl_cbfc_pause_times }; proto_macctrl = proto_register_protocol("MAC Control", "MACC", "macc"); proto_register_field_array(proto_macctrl, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }