void proto_register_btsmp(void) { static hf_register_info hf[] = { {&hf_btsmp_opcode, {"Opcode", "btsmp.opcode", FT_UINT8, BASE_HEX, VALS(opcode_vals), 0x0, NULL, HFILL} }, {&hf_btsmp_reason, {"Reason", "btsmp.reason", FT_UINT8, BASE_HEX, VALS(reason_vals), 0x0, NULL, HFILL} }, {&hf_btsmp_io_capabilities, {"IO Capability", "btsmp.io_capability", FT_UINT8, BASE_HEX, VALS(io_capability_vals), 0x0, NULL, HFILL} }, {&hf_btsmp_oob_data_flags, {"OOB Data Flags", "btsmp.oob_data_flags", FT_UINT8, BASE_HEX, VALS(oob_data_flag_vals), 0x0, NULL, HFILL} }, {&hf_btsmp_cfm_value, {"Confirm Value", "btsmp.cfm_value", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL} }, {&hf_btsmp_random, {"Random Value", "btsmp.random_value", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL} }, {&hf_btsmp_long_term_key, {"Long Term Key", "btsmp.long_term_key", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL} }, {&hf_btsmp_id_resolving_key, {"Identity Resolving Key", "btsmp.id_resolving_key", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL} }, {&hf_btsmp_signature_key, {"Signature Key", "btsmp.signature_key", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL} }, {&hf_btsmp_bonding_flags, {"Bonding Flags", "btsmp.bonding_flags", FT_UINT8, BASE_HEX, VALS(bonding_flag_vals), 0x03, NULL, HFILL} }, {&hf_btsmp_mitm_flag, {"MITM Flag", "btsmp.mitm_flag", FT_UINT8, BASE_DEC, NULL, 0x04, NULL, HFILL} }, {&hf_btsmp_max_enc_key_size, {"Max Encryption Key Size", "btsmp.max_enc_key_size", FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL} }, {&hf_btsmp_key_dist_enc, {"Encryption Key (LTK)", "btsmp.key_dist_enc", FT_UINT8, BASE_DEC, NULL, 0x01, NULL, HFILL} }, {&hf_btsmp_key_dist_id, {"Id Key (IRK)", "btsmp.key_dist_id", FT_UINT8, BASE_DEC, NULL, 0x02, NULL, HFILL} }, {&hf_btsmp_key_dist_sign, {"Signature Key (CSRK)", "btsmp.key_dist_sign", FT_UINT8, BASE_DEC, NULL, 0x04, NULL, HFILL} }, {&hf_btsmp_ediv, {"Encrypted Diversifier (EDIV)", "btsmp.ediv", FT_UINT16, BASE_HEX, NULL, 0x00, NULL, HFILL} }, {&hf_btsmp_authreq, {"AuthReq", "btsmp.authreq", FT_NONE, BASE_NONE, NULL, 0x00, NULL, HFILL} }, {&hf_btsmp_initiator_key_distribution, {"Initiator Key Distribution", "btsmp.initiator_key_distribution", FT_NONE, BASE_NONE, NULL, 0x00, NULL, HFILL} }, {&hf_btsmp_responder_key_distribution, {"Responder Key Distribution", "btsmp.responder_key_distribution", FT_NONE, BASE_NONE, NULL, 0x00, NULL, HFILL} }, {&hf_bd_addr, { "BD_ADDR", "btsmp.bd_addr", FT_ETHER, BASE_NONE, NULL, 0x0, "Bluetooth Device Address", HFILL} }, { &hf_address_type, { "Address Type", "btsmp.address_type", FT_UINT8, BASE_HEX, VALS(bluetooth_address_type_vals), 0x0, NULL, HFILL } } }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_btsmp, &ett_btsmp_auth_req, &ett_btsmp_key_dist }; /* Register the protocol name and description */ proto_btsmp = proto_register_protocol("Bluetooth Security Manager Protocol", "BT SMP", "btsmp"); btsmp_handle = new_register_dissector("btsmp", dissect_btsmp, proto_btsmp); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_btsmp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }
/* * Name: proto_register_nlsp() * * Description: * main register for NLSP protocol set. We register some display * formats and the protocol module variables. * * NOTE: this procedure to autolinked by the makefile process that * builds register.c * * Input: * void * * Output: * void */ void proto_register_nlsp(void) { static hf_register_info hf[] = { { &hf_nlsp_irpd, { "NetWare Link Services Protocol Discriminator", "nlsp.irpd", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_nlsp_header_length, { "PDU Header Length", "nlsp.header_length", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_nlsp_minor_version, { "Minor Version", "nlsp.minor_version", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_nlsp_nr, { "Multi-homed Non-routing Server", "nlsp.nr", FT_BOOLEAN, 8, NULL, 0x80, NULL, HFILL }}, { &hf_nlsp_type, { "Packet Type", "nlsp.type", FT_UINT8, BASE_DEC, VALS(nlsp_packet_type_vals), PACKET_TYPE_MASK, NULL, HFILL }}, { &hf_nlsp_major_version, { "Major Version", "nlsp.major_version", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_nlsp_packet_length, { "Packet Length", "nlsp.packet_length", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_nlsp_hello_state, { "State", "nlsp.hello.state", FT_UINT8, BASE_DEC, VALS(nlsp_hello_state_vals), NLSP_HELLO_STATE_MASK, NULL, HFILL }}, { &hf_nlsp_hello_multicast, { "Multicast Routing", "nlsp.hello.multicast", FT_BOOLEAN, 8, TFS(&tfs_supported_not_supported), NLSP_HELLO_MULTICAST_MASK, "If set, this router supports multicast routing", HFILL }}, { &hf_nlsp_hello_circuit_type, { "Circuit Type", "nlsp.hello.circuit_type", FT_UINT8, BASE_DEC, VALS(nlsp_hello_circuit_type_vals), NLSP_HELLO_CTYPE_MASK, NULL, HFILL }}, { &hf_nlsp_hello_holding_timer, { "Holding Timer", "nlsp.hello.holding_timer", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_nlsp_hello_priority, { "Priority", "nlsp.hello.priority", FT_UINT8, BASE_DEC, NULL, NLSP_HELLO_PRIORITY_MASK, NULL, HFILL }}, { &hf_nlsp_lsp_sequence_number, { "Sequence Number", "nlsp.sequence_number", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_nlsp_lsp_checksum, { "Checksum", "nlsp.lsp.checksum", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_nlsp_lsp_p, { "Partition Repair", "nlsp.lsp.partition_repair", FT_BOOLEAN, 8, TFS(&tfs_supported_not_supported), NLSP_LSP_PARTITION_MASK, "If set, this router supports the optional Partition Repair function", HFILL }}, { &hf_nlsp_lsp_attached_flag, { "Attached Flag", "nlsp.lsp.attached_flag", FT_UINT8, BASE_DEC, VALS(nlsp_attached_flag_vals), NLSP_LSP_ATT_MASK, NULL, HFILL }}, { &hf_nlsp_lsp_lspdbol, { "LSP Database Overloaded", "nlsp.lsp.lspdbol", FT_BOOLEAN, 8, NULL, NLSP_LSP_OVERFLOW_MASK, NULL, HFILL }}, { &hf_nlsp_lsp_router_type, { "Router Type", "nlsp.lsp.router_type", FT_UINT8, BASE_DEC, VALS(nlsp_router_type_vals), NLSP_LSP_ROUTER_TYPE_MASK, NULL, HFILL }}, { &hf_nlsp_lsp_link_info_clv_flags_cost_present, { "Cost present", "nlsp.lsp.link_info_clv.flags.cost_present", FT_BOOLEAN, 8, TFS(&tfs_no_yes), 0x80, NULL, HFILL }}, { &hf_nlsp_lsp_link_info_clv_flags_cost_metric, { "Cost metric", "nlsp.lsp.link_info_clv.flags.cost_metric", FT_BOOLEAN, 8, TFS(&tfs_internal_external), 0x40, NULL, HFILL }}, { &hf_nlsp_lsp_link_info_clv_flags_cost, { "Cost", "nlsp.lsp.link_info_clv.flags.cost", FT_UINT8, BASE_DEC, NULL, 0x3F, NULL, HFILL }}, }; static gint *ett[] = { &ett_nlsp, &ett_nlsp_hello_clv_area_addr, &ett_nlsp_hello_clv_neighbors, &ett_nlsp_hello_local_mtu, &ett_nlsp_hello_clv_unknown, &ett_nlsp_lsp_info, &ett_nlsp_lsp_clv_area_addr, &ett_nlsp_lsp_clv_mgt_info, &ett_nlsp_lsp_clv_link_info, &ett_nlsp_lsp_clv_svcs_info, &ett_nlsp_lsp_clv_ext_routes, &ett_nlsp_lsp_clv_unknown, &ett_nlsp_csnp_lsp_entries, &ett_nlsp_csnp_lsp_entry, &ett_nlsp_csnp_clv_unknown, &ett_nlsp_psnp_lsp_entries, &ett_nlsp_psnp_lsp_entry, &ett_nlsp_psnp_clv_unknown, }; proto_nlsp = proto_register_protocol("NetWare Link Services Protocol", "NLSP", "nlsp"); proto_register_field_array(proto_nlsp, 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, }; static ei_register_info ei[] = { { &ei_clnp_length, { "clnp.len.bad", PI_MALFORMED, PI_ERROR, "Header length value bad", EXPFILL }}, }; module_t *clnp_module; expert_module_t* expert_clnp; 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)); expert_clnp = expert_register_protocol(proto_clnp); expert_register_field_array(expert_clnp, ei, array_length(ei)); 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); }
void proto_register_ayiya(void) { static hf_register_info hf[] = { { &hf_id_len, { "Identity field length", "ayiya.idlen", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_id_type, { "Identity field type", "ayiya.idtype", FT_UINT8, BASE_HEX, VALS(identity_types), 0x0, NULL, HFILL } }, { &hf_sig_len, { "Signature Length", "ayiya.siglen", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_hash_method, { "Hash method", "ayiya.hashmethod", FT_UINT8, BASE_HEX, VALS(hash_methods), 0x0, NULL, HFILL } }, { &hf_auth_method, { "Authentication method", "ayiya.authmethod", FT_UINT8, BASE_HEX, VALS(auth_methods), 0x0, NULL, HFILL } }, { &hf_opcode, { "Operation Code", "ayiya.opcode", FT_UINT8, BASE_HEX, VALS(opcodes), 0x0, NULL, HFILL } }, { &hf_next_header, { "Next Header", "ayiya.nextheader", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_epoch, { "Epoch", "ayiya.epoch", FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL, NULL, 0x0, NULL, HFILL } }, { &hf_identity, { "Identity", "ayiya.identity", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_signature, { "Signature", "ayiya.signature", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, }; static gint *ett[] = { &ett_ayiya, }; proto_ayiya = proto_register_protocol("Anything in Anything Protocol", "AYIYA", "ayiya"); register_dissector("ayiya", dissect_ayiya, proto_ayiya); proto_register_field_array(proto_ayiya, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }
void proto_register_isis(void) { static hf_register_info hf[] = { { &hf_isis_irpd, { "Intra Domain Routing Protocol Discriminator", "isis.irpd", FT_UINT8, BASE_HEX, VALS(nlpid_vals), 0x0, NULL, HFILL }}, { &hf_isis_header_length, { "PDU Header Length", "isis.len", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_isis_version, { "Version", "isis.version", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_isis_system_id_length, { "System ID Length", "isis.sysid_len", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_isis_type, { "PDU Type", "isis.type", FT_UINT8, BASE_DEC, VALS(isis_vals), ISIS_TYPE_MASK, NULL, HFILL }}, { &hf_isis_type_reserved, { "Reserved", "isis.reserved", FT_UINT8, BASE_HEX, NULL, ISIS_TYPE_RESERVED_MASK, NULL, HFILL }}, { &hf_isis_version2, { "Version2 (==1)", "isis.version2", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_isis_reserved, { "Reserved (==0)", "isis.reserved", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_isis_max_area_adr, { "Max.AREAs: (0==3)", "isis.max_area_adr", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, }; /* * Note, we pull in the unknown CLV handler here, since it * is used by all ISIS packet types. */ static gint *ett[] = { &ett_isis, }; static ei_register_info ei[] = { { &ei_isis_version, { "isis.version.unknown", PI_PROTOCOL, PI_WARN, "Unknown ISIS version", EXPFILL }}, { &ei_isis_type, { "isis.type.unknown", PI_PROTOCOL, PI_WARN, "Unknown ISIS packet type", EXPFILL }}, }; expert_module_t* expert_isis; proto_isis = proto_register_protocol(PROTO_STRING_ISIS, "ISIS", "isis"); proto_register_field_array(proto_isis, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); expert_isis = expert_register_protocol(proto_isis); expert_register_field_array(expert_isis, ei, array_length(ei)); isis_handle = register_dissector("isis", dissect_isis, proto_isis); isis_dissector_table = register_dissector_table("isis.type", "ISIS Type", FT_UINT8, BASE_DEC); }
void proto_register_ipxwan(void) { static hf_register_info hf[] = { { &hf_ipxwan_identifier, { "Identifier", "ipxwan.identifier", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_ipxwan_packet_type, { "Packet Type", "ipxwan.packet_type", FT_UINT8, BASE_DEC, VALS(ipxwan_packet_type_vals), 0x0, NULL, HFILL }}, { &hf_ipxwan_node_id, { "Node ID", "ipxwan.node_id", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_ipxwan_sequence_number, { "Sequence Number", "ipxwan.sequence_number", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_ipxwan_num_options, { "Number of Options", "ipxwan.num_options", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_ipxwan_option_num, { "Option Number", "ipxwan.option_num", FT_UINT8, BASE_HEX, VALS(ipxwan_option_num_vals), 0x0, NULL, HFILL }}, { &hf_ipxwan_accept_option, { "Accept Option", "ipxwan.accept_option", FT_UINT8, BASE_DEC, VALS(ipxwan_accept_option_vals), 0x0, NULL, HFILL }}, { &hf_ipxwan_option_data_len, { "Option Data Length", "ipxwan.option_data_len", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_ipxwan_routing_type, { "Routing Type", "ipxwan.routing_type", FT_UINT8, BASE_DEC, VALS(ipxwan_routing_type_vals), 0x0, NULL, HFILL }}, { &hf_ipxwan_wan_link_delay, { "WAN Link Delay", "ipxwan.rip_sap_info_exchange.wan_link_delay", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_ipxwan_common_network_number, { "Common Network Number", "ipxwan.rip_sap_info_exchange.common_network_number", FT_IPXNET, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_ipxwan_router_name, { "Router Name", "ipxwan.rip_sap_info_exchange.router_name", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_ipxwan_delay, { "Delay", "ipxwan.nlsp_information.delay", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_ipxwan_throughput, { "Throughput", "ipxwan.nlsp_information.throughput", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_ipxwan_request_size, { "Request Size", "ipxwan.nlsp_raw_throughput_data.request_size", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_ipxwan_delta_time, { "Delta Time", "ipxwan.nlsp_raw_throughput_data.delta_time", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_ipxwan_extended_node_id, { "Extended Node ID", "ipxwan.extended_node_id", FT_IPXNET, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_ipxwan_node_number, { "Node Number", "ipxwan.node_number", FT_ETHER, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_ipxwan_compression_type, { "Compression Type", "ipxwan.compression.type", FT_UINT8, BASE_DEC, VALS(ipxwan_compression_type_vals), 0x0, NULL, HFILL }}, { &hf_ipxwan_compression_options, { "Compression options", "ipxwan.compression.options", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_ipxwan_compression_slots, { "Number of compression slots", "ipxwan.compression.slots", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_ipxwan_compression_parameters, { "Option parameters", "ipxwan.compression.parameters", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_ipxwan_padding, { "Padding", "ipxwan.padding", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_ipxwan_option_value, { "Option value", "ipxwan.option_value", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, }; static gint *ett[] = { &ett_ipxwan, &ett_ipxwan_option, }; static ei_register_info ei[] = { { &ei_ipxwan_option_data_len, { "ipxwan.option_data_len.invalid", PI_MALFORMED, PI_ERROR, "Wrong length", EXPFILL }}, }; expert_module_t* expert_ipxwan; proto_ipxwan = proto_register_protocol("IPX WAN", "IPX WAN", "ipxwan"); proto_register_field_array(proto_ipxwan, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); expert_ipxwan = expert_register_protocol(proto_ipxwan); expert_register_field_array(expert_ipxwan, ei, array_length(ei)); }
void proto_register_multipart(void) { /* Setup list of header fields See Section 1.6.1 for details */ static hf_register_info hf[] = { { &hf_multipart_type, { "Type", "mime_multipart.type", FT_STRING, BASE_NONE, NULL, 0x00, "MIME multipart encapsulation type", HFILL } }, { &hf_multipart_part, { "Encapsulated multipart part", "mime_multipart.part", FT_STRING, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_multipart_sec_token_len, { "Length of security token", "mime_multipart.header.sectoken-length", FT_UINT32, BASE_DEC, NULL, 0x00, "Length of the Kerberos BLOB which follows this token", HFILL } }, { &hf_header_array[POS_CONTENT_DISPOSITION], { "Content-Disposition", "mime_multipart.header.content-disposition", FT_STRING, BASE_NONE, NULL, 0x00, "RFC 2183: Content-Disposition Header", HFILL } }, { &hf_header_array[POS_CONTENT_ENCODING], { "Content-Encoding", "mime_multipart.header.content-encoding", FT_STRING, BASE_NONE, NULL, 0x00, "Content-Encoding Header", HFILL } }, { &hf_header_array[POS_CONTENT_ID], { "Content-Id", "mime_multipart.header.content-id", FT_STRING, BASE_NONE, NULL, 0x00, "RFC 2045: Content-Id Header", HFILL } }, { &hf_header_array[POS_CONTENT_LANGUAGE], { "Content-Language", "mime_multipart.header.content-language", FT_STRING, BASE_NONE, NULL, 0x00, "Content-Language Header", HFILL } }, { &hf_header_array[POS_CONTENT_LENGTH], { "Content-Length", "mime_multipart.header.content-length", FT_STRING, BASE_NONE, NULL, 0x0, "Content-Length Header", HFILL } }, { &hf_header_array[POS_CONTENT_TRANSFER_ENCODING], { "Content-Transfer-Encoding", "mime_multipart.header.content-transfer-encoding", FT_STRING, BASE_NONE, NULL, 0x00, "RFC 2045: Content-Transfer-Encoding Header", HFILL } }, { &hf_header_array[POS_CONTENT_TYPE], { "Content-Type", "mime_multipart.header.content-type", FT_STRING, BASE_NONE,NULL,0x0, "Content-Type Header", HFILL } }, { &hf_header_array[POS_ORIGINALCONTENT], { "OriginalContent", "mime_multipart.header.originalcontent", FT_STRING, BASE_NONE,NULL,0x0, "Original Content-Type Header", HFILL } }, /* Generated from convert_proto_tree_add_text.pl */ { &hf_multipart_first_boundary, { "First boundary", "mime_multipart.first_boundary", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_multipart_preamble, { "Preamble", "mime_multipart.preamble", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_multipart_last_boundary, { "Last boundary", "mime_multipart.last_boundary", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_multipart_boundary, { "Boundary", "mime_multipart.boundary", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_multipart_trailer, { "Trailer", "mime_multipart.trailer", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, }; /* * Preferences */ module_t *multipart_module; expert_module_t* expert_multipart; /* * Setup protocol subtree array */ static gint *ett[] = { &ett_multipart, &ett_multipart_main, &ett_multipart_body, }; static ei_register_info ei[] = { { &ei_multipart_no_required_parameter, { "mime_multipart.no_required_parameter", PI_PROTOCOL, PI_ERROR, "The multipart dissector could not find a required parameter.", EXPFILL }}, { &ei_multipart_decryption_not_possible, { "mime_multipart.decryption_not_possible", PI_UNDECODED, PI_WARN, "The multipart dissector could not decrypt the message.", EXPFILL }}, }; /* * Register the protocol name and description */ proto_multipart = proto_register_protocol( "MIME Multipart Media Encapsulation", "MIME multipart", "mime_multipart"); /* * Required function calls to register * the header fields and subtrees used. */ proto_register_field_array(proto_multipart, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); expert_multipart = expert_register_protocol(proto_multipart); expert_register_field_array(expert_multipart, ei, array_length(ei)); multipart_module = prefs_register_protocol(proto_multipart, NULL); prefs_register_bool_preference(multipart_module, "display_unknown_body_as_text", "Display bodies without media type as text", "Display multipart bodies with no media type dissector" " as raw text (may cause problems with binary data).", &display_unknown_body_as_text); prefs_register_bool_preference(multipart_module, "remove_base64_encoding", "Remove base64 encoding from bodies", "Remove any base64 content-transfer encoding from bodies. " "This supports export of the body and its further dissection.", &remove_base64_encoding); /* * Dissectors requiring different behavior in cases where the media * is contained in a multipart entity should register their multipart * dissector in the dissector table below, which is similar to the * "media_type" dissector table defined in the HTTP dissector code. */ multipart_media_subdissector_table = register_dissector_table( "multipart_media_type", "Internet media type (for multipart processing)", FT_STRING, BASE_NONE, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); }
void proto_register_nv(void) { static hf_register_info hf[] = { #if 0 { &hf_nv_summary, { "Summary of the Nv Packet", "tc_nv.summary", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, #endif { &hf_nv_header, { "Header", "tc_nv.header", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_nv_publisher, { "Publisher", "tc_nv.publisher", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_nv_count, { "Count", "tc_nv.count", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_nv_cycleindex, { "CycleIndex", "tc_nv.cycleindex", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_nv_variable, { "Variable", "tc_nv.variable", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_nv_varheader, { "VarHeader", "tc_nv.varheader", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_nv_id, { "Id", "tc_nv.id", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_nv_hash, { "Hash", "tc_nv.hash", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_nv_length, { "Length", "tc_nv.length", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_nv_quality, { "Quality", "tc_nv.quality", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_nv_data, { "Data", "tc_nv.data", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, }; static gint *ett[] = { &ett_nv, &ett_nv_header, &ett_nv_var, &ett_nv_varheader }; proto_nv = proto_register_protocol("TwinCAT NV", "TC-NV","tc_nv"); proto_register_field_array(proto_nv,hf,array_length(hf)); proto_register_subtree_array(ett,array_length(ett)); }
void proto_register_zebra(void) { static hf_register_info hf[] = { { &hf_zebra_len, { "Length", "zebra.len", FT_UINT16, BASE_DEC, NULL, 0x0, "Length of ZEBRA request", HFILL }}, { &hf_zebra_version, { "Version", "zebra.version", FT_UINT8, BASE_DEC, NULL, 0x0, "Zerbra srv version", HFILL }}, { &hf_zebra_request, { "Request", "zebra.request", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "TRUE if ZEBRA request", HFILL }}, { &hf_zebra_command, { "Command", "zebra.command", FT_UINT8, BASE_DEC, VALS(messages), 0x0, "ZEBRA command", HFILL }}, { &hf_zebra_interface, { "Interface", "zebra.interface", FT_STRING, BASE_NONE, NULL, 0x0, "Interface name of ZEBRA request", HFILL }}, { &hf_zebra_index, { "Index", "zebra.index", FT_UINT32, BASE_DEC, NULL, 0x0, "Index of interface", HFILL }}, { &hf_zebra_intstatus, { "Status", "zebra.intstatus", FT_UINT8, BASE_DEC, NULL, 0x0, "Status of interface", HFILL}}, { &hf_zebra_indexnum, { "Index Number", "zebra.indexnum", FT_UINT8, BASE_DEC, NULL, 0x0, "Number of indices for route", HFILL }}, { &hf_zebra_intflags, { "Flags", "zebra.intflags", FT_UINT64, BASE_DEC, NULL, 0x0, "Flags of interface", HFILL }}, { &hf_zebra_rtflags, { "Flags", "zebra.rtflags", FT_UINT8, BASE_DEC, NULL, 0x0, "Flags of route", HFILL }}, { &hf_zebra_message, { "Message", "zebra.message", FT_UINT8, BASE_DEC, NULL, 0x0, "Message type of route", HFILL }}, { &hf_zebra_msg_nexthop, { "Message Nexthop", "zebra.message.nexthop", FT_BOOLEAN, 8, NULL, ZEBRA_ZAPI_MESSAGE_NEXTHOP, "Message contains nexthop", HFILL }}, { &hf_zebra_msg_index, { "Message Index", "zebra.message.index", FT_BOOLEAN, 8, NULL, ZEBRA_ZAPI_MESSAGE_IFINDEX, "Message contains index", HFILL }}, { &hf_zebra_msg_distance, { "Message Distance", "zebra.message.distance", FT_BOOLEAN, 8, NULL, ZEBRA_ZAPI_MESSAGE_DISTANCE, "Message contains distance", HFILL }}, { &hf_zebra_msg_metric, { "Message Metric", "zebra.message.metric", FT_BOOLEAN, 8, NULL, ZEBRA_ZAPI_MESSAGE_METRIC, "Message contains metric", HFILL }}, { &hf_zebra_type, { "Type", "zebra.type", FT_UINT8, BASE_DEC, VALS(routes), 0x0, "Type of route", HFILL }}, { &hf_zebra_distance, { "Distance", "zebra.distance", FT_UINT8, BASE_DEC, NULL, 0x0, "Distance of route", HFILL }}, { &hf_zebra_metric, { "Metric", "zebra.metric", FT_UINT32, BASE_DEC, NULL, 0x0, "Metric of interface or route", HFILL }}, { &hf_zebra_mtu, { "MTU", "zebra.mtu", FT_UINT32, BASE_DEC, NULL, 0x0, "MTU of interface", HFILL }}, { &hf_zebra_mtu6, { "MTUv6", "zebra.mtu6", FT_UINT32, BASE_DEC, NULL, 0x0, "MTUv6 of interface", HFILL }}, { &hf_zebra_bandwidth, { "Bandwidth", "zebra.bandwidth", FT_UINT32, BASE_DEC, NULL, 0x0, "Bandwidth of interface", HFILL }}, { &hf_zebra_family, { "Family", "zebra.family", FT_UINT8, BASE_DEC, VALS(families), 0x0, "Family of IP address", HFILL }}, { &hf_zebra_flags, { "Flags", "zebra.flags", FT_UINT8, BASE_DEC, NULL, 0x0, "Flags of Address Info", HFILL }}, { &hf_zebra_dest4, { "Destination", "zebra.dest4", FT_IPv4, BASE_NONE, NULL, 0x0, "Destination IPv4 field", HFILL }}, { &hf_zebra_dest6, { "Destination", "zebra.dest6", FT_IPv6, BASE_NONE, NULL, 0x0, "Destination IPv6 field", HFILL }}, { &hf_zebra_nexthopnum, { "Nexthop Number", "zebra.nexthopnum", FT_UINT8, BASE_DEC, NULL, 0x0, "Number of nexthops in route", HFILL }}, { &hf_zebra_nexthop4, { "Nexthop", "zebra.nexthop4", FT_IPv4, BASE_NONE, NULL, 0x0, "Nethop IPv4 field of route", HFILL }}, { &hf_zebra_nexthop6, { "Nexthop", "zebra.nexthop6", FT_IPv6, BASE_NONE, NULL, 0x0, "Nethop IPv6 field of route", HFILL }}, { &hf_zebra_prefixlen, { "Prefix length", "zebra.prefixlen", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_zebra_prefix4, { "Prefix", "zebra.prefix4", FT_IPv4, BASE_NONE, NULL, 0x0, "Prefix IPv4", HFILL }}, { &hf_zebra_prefix6, { "Prefix", "zebra.prefix6", FT_IPv6, BASE_NONE, NULL, 0x0, "Prefix IPv6", HFILL }}, { &hf_zebra_routeridaddress, { "Router ID address", "zebra.routerIDAddress", FT_IPv4, BASE_NONE, NULL, 0x0, "Router ID", HFILL }}, { &hf_zebra_routeridmask, { "Router ID mask", "zebra.routerIDMask", FT_UINT8, BASE_DEC, NULL, 0x0, "netmask of Router ID", HFILL }}, { &hf_zebra_mac, { "MAC address", "zebra.macaddress", FT_ETHER, BASE_NONE, NULL, 0x0, "MAC address of interface", HFILL }}, }; static gint *ett[] = { &ett_zebra, &ett_zebra_request, &ett_message, }; proto_zebra = proto_register_protocol("Zebra Protocol", "ZEBRA", "zebra"); proto_register_field_array(proto_zebra, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }
void proto_register_ax4000(void) { static hf_register_info hf[] = { { &hf_ax4000_port, { "Port Number", "ax4000.port", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_ax4000_chassis, { "Chassis Number", "ax4000.chassis", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_ax4000_fill, { "Fill Type", "ax4000.fill", FT_UINT8, BASE_DEC, NULL, 0xc0, NULL, HFILL } }, { &hf_ax4000_index, { "Index", "ax4000.index", FT_UINT16, BASE_DEC, NULL, 0x0FFF, NULL, HFILL } }, { &hf_ax4000_timestamp, { "Timestamp", "ax4000.timestamp", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_ax4000_seq, { "Sequence Number", "ax4000.seq", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_ax4000_crc, { "CRC (unchecked)", "ax4000.crc", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } } }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_ax4000 }; /* Register the protocol name and description */ proto_ax4000 = proto_register_protocol("AX/4000 Test Block", "AX4000", "ax4000"); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_ax4000, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }
void proto_register_docsis_dpvreq (void) { /* Setup list of header fields See Section 1.6.1 for details*/ static hf_register_info hf[] = { {&hf_docsis_dpvreq_tranid, {"Transaction Id", "docsis_dpvreq.tranid", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL} }, {&hf_docsis_dpvreq_dschan, {"Downstream Channel ID", "docsis_dpvreq.dschan", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL} }, {&hf_docsis_dpvreq_flags, {"Flags", "docsis_dpvreq.flags", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL} }, {&hf_docsis_dpvreq_us_sf, {"Upstream Service Flow ID", "docsis_dpvreq.us_sf", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL} }, {&hf_docsis_dpvreq_n, {"N (Measurement avaraging factor)", "docsis_dpvreq.n", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL} }, {&hf_docsis_dpvreq_start, {"Start Reference Point", "docsis_dpvreq.start", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL} }, {&hf_docsis_dpvreq_end, {"End Reference Point", "docsis_dpvreq.end", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL} }, {&hf_docsis_dpvreq_ts_start, {"Timestamp Start", "docsis_dpvreq.ts_start", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL} }, {&hf_docsis_dpvreq_ts_end, {"Timestamp End", "docsis_dpvreq.ts_end", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL} }, }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_docsis_dpvreq, }; /* Register the protocol name and description */ proto_docsis_dpvreq = proto_register_protocol ("DOCSIS Path Verify Request", "DOCSIS DPV-REQ", "docsis_dpvreq"); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array (proto_docsis_dpvreq, hf, array_length (hf)); proto_register_subtree_array (ett, array_length (ett)); register_dissector ("docsis_dpvreq", dissect_dpvreq, proto_docsis_dpvreq); }
void proto_register_pn_dcp (void) { static hf_register_info hf[] = { { &hf_pn_dcp_service_id, { "ServiceID", "pn_dcp.service_id", FT_UINT8, BASE_DEC, VALS(pn_dcp_service_id), 0x0, NULL, HFILL }}, { &hf_pn_dcp_service_type, { "ServiceType", "pn_dcp.service_type", FT_UINT8, BASE_DEC, VALS(pn_dcp_service_type), 0x0, NULL, HFILL }}, { &hf_pn_dcp_xid, { "Xid", "pn_dcp.xid", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pn_dcp_reserved8, { "Reserved", "pn_dcp.reserved8", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pn_dcp_reserved16, { "Reserved", "pn_dcp.reserved16", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pn_dcp_response_delay, { "ResponseDelay", "pn_dcp.response_delay", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pn_dcp_data_length, { "DCPDataLength", "pn_dcp.data_length", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pn_dcp_block_length, { "DCPBlockLength", "pn_dcp.block_length", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pn_dcp_option, { "Option", "pn_dcp.option", FT_UINT8, BASE_DEC, VALS(pn_dcp_option), 0x0, NULL, HFILL }}, { &hf_pn_dcp_suboption, { "Suboption", "pn_dcp.suboption", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pn_dcp_block_error, { "BlockError", "pn_dcp.block_error", FT_UINT8, BASE_DEC, VALS(pn_dcp_block_error), 0x0, NULL, HFILL }}, { &hf_pn_dcp_block, { "Block", "pn_dcp.block", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pn_dcp_block_info, { "BlockInfo", "pn_dcp.block_info", FT_UINT16, BASE_DEC, VALS(pn_dcp_block_info), 0x0, NULL, HFILL }}, { &hf_pn_dcp_block_qualifier, { "BlockQualifier", "pn_dcp.block_qualifier", FT_UINT16, BASE_DEC, VALS(pn_dcp_block_qualifier), 0x0, NULL, HFILL }}, { &hf_pn_dcp_suboption_ip, { "Suboption", "pn_dcp.suboption_ip", FT_UINT8, BASE_DEC, VALS(pn_dcp_suboption_ip), 0x0, NULL, HFILL }}, { &hf_pn_dcp_suboption_ip_block_info, { "BlockInfo", "pn_dcp.suboption_ip_block_info", FT_UINT16, BASE_DEC, VALS(pn_dcp_suboption_ip_block_info), 0x0, NULL, HFILL }}, { &hf_pn_dcp_suboption_ip_ip, { "IPaddress", "pn_dcp.subobtion_ip_ip", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pn_dcp_suboption_ip_subnetmask, { "Subnetmask", "pn_dcp.subobtion_ip_subnetmask", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pn_dcp_suboption_ip_standard_gateway, { "StandardGateway", "pn_dcp.suboption_ip_standard_gateway", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pn_dcp_suboption_device, { "Suboption", "pn_dcp.suboption_device", FT_UINT8, BASE_DEC, VALS(pn_dcp_suboption_device), 0x0, NULL, HFILL }}, { &hf_pn_dcp_suboption_device_typeofstation, { "TypeOfStation", "pn_dcp.suboption_device_typeofstation", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pn_dcp_suboption_device_nameofstation, { "NameOfStation", "pn_dcp.suboption_device_nameofstation", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pn_dcp_suboption_vendor_id, { "VendorID", "pn_dcp.suboption_vendor_id", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pn_dcp_suboption_device_id, { "DeviceID", "pn_dcp.suboption_device_id", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pn_dcp_suboption_device_role, { "DeviceRoleDetails", "pn_dcp.suboption_device_role", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pn_dcp_suboption_device_aliasname, { "AliasName", "pn_dcp.suboption_device_aliasname", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pn_dcp_suboption_dhcp, { "Suboption", "pn_dcp.suboption_dhcp", FT_UINT8, BASE_DEC, VALS(pn_dcp_suboption_dhcp), 0x0, NULL, HFILL }}, { &hf_pn_dcp_suboption_dhcp_device_id, { "Device ID", "pn_dcp.suboption_dhcp_device_id", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pn_dcp_suboption_control, { "Suboption", "pn_dcp.suboption_control", FT_UINT8, BASE_DEC, VALS(pn_dcp_suboption_control), 0x0, NULL, HFILL }}, { &hf_pn_dcp_suboption_control_response, { "Response", "pn_dcp.suboption_control_response", FT_UINT8, BASE_DEC, VALS(pn_dcp_option), 0x0, NULL, HFILL }}, { &hf_pn_dcp_suboption_deviceinitiative, { "Suboption", "pn_dcp.suboption_deviceinitiative", FT_UINT8, BASE_DEC, VALS(pn_dcp_suboption_deviceinitiative), 0x0, NULL, HFILL }}, { &hf_pn_dcp_deviceinitiative_value, { "DeviceInitiativeValue", "pn_dcp.deviceinitiative_value", FT_UINT16, BASE_DEC, VALS(pn_dcp_deviceinitiative_value), 0x0, NULL, HFILL }}, { &hf_pn_dcp_suboption_all, { "Suboption", "pn_dcp.suboption_all", FT_UINT8, BASE_DEC, VALS(pn_dcp_suboption_all), 0x0, NULL, HFILL }}, { &hf_pn_dcp_suboption_manuf, { "Suboption", "pn_dcp.suboption_manuf", FT_UINT8, BASE_DEC, VALS(pn_dcp_suboption_manuf), 0x0, NULL, HFILL }}, }; static gint *ett[] = { &ett_pn_dcp, &ett_pn_dcp_block }; proto_pn_dcp = proto_register_protocol ("PROFINET DCP", "PN-DCP", "pn_dcp"); proto_register_field_array (proto_pn_dcp, hf, array_length (hf)); proto_register_subtree_array (ett, array_length (ett)); }
void proto_register_netdump(void) { module_t *netdump_module; /* Setup protocol subtree array */ static gint *ett[] = { &ett_netdump }; static hf_register_info hf[] = { { &hf_netdump_magic_number, { "Netdump Magic Number", "netdump.magic", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_netdump_seq_nr, {"Netdump seq number", "netdump.seq_nr", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL} }, { &hf_netdump_command, {"Netdump command", "netdump.command", FT_UINT32, BASE_DEC, VALS(command_names), 0x0, NULL, HFILL} }, { &hf_netdump_from, {"Netdump from val", "netdump.from", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL} }, { &hf_netdump_to, {"Netdump to val", "netdump.to", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL} }, { &hf_netdump_code, {"Netdump code", "netdump.code", FT_UINT32, BASE_DEC, VALS(reply_code_names), 0x0, NULL, HFILL} }, { &hf_netdump_info, {"Netdump info", "netdump.info", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL} }, { &hf_netdump_payload, {"Netdump payload", "netdump.payload", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL} }, { &hf_netdump_version, {"Netdump version", "netdump.version", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL} } }; proto_netdump = proto_register_protocol ( "Netdump Protocol", /* name */ "Netdump", /* short name */ "netdump" /* abbrev */ ); proto_register_field_array(proto_netdump, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); netdump_module = prefs_register_protocol(proto_netdump, proto_reg_handoff_netdump); /* Register a sample port preference */ prefs_register_uint_preference(netdump_module, "udp.port", "Netdump UDP port", "port if other than the default", 10, &gPORT_PREF); }
void proto_register_aoe(void) { static hf_register_info hf[] = { { &hf_aoe_cmd, { "Command", "aoe.cmd", FT_UINT8, BASE_DEC, VALS(cmd_vals), 0x0, "AOE Command", HFILL}}, { &hf_aoe_version, { "Version", "aoe.version", FT_UINT8, BASE_DEC, NULL, 0x0, "Version of the AOE protocol", HFILL}}, { &hf_aoe_error, { "Error", "aoe.error", FT_UINT8, BASE_DEC, VALS(error_vals), 0x0, "Error code", HFILL}}, { &hf_aoe_err_feature, { "Err/Feature", "aoe.err_feature", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_aoe_sector_count, { "Sector Count", "aoe.sector_count", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_aoe_flags_response, { "Response flag", "aoe.response", FT_BOOLEAN, 8, TFS(&tfs_response), AOE_FLAGS_RESPONSE, "Whether this is a response PDU or not", HFILL}}, { &hf_aoe_flags_error, { "Error flag", "aoe.flags_error", FT_BOOLEAN, 8, TFS(&tfs_error), AOE_FLAGS_ERROR, "Whether this is an error PDU or not", HFILL}}, { &hf_aoe_major, { "Major", "aoe.major", FT_UINT16, BASE_HEX, NULL, 0x0, "Major address", HFILL}}, { &hf_aoe_minor, { "Minor", "aoe.minor", FT_UINT8, BASE_HEX, NULL, 0x0, "Minor address", HFILL}}, { &hf_aoe_acmd, { "ATA Cmd", "aoe.ata.cmd", FT_UINT8, BASE_HEX, VALS(ata_cmd_vals), 0x0, "ATA command opcode", HFILL}}, { &hf_aoe_astatus, { "ATA Status", "aoe.ata.status", FT_UINT8, BASE_HEX, NULL, 0x0, "ATA status bits", HFILL}}, { &hf_aoe_tag, { "Tag", "aoe.tag", FT_UINT32, BASE_HEX, NULL, 0x0, "Command Tag", HFILL}}, { &hf_aoe_aflags_e, { "E", "aoe.aflags.e", FT_BOOLEAN, 8, TFS(&tfs_aflags_e), AOE_AFLAGS_E, "Whether this is a normal or LBA48 command", HFILL}}, { &hf_aoe_aflags_d, { "D", "aoe.aflags.d", FT_BOOLEAN, 8, TFS(&tfs_aflags_d), AOE_AFLAGS_D, NULL, HFILL}}, { &hf_aoe_aflags_a, { "A", "aoe.aflags.a", FT_BOOLEAN, 8, TFS(&tfs_aflags_a), AOE_AFLAGS_A, "Whether this is an asynchronous write or not", HFILL}}, { &hf_aoe_aflags_w, { "W", "aoe.aflags.w", FT_BOOLEAN, 8, TFS(&tfs_aflags_w), AOE_AFLAGS_W, "Is this a command writing data to the device or not", HFILL}}, { &hf_aoe_lba, { "Lba", "aoe.lba", FT_UINT64, BASE_HEX, NULL, 0x00, "Lba address", HFILL}}, { &hf_aoe_response_in, { "Response In", "aoe.response_in", FT_FRAMENUM, BASE_NONE, NULL, 0x0, "The response to this packet is in this frame", HFILL }}, { &hf_aoe_response_to, { "Response To", "aoe.response_to", FT_FRAMENUM, BASE_NONE, NULL, 0x0, "This is a response to the ATA command in this frame", HFILL }}, { &hf_aoe_time, { "Time from request", "aoe.time", FT_RELATIVE_TIME, BASE_NONE, NULL, 0, "Time between Request and Reply for ATA calls", HFILL }}, }; static gint *ett[] = { &ett_aoe, &ett_aoe_flags, }; proto_aoe = proto_register_protocol("ATAoverEthernet", "AOE", "aoe"); proto_register_field_array(proto_aoe, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); aoe_handle = register_dissector("aoe", dissect_aoe, proto_aoe); register_init_routine(ata_init); }
void proto_register_dvmrp(void) { static hf_register_info hf[] = { { &hf_version, { "DVMRP Version", "dvmrp.version", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, { &hf_type, { "Type", "dvmrp.type", FT_UINT8, BASE_HEX, VALS(dvmrp_type), 0, "DVMRP Packet Type", HFILL }}, { &hf_code_v1, { "Code", "dvmrp.v1.code", FT_UINT8, BASE_HEX, VALS(code_v1), 0, "DVMRP Packet Code", HFILL }}, { &hf_checksum, { "Checksum", "dvmrp.checksum", FT_UINT16, BASE_HEX, NULL, 0, "DVMRP Checksum", HFILL }}, { &hf_checksum_bad, { "Bad Checksum", "dvmrp.checksum_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Bad DVMRP Checksum", HFILL }}, { &hf_commands, { "Commands", "dvmrp.commands", FT_NONE, BASE_NONE, NULL, 0, "DVMRP V1 Commands", HFILL }}, { &hf_command, { "Command", "dvmrp.command", FT_UINT8, BASE_HEX, VALS(command), 0, "DVMRP V1 Command", HFILL }}, { &hf_afi, { "Address Family", "dvmrp.afi", FT_UINT8, BASE_HEX, VALS(afi), 0, "DVMRP Address Family Indicator", HFILL }}, { &hf_count, { "Count", "dvmrp.count", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL }}, { &hf_netmask, { "Netmask", "dvmrp.netmask", FT_IPv4, BASE_NONE, NULL, 0, "DVMRP Netmask", HFILL }}, { &hf_metric, { "Metric", "dvmrp.metric", FT_UINT8, BASE_DEC, NULL, 0, "DVMRP Metric", HFILL }}, {&hf_dest_unr, { "Destination Unreachable", "dvmrp.dest_unreach", FT_BOOLEAN, 8, TFS(&tfs_dest_unreach), 0x01, NULL, HFILL }}, {&hf_split_horiz, { "Split Horizon", "dvmrp.split_horiz", FT_BOOLEAN, 8, TFS(&tfs_split_horiz), 0x02, "Split Horizon concealed route", HFILL }}, { &hf_infinity, { "Infinity", "dvmrp.infinity", FT_UINT8, BASE_DEC, NULL, 0, "DVMRP Infinity", HFILL }}, { &hf_daddr, { "Dest Addr", "dvmrp.daddr", FT_IPv4, BASE_NONE, NULL, 0, "DVMRP Destination Address", HFILL }}, { &hf_maddr, { "Multicast Addr", "dvmrp.maddr", FT_IPv4, BASE_NONE, NULL, 0, "DVMRP Multicast Address", HFILL }}, { &hf_hold, { "Hold Time", "dvmrp.hold", FT_UINT32, BASE_DEC, NULL, 0, "DVMRP Hold Time in seconds", HFILL }}, { &hf_code_v3, { "Code", "dvmrp.v3.code", FT_UINT8, BASE_HEX, VALS(code_v3), 0, "DVMRP Packet Code", HFILL }}, { &hf_capabilities, { "Capabilities", "dvmrp.capabilities", FT_NONE, BASE_NONE, NULL, 0, "DVMRP V3 Capabilities", HFILL }}, {&hf_cap_leaf, { "Leaf", "dvmrp.cap.leaf", FT_BOOLEAN, 8, TFS(&tfs_cap_leaf), DVMRP_V3_CAP_LEAF, NULL, HFILL }}, {&hf_cap_prune, { "Prune", "dvmrp.cap.prune", FT_BOOLEAN, 8, TFS(&tfs_cap_prune), DVMRP_V3_CAP_PRUNE, "Prune capability", HFILL }}, {&hf_cap_genid, { "Genid", "dvmrp.cap.genid", FT_BOOLEAN, 8, TFS(&tfs_cap_genid), DVMRP_V3_CAP_GENID, "Genid capability", HFILL }}, {&hf_cap_mtrace, { "Mtrace", "dvmrp.cap.mtrace", FT_BOOLEAN, 8, TFS(&tfs_cap_mtrace), DVMRP_V3_CAP_MTRACE, "Mtrace capability", HFILL }}, {&hf_cap_snmp, { "SNMP", "dvmrp.cap.snmp", FT_BOOLEAN, 8, TFS(&tfs_cap_snmp), DVMRP_V3_CAP_SNMP, "SNMP capability", HFILL }}, {&hf_cap_netmask, { "Netmask", "dvmrp.cap.netmask", FT_BOOLEAN, 8, TFS(&tfs_cap_netmask), DVMRP_V3_CAP_NETMASK, "Netmask capability", HFILL }}, { &hf_min_ver, { "Minor Version", "dvmrp.min_ver", FT_UINT8, BASE_HEX, NULL, 0, "DVMRP Minor Version", HFILL }}, { &hf_maj_ver, { "Major Version", "dvmrp.maj_ver", FT_UINT8, BASE_HEX, NULL, 0, "DVMRP Major Version", HFILL }}, { &hf_genid, { "Generation ID", "dvmrp.genid", FT_UINT32, BASE_DEC, NULL, 0, "DVMRP Generation ID", HFILL }}, { &hf_route, { "Route", "dvmrp.route", FT_NONE, BASE_NONE, NULL, 0, "DVMRP V3 Route Report", HFILL }}, { &hf_saddr, { "Source Addr", "dvmrp.saddr", FT_IPv4, BASE_NONE, NULL, 0, "DVMRP Source Address", HFILL }}, { &hf_life, { "Prune lifetime", "dvmrp.lifetime", FT_UINT32, BASE_DEC, NULL, 0, "DVMRP Prune Lifetime", HFILL }}, { &hf_local, { "Local Addr", "dvmrp.local", FT_IPv4, BASE_NONE, NULL, 0, "DVMRP Local Address", HFILL }}, { &hf_threshold, { "Threshold", "dvmrp.threshold", FT_UINT8, BASE_DEC, NULL, 0, "DVMRP Interface Threshold", HFILL }}, { &hf_flags, { "Flags", "dvmrp.flags", FT_NONE, BASE_NONE, NULL, 0, "DVMRP Interface Flags", HFILL }}, { &hf_flag_tunnel, { "Tunnel", "dvmrp.flag.tunnel", FT_BOOLEAN, 8, NULL, DVMRP_V3_FLAG_TUNNEL, "Neighbor reached via tunnel", HFILL }}, { &hf_flag_srcroute, { "Source Route", "dvmrp.flag.srcroute", FT_BOOLEAN, 8, NULL, DVMRP_V3_FLAG_SRCROUTE, "Tunnel uses IP source routing", HFILL }}, { &hf_flag_down, { "Down", "dvmrp.flag.down", FT_BOOLEAN, 8, NULL, DVMRP_V3_FLAG_DOWN, "Operational status down", HFILL }}, { &hf_flag_disabled, { "Disabled", "dvmrp.flag.disabled", FT_BOOLEAN, 8, NULL, DVMRP_V3_FLAG_DISABLED, "Administrative status down", HFILL }}, { &hf_flag_querier, { "Querier", "dvmrp.flag.querier", FT_BOOLEAN, 8, NULL, DVMRP_V3_FLAG_QUERIER, "Querier for interface", HFILL }}, { &hf_flag_leaf, { "Leaf", "dvmrp.flag.leaf", FT_BOOLEAN, 8, NULL, DVMRP_V3_FLAG_LEAF, "No downstream neighbors on interface", HFILL }}, { &hf_ncount, { "Neighbor Count", "dvmrp.ncount", FT_UINT8, BASE_DEC, NULL, 0, "DVMRP Neighbor Count", HFILL }}, { &hf_neighbor, { "Neighbor Addr", "dvmrp.neighbor", FT_IPv4, BASE_NONE, NULL, 0, "DVMRP Neighbor Address", HFILL }} }; static gint *ett[] = { &ett_dvmrp, &ett_commands, &ett_capabilities, &ett_flags, &ett_route }; module_t *module_dvmrp; proto_dvmrp = proto_register_protocol("Distance Vector Multicast Routing Protocol", "DVMRP", "dvmrp"); proto_register_field_array(proto_dvmrp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); module_dvmrp = prefs_register_protocol(proto_dvmrp, NULL); prefs_register_bool_preference(module_dvmrp, "strict_v3", "Allow strict DVMRP V3 only", "Allow only packets with Major=0x03//Minor=0xFF as DVMRP V3 packets", &strict_v3); }
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); }
void proto_register_mqpcf(void) { expert_module_t *expert_mqpcf; static hf_register_info hf[] = { { &hf_mqpcf_cfh_type , { "Type.....", "mqpcf.cfh.type" , FT_UINT32, BASE_DEC, VALS(mq_mqcft_vals), 0x0, "CFH type", HFILL }}, { &hf_mqpcf_cfh_length , { "Length...", "mqpcf.cfh.length" , FT_UINT32, BASE_DEC, NULL, 0x0, "CFH length", HFILL }}, { &hf_mqpcf_cfh_version , { "Version..", "mqpcf.cfh.version" , FT_UINT32, BASE_DEC, NULL, 0x0, "CFH version", HFILL }}, { &hf_mqpcf_cfh_command , { "Command..", "mqpcf.cfh.command" , FT_UINT32, BASE_DEC | BASE_EXT_STRING, &mq_mqcmd_xvals, 0x0, "CFH command", HFILL }}, { &hf_mqpcf_cfh_MsgSeqNbr, { "MsgSeqNbr", "mqpcf.cfh.MsgSeqNbr" , FT_UINT32, BASE_DEC, NULL, 0x0, "CFH message sequence number", HFILL }}, { &hf_mqpcf_cfh_control , { "Control..", "mqpcf.cfh.control" , FT_UINT32, BASE_DEC, VALS(mq_CtlOpt_vals), 0x0, "CFH control", HFILL }}, { &hf_mqpcf_cfh_compcode , { "CompCode.", "mqpcf.cfh.compcode" , FT_UINT32, BASE_DEC, VALS(mq_mqcc_vals), 0x0, "CFH completion code", HFILL }}, { &hf_mqpcf_cfh_reason , { "ReasCode.", "mqpcf.cfh.reasoncode", FT_UINT32, BASE_DEC | BASE_EXT_STRING, &mq_mqrc_xvals, 0x0, "CFH reason code", HFILL }}, { &hf_mqpcf_cfh_ParmCount, { "ParmCount", "mqpcf.cfh.ParmCount" , FT_UINT32, BASE_DEC, NULL, 0x0, "CFH parameter count", HFILL }}, { &hf_mq_pcf_prmtyp , { "ParmTyp..", "mqpcf.parm.type" , FT_UINT32 , BASE_DEC | BASE_EXT_STRING, &mq_PrmTyp_xvals, 0x0, "MQPCF parameter type", HFILL }}, { &hf_mq_pcf_prmlen , { "ParmLen..", "mqpcf.parm.len" , FT_UINT32 , BASE_DEC, NULL, 0x0, "MQPCF parameter length", HFILL }}, { &hf_mq_pcf_prmid , { "ParmID...", "mqpcf.parm.id" , FT_UINT32 , BASE_DEC | BASE_EXT_STRING, &mq_PrmId_xvals, 0x0, "MQPCF parameter id", HFILL }}, { &hf_mq_pcf_prmidnovals , { "ParmID...", "mqpcf.parm.idNoVals" , FT_UINT32 , BASE_HEX_DEC, NULL, 0x0, "MQPCF parameter id No Vals", HFILL }}, { &hf_mq_pcf_filterop , { "FilterOP.", "mqpcf.filter.op" , FT_UINT32 , BASE_DEC, VALS(mq_FilterOP_vals), 0x0, "MQPCF Filter operator", HFILL }}, { &hf_mq_pcf_prmccsid , { "ParmCCSID", "mqpcf.parm.ccsid" , FT_UINT32 , BASE_DEC | BASE_RANGE_STRING, RVALS(mq_ccsid_rvals), 0x0, "MQPCF parameter ccsid", HFILL }}, { &hf_mq_pcf_prmstrlen , { "ParmStrLn", "mqpcf.parm.strlen" , FT_UINT32 , BASE_DEC, NULL, 0x0, "MQPCF parameter strlen", HFILL }}, { &hf_mq_pcf_prmcount , { "ParmCount", "mqpcf.parm.count" , FT_UINT32 , BASE_DEC, NULL, 0x0, "MQPCF parameter count", HFILL }}, { &hf_mq_pcf_prmunused , { "ParmUnuse", "mqpcf.parm.unused" , FT_UINT32 , BASE_DEC, NULL, 0x0, "MQPCF parameter unused", HFILL }}, { &hf_mq_pcf_string , { "String...", "mqpcf.parm.string" , FT_STRINGZ, BASE_NONE, NULL, 0x0, "MQPCF parameter string", HFILL }}, { &hf_mq_pcf_stringlist , { "StrList..", "mqpcf.parm.stringlist", FT_STRINGZ, BASE_NONE, NULL, 0x0, "MQPCF parameter string list", HFILL }}, { &hf_mq_pcf_int , { "Integer..", "mqpcf.parm.int" , FT_INT32 , BASE_DEC, NULL, 0x0, "MQPCF parameter int", HFILL }}, { &hf_mq_pcf_intlist , { "IntList..", "mqpcf.parm.intlist" , FT_INT32 , BASE_DEC, NULL, 0x0, "MQPCF parameter int list", HFILL }}, { &hf_mq_pcf_bytestring , { "ByteStr..", "mqpcf.parm.bytestring", FT_BYTES , BASE_NONE, NULL, 0x0, "MQPCF parameter byte string", HFILL }}, { &hf_mq_pcf_int64 , { "Int64....", "mqpcf.parm.int64" , FT_INT64 , BASE_DEC, NULL, 0x0, "MQPCF parameter int64", HFILL }}, { &hf_mq_pcf_int64list , { "Int64List", "mqpcf.parm.int64list" , FT_INT64 , BASE_DEC, NULL, 0x0, "MQPCF parameter int64 list", HFILL }}, }; static gint *ett[] = { &ett_mqpcf, &ett_mqpcf_prm, &ett_mqpcf_cfh, }; static ei_register_info ei[] = { { &ei_mq_pcf_prmln0, { "mqpcf.parm.len0" , PI_MALFORMED, PI_ERROR, "MQPCF Parameter length is 0", EXPFILL }}, { &ei_mq_pcf_MaxInt, { "mqpcf.parm.IntList" , PI_UNDECODED, PI_WARN , "MQPCF Parameter Integer list exhausted", EXPFILL }}, { &ei_mq_pcf_MaxStr, { "mqpcf.parm.StrList" , PI_UNDECODED, PI_WARN , "MQPCF Parameter String list exhausted", EXPFILL }}, { &ei_mq_pcf_MaxI64, { "mqpcf.parm.Int64List", PI_UNDECODED, PI_WARN , "MQPCF Parameter Int64 list exhausted", EXPFILL }}, { &ei_mq_pcf_MaxPrm, { "mqpcf.parm.MaxPrm" , PI_UNDECODED, PI_WARN , "MQPCF Max number of parameter exhausted", EXPFILL }}, { &ei_mq_pcf_PrmCnt, { "mqpcf.parm.PrmCnt" , PI_UNDECODED, PI_WARN , "MQPCF Unkn Parm Cnt Length invalid", EXPFILL }}, }; module_t *mq_pcf_module; proto_mqpcf = proto_register_protocol("WebSphere MQ Programmable Command Formats", "MQ PCF", "mqpcf"); proto_register_field_array(proto_mqpcf, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); expert_mqpcf = expert_register_protocol(proto_mqpcf); expert_register_field_array(expert_mqpcf, ei, array_length(ei)); mq_pcf_module = prefs_register_protocol(proto_mqpcf, NULL); prefs_register_uint_preference(mq_pcf_module, "maxprm", "Set the maximun number of parameter in the PCF to decode", "When dissecting PCF there can be a lot of parameters." " You can limit the number of parameter decoded, before it continue with the next PCF.", 10, &mq_pcf_maxprm); prefs_register_uint_preference(mq_pcf_module, "maxlst", "Set the maximun number of Parameter List that are displayed", "When dissecting a parameter of a PCFm, if it is a StringList, IntegerList or Integer64 List, " " You can limit the number of element displayed, before it continue with the next Parameter.", 10, &mq_pcf_maxlst); }
void proto_register_llc(void) { static struct true_false_string ig_bit = { "Group", "Individual" }; static struct true_false_string cr_bit = { "Response", "Command" }; static hf_register_info hf[] = { { &hf_llc_dsap, { "DSAP", "llc.dsap", FT_UINT8, BASE_HEX, VALS(sap_vals), 0x0, "Destination Service Access Point", HFILL }}, { &hf_llc_dsap_sap, { "SAP", "llc.dsap.sap", FT_UINT8, BASE_CUSTOM, llc_sap_value, 0xFE, "Service Access Point", HFILL }}, { &hf_llc_dsap_ig, { "IG Bit", "llc.dsap.ig", FT_BOOLEAN, 8, TFS(&ig_bit), DSAP_GI_BIT, "Individual/Group", HFILL }}, { &hf_llc_ssap, { "SSAP", "llc.ssap", FT_UINT8, BASE_HEX, VALS(sap_vals), 0x0, "Source Service Access Point", HFILL }}, { &hf_llc_ssap_sap, { "SAP", "llc.ssap.sap", FT_UINT8, BASE_CUSTOM, llc_sap_value, 0xFE, "Service Access Point", HFILL }}, { &hf_llc_ssap_cr, { "CR Bit", "llc.ssap.cr", FT_BOOLEAN, 8, TFS(&cr_bit), SSAP_CR_BIT, "Command/Response", HFILL }}, { &hf_llc_ctrl, { "Control", "llc.control", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_llc_n_r, { "N(R)", "llc.control.n_r", FT_UINT16, BASE_DEC, NULL, XDLC_N_R_EXT_MASK, NULL, HFILL }}, { &hf_llc_n_s, { "N(S)", "llc.control.n_s", FT_UINT16, BASE_DEC, NULL, XDLC_N_S_EXT_MASK, NULL, HFILL }}, { &hf_llc_p, { "Poll", "llc.control.p", FT_BOOLEAN, 8, TFS(&tfs_set_notset), XDLC_P_F, NULL, HFILL }}, { &hf_llc_p_ext, { "Poll", "llc.control.p", FT_BOOLEAN, 16, TFS(&tfs_set_notset), XDLC_P_F_EXT, NULL, HFILL }}, { &hf_llc_f, { "Final", "llc.control.f", FT_BOOLEAN, 8, TFS(&tfs_set_notset), XDLC_P_F, NULL, HFILL }}, { &hf_llc_f_ext, { "Final", "llc.control.f", FT_BOOLEAN, 16, TFS(&tfs_set_notset), XDLC_P_F_EXT, NULL, HFILL }}, { &hf_llc_s_ftype, { "Supervisory frame type", "llc.control.s_ftype", FT_UINT16, BASE_HEX, VALS(stype_vals), XDLC_S_FTYPE_MASK, NULL, HFILL }}, { &hf_llc_u_modifier_cmd, { "Command", "llc.control.u_modifier_cmd", FT_UINT8, BASE_HEX, VALS(modifier_vals_cmd), XDLC_U_MODIFIER_MASK, NULL, HFILL }}, { &hf_llc_u_modifier_resp, { "Response", "llc.control.u_modifier_resp", FT_UINT8, BASE_HEX, VALS(modifier_vals_resp), XDLC_U_MODIFIER_MASK, NULL, HFILL }}, { &hf_llc_ftype_i, { "Frame type", "llc.control.ftype", FT_UINT16, BASE_HEX, VALS(ftype_vals), XDLC_I_MASK, NULL, HFILL }}, { &hf_llc_ftype_s_u, { "Frame type", "llc.control.ftype", FT_UINT8, BASE_HEX, VALS(ftype_vals), XDLC_S_U_MASK, NULL, HFILL }}, { &hf_llc_ftype_s_u_ext, { "Frame type", "llc.control.ftype", FT_UINT16, BASE_HEX, VALS(ftype_vals), XDLC_S_U_MASK, NULL, HFILL }}, /* registered here but handled in ethertype.c */ { &hf_llc_type, { "Type", "llc.type", FT_UINT16, BASE_HEX, VALS(etype_vals), 0x0, NULL, HFILL }}, { &hf_llc_oui, { "Organization Code", "llc.oui", FT_UINT24, BASE_HEX, VALS(oui_vals), 0x0, NULL, HFILL }}, { &hf_llc_pid, { "Protocol ID", "llc.pid", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }} }; static gint *ett[] = { &ett_llc, &ett_llc_dsap, &ett_llc_ssap, &ett_llc_ctrl, }; proto_llc = proto_register_protocol("Logical-Link Control", "LLC", "llc"); proto_register_field_array(proto_llc, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); /* subdissector code */ dsap_subdissector_table = register_dissector_table("llc.dsap", "LLC SAP", FT_UINT8, BASE_HEX); xid_subdissector_table = register_dissector_table("llc.xid_dsap", "LLC XID SAP", FT_UINT8, BASE_HEX); register_dissector("llc", dissect_llc, proto_llc); }
void proto_register_n2n(void) { static hf_register_info hf[] = { { &hf_n2n_version, { "N2N Version", "n2n.version", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_n2n_ttl, { "Time to Live", "n2n.ttl", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_n2n_flag_supernode, { "From Supernode", "n2n.flags.from_supernode", FT_BOOLEAN, 16, NULL, N2N_FLAGS_FROM_SUPERNODE, NULL, HFILL } }, { &hf_n2n_pkttype, { "Packet Type", "n2n.pkttype", FT_UINT16, BASE_DEC, VALS(packettypenames), N2N_PKTTYPE_MASK, NULL, HFILL } }, { &hf_n2n_community, { "Community", "n2n.community", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_n2n_transportid, { "Transport ID", "n2n.transportid", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL} }, { &hf_n2n_dstmac, { "Destination MAC", "n2n.dstmac", FT_ETHER, BASE_NONE, NULL, 0x0, NULL, HFILL} }, { &hf_n2n_srcmac, { "Source MAC", "n2n.srcmac", FT_ETHER, BASE_NONE, NULL, 0x0, NULL, HFILL} }, { &hf_n2n_ethertype, { "Encapsulated Protocol", "n2n.ethertype", FT_UINT16, BASE_HEX, VALS(etype_vals), 0x0, NULL, HFILL} } }; /* Setup protcol subtree array */ static gint *ett[] = { &ett_n2n }; proto_n2n = proto_register_protocol ( "N2N Protocol", /* name */ "N2N", /* short name */ "n2n" /* abbrev */ ); proto_register_field_array(proto_n2n, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }
void proto_register_sita(void) { static hf_register_info hf[] = { { &hf_proto, { "Protocol", "sita.errors.protocol", FT_UINT8, BASE_HEX, VALS(tfs_sita_proto), 0, "Protocol value", HFILL } }, { &hf_dir, { "Direction", "sita.flags.flags", FT_BOOLEAN, 8, TFS(&tfs_sita_flags), SITA_FRAME_DIR, "TRUE 'from Remote', FALSE 'from Local'", HFILL } }, { &hf_droppedframe, { "No Buffers", "sita.flags.droppedframe", FT_BOOLEAN, 8, TFS(&tfs_sita_error), SITA_ERROR_NO_BUFFER, "TRUE if Buffer Failure", HFILL } }, { &hf_framing, { "Framing", "sita.errors.framing", FT_BOOLEAN, 8, TFS(&tfs_sita_error), SITA_ERROR_RX_FRAMING, "TRUE if Framing Error", HFILL } }, { &hf_parity, { "Parity", "sita.errors.parity", FT_BOOLEAN, 8, TFS(&tfs_sita_error), SITA_ERROR_RX_PARITY, "TRUE if Parity Error", HFILL } }, { &hf_collision, { "Collision", "sita.errors.collision", FT_BOOLEAN, 8, TFS(&tfs_sita_error), SITA_ERROR_RX_COLLISION, "TRUE if Collision", HFILL } }, { &hf_longframe, { "Long Frame", "sita.errors.longframe", FT_BOOLEAN, 8, TFS(&tfs_sita_error), SITA_ERROR_RX_FRAME_LONG, "TRUE if Long Frame Received", HFILL } }, { &hf_shortframe, { "Short Frame", "sita.errors.shortframe", FT_BOOLEAN, 8, TFS(&tfs_sita_error), SITA_ERROR_RX_FRAME_SHORT, "TRUE if Short Frame", HFILL } }, { &hf_nonaligned, { "NonAligned", "sita.errors.nonaligned", FT_BOOLEAN, 8, TFS(&tfs_sita_error), SITA_ERROR_RX_NONOCTET_ALIGNED, "TRUE if NonAligned Frame", HFILL } }, { &hf_abort, { "Abort", "sita.errors.abort", FT_BOOLEAN, 8, TFS(&tfs_sita_received), SITA_ERROR_RX_ABORT, "TRUE if Abort Received", HFILL } }, { &hf_lostcd, { "Carrier", "sita.errors.lostcd", FT_BOOLEAN, 8, TFS(&tfs_sita_lost), SITA_ERROR_RX_CD_LOST, "TRUE if Carrier Lost", HFILL } }, { &hf_rxdpll, { "DPLL", "sita.errors.rxdpll", FT_BOOLEAN, 8, TFS(&tfs_sita_error), SITA_ERROR_RX_DPLL, "TRUE if DPLL Error", HFILL } }, { &hf_overrun, { "Overrun", "sita.errors.overrun", FT_BOOLEAN, 8, TFS(&tfs_sita_error), SITA_ERROR_RX_OVERRUN, "TRUE if Overrun Error", HFILL } }, { &hf_length, { "Length", "sita.errors.length", FT_BOOLEAN, 8, TFS(&tfs_sita_violation), SITA_ERROR_RX_FRAME_LEN_VIOL, "TRUE if Length Violation", HFILL } }, { &hf_crc, { "CRC", "sita.errors.crc", FT_BOOLEAN, 8, TFS(&tfs_sita_error), SITA_ERROR_RX_CRC, "TRUE if CRC Error", HFILL } }, { &hf_break, { "Break", "sita.errors.break", FT_BOOLEAN, 8, TFS(&tfs_sita_received), SITA_ERROR_RX_BREAK, "TRUE if Break Received", HFILL } }, { &hf_underrun, { "Underrun", "sita.errors.underrun", FT_BOOLEAN, 8, TFS(&tfs_sita_error), SITA_ERROR_TX_UNDERRUN, "TRUE if Tx Underrun", HFILL } }, { &hf_lostcts, { "Clear To Send", "sita.errors.lostcts", FT_BOOLEAN, 8, TFS(&tfs_sita_lost), SITA_ERROR_TX_CTS_LOST, "TRUE if Clear To Send Lost", HFILL } }, { &hf_uarterror, { "UART", "sita.errors.uarterror", FT_BOOLEAN, 8, TFS(&tfs_sita_error), SITA_ERROR_TX_UART_ERROR, "TRUE if UART Error", HFILL } }, { &hf_rtxlimit, { "Retx Limit", "sita.errors.rtxlimit", FT_BOOLEAN, 8, TFS(&tfs_sita_exceeded), SITA_ERROR_TX_RETX_LIMIT, "TRUE if Retransmit Limit reached", HFILL } }, { &hf_dsr, { "DSR", "sita.signals.dsr", FT_BOOLEAN, 8, TFS(&tfs_sita_on_off), SITA_SIG_DSR, "TRUE if Data Set Ready", HFILL } }, { &hf_dtr, { "DTR", "sita.signals.dtr", FT_BOOLEAN, 8, TFS(&tfs_sita_on_off), SITA_SIG_DTR, "TRUE if Data Terminal Ready", HFILL } }, { &hf_cts, { "CTS", "sita.signals.cts", FT_BOOLEAN, 8, TFS(&tfs_sita_on_off), SITA_SIG_CTS, "TRUE if Clear To Send", HFILL } }, { &hf_rts, { "RTS", "sita.signals.rts", FT_BOOLEAN, 8, TFS(&tfs_sita_on_off), SITA_SIG_RTS, "TRUE if Request To Send", HFILL } }, { &hf_dcd, { "DCD", "sita.signals.dcd", FT_BOOLEAN, 8, TFS(&tfs_sita_on_off), SITA_SIG_DCD, "TRUE if Data Carrier Detect", HFILL } }, { &hf_signals, { "Signals", "sita.signals", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } }, }; static gint *ett[] = { &ett_sita, &ett_sita_flags, &ett_sita_signals, &ett_sita_errors1, &ett_sita_errors2, }; proto_sita = proto_register_protocol("Societe Internationale de Telecommunications Aeronautiques", "SITA", "sita"); /* name, short name,abbreviation */ sita_dissector_table = register_dissector_table("sita.proto", "SITA protocol number", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE); proto_register_field_array(proto_sita, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); register_dissector("sita", dissect_sita, proto_sita); }
/* registers this protocol with Wireshark */ void proto_register_mpa(void) { /* setup list of header fields */ static hf_register_info hf[] = { { &hf_mpa_req, { "Request frame header", "iwarp_mpa.req", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_mpa_rep, { "Reply frame header", "iwarp_mpa.rep", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_mpa_fpdu, { "FPDU", "iwarp_mpa.fpdu", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_mpa_marker, { "Markers", "iwarp_mpa.markers", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_mpa_key_req, { "ID Req frame", "iwarp_mpa.key.req", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_mpa_key_rep, { "ID Rep frame", "iwarp_mpa.key.rep", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_mpa_flag_m, { "Marker flag", "iwarp_mpa.marker_flag", FT_BOOLEAN, 8, NULL, MPA_MARKER_FLAG, NULL, HFILL } }, { &hf_mpa_flag_c, { "CRC flag", "iwarp_mpa.crc_flag", FT_BOOLEAN, 8, NULL, MPA_CRC_FLAG, NULL, HFILL } }, { &hf_mpa_flag_r, { "Connection rejected flag", "iwarp_mpa.rej_flag", FT_BOOLEAN, 8, NULL, MPA_REJECT_FLAG, NULL, HFILL } }, { &hf_mpa_flag_res, { "Reserved", "iwarp_mpa.res", FT_UINT8, BASE_HEX, NULL, MPA_RESERVED_FLAG, NULL, HFILL } }, { &hf_mpa_rev, { "Revision", "iwarp_mpa.rev", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_mpa_pd_length, { "Private data length", "iwarp_mpa.pdlength", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_mpa_private_data, { "Private data", "iwarp_mpa.privatedata", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_mpa_ulpdu_length, { "ULPDU length", "iwarp_mpa.ulpdulength", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_mpa_pad, { "Padding", "iwarp_mpa.pad", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_mpa_crc, { "CRC", "iwarp_mpa.crc", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_mpa_crc_check, { "CRC check", "iwarp_mpa.crc_check", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_mpa_marker_res, { "Reserved", "iwarp_mpa.marker_res", FT_UINT16, BASE_HEX, NULL, 0x0, "Marker: Reserved", HFILL } }, { &hf_mpa_marker_fpduptr, { "FPDU back pointer", "iwarp_mpa.marker_fpduptr", FT_UINT16, BASE_DEC, NULL, 0x0, "Marker: FPDU Pointer", HFILL } } }; /* setup protocol subtree array */ static gint *ett[] = { &ett_mpa, &ett_mpa_req, &ett_mpa_rep, &ett_mpa_fpdu, &ett_mpa_marker }; static ei_register_info ei[] = { { &ei_mpa_res_field_not_set0, { "iwarp_mpa.res.not_set0", PI_REQUEST_CODE, PI_WARN, "Res field is NOT set to zero as required by RFC 5044", EXPFILL }}, { &ei_mpa_rev_field_not_set1, { "iwarp_mpa.rev.not_set1", PI_REQUEST_CODE, PI_WARN, "Rev field is NOT set to one as required by RFC 5044", EXPFILL }}, { &ei_mpa_reject_bit_responder, { "iwarp_mpa.reject_bit_responder", PI_RESPONSE_CODE, PI_NOTE, "Reject bit set by Responder", EXPFILL }}, { &ei_mpa_bad_length, { "iwarp_mpa.bad_length", PI_MALFORMED, PI_ERROR, "Bad length", EXPFILL }}, }; expert_module_t* expert_iwarp_mpa; /* register the protocol name and description */ proto_iwarp_mpa = proto_register_protocol( "iWARP Marker Protocol data unit Aligned framing", "IWARP_MPA", "iwarp_mpa"); /* required function calls to register the header fields and subtrees */ proto_register_field_array(proto_iwarp_mpa, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); expert_iwarp_mpa = expert_register_protocol(proto_iwarp_mpa); expert_register_field_array(expert_iwarp_mpa, ei, array_length(ei)); }
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 } }, #if 0 { &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 } }, #endif { &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_dec_bpdu(void) { static hf_register_info hf[] = { { &hf_dec_bpdu_proto_id, { "Protocol Identifier", "dec_stp.protocol", FT_UINT8, BASE_HEX, VALS(protocol_id_vals), 0x0, NULL, HFILL }}, { &hf_dec_bpdu_type, { "BPDU Type", "dec_stp.type", FT_UINT8, BASE_DEC, VALS(bpdu_type_vals), 0x0, NULL, HFILL }}, { &hf_dec_bpdu_version_id, { "BPDU Version", "dec_stp.version", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_dec_bpdu_flags, { "BPDU flags", "dec_stp.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_dec_bpdu_flags_short_timers, { "Use short timers", "dec_stp.flags.short_timers", FT_BOOLEAN, 8, TFS(&tfs_yes_no), BPDU_FLAGS_SHORT_TIMERS, NULL, HFILL }}, { &hf_dec_bpdu_flags_tcack, { "Topology Change Acknowledgment", "dec_stp.flags.tcack", FT_BOOLEAN, 8, TFS(&tfs_yes_no), BPDU_FLAGS_TCACK, NULL, HFILL }}, { &hf_dec_bpdu_flags_tc, { "Topology Change", "dec_stp.flags.tc", FT_BOOLEAN, 8, TFS(&tfs_yes_no), BPDU_FLAGS_TC, NULL, HFILL }}, { &hf_dec_bpdu_root_pri, { "Root Priority", "dec_stp.root.pri", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_dec_bpdu_root_mac, { "Root MAC", "dec_stp.root.mac", FT_ETHER, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_dec_bpdu_root_cost, { "Root Path Cost", "dec_stp.root.cost", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_dec_bpdu_bridge_pri, { "Bridge Priority", "dec_stp.bridge.pri", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_dec_bpdu_bridge_mac, { "Bridge MAC", "dec_stp.bridge.mac", FT_ETHER, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_dec_bpdu_port_id, { "Port identifier", "dec_stp.port", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_dec_bpdu_msg_age, { "Message Age", "dec_stp.msg_age", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_dec_bpdu_hello_time, { "Hello Time", "dec_stp.hello", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_dec_bpdu_max_age, { "Max Age", "dec_stp.max_age", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_dec_bpdu_forward_delay, { "Forward Delay", "dec_stp.forward", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, }; static gint *ett[] = { &ett_dec_bpdu, &ett_dec_bpdu_flags, }; proto_dec_bpdu = proto_register_protocol("DEC Spanning Tree Protocol", "DEC_STP", "dec_stp"); proto_register_field_array(proto_dec_bpdu, 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_HEX, NULL, 0x0, "Network Service Virtual Link Identifier", HFILL } }, { &hf_nsip_pdu_type, { "PDU type", "nsip.pdu_type", FT_UINT8, BASE_OCT, VALS(tab_nsip_pdu_types), 0x0, "PDU type information element", HFILL } }, { &hf_nsip_bvci, { "BVCI", "nsip.bvci", FT_UINT16, BASE_DEC, NULL, 0x0, "BSSGP Virtual Connection Identifier", HFILL } }, { &hf_nsip_nsei, { "NSEI", "nsip.nsei", FT_UINT16, BASE_DEC, NULL, 0x0, "Network Service Entity Identifier", HFILL } }, #if 0 { &hf_nsip_ip4_elements, { "IP4 elements", "nsip.ip4_elements", FT_NONE, BASE_NONE, NULL, 0x0, "List of IP4 elements", HFILL } }, #endif #if 0 { &hf_nsip_ip6_elements, { "IP6 elements", "nsip.ip6_elements", FT_NONE, BASE_NONE, NULL, 0x0, "List of IP6 elements", HFILL } }, #endif { &hf_nsip_max_num_ns_vc, { "Maximum number of NS-VCs", "nsip.max_num_ns_vc", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_nsip_num_ip4_endpoints, { "Number of IP4 endpoints", "nsip.num_ip4_endpoints", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_nsip_num_ip6_endpoints, { "Number of IP6 endpoints", "nsip.num_ip6_endpoints", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_nsip_reset_flag, { "Reset flag", "nsip.reset_flag.flag", FT_BOOLEAN, 8, TFS(&tfs_set_notset), NSIP_MASK_RESET_FLAG, NULL, HFILL } }, { &hf_nsip_reset_flag_spare, { "Reset flag spare bits", "nsip.reset_flag.spare", FT_UINT8, BASE_HEX, NULL, NSIP_MASK_RESET_FLAG_SPARE, NULL, HFILL } }, { &hf_nsip_ip_address_type, { "IP Address Type", "nsip.ip_address_type", FT_UINT8, BASE_DEC, VALS(ip_address_type_vals), 0x0, NULL, HFILL } }, { &hf_nsip_ip_address_ipv4, { "IP Address", "nsip.ipv4_address", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_nsip_ip_address_ipv6, { "IP Address", "nsip.ipv6_address", FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_nsip_end_flag, { "End flag", "nsip.end_flag.flag", FT_BOOLEAN, 8, TFS(&tfs_set_notset), NSIP_MASK_END_FLAG, NULL, HFILL } }, { &hf_nsip_end_flag_spare, { "End flag spare bits", "nsip.end_flag.spare", FT_UINT8, BASE_HEX, NULL, NSIP_MASK_END_FLAG_SPARE, NULL, HFILL } }, { &hf_nsip_control_bits_r, { "Request change flow", "nsip.control_bits.r", FT_BOOLEAN, 8, TFS(&tfs_set_notset), NSIP_MASK_CONTROL_BITS_R, NULL, HFILL } }, { &hf_nsip_control_bits_c, { "Confirm change flow", "nsip.control_bits.c", FT_BOOLEAN, 8, TFS(&tfs_set_notset), NSIP_MASK_CONTROL_BITS_C, NULL, HFILL } }, { &hf_nsip_control_bits_spare, { "Spare bits", "nsip.control_bits.spare", FT_UINT8, BASE_HEX, NULL, NSIP_MASK_CONTROL_BITS_SPARE, NULL, HFILL } }, { &hf_nsip_transaction_id, { "Transaction ID", "nsip.transaction_id", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, #if 0 { &hf_nsip_ip_element_ip_address_ipv4, { "IP Address", "nsip.ip_element.ipv4_address", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } }, #endif #if 0 { &hf_nsip_ip_element_ip_address_ipv6, { "IP Address", "nsip.ip_element.ipv6_address", FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL } }, #endif { &hf_nsip_ip_element_udp_port, { "UDP Port", "nsip.ip_element.udp_port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_nsip_ip_element_signalling_weight, { "Signalling Weight", "nsip.ip_element.signalling_weight", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_nsip_ip_element_data_weight, { "Data Weight", "nsip.ip_element.data_weight", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_nsip, &ett_nsip_control_bits, &ett_nsip_reset_flag, &ett_nsip_end_flag, &ett_nsip_ip_element, &ett_nsip_ip_element_list, }; module_t *nsip_module; /* Register the protocol name and description */ proto_nsip = proto_register_protocol("GPRS Network Service", "GPRS-NS", "gprs-ns"); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_nsip, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); register_dissector("gprs_ns", dissect_nsip, proto_nsip); /* Set default UDP ports */ range_convert_str(&global_nsip_udp_port_range, DEFAULT_NSIP_PORT_RANGE, MAX_UDP_PORT); /* Register configuration options */ nsip_module = prefs_register_protocol(proto_nsip, proto_reg_handoff_nsip); prefs_register_obsolete_preference(nsip_module, "udp.port1"); prefs_register_obsolete_preference(nsip_module, "udp.port2"); prefs_register_range_preference(nsip_module, "udp.ports", "GPRS-NS UDP ports", "UDP ports to be decoded as GPRS-NS (default: " DEFAULT_NSIP_PORT_RANGE ")", &global_nsip_udp_port_range, MAX_UDP_PORT); }
void proto_register_roofnet(void) { static hf_register_info hf[] = { /* Roofnet Header */ { &hf_roofnet_version, { "Version", "roofnet.version", FT_UINT8, BASE_DEC, NULL, 0x0, "Roofnet Version", HFILL } }, { &hf_roofnet_type, { "Type", "roofnet.type", FT_UINT8, BASE_DEC, VALS(roofnet_pt_vals), 0x0, "Roofnet Message Type", HFILL } }, { &hf_roofnet_nlinks, { "Number of Links", "roofnet.nlinks", FT_UINT8, BASE_DEC, NULL, 0x0, "Roofnet Number of Links", HFILL } }, { &hf_roofnet_next, { "Next Link", "roofnet.next", FT_UINT8, BASE_DEC, NULL, 0x0, "Roofnet Next Link to Use", HFILL } }, { &hf_roofnet_ttl, { "Time To Live", "roofnet.ttl", FT_UINT16, BASE_DEC, NULL, 0x0, "Roofnet Time to Live", HFILL } }, { &hf_roofnet_cksum, { "Checksum", "roofnet.cksum", FT_UINT16, BASE_DEC, NULL, 0x0, "Roofnet Header Checksum", HFILL } }, { &hf_roofnet_flags, { "Flags", "roofnet.flags", FT_UINT16, BASE_DEC, VALS(roofnet_flags_vals), 0x0, "Roofnet Flags", HFILL } }, { &hf_roofnet_data_length, { "Data Length", "roofnet.datalength", FT_UINT16, BASE_DEC, NULL, 0x0, "Data Payload Length", HFILL } }, { &hf_roofnet_query_dst, { "Query Dst", "roofnet.querydst", FT_IPv4, BASE_NONE, NULL, 0x0, "Roofnet Query Destination", HFILL } }, { &hf_roofnet_seq, { "Seq", "roofnet.seq", FT_UINT32, BASE_DEC, NULL, 0x0, "Roofnet Sequential Number", HFILL } }, #if 0 { &hf_roofnet_links, { "Links", "roofnet.links", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, #endif { &hf_roofnet_link_src, { "Source IP", "roofnet.link.src", FT_IPv4, BASE_NONE, NULL, 0x0, "Roofnet Message Source", HFILL } }, { &hf_roofnet_link_forward, { "Forward", "roofnet.link.forward", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_roofnet_link_rev, { "Rev", "roofnet.link.rev", FT_UINT32, BASE_DEC, NULL, 0x0, "Revision Number", HFILL } }, { &hf_roofnet_link_seq, { "Seq", "roofnet.link.seq", FT_UINT32, BASE_DEC, NULL, 0x0, "Link Sequential Number", HFILL } }, { &hf_roofnet_link_age, { "Age", "roofnet.link.age", FT_UINT32, BASE_DEC, NULL, 0x0, "Information Age", HFILL } }, { &hf_roofnet_link_dst, { "Dst IP", "roofnet.link.dst", FT_IPv4, BASE_NONE, NULL, 0x0, "Roofnet Message Destination", HFILL } } }; /* setup protocol subtree array */ static gint *ett[] = { &ett_roofnet, &ett_roofnet_link }; static ei_register_info ei[] = { { &ei_roofnet_too_many_links, { "roofnet.too_many_links", PI_MALFORMED, PI_ERROR, "Too many links", EXPFILL }}, }; expert_module_t* expert_roofnet; proto_roofnet = proto_register_protocol( "Roofnet Protocol", /* Name */ "Roofnet", /* Short Name */ "roofnet" /* Abbrev */ ); proto_register_field_array(proto_roofnet, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); expert_roofnet = expert_register_protocol(proto_roofnet); expert_register_field_array(expert_roofnet, ei, array_length(ei)); }
void proto_register_turbocell(void) { static hf_register_info hf[] = { { &hf_turbocell_type, { "Packet Type", "turbocell.type", FT_UINT8, BASE_HEX, VALS(turbocell_type_values), 0, NULL, HFILL } }, { &hf_turbocell_satmode, { "Satellite Mode", "turbocell.satmode", FT_UINT8, BASE_HEX, VALS(turbocell_satmode_values), 0xF0, NULL, HFILL } }, { &hf_turbocell_nwid, { "Network ID", "turbocell.nwid", FT_UINT8, BASE_DEC, NULL, 0x0F, NULL, HFILL } }, { &hf_turbocell_counter, { "Counter", "turbocell.counter", FT_UINT24, BASE_DEC_HEX, NULL, 0, "Increments every frame (per station)", HFILL } }, { &hf_turbocell_dst, { "Destination", "turbocell.dst", FT_ETHER, BASE_NONE, NULL, 0, "Seems to be the destination", HFILL } }, { &hf_turbocell_ip, { "IP", "turbocell.ip", FT_IPv4, BASE_NONE, NULL, 0, "IP adress of base station ?", HFILL } }, { &hf_turbocell_unknown, { "Unknown", "turbocell.unknown", FT_UINT16, BASE_HEX, NULL, 0, "Always 0000", HFILL } }, { &hf_turbocell_timestamp, { "Timestamp (in 10 ms)", "turbocell.timestamp", FT_UINT24, BASE_DEC_HEX, NULL, 0, "Timestamp per station (since connection?)", HFILL } }, { &hf_turbocell_name, { "Network Name", "turbocell.name", FT_STRINGZ, BASE_NONE, NULL, 0, NULL, HFILL } }, STATION(0),STATION(1),STATION(2),STATION(3),STATION(4),STATION(5),STATION(6),STATION(7),STATION(8),STATION(9), STATION(10),STATION(11),STATION(12),STATION(13),STATION(14),STATION(15),STATION(16),STATION(17),STATION(18),STATION(19), STATION(20),STATION(21),STATION(22),STATION(23),STATION(24),STATION(25),STATION(26),STATION(27),STATION(28),STATION(29), STATION(30),STATION(31) }; static hf_register_info aggregate_fields[] = { { &hf_turbocell_aggregate_msdu_header_text, {"MAC Service Data Unit (MSDU)", "turbocell_aggregate.msduheader", FT_UINT16, BASE_DEC, 0, 0x0000, NULL, HFILL } }, { &hf_turbocell_aggregate_msdu_len, {"MSDU length", "turbocell_aggregate.msdulen", FT_UINT16, BASE_DEC_HEX, 0, 0x0FFF, NULL, HFILL } }, { &hf_turbocell_aggregate_len, { "Total Length", "turbocell_aggregate.len", FT_UINT16, BASE_DEC_HEX, NULL, 0, "Total reported length", HFILL } }, { &hf_turbocell_aggregate_unknown1, { "Unknown", "turbocell_aggregate.unknown1", FT_UINT16, BASE_HEX, NULL, 0, "Always 0x7856", HFILL } }, { &hf_turbocell_aggregate_unknown2, { "Unknown", "turbocell_aggregate.unknown2", FT_UINT8, BASE_HEX, NULL, 0xF0, "have the values 0x4,0xC or 0x8", HFILL } }, }; static gint *ett[] = { &ett_turbocell, &ett_network, &ett_msdu_aggregation_parent_tree, &ett_msdu_aggregation_subframe_tree }; proto_turbocell = proto_register_protocol("Turbocell Header", "Turbocell", "turbocell"); proto_aggregate = proto_register_protocol("Turbocell Aggregate Data", "Turbocell Aggregate Data", "turbocell_aggregate"); proto_register_field_array(proto_aggregate, aggregate_fields, array_length(aggregate_fields)); register_dissector("turbocell", dissect_turbocell, proto_turbocell); proto_register_field_array(proto_turbocell, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }
void proto_register_sdh(void) { static hf_register_info hf[] = { { &hf_sdh_a1, { "A1", "sdh.a1", FT_UINT24, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_sdh_a2, { "A2", "sdh.a2", FT_UINT24, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_sdh_j0, { "J0", "sdh.j0", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_sdh_b1, { "B1", "sdh.b1", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_sdh_e1, { "E1", "sdh.e1", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_sdh_f1, { "F1", "sdh.f1", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_sdh_d1, { "D1", "sdh.d1", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_sdh_d2, { "D2", "sdh.d2", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_sdh_d3, { "D3", "sdh.d3", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_sdh_au, { "AU", "sdh.au", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_sdh_b2, { "B2", "sdh.b2", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_sdh_k1, { "K1", "sdh.k1", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_sdh_k2, { "K2", "sdh.k2", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_sdh_d4, { "D4", "sdh.d4", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_sdh_d5, { "D5", "sdh.d5", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_sdh_d6, { "D6", "sdh.d6", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_sdh_d7, { "D7", "sdh.d7", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_sdh_d8, { "D8", "sdh.d8", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_sdh_d9, { "D9", "sdh.d9", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_sdh_d10, { "D10", "sdh.d10", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_sdh_d11, { "D11", "sdh.d11", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_sdh_d12, { "D12", "sdh.d12", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_sdh_s1, { "S1", "sdh.s1", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_sdh_m1, { "M1", "sdh.m1", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_sdh_e2, { "E2", "sdh.e2", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_sdh_j1, { "J1", "sdh.j1", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }} }; static gint *ett[] = { &ett_sdh }; module_t *sdh_module; proto_sdh = proto_register_protocol("SDH/SONET Protocol", "SDH", "sdh"); proto_register_field_array(proto_sdh, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); sdh_module = prefs_register_protocol(proto_sdh, NULL); prefs_register_enum_preference(sdh_module, "data.rate", "Data rate", "Data rate", &sdh_data_rate, data_rates, ENC_BIG_ENDIAN); register_dissector("sdh", dissect_sdh, proto_sdh); }
void proto_register_ppcap(void) { static hf_register_info hf[] = { { &hf_ppcap_length, { "Length", "ppcap.length", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL}}, { &hf_ppcap_payload_type, { "Payload Type" , "ppcap.payload_type", FT_STRING, BASE_NONE, NULL, 0x0 , NULL, HFILL}}, { &hf_ppcap_reserved, { "Reserved", "ppcap.reserved", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL}}, { &hf_ppcap_address_type, { "Address Type", "ppcap.address_type", FT_UINT16, BASE_DEC, VALS(address_type_values), 0x00 , NULL, HFILL}}, #if 0 { &hf_ppcap_source_address_type, { "Source Address Type", "ppcap.source_address_type", FT_UINT16, BASE_DEC, VALS(address_type_values), 0x00 , NULL, HFILL}}, #endif { &hf_ppcap_ssn, { "SSN", "ppcap.ssn", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL}}, { &hf_ppcap_spc, {"OPC", "ppcap.spc", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL}}, { &hf_ppcap_opc, { "OPC", "ppcap.opc", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL}}, { &hf_ppcap_source_ip_address1, { "Source IP Addresss", "ppcap.source_ip_address1", FT_IPv4, BASE_NONE, NULL, 0x00, NULL, HFILL}}, { &hf_ppcap_source_ip_address2, { "Source IP Address", "ppcap.source_ip_address2", FT_IPv6, BASE_NONE, NULL, 0x00, NULL, HFILL}}, { &hf_ppcap_destreserved, { "Reserved", "ppcap.destreserved", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL}}, #if 0 { &hf_ppcap_destination_address_type, { "Destination Address Type", "ppcap.destination_address_type", FT_UINT16, BASE_DEC, VALS(address_type_values), 0x00, NULL, HFILL}}, #endif { &hf_ppcap_ssn1, { "SSN", "ppcap.ssn1", FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL}}, { &hf_ppcap_spc1, { "DPC", "ppcap.spc1", FT_UINT24, BASE_DEC, NULL, 0x00, NULL, HFILL}}, { &hf_ppcap_dpc, { "DPC", "ppcap.dpc", FT_UINT32, BASE_DEC, NULL, 0x00, NULL, HFILL}}, { &hf_ppcap_destination_ip_address1, { "Destination IP Address", "ppcap.destination_ip_address1", FT_IPv4, BASE_NONE, NULL, 0x00, NULL, HFILL}}, { &hf_ppcap_destination_ip_address2, { "Destination IP Address", "ppcap.destination_ip_address2", FT_IPv6, BASE_NONE, NULL, 0x00, NULL, HFILL}}, { &hf_ppcap_source_nodeid, { "Source Node ID", "ppcap.source_nodeid", FT_STRING, BASE_NONE, NULL, 0x00, NULL, HFILL}}, { &hf_ppcap_destination_nodeid, { "Destination Node ID", "ppcap.destination_address_value", FT_STRING, BASE_NONE, NULL, 0x00, NULL, HFILL}}, { &hf_ppcap_info, { "Info", "ppcap.info", FT_STRING, BASE_NONE, NULL, 0x0000, NULL, HFILL}}, { &hf_ppcap_payload_data, { "Payload Data", "ppcap.payload_data", FT_BYTES, BASE_NONE, NULL, 0x0000, NULL, HFILL}}, }; static gint *ett[]= { &ett_ppcap, &ett_ppcap1, &ett_ppcap_new, }; proto_ppcap = proto_register_protocol("Proprietary PCAP", "PPCAP", "ppcap"); proto_register_field_array(proto_ppcap , hf , array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); register_dissector("ppcap", dissect_ppcap, proto_ppcap); }
void proto_register_dvb_eit(void) { static hf_register_info hf[] = { { &hf_dvb_eit_service_id, { "Service ID", "dvb_eit.sid", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_dvb_eit_reserved, { "Reserved", "dvb_eit.reserved", FT_UINT8, BASE_HEX, NULL, DVB_EIT_RESERVED_MASK, NULL, HFILL } }, { &hf_dvb_eit_version_number, { "Version Number", "dvb_eit.version", FT_UINT8, BASE_HEX, NULL, DVB_EIT_VERSION_NUMBER_MASK, NULL, HFILL } }, { &hf_dvb_eit_current_next_indicator, { "Current/Next Indicator", "dvb_eit.cur_next_ind", FT_UINT8, BASE_DEC, VALS(dvb_eit_cur_next_vals), DVB_EIT_CURRENT_NEXT_INDICATOR_MASK, NULL, HFILL } }, { &hf_dvb_eit_section_number, { "Section Number", "dvb_eit.sect_num", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_dvb_eit_last_section_number, { "Last Section Number", "dvb_eit.last_sect_num", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_dvb_eit_transport_stream_id, { "Transport Stream ID", "dvb_eit.tsid", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_dvb_eit_original_network_id, { "Original Network ID", "dvb_eit.original_nid", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_dvb_eit_segment_last_section_number, { "Segment Last Section Number", "dvb_eit.segment_last_sect_num", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_dvb_eit_last_table_id, { "Last Table ID", "dvb_eit.last_tid", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_dvb_eit_event_id, { "Event ID", "dvb_eit.evt.id", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_dvb_eit_start_time, { "UTC Start Time", "dvb_eit.evt.start_time", FT_ABSOLUTE_TIME, ABSOLUTE_TIME_UTC, NULL, 0, NULL, HFILL } }, { &hf_dvb_eit_duration, { "Duration", "dvb_eit.evt.duration", FT_UINT24, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_dvb_eit_running_status, { "Running Status", "dvb_eit.evt.running_status", FT_UINT16, BASE_HEX, VALS(dvb_eit_running_status_vals), DVB_EIT_RUNNING_STATUS_MASK, NULL, HFILL } }, { &hf_dvb_eit_free_ca_mode, { "Free CA Mode", "dvb_eit.evt.free_ca_mode", FT_UINT16, BASE_HEX, VALS(dvb_eit_free_ca_mode_vals), DVB_EIT_FREE_CA_MODE_MASK, NULL, HFILL } }, { &hf_dvb_eit_descriptors_loop_length, { "Descriptors Loop Length", "dvb_eit.evt.descr_loop_len", FT_UINT16, BASE_HEX, NULL, DVB_EIT_DESCRIPTORS_LOOP_LENGTH_MASK, NULL, HFILL } } }; static gint *ett[] = { &ett_dvb_eit, &ett_dvb_eit_event }; proto_dvb_eit = proto_register_protocol("DVB Event Information Table", "DVB EIT", "dvb_eit"); proto_register_field_array(proto_dvb_eit, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }
void proto_register_eapol(void) { static hf_register_info hf[] = { { &hf_eapol_version, { "Version", "eapol.version", FT_UINT8, BASE_DEC, VALS(eapol_version_vals), 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, { "Key Descriptor Type", "eapol.keydes.type", FT_UINT8, BASE_DEC, VALS(eapol_keydes_type_vals), 0x0, NULL, HFILL }}, { &hf_eapol_keydes_key_len, { "Key Length", "eapol.keydes.key_len", 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, NULL, HFILL }}, { &hf_eapol_keydes_key_index, { "Key Index", "eapol.keydes.key_index", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_eapol_keydes_key_index_type, { "Type", "eapol.keydes.key_index.type", FT_BOOLEAN, 8, TFS(&keytype_tfs), KEYDES_KEY_INDEX_TYPE_MASK , NULL, HFILL }}, { &hf_eapol_keydes_key_index_number, { "Number", "eapol.keydes.key_index.number", FT_UINT8, BASE_DEC, NULL, KEYDES_KEY_INDEX_NUMBER_MASK, NULL, 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_keydes_key_generated_locally, { "Key Generated Locally", "eapol.keydes.key.generated_locally", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_eapol_wpa_keydes_keyinfo, { "Key Information", "eapol.keydes.key_info", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_eapol_wpa_keydes_keyinfo_keydes_version, { "Key Descriptor Version", "eapol.keydes.key_info.keydes_version", FT_UINT16, BASE_DEC, VALS(keydes_version_vals), KEY_INFO_KEYDES_VERSION_MASK, NULL, HFILL }}, { &hf_eapol_wpa_keydes_keyinfo_key_type, { "Key Type", "eapol.keydes.key_info.key_type", FT_BOOLEAN, 16, TFS(&keyinfo_key_type_tfs), KEY_INFO_KEY_TYPE_MASK, NULL, 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, NULL, HFILL }}, { &hf_eapol_wpa_keydes_keyinfo_install, { "Install", "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", "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", "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", "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", "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", "eapol.keydes.key_info.request", FT_BOOLEAN, 16, TFS(&tfs_set_notset), KEY_INFO_REQUEST_MASK, NULL, HFILL }}, { &hf_eapol_wpa_keydes_keyinfo_encrypted_key_data, { "Encrypted Key Data", "eapol.keydes.key_info.encrypted_key_data", FT_BOOLEAN, 16, TFS(&tfs_set_notset), KEY_INFO_ENCRYPTED_KEY_DATA_MASK, NULL, HFILL }}, { &hf_eapol_wpa_keydes_nonce, { "WPA Key Nonce", "eapol.keydes.nonce", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_eapol_wpa_keydes_rsc, { "WPA Key RSC", "eapol.keydes.rsc", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_eapol_wpa_keydes_id, { "WPA Key ID", "eapol.keydes.id", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_eapol_wpa_keydes_mic, { "WPA Key MIC", "eapol.keydes.mic", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_eapol_wpa_keydes_data_len, { "WPA Key Data Length", "eapol.keydes.data_len", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_eapol_wpa_keydes_data, { "WPA Key Data", "eapol.keydes.data", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, 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)); }