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);
}
