void proto_register_eapol(void) { static hf_register_info hf[] = { { &hf_eapol_version, { "Version", "eapol.version", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_eapol_type, { "Type", "eapol.type", FT_UINT8, BASE_DEC, VALS(eapol_type_vals), 0x0, NULL, HFILL }}, { &hf_eapol_len, { "Length", "eapol.len", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_eapol_keydes_type, { "Descriptor Type", "eapol.keydes.type", FT_UINT8, BASE_DEC, VALS(eapol_keydes_type_vals), 0x0, "Key Descriptor Type", HFILL }}, { &hf_eapol_keydes_keylen, { "Key Length", "eapol.keydes.keylen", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_eapol_keydes_replay_counter, { "Replay Counter", "eapol.keydes.replay_counter", FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_eapol_keydes_key_iv, { "Key IV", "eapol.keydes.key_iv", FT_BYTES, BASE_NONE, NULL, 0x0, "Key Initialization Vector", HFILL }}, { &hf_eapol_keydes_key_index_keytype, { "Key Type", "eapol.keydes.index.keytype", FT_BOOLEAN, 8, TFS(&keytype_tfs), 0x80, "Key Type (unicast/broadcast)", HFILL }}, { &hf_eapol_keydes_key_index_indexnum, { "Index Number", "eapol.keydes.index.indexnum", FT_UINT8, BASE_DEC, NULL, 0x7F, "Key Index number", HFILL }}, { &hf_eapol_keydes_key_signature, { "Key Signature", "eapol.keydes.key_signature", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_eapol_keydes_key, { "Key", "eapol.keydes.key", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_eapol_wpa_keydes_keyinfo, { "Key Information", "eapol.keydes.key_info", FT_UINT16, BASE_HEX, NULL, 0x0, "WPA key info", HFILL }}, { &hf_eapol_wpa_keydes_keyinfo_keydes_ver, { "Key Descriptor Version", "eapol.keydes.key_info.keydes_ver", FT_UINT16, BASE_DEC, VALS(keydes_ver), KEY_INFO_KEYDES_VER_MASK, "Key Descriptor Version Type", HFILL }}, { &hf_eapol_wpa_keydes_keyinfo_key_type, { "Key Type", "eapol.keydes.key_info.key_type", FT_BOOLEAN, 16, TFS(&tfs_keyinfo_key_type), KEY_INFO_KEY_TYPE_MASK, "Key Type (Pairwise or Group)", HFILL }}, { &hf_eapol_wpa_keydes_keyinfo_key_index, { "Key Index", "eapol.keydes.key_info.key_index", FT_UINT16, BASE_DEC, NULL, KEY_INFO_KEY_INDEX_MASK, "Key Index (0-3) (RSN: Reserved)", HFILL }}, { &hf_eapol_wpa_keydes_keyinfo_install, { "Install flag", "eapol.keydes.key_info.install", FT_BOOLEAN, 16, TFS(&tfs_set_notset), KEY_INFO_INSTALL_MASK, NULL, HFILL }}, { &hf_eapol_wpa_keydes_keyinfo_key_ack, { "Key Ack flag", "eapol.keydes.key_info.key_ack", FT_BOOLEAN, 16, TFS(&tfs_set_notset), KEY_INFO_KEY_ACK_MASK, NULL, HFILL }}, { &hf_eapol_wpa_keydes_keyinfo_key_mic, { "Key MIC flag", "eapol.keydes.key_info.key_mic", FT_BOOLEAN, 16, TFS(&tfs_set_notset), KEY_INFO_KEY_MIC_MASK, NULL, HFILL }}, { &hf_eapol_wpa_keydes_keyinfo_secure, { "Secure flag", "eapol.keydes.key_info.secure", FT_BOOLEAN, 16, TFS(&tfs_set_notset), KEY_INFO_SECURE_MASK, NULL, HFILL }}, { &hf_eapol_wpa_keydes_keyinfo_error, { "Error flag", "eapol.keydes.key_info.error", FT_BOOLEAN, 16, TFS(&tfs_set_notset), KEY_INFO_ERROR_MASK, NULL, HFILL }}, { &hf_eapol_wpa_keydes_keyinfo_request, { "Request flag", "eapol.keydes.key_info.request", FT_BOOLEAN, 16, TFS(&tfs_set_notset), KEY_INFO_REQUEST_MASK, NULL, HFILL }}, { &hf_eapol_wpa_keydes_keyinfo_encr_key_data, { "Encrypted Key Data flag", "eapol.keydes.key_info.encr_key_data", FT_BOOLEAN, 16, TFS(&tfs_set_notset), KEY_INFO_ENCR_KEY_DATA_MASK, NULL, HFILL }}, { &hf_eapol_wpa_keydes_nonce, { "Nonce", "eapol.keydes.nonce", FT_BYTES, BASE_NONE, NULL, 0x0, "WPA Key Nonce", HFILL }}, { &hf_eapol_wpa_keydes_rsc, { "WPA Key RSC", "eapol.keydes.rsc", FT_BYTES, BASE_NONE, NULL, 0x0, "WPA Key Receive Sequence Counter", HFILL }}, { &hf_eapol_wpa_keydes_id, { "WPA Key ID", "eapol.keydes.id", FT_BYTES, BASE_NONE, NULL, 0x0, "WPA Key ID(RSN Reserved)", HFILL }}, { &hf_eapol_wpa_keydes_mic, { "WPA Key MIC", "eapol.keydes.mic", FT_BYTES, BASE_NONE, NULL, 0x0, "WPA Key Message Integrity Check", HFILL }}, { &hf_eapol_wpa_keydes_datalen, { "WPA Key Length", "eapol.keydes.datalen", FT_UINT16, BASE_DEC, NULL, 0x0, "WPA Key Data Length", HFILL }}, { &hf_eapol_wpa_keydes_data, { "WPA Key", "eapol.keydes.data", FT_BYTES, BASE_NONE, NULL, 0x0, "WPA Key Data", HFILL }}, }; static gint *ett[] = { &ett_eapol, &ett_eapol_keydes_data, &ett_keyinfo, &ett_eapol_key_index }; proto_eapol = proto_register_protocol("802.1X Authentication", "EAPOL", "eapol"); proto_register_field_array(proto_eapol, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }
void proto_register_wifi_display(void) { static hf_register_info hf[] = { { &hf_wfd_subelem_id, { "Subelement ID", "wifi_display.subelem.id", FT_UINT8, BASE_DEC, VALS(wfd_subelem_ids), 0, NULL, HFILL }}, { &hf_wfd_subelem_len, { "Length", "wifi_display.subelem.length", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_wfd_subelem_dev_info_type, { "Device type", "wifi_display.subelem.dev_info.type", FT_UINT16, BASE_DEC, VALS(wfd_dev_info_types), 0x0003, NULL, HFILL }}, { &hf_wfd_subelem_dev_info_coupled_sink_source, { "Coupled sink operation supported by WFD source", "wifi_display.subelem.dev_info.coupled_sink_by_source", FT_BOOLEAN, 16, NULL, 0x0004, NULL, HFILL }}, { &hf_wfd_subelem_dev_info_coupled_sink_sink, { "Coupled sink operation supported by WFD sink", "wifi_display.subelem.dev_info.coupled_sink_by_sink", FT_BOOLEAN, 16, NULL, 0x0008, NULL, HFILL }}, { &hf_wfd_subelem_dev_info_available, { "Available for WFD Session", "wifi_display.subelem.dev_info.available", FT_UINT16, BASE_DEC, VALS(wfd_dev_info_avail), 0x0030, NULL, HFILL }}, { &hf_wfd_subelem_dev_info_wsd, { "WFD Service Discovery", "wifi_display.subelem.dev_info.wsd", FT_BOOLEAN, 16, NULL, 0x0040, NULL, HFILL }}, { &hf_wfd_subelem_dev_info_pc, { "Preferred Connectivity", "wifi_display.subelem.dev_info.pc", FT_UINT16, BASE_DEC, VALS(wfd_dev_info_pc), 0x0080, NULL, HFILL }}, { &hf_wfd_subelem_dev_info_content_protection, { "Content Protection using HDCP2.0", "wifi_display.subelem.dev_info.content_protection", FT_BOOLEAN, 16, NULL, 0x0100, NULL, HFILL }}, { &hf_wfd_subelem_dev_info_time_sync, { "Time Synchronization using 802.1AS", "wifi_display.subelem.dev_info.time_sync", FT_BOOLEAN, 16, NULL, 0x0200, NULL, HFILL }}, { &hf_wfd_subelem_dev_info_audio_unsupp_pri_sink, { "Audio un-supported at Primary sink", "wifi_display.subelem.session.audio_unsupp_pri_sink", FT_BOOLEAN, 16, NULL, 0x0400, NULL, HFILL }}, { &hf_wfd_subelem_dev_info_audio_only_supp_source, { "Audio only support af WFD source", "wifi_display.subelem.session.audio_only_supp_source", FT_BOOLEAN, 16, NULL, 0x0800, NULL, HFILL }}, { &hf_wfd_subelem_dev_info_tdls_persistent_group, { "TDLS Persistent Group", "wifi_display.subelem.session.tdls_persistent_group", FT_BOOLEAN, 16, NULL, 0x1000, NULL, HFILL }}, { &hf_wfd_subelem_dev_info_tdls_persistent_group_reinvoke, { "TDLS Persistent Group Re-invoke", "wifi_display.subelem.session.tdls_persistent_group_reinvoke", FT_BOOLEAN, 16, NULL, 0x2000, NULL, HFILL }}, { &hf_wfd_subelem_dev_info_reserved, { "Reserved", "wifi_display.subelem.session.reserved", FT_UINT16, BASE_DEC, NULL, 0xc000, NULL, HFILL }}, { &hf_wfd_subelem_dev_info_control_port, { "Session Management Control Port", "wifi_display.subelem.dev_info.control_port", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_wfd_subelem_dev_info_max_throughput, { "WFD Device Maximum Throughput (Mbps)", "wifi_display.subelem.dev_info.max_throughput", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_wfd_subelem_assoc_bssid, { "Associated BSSID", "wifi_display.subelem.assoc_bssid.bssid", FT_ETHER, BASE_NONE, NULL, 0, NULL, HFILL }}, { &hf_wfd_subelem_coupled_sink_status_bitmap, { "Coupled Sink Status bitmap", "wifi_display.subelem.coupled_sink.status", FT_UINT8, BASE_DEC, VALS(wfd_coupled_sink_status_bitmap), 0x03, NULL, HFILL }}, { &hf_wfd_subelem_coupled_sink_reserved, { "Reserved", "wifi_display.subelem.coupled_sink.reserved", FT_UINT8, BASE_DEC, NULL, 0xfc, NULL, HFILL }}, { &hf_wfd_subelem_coupled_sink_mac_addr, { "Coupled Sink MAC Address", "wifi_display.subelem.coupled_sink.mac_addr", FT_ETHER, BASE_NONE, NULL, 0, NULL, HFILL }}, { &hf_wfd_subelem_session_descr_len, { "Descriptor length", "wifi_display.subelem.session.descr_len", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_wfd_subelem_session_dev_addr, { "Device address", "wifi_display.subelem.session.device_address", FT_ETHER, BASE_NONE, NULL, 0, NULL, HFILL }}, { &hf_wfd_subelem_session_assoc_bssid, { "Associated BSSID", "wifi_display.subelem.session.associated_bssid", FT_ETHER, BASE_NONE, NULL, 0, NULL, HFILL }}, { &hf_wfd_subelem_session_dev_info_type, { "Device type", "wifi_display.subelem.session.type", FT_UINT16, BASE_DEC, VALS(wfd_dev_info_types), 0x0003, NULL, HFILL }}, { &hf_wfd_subelem_session_dev_info_coupled_sink_source, { "Coupled sink operation supported by WFD source", "wifi_display.subelem.session.coupled_sink_by_source", FT_BOOLEAN, 16, NULL, 0x0004, NULL, HFILL }}, { &hf_wfd_subelem_session_dev_info_coupled_sink_sink, { "Coupled sink operation supported by WFD sink", "wifi_display.subelem.session.coupled_sink_by_sink", FT_BOOLEAN, 16, NULL, 0x0008, NULL, HFILL }}, { &hf_wfd_subelem_session_dev_info_available, { "Available for WFD Session", "wifi_display.subelem.session.available", FT_UINT16, BASE_DEC, VALS(wfd_dev_info_avail), 0x0030, NULL, HFILL }}, { &hf_wfd_subelem_session_dev_info_wsd, { "WFD Service Discovery", "wifi_display.subelem.session.wsd", FT_BOOLEAN, 16, NULL, 0x0040, NULL, HFILL }}, { &hf_wfd_subelem_session_dev_info_pc, { "Preferred Connectivity", "wifi_display.subelem.session.pc", FT_UINT16, BASE_DEC, VALS(wfd_dev_info_pc), 0x0080, NULL, HFILL }}, { &hf_wfd_subelem_session_dev_info_content_protection, { "Content Protection using HDCP2.0", "wifi_display.subelem.session.content_protection", FT_BOOLEAN, 16, NULL, 0x0100, NULL, HFILL }}, { &hf_wfd_subelem_session_dev_info_time_sync, { "Time Synchronization using 802.1AS", "wifi_display.subelem.session.time_sync", FT_BOOLEAN, 16, NULL, 0x0200, NULL, HFILL }}, { &hf_wfd_subelem_session_dev_info_audio_unsupp_pri_sink, { "Audio un-supported at Primary sink", "wifi_display.subelem.session.audio_unsupp_pri_sink", FT_BOOLEAN, 16, NULL, 0x0400, NULL, HFILL }}, { &hf_wfd_subelem_session_dev_info_audio_only_supp_source, { "Audio only support af WFD source", "wifi_display.subelem.session.audio_only_supp_source", FT_BOOLEAN, 16, NULL, 0x0800, NULL, HFILL }}, { &hf_wfd_subelem_session_dev_info_tdls_persistent_group, { "TDLS Persistent Group", "wifi_display.subelem.session.tdls_persistent_group", FT_BOOLEAN, 16, NULL, 0x1000, NULL, HFILL }}, { &hf_wfd_subelem_session_dev_info_tdls_persistent_group_reinvoke, { "TDLS Persistent Group Re-invoke", "wifi_display.subelem.session.tdls_persistent_group_reinvoke", FT_BOOLEAN, 16, NULL, 0x2000, NULL, HFILL }}, { &hf_wfd_subelem_session_dev_info_reserved, { "Reserved", "wifi_display.subelem.session.reserved", FT_UINT16, BASE_DEC, NULL, 0xc000, NULL, HFILL }}, { &hf_wfd_subelem_session_dev_info_max_throughput, { "WFD Device Maximum Throughput (Mbps)", "wifi_display.subelem.session.max_throughput", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_wfd_subelem_session_coupled_sink_status_bitmap, { "Coupled Sink Status bitmap", "wifi_display.subelem.session.coupled_sink_status", FT_UINT8, BASE_DEC, VALS(wfd_coupled_sink_status_bitmap), 0x03, NULL, HFILL }}, { &hf_wfd_subelem_session_coupled_sink_reserved, { "Reserved", "wifi_display.subelem.session.coupled_sink.reserved", FT_UINT8, BASE_DEC, NULL, 0xfc, NULL, HFILL }}, { &hf_wfd_subelem_session_coupled_sink_addr, { "Coupled peer sink address", "wifi_display.subelem.session.coupled_peer_sink_addr", FT_ETHER, BASE_NONE, NULL, 0, NULL, HFILL }}, { &hf_wfd_subelem_session_extra_info, { "Extra info in the end of descriptor", "wifi_display.subelem.session.extra_info", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, { &hf_wfd_subelem_ext_capab, { "WFD Extended Capability Bitmap", "wifi_display.subelem.ext_capab", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_wfd_subelem_ext_capab_uibc, { "User Input Back Channel(UIBC)", "wifi_display.subelem.ext_capab.uibc", FT_BOOLEAN, 16, TFS (&tfs_supported_not_supported), 0x0001, NULL, HFILL }}, { &hf_wfd_subelem_ext_capab_i2c_read_write, { "I2C Read/Write", "wifi_display.subelem.ext_capab.i2c_read_write", FT_BOOLEAN, 16, TFS (&tfs_supported_not_supported), 0x0002, NULL, HFILL }}, { &hf_wfd_subelem_ext_capab_preferred_display_mode, { "Preferred Display Mode", "wifi_display.subelem.ext_capab.preferred_display_mode", FT_BOOLEAN, 16, TFS (&tfs_supported_not_supported), 0x0004, NULL, HFILL }}, { &hf_wfd_subelem_ext_capab_standby_resume_control, { "Standby and Resume Control", "wifi_display.subelem.ext_capab.standby_resume_control", FT_BOOLEAN, 16, TFS (&tfs_supported_not_supported), 0x008, NULL, HFILL }}, { &hf_wfd_subelem_ext_capab_tdls_persistent, { "TDLS Persistent", "wifi_display.subelem.ext_capab.tdls_persistent", FT_BOOLEAN, 16, TFS (&tfs_supported_not_supported), 0x0010, NULL, HFILL }}, { &hf_wfd_subelem_ext_capab_tdls_persistent_bssid, { "TDLS Persistent BSSID", "wifi_display.subelem.ext_capab.tdls_persistent_bssid", FT_BOOLEAN, 16, TFS (&tfs_supported_not_supported), 0x0020, NULL, HFILL }}, { &hf_wfd_subelem_ext_capab_reserved, { "Reserved", "wifi_display.subelem.ext_capab.reserved", FT_UINT16, BASE_HEX, NULL, 0xffc0, NULL, HFILL }}, { &hf_wfd_subelem_alt_mac_addr, { "Alternative MAC Address", "wifi_display.subelem.alt_mac_addr", FT_ETHER, BASE_NONE, NULL, 0, NULL, HFILL }}, }; static gint *ett[] = { &ett_wfd_subelem, &ett_wfd_dev_info_descr }; static ei_register_info ei[] = { { &ei_wfd_subelem_len_invalid, { "wifi_display.subelem.length.invalid", PI_MALFORMED, PI_ERROR, "Subelement length invalid", EXPFILL }}, { &ei_wfd_subelem_session_descr_invalid, { "wifi_display.subelem.session.descr_invalid", PI_MALFORMED, PI_ERROR, "Invalid WFD Device Info Descriptor", EXPFILL }}, { &ei_wfd_subelem_id, { "wifi_display.subelem.id.unknown", PI_PROTOCOL, PI_WARN, "Unknown subelement payload", EXPFILL }}, }; expert_module_t* expert_wifi_display; proto_wifi_display = proto_register_protocol("Wi-Fi Display", "WFD", "wifi_display"); proto_register_field_array(proto_wifi_display, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); expert_wifi_display = expert_register_protocol(proto_wifi_display); expert_register_field_array(expert_wifi_display, ei, array_length(ei)); }
void proto_register_brdwlk (void) { /* Setup list of header fields See Section 1.6.1 for details*/ static hf_register_info hf[] = { { &hf_brdwlk_sof, { "SOF", "brdwlk.sof", FT_UINT8, BASE_HEX, VALS (brdwlk_sof_vals), 0xF0, NULL, HFILL } }, { &hf_brdwlk_eof, { "EOF", "brdwlk.eof", FT_UINT8, BASE_HEX, VALS (brdwlk_eof_vals), 0x0F, NULL, HFILL } }, { &hf_brdwlk_error, { "Error", "brdwlk.error", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_brdwlk_pktcnt, { "Packet Count", "brdwlk.pktcnt", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_brdwlk_drop, { "Packet Dropped", "brdwlk.drop", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_brdwlk_vsan, { "VSAN", "brdwlk.vsan", FT_UINT16, BASE_DEC, NULL, 0xFFF, NULL, HFILL } }, { &hf_brdwlk_plen, { "Original Packet Length", "brdwlk.plen", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_brdwlk_error_plp, { "Packet Length Present", "brdwlk.error.plp", FT_BOOLEAN, 8, TFS(&tfs_error_plp), 0x01, NULL, HFILL } }, { &hf_brdwlk_error_ef, { "Empty Frame", "brdwlk.error.ef", FT_BOOLEAN, 8, TFS(&tfs_error_ef), 0x02, NULL, HFILL } }, { &hf_brdwlk_error_nd, { "No Data", "brdwlk.error.nd", FT_BOOLEAN, 8, TFS(&tfs_error_nd), 0x04, NULL, HFILL } }, { &hf_brdwlk_error_tr, { "Truncated", "brdwlk.error.tr", FT_BOOLEAN, 8, TFS(&tfs_error_tr), 0x08, NULL, HFILL } }, { &hf_brdwlk_error_badcrc, { "CRC", "brdwlk.error.crc", FT_BOOLEAN, 8, TFS(&tfs_error_crc), 0x10, NULL, HFILL } }, { &hf_brdwlk_error_ff, { "Fifo Full", "brdwlk.error.ff", FT_BOOLEAN, 8, TFS(&tfs_error_ff), 0x20, NULL, HFILL } }, { &hf_brdwlk_error_jumbo, { "Jumbo FC Frame", "brdwlk.error.jumbo", FT_BOOLEAN, 8, TFS(&tfs_error_jumbo), 0x40, NULL, HFILL } }, { &hf_brdwlk_error_ctrl, { "Ctrl Char Inside Frame", "brdwlk.error.ctrl", FT_BOOLEAN, 8, TFS(&tfs_error_ctrl), 0x80, NULL, HFILL } }, }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_brdwlk, &ett_brdwlk_error, }; /* Register the protocol name and description */ proto_brdwlk = proto_register_protocol("Boardwalk", "Boardwalk", "brdwlk"); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_brdwlk, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); register_init_routine(&brdwlk_init); }
/* registration with the filtering engine */ void proto_register_lwapp(void) { static hf_register_info hf[] = { { &hf_lwapp_version, { "Version", "lwapp.version", FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL }}, { &hf_lwapp_slotid, { "slotId","lwapp.slotId", FT_UINT24, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_lwapp_flags_type, { "Type", "lwapp.flags.type", FT_BOOLEAN, 8, TFS(&lwapp_flags_type), LWAPP_FLAGS_T, NULL, HFILL }}, { &hf_lwapp_flags_fragment, { "Fragment", "lwapp.flags.fragment", FT_BOOLEAN, 8, TFS(&lwapp_set_truth), LWAPP_FLAGS_F, NULL, HFILL }}, { &hf_lwapp_flags_fragment_type, { "Fragment Type", "lwapp.flags.fragmentType", FT_BOOLEAN, 8, TFS(&lwapp_set_truth), LWAPP_FLAGS_FT, NULL, HFILL }}, { &hf_lwapp_fragment_id, { "Fragment Id","lwapp.fragmentId", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_lwapp_length, { "Length","lwapp.Length", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_lwapp_rssi, { "RSSI","lwapp.rssi", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_lwapp_snr, { "SNR","lwapp.snr", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_lwapp_control, { "Control Data (not dissected yet)","lwapp.control", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_lwapp_control_mac, { "AP Identity", "lwapp.apid", FT_ETHER, BASE_NONE, NULL, 0x0, "Access Point Identity", HFILL }}, { &hf_lwapp_control_type, { "Control Type", "lwapp.control.type", FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL }}, { &hf_lwapp_control_seq_no, { "Control Sequence Number", "lwapp.control.seqno", FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL }}, { &hf_lwapp_control_length, { "Control Length","lwapp.control.length", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, }; static gint *ett[] = { &ett_lwapp_l3, &ett_lwapp, &ett_lwapp_control, &ett_lwapp_flags }; module_t *lwapp_module; proto_lwapp = proto_register_protocol ("LWAPP Encapsulated Packet", "LWAPP", "lwapp"); proto_lwapp_l3 = proto_register_protocol ("LWAPP Layer 3 Packet", "LWAPP-L3", "lwapp-l3"); proto_lwapp_control = proto_register_protocol ("LWAPP Control Message", "LWAPP-CNTL", "lwapp-cntl"); proto_register_field_array(proto_lwapp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); lwapp_module = prefs_register_protocol(proto_lwapp, NULL); prefs_register_bool_preference(lwapp_module,"swap_fc","Swap Frame Control", "Swap frame control bytes (needed for some APs", &swap_frame_control); } /* proto_register_diameter */
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); }
/* Register the protocol with Wireshark */ void proto_register_wtp(void) { /* Setup list of header fields */ static hf_register_info hf[] = { { &hf_wtp_header_sub_pdu_size, { "Sub PDU size", "wtp.sub_pdu_size", FT_UINT16, BASE_DEC, NULL, 0x0, "Size of Sub-PDU (bytes)", HFILL } }, { &hf_wtp_header_flag_continue, { "Continue Flag", "wtp.continue_flag", FT_BOOLEAN, 8, TFS( &continue_truth ), 0x80, NULL, HFILL } }, { &hf_wtp_header_pdu_type, { "PDU Type", "wtp.pdu_type", FT_UINT8, BASE_HEX, VALS( vals_wtp_pdu_type ), 0x78, NULL, HFILL } }, { &hf_wtp_header_flag_Trailer, { "Trailer Flags", "wtp.trailer_flags", FT_UINT8, BASE_HEX, VALS( vals_transaction_trailer ), 0x06, NULL, HFILL } }, { &hf_wtp_header_flag_RID, { "Re-transmission Indicator", "wtp.RID", FT_BOOLEAN, 8, TFS( &RID_truth ), 0x01, NULL, HFILL } }, { &hf_wtp_header_flag_TID_response, { "TID Response", "wtp.TID.response", FT_BOOLEAN, 16, TFS( &tid_response_truth ), 0x8000, NULL, HFILL } }, { &hf_wtp_header_flag_TID, { "Transaction ID", "wtp.TID", FT_UINT16, BASE_HEX, NULL, 0x7FFF, NULL, HFILL } }, { &hf_wtp_header_Inv_version, { "Version", "wtp.header.version", FT_UINT8, BASE_HEX, VALS( vals_version ), 0xC0, NULL, HFILL } }, { &hf_wtp_header_Inv_flag_TIDNew, { "TIDNew", "wtp.header.TIDNew", FT_BOOLEAN, 8, TFS( &TIDNew_truth ), 0x20, NULL, HFILL } }, { &hf_wtp_header_Inv_flag_UP, { "U/P flag", "wtp.header.UP", FT_BOOLEAN, 8, TFS( &UP_truth ), 0x10, NULL, HFILL } }, { &hf_wtp_header_Inv_Reserved, { "Reserved", "wtp.inv.reserved", FT_UINT8, BASE_HEX, NULL, 0x0C, NULL, HFILL } }, { &hf_wtp_header_Inv_TransactionClass, { "Transaction Class", "wtp.inv.transaction_class", FT_UINT8, BASE_HEX, VALS( vals_transaction_classes ), 0x03, NULL, HFILL } }, { &hf_wtp_header_Ack_flag_TVETOK, { "Tve/Tok flag", "wtp.ack.tvetok", FT_BOOLEAN, 8, TFS( &TVETOK_truth ), 0x04, NULL, HFILL } }, { &hf_wtp_header_Abort_type, { "Abort Type", "wtp.abort.type", FT_UINT8, BASE_HEX, VALS ( vals_abort_type ), 0x07, NULL, HFILL } }, { &hf_wtp_header_Abort_reason_provider, { "Abort Reason", "wtp.abort.reason.provider", FT_UINT8, BASE_HEX, VALS ( vals_abort_reason_provider ), 0x00, NULL, HFILL } }, /* Assume WSP is the user and use its reason codes */ { &hf_wtp_header_Abort_reason_user, { "Abort Reason", "wtp.abort.reason.user", FT_UINT8, BASE_HEX|BASE_EXT_STRING, &vals_wsp_reason_codes_ext, 0x00, NULL, HFILL } }, { &hf_wtp_header_sequence_number, { "Packet Sequence Number", "wtp.header.sequence", FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_wtp_header_missing_packets, { "Missing Packets", "wtp.header.missing_packets", FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_wtp_header_variable_part, { "Header: Variable part", "wtp.header_variable_part", FT_BYTES, BASE_NONE, NULL, 0x0, "Variable part of the header", HFILL } }, { &hf_wtp_data, { "Data", "wtp.header_data", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_wtp_tpi_type, { "TPI", "wtp.tpi", FT_UINT8, BASE_HEX, VALS(vals_tpi_type), 0x00, "Identification of the Transport Information Item", HFILL } }, { &hf_wtp_tpi_psn, { "Packet sequence number", "wtp.tpi.psn", FT_UINT8, BASE_DEC, NULL, 0x00, "Sequence number of this packet", HFILL } }, { &hf_wtp_tpi_opt, { "Option", "wtp.tpi.opt", FT_UINT8, BASE_HEX, VALS(vals_tpi_opt), 0x00, "The given option for this TPI", HFILL } }, { &hf_wtp_tpi_optval, { "Option Value", "wtp.tpi.opt.val", FT_NONE, BASE_NONE, NULL, 0x00, "The value that is supplied with this option", HFILL } }, { &hf_wtp_tpi_info, { "Information", "wtp.tpi.info", FT_NONE, BASE_NONE, NULL, 0x00, "The information being send by this TPI", HFILL } }, /* Fragment fields */ { &hf_wtp_fragment_overlap, { "Fragment overlap", "wtp.fragment.overlap", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Fragment overlaps with other fragments", HFILL } }, { &hf_wtp_fragment_overlap_conflict, { "Conflicting data in fragment overlap", "wtp.fragment.overlap.conflict", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Overlapping fragments contained conflicting data", HFILL } }, { &hf_wtp_fragment_multiple_tails, { "Multiple tail fragments found", "wtp.fragment.multipletails", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Several tails were found when defragmenting the packet", HFILL } }, { &hf_wtp_fragment_too_long_fragment, { "Fragment too long", "wtp.fragment.toolongfragment", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Fragment contained data past end of packet", HFILL } }, { &hf_wtp_fragment_error, { "Defragmentation error", "wtp.fragment.error", FT_FRAMENUM, BASE_NONE, NULL, 0x0, "Defragmentation error due to illegal fragments", HFILL } }, { &hf_wtp_fragment_count, { "Fragment count", "wtp.fragment.count", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_wtp_reassembled_in, { "Reassembled in", "wtp.reassembled.in", FT_FRAMENUM, BASE_NONE, NULL, 0x0, "WTP fragments are reassembled in the given packet", HFILL } }, { &hf_wtp_reassembled_length, { "Reassembled WTP length", "wtp.reassembled.length", FT_UINT32, BASE_DEC, NULL, 0x0, "The total length of the reassembled payload", HFILL } }, { &hf_wtp_fragment, { "WTP Fragment", "wtp.fragment", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_wtp_fragments, { "WTP Fragments", "wtp.fragments", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_wtp, &ett_wtp_sub_pdu_tree, &ett_header, &ett_tpilist, &ett_wsp_fragments, &ett_wtp_fragment, }; /* Register the protocol name and description */ proto_wtp = proto_register_protocol( "Wireless Transaction Protocol", /* protocol name for use by wireshark */ "WTP", /* short version of name */ "wtp" /* Abbreviated protocol name, should Match IANA < URL:http://www.iana.org/assignments/port-numbers/ > */ ); /* Required calls to register the header fields and subtrees used */ proto_register_field_array(proto_wtp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); register_dissector("wtp-wtls", dissect_wtp_fromwtls, proto_wtp); register_dissector("wtp-udp", dissect_wtp_fromudp, proto_wtp); register_init_routine(wtp_defragment_init); }
void ipmi_register_storage(gint proto_ipmi) { static hf_register_info hf[] = { { &hf_ipmi_stor_10_fruid, { "FRU ID", "ipmi.st10.fruid", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_10_size, { "FRU Inventory area size", "ipmi.st10.size", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_10_access, { "Device is accessed", "ipmi.st10.access", FT_BOOLEAN, 8, TFS(&tfs_10_access), 0x01, NULL, HFILL }}, { &hf_ipmi_stor_11_fruid, { "FRU ID", "ipmi.st11.fruid", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_11_offset, { "Offset to read", "ipmi.st11.offset", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_11_count, { "Count to read", "ipmi.st11.count", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_11_ret_count, { "Returned count", "ipmi.st11.ret_count", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_11_data, { "Requested data", "ipmi.st11.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_12_fruid, { "FRU ID", "ipmi.st12.fruid", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_12_offset, { "Offset to read", "ipmi.st12.offset", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_12_data, { "Requested data", "ipmi.st12.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_12_ret_count, { "Returned count", "ipmi.st12.ret_count", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_20_sdr_version, { "SDR Version", "ipmi.st20.sdr_version", FT_UINT8, BASE_CUSTOM, ipmi_fmt_version, 0, NULL, HFILL }}, { &hf_ipmi_stor_20_rec_count, { "Record Count", "ipmi.st20.rec_count", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_20_free_space, { "Free Space", "ipmi.st20.free_space", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_20_ts_add, { "Most recent addition timestamp", "ipmi.st20.ts_add", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_20_ts_erase, { "Most recent erase timestamp", "ipmi.st20.ts_erase", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_20_op_overflow, { "Overflow", "ipmi.st20.op_overflow", FT_BOOLEAN, 8, NULL, 0x80, NULL, HFILL }}, { &hf_ipmi_stor_20_op_update, { "SDR Repository Update", "ipmi.st20.op_update", FT_UINT8, BASE_HEX, vals_20_update, 0x60, NULL, HFILL }}, { &hf_ipmi_stor_20_op_delete, { "Delete SDR", "ipmi.st20.op_delete", FT_BOOLEAN, 8, NULL, 0x08, NULL, HFILL }}, { &hf_ipmi_stor_20_op_partial_add, { "Partial Add SDR", "ipmi.st20.op_partial_add", FT_BOOLEAN, 8, NULL, 0x04, NULL, HFILL }}, { &hf_ipmi_stor_20_op_reserve, { "Reserve SDR Repository", "ipmi.st20.op_reserve", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL }}, { &hf_ipmi_stor_20_op_allocinfo, { "Get SDR Repository Allocation Info", "ipmi.st20.op_allocinfo", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL }}, { &hf_ipmi_stor_21_units, { "Number of allocation units", "ipmi.st21.units", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_21_size, { "Allocation unit size", "ipmi.st21.size", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_21_free, { "Number of free units", "ipmi.st21.free", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_21_largest, { "Largest free block (in units)", "ipmi.st21.largest", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_21_maxrec, { "Maximum record size (in units)", "ipmi.st21.maxrec", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_22_rsrv_id, { "Reservation ID", "ipmi.st22.rsrv_id", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_23_rsrv_id, { "Reservation ID", "ipmi.st23.rsrv_id", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_23_rec_id, { "Record ID", "ipmi.st23.rec_id", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_23_offset, { "Offset into record", "ipmi.st23.offset", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_23_count, { "Bytes to read", "ipmi.st23.count", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_23_next, { "Next Record ID", "ipmi.st23.next", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_23_data, { "Record Data", "ipmi.st23.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_24_data, { "SDR Data", "ipmi.st24.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_24_added_rec_id, { "Record ID for added record", "ipmi.st23.added_rec_id", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_25_rsrv_id, { "Reservation ID", "ipmi.st25.rsrv_id", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_25_rec_id, { "Record ID", "ipmi.st25.rec_id", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_25_offset, { "Offset into record", "ipmi.st25.offset", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_25_inprogress, { "In progress", "ipmi.st25.inprogress", FT_UINT8, BASE_HEX, vals_25_inprogress, 0x0f, NULL, HFILL }}, { &hf_ipmi_stor_25_data, { "SDR Data", "ipmi.st25.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_25_added_rec_id, { "Record ID for added record", "ipmi.st25.added_rec_id", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, #if 0 { &hf_ipmi_stor_26_rsrv_id, { "Reservation ID", "ipmi.st26.rsrv_id", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_26_rec_id, { "Record ID", "ipmi.st26.rec_id", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, #endif { &hf_ipmi_stor_26_del_rec_id, { "Deleted Record ID", "ipmi.st26.del_rec_id", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_27_rsrv_id, { "Reservation ID", "ipmi.st27.rsrv_id", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_27_clr, { "Confirmation (should be CLR)", "ipmi.st27.clr", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_27_action, { "Action", "ipmi.st27.action", FT_UINT8, BASE_HEX, vals_27_action, 0, NULL, HFILL }}, { &hf_ipmi_stor_27_status, { "Erasure Status", "ipmi.st27.status", FT_UINT8, BASE_HEX, vals_27_status, 0x0f, NULL, HFILL }}, { &hf_ipmi_stor_28_time, { "Time", "ipmi.st28.time", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_29_time, { "Time", "ipmi.st29.time", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_2c_init_agent, { "Initialization agent", "ipmi.st2c.init_agent", FT_BOOLEAN, 8, TFS(&tfs_2c_init_agent), 0x01, NULL, HFILL }}, { &hf_ipmi_stor_2c_init_state, { "Initialization", "ipmi.st2c.init_state", FT_BOOLEAN, 8, TFS(&tfs_2c_init_state), 0x01, NULL, HFILL }}, { &hf_ipmi_stor_40_sel_version, { "SEL Version", "ipmi.st40.sel_version", FT_UINT8, BASE_CUSTOM, ipmi_fmt_version, 0, NULL, HFILL }}, { &hf_ipmi_stor_40_entries, { "Entries", "ipmi.st40.rec_count", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_40_free_space, { "Free Space", "ipmi.st40.free_space", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_40_ts_add, { "Most recent addition timestamp", "ipmi.st40.ts_add", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_40_ts_erase, { "Most recent erase timestamp", "ipmi.st40.ts_erase", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_40_op_overflow, { "Overflow", "ipmi.st40.op_overflow", FT_BOOLEAN, 8, NULL, 0x80, NULL, HFILL }}, { &hf_ipmi_stor_40_op_delete, { "Delete SEL", "ipmi.st40.op_delete", FT_BOOLEAN, 8, NULL, 0x08, NULL, HFILL }}, { &hf_ipmi_stor_40_op_partial_add, { "Partial Add SEL Entry", "ipmi.st40.op_partial_add", FT_BOOLEAN, 8, NULL, 0x04, NULL, HFILL }}, { &hf_ipmi_stor_40_op_reserve, { "Reserve SEL", "ipmi.st40.op_reserve", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL }}, { &hf_ipmi_stor_40_op_allocinfo, { "Get SEL Allocation Info", "ipmi.st40.op_allocinfo", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL }}, { &hf_ipmi_stor_41_units, { "Number of allocation units", "ipmi.st41.units", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_41_size, { "Allocation unit size", "ipmi.st41.size", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_41_free, { "Number of free units", "ipmi.st41.free", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_41_largest, { "Largest free block (in units)", "ipmi.st41.largest", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_41_maxrec, { "Maximum record size (in units)", "ipmi.st41.maxrec", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_42_rsrv_id, { "Reservation ID", "ipmi.st42.rsrv_id", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_43_rsrv_id, { "Reservation ID", "ipmi.st43.rsrv_id", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_43_rec_id, { "Record ID", "ipmi.st43.rec_id", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_43_offset, { "Offset into record", "ipmi.st43.offset", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_43_count, { "Bytes to read", "ipmi.st43.count", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_43_next, { "Next Record ID", "ipmi.st43.next", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_43_data, { "Record Data", "ipmi.st43.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_44_data, { "SDR Data", "ipmi.st44.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_44_added_rec_id, { "Record ID for added record", "ipmi.st43.added_rec_id", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_45_rsrv_id, { "Reservation ID", "ipmi.st45.rsrv_id", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_45_rec_id, { "Record ID", "ipmi.st45.rec_id", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_45_offset, { "Offset into record", "ipmi.st45.offset", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_45_inprogress, { "In progress", "ipmi.st45.inprogress", FT_UINT8, BASE_HEX, vals_45_inprogress, 0x0f, NULL, HFILL }}, { &hf_ipmi_stor_45_data, { "Record Data", "ipmi.st45.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_45_added_rec_id, { "Record ID for added record", "ipmi.st45.added_rec_id", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, #if 0 { &hf_ipmi_stor_46_rsrv_id, { "Reservation ID", "ipmi.st46.rsrv_id", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_46_rec_id, { "Record ID", "ipmi.st46.rec_id", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, #endif { &hf_ipmi_stor_46_del_rec_id, { "Deleted Record ID", "ipmi.st46.del_rec_id", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_47_rsrv_id, { "Reservation ID", "ipmi.st47.rsrv_id", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_47_clr, { "Confirmation (should be CLR)", "ipmi.st47.clr", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_47_action, { "Action", "ipmi.st47.action", FT_UINT8, BASE_HEX, vals_47_action, 0, NULL, HFILL }}, { &hf_ipmi_stor_47_status, { "Erasure Status", "ipmi.st47.status", FT_UINT8, BASE_HEX, vals_47_status, 0x0f, NULL, HFILL }}, { &hf_ipmi_stor_48_time, { "Time", "ipmi.st48.time", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_49_time, { "Time", "ipmi.st49.time", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_5a_log_type, { "Log type", "ipmi.st5a.log_type", FT_UINT8, BASE_HEX, log_type_vals, 0x0f, NULL, HFILL }}, { &hf_ipmi_stor_5a_ts_add, { "Last addition timestamp", "ipmi.st5a.ts_add", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_5a_num_entries, { "Number of entries in MCA Log", "ipmi.st5a.num_entries", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_5a_iana, { "OEM IANA", "ipmi.st5a.iana", FT_UINT24, BASE_HEX, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_5a_bytes, { "Log status bytes", "ipmi.st5a.bytes", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_5a_unknown, { "Unknown log format (cannot parse data)", "ipmi.st5a.unknown", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_5b_log_type, { "Log type", "ipmi.st5b.log_type", FT_UINT8, BASE_HEX, log_type_vals, 0x0f, NULL, HFILL }}, { &hf_ipmi_stor_5b_ts_add, { "Last addition timestamp", "ipmi.st5b.ts_add", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_5b_num_entries, { "Number of entries in MCA Log", "ipmi.st5b.num_entries", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_5b_iana, { "OEM IANA", "ipmi.st5b.iana", FT_UINT24, BASE_HEX, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_5b_bytes, { "Log status bytes", "ipmi.st5b.bytes", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, { &hf_ipmi_stor_5b_unknown, { "Unknown log format (cannot parse data)", "ipmi.st5b.unknown", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, }; static gint *ett[] = { &ett_ipmi_stor_10_flags, &ett_ipmi_stor_20_ops, &ett_ipmi_stor_25_byte6, &ett_ipmi_stor_27_status, &ett_ipmi_stor_2c_rq_byte1, &ett_ipmi_stor_2c_rs_byte1, &ett_ipmi_stor_40_ops, &ett_ipmi_stor_45_byte6, &ett_ipmi_stor_47_status, &ett_ipmi_stor_5a_byte1, &ett_ipmi_stor_5b_byte1, }; proto_register_field_array(proto_ipmi, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); ipmi_register_netfn_cmdtab(IPMI_STORAGE_REQ, IPMI_OEM_NONE, NULL, 0, NULL, cmd_storage, array_length(cmd_storage)); }
void proto_register_sap(void) { static hf_register_info hf[] = { { &hf_sap_flags, { "Flags", "sap.flags", FT_UINT8, BASE_HEX, NULL, 0x0, "Bits in the beginning of the SAP header", HFILL }}, { &hf_sap_flags_v, { "Version Number", "sap.flags.v", FT_UINT8, BASE_DEC, VALS(mcast_sap_ver), MCAST_SAP_VERSION_MASK, "3 bit version field in the SAP header", HFILL }}, { &hf_sap_flags_a, { "Address Type", "sap.flags.a", FT_BOOLEAN, 8, TFS(&mcast_sap_address_type), MCAST_SAP_BIT_A, "Originating source address type", HFILL }}, { &hf_sap_flags_r, { "Reserved", "sap.flags.r", FT_BOOLEAN, 8, TFS(&tfs_set_notset), MCAST_SAP_BIT_R, NULL, HFILL }}, { &hf_sap_flags_t, { "Message Type", "sap.flags.t", FT_BOOLEAN, 8, TFS(&mcast_sap_message_type), MCAST_SAP_BIT_T, "Announcement type", HFILL }}, { &hf_sap_flags_e, { "Encryption Bit", "sap.flags.e", FT_BOOLEAN, 8, TFS(&mcast_sap_crypt_type), MCAST_SAP_BIT_E, NULL, HFILL }}, { &hf_sap_flags_c, { "Compression Bit", "sap.flags.c", FT_BOOLEAN, 8, TFS(&mcast_sap_comp_type), MCAST_SAP_BIT_C, NULL, HFILL }}, { &hf_auth_data, { "Authentication data", "sap.auth", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_auth_flags, { "Authentication data flags", "sap.auth.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_auth_flags_v, { "Version Number", "sap.auth.flags.v", FT_UINT8, BASE_DEC, VALS(mcast_sap_auth_ver), MCAST_SAP_VERSION_MASK, NULL, HFILL }}, { &hf_auth_flags_p, { "Padding Bit", "sap.auth.flags.p", FT_BOOLEAN, 8, TFS(&mcast_sap_auth_pad), MCAST_SAP_AUTH_BIT_P, NULL, HFILL }}, { &hf_auth_flags_t, { "Authentication Type", "sap.auth.flags.t", FT_UINT8, BASE_DEC, VALS(mcast_sap_auth_type), MCAST_SAP_AUTH_TYPE_MASK, NULL, HFILL }}, /* Generated from convert_proto_tree_add_text.pl */ { &hf_sap_auth_len, { "Authentication Length", "sap.auth.len", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_sap_message_identifier_hash, { "Message Identifier Hash", "sap.message_identifier_hash", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_sap_originating_source_ipv4, { "Originating Source", "sap.originating_source", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_sap_originating_source_ipv6, { "Originating Source", "sap.originating_source", FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_sap_auth_subheader, { "Authentication subheader", "sap.auth.subheader", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_sap_auth_data_padding, { "Authentication data padding", "sap.auth.data_padding", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_sap_auth_data_padding_len, { "Authentication data pad count (bytes)", "sap.auth.data_padding.len", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_sap_payload_type, { "Payload type", "sap.payload_type", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }}, }; static gint *ett[] = { &ett_sap, &ett_sap_flags, &ett_sap_auth, &ett_sap_authf, }; static ei_register_info ei[] = { { &ei_sap_compressed_and_encrypted, { "sap.compressed_and_encrypted", PI_UNDECODED, PI_WARN, "The rest of the packet is compressed and encrypted", EXPFILL }}, { &ei_sap_encrypted, { "sap.encrypted", PI_UNDECODED, PI_WARN, "The rest of the packet is encrypted", EXPFILL }}, { &ei_sap_compressed, { "sap.compressed", PI_UNDECODED, PI_WARN, "The rest of the packet is compressed", EXPFILL }}, /* Generated from convert_proto_tree_add_text.pl */ { &ei_sap_bogus_authentication_or_pad_length, { "sap.bogus_authentication_or_pad_length", PI_PROTOCOL, PI_WARN, "Bogus authentication length", EXPFILL }}, }; expert_module_t* expert_sap; proto_sap = proto_register_protocol("Session Announcement Protocol", "SAP", "sap"); proto_register_field_array(proto_sap, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); expert_sap = expert_register_protocol(proto_sap); expert_register_field_array(expert_sap, ei, array_length(ei)); }
/* Register all the bits needed with the filtering engine */ void proto_register_pgm(void) { static hf_register_info hf[] = { { &hf_pgm_main_sport, { "Source Port", "pgm.hdr.sport", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_main_dport, { "Destination Port", "pgm.hdr.dport", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_port, { "Port", "pgm.port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_main_type, { "Type", "pgm.hdr.type", FT_UINT8, BASE_HEX, VALS(type_vals), 0x0, NULL, HFILL }}, { &hf_pgm_main_opts, { "Options", "pgm.hdr.opts", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_main_opts_opt, { "Options", "pgm.hdr.opts.opt", FT_BOOLEAN, 8, TFS(&opts_present), PGM_OPT, NULL, HFILL }}, { &hf_pgm_main_opts_netsig, { "Network Significant Options", "pgm.hdr.opts.netsig", FT_BOOLEAN, 8, TFS(&opts_present), PGM_OPT_NETSIG, NULL, HFILL }}, { &hf_pgm_main_opts_varlen, { "Variable length Parity Packet Option", "pgm.hdr.opts.varlen", FT_BOOLEAN, 8, TFS(&opts_present), PGM_OPT_VAR_PKTLEN, NULL, HFILL }}, { &hf_pgm_main_opts_parity, { "Parity", "pgm.hdr.opts.parity", FT_BOOLEAN, 8, TFS(&opts_present), PGM_OPT_PARITY, NULL, HFILL }}, { &hf_pgm_main_cksum, { "Checksum", "pgm.hdr.cksum", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_main_cksum_bad, { "Bad Checksum", "pgm.hdr.cksum_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_main_gsi, { "Global Source Identifier", "pgm.hdr.gsi", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_main_tsdulen, { "Transport Service Data Unit Length", "pgm.hdr.tsdulen", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_spm_sqn, { "Sequence number", "pgm.spm.sqn", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_spm_trail, { "Trailing Edge Sequence Number", "pgm.spm.trail", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_spm_lead, { "Leading Edge Sequence Number", "pgm.spm.lead", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_spm_pathafi, { "Path NLA AFI", "pgm.spm.pathafi", FT_UINT16, BASE_DEC, VALS(afn_vals), 0x0, NULL, HFILL }}, { &hf_pgm_spm_res, { "Reserved", "pgm.spm.res", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_spm_path, { "Path NLA", "pgm.spm.path", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_spm_path6, { "Path NLA", "pgm.spm.path", FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_data_sqn, { "Data Packet Sequence Number", "pgm.data.sqn", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_data_trail, { "Trailing Edge Sequence Number", "pgm.data.trail", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_nak_sqn, { "Requested Sequence Number", "pgm.nak.sqn", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_nak_srcafi, { "Source NLA AFI", "pgm.nak.srcafi", FT_UINT16, BASE_DEC, VALS(afn_vals), 0x0, NULL, HFILL }}, { &hf_pgm_nak_srcres, { "Reserved", "pgm.nak.srcres", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_nak_src, { "Source NLA", "pgm.nak.src", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_nak_src6, { "Source NLA", "pgm.nak.src", FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_nak_grpafi, { "Multicast Group AFI", "pgm.nak.grpafi", FT_UINT16, BASE_DEC, VALS(afn_vals), 0x0, NULL, HFILL }}, { &hf_pgm_nak_grpres, { "Reserved", "pgm.nak.grpres", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_nak_grp, { "Multicast Group NLA", "pgm.nak.grp", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_nak_grp6, { "Multicast Group NLA", "pgm.nak.grp", FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_poll_sqn, { "Sequence Number", "pgm.poll.sqn", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_poll_round, { "Round", "pgm.poll.round", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_poll_subtype, { "Subtype", "pgm.poll.subtype", FT_UINT16, BASE_HEX, VALS(poll_subtype_vals), 0x0, NULL, HFILL }}, { &hf_pgm_poll_pathafi, { "Path NLA AFI", "pgm.poll.pathafi", FT_UINT16, BASE_DEC, VALS(afn_vals), 0x0, NULL, HFILL }}, { &hf_pgm_poll_res, { "Reserved", "pgm.poll.res", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_poll_path, { "Path NLA", "pgm.poll.path", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_poll_path6, { "Path NLA", "pgm.poll.path", FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_poll_backoff_ivl, { "Back-off Interval", "pgm.poll.backoff_ivl", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_poll_rand_str, { "Random String", "pgm.poll.rand_str", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_poll_matching_bmask, { "Matching Bitmask", "pgm.poll.matching_bmask", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_polr_sqn, { "Sequence Number", "pgm.polr.sqn", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_polr_round, { "Round", "pgm.polr.round", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_polr_res, { "Reserved", "pgm.polr.res", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_ack_sqn, { "Maximum Received Sequence Number", "pgm.ack.maxsqn", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_ack_bitmap, { "Packet Bitmap", "pgm.ack.bitmap", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_type, { "Type", "pgm.opts.type", FT_UINT8, BASE_HEX, VALS(opt_vals), 0x0, NULL, HFILL }}, { &hf_pgm_opt_len, { "Length", "pgm.opts.len", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_tlen, { "Total Length", "pgm.opts.tlen", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_genopt_end, { "Option end", "pgm.genopts.end", FT_BOOLEAN, 8, TFS(&tfs_yes_no), 0x80, NULL, HFILL }}, { &hf_pgm_genopt_type, { "Type", "pgm.genopts.type", FT_UINT8, BASE_HEX, VALS(opt_vals), 0x7f, NULL, HFILL }}, { &hf_pgm_genopt_len, { "Length", "pgm.genopts.len", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_genopt_opx, { "Option Extensibility Bits", "pgm.genopts.opx", FT_UINT8, BASE_HEX, VALS(opx_vals), 0x0, NULL, HFILL }}, { &hf_pgm_opt_parity_prm_po, { "Parity Parameters", "pgm.opts.parity_prm.op", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_parity_prm_prmtgsz, { "Transmission Group Size", "pgm.opts.parity_prm.prm_grp", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_join_res, { "Reserved", "pgm.opts.join.res", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_join_minjoin, { "Minimum Sequence Number", "pgm.opts.join.min_join", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_parity_grp_res, { "Reserved", "pgm.opts.parity_prm.op", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_parity_grp_prmgrp, { "Transmission Group Size", "pgm.opts.parity_prm.prm_grp", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_nak_res, { "Reserved", "pgm.opts.nak.op", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_nak_list, { "List", "pgm.opts.nak.list", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_ccdata_res, { "Reserved", "pgm.opts.ccdata.res", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_ccdata_tsp, { "Time Stamp", "pgm.opts.ccdata.tstamp", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_ccdata_afi, { "Acker AFI", "pgm.opts.ccdata.afi", FT_UINT16, BASE_DEC, VALS(afn_vals), 0x0, NULL, HFILL }}, { &hf_pgm_opt_ccdata_res2, { "Reserved", "pgm.opts.ccdata.res2", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_ccdata_acker, { "Acker", "pgm.opts.ccdata.acker", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_ccdata_acker6, { "Acker", "pgm.opts.ccdata.acker", FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_ccfeedbk_res, { "Reserved", "pgm.opts.ccdata.res", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_ccfeedbk_tsp, { "Time Stamp", "pgm.opts.ccdata.tstamp", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_ccfeedbk_afi, { "Acker AFI", "pgm.opts.ccdata.afi", FT_UINT16, BASE_DEC, VALS(afn_vals), 0x0, NULL, HFILL }}, { &hf_pgm_opt_ccfeedbk_lossrate, { "Loss Rate", "pgm.opts.ccdata.lossrate", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_ccfeedbk_acker, { "Acker", "pgm.opts.ccdata.acker", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_ccfeedbk_acker6, { "Acker", "pgm.opts.ccdata.acker", FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_nak_bo_ivl_res, { "Reserved", "pgm.opts.nak_bo_ivl.res", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_nak_bo_ivl_bo_ivl, { "Back-off Interval", "pgm.opts.nak_bo_ivl.bo_ivl", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_nak_bo_ivl_bo_ivl_sqn, { "Back-off Interval Sequence Number", "pgm.opts.nak_bo_ivl.bo_ivl_sqn", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_nak_bo_rng_res, { "Reserved", "pgm.opts.nak_bo_rng.res", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_nak_bo_rng_min_bo_ivl, { "Min Back-off Interval", "pgm.opts.nak_bo_rng.min_bo_ivl", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_nak_bo_rng_max_bo_ivl, { "Max Back-off Interval", "pgm.opts.nak_bo_rng.max_bo_ivl", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_redirect_res, { "Reserved", "pgm.opts.redirect.res", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_redirect_afi, { "DLR AFI", "pgm.opts.redirect.afi", FT_UINT16, BASE_DEC, VALS(afn_vals), 0x0, NULL, HFILL }}, { &hf_pgm_opt_redirect_res2, { "Reserved", "pgm.opts.redirect.res2", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_redirect_dlr, { "DLR", "pgm.opts.redirect.dlr", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_redirect_dlr6, { "DLR", "pgm.opts.redirect.dlr", FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_fragment_res, { "Reserved", "pgm.opts.fragment.res", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_fragment_first_sqn, { "First Sequence Number", "pgm.opts.fragment.first_sqn", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_fragment_offset, { "Fragment Offset", "pgm.opts.fragment.fragment_offset", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_fragment_total_length, { "Total Length", "pgm.opts.fragment.total_length", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }} }; static gint *ett[] = { &ett_pgm, &ett_pgm_optbits, &ett_pgm_spm, &ett_pgm_data, &ett_pgm_nak, &ett_pgm_poll, &ett_pgm_polr, &ett_pgm_ack, &ett_pgm_opts, &ett_pgm_opts_join, &ett_pgm_opts_parityprm, &ett_pgm_opts_paritygrp, &ett_pgm_opts_naklist, &ett_pgm_opts_ccdata, &ett_pgm_opts_nak_bo_ivl, &ett_pgm_opts_nak_bo_rng, &ett_pgm_opts_redirect, &ett_pgm_opts_fragment }; module_t *pgm_module; proto_pgm = proto_register_protocol("Pragmatic General Multicast", "PGM", "pgm"); proto_register_field_array(proto_pgm, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); /* subdissector code */ subdissector_table = register_dissector_table("pgm.port", "PGM port", FT_UINT16, BASE_DEC); register_heur_dissector_list("pgm", &heur_subdissector_list); /* * Register configuration preferences for UDP encapsulation * (Note: Initially the ports are set to zero and the ports * are not registered so the dissecting of PGM * encapsulated in UDP packets is off by default; * dissector_add_handle is called so that pgm * is available for 'decode-as' */ pgm_module = prefs_register_protocol(proto_pgm, proto_reg_handoff_pgm); prefs_register_bool_preference(pgm_module, "check_checksum", "Check the validity of the PGM checksum when possible", "Whether to check the validity of the PGM checksum", &pgm_check_checksum); prefs_register_uint_preference(pgm_module, "udp.encap_ucast_port", "PGM Encap Unicast Port (standard is 3055)", "PGM Encap is PGM packets encapsulated in UDP packets" " (Note: This option is off, i.e. port is 0, by default)", 10, &udp_encap_ucast_port); prefs_register_uint_preference(pgm_module, "udp.encap_mcast_port", "PGM Encap Multicast Port (standard is 3056)", "PGM Encap is PGM packets encapsulated in UDP packets" " (Note: This option is off, i.e. port is 0, by default)", 10, &udp_encap_mcast_port); }
void proto_register_packetbb(void) { /* Setup list of header fields See Section 1.6.1 for details*/ static hf_register_info hf[] = { { &hf_packetbb_error, { "ERROR !", "packetbb.error", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_packetbb_header, { "Packet header", "packetbb.header", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_packetbb_version, { "Version", "packetbb.version", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_packetbb_header_flags, { "Flags", "packetbb.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_packetbb_header_flags_phasseqnum, { "Has sequence number", "packetbb.flags.phasseqnum", FT_BOOLEAN, 8, TFS(&tfs_true_false), PACKET_HEADER_HASSEQNR, NULL, HFILL } }, { &hf_packetbb_header_flags_phastlv, { "Has tlv block", "packetbb.flags.phastlv", FT_BOOLEAN, 8, TFS(&tfs_true_false), PACKET_HEADER_HASTLV, NULL, HFILL } }, { &hf_packetbb_seqnr, { "Sequence number", "packetbb.seqnr", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_packetbb_msg, { "Message", "packetbb.msg", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_packetbb_msgheader, { "Message header", "packetbb.msg.header", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_packetbb_msgheader_type, { "Type", "packetbb.msg.type", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_packetbb_msgheader_flags, { "Flags", "packetbb.msg.flags", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_packetbb_msgheader_flags_mhasorig, { "Has originator address", "packetbb.msg.flags.mhasorig", FT_BOOLEAN, 8, TFS(&tfs_true_false), MSG_HEADER_HASORIG, NULL, HFILL } }, { &hf_packetbb_msgheader_flags_mhashoplimit, { "Has hoplimit", "packetbb.msg.flags.mhashoplimit", FT_BOOLEAN, 8, TFS(&tfs_true_false), MSG_HEADER_HASHOPLIMIT, NULL, HFILL } }, { &hf_packetbb_msgheader_flags_mhashopcount, { "Has hopcount", "packetbb.msg.flags.mhashopcount", FT_BOOLEAN, 8, TFS(&tfs_true_false), MSG_HEADER_HASHOPCOUNT, NULL, HFILL } }, { &hf_packetbb_msgheader_flags_mhasseqnr, { "Has sequence number", "packetbb.msg.flags.mhasseqnum", FT_BOOLEAN, 8, TFS(&tfs_true_false), MSG_HEADER_HASSEQNR, NULL, HFILL } }, { &hf_packetbb_msgheader_addresssize, { "AddressSize", "packetbb.msg.addrsize", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_packetbb_msgheader_size, { "Size", "packetbb.msg.size", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_packetbb_msgheader_origaddripv4, { "Originator address", "packetbb.msg.origaddr4", FT_IPv4, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_packetbb_msgheader_origaddripv6, { "Originator address", "packetbb.msg.origaddr6", FT_IPv6, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_packetbb_msgheader_origaddrmac, { "Originator address", "packetbb.msg.origaddrmac", FT_ETHER, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_packetbb_msgheader_origaddrcustom, { "Originator address", "packetbb.msg.origaddrcustom", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_packetbb_msgheader_hoplimit, { "Hop limit", "packetbb.msg.hoplimit", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_packetbb_msgheader_hopcount, { "Hop count", "packetbb.msg.hopcount", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_packetbb_msgheader_seqnr, { "Squence number", "packetbb.msg.seqnum", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_packetbb_addr, { "Address block", "packetbb.msg.addr", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_packetbb_addr_num, { "Count", "packetbb.msg.addr.num", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_packetbb_addr_flags, { "Flags", "packetbb.msg.addr.flags", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_packetbb_addr_flags_hashead, { "Has head", "packetbb.msg.addr.hashead", FT_BOOLEAN, 8, TFS(&tfs_true_false), ADDR_HASHEAD, NULL, HFILL } }, { &hf_packetbb_addr_flags_hasfulltail, { "Has full tail", "packetbb.msg.addr.hasfulltail", FT_BOOLEAN, 8, TFS(&tfs_true_false), ADDR_HASFULLTAIL, NULL, HFILL } }, { &hf_packetbb_addr_flags_haszerotail, { "Has zero tail", "packetbb.msg.addr.haszerotail", FT_BOOLEAN, 8, TFS(&tfs_true_false), ADDR_HASZEROTAIL, NULL, HFILL } }, { &hf_packetbb_addr_flags_hassingleprelen, { "Has single prelen", "packetbb.msg.addr.hassingleprelen", FT_BOOLEAN, 8, TFS(&tfs_true_false), ADDR_HASSINGLEPRELEN, NULL, HFILL } }, { &hf_packetbb_addr_flags_hasmultiprelen, { "Has multiple prelen", "packetbb.msg.addr.hasmultiprelen", FT_BOOLEAN, 8, TFS(&tfs_true_false), ADDR_HASMULTIPRELEN, NULL, HFILL } }, { &hf_packetbb_addr_head, { "Head", "packetbb.msg.addr.head", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_packetbb_addr_tail, { "Tail", "packetbb.msg.addr.tail", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_packetbb_addr_value[0], { "Address", "packetbb.msg.addr.value4", FT_IPv4, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_packetbb_addr_value[1], { "Address", "packetbb.msg.addr.value6", FT_IPv6, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_packetbb_addr_value[2], { "Address", "packetbb.msg.addr.valuemac", FT_ETHER, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_packetbb_addr_value[3], { "Address", "packetbb.msg.addr.valuecustom", FT_UINT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_packetbb_addr_value_mid, { "Mid", "packetbb.msg.addr.value.mid", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_packetbb_addr_value_prefix, { "Prefix", "packetbb.msg.addr.value.prefix", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_packetbb_tlvblock, { "TLV block", "packetbb.tlvblock", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_packetbb_tlvblock_length, { "Length", "packetbb.tlvblock.length", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_packetbb_tlv, { "TLV", "packetbb.tlv", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_packetbb_tlv_type, { "Type", "packetbb.tlv.type", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_packetbb_tlv_flags, { "Flags", "packetbb.tlv.flags", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_packetbb_tlv_typeext, { "Extended Type", "packetbb.tlv.typeext", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_packetbb_tlv_flags_hastypext, { "Has type-ext", "packetbb.tlv.hastypeext", FT_BOOLEAN, 8, TFS(&tfs_true_false), TLV_HAS_TYPEEXT, NULL, HFILL } }, { &hf_packetbb_tlv_flags_hassingleindex, { "Has single index", "packetbb.tlv.hassingleindex", FT_BOOLEAN, 8, TFS(&tfs_true_false), TLV_HAS_SINGLEINDEX, NULL, HFILL } }, { &hf_packetbb_tlv_flags_hasmultiindex, { "Has multiple indices", "packetbb.tlv.hasmultiindex", FT_BOOLEAN, 8, TFS(&tfs_true_false), TLV_HAS_MULTIINDEX, NULL, HFILL } }, { &hf_packetbb_tlv_flags_hasvalue, { "Has value", "packetbb.tlv.hasvalue", FT_BOOLEAN, 8, TFS(&tfs_true_false), TLV_HAS_VALUE, NULL, HFILL } }, { &hf_packetbb_tlv_flags_hasextlen, { "Has extended length", "packetbb.tlv.hasextlen", FT_BOOLEAN, 8, TFS(&tfs_true_false), TLV_HAS_EXTLEN, NULL, HFILL } }, { &hf_packetbb_tlv_flags_hasmultivalue, { "Has multiple values", "packetbb.tlv.hasmultivalue", FT_BOOLEAN, 8, TFS(&tfs_true_false), TLV_HAS_MULTIVALUE, NULL, HFILL } }, { &hf_packetbb_tlv_indexstart, { "Index start", "packetbb.tlv.indexstart", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_packetbb_tlv_indexend, { "Index end", "packetbb.tlv.indexend", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_packetbb_tlv_length, { "Length", "packetbb.tlv.length", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_packetbb_tlv_value, { "Value", "packetbb.tlv.value", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_packetbb_tlv_multivalue, { "Multivalue", "packetbb.tlv.multivalue", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL } } }; /* Setup protocol subtree array */ gint *ett_base[] = { &ett_packetbb, &ett_packetbb_header, &ett_packetbb_header_flags, &ett_packetbb_msgheader, &ett_packetbb_msgheader_flags, &ett_packetbb_addr, &ett_packetbb_addr_flags, &ett_packetbb_addr_value, &ett_packetbb_tlvblock, &ett_packetbb_tlv_flags, &ett_packetbb_tlv_value }; static gint *ett[array_length(ett_base) + 2*PACKETBB_MSG_TLV_LENGTH]; module_t *packetbb_module; int i,j; memcpy(ett, ett_base, sizeof(ett_base)); j = array_length(ett_base); for (i=0; i<PACKETBB_MSG_TLV_LENGTH; i++) { ett_packetbb_msg[i] = -1; ett_packetbb_tlv[i] = -1; ett[j++] = &ett_packetbb_msg[i]; ett[j++] = &ett_packetbb_tlv[i]; } /* name, short name, abbrev */ proto_packetbb = proto_register_protocol("PacketBB Protocol", "PacketBB", "packetbb"); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_packetbb, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); /* configurable packetbb port */ packetbb_module = prefs_register_protocol(proto_packetbb, proto_reg_handoff_packetbb); prefs_register_uint_preference(packetbb_module, "communication_port", "UDP port for packetbb", "UDP communication port for packetbb PDUs", 10, &global_packetbb_port); }
void proto_register_pagp(void) { /* Setup list of header fields */ static hf_register_info hf[] = { { &hf_pagp_version_number, { "Version", "pagp.version", FT_UINT8, BASE_HEX, VALS(pdu_vers), 0x0, "Identifies the PAgP PDU version: 1 = Info, 2 = Flush", HFILL }}, { &hf_pagp_flags, { "Flags", "pagp.flags", FT_UINT8, BASE_HEX, NULL, 0x0, "Information flags", HFILL }}, { &hf_pagp_flags_slow_hello, { "Slow Hello", "pagp.flags.slowhello", FT_BOOLEAN, 8, TFS(&tfs_yes_no), PAGP_FLAGS_SLOW_HELLO, "1 = using Slow Hello, 0 = Slow Hello disabled", HFILL }}, { &hf_pagp_flags_auto_mode, { "Auto Mode", "pagp.flags.automode", FT_BOOLEAN, 8, TFS(&automode), PAGP_FLAGS_AUTO_MODE, "1 = Auto Mode enabled, 0 = Desirable Mode", HFILL }}, { &hf_pagp_flags_consistent_state, { "Consistent State", "pagp.flags.state", FT_BOOLEAN, 8, NULL, PAGP_FLAGS_CONSISTENT_STATE, "1 = Consistent State, 0 = Not Ready", HFILL }}, { &hf_pagp_local_device_id, { "Local Device ID", "pagp.localdevid", FT_ETHER, BASE_NONE, NULL, 0x0, "Local device ID", HFILL }}, { &hf_pagp_local_learn_cap, { "Local Learn Capability", "pagp.localearncap", FT_UINT8, BASE_HEX, VALS(learn_cap), 0x0, "Local learn capability", HFILL }}, { &hf_pagp_local_port_priority, { "Local Port Hot Standby Priority", "pagp.localportpri", FT_UINT8, BASE_DEC, NULL, 0x0, "The local hot standby priority assigned to this port", HFILL }}, { &hf_pagp_local_sent_port_ifindex, { "Local Sent Port ifindex", "pagp.localsentportifindex", FT_UINT32, BASE_DEC, NULL, 0x0, "The interface index of the local port used to send PDU", HFILL }}, { &hf_pagp_local_group_capability, { "Local Group Capability", "pagp.localgroupcap", FT_UINT32, BASE_HEX, NULL, 0x0, "The local group capability", HFILL }}, { &hf_pagp_local_group_ifindex, { "Local Group ifindex", "pagp.localgroupifindex", FT_UINT32, BASE_DEC, NULL, 0x0, "The local group interface index", HFILL }}, { &hf_pagp_partner_device_id, { "Partner Device ID", "pagp.partnerdevid", FT_ETHER, BASE_NONE, NULL, 0x0, "Remote Device ID (MAC)", HFILL }}, { &hf_pagp_partner_learn_cap, { "Partner Learn Capability", "pagp.partnerlearncap", FT_UINT8, BASE_HEX, VALS(learn_cap), 0x0, "Remote learn capability", HFILL }}, { &hf_pagp_partner_port_priority, { "Partner Port Hot Standby Priority", "pagp.partnerportpri", FT_UINT8, BASE_DEC, NULL, 0x0, "Remote port priority", HFILL }}, { &hf_pagp_partner_sent_port_ifindex, { "Partner Sent Port ifindex", "pagp.partnersentportifindex", FT_UINT32, BASE_DEC, NULL, 0x0, "Remote port interface index sent", HFILL }}, { &hf_pagp_partner_group_capability, { "Partner Group Capability", "pagp.partnergroupcap", FT_UINT32, BASE_HEX, NULL, 0x0, "Remote group capability", HFILL }}, { &hf_pagp_partner_group_ifindex, { "Partner Group ifindex", "pagp.partnergroupifindex", FT_UINT32, BASE_DEC, NULL, 0x0, "Remote group interface index", HFILL }}, { &hf_pagp_partner_count, { "Partner Count", "pagp.partnercount", FT_UINT16, BASE_DEC, NULL, 0x0, "Partner count", HFILL }}, { &hf_pagp_num_tlvs, { "Number of TLVs", "pagp.numtlvs", FT_UINT16, BASE_DEC, NULL, 0x0, "Number of TLVs following", HFILL }}, { &hf_pagp_tlv, { "Entry", "pagp.tlv", FT_UINT16, BASE_DEC, NULL, 0x0, "Type/Length/Value", HFILL }}, { &hf_pagp_tlv_device_name, { "Device Name", "pagp.tlvdevname", FT_STRING, BASE_NONE, NULL, 0x0, "sysName of device", HFILL }}, { &hf_pagp_tlv_port_name, { "Physical Port Name", "pagp.tlvportname", FT_STRING, BASE_NONE, NULL, 0x0, "Name of port used to send PDU", HFILL }}, { &hf_pagp_tlv_agport_mac, { "Agport MAC Address", "pagp.tlvagportmac", FT_ETHER, BASE_NONE, NULL, 0x0, "Source MAC on frames for this aggregate", HFILL }}, { &hf_pagp_flush_local_device_id, { "Flush Local Device ID", "pagp.flushlocaldevid", FT_ETHER, BASE_NONE, NULL, 0x0, "Flush local device ID", HFILL }}, { &hf_pagp_flush_partner_device_id, { "Flush Partner Device ID", "pagp.flushpartnerdevid", FT_ETHER, BASE_NONE, NULL, 0x0, "Flush remote device ID", HFILL }}, { &hf_pagp_flush_transaction_id, { "Transaction ID", "pagp.transid", FT_UINT32, BASE_HEX, NULL, 0x0, "Flush transaction ID", HFILL }}, }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_pagp, &ett_pagp_flags, &ett_pagp_tlvs, }; /* Register the protocol name and description */ proto_pagp = proto_register_protocol("Port Aggregation Protocol", "PAGP", "pagp"); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_pagp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }
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_adb(void) { module_t *module; expert_module_t *expert_module; static hf_register_info hf[] = { { &hf_command, { "Command", "adb.command", FT_UINT32, BASE_HEX, VALS(command_vals), 0x00, NULL, HFILL } }, { &hf_argument_0, { "Argument 0", "adb.argument.0", FT_UINT32, BASE_HEX, NULL, 0x00, NULL, HFILL } }, { &hf_argument_1, { "Argument 0", "adb.argument.1", FT_UINT32, BASE_HEX, NULL, 0x00, NULL, HFILL } }, { &hf_data_length, { "Data Length", "adb.data_length", FT_UINT32, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_data_crc32, { "Data CRC32", "adb.data_crc32", FT_UINT32, BASE_HEX, NULL, 0x00, NULL, HFILL } }, { &hf_magic, { "Magic", "adb.magic", FT_UINT32, BASE_HEX, VALS(magic_vals), 0x00, NULL, HFILL } }, { &hf_version, { "Version", "adb.version", FT_UINT32, BASE_HEX, NULL, 0x00, NULL, HFILL } }, { &hf_max_data, { "Max Data", "adb.max_data", FT_UINT32, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_auth_type, { "Type", "adb.auth_type", FT_UINT32, BASE_HEX, VALS(auth_type_vals), 0x00, NULL, HFILL } }, { &hf_online, { "Online", "adb.online", FT_BOOLEAN, 32, TFS(&tfs_no_yes), 0x00, NULL, HFILL } }, { &hf_sequence, { "Sequence", "adb.sequence", FT_UINT32, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_zero, { "Zero", "adb.zero", FT_UINT32, BASE_HEX, NULL, 0x00, NULL, HFILL } }, { &hf_local_id, { "Local ID", "adb.local_id", FT_UINT32, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_remote_id, { "Remote ID", "adb.remote_id", FT_UINT32, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_data, { "Data", "adb.data", FT_NONE, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_service, { "Service", "adb.service", FT_STRING, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_data_fragment, { "Data Fragment", "adb.data_fragment", FT_NONE, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_service_start_in_frame, { "Service Start in Frame", "adb.service_start_in_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_close_local_in_frame, { "Local Service Close in Frame", "adb.close_local_in_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_close_remote_in_frame, { "Remote Service Close in Frame", "adb.close_remote_in_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_command_in_frame, { "Command in Frame", "adb.command_in_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_completed_in_frame, { "Completed in Frame", "adb.completed_in_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_connection_info, { "Info", "adb.connection_info", FT_STRINGZ, STR_ASCII, NULL, 0x00, NULL, HFILL } } }; static gint *ett[] = { &ett_adb, &ett_adb_arg0, &ett_adb_arg1, &ett_adb_crc, &ett_adb_magic }; static ei_register_info ei[] = { { &ei_invalid_magic, { "adb.expert.invalid_magic", PI_PROTOCOL, PI_WARN, "Invalid Magic", EXPFILL }}, { &ei_invalid_crc, { "adb.expert.crc_error", PI_PROTOCOL, PI_ERROR, "CRC32 Error", EXPFILL }}, }; command_info = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); service_info = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); proto_adb = proto_register_protocol("Android Debug Bridge", "ADB", "adb"); adb_handle = register_dissector("adb", dissect_adb, proto_adb); proto_register_field_array(proto_adb, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); expert_module = expert_register_protocol(proto_adb); expert_register_field_array(expert_module, ei, array_length(ei)); module = prefs_register_protocol(proto_adb, NULL); prefs_register_static_text_preference(module, "version", "ADB protocol version is compatible prior to: adb 1.0.31", "Version of protocol supported by this dissector."); }
void proto_register_ehdlc(void) { static hf_register_info hf[] = { { &hf_ehdlc_data_len, { "DataLen", "ehdlc.data_len", FT_UINT8, BASE_DEC, NULL, 0x0, "The length of the data (in bytes)", HFILL } }, { &hf_ehdlc_protocol, { "Protocol", "ehdlc.protocol", FT_UINT8, BASE_HEX, VALS(ehdlc_protocol_vals), 0x0, "The HDLC Sub-Protocol", HFILL } }, { &hf_ehdlc_sapi, { "SAPI", "ehdlc.sapi", FT_UINT8, BASE_DEC, NULL, 0x1f, NULL, HFILL } }, { &hf_ehdlc_c_r, { "C/R", "ehdlc.c_r", FT_UINT8, BASE_HEX, NULL, 0x20, NULL, HFILL } }, { &hf_ehdlc_xid_payload, { "XID Payload", "ehdlc.xid_payload", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_ehdlc_control, { "Control Field", "ehdlc.control", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_ehdlc_n_r, { "N(R)", "ehdlc.control.n_r", FT_UINT16, BASE_DEC, NULL, XDLC_N_R_EXT_MASK, NULL, HFILL } }, { &hf_ehdlc_n_s, { "N(S)", "ehdlc.control.n_s", FT_UINT16, BASE_DEC, NULL, XDLC_N_S_EXT_MASK, NULL, HFILL } }, { &hf_ehdlc_p, { "Poll", "ehdlc.control.p", FT_BOOLEAN, 8, TFS(&tfs_set_notset), XDLC_P_F, NULL, HFILL } }, { &hf_ehdlc_p_ext, { "Poll", "ehdlc.control.p", FT_BOOLEAN, 16, TFS(&tfs_set_notset), XDLC_P_F_EXT, NULL, HFILL } }, { &hf_ehdlc_f, { "Final", "ehdlc.control.f", FT_BOOLEAN, 8, TFS(&tfs_set_notset), XDLC_P_F, NULL, HFILL } }, { &hf_ehdlc_f_ext, { "Final", "ehdlc.control.f", FT_BOOLEAN, 16, TFS(&tfs_set_notset), XDLC_P_F_EXT, NULL, HFILL } }, { &hf_ehdlc_s_ftype, { "Supervisory frame type", "ehdlc.control.s_ftype", FT_UINT16, BASE_HEX, VALS(stype_vals), XDLC_S_FTYPE_MASK, NULL, HFILL } }, { &hf_ehdlc_u_modifier_cmd, { "Command", "ehdlc.control.u_modifier_cmd", FT_UINT8, BASE_HEX, VALS(modifier_vals_cmd), XDLC_U_MODIFIER_MASK, NULL, HFILL } }, { &hf_ehdlc_u_modifier_resp, { "Response", "ehdlc.control.u_modifier_resp", FT_UINT8, BASE_HEX, VALS(modifier_vals_resp), XDLC_U_MODIFIER_MASK, NULL, HFILL } }, { &hf_ehdlc_ftype_i, { "Frame Type", "ehdlc.control.ftype", FT_UINT16, BASE_HEX, VALS(ftype_vals), XDLC_I_MASK, NULL, HFILL } }, { &hf_ehdlc_ftype_s_u, { "Frame Type", "ehdlc.control.ftype", FT_UINT8, BASE_HEX, VALS(ftype_vals), XDLC_S_U_MASK, NULL, HFILL } }, { &hf_ehdlc_ftype_s_u_ext, { "Frame Type", "ehdlc.control.ftype", FT_UINT16, BASE_HEX, VALS(ftype_vals), XDLC_S_U_MASK, NULL, HFILL } }, }; static gint *ett[] = { &ett_ehdlc, &ett_ehdlc_control, }; proto_ehdlc = proto_register_protocol("Ericsson HDLC", "Ericsson HDLC as used in A-bis over IP", "ehdlc"); proto_register_field_array(proto_ehdlc, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); register_dissector("ehdlc", dissect_ehdlc, proto_ehdlc); }
void proto_register_dcom_dispatch(void) { static hf_register_info hf_dispatch_array[] = { { &hf_dispatch_opnum, { "Operation", "dispatch_opnum", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_dispatch_riid, { "RIID", "dispatch_riid", FT_GUID, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_dispatch_name, { "Name", "hf_dispatch_name", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_dispatch_names, { "Names", "dispatch_names", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_dispatch_lcid, { "LCID", "dispatch_lcid", FT_UINT32, BASE_HEX, VALS(dcom_lcid_vals), 0x0, NULL, HFILL }}, { &hf_dispatch_id, { "DispID", "dispatch_id", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_dispatch_flags, { "Flags", "dispatch_flags", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_dispatch_arg, { "Argument", "dispatch_arg", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_dispatch_args, { "Args", "dispatch_args", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_dispatch_named_args, { "NamedArgs", "dispatch_named_args", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_dispatch_varref, { "VarRef", "dispatch_varref", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_dispatch_varrefidx, { "VarRefIdx", "dispatch_varrefidx", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_dispatch_varrefarg, { "VarRef", "dispatch_varrefarg", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_dispatch_varresult, { "VarResult", "dispatch_varresult", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_dispatch_flags_method, { "Method", "dispatch_flags_method", FT_BOOLEAN, 32, TFS (&tfs_set_notset), DISPATCH_FLAGS_METHOD, NULL, HFILL }}, { &hf_dispatch_flags_propget, { "PropertyGet", "dispatch_flags_propget", FT_BOOLEAN, 32, TFS (&tfs_set_notset), DISPATCH_FLAGS_PROPGET, NULL, HFILL }}, { &hf_dispatch_flags_propput, { "PropertyPut", "dispatch_flags_propput", FT_BOOLEAN, 32, TFS (&tfs_set_notset), DISPATCH_FLAGS_PROPPUT, NULL, HFILL }}, { &hf_dispatch_flags_propputref, { "PropertyPutRef", "dispatch_flags_propputref", FT_BOOLEAN, 32, TFS (&tfs_set_notset), DISPATCH_FLAGS_PROPPUTREF, NULL, HFILL }}, { &hf_dispatch_code, { "Code", "dispatch_code", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_dispatch_reserved16, { "Reserved", "dispatch_reserved16", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_dispatch_source, { "Source", "dispatch_source", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_dispatch_description, { "Description", "dispatch_description", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_dispatch_help_file, { "HelpFile", "dispatch_help_file", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_dispatch_help_context, { "HelpContext", "dispatch_help_context", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_dispatch_reserved32, { "Reserved", "dispatch_reserved32", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_dispatch_deferred_fill_in, { "DeferredFillIn", "dispatch_deferred_fill_in", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_dispatch_arg_err, { "ArgErr", "dispatch_arg_err", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_dispatch_tinfo, { "TInfo", "dispatch_tinfo", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_dispatch_itinfo, { "TInfo", "dispatch_itinfo", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_dispatch_dispparams, { "DispParams", "dispatch_dispparams", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_dispatch_excepinfo, { "ExcepInfo", "dispatch_excepinfo", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_dispatch_scode, { "SCode", "dispatch_scode", FT_UINT32, BASE_HEX, VALS(dcom_hresult_vals), 0x0, NULL, HFILL }} }; static gint *ett[] = { &ett_dispatch, &ett_dispatch_flags, &ett_dispatch_params, &ett_dispatch_excepinfo }; /* IDispatch currently only partially implemented */ proto_dispatch = proto_register_protocol ("DCOM IDispatch", "IDispatch", "dispatch"); proto_register_field_array (proto_dispatch, hf_dispatch_array, array_length (hf_dispatch_array)); proto_register_subtree_array (ett, array_length (ett)); }
/* Register the protocol */ void proto_register_ssprotocol(void) { /* Setup list of header fields */ static hf_register_info hf[] = { { &hf_message_type, { "Type", "ssprotocol.message_type", FT_UINT8, BASE_DEC, VALS(message_type_values), 0x0, NULL, HFILL } }, { &hf_message_flags, { "Flags", "ssprotocol.message_flags", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_message_length, { "Length", "ssprotocol.message_length", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_message_status, { "Status", "ssprotocol.message_status", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_message_reason, { "Reason", "ssprotocol.message_reason", FT_UINT32, BASE_DEC, VALS(notrdy_reason_values), 0x0, NULL, HFILL } }, { &hf_message_info, { "Info", "ssprotocol.message_info", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_message_data, { "Data", "ssprotocol.message_data", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_message_hash, { "Hash", "ssprotocol.message_hash", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_environment_u_bit, { "U-Bit", "ssprotocol.environment_u_bit", FT_BOOLEAN, 8,TFS(&environment_u_bit), SSP_ENVIRONMENT_U_BIT, NULL, HFILL } } }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_ssprotocol, &ett_environment_flags }; /* Register the protocol name and description */ proto_ssprotocol = proto_register_protocol("Scripting Service Protocol", "SSP", "ssp"); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_ssprotocol, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }
void proto_register_nsip(void) { static hf_register_info hf[] = { { &hf_nsip_cause, { "Cause", "nsip.cause", FT_UINT8, BASE_OCT, VALS(tab_nsip_cause_values), 0x0, NULL, HFILL } }, { &hf_nsip_ns_vci, { "NS-VCI", "nsip.ns_vci", FT_UINT16, BASE_DEC, NULL, 0x0, "Network Service Virtual Link Identifier", HFILL } }, { &hf_nsip_pdu_type, { "PDU type", "nsip.pdu_type", FT_UINT8, BASE_OCT, VALS(tab_nsip_pdu_types), 0x0, "PDU type information element", HFILL } }, { &hf_nsip_bvci, { "BVCI", "nsip.bvci", FT_UINT16, BASE_DEC, NULL, 0x0, "BSSGP Virtual Connection Identifier", HFILL } }, { &hf_nsip_nsei, { "NSEI", "nsip.nsei", FT_UINT16, BASE_DEC, NULL, 0x0, "Network Service Entity Identifier", HFILL } }, #if 0 { &hf_nsip_ip4_elements, { "IP4 elements", "nsip.ip4_elements", FT_NONE, BASE_NONE, NULL, 0x0, "List of IP4 elements", HFILL } }, #endif #if 0 { &hf_nsip_ip6_elements, { "IP6 elements", "nsip.ip6_elements", FT_NONE, BASE_NONE, NULL, 0x0, "List of IP6 elements", HFILL } }, #endif { &hf_nsip_max_num_ns_vc, { "Maximum number of NS-VCs", "nsip.max_num_ns_vc", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_nsip_num_ip4_endpoints, { "Number of IP4 endpoints", "nsip.num_ip4_endpoints", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_nsip_num_ip6_endpoints, { "Number of IP6 endpoints", "nsip.num_ip6_endpoints", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_nsip_reset_flag, { "Reset flag", "nsip.reset_flag.flag", FT_BOOLEAN, 8, TFS(&tfs_set_notset), NSIP_MASK_RESET_FLAG, NULL, HFILL } }, { &hf_nsip_reset_flag_spare, { "Reset flag spare bits", "nsip.reset_flag.spare", FT_UINT8, BASE_HEX, NULL, NSIP_MASK_RESET_FLAG_SPARE, NULL, HFILL } }, { &hf_nsip_ip_address_type, { "IP Address Type", "nsip.ip_address_type", FT_UINT8, BASE_DEC, VALS(ip_address_type_vals), 0x0, NULL, HFILL } }, { &hf_nsip_ip_address_ipv4, { "IP Address", "nsip.ipv4_address", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_nsip_ip_address_ipv6, { "IP Address", "nsip.ipv6_address", FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_nsip_end_flag, { "End flag", "nsip.end_flag.flag", FT_BOOLEAN, 8, TFS(&tfs_set_notset), NSIP_MASK_END_FLAG, NULL, HFILL } }, { &hf_nsip_end_flag_spare, { "End flag spare bits", "nsip.end_flag.spare", FT_UINT8, BASE_HEX, NULL, NSIP_MASK_END_FLAG_SPARE, NULL, HFILL } }, { &hf_nsip_control_bits_r, { "Request change flow", "nsip.control_bits.r", FT_BOOLEAN, 8, TFS(&tfs_set_notset), NSIP_MASK_CONTROL_BITS_R, NULL, HFILL } }, { &hf_nsip_control_bits_c, { "Confirm change flow", "nsip.control_bits.c", FT_BOOLEAN, 8, TFS(&tfs_set_notset), NSIP_MASK_CONTROL_BITS_C, NULL, HFILL } }, { &hf_nsip_control_bits_spare, { "Spare bits", "nsip.control_bits.spare", FT_UINT8, BASE_HEX, NULL, NSIP_MASK_CONTROL_BITS_SPARE, NULL, HFILL } }, { &hf_nsip_transaction_id, { "Transaction ID", "nsip.transaction_id", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, #if 0 { &hf_nsip_ip_element_ip_address_ipv4, { "IP Address", "nsip.ip_element.ipv4_address", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, #endif #if 0 { &hf_nsip_ip_element_ip_address_ipv6, { "IP Address", "nsip.ip_element.ipv6_address", FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL } }, #endif { &hf_nsip_ip_element_udp_port, { "UDP Port", "nsip.ip_element.udp_port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_nsip_ip_element_signalling_weight, { "Signalling Weight", "nsip.ip_element.signalling_weight", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_nsip_ip_element_data_weight, { "Data Weight", "nsip.ip_element.data_weight", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_nsip, &ett_nsip_control_bits, &ett_nsip_reset_flag, &ett_nsip_end_flag, &ett_nsip_ip_element, &ett_nsip_ip_element_list, }; module_t *nsip_module; /* Register the protocol name and description */ proto_nsip = proto_register_protocol("GPRS Network Service", "GPRS-NS", "gprs-ns"); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_nsip, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); register_dissector("gprs_ns", dissect_nsip, proto_nsip); /* Set default UDP ports */ range_convert_str(&global_nsip_udp_port_range, DEFAULT_NSIP_PORT_RANGE, MAX_UDP_PORT); /* Register configuration options */ nsip_module = prefs_register_protocol(proto_nsip, proto_reg_handoff_nsip); prefs_register_obsolete_preference(nsip_module, "udp.port1"); prefs_register_obsolete_preference(nsip_module, "udp.port2"); prefs_register_range_preference(nsip_module, "udp.ports", "GPRS-NS UDP ports", "UDP ports to be decoded as GPRS-NS (default: " DEFAULT_NSIP_PORT_RANGE ")", &global_nsip_udp_port_range, MAX_UDP_PORT); }
void proto_register_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 }}, { &hf_cups_uri, { "URI", "cups.uri", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_cups_location, { "Location", "cups.location", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_cups_information, { "Information", "cups.information", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_cups_make_model, { "Make and model", "cups.make_model", FT_STRING, BASE_NONE, NULL, 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)); }
/* * Name: isis_register_hello() * * Description: * Register our protocol sub-sets with protocol manager. * * Input: * int : protocol index for the ISIS protocol * * Output: * void */ void isis_register_hello(int proto_isis) { static hf_register_info hf[] = { { &hf_isis_hello_circuit_reserved, { "Circuit type", "isis.hello.circuit_type", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_isis_hello_source_id, { "SystemID{ Sender of PDU }", "isis.hello.source_id", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_isis_hello_holding_timer, { "Holding timer", "isis.hello.holding_timer", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_isis_hello_pdu_length, { "PDU length", "isis.hello.pdu_length", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_isis_hello_priority_reserved, { "Priority", "isis.hello.priority", FT_UINT8, BASE_DEC, NULL, ISIS_HELLO_P_RESERVED_MASK, NULL, HFILL }}, { &hf_isis_hello_lan_id, { "SystemID{ Designated IS }", "isis.hello.lan_id", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_isis_hello_local_circuit_id, { "Local circuit ID", "isis.hello.local_circuit_id", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_isis_hello_clv_ipv4_int_addr, { "IPv4 interface address", "isis.hello.clv_ipv4_int_addr", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_isis_hello_clv_ipv6_int_addr, { "IPv6 interface address", "isis.hello.clv_ipv6_int_addr", FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_isis_hello_clv_ptp_adj, { "Point-to-point Adjacency", "isis.hello.clv_ptp_adj", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_isis_hello_clv_mt, { "MT-ID", "isis.hello.clv_mt", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_isis_hello_clv_restart_flags, { "Restart Signaling Flags", "isis.hello.clv_restart_flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_isis_hello_clv_restart_flags_rr, { "Restart Request", "isis.hello.clv_restart_flags.rr", FT_BOOLEAN, 8, TFS(&tfs_true_false), ISIS_RESTART_RR, "When set, the router is beginning a graceful restart", HFILL }}, { &hf_isis_hello_clv_restart_flags_ra, { "Restart Acknowledgment", "isis.hello.clv_restart_flags.ra", FT_BOOLEAN, 8, TFS(&tfs_true_false), ISIS_RESTART_RA, "When set, the router is willing to enter helper mode", HFILL }}, { &hf_isis_hello_clv_restart_flags_sa, { "Suppress Adjacency", "isis.hello.clv_restart_flags.sa", FT_BOOLEAN, 8, TFS(&tfs_true_false), ISIS_RESTART_SA, "When set, the router is starting as opposed to restarting", HFILL }}, { &hf_isis_hello_clv_restart_remain_time, { "Remaining holding time", "isis.hello.clv_restart.remain_time", FT_UINT16, BASE_DEC, NULL, 0x0, "How long the helper router will maintain the existing adjacency", HFILL }}, { &hf_isis_hello_clv_restart_neighbor, { "Restarting Neighbor ID", "isis.hello.clv_restart.neighbor", FT_BYTES, BASE_NONE, NULL, 0x0, "The System ID of the restarting neighbor", HFILL }} }; static gint *ett[] = { &ett_isis_hello, &ett_isis_hello_clv_area_addr, &ett_isis_hello_clv_is_neighbors, &ett_isis_hello_clv_padding, &ett_isis_hello_clv_unknown, &ett_isis_hello_clv_nlpid, &ett_isis_hello_clv_authentication, &ett_isis_hello_clv_ip_authentication, &ett_isis_hello_clv_ipv4_int_addr, &ett_isis_hello_clv_ipv6_int_addr, &ett_isis_hello_clv_ptp_adj, &ett_isis_hello_clv_mt, &ett_isis_hello_clv_restart, &ett_isis_hello_clv_restart_flags, &ett_isis_hello_clv_checksum }; proto_register_field_array(proto_isis, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }
void proto_register_radiotap(void) { static const value_string phy_type[] = { { 0, "Unknown" }, { IEEE80211_CHAN_A, "802.11a" }, { IEEE80211_CHAN_A | IEEE80211_CHAN_HT20, "802.11a (ht20)" }, { IEEE80211_CHAN_A | IEEE80211_CHAN_HT40U, "802.11a (ht40+)" }, { IEEE80211_CHAN_A | IEEE80211_CHAN_HT40D, "802.11a (ht40-)" }, { IEEE80211_CHAN_B, "802.11b" }, { IEEE80211_CHAN_PUREG, "802.11g (pure-g)" }, { IEEE80211_CHAN_G, "802.11g" }, { IEEE80211_CHAN_G | IEEE80211_CHAN_HT20, "802.11g (ht20)" }, { IEEE80211_CHAN_G | IEEE80211_CHAN_HT40U, "802.11g (ht40+)" }, { IEEE80211_CHAN_G | IEEE80211_CHAN_HT40D, "802.11g (ht40-)" }, { IEEE80211_CHAN_T, "802.11a (turbo)" }, { IEEE80211_CHAN_108PUREG, "802.11g (pure-g, turbo)" }, { IEEE80211_CHAN_108G, "802.11g (turbo)" }, { IEEE80211_CHAN_FHSS, "FHSS" }, { 0, NULL }, }; static const true_false_string preamble_type = { "Short", "Long", }; static hf_register_info hf[] = { { &hf_radiotap_version, { "Header revision", "radiotap.version", FT_UINT8, BASE_DEC, NULL, 0x0, "Version of radiotap header format", HFILL } }, { &hf_radiotap_pad, { "Header pad", "radiotap.pad", FT_UINT8, BASE_DEC, NULL, 0x0, "Padding", HFILL } }, { &hf_radiotap_length, { "Header length", "radiotap.length", FT_UINT16, BASE_DEC, NULL, 0x0, "Length of header including version, pad, length and data fields", HFILL } }, { &hf_radiotap_present, { "Present flags", "radiotap.present", FT_UINT32, BASE_HEX, NULL, 0x0, "Bitmask indicating which fields are present", HFILL } }, #define RADIOTAP_MASK_TSFT 0x00000001 #define RADIOTAP_MASK_FLAGS 0x00000002 #define RADIOTAP_MASK_RATE 0x00000004 #define RADIOTAP_MASK_CHANNEL 0x00000008 #define RADIOTAP_MASK_FHSS 0x00000010 #define RADIOTAP_MASK_DBM_ANTSIGNAL 0x00000020 #define RADIOTAP_MASK_DBM_ANTNOISE 0x00000040 #define RADIOTAP_MASK_LOCK_QUALITY 0x00000080 #define RADIOTAP_MASK_TX_ATTENUATION 0x00000100 #define RADIOTAP_MASK_DB_TX_ATTENUATION 0x00000200 #define RADIOTAP_MASK_DBM_TX_ATTENUATION 0x00000400 #define RADIOTAP_MASK_ANTENNA 0x00000800 #define RADIOTAP_MASK_DB_ANTSIGNAL 0x00001000 #define RADIOTAP_MASK_DB_ANTNOISE 0x00002000 #define RADIOTAP_MASK_RX_FLAGS 0x00004000 #define RADIOTAP_MASK_XCHANNEL 0x00040000 #define RADIOTAP_MASK_EXT 0x80000000 /* Boolean 'present' flags */ { &hf_radiotap_present_tsft, { "TSFT", "radiotap.present.tsft", FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_TSFT, "Specifies if the Time Synchronization Function Timer field is present", HFILL } }, { &hf_radiotap_present_flags, { "Flags", "radiotap.present.flags", FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_FLAGS, "Specifies if the channel flags field is present", HFILL } }, { &hf_radiotap_present_rate, { "Rate", "radiotap.present.rate", FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_RATE, "Specifies if the transmit/receive rate field is present", HFILL } }, { &hf_radiotap_present_channel, { "Channel", "radiotap.present.channel", FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_CHANNEL, "Specifies if the transmit/receive frequency field is present", HFILL } }, { &hf_radiotap_present_fhss, { "FHSS", "radiotap.present.fhss", FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_FHSS, "Specifies if the hop set and pattern is present for frequency hopping radios", HFILL } }, { &hf_radiotap_present_dbm_antsignal, { "DBM Antenna Signal", "radiotap.present.dbm_antsignal", FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_DBM_ANTSIGNAL, "Specifies if the antenna signal strength in dBm is present", HFILL } }, { &hf_radiotap_present_dbm_antnoise, { "DBM Antenna Noise", "radiotap.present.dbm_antnoise", FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_DBM_ANTNOISE, "Specifies if the RF noise power at antenna field is present", HFILL } }, { &hf_radiotap_present_lock_quality, { "Lock Quality", "radiotap.present.lock_quality", FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_LOCK_QUALITY, "Specifies if the signal quality field is present", HFILL } }, { &hf_radiotap_present_tx_attenuation, { "TX Attenuation", "radiotap.present.tx_attenuation", FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_TX_ATTENUATION, "Specifies if the transmit power from max power field is present", HFILL } }, { &hf_radiotap_present_db_tx_attenuation, { "DB TX Attenuation", "radiotap.present.db_tx_attenuation", FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_DB_TX_ATTENUATION, "Specifies if the transmit power from max power (in dB) field is present", HFILL } }, { &hf_radiotap_present_dbm_tx_attenuation, { "DBM TX Attenuation", "radiotap.present.dbm_tx_attenuation", FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_DBM_TX_ATTENUATION, "Specifies if the transmit power from max power (in dBm) field is present", HFILL } }, { &hf_radiotap_present_antenna, { "Antenna", "radiotap.present.antenna", FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_ANTENNA, "Specifies if the antenna number field is present", HFILL } }, { &hf_radiotap_present_db_antsignal, { "DB Antenna Signal", "radiotap.present.db_antsignal", FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_DB_ANTSIGNAL, "Specifies if the RF signal power at antenna in dB field is present", HFILL } }, { &hf_radiotap_present_db_antnoise, { "DB Antenna Noise", "radiotap.present.db_antnoise", FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_DB_ANTNOISE, "Specifies if the RF signal power at antenna in dBm field is present", HFILL } }, { &hf_radiotap_present_rxflags, { "RX flags", "radiotap.present.rxflags", FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_RX_FLAGS, "Specifies if the RX flags field is present", HFILL } }, { &hf_radiotap_present_hdrfcs, { "FCS in header", "radiotap.present.fcs", FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_RX_FLAGS, "Specifies if the FCS field is present", HFILL } }, { &hf_radiotap_present_xchannel, { "Channel+", "radiotap.present.xchannel", FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_XCHANNEL, "Specifies if the extended channel info field is present", HFILL } }, { &hf_radiotap_present_ext, { "Ext", "radiotap.present.ext", FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_EXT, "Specifies if there are any extensions to the header present", HFILL } }, /* Boolean 'present.flags' flags */ { &hf_radiotap_flags, { "Flags", "radiotap.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_radiotap_flags_cfp, { "CFP", "radiotap.flags.cfp", FT_BOOLEAN, 8, NULL, IEEE80211_RADIOTAP_F_CFP, "Sent/Received during CFP", HFILL } }, { &hf_radiotap_flags_preamble, { "Preamble", "radiotap.flags.preamble", FT_BOOLEAN, 8, TFS(&preamble_type), IEEE80211_RADIOTAP_F_SHORTPRE, "Sent/Received with short preamble", HFILL } }, { &hf_radiotap_flags_wep, { "WEP", "radiotap.flags.wep", FT_BOOLEAN, 8, NULL, IEEE80211_RADIOTAP_F_WEP, "Sent/Received with WEP encryption", HFILL } }, { &hf_radiotap_flags_frag, { "Fragmentation", "radiotap.flags.frag", FT_BOOLEAN, 8, NULL, IEEE80211_RADIOTAP_F_FRAG, "Sent/Received with fragmentation", HFILL } }, { &hf_radiotap_flags_fcs, { "FCS at end", "radiotap.flags.fcs", FT_BOOLEAN, 8, NULL, IEEE80211_RADIOTAP_F_FCS, "Frame includes FCS at end", HFILL } }, { &hf_radiotap_flags_datapad, { "Data Pad", "radiotap.flags.datapad", FT_BOOLEAN, 8, NULL, IEEE80211_RADIOTAP_F_DATAPAD, "Frame has padding between 802.11 header and payload", HFILL } }, { &hf_radiotap_flags_badfcs, { "Bad FCS", "radiotap.flags.badfcs", FT_BOOLEAN, 8, NULL, IEEE80211_RADIOTAP_F_BADFCS, "Frame received with bad FCS", HFILL } }, { &hf_radiotap_flags_shortgi, { "Short GI", "radiotap.flags.shortgi", FT_BOOLEAN, 8, NULL, IEEE80211_RADIOTAP_F_SHORTGI, "Frame Sent/Received with HT short Guard Interval", HFILL } }, { &hf_radiotap_mactime, { "MAC timestamp", "radiotap.mactime", FT_UINT64, BASE_DEC, NULL, 0x0, "Value in microseconds of the MAC's Time Synchronization Function timer when the first bit of the MPDU arrived at the MAC.", HFILL } }, { &hf_radiotap_quality, { "Signal Quality", "radiotap.quality", FT_UINT16, BASE_DEC, NULL, 0x0, "Signal quality (unitless measure)", HFILL } }, { &hf_radiotap_fcs, { "802.11 FCS", "radiotap.fcs", FT_UINT32, BASE_HEX, NULL, 0x0, "Frame check sequence of this frame", HFILL } }, { &hf_radiotap_channel, { "Channel", "radiotap.channel", FT_UINT32, BASE_DEC, NULL, 0x0, "802.11 channel number that this frame was sent/received on", HFILL } }, { &hf_radiotap_channel_frequency, { "Channel frequency", "radiotap.channel.freq", FT_UINT32, BASE_DEC, NULL, 0x0, "Channel frequency in megahertz that this frame was sent/received on", HFILL } }, { &hf_radiotap_channel_flags, { "Channel type", "radiotap.channel.type", FT_UINT16, BASE_HEX, VALS(phy_type), 0x0, NULL, HFILL } }, { &hf_radiotap_channel_flags_turbo, { "Turbo", "radiotap.channel.type.turbo", FT_BOOLEAN, 16, NULL, 0x0010, "Channel Type Turbo", HFILL } }, { &hf_radiotap_channel_flags_cck, { "Complementary Code Keying (CCK)", "radiotap.channel.type.cck", FT_BOOLEAN, 16, NULL, 0x0020, "Channel Type Complementary Code Keying (CCK) Modulation", HFILL } }, { &hf_radiotap_channel_flags_ofdm, { "Orthogonal Frequency-Division Multiplexing (OFDM)", "radiotap.channel.type.ofdm", FT_BOOLEAN, 16, NULL, 0x0040, "Channel Type Orthogonal Frequency-Division Multiplexing (OFDM)", HFILL } }, { &hf_radiotap_channel_flags_2ghz, { "2 GHz spectrum", "radiotap.channel.type.2ghz", FT_BOOLEAN, 16, NULL, 0x0080, "Channel Type 2 GHz spectrum", HFILL } }, { &hf_radiotap_channel_flags_5ghz, { "5 GHz spectrum", "radiotap.channel.type.5ghz", FT_BOOLEAN, 16, NULL, 0x0100, "Channel Type 5 GHz spectrum", HFILL } }, { &hf_radiotap_channel_flags_passive, { "Passive", "radiotap.channel.type.passive", FT_BOOLEAN, 16, NULL, 0x0200, "Channel Type Passive", HFILL } }, { &hf_radiotap_channel_flags_dynamic, { "Dynamic CCK-OFDM", "radiotap.channel.type.dynamic", FT_BOOLEAN, 16, NULL, 0x0400, "Channel Type Dynamic CCK-OFDM Channel", HFILL } }, { &hf_radiotap_channel_flags_gfsk, { "Gaussian Frequency Shift Keying (GFSK)", "radiotap.channel.type.gfsk", FT_BOOLEAN, 16, NULL, 0x0800, "Channel Type Gaussian Frequency Shift Keying (GFSK) Modulation", HFILL } }, { &hf_radiotap_channel_flags_gsm, { "GSM (900MHz)", "radiotap.channel.type.gsm", FT_BOOLEAN, 16, NULL, 0x1000, "Channel Type GSM", HFILL } }, { &hf_radiotap_channel_flags_sturbo, { "Static Turbo", "radiotap.channel.type.sturbo", FT_BOOLEAN, 16, NULL, 0x2000, "Channel Type Status Turbo", HFILL } }, { &hf_radiotap_channel_flags_half, { "Half Rate Channel (10MHz Channel Width)", "radiotap.channel.type.half", FT_BOOLEAN, 16, NULL, 0x4000, "Channel Type Half Rate", HFILL } }, { &hf_radiotap_channel_flags_quarter, { "Quarter Rate Channel (5MHz Channel Width)", "radiotap.channel.type.quarter", FT_BOOLEAN, 16, NULL, 0x8000, "Channel Type Quarter Rate", HFILL } }, { &hf_radiotap_rxflags, { "RX flags", "radiotap.rxflags", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_radiotap_rxflags_badplcp, { "Bad PLCP", "radiotap.rxflags.badplcp", FT_BOOLEAN, 24, NULL, IEEE80211_RADIOTAP_F_RX_BADPLCP, "Frame with bad PLCP", HFILL } }, { &hf_radiotap_xchannel, { "Channel number", "radiotap.xchannel", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_radiotap_xchannel_frequency, { "Channel frequency", "radiotap.xchannel.freq", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_radiotap_xchannel_flags, { "Channel type", "radiotap.xchannel.flags", FT_UINT32, BASE_HEX, VALS(phy_type), 0x0, NULL, HFILL } }, { &hf_radiotap_xchannel_flags_turbo, { "Turbo", "radiotap.xchannel.type.turbo", FT_BOOLEAN, 24, NULL, 0x0010, "Channel Type Turbo", HFILL } }, { &hf_radiotap_xchannel_flags_cck, { "Complementary Code Keying (CCK)", "radiotap.xchannel.type.cck", FT_BOOLEAN, 24, NULL, 0x0020, "Channel Type Complementary Code Keying (CCK) Modulation", HFILL } }, { &hf_radiotap_xchannel_flags_ofdm, { "Orthogonal Frequency-Division Multiplexing (OFDM)", "radiotap.xchannel.type.ofdm", FT_BOOLEAN, 24, NULL, 0x0040, "Channel Type Orthogonal Frequency-Division Multiplexing (OFDM)", HFILL } }, { &hf_radiotap_xchannel_flags_2ghz, { "2 GHz spectrum", "radiotap.xchannel.type.2ghz", FT_BOOLEAN, 24, NULL, 0x0080, "Channel Type 2 GHz spectrum", HFILL } }, { &hf_radiotap_xchannel_flags_5ghz, { "5 GHz spectrum", "radiotap.xchannel.type.5ghz", FT_BOOLEAN, 24, NULL, 0x0100, "Channel Type 5 GHz spectrum", HFILL } }, { &hf_radiotap_xchannel_flags_passive, { "Passive", "radiotap.channel.xtype.passive", FT_BOOLEAN, 24, NULL, 0x0200, "Channel Type Passive", HFILL } }, { &hf_radiotap_xchannel_flags_dynamic, { "Dynamic CCK-OFDM", "radiotap.xchannel.type.dynamic", FT_BOOLEAN, 24, NULL, 0x0400, "Channel Type Dynamic CCK-OFDM Channel", HFILL } }, { &hf_radiotap_xchannel_flags_gfsk, { "Gaussian Frequency Shift Keying (GFSK)", "radiotap.xchannel.type.gfsk", FT_BOOLEAN, 24, NULL, 0x0800, "Channel Type Gaussian Frequency Shift Keying (GFSK) Modulation", HFILL } }, { &hf_radiotap_xchannel_flags_gsm, { "GSM (900MHz)", "radiotap.xchannel.type.gsm", FT_BOOLEAN, 24, NULL, 0x1000, "Channel Type GSM", HFILL } }, { &hf_radiotap_xchannel_flags_sturbo, { "Static Turbo", "radiotap.xchannel.type.sturbo", FT_BOOLEAN, 24, NULL, 0x2000, "Channel Type Status Turbo", HFILL } }, { &hf_radiotap_xchannel_flags_half, { "Half Rate Channel (10MHz Channel Width)", "radiotap.xchannel.type.half", FT_BOOLEAN, 24, NULL, 0x4000, "Channel Type Half Rate", HFILL } }, { &hf_radiotap_xchannel_flags_quarter, { "Quarter Rate Channel (5MHz Channel Width)", "radiotap.xchannel.type.quarter", FT_BOOLEAN, 24, NULL, 0x8000, "Channel Type Quarter Rate", HFILL } }, { &hf_radiotap_xchannel_flags_ht20, { "HT Channel (20MHz Channel Width)", "radiotap.xchannel.type.ht20", FT_BOOLEAN, 24, NULL, 0x10000, "Channel Type HT/20", HFILL } }, { &hf_radiotap_xchannel_flags_ht40u, { "HT Channel (40MHz Channel Width with Extension channel above)", "radiotap.xchannel.type.ht40u", FT_BOOLEAN, 24, NULL, 0x20000, "Channel Type HT/40+", HFILL } }, { &hf_radiotap_xchannel_flags_ht40d, { "HT Channel (40MHz Channel Width with Extension channel below)", "radiotap.xchannel.type.ht40d", FT_BOOLEAN, 24, NULL, 0x40000, "Channel Type HT/40-", HFILL } }, #if 0 { &hf_radiotap_xchannel_maxpower, { "Max transmit power", "radiotap.xchannel.maxpower", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL } }, #endif { &hf_radiotap_fhss_hopset, { "FHSS Hop Set", "radiotap.fhss.hopset", FT_UINT8, BASE_DEC, NULL, 0x0, "Frequency Hopping Spread Spectrum hopset", HFILL } }, { &hf_radiotap_fhss_pattern, { "FHSS Pattern", "radiotap.fhss.pattern", FT_UINT8, BASE_DEC, NULL, 0x0, "Frequency Hopping Spread Spectrum hop pattern", HFILL } }, { &hf_radiotap_datarate, { "Data rate", "radiotap.datarate", FT_UINT32, BASE_DEC, NULL, 0x0, "Speed this frame was sent/received at", HFILL } }, { &hf_radiotap_antenna, { "Antenna", "radiotap.antenna", FT_UINT32, BASE_DEC, NULL, 0x0, "Antenna number this frame was sent/received over (starting at 0)", HFILL } }, { &hf_radiotap_dbm_antsignal, { "SSI Signal (dBm)", "radiotap.dbm_antsignal", FT_INT32, BASE_DEC, NULL, 0x0, "RF signal power at the antenna from a fixed, arbitrary value in decibels from one milliwatt", HFILL } }, { &hf_radiotap_db_antsignal, { "SSI Signal (dB)", "radiotap.db_antsignal", FT_UINT32, BASE_DEC, NULL, 0x0, "RF signal power at the antenna from a fixed, arbitrary value in decibels", HFILL } }, { &hf_radiotap_dbm_antnoise, { "SSI Noise (dBm)", "radiotap.dbm_antnoise", FT_INT32, BASE_DEC, NULL, 0x0, "RF noise power at the antenna from a fixed, arbitrary value in decibels per one milliwatt", HFILL } }, { &hf_radiotap_db_antnoise, { "SSI Noise (dB)", "radiotap.db_antnoise", FT_UINT32, BASE_DEC, NULL, 0x0, "RF noise power at the antenna from a fixed, arbitrary value in decibels", HFILL } }, { &hf_radiotap_tx_attenuation, { "Transmit attenuation", "radiotap.txattenuation", FT_UINT16, BASE_DEC, NULL, 0x0, "Transmit power expressed as unitless distance from max power set at factory (0 is max power)", HFILL } }, { &hf_radiotap_db_tx_attenuation, { "Transmit attenuation (dB)", "radiotap.db_txattenuation", FT_UINT16, BASE_DEC, NULL, 0x0, "Transmit power expressed as decibels from max power set at factory (0 is max power)", HFILL } }, { &hf_radiotap_txpower, { "Transmit power", "radiotap.txpower", FT_INT32, BASE_DEC, NULL, 0x0, "Transmit power in decibels per one milliwatt (dBm)", HFILL } }, /* Special variables */ { &hf_radiotap_fcs_bad, { "Bad FCS", "radiotap.fcs_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Specifies if this frame has a bad frame check sequence", HFILL } }, }; static gint *ett[] = { &ett_radiotap, &ett_radiotap_present, &ett_radiotap_flags, &ett_radiotap_rxflags, &ett_radiotap_channel_flags, &ett_radiotap_xchannel_flags }; module_t *radiotap_module; proto_radiotap = proto_register_protocol("IEEE 802.11 Radiotap Capture header", "802.11 Radiotap", "radiotap"); proto_register_field_array(proto_radiotap, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); register_dissector("radiotap", dissect_radiotap, proto_radiotap); radiotap_tap = register_tap("radiotap"); radiotap_module = prefs_register_protocol(proto_radiotap, NULL); prefs_register_bool_preference(radiotap_module, "bit14_fcs_in_header", "Assume bit 14 means FCS in header", "Radiotap has a bit to indicate whether the FCS is still on the frame or not. " "Some generators (e.g. AirPcap) use a non-standard radiotap flag 14 to put " "the FCS into the header.", &radiotap_bit14_fcs); }
void proto_register_frame(void) { static hf_register_info hf[] = { { &hf_frame_arrival_time, { "Arrival Time", "frame.time", FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL, NULL, 0x0, "Absolute time when this frame was captured", HFILL }}, { &hf_frame_shift_offset, { "Time shift for this packet", "frame.offset_shift", FT_RELATIVE_TIME, BASE_NONE, NULL, 0x0, "Time shift applied to this packet", HFILL }}, { &hf_frame_arrival_time_epoch, { "Epoch Time", "frame.time_epoch", FT_RELATIVE_TIME, BASE_NONE, NULL, 0x0, "Epoch time when this frame was captured", HFILL }}, { &hf_frame_time_delta, { "Time delta from previous captured frame", "frame.time_delta", FT_RELATIVE_TIME, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_frame_time_delta_displayed, { "Time delta from previous displayed frame", "frame.time_delta_displayed", FT_RELATIVE_TIME, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_frame_time_relative, { "Time since reference or first frame", "frame.time_relative", FT_RELATIVE_TIME, BASE_NONE, NULL, 0x0, "Time relative to time reference or first frame", HFILL }}, { &hf_frame_time_reference, { "This is a Time Reference frame", "frame.ref_time", FT_NONE, BASE_NONE, NULL, 0x0, "This frame is a Time Reference frame", HFILL }}, { &hf_frame_number, { "Frame Number", "frame.number", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_frame_len, { "Frame length on the wire", "frame.len", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_frame_capture_len, { "Frame length stored into the capture file", "frame.cap_len", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_frame_md5_hash, { "Frame MD5 Hash", "frame.md5_hash", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_frame_p2p_dir, { "Point-to-Point Direction", "frame.p2p_dir", FT_INT8, BASE_DEC, VALS(p2p_dirs), 0x0, NULL, HFILL }}, { &hf_link_number, { "Link Number", "frame.link_nr", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_frame_file_off, { "File Offset", "frame.file_off", FT_INT64, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_frame_marked, { "Frame is marked", "frame.marked", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Frame is marked in the GUI", HFILL }}, { &hf_frame_ignored, { "Frame is ignored", "frame.ignored", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Frame is ignored by the dissectors", HFILL }}, { &hf_frame_protocols, { "Protocols in frame", "frame.protocols", FT_STRING, BASE_NONE, NULL, 0x0, "Protocols carried by this frame", HFILL }}, { &hf_frame_color_filter_name, { "Coloring Rule Name", "frame.coloring_rule.name", FT_STRING, BASE_NONE, NULL, 0x0, "The frame matched the coloring rule with this name", HFILL }}, { &hf_frame_color_filter_text, { "Coloring Rule String", "frame.coloring_rule.string", FT_STRING, BASE_NONE, NULL, 0x0, "The frame matched this coloring rule string", HFILL }}, { &hf_frame_interface_id, { "Interface id", "frame.interface_id", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_frame_pack_flags, { "Packet flags", "frame.packet_flags", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_frame_pack_direction, { "Direction", "frame.packet_flags_direction", FT_UINT32, BASE_HEX, VALS(packet_word_directions), PACKET_WORD_DIRECTION_MASK, NULL, HFILL }}, { &hf_frame_pack_reception_type, { "Reception type", "frame.packet_flags_reception_type", FT_UINT32, BASE_DEC, VALS(packet_word_reception_types), PACKET_WORD_RECEPTION_TYPE_MASK, NULL, HFILL }}, { &hf_frame_pack_fcs_length, { "FCS length", "frame.packet_flags_fcs_length", FT_UINT32, BASE_DEC, NULL, PACKET_WORD_FCS_LENGTH_MASK, NULL, HFILL }}, { &hf_frame_pack_reserved, { "Reserved", "frame.packet_flags_reserved", FT_UINT32, BASE_DEC, NULL, PACKET_WORD_RESERVED_MASK, NULL, HFILL }}, { &hf_frame_pack_crc_error, { "CRC error", "frame.packet_flags_crc_error", FT_BOOLEAN, 32, TFS(&tfs_set_notset), PACKET_WORD_CRC_ERR_MASK, NULL, HFILL }}, { &hf_frame_pack_wrong_packet_too_long_error, { "Packet too long error", "frame.packet_flags_packet_too_error", FT_BOOLEAN, 32, TFS(&tfs_set_notset), PACKET_WORD_PACKET_TOO_LONG_ERR_MASK, NULL, HFILL }}, { &hf_frame_pack_wrong_packet_too_short_error, { "Packet too short error", "frame.packet_flags_packet_too_short_error", FT_BOOLEAN, 32, TFS(&tfs_set_notset), PACKET_WORD_PACKET_TOO_SHORT_ERR_MASK, NULL, HFILL }}, { &hf_frame_pack_wrong_inter_frame_gap_error, { "Wrong interframe gap error", "frame.packet_flags_wrong_inter_frame_gap_error", FT_BOOLEAN, 32, TFS(&tfs_set_notset), PACKET_WORD_WRONG_INTER_FRAME_GAP_ERR_MASK, NULL, HFILL }}, { &hf_frame_pack_unaligned_frame_error, { "Unaligned frame error", "frame.packet_flags_unaligned_frame_error", FT_BOOLEAN, 32, TFS(&tfs_set_notset), PACKET_WORD_UNALIGNED_FRAME_ERR_MASK, NULL, HFILL }}, { &hf_frame_pack_start_frame_delimiter_error, { "Start frame delimiter error", "frame.packet_flags_start_frame_delimiter_error", FT_BOOLEAN, 32, TFS(&tfs_set_notset), PACKET_WORD_START_FRAME_DELIMITER_ERR_MASK, NULL, HFILL }}, { &hf_frame_pack_preamble_error, { "Preamble error", "frame.packet_flags_preamble_error", FT_BOOLEAN, 32, TFS(&tfs_set_notset), PACKET_WORD_PREAMBLE_ERR_MASK, NULL, HFILL }}, { &hf_frame_pack_symbol_error, { "Symbol error", "frame.packet_flags_symbol_error", FT_BOOLEAN, 32, TFS(&tfs_set_notset), PACKET_WORD_SYMBOL_ERR_MASK, NULL, HFILL }}, { &hf_comments_text, { "Comment", "frame.comment", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }}, }; static hf_register_info hf_encap = { &hf_frame_wtap_encap, { "Encapsulation type", "frame.encap_type", FT_INT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}; static gint *ett[] = { &ett_frame, &ett_flags, &ett_comments }; static ei_register_info ei[] = { { &ei_comments_text, { "frame.comment.expert", PI_COMMENTS_GROUP, PI_COMMENT, "Formatted comment", EXPFILL }}, { &ei_arrive_time_out_of_range, { "frame.time_invalid", PI_SEQUENCE, PI_NOTE, "Arrival Time: Fractional second out of range (0-1000000000)", EXPFILL }}, }; module_t *frame_module; expert_module_t* expert_frame; if (hf_encap.hfinfo.strings == NULL) { int encap_count = wtap_get_num_encap_types(); value_string *arr; int i; hf_encap.hfinfo.strings = arr = g_new(value_string, encap_count+1); for (i = 0; i < encap_count; i++) { arr[i].value = i; arr[i].strptr = wtap_encap_string(i); } arr[encap_count].value = 0; arr[encap_count].strptr = NULL; } wtap_encap_dissector_table = register_dissector_table("wtap_encap", "Wiretap encapsulation type", FT_UINT32, BASE_DEC); wtap_fts_rec_dissector_table = register_dissector_table("wtap_fts_rec", "Wiretap file type for file-type-specific records", FT_UINT32, BASE_DEC); proto_frame = proto_register_protocol("Frame", "Frame", "frame"); proto_pkt_comment = proto_register_protocol("Packet comments", "Pkt_Comment", "pkt_comment"); proto_register_field_array(proto_frame, hf, array_length(hf)); proto_register_field_array(proto_frame, &hf_encap, 1); proto_register_subtree_array(ett, array_length(ett)); expert_frame = expert_register_protocol(proto_frame); expert_register_field_array(expert_frame, ei, array_length(ei)); new_register_dissector("frame",dissect_frame,proto_frame); /* You can't disable dissection of "Frame", as that would be tantamount to not doing any dissection whatsoever. */ proto_set_cant_toggle(proto_frame); /* Our preferences */ frame_module = prefs_register_protocol(proto_frame, NULL); prefs_register_bool_preference(frame_module, "show_file_off", "Show File Offset", "Show offset of frame in capture file", &show_file_off); prefs_register_bool_preference(frame_module, "force_docsis_encap", "Treat all frames as DOCSIS frames", "Treat all frames as DOCSIS Frames", &force_docsis_encap); prefs_register_bool_preference(frame_module, "generate_md5_hash", "Generate an MD5 hash of each frame", "Whether or not MD5 hashes should be generated for each frame, useful for finding duplicate frames.", &generate_md5_hash); prefs_register_bool_preference(frame_module, "generate_epoch_time", "Generate an epoch time entry for each frame", "Whether or not an Epoch time entry should be generated for each frame.", &generate_epoch_time); prefs_register_bool_preference(frame_module, "generate_bits_field", "Show the number of bits in the frame", "Whether or not the number of bits in the frame should be shown.", &generate_bits_field); frame_tap=register_tap("frame"); }
void proto_register_itdm(void) { static hf_register_info hf[] = { { &hf_itdm_timestamp,{ "Timestamp", "itdm.timestamp", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_itdm_seqnum,{ "Sequence Number", "itdm.seqnum", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_itdm_sop_eop,{ "Start/End of Packet", "itdm.sop_eop", FT_UINT8, BASE_DEC, VALS(sop_eop_vals), 0xc0, NULL, HFILL } }, { &hf_itdm_last_pack,{ "Last Packet", "itdm.last_pack", FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x20, NULL, HFILL } }, { &hf_itdm_pktlen,{ "Packet Length", "itdm.pktlen", FT_UINT16, BASE_DEC, NULL, 0x07ff, NULL, HFILL } }, { &hf_itdm_chksum,{ "Checksum", "itdm.chksum", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_itdm_uid,{ "Flow ID", "itdm.uid", FT_UINT24, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_itdm_ack,{ "ACK", "itdm.ack", FT_BOOLEAN, 8, TFS(&ack_tfs), 0x20, NULL, HFILL } }, { &hf_itdm_act,{ "Activate", "itdm.act", FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x10, NULL, HFILL } }, { &hf_itdm_chcmd,{ "Channel Command", "itdm.chcmd", FT_UINT8, BASE_DEC, VALS(chcmd_vals), 0x0f, NULL, HFILL } }, { &hf_itdm_chid,{ "Channel ID", "itdm.chid", FT_UINT24, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_itdm_chloc1,{ "Channel Location 1", "itdm.chloc1", FT_UINT16, BASE_DEC, NULL, 0x1ff, NULL, HFILL } }, { &hf_itdm_chloc2,{ "Channel Location 2", "itdm.chloc2", FT_UINT16, BASE_DEC, NULL, 0x1ff, NULL, HFILL } }, { &hf_itdm_pktrate,{ "IEEE 754 Packet Rate", "itdm.pktrate", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_itdm_cxnsize, { "Connection Size", "itdm.cxnsize", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_itdm_ctl_transid, { "Transaction ID", "itdm.ctl_transid", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_itdm_ctl_command, { "Control Command", "itdm.ctl_cmd", FT_UINT8, BASE_DEC, VALS(itdm_ctl_command_vals), 0x0, NULL, HFILL } }, { &hf_itdm_ctl_flowid, { "Allocated Flow ID", "itdm.ctl_flowid", FT_UINT24, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_itdm_ctl_dm, { "I-TDM Data Mode", "itdm.ctl_dm", FT_UINT8, BASE_DEC, VALS(itdm_ctl_data_mode_vals), 0x0, NULL, HFILL } }, { &hf_itdm_ctl_emts, { "I-TDM Explicit Multi-timeslot Size", "itdm.ctlemts", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_itdm_ctl_pktrate, { "I-TDM Packet Rate", "itdm.ctl_pktrate", FT_UINT32, BASE_HEX, VALS(itdm_ctl_pktrate_vals), 0x0, NULL, HFILL } }, { &hf_itdm_ctl_ptid, { "Paired Transaction ID", "itdm.ctl_ptid", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_itdm_ctl_cksum, { "ITDM Control Message Checksum", "itdm.ctl_cksum", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } } }; static gint *ett[] = { &ett_itdm, &ett_itdm_ctl }; module_t *itdm_module; proto_itdm = proto_register_protocol("Internal TDM", "ITDM", "itdm"); register_dissector("itdm", dissect_itdm, proto_itdm); proto_register_field_array(proto_itdm, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); itdm_module = prefs_register_protocol(proto_itdm, proto_reg_handoff_itdm); prefs_register_uint_preference(itdm_module, "mpls_label", "ITDM MPLS label (Flow Bundle ID in hex)", "The MPLS label (aka Flow Bundle ID) used by ITDM traffic.", 16, &gbl_ItdmMPLSLabel); prefs_register_uint_preference(itdm_module, "ctl_flowno", "I-TDM Control Protocol Flow Number", "Flow Number used by I-TDM Control Protocol traffic.", 10, &gbl_ItdmCTLFlowNo); }
/* Register VxLAN with Wireshark */ void proto_register_vxlan(void) { static hf_register_info hf[] = { { &hf_vxlan_flags, { "Flags", "vxlan.flags", FT_UINT8, BASE_HEX, NULL, 0x00, NULL, HFILL }, }, { &hf_vxlan_flag_b7, { "Reserved(R)", "vxlan.flag_b7", FT_BOOLEAN, 8, NULL, 0x80, NULL, HFILL, }, }, { &hf_vxlan_flag_b6, { "Reserved(R)", "vxlan.flag_b6", FT_BOOLEAN, 8, NULL, 0x40, NULL, HFILL, }, }, { &hf_vxlan_flag_b5, { "Reserved(R)", "vxlan.flag_b5", FT_BOOLEAN, 8, NULL, 0x20, NULL, HFILL, }, }, { &hf_vxlan_flag_b4, { "Reserved(R)", "vxlan.flag_b4", FT_BOOLEAN, 8, NULL, 0x10, NULL, HFILL, }, }, { &hf_vxlan_flag_i, { "VXLAN Network ID(VNI)", "vxlan.flag_i", FT_BOOLEAN, 8, TFS(&tfs_present_not_present), 0x08, NULL, HFILL, }, }, { &hf_vxlan_flag_b2, { "Reserved(R)", "vxlan.flag_b2", FT_BOOLEAN, 8, NULL, 0x10, NULL, HFILL, }, }, { &hf_vxlan_flag_b1, { "Reserved(R)", "vxlan.flag_b1", FT_BOOLEAN, 8, NULL, 0x10, NULL, HFILL, }, }, { &hf_vxlan_flag_b0, { "Reserved(R)", "vxlan.flag_b0", FT_BOOLEAN, 8, NULL, 0x10, NULL, HFILL, }, }, { &hf_vxlan_reserved_24, { "Reserved", "vxlan.reserved24", FT_UINT24, BASE_HEX, NULL, 0x00, NULL, HFILL }, }, { &hf_vxlan_vni, { "VXLAN Network Identifier (VNI)", "vxlan.vni", FT_UINT24, BASE_DEC, NULL, 0x00, NULL, HFILL }, }, { &hf_vxlan_reserved_8, { "Reserved", "vxlan.reserved8", FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL }, }, }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_vxlan, &ett_vxlan_flgs, }; /* Register the protocol name and description */ proto_vxlan = proto_register_protocol("Virtual eXtensible Local Area Network", "VXLAN", "vxlan"); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_vxlan, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }
void proto_register_clnp(void) { static hf_register_info hf[] = { { &hf_clnp_id, { "Network Layer Protocol Identifier", "clnp.nlpi", FT_UINT8, BASE_HEX, VALS(nlpid_vals), 0x0, NULL, HFILL }}, { &hf_clnp_length, { "HDR Length", "clnp.len", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_clnp_version, { "Version", "clnp.version", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_clnp_ttl, { "Holding Time", "clnp.ttl", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_clnp_type, { "PDU Type", "clnp.type", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_clnp_cnf_segmentation, { "Segmentation permitted", "clnp.cnf.segmentation", FT_BOOLEAN, 8, TFS(&tfs_yes_no), CNF_SEG_OK, NULL, HFILL }}, { &hf_clnp_cnf_more_segments, { "More segments", "clnp.cnf.more_segments", FT_BOOLEAN, 8, TFS(&tfs_yes_no), CNF_MORE_SEGS, NULL, HFILL }}, { &hf_clnp_cnf_report_error, { "Report error if PDU discarded", "clnp.cnf.report_error", FT_BOOLEAN, 8, TFS(&tfs_yes_no), CNF_ERR_OK, NULL, HFILL }}, { &hf_clnp_cnf_type, { "Type", "clnp.cnf.type", FT_UINT8, BASE_DEC, VALS(npdu_type_vals), CNF_TYPE, NULL, HFILL }}, { &hf_clnp_pdu_length, { "PDU length", "clnp.pdu.len", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_clnp_checksum, { "Checksum", "clnp.checksum", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_clnp_dest_length, { "DAL", "clnp.dsap.len", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_clnp_dest, { "DA", "clnp.dsap", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_clnp_src_length, { "SAL", "clnp.ssap.len", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_clnp_src, { "SA", "clnp.ssap", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_clnp_atntt, { "ATN traffic type", "clnp.atn.tt", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_clnp_atnsc, { "ATN security classification", "clnp.atn.sc", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_clnp_segment_overlap, { "Segment overlap", "clnp.segment.overlap", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Segment overlaps with other segments", HFILL }}, { &hf_clnp_segment_overlap_conflict, { "Conflicting data in segment overlap", "clnp.segment.overlap.conflict", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Overlapping segments contained conflicting data", HFILL }}, { &hf_clnp_segment_multiple_tails, { "Multiple tail segments found", "clnp.segment.multipletails", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Several tails were found when reassembling the packet", HFILL }}, { &hf_clnp_segment_too_long_segment, { "Segment too long", "clnp.segment.toolongsegment", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Segment contained data past end of packet", HFILL }}, { &hf_clnp_segment_error, { "Reassembly error", "clnp.segment.error", FT_FRAMENUM, BASE_NONE, NULL, 0x0, "Reassembly error due to illegal segments", HFILL }}, { &hf_clnp_segment_count, { "Segment count", "clnp.segment.count", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_clnp_segment, { "CLNP Segment", "clnp.segment", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_clnp_segments, { "CLNP Segments", "clnp.segments", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_clnp_reassembled_in, { "Reassembled CLNP in frame", "clnp.reassembled_in", FT_FRAMENUM, BASE_NONE, NULL, 0x0, "This CLNP packet is reassembled in this frame", HFILL }}, { &hf_clnp_reassembled_length, { "Reassembled CLNP length", "clnp.reassembled.length", FT_UINT32, BASE_DEC, NULL, 0x0, "The total length of the reassembled payload", HFILL }} }; static gint *ett[] = { &ett_clnp, &ett_clnp_type, &ett_clnp_segments, &ett_clnp_segment, &ett_clnp_disc_pdu, }; module_t *clnp_module; proto_clnp = proto_register_protocol(PROTO_STRING_CLNP, "CLNP", "clnp"); proto_register_field_array(proto_clnp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); register_dissector("clnp", dissect_clnp, proto_clnp); register_heur_dissector_list("clnp", &clnp_heur_subdissector_list); register_init_routine(clnp_reassemble_init); clnp_module = prefs_register_protocol(proto_clnp, NULL); prefs_register_uint_preference(clnp_module, "tp_nsap_selector", "NSAP selector for Transport Protocol (last byte in hex)", "NSAP selector for Transport Protocol (last byte in hex)", 16, &tp_nsap_selector); prefs_register_bool_preference(clnp_module, "always_decode_transport", "Always try to decode NSDU as transport PDUs", "Always try to decode NSDU as transport PDUs", &always_decode_transport); prefs_register_bool_preference(clnp_module, "reassemble", "Reassemble segmented CLNP datagrams", "Whether segmented CLNP datagrams should be reassembled", &clnp_reassemble); prefs_register_bool_preference(clnp_module, "decode_atn_options", "Decode ATN security label", "Whether ATN security label should be decoded", &clnp_decode_atn_options); }
static header_field_info hfi_png_chunk_len PNG_HFI_INIT = { "Len", "png.chunk.len", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }; static header_field_info hfi_png_chunk_crc PNG_HFI_INIT = { "CRC", "png.chunk.crc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }; static const true_false_string png_chunk_anc = { "This is an ANCILLARY chunk", "This is a CRITICAL chunk" }; static header_field_info hfi_png_chunk_flag_anc PNG_HFI_INIT = { "Ancillary", "png.chunk.flag.ancillary", FT_BOOLEAN, 32, TFS(&png_chunk_anc), 0x20000000, NULL, HFILL }; static const true_false_string png_chunk_priv = { "This is a PRIVATE chunk", "This is a PUBLIC chunk" }; static header_field_info hfi_png_chunk_flag_priv PNG_HFI_INIT = { "Private", "png.chunk.flag.private", FT_BOOLEAN, 32, TFS(&png_chunk_priv), 0x00200000, NULL, HFILL }; static const true_false_string png_chunk_stc = { "This chunk is SAFE TO COPY", "This chunk is NOT safe to copy" };
/* Register Wimax Mac Payload Protocol and Dissector */ void proto_register_mac_mgmt_msg_rng_rsp(void) { /* RNG-RSP fields display */ static hf_register_info hf[] = { { &hf_rng_rsp_broadcast, { "AAS broadcast permission", "wmx.rng_rsp.aas_broadcast", FT_BOOLEAN, BASE_NONE, TFS(&tfs_rng_rsp_aas_broadcast), 0x0, NULL, HFILL } }, { &hf_rng_rsp_akid, { "AKId", "wmx.rng_rsp.akid", FT_BYTES, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_rng_rsp_basic_cid, { "Basic CID", "wmx.rng_rsp.basic_cid", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_rng_rsp_bs_random, { "BS_Random", "wmx.rng_rsp.bs_random", FT_BYTES, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_rng_rsp_config_change_count_of_dcd, { "Configuration Change Count value of DCD defining DIUC associated burst profile", "wmx.rng_rsp.config_change_count_of_dcd", FT_UINT16, BASE_HEX, NULL, 0xFF00, NULL, HFILL } }, { &hf_rng_rsp_dl_freq_override, { "Downlink Frequency Override", "wmx.rng_rsp.dl_freq_override", FT_UINT32, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_rng_rsp_dl_operational_burst_profile_ccc, { "CCC value of DCD defining the burst profile associated with DIUC", "wmx.rng_rsp.dl_op_burst_prof.ccc", FT_UINT16, BASE_DEC, NULL, 0x00FF, NULL, HFILL } }, { &hf_rng_rsp_dl_operational_burst_profile_diuc, { "The least robust DIUC that may be used by the BS for transmissions to the SS", "wmx.rng_rsp.dl_op_burst_prof.diuc", FT_UINT16, BASE_DEC, NULL, 0xFF00, NULL, HFILL } }, { &hf_rng_rsp_dl_operational_burst_profile, { "Downlink Operational Burst Profile", "wmx.rng_rsp.dl_op_burst_profile", FT_UINT16, BASE_HEX, NULL, 0x00, NULL, HFILL } }, /* Added the following to help implement RNG-RSP message encoding 33 (Table 367 in IEEE 802.16e-2007) */ { &hf_rng_rsp_dl_op_burst_profile_ofdma, { "Downlink Operational Burst Profile for OFDMA", "wmx.rng_rsp.dl_op_burst_profile_ofdma", FT_UINT16, BASE_HEX, NULL, 0x00, NULL, HFILL } }, { &hf_rng_rsp_frame_number2, { "The 8 least significant bits of the frame number of the OFDMA frame where the SS sent the ranging code", "wmx.rng_rsp.eight_bit_frame_num", FT_UINT32, BASE_DEC, NULL, 0x000000FF, NULL, HFILL } }, { &hf_rng_rsp_frame_number, { "Frame number", "wmx.rng_rsp.frame_number", FT_UINT24, BASE_DEC, NULL, 0x00, NULL, HFILL } }, /* Added the following to help implement RNG-RSP message encoding 22 (IEEE 802.16e-2007) */ { &hf_rng_rsp_ho_id, { "HO ID", "wmx.rng_rsp.ho_id", FT_UINT8, BASE_HEX, NULL, 0x00, NULL, HFILL } }, { &hf_rng_rsp_ho_process_optimization, { "HO Process Optimization", "wmx.rng_rsp.ho_process_optimization", FT_UINT16, BASE_HEX, NULL, 0x0000, NULL, HFILL } }, { &hf_rng_rsp_ho_process_optimization_0, { "Bit #0", "wmx.rng_rsp.ho_process_optimization.omit_sbc_req", FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_ho_process_optimization_0), 0x0001, NULL, HFILL } }, { &hf_rng_rsp_ho_process_optimization_1_2, { "Bits #1-2", "wmx.rng_rsp.ho_process_optimization.perform_reauthentication", FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_ho_process_optimization_1_2), 0x0006, NULL, HFILL } }, { &hf_rng_rsp_ho_process_optimization_3, { "Bit #3", "wmx.rng_rsp.ho_process_optimization.omit_network_address", FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_ho_process_optimization_3), 0x0008, NULL, HFILL } }, { &hf_rng_rsp_ho_process_optimization_4, { "Bit #4", "wmx.rng_rsp.ho_process_optimization.omit_time_of_day", FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_ho_process_optimization_4), 0x0010, NULL, HFILL } }, { &hf_rng_rsp_ho_process_optimization_5, { "Bit #5", "wmx.rng_rsp.ho_process_optimization.omit_tftp", FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_ho_process_optimization_5), 0x0020, NULL, HFILL } }, { &hf_rng_rsp_ho_process_optimization_6, { "Bit #6", "wmx.rng_rsp.ho_process_optimization.transfer_or_sharing", FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_ho_process_optimization_6), 0x0040, NULL, HFILL } }, { &hf_rng_rsp_ho_process_optimization_7, { "Bit #7", "wmx.rng_rsp.ho_process_optimization.omit_reg_req", FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_ho_process_optimization_7), 0x0080, NULL, HFILL } }, { &hf_rng_rsp_ho_process_optimization_8, { "Bit #8", "wmx.rng_rsp.ho_process_optimization.unsolicited_sbc_rsp", FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_ho_process_optimization_8), 0x0100, NULL, HFILL } }, { &hf_rng_rsp_ho_process_optimization_9, { "Bit #9", "wmx.rng_rsp.ho_process_optimization.post_ho_reentry", FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_ho_process_optimization_9), 0x0200, NULL, HFILL } }, { &hf_rng_rsp_ho_process_optimization_10, { "Bit #10", "wmx.rng_rsp.ho_process_optimization.unsolicited_reg_rsp", FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_ho_process_optimization_10), 0x0400, NULL, HFILL } }, { &hf_rng_rsp_ho_process_optimization_11, { "Bit #11", "wmx.rng_rsp.ho_process_optimization.virtual_sdu_sn", FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_ho_process_optimization_11), 0x0800, NULL, HFILL } }, { &hf_rng_rsp_ho_process_optimization_12, { "Bit #12", "wmx.rng_rsp.ho_process_optimization.send_notification", FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_ho_process_optimization_12), 0x1000, NULL, HFILL } }, { &hf_rng_rsp_ho_process_optimization_13, { "Bit #13", "wmx.rng_rsp.ho_process_optimization.trigger_higher_layer_protocol", FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_ho_process_optimization_13), 0x2000, NULL, HFILL } }, { &hf_rng_rsp_ho_process_optimization_14, { "Bit #14: Reserved", "wmx.rng_rsp.ho_process_optimization.reserved", FT_UINT16, BASE_HEX, NULL, 0x4000, NULL, HFILL } }, { &hf_rng_rsp_ho_process_optimization_15, { "Bit #15: Reserved", "wmx.rng_rsp.ho_process_optimization.reserved", FT_UINT16, BASE_HEX, NULL, 0x8000, NULL, HFILL } }, { &hf_rng_invalid_tlv, { "Invalid TLV", "wmx.rng_rsp.invalid_tlv", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_rng_rsp_least_robust_diuc, { "Least Robust DIUC that may be used by the BS for transmissions to the MS", "wmx.rng_rsp.least_robust_diuc", FT_UINT16, BASE_HEX, NULL, 0x000F, NULL, HFILL } }, { &hf_rng_rsp_location_update_response, { "Location Update Response", "wmx.rng_rsp.location_update_response", FT_UINT8, BASE_DEC, VALS(vals_rng_rsp_location_update_response), 0xFF, NULL, HFILL } }, { &hf_rng_rsp_offset_freq_adjust, { "Offset Frequency Adjust", "wmx.rng_rsp.offset_freq_adjust", FT_INT32, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_rng_rsp_opportunity_number, { "Initial ranging opportunity number", "wmx.rng_rsp.opportunity_number", FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_rng_rsp_paging_cycle, { "Paging Cycle", "wmx.rng_rsp.paging_cycle", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_rng_rsp_paging_group_id, { "Paging Group ID", "wmx.rng_rsp.paging_group_id", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_rng_rsp_paging_information, { "Paging Information", "wmx.rng_rsp.paging_information", FT_BYTES, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_rng_rsp_paging_offset, { "Paging Offset", "wmx.rng_rsp.paging_offset", FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_rng_rsp_power_level_adjust, { "Power Level Adjust", "wmx.rng_rsp.power_level_adjust", FT_FLOAT, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_rng_rsp_primary_mgmt_cid, { "Primary Management CID", "wmx.rng_rsp.primary_mgmt_cid", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_rng_rsp_ranging_code_index, { "The ranging code index that was sent by the SS", "wmx.rng_rsp.ranging_code_index", FT_UINT32, BASE_DEC, NULL, 0x0000FF00, NULL, HFILL } }, { &hf_rng_rsp_ranging_status, { "Ranging status", "wmx.rng_rsp.ranging_status", FT_UINT8, BASE_DEC, VALS(vals_rng_rsp_ranging_status), 0x00, NULL, HFILL } }, { &hf_rng_rsp_ranging_subchan, { "Ranging code attributes", "wmx.rng_rsp.ranging_subchannel", FT_UINT32, BASE_HEX, NULL, 0x00, NULL, HFILL } }, { &hf_rng_rsp_repetition_coding_indication, { "Repetition Coding Indication", "wmx.rng_rsp.repetition_coding_indication", FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_repetition_coding_indication), 0x00F0, NULL, HFILL } }, { &hf_rng_req_reserved, { "Reserved", "wmx.rng_rsp.reserved", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_rng_rsp_resource_retain_flag, { "The connection information for the MS is", "wmx.rng_rsp.resource_retain_flag", FT_BOOLEAN, BASE_NONE, TFS(&tfs_rng_rsp_resource_retain_flag), 0x0, NULL, HFILL } }, { &hf_rng_rsp_service_level_prediction, { "Service Level Prediction", "wmx.rng_rsp.service_level_prediction", FT_UINT8, BASE_DEC, VALS(vals_rng_rsp_level_of_service), 0x00, NULL, HFILL } }, { &hf_rng_rsp_ss_mac_address, { "SS MAC Address", "wmx.rng_rsp.ss_mac_address", FT_ETHER, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_rng_rsp_subchannel_reference, { "OFDMA subchannel reference used to transmit the ranging code", "wmx.rng_rsp.subchannel_reference", FT_UINT32, BASE_DEC, NULL, 0x003f0000, NULL, HFILL } }, { &hf_rng_rsp_time_symbol_reference, { "OFDM time symbol reference used to transmit the ranging code", "wmx.rng_rsp.time_symbol_reference", FT_UINT32, BASE_DEC, NULL, 0xFFC00000, NULL, HFILL } }, { &hf_rng_rsp_timing_adjust, { "Timing Adjust", "wmx.rng_rsp.timing_adjust", FT_FLOAT, BASE_NONE, NULL, 0x00, NULL, HFILL } }, #if 0 { &hf_rng_rsp_ul_channel_id, { "Uplink Channel ID", "wmx.rng_rsp.ul_chan_id", FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL } }, #endif { &hf_rng_rsp_ul_chan_id_override, { "Uplink channel ID Override", "wmx.rng_rsp.ul_chan_id_override", FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL } }, { &hf_tlv_type, { "Unknown TLV Type", "wmx.rng_rsp.unknown_tlv_type", FT_BYTES, BASE_NONE, NULL, 0x00, NULL, HFILL } }, #if 0 { &hf_tlv_value, { "Value", "wmx.rng_rsp.tlv_value", FT_BYTES, BASE_NONE, NULL, 0x00, NULL, HFILL } } #endif }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_mac_mgmt_msg_rng_rsp_decoder, &ett_rng_rsp_message_tree }; proto_mac_mgmt_msg_rng_rsp_decoder = proto_register_protocol ( "WiMax RNG-RSP Messages", /* name */ "WiMax RNG-RSP", /* short name */ "wmx.rng_rsp" /* abbrev */ ); proto_register_field_array(proto_mac_mgmt_msg_rng_rsp_decoder, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }
void proto_register_csm_encaps(void) { static struct true_false_string control_endian_bit = {"Little Endian","Big Endian"}; static struct true_false_string control_ack_bit = {"ACK Packet", "Message Packet"}; static struct true_false_string control_ack_suppress_bit = {"ACK Suppressed", "ACK Required"}; static hf_register_info hf[] = { { &hf_csm_encaps_opcode, { "Opcode", "csm_encaps.opcode", FT_UINT16, BASE_HEX, VALS(opcode_vals), 0, "CSM_ENCAPS Opcode", HFILL } }, { &hf_csm_encaps_seq, { "Sequence Number", "csm_encaps.seq_num", FT_UINT8, BASE_DEC, NULL, 0, "CSM_ENCAPS Sequence Number", HFILL } }, { &hf_csm_encaps_ctrl, { "Control", "csm_encaps.ctrl", FT_UINT8, BASE_HEX, NULL, 0, "CSM_ENCAPS Control", HFILL } }, { &hf_csm_encaps_ctrl_ack, { "Packet Bit", "csm_encaps.ctrl.ack", FT_BOOLEAN, 8, TFS(&control_ack_bit), CSM_ENCAPS_CTRL_ACK, "Message Packet/ACK Packet", HFILL } }, { &hf_csm_encaps_ctrl_ack_suppress, { "ACK Suppress Bit", "csm_encaps.ctrl.ack_suppress", FT_BOOLEAN, 8, TFS(&control_ack_suppress_bit), CSM_ENCAPS_CTRL_ACK_SUPPRESS, "ACK Required/ACK Suppressed", HFILL } }, { &hf_csm_encaps_ctrl_endian, { "Endian Bit", "csm_encaps.ctrl.endian", FT_BOOLEAN, 8, TFS(&control_endian_bit), CSM_ENCAPS_CTRL_ENDIAN, "Little Endian/Big Endian", HFILL } }, { &hf_csm_encaps_channel, { "Channel Number", "csm_encaps.channel", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Channel Number", HFILL } }, { &hf_csm_encaps_index, { "Index", "csm_encaps.index", FT_UINT8, BASE_DEC, NULL, 0, "CSM_ENCAPS Index", HFILL } }, { &hf_csm_encaps_length, { "Length", "csm_encaps.length", FT_UINT8, BASE_DEC, NULL, 0, "CSM_ENCAPS Length", HFILL } }, { &hf_csm_encaps_class, { "Class", "csm_encaps.class", FT_UINT8, BASE_DEC, NULL, 0, "CSM_ENCAPS Class", HFILL } }, { &hf_csm_encaps_type, { "Type", "csm_encaps.type", FT_UINT8, BASE_DEC, NULL, 0, "CSM_ENCAPS Type", HFILL } }, { &hf_csm_encaps_function_code, { "Function Code", "csm_encaps.function_code", FT_UINT16, BASE_HEX, VALS(function_code_vals), 0, "CSM_ENCAPS Function Code", HFILL } }, { &hf_csm_encaps_reserved, { "Reserved", "csm_encaps.reserved", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Reserved", HFILL } }, { &hf_csm_encaps_param_error, { "Parameter 1", "csm_encaps.param1", FT_UINT16, BASE_HEX, VALS(error_vals), 0, "CSM_ENCAPS Parameter 1", HFILL } }, { &hf_csm_encaps_param1, { "Parameter 1", "csm_encaps.param1", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 1", HFILL } }, { &hf_csm_encaps_param2, { "Parameter 2", "csm_encaps.param2", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 2", HFILL } }, { &hf_csm_encaps_param3, { "Parameter 3", "csm_encaps.param3", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 3", HFILL } }, { &hf_csm_encaps_param4, { "Parameter 4", "csm_encaps.param4", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 4", HFILL } }, { &hf_csm_encaps_param5, { "Parameter 5", "csm_encaps.param5", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 5", HFILL } }, { &hf_csm_encaps_param6, { "Parameter 6", "csm_encaps.param6", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 6", HFILL } }, { &hf_csm_encaps_param7, { "Parameter 7", "csm_encaps.param7", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 7", HFILL } }, { &hf_csm_encaps_param8, { "Parameter 8", "csm_encaps.param8", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 8", HFILL } }, { &hf_csm_encaps_param9, { "Parameter 9", "csm_encaps.param9", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 9", HFILL } }, { &hf_csm_encaps_param10, { "Parameter 10", "csm_encaps.param10", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 10", HFILL } }, { &hf_csm_encaps_param11, { "Parameter 11", "csm_encaps.param11", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 11", HFILL } }, { &hf_csm_encaps_param12, { "Parameter 12", "csm_encaps.param12", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 12", HFILL } }, { &hf_csm_encaps_param13, { "Parameter 13", "csm_encaps.param13", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 13", HFILL } }, { &hf_csm_encaps_param14, { "Parameter 14", "csm_encaps.param14", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 14", HFILL } }, { &hf_csm_encaps_param15, { "Parameter 15", "csm_encaps.param15", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 15", HFILL } }, { &hf_csm_encaps_param16, { "Parameter 16", "csm_encaps.param16", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 16", HFILL } }, { &hf_csm_encaps_param17, { "Parameter 17", "csm_encaps.param17", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 17", HFILL } }, { &hf_csm_encaps_param18, { "Parameter 18", "csm_encaps.param18", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 18", HFILL } }, { &hf_csm_encaps_param19, { "Parameter 19", "csm_encaps.param19", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 19", HFILL } }, { &hf_csm_encaps_param20, { "Parameter 20", "csm_encaps.param20", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 20", HFILL } }, { &hf_csm_encaps_param21, { "Parameter 21", "csm_encaps.param21", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 21", HFILL } }, { &hf_csm_encaps_param22, { "Parameter 22", "csm_encaps.param22", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 22", HFILL } }, { &hf_csm_encaps_param23, { "Parameter 23", "csm_encaps.param23", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 23", HFILL } }, { &hf_csm_encaps_param24, { "Parameter 24", "csm_encaps.param24", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 24", HFILL } }, { &hf_csm_encaps_param25, { "Parameter 25", "csm_encaps.param25", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 25", HFILL } }, { &hf_csm_encaps_param26, { "Parameter 26", "csm_encaps.param26", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 26", HFILL } }, { &hf_csm_encaps_param27, { "Parameter 27", "csm_encaps.param27", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 27", HFILL } }, { &hf_csm_encaps_param28, { "Parameter 28", "csm_encaps.param28", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 28", HFILL } }, { &hf_csm_encaps_param29, { "Parameter 29", "csm_encaps.param29", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 29", HFILL } }, { &hf_csm_encaps_param30, { "Parameter 30", "csm_encaps.param30", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 30", HFILL } }, { &hf_csm_encaps_param31, { "Parameter 31", "csm_encaps.param31", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 31", HFILL } }, { &hf_csm_encaps_param32, { "Parameter 32", "csm_encaps.param32", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 32", HFILL } }, { &hf_csm_encaps_param33, { "Parameter 33", "csm_encaps.param33", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 33", HFILL } }, { &hf_csm_encaps_param34, { "Parameter 34", "csm_encaps.param34", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 34", HFILL } }, { &hf_csm_encaps_param35, { "Parameter 35", "csm_encaps.param35", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 35", HFILL } }, { &hf_csm_encaps_param36, { "Parameter 36", "csm_encaps.param36", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 36", HFILL } }, { &hf_csm_encaps_param37, { "Parameter 37", "csm_encaps.param37", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 37", HFILL } }, { &hf_csm_encaps_param38, { "Parameter 38", "csm_encaps.param38", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 38", HFILL } }, { &hf_csm_encaps_param39, { "Parameter 39", "csm_encaps.param39", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 39", HFILL } }, { &hf_csm_encaps_param40, { "Parameter 40", "csm_encaps.param40", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter 40", HFILL } }, { &hf_csm_encaps_param, { "Parameter", "csm_encaps.param", FT_UINT16, BASE_HEX, NULL, 0, "CSM_ENCAPS Parameter", HFILL } }, }; static gint *ett[] = { &ett_csm_encaps, &ett_csm_encaps_control }; proto_csm_encaps = proto_register_protocol("CSM_ENCAPS", "CSM_ENCAPS", "csm_encaps"); proto_register_field_array(proto_csm_encaps, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }
void proto_register_dcerpc_svcctl(void) { static hf_register_info hf[] = { { &hf_svcctl_opnum, { "Operation", "svcctl.opnum", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_svcctl_machinename, { "MachineName", "svcctl.machinename", FT_STRING, BASE_NONE, NULL, 0x0, "Name of the host we want to open the database on", HFILL }}, { &hf_svcctl_database, { "Database", "svcctl.database", FT_STRING, BASE_NONE, NULL, 0x0, "Name of the database to open", HFILL }}, { &hf_svcctl_access_mask, { "Access Mask", "svcctl.access_mask", FT_UINT32, BASE_HEX, NULL, 0x0, "SVCCTL Access Mask", HFILL }}, { &hf_svcctl_scm_rights_connect, { "Connect", "svcctl.scm_rights_connect", FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x00000001, "SVCCTL Rights to connect to SCM", HFILL }}, { &hf_svcctl_scm_rights_create_service, { "Create Service", "svcctl.scm_rights_create_service", FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x00000002, "SVCCTL Rights to create services", HFILL }}, { &hf_svcctl_scm_rights_enumerate_service, { "Enumerate Service", "svcctl.scm_rights_enumerate_service", FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x00000004, "SVCCTL Rights to enumerate services", HFILL }}, { &hf_svcctl_scm_rights_lock, { "Lock", "svcctl.scm_rights_lock", FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x00000008, "SVCCTL Rights to lock database", HFILL }}, { &hf_svcctl_scm_rights_query_lock_status, { "Query Lock Status", "svcctl.scm_rights_query_lock_status", FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x00000010, "SVCCTL Rights to query database lock status", HFILL }}, { &hf_svcctl_scm_rights_modify_boot_config, { "Modify Boot Config", "svcctl.scm_rights_modify_boot_config", FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x00000020, "SVCCTL Rights to modify boot config", HFILL }}, { &hf_svcctl_hnd, { "Context Handle", "svcctl.hnd", FT_BYTES, BASE_NONE, NULL, 0x0, "SVCCTL Context handle", HFILL }}, { &hf_svcctl_lock, { "Lock", "svcctl.lock", FT_BYTES, BASE_NONE, NULL, 0x0, "SVCCTL Database Lock", HFILL }}, { &hf_svcctl_rc, { "Return code", "svcctl.rc", FT_UINT32, BASE_HEX | BASE_EXT_STRING, &DOS_errors_ext, 0x0, "SVCCTL return code", HFILL }}, { &hf_svcctl_size, { "Size", "svcctl.size", FT_UINT32, BASE_DEC, NULL, 0x0, "SVCCTL size of buffer", HFILL }}, { &hf_svcctl_required_size, { "Required Size", "svcctl.required_size", FT_UINT32, BASE_DEC, NULL, 0x0, "SVCCTL required size of buffer for data to fit", HFILL }}, { &hf_svcctl_is_locked, { "IsLocked", "svcctl.is_locked", FT_UINT32, BASE_DEC, NULL, 0x0, "SVCCTL whether the database is locked or not", HFILL }}, { &hf_svcctl_lock_duration, { "Duration", "svcctl.lock_duration", FT_UINT32, BASE_DEC, NULL, 0x0, "SVCCTL number of seconds the database has been locked", HFILL }}, { &hf_svcctl_lock_owner, { "Owner", "svcctl.lock_owner", FT_STRING, BASE_NONE, NULL, 0x0, "SVCCTL the user that holds the database lock", HFILL }}, { &hf_svcctl_service_type, { "Service Type", "svcctl.service_type", FT_UINT32, BASE_HEX, NULL, 0x0, "SVCCTL type of service", HFILL }}, { &hf_svcctl_service_type_kernel_driver, { "Kernel Driver Service", "svcctl.service_type.kernel", FT_BOOLEAN, 32, TFS(&tfs_svcctl_service_type_kernel_driver), SVCCTL_SERVICE_TYPE_KERNEL_DRIVER, "Request includes kernel driver services?", HFILL }}, { &hf_svcctl_service_type_fs_driver, { "File System Driver Service", "svcctl.service_type.fs", FT_BOOLEAN, 32, TFS(&tfs_svcctl_service_type_fs_driver), SVCCTL_SERVICE_TYPE_FILE_SYSTEM_DRIVER, "Request includes file system driver services?", HFILL }}, { &hf_svcctl_service_type_win32_own_process, { "Self Process Service", "svcctl.service_type.win32_own", FT_BOOLEAN, 32, TFS(&tfs_svcctl_service_type_win32_own_process), SVCCTL_SERVICE_TYPE_WIN32_OWN_PROCESS, "Request includes services that run their own process?", HFILL }}, { &hf_svcctl_service_type_win32_share_process, { "Shared Process Service", "svcctl.service_type.win32_shared", FT_BOOLEAN, 32, TFS(&tfs_svcctl_service_type_win32_share_process), SVCCTL_SERVICE_TYPE_WIN32_SHARE_PROCESS, "Request includes services that share their process?", HFILL }}, { &hf_svcctl_service_type_interactive_process, { "Interactive Process Service", "svcctl.service_type.interactive", FT_BOOLEAN, 32, TFS(&tfs_svcctl_service_type_interactive_process), SVCCTL_SERVICE_TYPE_INTERACTIVE_PROCESS, "Request includes services that can interact with the desktop?", HFILL }}, { &hf_svcctl_service_state, { "Service State", "svcctl.service_state", FT_UINT32, BASE_DEC, VALS(svcctl_service_status_vals), 0x0, "SVCCTL service state", HFILL }}, { &hf_svcctl_buffer, { "Buffer", "svcctl.buffer", FT_UINT32, BASE_DEC, NULL, 0x0, "SVCCTL buffer", HFILL }}, #if 0 { &hf_svcctl_bytes_needed, { "Bytes Needed", "svcctl.bytes_needed", FT_UINT32, BASE_DEC, NULL, 0x0, "SVCCTL bytes needed", HFILL }}, { &hf_svcctl_services_returned, { "Services Returned", "svcctl.services_returned", FT_UINT32, BASE_DEC, NULL, 0x0, "SVCCTL services returned", HFILL }}, #endif { &hf_svcctl_service_name, { "Service Name", "svcctl.servicename", FT_STRING, BASE_NONE, NULL, 0x0, "SVCCTL name of service", HFILL }}, { &hf_svcctl_display_name, { "Display Name", "svcctl.displayname", FT_STRING, BASE_NONE, NULL, 0x0, "SVCCTL display name", HFILL }}, { &hf_svcctl_service_start_type, { "Service Start Type", "svcctl.service_start_type", FT_UINT32, BASE_DEC, VALS(svcctl_service_start_type_vals), 0x0, "SVCCTL service start type", HFILL }}, { &hf_svcctl_service_error_control, { "Service Error Control", "svcctl.service_error_control", FT_UINT32, BASE_DEC, VALS(svcctl_service_error_control_vals), 0x0, "SVCCTL service error control", HFILL }}, { &hf_svcctl_binarypathname, { "Binary Path Name", "svcctl.binarypathname", FT_STRING, BASE_NONE, NULL, 0x0, "SVCCTL binary path name", HFILL }}, { &hf_svcctl_loadordergroup, { "Load Order Group", "svcctl.loadordergroup", FT_STRING, BASE_NONE, NULL, 0x0, "SVCCTL load order group", HFILL }}, { &hf_svcctl_tagid, { "Tag Id", "svcctl.tagid", FT_UINT32, BASE_DEC, NULL, 0x0, "SVCCTL tag id", HFILL }}, { &hf_svcctl_dependencies, { "Dependencies", "svcctl.dependencies", FT_STRING, BASE_NONE, NULL, 0x0, "SVCCTL dependencies", HFILL }}, { &hf_svcctl_depend_size, { "Depend Size", "svcctl.depend_size", FT_UINT32, BASE_DEC, NULL, 0x0, "SVCCTL depend size", HFILL }}, { &hf_svcctl_service_start_name, { "Service Start Name", "svcctl.service_start_name", FT_STRING, BASE_NONE, NULL, 0x0, "SVCCTL service start name", HFILL }}, { &hf_svcctl_password, { "Password", "svcctl.password", FT_STRING, BASE_NONE, NULL, 0x0, "SVCCTL password", HFILL }}, { &hf_svcctl_password_size, { "Password Size", "svcctl.password_size", FT_UINT32, BASE_DEC, NULL, 0x0, "SVCCTL password size", HFILL }}, { &hf_svcctl_resume, { "Resume Handle", "svcctl.resume", FT_UINT32, BASE_DEC, NULL, 0x0, "SVCCTL resume handle", HFILL }}, }; static gint *ett[] = { &ett_dcerpc_svcctl, &ett_dcerpc_svcctl_service_type_bits, }; proto_dcerpc_svcctl = proto_register_protocol( "Microsoft Service Control", "SVCCTL", "svcctl"); proto_register_field_array(proto_dcerpc_svcctl, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }
void proto_register_bacnet(void) { static hf_register_info hf[] = { { &hf_bacnet_version, { "Version", "bacnet.version", FT_UINT8, BASE_DEC, NULL, 0, "BACnet Version", HFILL } }, { &hf_bacnet_control, { "Control", "bacnet.control", FT_UINT8, BASE_HEX, NULL, 0, "BACnet Control", HFILL } }, { &hf_bacnet_control_net, { "NSDU contains", "bacnet.control_net", FT_BOOLEAN, 8, TFS(&control_net_set_high), BAC_CONTROL_NET, "BACnet Control", HFILL } }, { &hf_bacnet_control_res1, { "Reserved", "bacnet.control_res1", FT_BOOLEAN, 8, TFS(&control_res_high), BAC_CONTROL_RES1, "BACnet Control", HFILL } }, { &hf_bacnet_control_dest, { "Destination Specifier", "bacnet.control_dest", FT_BOOLEAN, 8, TFS(&control_dest_high), BAC_CONTROL_DEST, "BACnet Control", HFILL } }, { &hf_bacnet_control_res2, { "Reserved", "bacnet.control_res2", FT_BOOLEAN, 8, TFS(&control_res_high), BAC_CONTROL_RES2, "BACnet Control", HFILL } }, { &hf_bacnet_control_src, { "Source specifier", "bacnet.control_src", FT_BOOLEAN, 8, TFS(&control_src_high), BAC_CONTROL_SRC, "BACnet Control", HFILL } }, { &hf_bacnet_control_expect, { "Expecting Reply", "bacnet.control_expect", FT_BOOLEAN, 8, TFS(&control_expect_high), BAC_CONTROL_EXPECT, "BACnet Control", HFILL } }, { &hf_bacnet_control_prio_high, { "Priority", "bacnet.control_prio_high", FT_BOOLEAN, 8, TFS(&control_prio_high_high), BAC_CONTROL_PRIO_HIGH, "BACnet Control", HFILL } }, { &hf_bacnet_control_prio_low, { "Priority", "bacnet.control_prio_low", FT_BOOLEAN, 8, TFS(&control_prio_low_high), BAC_CONTROL_PRIO_LOW, "BACnet Control", HFILL } }, { &hf_bacnet_dnet, { "Destination Network Address", "bacnet.dnet", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_bacnet_dlen, { "Destination MAC Layer Address Length", "bacnet.dlen", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_bacnet_dadr_eth, { "Destination ISO 8802-3 MAC Address", "bacnet.dadr_eth", FT_ETHER, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_bacnet_dadr_mstp, { "DADR", "bacnet.dadr_mstp", FT_UINT8, BASE_DEC, NULL, 0, "Destination MS/TP or ARCNET MAC Address", HFILL } }, { &hf_bacnet_dadr_tmp, { "Unknown Destination MAC", "bacnet.dadr_tmp", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_bacnet_snet, { "Source Network Address", "bacnet.snet", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_bacnet_slen, { "Source MAC Layer Address Length", "bacnet.slen", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_bacnet_sadr_eth, { "SADR", "bacnet.sadr_eth", FT_ETHER, BASE_NONE, NULL, 0, "Source ISO 8802-3 MAC Address", HFILL } }, { &hf_bacnet_sadr_mstp, { "SADR", "bacnet.sadr_mstp", FT_UINT8, BASE_DEC, NULL, 0, "Source MS/TP or ARCNET MAC Address", HFILL } }, { &hf_bacnet_sadr_tmp, { "Unknown Source MAC", "bacnet.sadr_tmp", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_bacnet_hopc, { "Hop Count", "bacnet.hopc", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_bacnet_mesgtyp, { "Network Layer Message Type", "bacnet.mesgtyp", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_bacnet_vendor, { "Vendor ID", "bacnet.vendor", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_bacnet_perf, { "Performance Index", "bacnet.perf", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_bacnet_rejectreason, { "Reject Reason", "bacnet.rejectreason", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_bacnet_rportnum, { "Number of Port Mappings", "bacnet.rportnum", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_bacnet_pinfolen, { "Port Info Length", "bacnet.pinfolen", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_bacnet_portid, { "Port ID", "bacnet.portid", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_bacnet_term_time_value, { "Termination Time Value (seconds)", "bacnet.term_time_value", FT_UINT8, BASE_DEC, NULL, 0, "Termination Time Value", HFILL } } }; static gint *ett[] = { &ett_bacnet, &ett_bacnet_control, }; proto_bacnet = proto_register_protocol("Building Automation and Control Network NPDU", "BACnet", "bacnet"); proto_register_field_array(proto_bacnet, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); register_dissector("bacnet", dissect_bacnet, proto_bacnet); bacnet_dissector_table = register_dissector_table("bacnet.vendor", "BACnet Vendor Identifier", FT_UINT8, BASE_HEX); }
/* Register the protocol with Wireshark */ void proto_register_lisp_data(void) { /* Setup list of header fields */ static hf_register_info hf[] = { { &hf_lisp_data_flags, { "Flags", "lisp-data.flags", FT_UINT8, BASE_HEX, NULL, 0x0, "LISP Data Header Flags", HFILL }}, { &hf_lisp_data_flags_nonce, { "N bit (Nonce present)", "lisp-data.flags.nonce", FT_BOOLEAN, LISP_DATA_FLAGS_WIDTH, TFS(&tfs_set_notset), LISP_DATA_FLAG_N, NULL, HFILL }}, { &hf_lisp_data_flags_lsb, { "L bit (Locator-Status-Bits field enabled)", "lisp-data.flags.lsb", FT_BOOLEAN, LISP_DATA_FLAGS_WIDTH, TFS(&tfs_set_notset), LISP_DATA_FLAG_L, NULL, HFILL }}, { &hf_lisp_data_flags_enr, { "E bit (Echo-Nonce-Request)", "lisp-data.flags.enr", FT_BOOLEAN, LISP_DATA_FLAGS_WIDTH, TFS(&tfs_set_notset), LISP_DATA_FLAG_E, NULL, HFILL }}, { &hf_lisp_data_flags_mv, { "V bit (Map-Version present)", "lisp-data.flags.mv", FT_BOOLEAN, LISP_DATA_FLAGS_WIDTH, TFS(&tfs_set_notset), LISP_DATA_FLAG_V, NULL, HFILL }}, { &hf_lisp_data_flags_iid, { "I bit (Instance ID present)", "lisp-data.flags.iid", FT_BOOLEAN, LISP_DATA_FLAGS_WIDTH, TFS(&tfs_set_notset), LISP_DATA_FLAG_I, NULL, HFILL }}, { &hf_lisp_data_flags_res, { "Reserved", "lisp-data.flags.res", FT_UINT8, BASE_HEX, NULL, LISP_DATA_FLAG_RES, "Must be zero", HFILL }}, { &hf_lisp_data_nonce, { "Nonce", "lisp-data.nonce", FT_UINT24, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_lisp_data_mapver, { "Map-Version", "lisp-data.mapver", FT_UINT24, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_lisp_data_srcmapver, { "Source Map-Version", "lisp-data.srcmapver", FT_UINT24, BASE_DEC, NULL, 0xFFF000, NULL, HFILL }}, { &hf_lisp_data_dstmapver, { "Destination Map-Version", "lisp-data.dstmapver", FT_UINT24, BASE_DEC, NULL, 0x000FFF, NULL, HFILL }}, { &hf_lisp_data_iid, { "Instance ID", "lisp-data.iid", FT_UINT24, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_lisp_data_lsb, { "Locator-Status-Bits", "lisp-data.lsb", FT_UINT32, BASE_HEX, NULL, 0xFFFFFFFF, NULL, HFILL }}, { &hf_lisp_data_lsb8, { "Locator-Status-Bits", "lisp-data.lsb8", FT_UINT8, BASE_HEX, NULL, 0xFF, NULL, HFILL }} }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_lisp_data, &ett_lisp_data_flags, &ett_lisp_data_mapver }; /* Register the protocol name and description */ proto_lisp_data = proto_register_protocol("Locator/ID Separation Protocol (Data)", "LISP Data", "lisp-data"); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_lisp_data, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }