void proto_register_media(void) { static hf_register_info hf[] = { { &hf_media_type, { "Media type", "media.type", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, }; static gint *ett[] = { &ett_media }; proto_media = proto_register_protocol ( "Media Type", /* name */ "Media", /* short name */ "media" /* abbrev */ ); new_register_dissector("media", dissect_media, proto_media); register_heur_dissector_list("media", &heur_subdissector_list); proto_register_field_array(proto_media, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); /* * "Media" is used to dissect something whose normal dissector * is disabled, so it cannot itself be disabled. */ proto_set_cant_toggle(proto_media); }
void proto_register_mime_encap(void) { proto_mime_encap = proto_register_protocol("MIME file", "MIME_FILE", "mime_dlt"); register_dissector("mime_dlt", dissect_mime_encap, proto_mime_encap); register_init_routine(mime_encap_init); register_heur_dissector_list("wtap_file", &heur_subdissector_list); }
/* 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); }
void proto_register_media(void) { static gint *ett[] = { &ett_media }; proto_media = proto_register_protocol ( "Media Type", /* name */ "Media", /* short name */ "media" /* abbrev */ ); register_dissector("media", dissect_media, proto_media); register_heur_dissector_list("media", &heur_subdissector_list); proto_register_subtree_array(ett, array_length(ett)); /* * "Media" is used to dissect something whose normal dissector * is disabled, so it cannot itself be disabled. */ proto_set_cant_toggle(proto_media); }
void proto_register_radiohead_datagram(void) { /* RadioHead 1.32 RHDatagram: -TO The node address that the message is being sent to (broadcast RH_BROADCAST_ADDRESS (255) is permitted) -FROM The node address of the sending node -ID A message ID, distinct (over short time scales) for each message sent by a particilar node -FLAGS A bitmask of flags. The most significant 4 bits are reserved for use by RadioHead. The least significant 4 bits are reserved for applications. RHReliableDatagram: RHDatagram header, RH_FLAGS_ACK bit set, - 1 octet of payload containing ASCII '!' (since some drivers cannot handle 0 length payloads) */ static hf_register_info hf[] = { // Name Abbrev Type Display Strings Bitmask Blurb DontTouch { &hf_radiohead_datagram_to, { "To", "radiohead.datagram.to", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_radiohead_datagram_from, { "From", "radiohead.datagram.from", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_radiohead_datagram_id, { "Id", "radiohead.datagram.id", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_radiohead_datagram_flags, { "Flags", "radiohead.datagram.flags", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_radiohead_datagram_flags_ack, { "Ack", "radiohead.datagram.flags.ack", FT_UINT8, BASE_DEC, VALS(ack_types), RH_FLAGS_ACK_MASK, NULL, HFILL } }, }; static int *ett[] = { &ett_radiohead_datagram, // subtree radiohead &ett_radiohead_datagram_flags // subtree radiohead flags field }; proto_radiohead_datagram = proto_register_protocol ( "RadioHeadDatagram", // name "rhdatagram", // short name "rhdatagram" // abbrev ); register_dissector("rhdatagram", dissect_radiohead_datagram, proto_radiohead_datagram); register_heur_dissector_list("rhdatagram", &heur_subdissector_list); proto_register_field_array(proto_radiohead_datagram, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }
void proto_reg_handoff_eth_esp(void) { static gboolean inited = FALSE; static unsigned int old_eth_esp_ethertype; if (!inited) { eth_esp_handle = create_dissector_handle(dissect_eth_esp, proto_eth_esp_plugin); data_handle = find_dissector("data"); eth_esp_tap = register_tap("eth_esp"); eth_esp_follow_tap = register_tap("eth_esp_follow"); register_heur_dissector_list("eth_esp", &heur_subdissector_list); inited = TRUE; } else { dissector_delete("ethertype", old_eth_esp_ethertype, eth_esp_handle); } old_eth_esp_ethertype = eth_esp_ethertype; dissector_add("ethertype", eth_esp_ethertype, eth_esp_handle); }
void proto_register_radiohead_router(void) { /* RadioHead 1.32 RHRouter: - 1 octet DEST, the destination node address (ie the address of the final destination node for this message) - 1 octet SOURCE, the source node address (ie the address of the originating node that first sent the message). - 1 octet HOPS, the number of hops this message has traversed so far. - 1 octet ID, an incrementing message ID for end-to-end message tracking for use by subclasses. Not used by RHRouter. - 1 octet FLAGS, a bitmask for use by subclasses. Not used by RHRouter. - 0 or more octets DATA, the application payload data. The length of this data is implicit in the length of the entire message. */ static hf_register_info hf[] = { // Name Abbrev Type Display Strings Bitmask Blurb DontTouch { &hf_radiohead_router_dest, { "Dest", "radiohead.router.dest", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_radiohead_router_source, { "Source", "radiohead.router.source", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_radiohead_router_hops, { "Hops", "radiohead.router.hops", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_radiohead_router_id, { "Id", "radiohead.router.id", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_radiohead_router_flags, { "Flags", "radiohead.router.flags", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } }, }; static int *ett[] = { &ett_radiohead_router // subtree radiohead }; proto_radiohead_router = proto_register_protocol ( "RadioHeadRouter", // name "rhrouter", // short name "rhrouter" // abbrev ); register_dissector("rhrouter", dissect_radiohead_router, proto_radiohead_router); register_heur_dissector_list("rhrouter", &heur_subdissector_list); proto_register_field_array(proto_radiohead_router, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); }
/* Register all the bits needed with the filtering engine */ void proto_register_pgm(void) { static hf_register_info hf[] = { { &hf_pgm_main_sport, { "Source Port", "pgm.hdr.sport", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_main_dport, { "Destination Port", "pgm.hdr.dport", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_port, { "Port", "pgm.port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_main_type, { "Type", "pgm.hdr.type", FT_UINT8, BASE_HEX, VALS(type_vals), 0x0, NULL, HFILL }}, { &hf_pgm_main_opts, { "Options", "pgm.hdr.opts", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_main_opts_opt, { "Options", "pgm.hdr.opts.opt", FT_BOOLEAN, 8, TFS(&opts_present), PGM_OPT, NULL, HFILL }}, { &hf_pgm_main_opts_netsig, { "Network Significant Options", "pgm.hdr.opts.netsig", FT_BOOLEAN, 8, TFS(&opts_present), PGM_OPT_NETSIG, NULL, HFILL }}, { &hf_pgm_main_opts_varlen, { "Variable length Parity Packet Option", "pgm.hdr.opts.varlen", FT_BOOLEAN, 8, TFS(&opts_present), PGM_OPT_VAR_PKTLEN, NULL, HFILL }}, { &hf_pgm_main_opts_parity, { "Parity", "pgm.hdr.opts.parity", FT_BOOLEAN, 8, TFS(&opts_present), PGM_OPT_PARITY, NULL, HFILL }}, { &hf_pgm_main_cksum, { "Checksum", "pgm.hdr.cksum", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_main_cksum_bad, { "Bad Checksum", "pgm.hdr.cksum_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_main_gsi, { "Global Source Identifier", "pgm.hdr.gsi", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_main_tsdulen, { "Transport Service Data Unit Length", "pgm.hdr.tsdulen", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_spm_sqn, { "Sequence number", "pgm.spm.sqn", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_spm_trail, { "Trailing Edge Sequence Number", "pgm.spm.trail", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_spm_lead, { "Leading Edge Sequence Number", "pgm.spm.lead", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_spm_pathafi, { "Path NLA AFI", "pgm.spm.pathafi", FT_UINT16, BASE_DEC, VALS(afn_vals), 0x0, NULL, HFILL }}, { &hf_pgm_spm_res, { "Reserved", "pgm.spm.res", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_spm_path, { "Path NLA", "pgm.spm.path", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_spm_path6, { "Path NLA", "pgm.spm.path", FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_data_sqn, { "Data Packet Sequence Number", "pgm.data.sqn", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_data_trail, { "Trailing Edge Sequence Number", "pgm.data.trail", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_nak_sqn, { "Requested Sequence Number", "pgm.nak.sqn", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_nak_srcafi, { "Source NLA AFI", "pgm.nak.srcafi", FT_UINT16, BASE_DEC, VALS(afn_vals), 0x0, NULL, HFILL }}, { &hf_pgm_nak_srcres, { "Reserved", "pgm.nak.srcres", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_nak_src, { "Source NLA", "pgm.nak.src", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_nak_src6, { "Source NLA", "pgm.nak.src", FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_nak_grpafi, { "Multicast Group AFI", "pgm.nak.grpafi", FT_UINT16, BASE_DEC, VALS(afn_vals), 0x0, NULL, HFILL }}, { &hf_pgm_nak_grpres, { "Reserved", "pgm.nak.grpres", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_nak_grp, { "Multicast Group NLA", "pgm.nak.grp", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_nak_grp6, { "Multicast Group NLA", "pgm.nak.grp", FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_poll_sqn, { "Sequence Number", "pgm.poll.sqn", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_poll_round, { "Round", "pgm.poll.round", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_poll_subtype, { "Subtype", "pgm.poll.subtype", FT_UINT16, BASE_HEX, VALS(poll_subtype_vals), 0x0, NULL, HFILL }}, { &hf_pgm_poll_pathafi, { "Path NLA AFI", "pgm.poll.pathafi", FT_UINT16, BASE_DEC, VALS(afn_vals), 0x0, NULL, HFILL }}, { &hf_pgm_poll_res, { "Reserved", "pgm.poll.res", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_poll_path, { "Path NLA", "pgm.poll.path", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_poll_path6, { "Path NLA", "pgm.poll.path", FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_poll_backoff_ivl, { "Back-off Interval", "pgm.poll.backoff_ivl", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_poll_rand_str, { "Random String", "pgm.poll.rand_str", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_poll_matching_bmask, { "Matching Bitmask", "pgm.poll.matching_bmask", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_polr_sqn, { "Sequence Number", "pgm.polr.sqn", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_polr_round, { "Round", "pgm.polr.round", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_polr_res, { "Reserved", "pgm.polr.res", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_ack_sqn, { "Maximum Received Sequence Number", "pgm.ack.maxsqn", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_ack_bitmap, { "Packet Bitmap", "pgm.ack.bitmap", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_type, { "Type", "pgm.opts.type", FT_UINT8, BASE_HEX, VALS(opt_vals), 0x0, NULL, HFILL }}, { &hf_pgm_opt_len, { "Length", "pgm.opts.len", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_tlen, { "Total Length", "pgm.opts.tlen", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_genopt_end, { "Option end", "pgm.genopts.end", FT_BOOLEAN, 8, TFS(&tfs_yes_no), 0x80, NULL, HFILL }}, { &hf_pgm_genopt_type, { "Type", "pgm.genopts.type", FT_UINT8, BASE_HEX, VALS(opt_vals), 0x7f, NULL, HFILL }}, { &hf_pgm_genopt_len, { "Length", "pgm.genopts.len", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_genopt_opx, { "Option Extensibility Bits", "pgm.genopts.opx", FT_UINT8, BASE_HEX, VALS(opx_vals), 0x0, NULL, HFILL }}, { &hf_pgm_opt_parity_prm_po, { "Parity Parameters", "pgm.opts.parity_prm.op", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_parity_prm_prmtgsz, { "Transmission Group Size", "pgm.opts.parity_prm.prm_grp", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_join_res, { "Reserved", "pgm.opts.join.res", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_join_minjoin, { "Minimum Sequence Number", "pgm.opts.join.min_join", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_parity_grp_res, { "Reserved", "pgm.opts.parity_prm.op", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_parity_grp_prmgrp, { "Transmission Group Size", "pgm.opts.parity_prm.prm_grp", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_nak_res, { "Reserved", "pgm.opts.nak.op", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_nak_list, { "List", "pgm.opts.nak.list", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_ccdata_res, { "Reserved", "pgm.opts.ccdata.res", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_ccdata_tsp, { "Time Stamp", "pgm.opts.ccdata.tstamp", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_ccdata_afi, { "Acker AFI", "pgm.opts.ccdata.afi", FT_UINT16, BASE_DEC, VALS(afn_vals), 0x0, NULL, HFILL }}, { &hf_pgm_opt_ccdata_res2, { "Reserved", "pgm.opts.ccdata.res2", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_ccdata_acker, { "Acker", "pgm.opts.ccdata.acker", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_ccdata_acker6, { "Acker", "pgm.opts.ccdata.acker", FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_ccfeedbk_res, { "Reserved", "pgm.opts.ccdata.res", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_ccfeedbk_tsp, { "Time Stamp", "pgm.opts.ccdata.tstamp", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_ccfeedbk_afi, { "Acker AFI", "pgm.opts.ccdata.afi", FT_UINT16, BASE_DEC, VALS(afn_vals), 0x0, NULL, HFILL }}, { &hf_pgm_opt_ccfeedbk_lossrate, { "Loss Rate", "pgm.opts.ccdata.lossrate", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_ccfeedbk_acker, { "Acker", "pgm.opts.ccdata.acker", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_ccfeedbk_acker6, { "Acker", "pgm.opts.ccdata.acker", FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_nak_bo_ivl_res, { "Reserved", "pgm.opts.nak_bo_ivl.res", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_nak_bo_ivl_bo_ivl, { "Back-off Interval", "pgm.opts.nak_bo_ivl.bo_ivl", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_nak_bo_ivl_bo_ivl_sqn, { "Back-off Interval Sequence Number", "pgm.opts.nak_bo_ivl.bo_ivl_sqn", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_nak_bo_rng_res, { "Reserved", "pgm.opts.nak_bo_rng.res", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_nak_bo_rng_min_bo_ivl, { "Min Back-off Interval", "pgm.opts.nak_bo_rng.min_bo_ivl", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_nak_bo_rng_max_bo_ivl, { "Max Back-off Interval", "pgm.opts.nak_bo_rng.max_bo_ivl", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_redirect_res, { "Reserved", "pgm.opts.redirect.res", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_redirect_afi, { "DLR AFI", "pgm.opts.redirect.afi", FT_UINT16, BASE_DEC, VALS(afn_vals), 0x0, NULL, HFILL }}, { &hf_pgm_opt_redirect_res2, { "Reserved", "pgm.opts.redirect.res2", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_redirect_dlr, { "DLR", "pgm.opts.redirect.dlr", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_redirect_dlr6, { "DLR", "pgm.opts.redirect.dlr", FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_fragment_res, { "Reserved", "pgm.opts.fragment.res", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_fragment_first_sqn, { "First Sequence Number", "pgm.opts.fragment.first_sqn", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_fragment_offset, { "Fragment Offset", "pgm.opts.fragment.fragment_offset", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_pgm_opt_fragment_total_length, { "Total Length", "pgm.opts.fragment.total_length", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }} }; static gint *ett[] = { &ett_pgm, &ett_pgm_optbits, &ett_pgm_spm, &ett_pgm_data, &ett_pgm_nak, &ett_pgm_poll, &ett_pgm_polr, &ett_pgm_ack, &ett_pgm_opts, &ett_pgm_opts_join, &ett_pgm_opts_parityprm, &ett_pgm_opts_paritygrp, &ett_pgm_opts_naklist, &ett_pgm_opts_ccdata, &ett_pgm_opts_nak_bo_ivl, &ett_pgm_opts_nak_bo_rng, &ett_pgm_opts_redirect, &ett_pgm_opts_fragment }; module_t *pgm_module; proto_pgm = proto_register_protocol("Pragmatic General Multicast", "PGM", "pgm"); proto_register_field_array(proto_pgm, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); /* subdissector code */ subdissector_table = register_dissector_table("pgm.port", "PGM port", FT_UINT16, BASE_DEC); register_heur_dissector_list("pgm", &heur_subdissector_list); /* * Register configuration preferences for UDP encapsulation * (Note: Initially the ports are set to zero and the ports * are not registered so the dissecting of PGM * encapsulated in UDP packets is off by default; * dissector_add_handle is called so that pgm * is available for 'decode-as' */ pgm_module = prefs_register_protocol(proto_pgm, proto_reg_handoff_pgm); prefs_register_bool_preference(pgm_module, "check_checksum", "Check the validity of the PGM checksum when possible", "Whether to check the validity of the PGM checksum", &pgm_check_checksum); prefs_register_uint_preference(pgm_module, "udp.encap_ucast_port", "PGM Encap Unicast Port (standard is 3055)", "PGM Encap is PGM packets encapsulated in UDP packets" " (Note: This option is off, i.e. port is 0, by default)", 10, &udp_encap_ucast_port); prefs_register_uint_preference(pgm_module, "udp.encap_mcast_port", "PGM Encap Multicast Port (standard is 3056)", "PGM Encap is PGM packets encapsulated in UDP packets" " (Note: This option is off, i.e. port is 0, by default)", 10, &udp_encap_mcast_port); }
void proto_register_eth(void) { static hf_register_info hf[] = { { &hf_eth_dst, { "Destination", "eth.dst", FT_ETHER, BASE_NONE, NULL, 0x0, "Destination Hardware Address", HFILL }}, { &hf_eth_src, { "Source", "eth.src", FT_ETHER, BASE_NONE, NULL, 0x0, "Source Hardware Address", HFILL }}, { &hf_eth_len, { "Length", "eth.len", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, /* registered here but handled in packet-ethertype.c */ { &hf_eth_type, { "Type", "eth.type", FT_UINT16, BASE_HEX, VALS(etype_vals), 0x0, NULL, HFILL }}, { &hf_eth_invalid_lentype, { "Invalid length/type", "eth.invalid_lentype", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_eth_addr, { "Address", "eth.addr", FT_ETHER, BASE_NONE, NULL, 0x0, "Source or Destination Hardware Address", HFILL }}, { &hf_eth_padding, { "Padding", "eth.padding", FT_BYTES, BASE_NONE, NULL, 0x0, "Ethernet Padding", HFILL }}, { &hf_eth_trailer, { "Trailer", "eth.trailer", FT_BYTES, BASE_NONE, NULL, 0x0, "Ethernet Trailer or Checksum", HFILL }}, { &hf_eth_fcs, { "Frame check sequence", "eth.fcs", FT_UINT32, BASE_HEX, NULL, 0x0, "Ethernet checksum", HFILL }}, { &hf_eth_fcs_good, { "FCS Good", "eth.fcs_good", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "True: checksum matches packet content; False: doesn't match content or not checked", HFILL }}, { &hf_eth_fcs_bad, { "FCS Bad", "eth.fcs_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "True: checksum doesn't matche packet content; False: does match content or not checked", HFILL }}, { &hf_eth_lg, { "LG bit", "eth.lg", FT_BOOLEAN, 24, TFS(&lg_tfs), 0x020000, "Specifies if this is a locally administered or globally unique (IEEE assigned) address", HFILL }}, { &hf_eth_ig, { "IG bit", "eth.ig", FT_BOOLEAN, 24, TFS(&ig_tfs), 0x010000, "Specifies if this is an individual (unicast) or group (broadcast/multicast) address", HFILL }} }; static gint *ett[] = { &ett_ieee8023, &ett_ether2, &ett_ether, &ett_addr, &ett_eth_fcs }; module_t *eth_module; proto_eth = proto_register_protocol("Ethernet", "Ethernet", "eth"); proto_register_field_array(proto_eth, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); /* subdissector code */ register_heur_dissector_list("eth", &heur_subdissector_list); register_heur_dissector_list("eth.trailer", ð_trailer_subdissector_list); /* Register configuration preferences */ eth_module = prefs_register_protocol(proto_eth, NULL); prefs_register_bool_preference(eth_module, "assume_padding", "Assume short frames which include a trailer contain padding", "Some devices add trailing data to frames. When this setting is checked " "the Ethernet dissector will assume there has been added padding to the " "frame before the trailer was added. Uncheck if a device added a trailer " "before the frame was padded.", ð_assume_padding); prefs_register_bool_preference(eth_module, "assume_fcs", "Assume packets have FCS", "Some Ethernet adapters and drivers include the FCS at the end of a packet, others do not. " "The Ethernet dissector attempts to guess whether a captured packet has an FCS, " "but it cannot always guess correctly.", ð_assume_fcs); prefs_register_bool_preference(eth_module, "check_fcs", "Validate the Ethernet checksum if possible", "Whether to validate the Frame Check Sequence", ð_check_fcs); prefs_register_bool_preference(eth_module, "interpret_as_fw1_monitor", "Attempt to interpret as FireWall-1 monitor file", "Whether packets should be interpreted as coming from CheckPoint FireWall-1 monitor file if they look as if they do", ð_interpret_as_fw1_monitor); prefs_register_static_text_preference(eth_module, "ccsds_heuristic", "These are the conditions to match a payload against in order to determine if this\n" "is a CCSDS (Consultative Committee for Space Data Systems) packet within\n" "an 802.3 packet. A packet is considered as a possible CCSDS packet only if\n" "one or more of the conditions are checked.", "Describe the conditions that must be true for the CCSDS dissector to be called"); prefs_register_bool_preference(eth_module, "ccsds_heuristic_length", "CCSDS Length in header matches payload size", "Set the condition that must be true for the CCSDS dissector to be called", &ccsds_heuristic_length); prefs_register_bool_preference(eth_module, "ccsds_heuristic_version", "CCSDS Version # is zero", "Set the condition that must be true for the CCSDS dissector to be called", &ccsds_heuristic_version); prefs_register_bool_preference(eth_module, "ccsds_heuristic_header", "CCSDS Secondary Header Flag is set", "Set the condition that must be true for the CCSDS dissector to be called", &ccsds_heuristic_header); prefs_register_bool_preference(eth_module, "ccsds_heuristic_bit", "CCSDS Spare bit is cleared", "Set the condition that must be true for the CCSDS dissector to be called", &ccsds_heuristic_bit); register_dissector("eth_withoutfcs", dissect_eth_withoutfcs, proto_eth); register_dissector("eth_withfcs", dissect_eth_withfcs, proto_eth); register_dissector("eth", dissect_eth_maybefcs, proto_eth); eth_tap = register_tap("eth"); }
void proto_register_udp(void) { module_t *udp_module; module_t *udplite_module; static hf_register_info hf[] = { { &hf_udp_srcport, { "Source Port", "udp.srcport", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_udp_dstport, { "Destination Port", "udp.dstport", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_udp_port, { "Source or Destination Port", "udp.port", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_udp_length, { "Length", "udp.length", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_udp_checksum, { "Checksum", "udp.checksum", FT_UINT16, BASE_HEX, NULL, 0x0, "Details at: http://www.wireshark.org/docs/wsug_html_chunked/ChAdvChecksums.html", HFILL }}, { &hf_udp_checksum_good, { "Good Checksum", "udp.checksum_good", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "True: checksum matches packet content; False: doesn't match content or not checked", HFILL }}, { &hf_udp_checksum_bad, { "Bad Checksum", "udp.checksum_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "True: checksum doesn't match packet content; False: matches content or not checked", HFILL }}, { &hf_udp_proc_src_uid, { "Source process user ID", "udp.proc.srcuid", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_udp_proc_src_pid, { "Source process ID", "udp.proc.srcpid", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_udp_proc_src_uname, { "Source process user name", "udp.proc.srcuname", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL}}, { &hf_udp_proc_src_cmd, { "Source process name", "udp.proc.srccmd", FT_STRING, BASE_NONE, NULL, 0x0, "Source process command name", HFILL}}, { &hf_udp_proc_dst_uid, { "Destination process user ID", "udp.proc.dstuid", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_udp_proc_dst_pid, { "Destination process ID", "udp.proc.dstpid", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_udp_proc_dst_uname, { "Destination process user name", "udp.proc.dstuname", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL}}, { &hf_udp_proc_dst_cmd, { "Destination process name", "udp.proc.dstcmd", FT_STRING, BASE_NONE, NULL, 0x0, "Destination process command name", HFILL}} }; static hf_register_info hf_lite[] = { { &hf_udplite_checksum_coverage_bad, { "Bad Checksum coverage", "udp.checksum_coverage_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_udplite_checksum_coverage, { "Checksum coverage", "udp.checksum_coverage", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }} }; static gint *ett[] = { &ett_udp, &ett_udp_checksum, &ett_udp_process_info }; proto_udp = proto_register_protocol("User Datagram Protocol", "UDP", "udp"); register_dissector("udp", dissect_udp, proto_udp); proto_udplite = proto_register_protocol("Lightweight User Datagram Protocol", "UDPlite", "udplite"); proto_register_field_array(proto_udp, hf, array_length(hf)); proto_register_field_array(proto_udplite, hf_lite, array_length(hf_lite)); proto_register_subtree_array(ett, array_length(ett)); /* subdissector code */ udp_dissector_table = register_dissector_table("udp.port", "UDP port", FT_UINT16, BASE_DEC); register_heur_dissector_list("udp", &heur_subdissector_list); register_heur_dissector_list("udplite", &heur_subdissector_list); /* Register configuration preferences */ udp_module = prefs_register_protocol(proto_udp, NULL); prefs_register_bool_preference(udp_module, "summary_in_tree", "Show UDP summary in protocol tree", "Whether the UDP summary line should be shown in the protocol tree", &udp_summary_in_tree); prefs_register_bool_preference(udp_module, "try_heuristic_first", "Try heuristic sub-dissectors first", "Try to decode a packet using an heuristic sub-dissector before using a sub-dissector registered to a specific port", &try_heuristic_first); prefs_register_bool_preference(udp_module, "check_checksum", "Validate the UDP checksum if possible", "Whether to validate the UDP checksum", &udp_check_checksum); prefs_register_bool_preference(udp_module, "process_info", "Collect process flow information", "Collect process flow information from IPFIX", &udp_process_info); udplite_module = prefs_register_protocol(proto_udplite, NULL); prefs_register_bool_preference(udplite_module, "ignore_checksum_coverage", "Ignore UDPlite checksum coverage", "Ignore an invalid checksum coverage field and continue dissection", &udplite_ignore_checksum_coverage); prefs_register_bool_preference(udplite_module, "check_checksum", "Validate the UDPlite checksum if possible", "Whether to validate the UDPlite checksum", &udplite_check_checksum); }
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_udp(void) { module_t *udp_module; module_t *udplite_module; expert_module_t* expert_udp; #ifndef HAVE_HFI_SECTION_INIT static header_field_info *hfi[] = { &hfi_udp_srcport, &hfi_udp_dstport, &hfi_udp_port, &hfi_udp_stream, &hfi_udp_length, &hfi_udp_checksum, &hfi_udp_checksum_calculated, &hfi_udp_checksum_good, &hfi_udp_checksum_bad, &hfi_udp_proc_src_uid, &hfi_udp_proc_src_pid, &hfi_udp_proc_src_uname, &hfi_udp_proc_src_cmd, &hfi_udp_proc_dst_uid, &hfi_udp_proc_dst_pid, &hfi_udp_proc_dst_uname, &hfi_udp_proc_dst_cmd, }; static header_field_info *hfi_lite[] = { &hfi_udplite_checksum_coverage_bad, &hfi_udplite_checksum_coverage, }; #endif static gint *ett[] = { &ett_udp, &ett_udp_checksum, &ett_udp_process_info }; static ei_register_info ei[] = { { &ei_udp_possible_traceroute, { "udp.possible_traceroute", PI_SEQUENCE, PI_CHAT, "Possible traceroute", EXPFILL }}, { &ei_udp_length, { "udp.length.bad", PI_MALFORMED, PI_ERROR, "Bad length value", EXPFILL }}, { &ei_udplite_checksum_coverage, { "udp.checksum_coverage.expert", PI_MALFORMED, PI_ERROR, "Bad checksum coverage length value", EXPFILL }}, { &ei_udp_checksum_zero, { "udp.checksum.zero", PI_CHECKSUM, PI_ERROR, "Illegal Checksum value (0)", EXPFILL }}, { &ei_udp_checksum_bad, { "udp.checksum_bad.expert", PI_CHECKSUM, PI_ERROR, "Bad checksum", EXPFILL }}, }; static build_valid_func udp_da_src_values[1] = {udp_src_value}; static build_valid_func udp_da_dst_values[1] = {udp_dst_value}; static build_valid_func udp_da_both_values[2] = {udp_src_value, udp_dst_value}; static decode_as_value_t udp_da_values[3] = {{udp_src_prompt, 1, udp_da_src_values}, {udp_dst_prompt, 1, udp_da_dst_values}, {udp_both_prompt, 2, udp_da_both_values}}; static decode_as_t udp_da = {"udp", "Transport", "udp.port", 3, 2, udp_da_values, "UDP", "port(s) as", decode_as_default_populate_list, decode_as_default_reset, decode_as_default_change, NULL}; int proto_udp, proto_udplite; proto_udp = proto_register_protocol("User Datagram Protocol", "UDP", "udp"); hfi_udp = proto_registrar_get_nth(proto_udp); udp_handle = register_dissector("udp", dissect_udp, proto_udp); expert_udp = expert_register_protocol(proto_udp); proto_register_fields(proto_udp, hfi, array_length(hfi)); proto_udplite = proto_register_protocol("Lightweight User Datagram Protocol", "UDPlite", "udplite"); udplite_handle = create_dissector_handle(dissect_udplite, proto_udplite); hfi_udplite = proto_registrar_get_nth(proto_udplite); proto_register_fields(proto_udplite, hfi_lite, array_length(hfi_lite)); proto_register_subtree_array(ett, array_length(ett)); expert_register_field_array(expert_udp, ei, array_length(ei)); /* subdissector code */ udp_dissector_table = register_dissector_table("udp.port", "UDP port", FT_UINT16, BASE_DEC); register_heur_dissector_list("udp", &heur_subdissector_list); register_heur_dissector_list("udplite", &heur_subdissector_list); /* Register configuration preferences */ udp_module = prefs_register_protocol(proto_udp, NULL); prefs_register_bool_preference(udp_module, "summary_in_tree", "Show UDP summary in protocol tree", "Whether the UDP summary line should be shown in the protocol tree", &udp_summary_in_tree); prefs_register_bool_preference(udp_module, "try_heuristic_first", "Try heuristic sub-dissectors first", "Try to decode a packet using an heuristic sub-dissector" " before using a sub-dissector registered to a specific port", &try_heuristic_first); prefs_register_bool_preference(udp_module, "check_checksum", "Validate the UDP checksum if possible", "Whether to validate the UDP checksum", &udp_check_checksum); prefs_register_bool_preference(udp_module, "process_info", "Collect process flow information", "Collect process flow information from IPFIX", &udp_process_info); udplite_module = prefs_register_protocol(proto_udplite, NULL); prefs_register_bool_preference(udplite_module, "ignore_checksum_coverage", "Ignore UDPlite checksum coverage", "Ignore an invalid checksum coverage field and continue dissection", &udplite_ignore_checksum_coverage); prefs_register_bool_preference(udplite_module, "check_checksum", "Validate the UDPlite checksum if possible", "Whether to validate the UDPlite checksum", &udplite_check_checksum); register_decode_as(&udp_da); register_init_routine(udp_init); }
/* register the protocol with Wireshark */ void proto_register_iwarp_ddp_rdmap(void) { /* setup list of header fields */ static hf_register_info hf[] = { /* DDP */ { &hf_iwarp_ddp, { "DDP header", "iwarp_ddp", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_iwarp_ddp_control_field, { "DDP control field", "iwarp_ddp.control_field", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_iwarp_ddp_tagged_header, { "Tagged buffer model", "iwarp_ddp.tagged", FT_NONE, BASE_NONE, NULL, 0x0, "DDP Tagged Buffer Model Header", HFILL} }, { &hf_iwarp_ddp_untagged_header, { "Untagged buffer model", "iwarp_ddp.untagged", FT_NONE, BASE_NONE, NULL, 0x0, "DDP Untagged Buffer Model Header", HFILL} }, { &hf_iwarp_ddp_t_flag, { "Tagged flag", "iwarp_ddp.tagged_flag", FT_BOOLEAN, 8, NULL, DDP_TAGGED_FLAG, NULL, HFILL} }, { &hf_iwarp_ddp_l_flag, { "Last flag", "iwarp_ddp.last_flag", FT_BOOLEAN, 8, NULL, DDP_LAST_FLAG, NULL, HFILL} }, { &hf_iwarp_ddp_rsvd, { "Reserved", "iwarp_ddp.rsvd", FT_UINT8, BASE_HEX, NULL, DDP_RSVD, NULL, HFILL} }, { &hf_iwarp_ddp_dv, { "DDP protocol version", "iwarp_ddp.dv", FT_UINT8, BASE_DEC, NULL, DDP_DV, NULL, HFILL} }, { &hf_iwarp_ddp_rsvdulp, { "Reserved for use by the ULP", "iwarp_ddp.rsvdulp", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL} }, { &hf_iwarp_ddp_stag, { "(Data Sink) Steering Tag", "iwarp_ddp.stag", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL} }, { &hf_iwarp_ddp_to, { "(Data Sink) Tagged offset", "iwarp_ddp.tagged_offset", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL} }, { &hf_iwarp_ddp_qn, { "Queue number", "iwarp_ddp.qn", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL} }, { &hf_iwarp_ddp_msn, { "Message sequence number", "iwarp_ddp.msn", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL} }, { &hf_iwarp_ddp_mo, { "Message offset", "iwarp_ddp.mo", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL} }, /* RDMAP */ { &hf_iwarp_rdma, { "RDMAP header", "iwarp_rdma", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL} }, { &hf_iwarp_rdma_control_field, { "RDMAP control field", "iwarp_rdma.control_field", FT_NONE, BASE_NONE, NULL, 0x0, "RDMA Control Field", HFILL} }, { &hf_iwarp_rdma_version, { "Version", "iwarp_rdma.version", FT_UINT8, BASE_DEC, NULL, RDMA_RV, "RDMA Version Field", HFILL} }, { &hf_iwarp_rdma_rsvd, { "Reserved", "iwarp_rdma.rsv", FT_UINT8, BASE_HEX, NULL, RDMA_RSV, "RDMA Control Field Reserved", HFILL} }, { &hf_iwarp_rdma_opcode, { "OpCode", "iwarp_rdma.opcode", FT_UINT8, BASE_HEX, VALS(rdmap_messages), RDMA_OPCODE, "RDMA OpCode Field", HFILL} }, { &hf_iwarp_rdma_reserved, { "Reserved", "iwarp_rdma.reserved", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL} }, { &hf_iwarp_rdma_inval_stag, { "Invalidate STag", "iwarp_rdma.inval_stag", FT_UINT32, BASE_DEC, NULL, 0x0, "RDMA Invalidate STag", HFILL} }, { &hf_iwarp_rdma_rr_header, { "Read request", "iwarp_rdma.rr", FT_NONE, BASE_NONE, NULL, 0x0, "RDMA Read Request Header", HFILL} }, { &hf_iwarp_rdma_terminate_header, { "Terminate", "iwarp_rdma.terminate", FT_NONE, BASE_NONE, NULL, 0x0, "RDMA Terminate Header", HFILL} }, { &hf_iwarp_rdma_sinkstag, { "Data Sink STag", "iwarp_rdma.sinkstag", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL} }, { &hf_iwarp_rdma_sinkto, { "Data Sink Tagged Offset", "iwarp_rdma.sinkto", FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL} }, { &hf_iwarp_rdma_rdmardsz, { "RDMA Read Message Size", "iwarp_rdma.rdmardsz", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL} }, { &hf_iwarp_rdma_srcstag, { "Data Source STag", "iwarp_rdma.srcstag", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL} }, { &hf_iwarp_rdma_srcto, { "Data Source Tagged Offset", "iwarp_rdma.srcto", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL} }, { &hf_iwarp_rdma_term_ctrl, { "Terminate Control", "iwarp_rdma.term_ctrl", FT_NONE, BASE_NONE, NULL, 0x0, "RDMA Terminate Control Field", HFILL} }, { &hf_iwarp_rdma_term_layer, { "Layer", "iwarp_rdma.term_layer", FT_UINT8, BASE_HEX, VALS(layer_names), IWARP_LAYER, "Terminate Control Field: Layer", HFILL} }, { &hf_iwarp_rdma_term_etype_rdma, { "Error Types for RDMA layer", "iwarp_rdma.term_etype_rdma", FT_UINT8, BASE_HEX, VALS(rdma_etype_names), IWARP_ETYPE, "Terminate Control Field: Error Type", HFILL} }, { &hf_iwarp_rdma_term_etype_ddp, { "Error Types for DDP layer", "iwarp_rdma.term_etype_ddp", FT_UINT8, BASE_HEX, VALS(ddp_etype_names), IWARP_ETYPE, "Terminate Control Field: Error Type", HFILL} }, { &hf_iwarp_rdma_term_etype_llp, { "Error Types for LLP layer", "iwarp_rdma.term_etype_llp", FT_UINT8, BASE_HEX, NULL, IWARP_ETYPE, "Terminate Control Field: Error Type", HFILL} }, { &hf_iwarp_rdma_term_etype, { "Error Types", "iwarp_rdma.term_etype", FT_UINT8, BASE_HEX, NULL, IWARP_ETYPE, "Terminate Control Field: Error Type", HFILL} }, { &hf_iwarp_rdma_term_errcode_rdma, { "Error Code for RDMA layer", "iwarp_rdma.term_errcode_rdma", FT_UINT8, BASE_HEX, VALS(rdma_errcode_names), 0x0, "Terminate Control Field: Error Code", HFILL} }, { &hf_iwarp_rdma_term_errcode_ddp_tagged, { "Error Code for DDP Tagged Buffer", "iwarp_rdma.term_errcode_ddp_tagged", FT_UINT8, BASE_HEX, VALS(ddp_errcode_tagged_names), 0x0, "Terminate Control Field: Error Code", HFILL} }, { &hf_iwarp_rdma_term_errcode_ddp_untagged, { "Error Code for DDP Untagged Buffer", "iwarp_rdma.term_errcode_ddp_untagged", FT_UINT8, BASE_HEX, VALS(ddp_errcode_untagged_names), 0x0, "Terminate Control Field: Error Code", HFILL} }, { &hf_iwarp_rdma_term_errcode, { "Error Code", "iwarp_rdma.term_errcode", FT_UINT8, BASE_HEX, NULL, 0x0, "Terminate Control Field: Error Code", HFILL} }, { &hf_iwarp_rdma_term_errcode_llp, { "Error Code for LLP layer", "iwarp_rdma.term_errcode_llp", FT_UINT8, BASE_HEX, NULL, 0x0, "Terminate Control Field: Lower Layer Protocol Error Code", HFILL} }, { &hf_iwarp_rdma_term_hdrct, { "Header control bits", "iwarp_rdma.term_hdrct", FT_NONE, BASE_NONE, NULL, 0x0, "Terminate Control Field: Header control bits", HFILL} }, { &hf_iwarp_rdma_term_hdrct_m, { "M bit", "iwarp_rdma.term_hdrct_m", FT_UINT8, BASE_HEX, NULL, IWARP_HDRCT_M, "Header control bit m: DDP Segment Length valid", HFILL} }, { &hf_iwarp_rdma_term_hdrct_d, { "D bit", "iwarp_rdma.hdrct_d", FT_UINT8, BASE_HEX, NULL, IWARP_HDRCT_D, "Header control bit d: DDP Header Included", HFILL} }, { &hf_iwarp_rdma_term_hdrct_r, { "R bit", "iwarp_rdma.hdrct_r", FT_UINT8, BASE_HEX, NULL, IWARP_HDRCT_R, "Header control bit r: RDMAP Header Included", HFILL} }, { &hf_iwarp_rdma_term_rsvd, { "Reserved", "iwarp_rdma.term_rsvd", FT_UINT16, BASE_HEX, NULL, IWARP_TERM_RES, NULL, HFILL} }, { &hf_iwarp_rdma_term_ddp_seg_len, { "DDP Segment Length", "iwarp_rdma.term_ddp_seg_len", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL} }, { &hf_iwarp_rdma_term_ddp_h, { "Terminated DDP Header", "iwarp_rdma.term_ddp_h", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL} }, { &hf_iwarp_rdma_term_rdma_h, { "Terminated RDMA Header", "iwarp_rdma.term_rdma_h", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL} } }; /* setup protocol subtree array */ static gint *ett[] = { &ett_iwarp_ddp_rdmap, /* DDP */ &ett_iwarp_ddp, &ett_iwarp_ddp_control_field, &ett_iwarp_ddp_tagged_header, &ett_iwarp_ddp_untagged_header, /* RDMAP */ &ett_iwarp_rdma, &ett_iwarp_rdma_control_field, &ett_iwarp_rdma_rr_header, &ett_iwarp_rdma_terminate_header, &ett_iwarp_rdma_term_ctrl, &ett_iwarp_rdma_term_hdrct }; /* register the protocol name and description */ proto_iwarp_ddp_rdmap = proto_register_protocol( "iWARP Direct Data Placement and Remote Direct Memory Access Protocol", "IWARP_DDP_RDMAP", "iwarp_ddp_rdmap"); /* required function calls to register the header fields and subtrees */ proto_register_field_array(proto_iwarp_ddp_rdmap, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); register_heur_dissector_list("iwarp_ddp_rdmap", &rdmap_heur_subdissector_list); register_dissector("iwarp_ddp_rdmap", dissect_iwarp_ddp_rdmap, proto_iwarp_ddp_rdmap); }
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_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_segment_overlap, { "Segment overlap", "clnp.segment.overlap", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Segment overlaps with other segments", HFILL }}, { &hf_clnp_segment_overlap_conflict, { "Conflicting data in segment overlap", "clnp.segment.overlap.conflict", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Overlapping segments contained conflicting data", HFILL }}, { &hf_clnp_segment_multiple_tails, { "Multiple tail segments found", "clnp.segment.multipletails", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Several tails were found when reassembling the packet", HFILL }}, { &hf_clnp_segment_too_long_segment, { "Segment too long", "clnp.segment.toolongsegment", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Segment contained data past end of packet", HFILL }}, { &hf_clnp_segment_error, { "Reassembly error", "clnp.segment.error", FT_FRAMENUM, BASE_NONE, NULL, 0x0, "Reassembly error due to illegal segments", HFILL }}, { &hf_clnp_segment_count, { "Segment count", "clnp.segment.count", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_clnp_segment, { "CLNP Segment", "clnp.segment", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_clnp_segments, { "CLNP Segments", "clnp.segments", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_clnp_reassembled_in, { "Reassembled CLNP in frame", "clnp.reassembled_in", FT_FRAMENUM, BASE_NONE, NULL, 0x0, "This CLNP packet is reassembled in this frame", HFILL }}, { &hf_clnp_reassembled_length, { "Reassembled CLNP length", "clnp.reassembled.length", FT_UINT32, BASE_DEC, NULL, 0x0, "The total length of the reassembled payload", HFILL }} }; static gint *ett[] = { &ett_clnp, &ett_clnp_type, &ett_clnp_segments, &ett_clnp_segment, &ett_clnp_disc_pdu, }; module_t *clnp_module; proto_clnp = proto_register_protocol(PROTO_STRING_CLNP, "CLNP", "clnp"); proto_register_field_array(proto_clnp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); register_dissector("clnp", dissect_clnp, proto_clnp); register_heur_dissector_list("clnp", &clnp_heur_subdissector_list); register_init_routine(clnp_reassemble_init); clnp_module = prefs_register_protocol(proto_clnp, NULL); prefs_register_uint_preference(clnp_module, "tp_nsap_selector", "NSAP selector for Transport Protocol (last byte in hex)", "NSAP selector for Transport Protocol (last byte in hex)", 16, &tp_nsap_selector); prefs_register_bool_preference(clnp_module, "always_decode_transport", "Always try to decode NSDU as transport PDUs", "Always try to decode NSDU as transport PDUs", &always_decode_transport); prefs_register_bool_preference(clnp_module, "reassemble", "Reassemble segmented CLNP datagrams", "Whether segmented CLNP datagrams should be reassembled", &clnp_reassemble); }