/* Register the protocol with Wireshark */ void proto_register_cc2420(void) { module_t *module_cc2420; /* 802.15.4 Header */ static hf_register_info hf[] = { /* cc2420 specific phy header */ { &hf_cc2420_length, { "Length", "cc2420.length", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL } }, /* cc2420 specific FCS */ { &hf_cc2420_fcs, { "FCS", "cc2420.fcs", FT_NONE, FT_NONE, NULL, 0x0, "", HFILL } }, { &hf_cc2420_crc, { "Crc", "cc2420.crc", FT_BOOLEAN, 16, TFS(&cc2420_crc_string), 0x80, "", HFILL } }, /* cc2420 specific FCS fields containing rssi & lqi & crc_pass*/ { &hf_cc2420_lqi, { "Lqi", "cc2420.lqi", FT_UINT16, BASE_HEX, NULL, 0x7f, "", HFILL } }, { &hf_cc2420_rssi, { "Rssi", "cc2420.rssi", FT_UINT16, BASE_HEX, NULL, 0xff00, "", HFILL } } }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_cc2420 }; /* Register the protocol name and description */ proto_cc2420 = proto_register_protocol("CC2420 Frame Format", "CC2420", "cc2420"); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_cc2420, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); /* Register preferences module (See Section 2.6 for more on preferences) */ module_cc2420 = prefs_register_protocol(proto_cc2420, proto_reg_handoff_cc2420); /* subdissector code */ register_heur_dissector_list("cc2420", &heur_subdissector_list); /* Register prefs */ prefs_register_uint_preference(module_cc2420, "am_type", "Serial type ", "The type of Serial T2 messgaes which " "contain CC2420 " "packets as payload", 10, &global_serial_type_cc2420); prefs_register_uint_preference(module_cc2420, "channel", "Standard Channel ", "The channel on which " "the CC2420 radio" "receives", 10, &global_channel_cc2420); }
/*--- proto_register_s1ap -------------------------------------------*/ void proto_register_s1ap(void) { /* List of fields */ static hf_register_info hf[] = { { &hf_s1ap_transportLayerAddressIPv4, { "transportLayerAddress(IPv4)", "s1ap.transportLayerAddressIPv4", FT_IPv4, BASE_NONE, NULL, 0, NULL, HFILL }}, { &hf_s1ap_transportLayerAddressIPv6, { "transportLayerAddress(IPv6)", "s1ap.transportLayerAddressIPv6", FT_IPv6, BASE_NONE, NULL, 0, NULL, HFILL }}, #include "packet-s1ap-hfarr.c" }; /* List of subtrees */ static gint *ett[] = { &ett_s1ap, &ett_s1ap_TransportLayerAddress, &ett_s1ap_ToTargetTransparentContainer, &ett_s1ap_ToSourceTransparentContainer, &ett_s1ap_RRCContainer, &ett_s1ap_UERadioCapability, &ett_s1ap_RIMInformation, #include "packet-s1ap-ettarr.c" }; module_t *s1ap_module; /* Register protocol */ proto_s1ap = proto_register_protocol(PNAME, PSNAME, PFNAME); /* Register fields and subtrees */ proto_register_field_array(proto_s1ap, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); /* Register dissector */ register_dissector("s1ap", dissect_s1ap, proto_s1ap); /* Register dissector tables */ s1ap_ies_dissector_table = register_dissector_table("s1ap.ies", "S1AP-PROTOCOL-IES", FT_UINT32, BASE_DEC); s1ap_ies_p1_dissector_table = register_dissector_table("s1ap.ies.pair.first", "S1AP-PROTOCOL-IES-PAIR FirstValue", FT_UINT32, BASE_DEC); s1ap_ies_p2_dissector_table = register_dissector_table("s1ap.ies.pair.second", "S1AP-PROTOCOL-IES-PAIR SecondValue", FT_UINT32, BASE_DEC); s1ap_extension_dissector_table = register_dissector_table("s1ap.extension", "S1AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); s1ap_proc_imsg_dissector_table = register_dissector_table("s1ap.proc.imsg", "S1AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC); s1ap_proc_sout_dissector_table = register_dissector_table("s1ap.proc.sout", "S1AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC); s1ap_proc_uout_dissector_table = register_dissector_table("s1ap.proc.uout", "S1AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC); /* Register configuration options for ports */ s1ap_module = prefs_register_protocol(proto_s1ap, proto_reg_handoff_s1ap); prefs_register_uint_preference(s1ap_module, "sctp.port", "S1AP SCTP Port", "Set the SCTP port for S1AP messages", 10, &gbl_s1apSctpPort); prefs_register_bool_preference(s1ap_module, "dissect_container", "Dissect TransparentContainer", "Dissect TransparentContainers that are opaque to S1AP", &g_s1ap_dissect_container); }
/* Register Jmirror dissector with Wireshark */ void proto_register_jmirror(void) { module_t *jmirror_module = NULL; /* Used by the Expression dialog and filter box */ static hf_register_info jmirror_hf[] = { { &hf_jmirror_mid, { "Jmirror Identifier", "jmirror.mid", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, "Unique identifier of the mirrored session", HFILL } }, { &hf_jmirror_sid, { "Session Identifier", "jmirror.sid", FT_UINT32, BASE_HEX_DEC, NULL, 0x0, "Unique identifier of the user session", HFILL } } }; static gint *jmirror_ett[] = { &ett_jmirror }; /* Register the Jmirror protocol with Wireshark */ proto_jmirror = proto_register_protocol("Juniper Packet Mirror", "Jmirror", "jmirror"); /* Register the Jmirror preferences with Wireshark */ jmirror_module = prefs_register_protocol(proto_jmirror, proto_reg_handoff_jmirror); /* Allow the user to set the UDP port for the decode under the Edit -> Preferences menu */ prefs_register_uint_preference(jmirror_module, "udp.port", "JMirror UDP Port", "Set the port for JMirror Port (if other than the default of 30030)", 10, &global_jmirror_udp_port); /* Register the Jmirror subfields for filters */ proto_register_field_array(proto_jmirror, jmirror_hf, array_length(jmirror_hf)); proto_register_subtree_array(jmirror_ett, array_length(jmirror_ett)); }
void proto_register_kismet(void) { static hf_register_info hf[] = { {&hf_kismet_response, {"Response", "kismet.response", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "TRUE if kismet response", HFILL}}, {&hf_kismet_request, {"Request", "kismet.request", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "TRUE if kismet request", HFILL}} }; static gint *ett[] = { &ett_kismet, &ett_kismet_reqresp, }; module_t *kismet_module; proto_kismet = proto_register_protocol("Kismet Client/Server Protocol", "Kismet", "kismet"); proto_register_field_array(proto_kismet, hf, array_length (hf)); proto_register_subtree_array(ett, array_length (ett)); /* Register our configuration options for Kismet, particularly our port */ kismet_module = prefs_register_protocol(proto_kismet, proto_reg_handoff_kismet); prefs_register_uint_preference(kismet_module, "tcp.port", "Kismet Server TCP Port", "Set the port for Kismet Client/Server messages (if other" " than the default of 2501)", 10, &global_kismet_tcp_port); }
void proto_register_hp_erm(void) { void proto_reg_handoff_hp_erm(void); static hf_register_info hf[] = { { &hf_hp_erm_unknown, { "Unknown", "hp_erm.unknown", FT_BYTES, BASE_NONE, NULL, 0x00, NULL, HFILL } }, }; static gint *ett[] = { &ett_hp_erm, }; module_t *hp_erm_module; proto_hp_erm = proto_register_protocol(PROTO_LONG_NAME, PROTO_SHORT_NAME, "hp_erm"); hp_erm_module = prefs_register_protocol(proto_hp_erm, proto_reg_handoff_hp_erm); prefs_register_uint_preference(hp_erm_module, "udp.port", "HP_ERM UDP Port", "Set the UDP port (source or destination) used for HP" " encapsulated remote mirroring frames;\n" "0 (default) means that the HP_ERM dissector is not active", 10, &global_hp_erm_udp_port); proto_register_field_array(proto_hp_erm, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }
/*--- proto_register_disp -------------------------------------------*/ void proto_register_disp(void) { /* List of fields */ static hf_register_info hf[] = { #include "packet-disp-hfarr.c" }; /* List of subtrees */ static gint *ett[] = { &ett_disp, #include "packet-disp-ettarr.c" }; module_t *disp_module; /* Register protocol */ proto_disp = proto_register_protocol(PNAME, PSNAME, PFNAME); register_dissector("disp", dissect_disp, proto_disp); /* Register fields and subtrees */ proto_register_field_array(proto_disp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); /* Register our configuration options for DISP, particularly our port */ disp_module = prefs_register_protocol_subtree("OSI/X.500", proto_disp, prefs_register_disp); prefs_register_uint_preference(disp_module, "tcp.port", "DISP TCP Port", "Set the port for DISP operations (if other" " than the default of 102)", 10, &global_disp_tcp_port); }
/*--- proto_register_p7 -------------------------------------------*/ void proto_register_p7(void) { /* List of fields */ static hf_register_info hf[] = { #include "packet-p7-hfarr.c" }; /* List of subtrees */ static gint *ett[] = { &ett_p7, #include "packet-p7-ettarr.c" }; module_t *p7_module; /* Register protocol */ proto_p7 = proto_register_protocol(PNAME, PSNAME, PFNAME); /* Register fields and subtrees */ proto_register_field_array(proto_p7, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); /* Register our configuration options for P7, particularly our port */ p7_module = prefs_register_protocol_subtree("OSI/X.400", proto_p7, prefs_register_p7); prefs_register_uint_preference(p7_module, "tcp.port", "P7 TCP Port", "Set the port for P7 operations (if other" " than the default of 102)", 10, &global_p7_tcp_port); }
void proto_register_pcli(void) { static hf_register_info hf[] = { { &hf_pcli_cccid, { "CCCID", "pcli.cccid", FT_UINT32, BASE_DEC, NULL, 0x0, "Call Content Connection Identifier", HFILL }}, }; static gint *ett[] = { &ett_pcli, }; module_t *pcli_module; proto_pcli = proto_register_protocol("Packet Cable Lawful Intercept", "PCLI","pcli"); proto_register_field_array(proto_pcli,hf,array_length(hf)); proto_register_subtree_array(ett,array_length(ett)); pcli_module = prefs_register_protocol(proto_pcli, proto_reg_handoff_pcli); prefs_register_uint_preference(pcli_module, "udp_port", "PCLI UDP Port", "The UDP port on which " "Packet Cable Lawful Intercept " "packets will be sent", 10,&global_udp_port_pcli); }
/* Register the protocol with Wireshark */ void proto_register_moldudp(void) { module_t *moldudp_module; /* Setup list of header fields */ static hf_register_info hf[] = { { &hf_moldudp_session, { "Session", "moldudp.session", FT_STRING, BASE_NONE, NULL, 0, "The session to which this packet belongs.", HFILL }}, { &hf_moldudp_sequence, { "Sequence", "moldudp.sequence", FT_UINT32, BASE_DEC, NULL, 0, "The sequence number of the first message in this packet.", HFILL }}, { &hf_moldudp_count, { "Count", "moldudp.count", FT_UINT16, BASE_DEC, NULL, 0, "The number of messages contained in this packet.", HFILL }}, { &hf_moldudp_msgblk, { "Message Block", "moldudp.msgblock", FT_NONE, BASE_NONE, NULL, 0, "A message.", HFILL }}, { &hf_moldudp_msglen, { "Length", "moldudp.msglen", FT_UINT16, BASE_DEC, NULL, 0, "The length of this message.", HFILL }}, { &hf_moldudp_msgseq, { "Sequence", "moldudp.msgseq", FT_UINT32, BASE_DEC, NULL, 0, "The sequence number of this message.", HFILL }}, { &hf_moldudp_msgdata, { "Payload", "moldudp.msgdata", FT_BYTES, BASE_NONE, NULL, 0, "The payload data of this message.", HFILL }} }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_moldudp, &ett_moldudp_msgblk }; /* Register the protocol name and description */ proto_moldudp = proto_register_protocol("MoldUDP", "MoldUDP", "moldudp"); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_moldudp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); /* Register preferences module */ moldudp_module = prefs_register_protocol(proto_moldudp, proto_reg_handoff_moldudp); /* Register a sample port preference */ prefs_register_uint_preference(moldudp_module, "udp.port", "MoldUDP UDP Port", "MoldUDP UDP port to capture on.", 10, &pf_moldudp_port); }
void proto_register_osi(void) { module_t *osi_module; /* There's no "OSI" protocol *per se*, but we do register a dissector table so various protocols running at the network layer can register themselves. all protocols that require inclusion of the NLPID should register here */ osinl_incl_subdissector_table = register_dissector_table("osinl.incl", "OSI incl NLPID", FT_UINT8, BASE_HEX); /* This dissector table is for those protocols whose PDUs * aren't* defined to begin with an NLPID. * (typically non OSI protocols like IP,IPv6,PPP */ osinl_excl_subdissector_table = register_dissector_table("osinl.excl", "OSI excl NLPID", FT_UINT8, BASE_HEX); proto_osi = proto_register_protocol("OSI", "OSI", "osi"); /* Preferences how OSI protocols should be dissected */ osi_module = prefs_register_protocol(proto_osi, proto_reg_handoff_osi); prefs_register_uint_preference(osi_module, "tpkt_port", "TCP port for OSI over TPKT", "TCP port for OSI over TPKT", 10, &global_tcp_port_osi_over_tpkt); prefs_register_bool_preference(osi_module, "tpkt_reassemble", "Reassemble segmented TPKT datagrams", "Whether segmented TPKT datagrams should be reassembled", &tpkt_desegment); }
void proto_register_tte(void) { module_t *tte_module; static hf_register_info hf[] = { { &hf_tte_dst_cf, { "Constant Field", "tte.cf", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_tte_ctid, { "Critical Traffic Identifier", "tte.ctid", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } } }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_tte, &ett_tte_macdest, &ett_tte_macsrc }; /* Register the protocol name and description */ proto_tte = proto_register_protocol("TTEthernet", "TTE", "tte"); /* Required function calls to register header fields and subtrees used */ proto_register_field_array(proto_tte, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); /* Register preferences module */ tte_module = prefs_register_protocol(proto_tte, NULL); /* Register preferences */ prefs_register_uint_preference(tte_module, "ct_mask_value", "CT Mask (in hex)", "Critical Traffic Mask (base hex)", 16, &tte_pref_ct_mask); prefs_register_uint_preference(tte_module, "ct_marker_value", "CT Marker (in hex)", "Critical Traffic Marker (base hex)", 16, &tte_pref_ct_marker); }
void proto_register_tcpencap(void) { static hf_register_info hf[] = { { &hf_tcpencap_unknown, { "Unknown trailer", "tcpencap.unknown", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_tcpencap_zero, { "All zero", "tcpencap.zero", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_tcpencap_seq, { "Sequence number", "tcpencap.seq", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_tcpencap_esp_zero, { "ESP zero", "tcpencap.espzero", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_tcpencap_ike_direction, { "ISAKMP traffic direction", "tcpencap.ikedirection", FT_UINT16, BASE_HEX, VALS(tcpencap_ikedir_vals), 0x0, NULL, HFILL }}, { &hf_tcpencap_magic, { "Magic number", "tcpencap.magic", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_tcpencap_proto, { "Protocol", "tcpencap.proto", FT_UINT8, BASE_HEX, VALS(tcpencap_proto_vals), 0x0, NULL, HFILL }}, { &hf_tcpencap_magic2, { "Magic 2", "tcpencap.magic2", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, }; static gint *ett[] = { &ett_tcpencap, &ett_tcpencap_unknown, }; module_t *tcpencap_module; void proto_reg_handoff_tcpencap(void); proto_tcpencap = proto_register_protocol( "TCP Encapsulation of IPsec Packets", "TCPENCAP", "tcpencap"); proto_register_field_array(proto_tcpencap, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); tcpencap_module = prefs_register_protocol(proto_tcpencap, proto_reg_handoff_tcpencap); prefs_register_uint_preference(tcpencap_module, "tcp.port", "IPSEC TCP Port", "Set the port for IPSEC/ISAKMP messages" "If other than the default of 10000)", 10, &global_tcpencap_tcp_port); }
void proto_register_uhd(void) { static hf_register_info hf[] = { { &hf_uhd_version, { "VERSION", "uhd.version", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_uhd_id, { "ID", "uhd.id", FT_UINT32, BASE_HEX, VALS(uhd_ids), 0, NULL, HFILL } }, { &hf_uhd_seq, { "SEQ", "uhd.seq", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_uhd_ip_addr, { "IP ADDR", "uhd.ip_addr", FT_IPv4, BASE_NONE, NULL, 0x0,"", HFILL } }, { &hf_uhd_i2c_addr, { "I2C ADDR", "uhd.i2c_addr", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_uhd_i2c_bytes, { "I2C BYTES", "uhd.i2c_bytes", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_uhd_i2c_data, { "I2C DATA", "uhd.i2c_data", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_uhd_spi_dev, { "SPI DEV", "uhd.spi_dev", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_uhd_spi_data, { "SPI DATA", "uhd.spi_data", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_uhd_spi_miso_edge, { "SPI MISO EDGE", "uhd.spi_miso_edge", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_uhd_spi_mosi_edge, { "SPI MOSI EDGE", "uhd.spi_mosi_edge", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_uhd_spi_num_bits, { "SPI NUM BITS", "uhd.spi_num_bits", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_uhd_spi_readback, { "SPI READBACK", "uhd.spi_readback", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_uhd_reg_addr, { "REG ADDR", "uhd.reg_addr", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_uhd_reg_data, { "REG DATA", "uhd.reg_data", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_uhd_reg_action, { "REG ACTION", "uhd.reg_action", FT_UINT8, BASE_HEX, VALS(uhd_reg_actions), 0, NULL, HFILL } }, { &hf_uhd_echo_len, { "ECHO LEN", "uhd.echo_len", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL } }, }; static gint *ett[] = { &ett_uhd }; module_t *uhd_module; proto_uhd = proto_register_protocol("UHD", "UHD", "uhd"); proto_register_field_array(proto_uhd, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); uhd_module = prefs_register_protocol(proto_uhd, proto_reg_handoff_uhd); prefs_register_uint_preference(uhd_module, "dissector_port", "Dissector UDP port", "The UDP port used by this dissector", 10, &dissector_port_pref); }
void proto_register_cwids(void) { static hf_register_info hf[] = { { &hf_cwids_version, { "Capture Version", "cwids.version", FT_UINT16, BASE_DEC, NULL, 0x0, "Version or format of record", HFILL }}, { &hf_cwids_unknown1, { "Unknown1", "cwids.unknown1", FT_BYTES, BASE_NONE, NULL, 0x0, "1st Unknown block - timestamp?", HFILL }}, { &hf_cwids_channel, { "Channel", "cwids.channel", FT_UINT8, BASE_DEC, NULL, 0x0, "Channel for this capture", HFILL }}, { &hf_cwids_unknown2, { "Unknown2", "cwids.unknown2", FT_BYTES, BASE_NONE, NULL, 0x0, "2nd Unknown block", HFILL }}, { &hf_cwids_reallength, { "Original length", "cwids.reallen", FT_UINT16, BASE_DEC, NULL, 0x0, "Original num bytes in frame", HFILL }}, { &hf_cwids_capturelen, { "Capture length", "cwids.caplen", FT_UINT16, BASE_DEC, NULL, 0x0, "Captured bytes in record", HFILL }}, { &hf_cwids_unknown3, { "Unknown3", "cwids.unknown3", FT_BYTES, BASE_NONE, NULL, 0x0, "3rd Unknown block", HFILL }}, }; static gint *ett[] = { &ett_cwids, }; static ei_register_info ei[] = { { &ie_ieee80211_subpacket, { "cwids.ieee80211_malformed", PI_MALFORMED, PI_ERROR, "Malformed or short IEEE80211 subpacket", EXPFILL }}, }; module_t *cwids_module; expert_module_t* expert_cwids; proto_cwids = proto_register_protocol("Cisco Wireless IDS Captures", "CWIDS", "cwids"); proto_register_field_array(proto_cwids, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); expert_cwids = expert_register_protocol(proto_cwids); expert_register_field_array(expert_cwids, ei, array_length(ei)); cwids_module = prefs_register_protocol(proto_cwids, proto_reg_handoff_cwids); prefs_register_uint_preference(cwids_module, "udp.port", "CWIDS port", "Set the destination UDP port Cisco wireless IDS messages", 10, &global_udp_port); }
void proto_register_m2pa(void) { static hf_register_info hf[] = { { &hf_version, { "Version", "m2pa.version", FT_UINT8, BASE_DEC, VALS(protocol_version_values), 0x0, NULL, HFILL} }, { &hf_spare, { "Spare", "m2pa.spare", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL} }, { &hf_v2_type, { "Message Type", "m2pa.type_v2", FT_UINT16, BASE_HEX, VALS(v2_message_type_values), 0x0, NULL, HFILL} }, { &hf_v8_type, { "Message Type", "m2pa.type_v8", FT_UINT8, BASE_DEC, VALS(v8_message_type_values), 0x0, NULL, HFILL} }, { &hf_type, { "Message Type", "m2pa.type", FT_UINT8, BASE_DEC, VALS(message_type_values), 0x0, NULL, HFILL} }, { &hf_class, { "Message Class", "m2pa.class", FT_UINT8, BASE_DEC, VALS(message_class_values), 0x0, NULL, HFILL} }, { &hf_length, { "Message length", "m2pa.length", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL} }, { &hf_unused, { "Unused", "m2pa.unused", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL} }, { &hf_bsn, { "BSN", "m2pa.bsn", FT_UINT24, BASE_DEC, NULL, 0x0, NULL, HFILL} }, { &hf_fsn, { "FSN", "m2pa.fsn", FT_UINT24, BASE_DEC, NULL, 0x0, NULL, HFILL} }, { &hf_v2_li_spare, { "Spare", "m2pa.li_spare_v2", FT_UINT8, BASE_DEC, NULL, V2_LI_SPARE_MASK, NULL, HFILL} }, { &hf_v8_li_spare, { "Spare", "m2pa.li_spare_v8", FT_UINT8, BASE_HEX, NULL, V8_LI_SPARE_MASK, NULL, HFILL} }, { &hf_pri_spare, { "Spare", "m2pa.priority_spare", FT_UINT8, BASE_HEX, NULL, SPARE_MASK, NULL, HFILL} }, { &hf_v2_li_prio, { "Priority", "m2pa.li_priority_v2", FT_UINT8, BASE_DEC, NULL, V2_LI_PRIORITY_MASK, NULL, HFILL} }, { &hf_v8_li_prio, { "Priority", "m2pa.li_priority_v8", FT_UINT8, BASE_HEX, NULL, V8_LI_PRIORITY_MASK, NULL, HFILL} }, { &hf_pri_prio, { "Priority", "m2pa.priority", FT_UINT8, BASE_HEX, NULL, PRIORITY_MASK, NULL, HFILL} }, { &hf_v2_status, { "Link Status", "m2pa.status_v2", FT_UINT32, BASE_DEC, VALS(v2_link_status_values), 0x0, NULL, HFILL} }, { &hf_v8_status, { "Link Status", "m2pa.status_v8", FT_UINT32, BASE_DEC, VALS(v8_link_status_values), 0x0, NULL, HFILL} }, { &hf_status, { "Link Status", "m2pa.status", FT_UINT32, BASE_DEC, VALS(link_status_values), 0x0, NULL, HFILL} }, { &hf_filler, { "Filler", "m2pa.filler", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL} }, { &hf_unknown_data, { "Unknown Data", "m2pa.unknown_data", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL} }, { &hf_undecode_data,{ "Undecoded data", "m2pa.undecoded_data", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL} } }; static gint *ett[] = { &ett_m2pa, &ett_m2pa_li }; static const enum_val_t m2pa_version_options[] = { { "draft-2", "Internet Draft version 2", M2PA_V02 }, { "draft-8", "Internet Draft version 8", M2PA_V08 }, { "RFC4165", "RFC 4165", M2PA_RFC4165 }, { NULL, NULL, 0 } }; proto_m2pa = proto_register_protocol("MTP2 Peer Adaptation Layer", "M2PA", "m2pa"); proto_register_field_array(proto_m2pa, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); /* Allow other dissectors to find this one by name. */ register_dissector("m2pa", dissect_m2pa, proto_m2pa); m2pa_module = prefs_register_protocol(proto_m2pa, proto_reg_handoff_m2pa); prefs_register_enum_preference(m2pa_module, "version", "M2PA version", "Version used by Wireshark", &m2pa_version, m2pa_version_options, FALSE); prefs_register_uint_preference(m2pa_module, "port", "M2PA SCTP Port", "Set the port for M2PA messages (Default of 3565)", 10, &global_sctp_port); }
void proto_register_op_uavtalk(void) { module_t *op_uavtalk_module; static hf_register_info hf[] = { { &hf_op_uavtalk_sync, { "Sync Byte", "uavtalk.sync", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_op_uavtalk_version, { "Version", "uavtalk.ver", FT_UINT8, BASE_DEC, NULL, 0xf8, NULL, HFILL } }, { &hf_op_uavtalk_type, { "Type", "uavtalk.type", FT_UINT8, BASE_HEX, VALS(uavtalk_packet_types), 0x07, NULL, HFILL } }, { &hf_op_uavtalk_len, { "Length", "uavtalk.len", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_op_uavtalk_objid, { "ObjID", "uavtalk.objid", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_op_uavtalk_crc8, { "Crc8", "uavtalk.crc8", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_op_uavtalk }; proto_op_uavtalk = proto_register_protocol("OpenPilot UAVTalk Protocol", "UAVTALK", "uavtalk"); /* Allow subdissectors for each objid to bind for decoding */ uavtalk_subdissector_table = register_dissector_table("uavtalk.objid", "UAVObject ID", FT_UINT32, BASE_HEX); proto_register_subtree_array(ett, array_length(ett)); proto_register_field_array(proto_op_uavtalk, hf, array_length(hf)); op_uavtalk_module = prefs_register_protocol(proto_op_uavtalk, proto_reg_handoff_op_uavtalk); prefs_register_uint_preference(op_uavtalk_module, "udp.port", "UAVTALK UDP port", "UAVTALK port (default 9000)", 10, &global_op_uavtalk_port); }
/*--- proto_register_x2ap -------------------------------------------*/ void proto_register_x2ap(void) { /* List of fields */ static hf_register_info hf[] = { { &hf_x2ap_transportLayerAddressIPv4, { "transportLayerAddress(IPv4)", "x2ap.transportLayerAddressIPv4", FT_IPv4, BASE_NONE, NULL, 0, NULL, HFILL }}, { &hf_x2ap_transportLayerAddressIPv6, { "transportLayerAddress(IPv6)", "x2ap.transportLayerAddressIPv6", FT_IPv6, BASE_NONE, NULL, 0, NULL, HFILL }}, #include "packet-x2ap-hfarr.c" }; /* List of subtrees */ static gint *ett[] = { &ett_x2ap, &ett_x2ap_TransportLayerAddress, #include "packet-x2ap-ettarr.c" }; module_t *x2ap_module; /* Register protocol */ proto_x2ap = proto_register_protocol(PNAME, PSNAME, PFNAME); /* Register fields and subtrees */ proto_register_field_array(proto_x2ap, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); /* Register dissector */ register_dissector("x2ap", dissect_x2ap, proto_x2ap); /* Register dissector tables */ x2ap_ies_dissector_table = register_dissector_table("x2ap.ies", "X2AP-PROTOCOL-IES", FT_UINT32, BASE_DEC); x2ap_extension_dissector_table = register_dissector_table("x2ap.extension", "X2AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); x2ap_proc_imsg_dissector_table = register_dissector_table("x2ap.proc.imsg", "X2AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC); x2ap_proc_sout_dissector_table = register_dissector_table("x2ap.proc.sout", "X2AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC); x2ap_proc_uout_dissector_table = register_dissector_table("x2ap.proc.uout", "X2AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC); /* Register configuration options for ports */ x2ap_module = prefs_register_protocol(proto_x2ap, proto_reg_handoff_x2ap); prefs_register_uint_preference(x2ap_module, "sctp.port", "X2AP SCTP Port", "Set the SCTP port for X2AP messages", 10, &gbl_x2apSctpPort); }
void proto_register_lge_monitor(void) { module_t *lge_monitor_module; /* Setup list of header fields */ static hf_register_info hf[] = { { &hf_lge_monitor_dir, { "Direction", "lge_monitor.dir", FT_UINT32, BASE_DEC, VALS(lge_monitor_dir_vals), 0x0, NULL, HFILL } }, { &hf_lge_monitor_prot, { "Protocol Identifier", "lge_monitor.prot", FT_UINT32, BASE_DEC, VALS(lge_monitor_prot_vals), 0x0, NULL, HFILL } }, { &hf_lge_monitor_length, { "Payload Length", "lge_monitor.length", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_lge_monitor, }; /* Register the protocol name and description */ proto_lge_monitor = proto_register_protocol("LGE Monitor","LGE_Monitor", "lge_monitor"); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_lge_monitor, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); /* Register a configuration option for port */ lge_monitor_module = prefs_register_protocol(proto_lge_monitor, proto_reg_handoff_lge_monitor); prefs_register_uint_preference(lge_monitor_module, "udp.port", "LGE Monitor UDP Port", "Set UDP port for LGE Monitor messages", 10, &LGEMonitorUDPPort); }
/*--- proto_register_h501 ----------------------------------------------*/ void proto_register_h501(void) { module_t *h501_module; /* List of fields */ static hf_register_info hf[] = { #include "packet-h501-hfarr.c" }; /* List of subtrees */ static gint *ett[] = { &ett_h501, #include "packet-h501-ettarr.c" }; /* Register protocol */ proto_h501 = proto_register_protocol(PNAME, PSNAME, PFNAME); /* Register fields and subtrees */ proto_register_field_array(proto_h501, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); new_register_dissector(PFNAME, dissect_h501_pdu, proto_h501); h501_module = prefs_register_protocol(proto_h501, proto_reg_handoff_h501); prefs_register_uint_preference(h501_module, "udp.port", "UDP port", "Port to be decoded as h501", 10, &h501_udp_port); prefs_register_uint_preference(h501_module, "tcp.port", "TCP port", "Port to be decoded as h501", 10, &h501_tcp_port); prefs_register_bool_preference(h501_module, "desegment", "Desegment H.501 over TCP", "Desegment H.501 messages that span more TCP segments", &h501_desegment_tcp); }
/* Register the protocol with Wireshark */ void proto_register_llt(void) { module_t *llt_module; static hf_register_info hf[] = { { &hf_llt_cluster_num, { "Cluster number", "llt.cluster_num", FT_UINT8, BASE_DEC, NULL, 0, "Cluster number that this node belongs to", HFILL } }, { &hf_llt_message_type, { "Message type", "llt.message_type", FT_UINT8, BASE_HEX, VALS(message_type_vs), 0, "Type of LLT message contained in this frame", HFILL } }, { &hf_llt_node_id, { "Node ID", "llt.node_id", FT_UINT8, BASE_DEC, NULL, 0, "Number identifying this node within the cluster", HFILL } }, { &hf_llt_sequence_num, { "Sequence number", "llt.sequence_num", FT_UINT32, BASE_DEC, NULL, 0, "Sequence number of this frame", HFILL } }, { &hf_llt_message_time, { "Message time", "llt.message_time", FT_UINT32, BASE_DEC, NULL, 0, "Number of ticks since this node was last rebooted", HFILL } } }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_llt, }; /* Register the protocol name and description */ proto_llt = proto_register_protocol("Veritas Low Latency Transport (LLT)", "LLT", "llt"); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_llt, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); /* Register preferences module */ llt_module = prefs_register_protocol(proto_llt, proto_reg_handoff_llt); /* Register our preferences */ prefs_register_uint_preference(llt_module, "alternate_ethertype", "Alternate ethertype value (in hex)", "Dissect this ethertype as LLT traffic in addition to the default, 0xCAFE.", 16, &preference_alternate_ethertype); /* A base-16 (hexadecimal) value */ }
/*--- proto_register_dop -------------------------------------------*/ void proto_register_dop(void) { /* List of fields */ static hf_register_info hf[] = { #include "packet-dop-hfarr.c" }; /* List of subtrees */ static gint *ett[] = { &ett_dop, &ett_dop_unknown, #include "packet-dop-ettarr.c" }; static ei_register_info ei[] = { { &ei_dop_unknown_binding_parameter, { "dop.unknown_binding_parameter", PI_UNDECODED, PI_WARN, "Unknown binding-parameter", EXPFILL }}, }; expert_module_t* expert_dop; module_t *dop_module; /* Register protocol */ proto_dop = proto_register_protocol(PNAME, PSNAME, PFNAME); new_register_dissector("dop", dissect_dop, proto_dop); dop_dissector_table = register_dissector_table("dop.oid", "DOP OID Dissectors", FT_STRING, BASE_NONE); /* Register fields and subtrees */ proto_register_field_array(proto_dop, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); expert_dop = expert_register_protocol(proto_dop); expert_register_field_array(expert_dop, ei, array_length(ei)); /* Register our configuration options for DOP, particularly our port */ dop_module = prefs_register_protocol_subtree("OSI/X.500", proto_dop, prefs_register_dop); prefs_register_uint_preference(dop_module, "tcp.port", "DOP TCP Port", "Set the port for DOP operations (if other" " than the default of 102)", 10, &global_dop_tcp_port); }
/* Register preferences */ static void alc_prefs_register(struct _alc_prefs *alc_prefs, module_t *module) { prefs_register_bool_preference(module, "default.udp_port.enabled", "Use default UDP port", "Whether that payload of UDP packets with a specific destination port should be automatically dissected as ALC packets", &alc_prefs->use_default_udp_port); prefs_register_uint_preference(module, "default.udp_port", "Default UDP destination port", "Specifies the UDP destination port for automatic dissection of ALC packets", 10, &alc_prefs->default_udp_port); lct_prefs_register(&alc_prefs->lct, module); fec_prefs_register(&alc_prefs->fec, module); }
/*--- proto_register_dsp -------------------------------------------*/ void proto_register_dsp(void) { /* List of fields */ static hf_register_info hf[] = { #include "packet-dsp-hfarr.c" }; /* List of subtrees */ static gint *ett[] = { &ett_dsp, #include "packet-dsp-ettarr.c" }; static ei_register_info ei[] = { { &ei_dsp_unsupported_opcode, { "dsp.unsupported_opcode", PI_UNDECODED, PI_WARN, "Unsupported DSP opcode", EXPFILL }}, { &ei_dsp_unsupported_errcode, { "dsp.unsupported_errcode", PI_UNDECODED, PI_WARN, "Unsupported DSP errcode", EXPFILL }}, { &ei_dsp_unsupported_pdu, { "dsp.unsupported_pdu", PI_UNDECODED, PI_WARN, "Unsupported DSP PDU", EXPFILL }}, { &ei_dsp_zero_pdu, { "dsp.zero_pdu", PI_PROTOCOL, PI_ERROR, "Internal error, zero-byte DSP PDU", EXPFILL }}, }; module_t *dsp_module; expert_module_t* expert_dsp; /* Register protocol */ proto_dsp = proto_register_protocol(PNAME, PSNAME, PFNAME); new_register_dissector("dsp", dissect_dsp, proto_dsp); /* Register fields and subtrees */ proto_register_field_array(proto_dsp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); expert_dsp = expert_register_protocol(proto_dsp); expert_register_field_array(expert_dsp, ei, array_length(ei)); /* Register our configuration options for DSP, particularly our port */ dsp_module = prefs_register_protocol_subtree("OSI/X.500", proto_dsp, prefs_register_dsp); prefs_register_uint_preference(dsp_module, "tcp.port", "DSP TCP Port", "Set the port for DSP operations (if other" " than the default of 102)", 10, &global_dsp_tcp_port); }
/* Register the protocol with Wireshark */ void proto_register_newmail(void) { /* Setup list of header fields See Section 1.6.1 for details*/ static hf_register_info hf[] = { { &hf_newmail_payload, { "Notification payload", "newmail.notification_payload", FT_BYTES, BASE_NONE, NULL, 0x0, "Payload requested by client in the MAPI register push notification packet", HFILL } }, }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_newmail, }; module_t *newmail_module; /* Register the protocol name and description */ proto_newmail = proto_register_protocol("Microsoft Exchange New Mail Notification", "NEWMAIL", "newmail"); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_newmail, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); /* Register the dissector without a port yet */ register_dissector("newmail", dissect_newmail, proto_newmail); /* Register preferences module */ newmail_module = prefs_register_protocol(proto_newmail, proto_reg_handoff_newmail); prefs_register_uint_preference(newmail_module, "default_port", "Default UDP port (optional)", "Always dissect this port's traffic as newmail notifications. Additional ports will be dynamically registered as they are seen in MAPI register push notification packets.", 10, &preference_default_port); }
void proto_register_atmtcp(void) { module_t *atmtcp_module; static hf_register_info hf[] = { { &hf_atmtcp_vpi, { "VPI", "atmtcp.vpi", FT_UINT16, BASE_DEC, NULL, 0x0, "Virtual Path Identifier", HFILL } }, { &hf_atmtcp_vci, { "VCI", "atmtcp.vci", FT_UINT16, BASE_DEC, NULL, 0x0, "Virtual Channel Identifier", HFILL } }, { &hf_atmtcp_length, { "Length", "atmtcp.length", FT_UINT32, BASE_DEC, NULL, 0x0, "length of data", HFILL } } }; static gint *ett[] = { &ett_atmtcp }; proto_atmtcp = proto_register_protocol("ATM over TCP", "ATMTCP", "atmtcp"); proto_register_field_array(proto_atmtcp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); atmtcp_module = prefs_register_protocol(proto_atmtcp, proto_reg_handoff_atmtcp); prefs_register_uint_preference(atmtcp_module, "tcp.port", "ATMTCP TCP Port", "ATMTCP TCP port if other than the default", 10, &global_atmtcp_tcp_port); }
/* Register the protocol with Wireshark */ void proto_register_t2sf(void) { module_t *t2sf_module; /* TinyOs2 Serial Active Message Header */ static hf_register_info hf[] = { { &hf_t2sf_length, { "Length", "t2sf.length", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL } }, { &hf_t2sf_type, { "Type", "t2sf.type", FT_UINT8, BASE_DEC, VALS(vals_t2sf_type), 0x0, "", HFILL } }, { &hf_t2sf_data, { "Payload_Data", "t2sf.payload_data", FT_BYTES, BASE_HEX, NULL, 0x0, "", HFILL } } }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_t2sf }; /* Register the protocol name and description */ proto_t2sf = proto_register_protocol("TinyOS2 SerialForwarder Protocol", "T2 SF", "t2sf"); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_t2sf, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); /* Register preferences module (See Section 2.6 for more on preferences) */ t2sf_module = prefs_register_protocol(proto_t2sf, proto_reg_handoff_t2sf); /* subdissector code */ t2sf_type_dissector_table = register_dissector_table("t2sf.type", "T2 SF type", FT_UINT8, BASE_HEX); //register_heur_dissector_list("t2sf", &heur_subdissector_list); /* Register prefs */ prefs_register_uint_preference(t2sf_module, "tcp_port", "TCP Port", "The TCP port on which " "SerialForwarder " "sends the packets", 10, &global_tcp_port_t2sf); }
/*--- proto_register_rua -------------------------------------------*/ void proto_register_rua(void) { module_t *rua_module; /* List of fields */ static hf_register_info hf[] = { #include "packet-rua-hfarr.c" }; /* List of subtrees */ static gint *ett[] = { &ett_rua, #include "packet-rua-ettarr.c" }; /* Register protocol */ proto_rua = proto_register_protocol(PNAME, PSNAME, PFNAME); /* Register fields and subtrees */ proto_register_field_array(proto_rua, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); /* Register dissector */ register_dissector("rua", dissect_rua, proto_rua); /* Register dissector tables */ rua_ies_dissector_table = register_dissector_table("rua.ies", "RUA-PROTOCOL-IES", FT_UINT32, BASE_DEC); rua_extension_dissector_table = register_dissector_table("rua.extension", "RUA-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC); rua_proc_imsg_dissector_table = register_dissector_table("rua.proc.imsg", "RUA-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC); rua_proc_sout_dissector_table = register_dissector_table("rua.proc.sout", "RUA-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC); rua_proc_uout_dissector_table = register_dissector_table("rua.proc.uout", "RUA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC); rua_module = prefs_register_protocol(proto_rua, proto_reg_handoff_rua); prefs_register_uint_preference(rua_module, "port", "RUA SCTP Port", "Set the port for RUA messages (Default of 29169)", 10, &global_sctp_port); }
/* Register the protocol with Wireshark */ void proto_register_ltp(void) { module_t *ltp_module; static hf_register_info hf[] = { {&hf_ltp_version, {"LTP Version","ltp.version", FT_UINT8,BASE_DEC,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_type, {"LTP Type","ltp.type", FT_UINT8,BASE_HEX,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_session_id, {"Session ID","ltp.session", FT_NONE,BASE_NONE,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_session_orig, {"Session originator","ltp.session.orig", FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_session_no, {"Session number","ltp.session.number", FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_hdr_extn_cnt, {"Header Extension Count","ltp.hdr.extn.cnt", FT_UINT8,BASE_DEC,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_trl_extn_cnt, {"Trailer Extension Count","ltp.trl.extn.cnt", FT_UINT8,BASE_DEC,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_data_clid, {"Client service ID","ltp.data.client.id", FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_data_offset, {"Offset","ltp.data.offset", FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_data_length, {"Length","ltp.data.length", FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_data_chkp, {"Checkpoint serial number","ltp.data.chkp", FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_data_rpt, {"Report serial number","ltp.data.rpt", FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_data_clidata, {"Client service data","ltp.data.data", FT_BYTES,BASE_NONE,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_rpt_sno, {"Report serial number","ltp.rpt.sno", FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_rpt_chkp, {"Checkpoint serial number","ltp.rpt.chkp", FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_rpt_ub, {"Upper bound","ltp.rpt.ub", FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_rpt_lb, {"Lower bound","ltp.rpt.lb", FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_rpt_clm_cnt, {"Reception claim count","ltp.rpt.clm.cnt", FT_UINT8,BASE_DEC,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_rpt_clm_off, {"Offset","ltp.rpt.clm.off", FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_rpt_clm_len, {"Length","ltp.rpt.clm.len", FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_rpt_ack_sno, {"Report serial number","ltp.rpt.ack.sno", FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_cancel_code, {"Cancel code","ltp.cancel.code", FT_UINT8,BASE_HEX,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_hdr_extn_tag, {"Extension tag","ltp.hdr.extn.tag", FT_UINT8,BASE_HEX,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_hdr_extn_len, {"Length","ltp.hdr.extn.len", FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_hdr_extn_val, {"Value","ltp.hdr.extn.val", FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_trl_extn_tag, {"Extension tag","ltp.trl.extn.tag", FT_UINT8,BASE_HEX,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_trl_extn_len, {"Length","ltp.trl.extn.len", FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_trl_extn_val, {"Value","ltp.trl.extn.val", FT_UINT64,BASE_DEC,NULL, 0x0, NULL, HFILL} }, {&hf_ltp_fragments, {"LTP Fragments", "ltp.fragments", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL} }, {&hf_ltp_fragment, {"LTP Fragment", "ltp.fragment", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL} }, {&hf_ltp_fragment_overlap, {"LTP fragment overlap", "ltp.fragment.overlap", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL} }, {&hf_ltp_fragment_overlap_conflicts, {"LTP fragment overlapping with conflicting data", "ltp.fragment.overlap.conflicts", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL} }, {&hf_ltp_fragment_multiple_tails, {"LTP has multiple tails", "ltp.fragment.multiple_tails", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL} }, {&hf_ltp_fragment_too_long_fragment, {"LTP fragment too long", "ltp.fragment.too_long_fragment", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL} }, {&hf_ltp_fragment_error, {"LTP defragmentation error", "ltp.fragment.error", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL} }, {&hf_ltp_fragment_count, {"LTP fragment count", "ltp.fragment.count", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL} }, {&hf_ltp_reassembled_in, {"LTP reassembled in", "ltp.reassembled.in", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL} }, {&hf_ltp_reassembled_length, {"LTP reassembled length", "ltp.reassembled.length", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL} } }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_ltp, &ett_ltp_hdr, &ett_hdr_session, &ett_hdr_extn, &ett_data_segm, &ett_data_data_segm, &ett_rpt_segm, &ett_rpt_clm, &ett_rpt_ack_segm, &ett_session_mgmt, &ett_trl_extn, &ett_ltp_fragment, &ett_ltp_fragments }; /* Register the protocol name and description */ proto_ltp = proto_register_protocol("Licklider Transmission Protocol", "LTP", "ltp"); proto_register_field_array(proto_ltp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); ltp_module = prefs_register_protocol(proto_ltp, proto_reg_handoff_ltp); prefs_register_obsolete_preference(ltp_module, "udp.port"); prefs_register_uint_preference(ltp_module, "port", "LTP Port", "The UDP or DCCP port to accept LTP Connections", 10, <p_port); register_init_routine(ltp_defragment_init); }
void proto_register_h263P(void) { module_t *h263P_module; static hf_register_info hf[] = { { &hf_h263P_payload, { "H.263 RFC4629 payload", "h263p.payload", FT_NONE, BASE_NONE, NULL, 0x0, "The actual H.263 RFC4629 data", HFILL } }, { &hf_h263P_rr, { "Reserved", "h263p.rr", FT_UINT16, BASE_DEC, NULL, 0xf800, "Reserved SHALL be zero", HFILL } }, { &hf_h263P_pbit, { "P", "h263p.p", FT_BOOLEAN, 16, NULL, 0x0400, "Indicates (GOB/Slice) start or (EOS or EOSBS)", HFILL } }, { &hf_h263P_vbit, { "V", "h263p.v", FT_BOOLEAN, 16, NULL, 0x0200, "presence of Video Redundancy Coding (VRC) field", HFILL } }, { &hf_h263P_plen, { "PLEN", "h263p.plen", FT_UINT16, BASE_DEC, NULL, 0x01f8, "Length, in bytes, of the extra picture header", HFILL } }, { &hf_h263P_pebit, { "PEBIT", "h263p.pebit", FT_UINT16, BASE_DEC, NULL, 0x0003, "number of bits that shall be ignored in the last byte of the picture header", HFILL } }, { &hf_h263P_tid, { "Thread ID", "h263p.tid", FT_UINT8, BASE_DEC, NULL, 0xe0, NULL, HFILL } }, { &hf_h263P_trun, { "Trun", "h263p.trun", FT_UINT8, BASE_DEC, NULL, 0x1e, "Monotonically increasing (modulo 16) 4-bit number counting the packet number within each thread", HFILL } }, { &hf_h263P_s, { "S", "h263p.s", FT_UINT8, BASE_DEC, NULL, 0x01, "Indicates that the packet content is for a sync frame", HFILL } }, { &hf_h263P_extra_hdr, { "Extra picture header", "h263p.extra_hdr", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, #if 0 { &hf_h263P_PSC, { "H.263 PSC", "h263p.PSC", FT_UINT16, BASE_HEX, NULL, 0xfc00, "Picture Start Code(PSC)", HFILL } }, #endif #if 0 { &hf_h263P_TR, { "H.263 Temporal Reference", "h263p.tr", FT_UINT16, BASE_HEX, NULL, 0x03fc, "Temporal Reference, TR", HFILL } }, #endif }; static gint *ett[] = { &ett_h263P, &ett_h263P_extra_hdr, &ett_h263P_payload, &ett_h263P_data, }; proto_h263P = proto_register_protocol("ITU-T Recommendation H.263 RTP Payload header (RFC4629)", "H263P", "h263p"); proto_register_field_array(proto_h263P, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); h263P_module = prefs_register_protocol(proto_h263P, proto_reg_handoff_h263P); prefs_register_uint_preference(h263P_module, "dynamic.payload.type", "H263-1998 and H263-2000 dynamic payload type", "The dynamic payload type which will be interpreted as H264" "; The value must be greater than 95", 10, &temp_dynamic_payload_type); register_dissector("h263P", dissect_h263P, proto_h263P); }
/* Wireshark Protocol Registration */ void proto_register_t38(void) { static hf_register_info hf[] = { #include "packet-t38-hfarr.c" { &hf_t38_setup, { "Stream setup", "t38.setup", FT_STRING, BASE_NONE, NULL, 0x0, "Stream setup, method and frame number", HFILL }}, { &hf_t38_setup_frame, { "Stream frame", "t38.setup-frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0, "Frame that set up this stream", HFILL }}, { &hf_t38_setup_method, { "Stream Method", "t38.setup-method", FT_STRING, BASE_NONE, NULL, 0x0, "Method used to set up this stream", HFILL }}, {&hf_t38_fragments, {"Message fragments", "t38.fragments", FT_NONE, BASE_NONE, NULL, 0x00, NULL, HFILL } }, {&hf_t38_fragment, {"Message fragment", "t38.fragment", FT_FRAMENUM, BASE_NONE, NULL, 0x00, NULL, HFILL } }, {&hf_t38_fragment_overlap, {"Message fragment overlap", "t38.fragment.overlap", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, {&hf_t38_fragment_overlap_conflicts, {"Message fragment overlapping with conflicting data", "t38.fragment.overlap.conflicts", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, {&hf_t38_fragment_multiple_tails, {"Message has multiple tail fragments", "t38.fragment.multiple_tails", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, {&hf_t38_fragment_too_long_fragment, {"Message fragment too long", "t38.fragment.too_long_fragment", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, {&hf_t38_fragment_error, {"Message defragmentation error", "t38.fragment.error", FT_FRAMENUM, BASE_NONE, NULL, 0x00, NULL, HFILL } }, {&hf_t38_fragment_count, {"Message fragment count", "t38.fragment.count", FT_UINT32, BASE_DEC, NULL, 0x00, NULL, HFILL } }, {&hf_t38_reassembled_in, {"Reassembled in", "t38.reassembled.in", FT_FRAMENUM, BASE_NONE, NULL, 0x00, NULL, HFILL } }, {&hf_t38_reassembled_length, {"Reassembled T38 length", "t38.reassembled.length", FT_UINT32, BASE_DEC, NULL, 0x00, NULL, HFILL } }, }; static gint *ett[] = { &ett_t38, #include "packet-t38-ettarr.c" &ett_t38_setup, &ett_data_fragment, &ett_data_fragments }; module_t *t38_module; proto_t38 = proto_register_protocol("T.38", "T.38", "t38"); proto_register_field_array(proto_t38, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); register_dissector("t38", dissect_t38, proto_t38); /* Init reassemble tables for HDLC */ register_init_routine(t38_defragment_init); t38_tap = register_tap("t38"); t38_module = prefs_register_protocol(proto_t38, proto_reg_handoff_t38); prefs_register_bool_preference(t38_module, "use_pre_corrigendum_asn1_specification", "Use the Pre-Corrigendum ASN.1 specification", "Whether the T.38 dissector should decode using the Pre-Corrigendum T.38 " "ASN.1 specification (1998).", &use_pre_corrigendum_asn1_specification); prefs_register_bool_preference(t38_module, "dissect_possible_rtpv2_packets_as_rtp", "Dissect possible RTP version 2 packets with RTP dissector", "Whether a UDP packet that looks like RTP version 2 packet will " "be dissected as RTP packet or T.38 packet. If enabled there is a risk that T.38 UDPTL " "packets with sequence number higher than 32767 may be dissected as RTP.", &dissect_possible_rtpv2_packets_as_rtp); prefs_register_uint_preference(t38_module, "tcp.port", "T.38 TCP Port", "Set the TCP port for T.38 messages", 10, &global_t38_tcp_port); prefs_register_uint_preference(t38_module, "udp.port", "T.38 UDP Port", "Set the UDP port for T.38 messages", 10, &global_t38_udp_port); prefs_register_bool_preference(t38_module, "reassembly", "Reassemble T.38 PDUs over TPKT over TCP", "Whether the dissector should reassemble T.38 PDUs spanning multiple TCP segments " "when TPKT is used over TCP. " "To use this option, you must also enable \"Allow subdissectors to reassemble " "TCP streams\" in the TCP protocol settings.", &t38_tpkt_reassembly); prefs_register_enum_preference(t38_module, "tpkt_usage", "TPKT used over TCP", "Whether T.38 is used with TPKT for TCP", (gint *)&t38_tpkt_usage,t38_tpkt_options,FALSE); prefs_register_bool_preference(t38_module, "show_setup_info", "Show stream setup information", "Where available, show which protocol and frame caused " "this T.38 stream to be created", &global_t38_show_setup_info); }