/*FUNCTION:------------------------------------------------------
* NAME
* zbee_security_register
* DESCRIPTION
* Called by proto_register_zbee_nwk() to initialize the security
* dissectors.
* PARAMETERS
* module_t zbee_prefs - Prefs module to load preferences under.
* RETURNS
* none
*---------------------------------------------------------------
*/
void zbee_security_register(module_t *zbee_prefs, int proto)
{
static hf_register_info hf[] = {
{ &hf_zbee_sec_key_id,
{ "Key Id", "zbee.sec.key", FT_UINT8, BASE_HEX, VALS(zbee_sec_key_names),
ZBEE_SEC_CONTROL_KEY, NULL, HFILL }},
{ &hf_zbee_sec_nonce,
{ "Extended Nonce", "zbee.sec.ext_nonce", FT_BOOLEAN, 8, NULL, ZBEE_SEC_CONTROL_NONCE,
NULL, HFILL }},
{ &hf_zbee_sec_counter,
{ "Frame Counter", "zbee.sec.counter", FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_zbee_sec_src64,
{ "Extended Source", "zbee.sec.src64", FT_EUI64, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_zbee_sec_key_seqno,
{ "Key Sequence Number", "zbee.sec.key_seqno", FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_zbee_sec_mic,
{ "Message Integrity Code", "zbee.sec.mic", FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_zbee_sec_key_origin,
{ "Key Origin", "zbee.sec.key.origin", FT_FRAMENUM, BASE_NONE, NULL, 0x0,
NULL, HFILL }}
};
static gint *ett[] = {
&ett_zbee_sec,
&ett_zbee_sec_control
};
static uat_field_t key_uat_fields[] = {
UAT_FLD_CSTRING(uat_key_records, string, "Key",
"A 16-byte key in hexadecimal with optional dash-,\n"
"colon-, or space-separator characters, or a\n"
"a 16-character string in double-quotes."),
UAT_FLD_VS(uat_key_records, byte_order, "Byte Order", byte_order_vals,
"Byte order of key."),
UAT_FLD_LSTRING(uat_key_records, label, "Label", "User label for key."),
UAT_END_FIELDS
};
/* If no prefs module was supplied, register our own. */
if (zbee_prefs == NULL) {
zbee_prefs = prefs_register_protocol(proto, NULL);
}
/* Register preferences */
prefs_register_enum_preference(zbee_prefs, "seclevel", "Security Level",
"Specifies the security level to use in the\n"
"decryption process. This value is ignored\n"
"for ZigBee 2004 and unsecured networks.",
&gPREF_zbee_sec_level, zbee_sec_level_enums, FALSE);
zbee_sec_key_table_uat = uat_new("Pre-configured Keys",
sizeof(uat_key_record_t),
"zigbee_pc_keys",
TRUE,
(void*) &uat_key_records,
&num_uat_key_records,
UAT_CAT_FFMT,
NULL, /* TODO: ptr to help manual? */
uat_key_record_copy_cb,
uat_key_record_update_cb,
uat_key_record_free_cb,
NULL, /* TODO: post_update */
key_uat_fields );
prefs_register_uat_preference(zbee_prefs,
"key_table",
"Pre-configured Keys",
"Pre-configured link or network keys.",
zbee_sec_key_table_uat);
proto_register_field_array(proto, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
/* Register the init routine. */
register_init_routine(proto_init_zbee_security);
} /* zbee_security_register */
void proto_register_ppcap(void)
{
static hf_register_info hf[] = {
{ &hf_ppcap_length,
{ "Length", "ppcap.length",
FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL}},
{ &hf_ppcap_payload_type,
{ "Payload Type" , "ppcap.payload_type", FT_STRING,
BASE_NONE, NULL, 0x0 , NULL, HFILL}},
{ &hf_ppcap_reserved,
{ "Reserved", "ppcap.reserved", FT_UINT16,
BASE_DEC, NULL, 0x00, NULL, HFILL}},
{ &hf_ppcap_address_type,
{ "Address Type", "ppcap.address_type", FT_UINT16,
BASE_DEC, VALS(address_type_values), 0x00 , NULL, HFILL}},
#if 0
{ &hf_ppcap_source_address_type,
{ "Source Address Type", "ppcap.source_address_type", FT_UINT16,
BASE_DEC, VALS(address_type_values), 0x00 , NULL, HFILL}},
#endif
{ &hf_ppcap_ssn,
{ "SSN", "ppcap.ssn", FT_UINT16,
BASE_DEC, NULL, 0x00, NULL, HFILL}},
{ &hf_ppcap_spc,
{"OPC", "ppcap.spc", FT_UINT16,
BASE_DEC, NULL, 0x00, NULL, HFILL}},
{ &hf_ppcap_opc,
{ "OPC", "ppcap.opc", FT_UINT16,
BASE_DEC, NULL, 0x00, NULL, HFILL}},
{ &hf_ppcap_source_ip_address1,
{ "Source IP Addresss", "ppcap.source_ip_address1", FT_IPv4,
BASE_NONE, NULL, 0x00, NULL, HFILL}},
{ &hf_ppcap_source_ip_address2,
{ "Source IP Address", "ppcap.source_ip_address2", FT_IPv6,
BASE_NONE, NULL, 0x00, NULL, HFILL}},
{ &hf_ppcap_destreserved,
{ "Reserved", "ppcap.destreserved", FT_UINT16,
BASE_DEC, NULL, 0x00, NULL, HFILL}},
#if 0
{ &hf_ppcap_destination_address_type,
{ "Destination Address Type", "ppcap.destination_address_type", FT_UINT16,
BASE_DEC, VALS(address_type_values), 0x00, NULL, HFILL}},
#endif
{ &hf_ppcap_ssn1,
{ "SSN", "ppcap.ssn1", FT_UINT8,
BASE_DEC, NULL, 0x00, NULL, HFILL}},
{ &hf_ppcap_spc1,
{ "DPC", "ppcap.spc1", FT_UINT24,
BASE_DEC, NULL, 0x00, NULL, HFILL}},
{ &hf_ppcap_dpc,
{ "DPC", "ppcap.dpc", FT_UINT32,
BASE_DEC, NULL, 0x00, NULL, HFILL}},
{ &hf_ppcap_destination_ip_address1,
{ "Destination IP Address", "ppcap.destination_ip_address1", FT_IPv4,
BASE_NONE, NULL, 0x00, NULL, HFILL}},
{ &hf_ppcap_destination_ip_address2,
{ "Destination IP Address", "ppcap.destination_ip_address2", FT_IPv6,
BASE_NONE, NULL, 0x00, NULL, HFILL}},
{ &hf_ppcap_source_nodeid,
{ "Source Node ID", "ppcap.source_nodeid", FT_STRING,
BASE_NONE, NULL, 0x00, NULL, HFILL}},
{ &hf_ppcap_destination_nodeid,
{ "Destination Node ID", "ppcap.destination_address_value", FT_STRING,
BASE_NONE, NULL, 0x00, NULL, HFILL}},
{ &hf_ppcap_info,
{ "Info", "ppcap.info", FT_STRING,
BASE_NONE, NULL, 0x0000, NULL, HFILL}},
{ &hf_ppcap_payload_data,
{ "Payload Data", "ppcap.payload_data", FT_BYTES,
BASE_NONE, NULL, 0x0000, NULL, HFILL}},
};
static gint *ett[]= {
&ett_ppcap,
&ett_ppcap1,
&ett_ppcap_new,
};
proto_ppcap = proto_register_protocol("Proprietary PCAP", "PPCAP", "ppcap");
proto_register_field_array(proto_ppcap , hf , array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
register_dissector("ppcap", dissect_ppcap, proto_ppcap);
}
void
proto_register_fddi(void)
{
static hf_register_info hf[] = {
/*
* XXX - we want this guy to have his own private formatting
* routine, using "fc_to_str()"; if "fc_to_str()" returns
* NULL, just show the hex value, else show the string.
*/
{ &hf_fddi_fc,
{ "Frame Control", "fddi.fc", FT_UINT8, BASE_HEX, NULL, 0x0,
NULL, HFILL }},
{ &hf_fddi_fc_clf,
{ "Class/Length/Format", "fddi.fc.clf", FT_UINT8, BASE_HEX, VALS(clf_vals), FDDI_FC_CLFF,
NULL, HFILL }},
{ &hf_fddi_fc_prio,
{ "Priority", "fddi.fc.prio", FT_UINT8, BASE_DEC, NULL, FDDI_FC_ASYNC_PRI,
NULL, HFILL }},
{ &hf_fddi_fc_smt_subtype,
{ "SMT Subtype", "fddi.fc.smt_subtype", FT_UINT8, BASE_DEC, VALS(smt_subtype_vals), FDDI_FC_ZZZZ,
NULL, HFILL }},
{ &hf_fddi_fc_mac_subtype,
{ "MAC Subtype", "fddi.fc.mac_subtype", FT_UINT8, BASE_DEC, VALS(mac_subtype_vals), FDDI_FC_ZZZZ,
NULL, HFILL }},
{ &hf_fddi_dst,
{ "Destination", "fddi.dst", FT_ETHER, BASE_NONE, NULL, 0x0,
"Destination Hardware Address", HFILL }},
{ &hf_fddi_src,
{ "Source", "fddi.src", FT_ETHER, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_fddi_addr,
{ "Source or Destination Address", "fddi.addr", FT_ETHER, BASE_NONE, NULL, 0x0,
"Source or Destination Hardware Address", HFILL }},
};
static gint *ett[] = {
&ett_fddi,
&ett_fddi_fc,
};
module_t *fddi_module;
proto_fddi = proto_register_protocol("Fiber Distributed Data Interface",
"FDDI", "fddi");
proto_register_field_array(proto_fddi, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
/*
* Called from various dissectors for encapsulated FDDI frames.
* We assume the MAC addresses in them aren't bitswapped.
*/
register_dissector("fddi", dissect_fddi_not_bitswapped, proto_fddi);
fddi_module = prefs_register_protocol(proto_fddi, NULL);
prefs_register_bool_preference(fddi_module, "padding",
"Add 3-byte padding to all FDDI packets",
"Whether the FDDI dissector should add 3-byte padding to all "
"captured FDDI packets (useful with e.g. Tru64 UNIX tcpdump)",
&fddi_padding);
fddi_tap = register_tap("fddi");
}
void
proto_register_nsrp(void)
{
static hf_register_info hf[] = {
{ &hf_nsrp_version,
{ "Version", "nsrp.version",
FT_UINT8, BASE_DEC, NULL, 0,
"NSRP Version", HFILL }
},
{ &hf_nsrp_msg_type,
{ "Type", "nsrp.type",
FT_UINT8, BASE_DEC, nsrp_msg_type_vals, 0,
"NSRP Message Type", HFILL }
},
{ &hf_nsrp_clust_id,
{ "Clust ID", "nsrp.clustid",
FT_UINT8, BASE_DEC, NULL, 0,
"NSRP CLUST ID", HFILL }
},
{ &hf_nsrp_msg_flag,
{ "Flag", "nsrp.flag",
FT_UINT8, BASE_DEC, NULL, 0,
"NSRP FLAG", HFILL }
},
{ &hf_nsrp_len,
{ "Length", "nsrp.length",
FT_UINT16, BASE_DEC, NULL, 0,
"NSRP Length", HFILL }
},
{ &hf_nsrp_ha_port,
{ "Port", "nsrp.haport",
FT_UINT8, BASE_DEC, NULL, 0,
"NSRP HA Port", HFILL }
},
{ &hf_nsrp_not_used,
{ "Not used", "nsrp.notused",
FT_UINT8, BASE_DEC, NULL, 0,
NULL, HFILL }
},
{ &hf_nsrp_dst_unit,
{ "Destination", "nsrp.dst",
FT_UINT32, BASE_DEC, NULL, 0,
"DESTINATION UNIT INFORMATION", HFILL }
},
{ &hf_nsrp_src_unit,
{ "Source", "nsrp.src",
FT_UINT32, BASE_DEC, NULL, 0,
"SOURCE UNIT INFORMATION", HFILL }
},
{ &hf_nsrp_msgtype,
{ "MsgType", "nsrp.msgtype",
FT_UINT8, BASE_DEC, VALS(nsrp_msgtype_vals), 0,
"Message Type", HFILL }
},
{ &hf_nsrp_wst_group,
{ "Wst group", "nsrp.wst",
FT_UINT8, BASE_DEC, NULL, 0,
"NSRP WST GROUP", HFILL }
},
{ &hf_nsrp_hst_group,
{ "Hst group", "nsrp.hst",
FT_UINT8, BASE_DEC, NULL, 0,
"NSRP HST GROUP", HFILL }
},
{ &hf_nsrp_msgflag,
{ "Msgflag", "nsrp.msgflag",
FT_UINT8, BASE_DEC, VALS(nsrp_flag_vals), 0,
"NSRP MSG FLAG", HFILL }
},
{ &hf_nsrp_msglen,
{ "Msg Length", "nsrp.msglen",
FT_UINT16, BASE_DEC, NULL, 0,
"NSRP MESSAGE LENGTH", HFILL }
},
{ &hf_nsrp_encflag,
{ "Enc Flag", "nsrp.encflag",
FT_UINT8, BASE_DEC, VALS(nsrp_encflag_vals), 0,
"NSRP ENCRYPT FLAG", HFILL }
},
{ &hf_nsrp_notused,
{ "Not Used", "nsrp.notused",
FT_UINT8, BASE_DEC, NULL, 0,
NULL, HFILL }
},
{ &hf_nsrp_total_size,
{ "Total Size", "nsrp.totalsize",
FT_UINT32, BASE_DEC, NULL, 0,
"NSRP MSG TOTAL MESSAGE", HFILL }
},
{ &hf_nsrp_ns,
{ "Ns", "nsrp.ns",
FT_UINT16, BASE_DEC, NULL, 0,
NULL, HFILL }
},
{ &hf_nsrp_nr,
{ "Nr", "nsrp.nr",
FT_UINT16, BASE_DEC, NULL, 0,
NULL, HFILL }
},
{ &hf_nsrp_no_used,
{ "Reserved", "nsrp.reserved",
FT_UINT16, BASE_DEC, NULL, 0,
NULL, HFILL }
},
{ &hf_nsrp_checksum,
{ "Checksum", "nsrp.checksum",
FT_UINT16, BASE_HEX, NULL, 0,
"NSRP PACKET CHECKSUM", HFILL }
},
{ &hf_nsrp_authflag,
{ "AuthFlag", "nsrp.authflag",
FT_UINT8, BASE_HEX, NULL, 0,
"NSRP Auth Flag", HFILL }
},
{ &hf_nsrp_priority,
{ "Priority", "nsrp.priority",
FT_UINT8, BASE_HEX, NULL, 0,
"NSRP Priority", HFILL }
},
{ &hf_nsrp_dummy,
{ "Dummy", "nsrp.dummy",
FT_UINT8, BASE_HEX, NULL, 0,
"NSRP Dummy", HFILL }
},
{ &hf_nsrp_authchecksum,
{ "Checksum", "nsrp.authchecksum",
FT_UINT16, BASE_HEX, NULL, 0,
"NSRP AUTH CHECKSUM", HFILL }
},
{ &hf_nsrp_ifnum,
{ "Ifnum", "nsrp.ifnum",
FT_UINT16, BASE_HEX, NULL, 0,
"NSRP IfNum", HFILL }
},
{ &hf_nsrp_data,
{ "Data", "nsrp.data",
FT_STRING, BASE_NONE, NULL, 0,
"PADDING", HFILL }
}
};
static gint *ett[] = {
&ett_nsrp
};
proto_nsrp = proto_register_protocol("Juniper Netscreen Redundant Protocol",
"NSRP", "nsrp");
proto_register_field_array(proto_nsrp, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
}
static header_field_info hfi_png_ihdr_bitdepth PNG_HFI_INIT = {
"Bit Depth", "png.ihdr.bitdepth", FT_UINT8, BASE_DEC,
NULL, 0, NULL, HFILL };
static const value_string colour_type_vals[] = {
{ 0, "Greyscale"},
{ 2, "Truecolour"},
{ 3, "Indexed-colour"},
{ 4, "Greyscale with alpha"},
{ 6, "Truecolour with alpha"},
{ 0, NULL }
};
static header_field_info hfi_png_ihdr_colour_type PNG_HFI_INIT = {
"Colour Type", "png.ihdr.colour_type", FT_UINT8, BASE_DEC,
VALS(colour_type_vals), 0, NULL, HFILL };
static const value_string compression_method_vals[] = {
{ 0, "Deflate"},
{ 0, NULL }
};
static header_field_info hfi_png_ihdr_compression_method PNG_HFI_INIT = {
"Compression Method", "png.ihdr.compression_method", FT_UINT8, BASE_DEC,
VALS(compression_method_vals), 0, NULL, HFILL };
static const value_string filter_method_vals[] = {
{ 0, "Adaptive"},
{ 0, NULL }
};
void proto_register_roofnet(void)
{
static hf_register_info hf[] = {
/* Roofnet Header */
{ &hf_roofnet_version,
{ "Version", "roofnet.version",
FT_UINT8, BASE_DEC, NULL, 0x0, "Roofnet Version", HFILL }
},
{ &hf_roofnet_type,
{ "Type", "roofnet.type",
FT_UINT8, BASE_DEC, VALS(roofnet_pt_vals), 0x0, "Roofnet Message Type", HFILL }
},
{ &hf_roofnet_nlinks,
{ "Number of Links", "roofnet.nlinks",
FT_UINT8, BASE_DEC, NULL, 0x0, "Roofnet Number of Links", HFILL }
},
{ &hf_roofnet_next,
{ "Next Link", "roofnet.next",
FT_UINT8, BASE_DEC, NULL, 0x0, "Roofnet Next Link to Use", HFILL }
},
{ &hf_roofnet_ttl,
{ "Time To Live", "roofnet.ttl",
FT_UINT16, BASE_DEC, NULL, 0x0, "Roofnet Time to Live", HFILL }
},
{ &hf_roofnet_cksum,
{ "Checksum", "roofnet.cksum",
FT_UINT16, BASE_DEC, NULL, 0x0, "Roofnet Header Checksum", HFILL }
},
{ &hf_roofnet_flags,
{ "Flags", "roofnet.flags",
FT_UINT16, BASE_DEC, VALS(roofnet_flags_vals), 0x0, "Roofnet Flags", HFILL }
},
{ &hf_roofnet_data_length,
{ "Data Length", "roofnet.datalength",
FT_UINT16, BASE_DEC, NULL, 0x0, "Data Payload Length", HFILL }
},
{ &hf_roofnet_query_dst,
{ "Query Dst", "roofnet.querydst",
FT_IPv4, BASE_NONE, NULL, 0x0, "Roofnet Query Destination", HFILL }
},
{ &hf_roofnet_seq,
{ "Seq", "roofnet.seq",
FT_UINT32, BASE_DEC, NULL, 0x0, "Roofnet Sequential Number", HFILL }
},
#if 0
{ &hf_roofnet_links,
{ "Links", "roofnet.links",
FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }
},
#endif
{ &hf_roofnet_link_src,
{ "Source IP", "roofnet.link.src",
FT_IPv4, BASE_NONE, NULL, 0x0, "Roofnet Message Source", HFILL }
},
{ &hf_roofnet_link_forward,
{ "Forward", "roofnet.link.forward",
FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
},
{ &hf_roofnet_link_rev,
{ "Rev", "roofnet.link.rev",
FT_UINT32, BASE_DEC, NULL, 0x0, "Revision Number", HFILL }
},
{ &hf_roofnet_link_seq,
{ "Seq", "roofnet.link.seq",
FT_UINT32, BASE_DEC, NULL, 0x0, "Link Sequential Number", HFILL }
},
{ &hf_roofnet_link_age,
{ "Age", "roofnet.link.age",
FT_UINT32, BASE_DEC, NULL, 0x0, "Information Age", HFILL }
},
{ &hf_roofnet_link_dst,
{ "Dst IP", "roofnet.link.dst",
FT_IPv4, BASE_NONE, NULL, 0x0, "Roofnet Message Destination", HFILL }
}
};
/* setup protocol subtree array */
static gint *ett[] = {
&ett_roofnet,
&ett_roofnet_link
};
static ei_register_info ei[] = {
{ &ei_roofnet_too_many_links, { "roofnet.too_many_links", PI_MALFORMED, PI_ERROR, "Too many links", EXPFILL }},
};
expert_module_t* expert_roofnet;
proto_roofnet = proto_register_protocol(
"Roofnet Protocol", /* Name */
"Roofnet", /* Short Name */
"roofnet" /* Abbrev */
);
proto_register_field_array(proto_roofnet, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
expert_roofnet = expert_register_protocol(proto_roofnet);
expert_register_field_array(expert_roofnet, ei, array_length(ei));
}
void
proto_register_dcc(void)
{
static hf_register_info hf[] = {
{ &hf_dcc_len, {
"Packet Length", "dcc.len", FT_UINT16, BASE_DEC,
NULL, 0, NULL, HFILL }},
{ &hf_dcc_pkt_vers, {
"Packet Version", "dcc.pkt_vers", FT_UINT16, BASE_DEC,
NULL, 0, NULL, HFILL }},
{ &hf_dcc_op, {
"Operation Type", "dcc.op", FT_UINT8, BASE_DEC,
VALS(dcc_op_vals), 0, NULL, HFILL }},
{ &hf_dcc_clientid, {
"Client ID", "dcc.clientid", FT_UINT32, BASE_DEC,
NULL, 0, NULL, HFILL }},
{ &hf_dcc_opnums_host, {
"Host", "dcc.opnums.host", FT_UINT32, BASE_DEC,
NULL, 0, NULL, HFILL }},
{ &hf_dcc_opnums_pid, {
"Process ID", "dcc.opnums.pid", FT_UINT32, BASE_DEC,
NULL, 0, NULL, HFILL }},
{ &hf_dcc_opnums_report, {
"Report", "dcc.opnums.report", FT_UINT32, BASE_DEC,
NULL, 0, NULL, HFILL }},
{ &hf_dcc_opnums_retrans, {
"Retransmission", "dcc.opnums.retrans", FT_UINT32, BASE_DEC,
NULL, 0, NULL, HFILL }},
{ &hf_dcc_signature, {
"Signature", "dcc.signature", FT_BYTES, BASE_NONE,
NULL, 0, NULL, HFILL }},
{ &hf_dcc_max_pkt_vers, {
"Maximum Packet Version", "dcc.max_pkt_vers", FT_UINT8, BASE_DEC,
NULL, 0, NULL, HFILL }},
{ &hf_dcc_qdelay_ms, {
"Client Delay", "dcc.qdelay_ms", FT_UINT16, BASE_DEC,
NULL, 0, NULL, HFILL }},
{ &hf_dcc_brand, {
"Server Brand", "dcc.brand", FT_STRING, BASE_NONE,
NULL, 0, NULL, HFILL }},
{ &hf_dcc_ck_type, {
"Type", "dcc.checksum.type", FT_UINT8, BASE_DEC,
VALS(dcc_cktype_vals), 0, "Checksum Type", HFILL }},
{ &hf_dcc_ck_len, {
"Length", "dcc.checksum.length", FT_UINT8, BASE_DEC,
NULL, 0, "Checksum Length", HFILL }},
{ &hf_dcc_ck_sum, {
"Sum", "dcc.checksum.sum", FT_BYTES, BASE_NONE,
NULL, 0, "Checksum", HFILL }},
{ &hf_dcc_target, {
"Target", "dcc.target", FT_UINT32, BASE_HEX,
NULL, 0, NULL, HFILL }},
{ &hf_dcc_date, {
"Date", "dcc.date", FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL,
NULL, 0, NULL, HFILL }},
{ &hf_dcc_adminop, {
"Admin Op", "dcc.adminop", FT_UINT8, BASE_DEC,
VALS(dcc_adminop_vals), 0, NULL, HFILL }},
{ &hf_dcc_adminval, {
"Admin Value", "dcc.adminval", FT_UINT32, BASE_DEC,
NULL, 0, NULL, HFILL }},
{ &hf_dcc_trace, {
"Trace Bits", "dcc.trace", FT_UINT32, BASE_HEX,
NULL, 0, NULL, HFILL }},
{ &hf_dcc_trace_admin, {
"Admin Requests", "dcc.trace.admin", FT_BOOLEAN, 32,
NULL, 0x00000001, NULL, HFILL }},
{ &hf_dcc_trace_anon, {
"Anonymous Requests", "dcc.trace.anon", FT_BOOLEAN, 32,
NULL, 0x00000002, NULL, HFILL }},
{ &hf_dcc_trace_client, {
"Authenticated Client Requests", "dcc.trace.client", FT_BOOLEAN, 32,
NULL, 0x00000004, NULL, HFILL }},
{ &hf_dcc_trace_rlim, {
"Rate-Limited Requests", "dcc.trace.rlim", FT_BOOLEAN, 32,
NULL, 0x00000008, NULL, HFILL }},
{ &hf_dcc_trace_query, {
"Queries and Reports", "dcc.trace.query", FT_BOOLEAN, 32,
NULL, 0x00000010, NULL, HFILL }},
{ &hf_dcc_trace_ridc, {
"RID Cache Messages", "dcc.trace.ridc", FT_BOOLEAN, 32,
NULL, 0x00000020, NULL, HFILL }},
{ &hf_dcc_trace_flood, {
"Input/Output Flooding", "dcc.trace.flood", FT_BOOLEAN, 32,
NULL, 0x00000040, NULL, HFILL }},
{ &hf_dcc_floodop, {
"Flood Control Operation", "dcc.floodop", FT_UINT32, BASE_DEC,
VALS(dcc_floodop_vals), 0, NULL, HFILL }},
};
static gint *ett[] = {
&ett_dcc,
&ett_dcc_op,
&ett_dcc_ck,
&ett_dcc_opnums,
&ett_dcc_trace,
};
proto_dcc = proto_register_protocol("Distributed Checksum Clearinghouse protocol",
"DCC", "dcc");
proto_register_field_array(proto_dcc, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
}
void
proto_register_itdm(void)
{
static hf_register_info hf[] = {
{ &hf_itdm_timestamp,{ "Timestamp", "itdm.timestamp",
FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_itdm_seqnum,{ "Sequence Number", "itdm.seqnum",
FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_itdm_sop_eop,{ "Start/End of Packet", "itdm.sop_eop",
FT_UINT8, BASE_DEC, VALS(sop_eop_vals), 0xc0, NULL, HFILL } },
{ &hf_itdm_last_pack,{ "Last Packet", "itdm.last_pack",
FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x20, NULL, HFILL } },
{ &hf_itdm_pktlen,{ "Packet Length", "itdm.pktlen",
FT_UINT16, BASE_DEC, NULL, 0x07ff, NULL, HFILL } },
{ &hf_itdm_chksum,{ "Checksum", "itdm.chksum",
FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } },
{ &hf_itdm_uid,{ "Flow ID", "itdm.uid",
FT_UINT24, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_itdm_ack,{ "ACK", "itdm.ack",
FT_BOOLEAN, 8, TFS(&ack_tfs), 0x20, NULL, HFILL } },
{ &hf_itdm_act,{ "Activate", "itdm.act",
FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x10, NULL, HFILL } },
{ &hf_itdm_chcmd,{ "Channel Command", "itdm.chcmd",
FT_UINT8, BASE_DEC, VALS(chcmd_vals), 0x0f, NULL, HFILL } },
{ &hf_itdm_chid,{ "Channel ID", "itdm.chid",
FT_UINT24, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_itdm_chloc1,{ "Channel Location 1", "itdm.chloc1",
FT_UINT16, BASE_DEC, NULL, 0x1ff, NULL, HFILL } },
{ &hf_itdm_chloc2,{ "Channel Location 2", "itdm.chloc2",
FT_UINT16, BASE_DEC, NULL, 0x1ff, NULL, HFILL } },
{ &hf_itdm_pktrate,{ "IEEE 754 Packet Rate", "itdm.pktrate",
FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
{ &hf_itdm_cxnsize, { "Connection Size", "itdm.cxnsize",
FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_itdm_ctl_transid, { "Transaction ID", "itdm.ctl_transid",
FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
{ &hf_itdm_ctl_command, { "Control Command", "itdm.ctl_cmd",
FT_UINT8, BASE_DEC, VALS(itdm_ctl_command_vals), 0x0, NULL, HFILL } },
{ &hf_itdm_ctl_flowid, { "Allocated Flow ID", "itdm.ctl_flowid",
FT_UINT24, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_itdm_ctl_dm, { "I-TDM Data Mode", "itdm.ctl_dm",
FT_UINT8, BASE_DEC, VALS(itdm_ctl_data_mode_vals), 0x0, NULL, HFILL } },
{ &hf_itdm_ctl_emts, { "I-TDM Explicit Multi-timeslot Size", "itdm.ctlemts",
FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_itdm_ctl_pktrate, { "I-TDM Packet Rate", "itdm.ctl_pktrate",
FT_UINT32, BASE_HEX, VALS(itdm_ctl_pktrate_vals), 0x0, NULL, HFILL } },
{ &hf_itdm_ctl_ptid, { "Paired Transaction ID", "itdm.ctl_ptid",
FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
{ &hf_itdm_ctl_cksum, { "ITDM Control Message Checksum", "itdm.ctl_cksum",
FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } }
};
static gint *ett[] = {
&ett_itdm,
&ett_itdm_ctl
};
module_t *itdm_module;
proto_itdm = proto_register_protocol("Internal TDM", "ITDM", "itdm");
register_dissector("itdm", dissect_itdm, proto_itdm);
proto_register_field_array(proto_itdm, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
itdm_module = prefs_register_protocol(proto_itdm, proto_reg_handoff_itdm);
prefs_register_uint_preference(itdm_module, "mpls_label",
"ITDM MPLS label (Flow Bundle ID in hex)",
"The MPLS label (aka Flow Bundle ID) used by ITDM traffic.",
16, &gbl_ItdmMPLSLabel);
prefs_register_uint_preference(itdm_module, "ctl_flowno",
"I-TDM Control Protocol Flow Number",
"Flow Number used by I-TDM Control Protocol traffic.",
10, &gbl_ItdmCTLFlowNo);
}
void
proto_register_forces(void)
{
module_t *forces_module;
expert_module_t* expert_forces;
/* Setup list of header fields See Section 1.6.1 for details*/
static hf_register_info hf[] = {
{ &hf_forces_version,
{ "Version", "forces.flags.version",
FT_UINT8, BASE_DEC, NULL, 0xF0, NULL, HFILL
}
},
{ &hf_forces_rsvd,
{ "Rsvd", "forces.flags.rsvd",
FT_UINT8, BASE_DEC, NULL, 0x0F, NULL, HFILL
}
},
{ &hf_forces_messagetype,
{ "Message Type", "forces.messagetype",
FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL
}
},
{ &hf_forces_length,
{ "Header Length", "forces.length",
FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL
}
},
{ &hf_forces_sid,
{ "Source ID", "forces.sid",
FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL
}
},
{ &hf_forces_did,
{ "Destination ID", "forces.did",
FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL
}
},
{ &hf_forces_correlator,
{ "Correlator", "forces.correlator",
FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL
}
},
{ &hf_forces_tlv_type,
{ "Type", "forces.tlv.type",
FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL
}
},
{ &hf_forces_tlv_length,
{ "Length", "forces.tlv.length",
FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL
}
},
/*flags*/
{ &hf_forces_flags,
{ "Flags", "forces.Flags",
FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL
}
},
{ &hf_forces_flags_ack,
{ "ACK indicator", "forces.flags.ack",
FT_UINT32, BASE_DEC, VALS(main_header_flags_ack_vals), 0xC0000000, NULL, HFILL
}
},
{ &hf_forces_flags_pri,
{ "Priority", "forces.flags.pri",
FT_UINT32, BASE_DEC, NULL, 0x38000000, NULL, HFILL
}
},
{ &hf_forces_flags_rsrvd,
{ "Rsrvd", "forces.Flags",
FT_UINT32, BASE_DEC,NULL, 0x07000000, NULL, HFILL
}
},
{ &hf_forces_flags_em,
{ "Execution mode", "forces.flags.em",
FT_UINT32, BASE_DEC, VALS(main_header_flags_em_vals), 0x00C00000, NULL, HFILL
}
},
{ &hf_forces_flags_at,
{ "Atomic Transaction", "forces.flags.at",
FT_UINT32, BASE_DEC, VALS(main_header_flags_at_vals), 0x00200000, NULL, HFILL
}
},
{ &hf_forces_flags_tp,
{ "Transaction phase", "forces.flags.tp",
FT_UINT32, BASE_DEC, VALS(main_header_flags_tp_vals), 0x00180000, NULL, HFILL
}
},
{ &hf_forces_flags_reserved,
{ "Reserved", "forces.flags.reserved",
FT_UINT32, BASE_DEC,NULL, 0x0007ffff, NULL, HFILL
}
},
/*LFBSelectTLV*/
{ &hf_forces_lfbselect_tlv_type_lfb_classid,
{ "Class ID", "forces.lfbselect.tlv.type.lfb.classid",
FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL
}
},
{ &hf_forces_lfbselect_tlv_type_lfb_instanceid,
{ "Instance ID", "forces.fbselect.tlv.type.lfb.instanceid",
FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL
}
},
/*Operation TLV*/
{ &hf_forces_lfbselect_tlv_type_operation_type,
{ "Type", "forces.lfbselect.tlv.type.operation.type",
FT_UINT16, BASE_DEC, VALS(operation_type_vals), 0x0, NULL, HFILL
}
},
{ &hf_forces_lfbselect_tlv_type_operation_length,
{ "Length", "forces.lfbselect.tlv.type.operation.length",
FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL
}
},
{ &hf_forces_lfbselect_tlv_type_operation_path_type,
{ "Type", "forces.lfbselect.tlv.type.operation.path.type",
FT_UINT16, BASE_DEC, VALS(tlv_type_vals), 0x0, NULL, HFILL
}
},
{ &hf_forces_lfbselect_tlv_type_operation_path_length,
{ "Length", "forces.lfbselect.tlv.type.operation.path.length",
FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL
}
},
{ &hf_forces_lfbselect_tlv_type_operation_path_data,
{ "Data", "forces.lfbselect.tlv.type.operation.path.data",
FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL
}
},
{ &hf_forces_lfbselect_tlv_type_operation_path_flags,
{ "Path Data Flags", "forces.lfbselect.tlv.type.operation.path.data.flags",
FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL
}
},
{ &hf_forces_lfbselect_tlv_type_operation_path_flags_selector,
{ "Selector", "forces.lfbselect.tlv.type.operation.path.data.flags.selector",
FT_UINT16, BASE_HEX, NULL, 0x80, NULL, HFILL
}
},
{ &hf_forces_lfbselect_tlv_type_operation_path_flags_reserved,
{ "Reserved", "forces.lfbselect.tlv.type.operation.path.data.flags.reserved",
FT_UINT16, BASE_HEX, NULL, 0x7F, NULL, HFILL
}
},
{ &hf_forces_lfbselect_tlv_type_operation_path_IDcount,
{ "Path Data IDcount", "forces.lfbselect.tlv.type.operation.path.data.IDcount",
FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL
}
},
{ &hf_forces_lfbselect_tlv_type_operation_path_IDs,
{ "Path Data IDs", "forces.lfbselect.tlv.type.operation.path.data.IDs",
FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL
}
},
/*Meta data TLV*/
{ &hf_forces_redirect_tlv_meta_data_tlv_type,
{ "Type", "forces.redirect.tlv.meta.data.tlv.type",
FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL
}
},
{ &hf_forces_redirect_tlv_meta_data_tlv_length,
{ "Length", "forces.redirect.tlv.meta.data.tlv.length",
FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL
}
},
{ &hf_forces_redirect_tlv_meta_data_tlv_meta_data_ilv,
{ "Meta Data ILV", "forces.redirect.tlv.meta.data.tlv.meta.data.ilv",
FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL
}
},
{ &hf_forces_redirect_tlv_meta_data_tlv_meta_data_ilv_id,
{ "ID", "forces.redirect.tlv.meta.data.tlv.meta.data.ilv.id",
FT_UINT32, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL
}
},
{ &hf_forces_redirect_tlv_meta_data_tlv_meta_data_ilv_length,
{ "Length", "forces.redirect.tlv.meta.data.tlv.meta.data.ilv.length",
FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL
}
},
{ &hf_forces_redirect_tlv_redirect_data_tlv_type,
{ "Type", "forces.redirect.tlv.redirect.data.tlv.type",
FT_UINT16, BASE_DEC, VALS(tlv_type_vals), 0x0, NULL, HFILL
}
},
{ &hf_forces_redirect_tlv_redirect_data_tlv_length,
{ "Length", "forces.redirect.tlv.redirect.data.tlv.length",
FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL
}
},
{ &hf_forces_asresult_association_setup_result,
{ "Association Setup Result", "forces.teardown.reason",
FT_UINT32, BASE_DEC, VALS(association_setup_result_at_vals), 0x0, NULL, HFILL
}
},
{ &hf_forces_astreason_tlv_teardown_reason,
{ "AStreason TLV TearDonw Reason", "forces.astreason.tlv.teardonw.reason",
FT_UINT32, BASE_DEC, VALS(teardown_reason_at_vals), 0x0, NULL, HFILL
}
},
{ &hf_forces_unknown_tlv,
{ "Data", "forces.unknown.tlv",
FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL
}
}
};
/* Setup protocol subtree array */
static gint *ett[] = {
&ett_forces,
&ett_forces_main_header,
&ett_forces_flags,
&ett_forces_tlv,
&ett_forces_lfbselect_tlv_type,
&ett_forces_lfbselect_tlv_type_operation,
&ett_forces_lfbselect_tlv_type_operation_path,
&ett_forces_lfbselect_tlv_type_operation_path_data,
&ett_forces_lfbselect_tlv_type_operation_path_data_path,
&ett_forces_lfbselect_tlv_type_operation_path_selector,
&ett_forces_path_data_tlv,
&ett_forces_path_data_tlv_flags,
&ett_forces_redirect_tlv_type,
&ett_forces_redirect_tlv_meta_data_tlv,
&ett_forces_redirect_tlv_redirect_data_tlv,
&ett_forces_redirect_tlv_meta_data_tlv_meta_data_ilv,
&ett_forces_asresult_tlv,
&ett_forces_astreason_tlv,
&ett_forces_unknown_tlv
};
static ei_register_info ei[] = {
{ &ei_forces_length, { "forces.length.bad", PI_PROTOCOL, PI_WARN, "ForCES Header length is wrong", EXPFILL }},
{ &ei_forces_tlv_type, { "forces.tlv.type.unknown", PI_PROTOCOL, PI_WARN, "Bogus: The Main_TLV type is unknown", EXPFILL }},
{ &ei_forces_tlv_length, { "forces.tlv.length.bad", PI_PROTOCOL, PI_WARN, "Bogus TLV length", EXPFILL }},
{ &ei_forces_lfbselect_tlv_type_operation_path_length, { "forces.lfbselect.tlv.type.operation.path.length.bad", PI_PROTOCOL, PI_WARN, "Bogus TLV length", EXPFILL }},
{ &ei_forces_lfbselect_tlv_type_operation_type, { "forces.lfbselect.tlv.type.operation.type.unsupported", PI_PROTOCOL, PI_WARN, "ForCES Operation TLV is not supported", EXPFILL }},
{ &ei_forces_redirect_tlv_redirect_data_tlv_length, { "forces.redirect.tlv.redirect.data.tlv.length.bad", PI_PROTOCOL, PI_WARN, "Redirect Data TLV length is wrong", EXPFILL }},
};
/* Register the protocol name and description */
proto_forces = proto_register_protocol("Forwarding and Control Element Separation Protocol", "ForCES", "forces");
/* Required function calls to register the header fields and subtrees used */
proto_register_field_array(proto_forces, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
expert_forces = expert_register_protocol(proto_forces);
expert_register_field_array(expert_forces, ei, array_length(ei));
forces_module = prefs_register_protocol(proto_forces,proto_reg_handoff_forces);
prefs_register_uint_preference(forces_module, "tcp_alternate_port",
"TCP port",
"Decode packets on this TCP port as ForCES",
10, &forces_alternate_tcp_port);
prefs_register_uint_preference(forces_module, "udp_alternate_port",
"UDP port",
"Decode packets on this UDP port as ForCES",
10, &forces_alternate_udp_port);
prefs_register_uint_preference(forces_module, "sctp_high_prio_port",
"SCTP High Priority channel port",
"Decode packets on this sctp port as ForCES",
10, &forces_alternate_sctp_high_prio_channel_port);
prefs_register_uint_preference(forces_module, "sctp_med_prio_port",
"SCTP Meidium Priority channel port",
"Decode packets on this sctp port as ForCES",
10, &forces_alternate_sctp_med_prio_channel_port);
prefs_register_uint_preference(forces_module, "sctp_low_prio_port",
"SCTP Low Priority channel port",
"Decode packets on this sctp port as ForCES",
10, &forces_alternate_sctp_low_prio_channel_port);
}
{ 3, "CMT/RPv2" },
{ 4, "MPTCP-Like" },
{ 0, NULL }
};
/* Setup list of random number generator types */
static const value_string rng_type_values[] = {
{ 0, "Constant" },
{ 1, "Uniform" },
{ 2, "Neg. Exponential" },
{ 0, NULL }
};
/* Setup list of header fields */
static hf_register_info hf[] = {
{ &hf_message_type, { "Type", "npmp.message_type", FT_UINT8, BASE_DEC, VALS(message_type_values), 0x0, NULL, HFILL } },
{ &hf_message_flags, { "Flags", "npmp.message_flags", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_message_length, { "Length", "npmp.message_length", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_acknowledge_flowid, { "Flow ID", "npmp.acknowledge_flowid", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
{ &hf_acknowledge_measurementid, { "Measurement ID", "npmp.acknowledge_measurementid", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } },
{ &hf_acknowledge_streamid, { "Stream ID", "npmp.acknowledge_streamid", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
#if 0
{ &hf_acknowledge_padding, { "Padding", "npmp.acknowledge_padding", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } },
#endif
{ &hf_acknowledge_status, { "Status", "npmp.acknowledge_status", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_addflow_flowid, { "Flow ID", "npmp.addflow_flowid", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
{ &hf_addflow_measurementid, { "Measurement ID", "npmp.addflow_measurementid", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL } },
{ &hf_addflow_streamid, { "Stream ID", "npmp.addflow_streamid", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_addflow_protocol, { "Protocol", "npmp.addflow_protocol", FT_UINT8, BASE_DEC, VALS(proto_type_values), 0x0, NULL, HFILL } },
/* Register the protocol */
void
proto_register_ssprotocol(void)
{
/* Setup list of header fields */
static hf_register_info hf[] = {
{ &hf_message_type, { "Type", "ssprotocol.message_type", FT_UINT8, BASE_DEC, VALS(message_type_values), 0x0, NULL, HFILL } },
{ &hf_message_flags, { "Flags", "ssprotocol.message_flags", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_message_length, { "Length", "ssprotocol.message_length", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_message_status, { "Status", "ssprotocol.message_status", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_message_reason, { "Reason", "ssprotocol.message_reason", FT_UINT32, BASE_DEC, VALS(notrdy_reason_values), 0x0, NULL, HFILL } },
{ &hf_message_info, { "Info", "ssprotocol.message_info", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } },
{ &hf_message_data, { "Data", "ssprotocol.message_data", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } },
{ &hf_message_hash, { "Hash", "ssprotocol.message_hash", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } },
{ &hf_environment_u_bit, { "U-Bit", "ssprotocol.environment_u_bit", FT_BOOLEAN, 8,TFS(&environment_u_bit), SSP_ENVIRONMENT_U_BIT, NULL, HFILL } }
};
/* Setup protocol subtree array */
static gint *ett[] = {
&ett_ssprotocol,
&ett_environment_flags
};
/* Register the protocol name and description */
proto_ssprotocol = proto_register_protocol("Scripting Service Protocol", "SSP", "ssp");
/* Required function calls to register the header fields and subtrees used */
proto_register_field_array(proto_ssprotocol, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
}
/* 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);
}
/* Register Wimax FCH Protocol */
void proto_register_wimax_fch(void)
{
/* TLV display */
static hf_register_info hf[] =
{
{
&hf_fch_used_subchannel_group0,
{
"Sub-Channel Group 0", "wmx.fch.subchannel_group0",
FT_UINT24, BASE_DEC, VALS(used_or_not_used), USED_SUB_CHANNEL_GROUP_0,
NULL, HFILL
}
},
{
&hf_fch_used_subchannel_group1,
{
"Sub-Channel Group 1", "wmx.fch.subchannel_group1",
FT_UINT24, BASE_DEC, VALS(used_or_not_used), USED_SUB_CHANNEL_GROUP_1,
NULL, HFILL
}
},
{
&hf_fch_used_subchannel_group2,
{
"Sub-Channel Group 2", "wmx.fch.subchannel_group2",
FT_UINT24, BASE_DEC, VALS(used_or_not_used), USED_SUB_CHANNEL_GROUP_2,
NULL, HFILL
}
},
{
&hf_fch_used_subchannel_group3,
{
"Sub-Channel Group 3", "wmx.fch.subchannel_group3",
FT_UINT24, BASE_DEC, VALS(used_or_not_used), USED_SUB_CHANNEL_GROUP_3,
NULL, HFILL
}
},
{
&hf_fch_used_subchannel_group4,
{
"Sub-Channel Group 4", "wmx.fch.subchannel_group4",
FT_UINT24, BASE_DEC, VALS(used_or_not_used), USED_SUB_CHANNEL_GROUP_4,
NULL, HFILL
}
},
{
&hf_fch_used_subchannel_group5,
{
"Sub-Channel Group 5", "wmx.fch.subchannel_group5",
FT_UINT24, BASE_DEC, VALS(used_or_not_used), USED_SUB_CHANNEL_GROUP_5,
NULL, HFILL
}
},
{
&hf_fch_reserved_1,
{
"Reserved", "wmx.fch.reserved1",
FT_UINT24, BASE_DEC, NULL, FCH_RESERVED_1,
NULL, HFILL
}
},
{
&hf_fch_repetition_coding_indication,
{
"Repetition Coding Indication", "wmx.fch.repetition_coding_indication",
FT_UINT24, BASE_DEC, VALS(repetition_coding_indications), REPETITION_CODING_INDICATION,
NULL, HFILL
}
},
{
&hf_fch_coding_indication,
{
"Coding Indication", "wmx.fch.coding_indication",
FT_UINT24, BASE_DEC, VALS(coding_indications), CODING_INDICATION,
NULL, HFILL
}
},
{
&hf_fch_dlmap_length,
{
"DL Map Length", "wmx.fch.dl_map_length",
FT_UINT24, BASE_DEC, NULL, DL_MAP_LENGTH,
NULL, HFILL
}
},
{
&hf_fch_reserved_2,
{
"Reserved", "wmx.fch.reserved2",
FT_UINT24, BASE_DEC, NULL, FCH_RESERVED_2,
NULL, HFILL
}
}
};
/* Setup protocol subtree array */
static gint *ett[] =
{
&ett_wimax_fch_decoder,
};
proto_wimax_fch_decoder = proto_wimax;
/* register the field display messages */
proto_register_field_array(proto_wimax_fch_decoder, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
register_dissector("wimax_fch_burst_handler", dissect_wimax_fch_decoder, -1);
}
void
proto_register_dvb_sdt(void)
{
static hf_register_info hf[] = {
{ &hf_dvb_sdt_transport_stream_id, {
"Transport Stream ID", "dvb_sdt.tsid",
FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL
} },
{ &hf_dvb_sdt_reserved1, {
"Reserved", "dvb_sdt.reserved1",
FT_UINT8, BASE_HEX, NULL, DVB_SDT_RESERVED1_MASK, NULL, HFILL
} },
{ &hf_dvb_sdt_version_number, {
"Version Number", "dvb_sdt.version",
FT_UINT8, BASE_HEX, NULL, DVB_SDT_VERSION_NUMBER_MASK, NULL, HFILL
} },
{ &hf_dvb_sdt_current_next_indicator, {
"Current/Next Indicator", "dvb_sdt.cur_next_ind",
FT_UINT8, BASE_DEC, VALS(dvb_sdt_cur_next_vals), DVB_SDT_CURRENT_NEXT_INDICATOR_MASK, NULL, HFILL
} },
{ &hf_dvb_sdt_section_number, {
"Section Number", "dvb_sdt.sect_num",
FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL
} },
{ &hf_dvb_sdt_last_section_number, {
"Last Section Number", "dvb_sdt.last_sect_num",
FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL
} },
{ &hf_dvb_sdt_original_network_id, {
"Original Network ID", "dvb_sdt.original_nid",
FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL
} },
{ &hf_dvb_sdt_reserved2, {
"Reserved", "dvb_sdt.reserved2",
FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL
} },
{ &hf_dvb_sdt_service_id, {
"Service ID", "dvb_sdt.svc.id",
FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL
} },
{ &hf_dvb_sdt_reserved3, {
"Reserved", "dvb_sdt.svc.reserved",
FT_UINT8, BASE_HEX, NULL, DVB_SDT_RESERVED3_MASK, NULL, HFILL
} },
{ &hf_dvb_sdt_eit_schedule_flag, {
"EIT Schedule Flag", "dvb_sdt.svc.eit_schedule_flag",
FT_UINT8, BASE_DEC, NULL, DVB_SDT_EIT_SCHEDULE_FLAG_MASK, NULL, HFILL
} },
{ &hf_dvb_sdt_eit_present_following_flag, {
"EIT Present Following Flag", "dvb_sdt.svc.eit_present_following_flag",
FT_UINT8, BASE_DEC, NULL, DVB_SDT_EIT_PRESENT_FOLLOWING_FLAG_MASK, NULL, HFILL
} },
{ &hf_dvb_sdt_running_status, {
"Running Status", "dvb_sdt.svc.running_status",
FT_UINT16, BASE_HEX, VALS(dvb_sdt_running_status_vals), DVB_SDT_RUNNING_STATUS_MASK, NULL, HFILL
} },
{ &hf_dvb_sdt_free_ca_mode, {
"Free CA Mode", "dvb_sdt.svc.free_ca_mode",
FT_UINT16, BASE_HEX, VALS(dvb_sdt_free_ca_mode_vals), DVB_SDT_FREE_CA_MODE_MASK, NULL, HFILL
} },
{ &hf_dvb_sdt_descriptors_loop_length, {
"Descriptors Loop Length", "dvb_sdt.svc.descr_loop_len",
FT_UINT16, BASE_HEX, NULL, DVB_SDT_DESCRIPTORS_LOOP_LENGTH_MASK, NULL, HFILL
} }
};
static gint *ett[] = {
&ett_dvb_sdt,
&ett_dvb_sdt_service
};
proto_dvb_sdt = proto_register_protocol("DVB Service Description Table", "DVB SDT", "dvb_sdt");
proto_register_field_array(proto_dvb_sdt, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
}
#define STAT_HFI_INIT HFI_INIT(proto_stat)
static const value_string stat1_proc_vals[] = {
{ 0, "NULL" },
{ STATPROC_STAT, "STAT" },
{ STATPROC_MON, "MON" },
{ STATPROC_UNMON, "UNMON" },
{ STATPROC_UNMON_ALL, "UNMON_ALL" },
{ STATPROC_SIMU_CRASH, "SIMU_CRASH" },
{ STATPROC_NOTIFY, "NOTIFY" },
{ 0, NULL }
};
static header_field_info hfi_stat_procedure_v1 STAT_HFI_INIT = {
"V1 Procedure", "stat.procedure_v1", FT_UINT32, BASE_DEC,
VALS(stat1_proc_vals), 0, NULL, HFILL };
static header_field_info hfi_stat_mon_name STAT_HFI_INIT = {
"Name", "stat.name", FT_STRING, BASE_NONE,
NULL, 0, NULL, HFILL };
static header_field_info hfi_stat_stat_res STAT_HFI_INIT = {
"Status Result", "stat.stat_res", FT_NONE,BASE_NONE,
NULL, 0, NULL, HFILL };
static const value_string stat_res[] =
{
{ 0, "STAT_SUCC" },
{ 1, "STAT_FAIL" },
{ 0, NULL }
};
/*--- proto_register_cmip ----------------------------------------------*/
void proto_register_cmip(void) {
/* List of fields */
static hf_register_info hf[] = {
{ &hf_cmip_actionType_OID,
{ "actionType", "cmip.actionType_OID",
FT_STRING, BASE_NONE, NULL, 0,
NULL, HFILL }},
{ &hf_cmip_eventType_OID,
{ "eventType", "cmip.eventType_OID",
FT_STRING, BASE_NONE, NULL, 0,
NULL, HFILL }},
{ &hf_cmip_attributeId_OID,
{ "attributeId", "cmip.attributeId_OID",
FT_STRING, BASE_NONE, NULL, 0,
NULL, HFILL }},
{ &hf_cmip_errorId_OID,
{ "errorId", "cmip.errorId_OID",
FT_STRING, BASE_NONE, NULL, 0,
NULL, HFILL }},
{ &hf_DiscriminatorConstruct,
{ "DiscriminatorConstruct", "cmip.DiscriminatorConstruct",
FT_UINT32, BASE_DEC, NULL, 0,
NULL, HFILL }},
{ &hf_Destination,
{ "Destination", "cmip.Destination",
FT_UINT32, BASE_DEC, NULL, 0,
NULL, HFILL }},
{ &hf_NameBinding,
{ "NameBinding", "cmip.NameBinding",
FT_STRING, BASE_NONE, NULL, 0,
NULL, HFILL }},
{ &hf_ObjectClass,
{ "ObjectClass", "cmip.ObjectClass",
FT_UINT32, BASE_DEC, VALS(cmip_ObjectClass_vals), 0,
NULL, HFILL }},
#include "packet-cmip-hfarr.c"
};
/* List of subtrees */
static gint *ett[] = {
&ett_cmip,
#include "packet-cmip-ettarr.c"
};
static ei_register_info ei[] = {
{ &ei_wrong_spdu_type, { "cmip.wrong_spdu_type", PI_PROTOCOL, PI_ERROR, "Internal error: wrong spdu type", EXPFILL }},
};
expert_module_t* expert_cmip;
/* Register protocol */
proto_cmip = proto_register_protocol(PNAME, PSNAME, PFNAME);
new_register_dissector("cmip", dissect_cmip, proto_cmip);
/* Register fields and subtrees */
proto_register_field_array(proto_cmip, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
expert_cmip = expert_register_protocol(proto_cmip);
expert_register_field_array(expert_cmip, ei, array_length(ei));
#include "packet-cmip-dis-tab.c"
oid_add_from_string("discriminatorId(1)","2.9.3.2.7.1");
attribute_id_dissector_table = register_dissector_table("cmip.attribute_id", "CMIP Attribute Id", FT_UINT32, BASE_DEC);
}
static header_field_info hfi_yami_message_hdr YAMI_HFI_INIT =
{ "Header message", "yami.msg_hdr", FT_NONE, BASE_NONE, NULL, 0x00, NULL, HFILL };
static header_field_info hfi_yami_message_data YAMI_HFI_INIT =
{ "Data message", "yami.msg_data", FT_NONE, BASE_NONE, NULL, 0x00, NULL, HFILL };
/* Parameter */
static header_field_info hfi_yami_param YAMI_HFI_INIT =
{ "Parameter", "yami.param", FT_NONE, BASE_NONE, NULL, 0x00, NULL, HFILL };
static header_field_info hfi_yami_param_name YAMI_HFI_INIT =
{ "Name", "yami.param.name", FT_STRING, BASE_NONE, NULL, 0x00, "Parameter name", HFILL };
static header_field_info hfi_yami_param_type YAMI_HFI_INIT =
{ "Type", "yami.param.type", FT_INT32, BASE_DEC, VALS(yami_param_type_vals), 0x00, "Parameter type", HFILL };
static header_field_info hfi_yami_param_value_bool YAMI_HFI_INIT =
{ "Value", "yami.param.value_bool", FT_BOOLEAN, BASE_NONE, NULL, 0x00, "Parameter value (bool)", HFILL };
static header_field_info hfi_yami_param_value_int YAMI_HFI_INIT =
{ "Value", "yami.param.value_int", FT_INT32, BASE_DEC, NULL, 0x00, "Parameter value (int)", HFILL };
static header_field_info hfi_yami_param_value_long YAMI_HFI_INIT =
{ "Value", "yami.param.value_long", FT_INT64, BASE_DEC, NULL, 0x00, "Parameter value (long)", HFILL };
static header_field_info hfi_yami_param_value_double YAMI_HFI_INIT =
{ "Value", "yami.param.value_double", FT_DOUBLE, BASE_NONE, NULL, 0x00, "Parameter value (double)", HFILL };
static header_field_info hfi_yami_param_value_str YAMI_HFI_INIT =
{ "Value", "yami.param.value_str", FT_STRING, BASE_NONE, NULL, 0x00, "Parameter value (string)", HFILL };
/* Register Wimax Mac Payload Protocol and Dissector */
void proto_register_mac_mgmt_msg_rng_rsp(void)
{
/* RNG-RSP fields display */
static hf_register_info hf[] =
{
{
&hf_rng_rsp_message_type,
{
"MAC Management Message Type", "wmx.macmgtmsgtype.rng_rsp",
FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL
}
},
{
&hf_rng_rsp_broadcast,
{
"AAS broadcast permission", "wmx.rng_rsp.aas_broadcast",
FT_BOOLEAN, BASE_NONE, TFS(&tfs_rng_rsp_aas_broadcast), 0x0, NULL, HFILL
}
},
{
&hf_rng_rsp_akid,
{
"AKId", "wmx.rng_rsp.akid",
FT_BYTES, BASE_NONE, NULL, 0x00, NULL, HFILL
}
},
{
&hf_rng_rsp_basic_cid,
{
"Basic CID", "wmx.rng_rsp.basic_cid",
FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL
}
},
{
&hf_rng_rsp_bs_random,
{
"BS_Random", "wmx.rng_rsp.bs_random",
FT_BYTES, BASE_NONE, NULL, 0x00, NULL, HFILL
}
},
{
&hf_rng_rsp_config_change_count_of_dcd,
{
"Configuration Change Count value of DCD defining DIUC associated burst profile", "wmx.rng_rsp.config_change_count_of_dcd",
FT_UINT16, BASE_HEX, NULL, 0xFF00, NULL, HFILL
}
},
{
&hf_rng_rsp_dl_freq_override,
{
"Downlink Frequency Override", "wmx.rng_rsp.dl_freq_override",
FT_UINT32, BASE_DEC, NULL, 0x00, NULL, HFILL
}
},
{
&hf_rng_rsp_dl_operational_burst_profile_ccc,
{
"CCC value of DCD defining the burst profile associated with DIUC", "wmx.rng_rsp.dl_op_burst_prof.ccc",
FT_UINT16, BASE_DEC, NULL, 0x00FF, NULL, HFILL
}
},
{
&hf_rng_rsp_dl_operational_burst_profile_diuc,
{
"The least robust DIUC that may be used by the BS for transmissions to the SS", "wmx.rng_rsp.dl_op_burst_prof.diuc",
FT_UINT16, BASE_DEC, NULL, 0xFF00, NULL, HFILL
}
},
{
&hf_rng_rsp_dl_operational_burst_profile,
{
"Downlink Operational Burst Profile", "wmx.rng_rsp.dl_op_burst_profile",
FT_UINT16, BASE_HEX, NULL, 0x00, NULL, HFILL
}
},
/* Added the following to help implement RNG-RSP message encoding 33 (Table 367 in IEEE 802.16e-2007) */
{
&hf_rng_rsp_dl_op_burst_profile_ofdma,
{
"Downlink Operational Burst Profile for OFDMA", "wmx.rng_rsp.dl_op_burst_profile_ofdma",
FT_UINT16, BASE_HEX, NULL, 0x00, NULL, HFILL
}
},
{
&hf_rng_rsp_frame_number2,
{
"The 8 least significant bits of the frame number of the OFDMA frame where the SS sent the ranging code", "wmx.rng_rsp.eight_bit_frame_num",
FT_UINT32, BASE_DEC, NULL, 0x000000FF, NULL, HFILL
}
},
{
&hf_rng_rsp_frame_number,
{
"Frame number", "wmx.rng_rsp.frame_number",
FT_UINT24, BASE_DEC, NULL, 0x00, NULL, HFILL
}
},
/* Added the following to help implement RNG-RSP message encoding 22 (IEEE 802.16e-2007) */
{
&hf_rng_rsp_ho_id,
{
"HO ID", "wmx.rng_rsp.ho_id",
FT_UINT8, BASE_HEX, NULL, 0x00, NULL, HFILL
}
},
{
&hf_rng_rsp_ho_process_optimization,
{
"HO Process Optimization", "wmx.rng_rsp.ho_process_optimization",
FT_UINT16, BASE_HEX, NULL, 0x0000, NULL, HFILL
}
},
{
&hf_rng_rsp_ho_process_optimization_0,
{
"Bit #0", "wmx.rng_rsp.ho_process_optimization.omit_sbc_req",
FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_ho_process_optimization_0), 0x0001, NULL, HFILL
}
},
{
&hf_rng_rsp_ho_process_optimization_1_2,
{
"Bits #1-2", "wmx.rng_rsp.ho_process_optimization.perform_reauthentication",
FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_ho_process_optimization_1_2), 0x0006, NULL, HFILL
}
},
{
&hf_rng_rsp_ho_process_optimization_3,
{
"Bit #3", "wmx.rng_rsp.ho_process_optimization.omit_network_address",
FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_ho_process_optimization_3), 0x0008, NULL, HFILL
}
},
{
&hf_rng_rsp_ho_process_optimization_4,
{
"Bit #4", "wmx.rng_rsp.ho_process_optimization.omit_time_of_day",
FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_ho_process_optimization_4), 0x0010, NULL, HFILL
}
},
{
&hf_rng_rsp_ho_process_optimization_5,
{
"Bit #5", "wmx.rng_rsp.ho_process_optimization.omit_tftp",
FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_ho_process_optimization_5), 0x0020, NULL, HFILL
}
},
{
&hf_rng_rsp_ho_process_optimization_6,
{
"Bit #6", "wmx.rng_rsp.ho_process_optimization.transfer_or_sharing",
FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_ho_process_optimization_6), 0x0040, NULL, HFILL
}
},
{
&hf_rng_rsp_ho_process_optimization_7,
{
"Bit #7", "wmx.rng_rsp.ho_process_optimization.omit_reg_req",
FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_ho_process_optimization_7), 0x0080, NULL, HFILL
}
},
{
&hf_rng_rsp_ho_process_optimization_8,
{
"Bit #8", "wmx.rng_rsp.ho_process_optimization.unsolicited_sbc_rsp",
FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_ho_process_optimization_8), 0x0100, NULL, HFILL
}
},
{
&hf_rng_rsp_ho_process_optimization_9,
{
"Bit #9", "wmx.rng_rsp.ho_process_optimization.post_ho_reentry",
FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_ho_process_optimization_9), 0x0200, NULL, HFILL
}
},
{
&hf_rng_rsp_ho_process_optimization_10,
{
"Bit #10", "wmx.rng_rsp.ho_process_optimization.unsolicited_reg_rsp",
FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_ho_process_optimization_10), 0x0400, NULL, HFILL
}
},
{
&hf_rng_rsp_ho_process_optimization_11,
{
"Bit #11", "wmx.rng_rsp.ho_process_optimization.virtual_sdu_sn",
FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_ho_process_optimization_11), 0x0800, NULL, HFILL
}
},
{
&hf_rng_rsp_ho_process_optimization_12,
{
"Bit #12", "wmx.rng_rsp.ho_process_optimization.send_notification",
FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_ho_process_optimization_12), 0x1000, NULL, HFILL
}
},
{
&hf_rng_rsp_ho_process_optimization_13,
{
"Bit #13", "wmx.rng_rsp.ho_process_optimization.trigger_higher_layer_protocol",
FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_ho_process_optimization_13), 0x2000, NULL, HFILL
}
},
{
&hf_rng_rsp_ho_process_optimization_14,
{
"Bit #14: Reserved", "wmx.rng_rsp.ho_process_optimization.reserved",
FT_UINT16, BASE_HEX, NULL, 0x4000, NULL, HFILL
}
},
{
&hf_rng_rsp_ho_process_optimization_15,
{
"Bit #15: Reserved", "wmx.rng_rsp.ho_process_optimization.reserved",
FT_UINT16, BASE_HEX, NULL, 0x8000, NULL, HFILL
}
},
{
&hf_rng_invalid_tlv,
{
"Invalid TLV", "wmx.rng_rsp.invalid_tlv",
FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL
}
},
{
&hf_rng_rsp_least_robust_diuc,
{
"Least Robust DIUC that may be used by the BS for transmissions to the MS", "wmx.rng_rsp.least_robust_diuc",
FT_UINT16, BASE_HEX, NULL, 0x000F, NULL, HFILL
}
},
{
&hf_rng_rsp_location_update_response,
{
"Location Update Response", "wmx.rng_rsp.location_update_response",
FT_UINT8, BASE_DEC, VALS(vals_rng_rsp_location_update_response), 0xFF, NULL, HFILL
}
},
{
&hf_rng_rsp_offset_freq_adjust,
{
"Offset Frequency Adjust", "wmx.rng_rsp.offset_freq_adjust",
FT_INT32, BASE_DEC, NULL, 0x00, NULL, HFILL
}
},
{
&hf_rng_rsp_opportunity_number,
{
"Initial ranging opportunity number", "wmx.rng_rsp.opportunity_number",
FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL
}
},
{
&hf_rng_rsp_paging_cycle,
{
"Paging Cycle", "wmx.rng_rsp.paging_cycle",
FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL
}
},
{
&hf_rng_rsp_paging_group_id,
{
"Paging Group ID", "wmx.rng_rsp.paging_group_id",
FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL
}
},
{
&hf_rng_rsp_paging_information,
{
"Paging Information", "wmx.rng_rsp.paging_information",
FT_BYTES, BASE_NONE, NULL, 0x00, NULL, HFILL
}
},
{
&hf_rng_rsp_paging_offset,
{
"Paging Offset", "wmx.rng_rsp.paging_offset",
FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL
}
},
{
&hf_rng_rsp_power_level_adjust,
{
"Power Level Adjust", "wmx.rng_rsp.power_level_adjust",
FT_FLOAT, BASE_NONE, NULL, 0x00, NULL, HFILL
}
},
{
&hf_rng_rsp_primary_mgmt_cid,
{
"Primary Management CID", "wmx.rng_rsp.primary_mgmt_cid",
FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL
}
},
{
&hf_rng_rsp_ranging_code_index,
{
"The ranging code index that was sent by the SS", "wmx.rng_rsp.ranging_code_index",
FT_UINT32, BASE_DEC, NULL, 0x0000FF00, NULL, HFILL
}
},
{
&hf_rng_rsp_ranging_status,
{
"Ranging status", "wmx.rng_rsp.ranging_status",
FT_UINT8, BASE_DEC, VALS(vals_rng_rsp_ranging_status), 0x00, NULL, HFILL
}
},
{
&hf_rng_rsp_ranging_subchan,
{
"Ranging code attributes", "wmx.rng_rsp.ranging_subchannel",
FT_UINT32, BASE_HEX, NULL, 0x00, NULL, HFILL
}
},
{
&hf_rng_rsp_repetition_coding_indication,
{
"Repetition Coding Indication", "wmx.rng_rsp.repetition_coding_indication",
FT_UINT16, BASE_HEX, VALS(vals_rng_rsp_repetition_coding_indication), 0x00F0, NULL, HFILL
}
},
{
&hf_rng_req_reserved,
{
"Reserved", "wmx.rng_rsp.reserved",
FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL
}
},
{
&hf_rng_rsp_resource_retain_flag,
{
"The connection information for the MS is", "wmx.rng_rsp.resource_retain_flag",
FT_BOOLEAN, BASE_NONE, TFS(&tfs_rng_rsp_resource_retain_flag), 0x0, NULL, HFILL
}
},
{
&hf_rng_rsp_service_level_prediction,
{
"Service Level Prediction", "wmx.rng_rsp.service_level_prediction",
FT_UINT8, BASE_DEC, VALS(vals_rng_rsp_level_of_service), 0x00, NULL, HFILL
}
},
{
&hf_rng_rsp_ss_mac_address,
{
"SS MAC Address", "wmx.rng_rsp.ss_mac_address",
FT_ETHER, BASE_NONE, NULL, 0x00, NULL, HFILL
}
},
{
&hf_rng_rsp_subchannel_reference,
{
"OFDMA subchannel reference used to transmit the ranging code", "wmx.rng_rsp.subchannel_reference",
FT_UINT32, BASE_DEC, NULL, 0x003f0000, NULL, HFILL
}
},
{
&hf_rng_rsp_time_symbol_reference,
{
"OFDM time symbol reference used to transmit the ranging code", "wmx.rng_rsp.time_symbol_reference",
FT_UINT32, BASE_DEC, NULL, 0xFFC00000, NULL, HFILL
}
},
{
&hf_rng_rsp_timing_adjust,
{
"Timing Adjust", "wmx.rng_rsp.timing_adjust",
FT_FLOAT, BASE_NONE, NULL, 0x00, NULL, HFILL
}
},
{
&hf_rng_rsp_ul_channel_id,
{
"Uplink Channel ID", "wmx.rng_rsp.ul_chan_id",
FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL
}
},
{
&hf_rng_rsp_ul_chan_id_override,
{
"Uplink channel ID Override", "wmx.rng_rsp.ul_chan_id_override",
FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL
}
},
{
&hf_tlv_type,
{
"Unknown TLV Type", "wmx.rng_rsp.unknown_tlv_type",
FT_BYTES, BASE_NONE, NULL, 0x00, NULL, HFILL
}
},
{
&hf_tlv_value,
{
"Value", "wmx.rng_rsp.tlv_value",
FT_BYTES, BASE_NONE, NULL, 0x00, NULL, HFILL
}
}
};
/* Setup protocol subtree array */
static gint *ett[] =
{
&ett_mac_mgmt_msg_rng_rsp_decoder,
&ett_rng_rsp_message_tree
};
proto_mac_mgmt_msg_rng_rsp_decoder = proto_mac_mgmt_msg_rng_req_decoder;
proto_register_field_array(proto_mac_mgmt_msg_rng_rsp_decoder, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
}
/** Register application layer types. */
void registerApplicationLayerTypes(int proto)
{
/** header field definitions */
static hf_register_info hf[] =
{
{ &hf_opcua_nodeid_encodingmask,
{ "NodeId EncodingMask", "application.nodeid.encodingmask", FT_UINT8, BASE_HEX, VALS(g_nodeidmasks), 0x0, NULL, HFILL }
},
{ &hf_opcua_app_nsid,
{ "NodeId EncodingMask", "application.nodeid.nsid", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }
},
{ &hf_opcua_app_numeric,
{ "NodeId Identifier Numeric", "application.nodeid.numeric", FT_UINT32, BASE_DEC, VALS(g_requesttypes), 0x0, NULL, HFILL }
}
};
proto_register_field_array(proto, hf, array_length(hf));
}
void
proto_register_ipx(void)
{
static hf_register_info hf_ipx[] = {
{ &hf_ipx_checksum,
{ "Checksum", "ipx.checksum", FT_UINT16, BASE_HEX, NULL, 0x0,
NULL, HFILL }},
{ &hf_ipx_src,
{ "Source Address", "ipx.src", FT_STRING, BASE_NONE, NULL, 0x0,
"Source IPX Address \"network.node\"", HFILL }},
{ &hf_ipx_dst,
{ "Destination Address", "ipx.dst", FT_STRING, BASE_NONE, NULL, 0x0,
"Destination IPX Address \"network.node\"", HFILL }},
{ &hf_ipx_addr,
{ "Src/Dst Address", "ipx.addr", FT_STRING, BASE_NONE, NULL, 0x0,
"Source or Destination IPX Address \"network.node\"", HFILL }},
{ &hf_ipx_len,
{ "Length", "ipx.len", FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_ipx_hops,
{ "Transport Control (Hops)", "ipx.hops", FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_ipx_packet_type,
{ "Packet Type", "ipx.packet_type", FT_UINT8, BASE_HEX, VALS(ipx_packet_type_vals),
0x0,
NULL, HFILL }},
{ &hf_ipx_dnet,
{ "Destination Network","ipx.dst.net", FT_IPXNET, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_ipx_dnode,
{ "Destination Node", "ipx.dst.node", FT_ETHER, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_ipx_dsocket,
{ "Destination Socket", "ipx.dst.socket", FT_UINT16, BASE_HEX|BASE_EXT_STRING,
&ipx_socket_vals_ext, 0x0,
NULL, HFILL }},
{ &hf_ipx_snet,
{ "Source Network","ipx.src.net", FT_IPXNET, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_ipx_snode,
{ "Source Node", "ipx.src.node", FT_ETHER, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_ipx_ssocket,
{ "Source Socket", "ipx.src.socket", FT_UINT16, BASE_HEX|BASE_EXT_STRING,
&ipx_socket_vals_ext, 0x0,
NULL, HFILL }},
{ &hf_ipx_net,
{ "Source or Destination Network","ipx.net", FT_IPXNET, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_ipx_node,
{ "Source or Destination Node", "ipx.node", FT_ETHER, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_ipx_socket,
{ "Source or Destination Socket", "ipx.socket", FT_UINT16, BASE_HEX|BASE_EXT_STRING,
&ipx_socket_vals_ext, 0x0,
NULL, HFILL }},
};
static hf_register_info hf_spx[] = {
{ &hf_spx_connection_control,
{ "Connection Control", "spx.ctl",
FT_UINT8, BASE_HEX, NULL, 0x0,
NULL, HFILL }},
{ &hf_spx_connection_control_sys,
{ "System Packet", "spx.ctl.sys",
FT_BOOLEAN, 8, NULL, SPX_SYS_PACKET,
NULL, HFILL }},
{ &hf_spx_connection_control_send_ack,
{ "Send Ack", "spx.ctl.send_ack",
FT_BOOLEAN, 8, NULL, SPX_SEND_ACK,
NULL, HFILL }},
{ &hf_spx_connection_control_attn,
{ "Attention", "spx.ctl.attn",
FT_BOOLEAN, 8, NULL, SPX_ATTN,
NULL, HFILL }},
{ &hf_spx_connection_control_eom,
{ "End of Message", "spx.ctl.eom",
FT_BOOLEAN, 8, NULL, SPX_EOM,
NULL, HFILL }},
{ &hf_spx_datastream_type,
{ "Datastream type", "spx.type",
FT_UINT8, BASE_HEX, NULL, 0x0,
NULL, HFILL }},
{ &hf_spx_src_id,
{ "Source Connection ID", "spx.src",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_spx_dst_id,
{ "Destination Connection ID", "spx.dst",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_spx_seq_nr,
{ "Sequence Number", "spx.seq",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_spx_ack_nr,
{ "Acknowledgment Number", "spx.ack",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_spx_all_nr,
{ "Allocation Number", "spx.alloc",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_spx_rexmt_frame,
{ "Retransmitted Frame Number", "spx.rexmt_frame",
FT_FRAMENUM, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
};
static hf_register_info hf_ipxrip[] = {
{ &hf_ipxrip_request,
{ "Request", "ipxrip.request",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if IPX RIP request", HFILL }},
{ &hf_ipxrip_response,
{ "Response", "ipxrip.response",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if IPX RIP response", HFILL }}
};
static hf_register_info hf_sap[] = {
{ &hf_sap_request,
{ "Request", "ipxsap.request",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if SAP request", HFILL }},
{ &hf_sap_response,
{ "Response", "ipxsap.response",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if SAP response", HFILL }}
};
static hf_register_info hf_ipxmsg[] = {
{ &hf_msg_conn,
{ "Connection Number", "ipxmsg.conn",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_msg_sigchar,
{ "Signature Char", "ipxmsg.sigchar",
FT_UINT8, BASE_DEC, VALS(ipxmsg_sigchar_vals), 0x0,
NULL, HFILL }}
};
static gint *ett[] = {
&ett_ipx,
&ett_spx,
&ett_spx_connctrl,
&ett_ipxmsg,
&ett_ipxrip,
&ett_serialization,
&ett_ipxsap,
&ett_ipxsap_server,
};
proto_ipx = proto_register_protocol("Internetwork Packet eXchange",
"IPX", "ipx");
proto_register_field_array(proto_ipx, hf_ipx, array_length(hf_ipx));
register_dissector("ipx", dissect_ipx, proto_ipx);
proto_spx = proto_register_protocol("Sequenced Packet eXchange",
"SPX", "spx");
proto_register_field_array(proto_spx, hf_spx, array_length(hf_spx));
proto_ipxrip = proto_register_protocol("IPX Routing Information Protocol",
"IPX RIP", "ipxrip");
proto_register_field_array(proto_ipxrip, hf_ipxrip, array_length(hf_ipxrip));
proto_serialization = proto_register_protocol("NetWare Serialization Protocol",
"NW_SERIAL", "nw_serial");
proto_ipxmsg = proto_register_protocol("IPX Message", "IPX MSG",
"ipxmsg");
proto_register_field_array(proto_ipxmsg, hf_ipxmsg, array_length(hf_ipxmsg));
proto_sap = proto_register_protocol("Service Advertisement Protocol",
"IPX SAP", "ipxsap");
register_dissector("ipxsap", dissect_ipxsap, proto_sap);
proto_register_field_array(proto_sap, hf_sap, array_length(hf_sap));
proto_register_subtree_array(ett, array_length(ett));
ipx_type_dissector_table = register_dissector_table("ipx.packet_type",
"IPX packet type", FT_UINT8, BASE_HEX);
ipx_socket_dissector_table = register_dissector_table("ipx.socket",
"IPX socket", FT_UINT16, BASE_HEX);
spx_socket_dissector_table = register_dissector_table("spx.socket",
"SPX socket", FT_UINT16, BASE_HEX);
register_init_routine(&spx_init_protocol);
register_postseq_cleanup_routine(&spx_postseq_cleanup);
ipx_tap=register_tap("ipx");
}
void
proto_register_cups(void)
{
static hf_register_info hf[] = {
{ &hf_cups_ptype,
{ "Type", "cups.ptype", FT_UINT32, BASE_HEX,
NULL, 0x0, NULL, HFILL }},
{ &hf_cups_ptype_default,
{ "Default printer on network", "cups.ptype.default", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), CUPS_PRINTER_DEFAULT, NULL, HFILL }},
{ &hf_cups_ptype_implicit,
{ "Class", "cups.ptype.implicit", FT_BOOLEAN, 32,
TFS(&tfs_implicit_explicit), CUPS_PRINTER_IMPLICIT, NULL, HFILL }},
{ &hf_cups_ptype_variable,
{ "Can print variable sizes", "cups.ptype.variable", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), CUPS_PRINTER_VARIABLE, NULL, HFILL }},
{ &hf_cups_ptype_large,
{ "Can print up to 36x48 inches", "cups.ptype.large", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), CUPS_PRINTER_LARGE, NULL, HFILL }},
{ &hf_cups_ptype_medium,
{ "Can print up to 18x24 inches", "cups.ptype.medium", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), CUPS_PRINTER_MEDIUM, NULL, HFILL }},
{ &hf_cups_ptype_small,
{ "Can print up to 9x14 inches", "cups.ptype.small", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), CUPS_PRINTER_SMALL, NULL, HFILL }},
{ &hf_cups_ptype_sort,
{ "Can sort", "cups.ptype.sort", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), CUPS_PRINTER_SORT, NULL, HFILL }},
{ &hf_cups_ptype_bind,
{ "Can bind", "cups.ptype.bind", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), CUPS_PRINTER_BIND, NULL, HFILL }},
{ &hf_cups_ptype_cover,
{ "Can cover", "cups.ptype.cover", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), CUPS_PRINTER_COVER, NULL, HFILL }},
{ &hf_cups_ptype_punch,
{ "Can punch holes", "cups.ptype.punch", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), CUPS_PRINTER_PUNCH, NULL, HFILL }},
{ &hf_cups_ptype_collate,
{ "Can do fast collating", "cups.ptype.collate", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), CUPS_PRINTER_COLLATE, NULL, HFILL }},
{ &hf_cups_ptype_copies,
{ "Can do fast copies", "cups.ptype.copies", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), CUPS_PRINTER_COPIES, NULL, HFILL }},
{ &hf_cups_ptype_staple,
{ "Can staple", "cups.ptype.staple", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), CUPS_PRINTER_STAPLE, NULL, HFILL }},
{ &hf_cups_ptype_duplex,
{ "Can duplex", "cups.ptype.duplex", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), CUPS_PRINTER_DUPLEX, NULL, HFILL }},
{ &hf_cups_ptype_color,
{ "Can print color", "cups.ptype.color", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), CUPS_PRINTER_COLOR, NULL, HFILL }},
{ &hf_cups_ptype_bw,
{ "Can print black", "cups.ptype.bw", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), CUPS_PRINTER_BW, NULL, HFILL }},
{ &hf_cups_ptype_remote,
{ "Remote", "cups.ptype.remote", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), CUPS_PRINTER_REMOTE, NULL, HFILL }},
{ &hf_cups_ptype_class,
{ "Class", "cups.ptype.class", FT_BOOLEAN, 32,
TFS(&tfs_printer_class), CUPS_PRINTER_CLASS, NULL, HFILL }},
{ &hf_cups_state,
{ "State", "cups.state", FT_UINT8, BASE_HEX,
VALS(cups_state_values), 0x0, NULL, HFILL }},
{ &hf_cups_uri,
{ "URI", "cups.uri", FT_STRING, BASE_NONE,
NULL, 0x0, NULL, HFILL }},
{ &hf_cups_location,
{ "Location", "cups.location", FT_STRING, BASE_NONE,
NULL, 0x0, NULL, HFILL }},
{ &hf_cups_information,
{ "Information", "cups.information", FT_STRING, BASE_NONE,
NULL, 0x0, NULL, HFILL }},
{ &hf_cups_make_model,
{ "Make and model", "cups.make_model", FT_STRING, BASE_NONE,
NULL, 0x0, NULL, HFILL }},
};
static gint *ett[] = {
&ett_cups,
&ett_cups_ptype
};
proto_cups = proto_register_protocol(
"Common Unix Printing System (CUPS) Browsing Protocol",
"CUPS", "cups");
proto_register_field_array(proto_cups, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
}
void
proto_register_ftp(void)
{
static hf_register_info hf[] = {
{ &hf_ftp_response,
{ "Response", "ftp.response",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if FTP response", HFILL }},
{ &hf_ftp_request,
{ "Request", "ftp.request",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if FTP request", HFILL }},
{ &hf_ftp_request_command,
{ "Request command", "ftp.request.command",
FT_STRING, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_ftp_request_arg,
{ "Request arg", "ftp.request.arg",
FT_STRING, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_ftp_response_code,
{ "Response code", "ftp.response.code",
FT_UINT32, BASE_DEC|BASE_EXT_STRING, &response_table_ext, 0x0,
NULL, HFILL }},
{ &hf_ftp_response_arg,
{ "Response arg", "ftp.response.arg",
FT_STRING, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_ftp_pasv_ip,
{ "Passive IP address", "ftp.passive.ip",
FT_IPv4, BASE_NONE, NULL,0x0,
"Passive IP address (check NAT)", HFILL}},
{ &hf_ftp_pasv_port,
{ "Passive port", "ftp.passive.port",
FT_UINT16, BASE_DEC, NULL,0x0,
"Passive FTP server port", HFILL }},
{ &hf_ftp_pasv_nat,
{"Passive IP NAT", "ftp.passive.nat",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"NAT is active SIP and passive IP different", HFILL }},
{ &hf_ftp_active_ip,
{ "Active IP address", "ftp.active.cip",
FT_IPv4, BASE_NONE, NULL, 0x0,
"Active FTP client IP address", HFILL }},
{ &hf_ftp_active_port,
{"Active port", "ftp.active.port",
FT_UINT16, BASE_DEC, NULL, 0x0,
"Active FTP client port", HFILL }},
{ &hf_ftp_active_nat,
{ "Active IP NAT", "ftp.active.nat",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"NAT is active", HFILL}},
{ &hf_ftp_eprt_af,
{ "Extended active address family", "ftp.eprt.af",
FT_UINT8, BASE_DEC, VALS(eprt_af_vals), 0,
NULL, HFILL }},
{ &hf_ftp_eprt_ip,
{ "Extended active IP address", "ftp.eprt.ip",
FT_IPv4, BASE_NONE, NULL, 0,
"Extended active FTP client IPv4 address", HFILL }},
{ &hf_ftp_eprt_ipv6,
{ "Extended active IPv6 address", "ftp.eprt.ipv6",
FT_IPv6, BASE_NONE, NULL, 0,
"Extended active FTP client IPv6 address", HFILL }},
{ &hf_ftp_eprt_port,
{ "Extended active port", "ftp.eprt.port",
FT_UINT16, BASE_DEC, NULL, 0,
"Extended active FTP client listener port", HFILL }}
};
static gint *ett[] = {
&ett_ftp,
&ett_ftp_reqresp
};
proto_ftp = proto_register_protocol("File Transfer Protocol (FTP)", "FTP",
"ftp");
register_dissector("ftp", dissect_ftp, proto_ftp);
proto_ftp_data = proto_register_protocol("FTP Data", "FTP-DATA", "ftp-data");
register_dissector("ftp-data", dissect_ftpdata, proto_ftp_data);
proto_register_field_array(proto_ftp, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
}
void
proto_register_msdp(void)
{
static hf_register_info hf[] = {
{ &hf_msdp_type,
{ "Type", "msdp.type",
FT_UINT8, BASE_DEC, VALS(msdp_types), 0,
"MSDP TLV type", HFILL }
},
{ &hf_msdp_length,
{ "Length", "msdp.length",
FT_UINT16, BASE_DEC, NULL, 0,
"MSDP TLV Length", HFILL }
},
{ &hf_msdp_sa_entry_count,
{ "Entry Count", "msdp.sa.entry_count",
FT_UINT8, BASE_DEC, NULL, 0,
"MSDP SA Entry Count", HFILL }
},
{ &hf_msdp_sa_rp_addr,
{ "RP Address", "msdp.sa.rp_addr",
FT_IPv4, BASE_NONE, NULL, 0,
"Active source's RP address", HFILL }
},
{ &hf_msdp_sa_reserved,
{ "Reserved", "msdp.sa.reserved",
FT_UINT24, BASE_HEX, NULL, 0,
"Transmitted as zeros and ignored by a receiver", HFILL }
},
{ &hf_msdp_sa_sprefix_len,
{ "Sprefix len", "msdp.sa.sprefix_len",
FT_UINT8, BASE_DEC, NULL, 0,
"The route prefix length associated with source address", HFILL }
},
{ &hf_msdp_sa_group_addr,
{ "Group Address", "msdp.sa.group_addr",
FT_IPv4, BASE_NONE, NULL, 0,
"The group address the active source has sent data to", HFILL }
},
{ &hf_msdp_sa_src_addr,
{ "Source Address", "msdp.sa.src_addr",
FT_IPv4, BASE_NONE, NULL, 0,
"The IP address of the active source", HFILL }
},
{ &hf_msdp_sa_req_res,
{ "Reserved", "msdp.sa_req.res",
FT_UINT8, BASE_HEX, NULL, 0,
"Transmitted as zeros and ignored by a receiver", HFILL }
},
{ &hf_msdp_sa_req_group,
{ "Group Address", "msdp.sa_req.group_addr",
FT_IPv4, BASE_NONE, NULL, 0,
"The group address the MSDP peer is requesting", HFILL }
},
{ &hf_msdp_not_o,
{ "Open-bit", "msdp.not.o",
FT_UINT8, BASE_HEX, NULL, 0x80,
"If clear, the connection will be closed", HFILL }
},
{ &hf_msdp_not_error,
{ "Error Code", "msdp.not.error",
FT_UINT8, BASE_DEC, VALS(error_vals), 0x7F,
"Indicates the type of Notification", HFILL }
},
{ &hf_msdp_not_error_sub,
{ "Error subcode", "msdp.not.error_sub",
FT_UINT8, BASE_DEC, NULL, 0,
NULL, HFILL }
},
{ &hf_msdp_not_group_address,
{ "Group address", "msdp.not.group_address",
FT_IPv4, BASE_NONE, NULL, 0,
"Group address in Notification messages", HFILL }
},
{ &hf_msdp_not_rp_address,
{ "RP address", "msdp.not.rp_address",
FT_IPv4, BASE_NONE, NULL, 0,
"RP address in Notification messages", HFILL }
},
{ &hf_msdp_not_source_address,
{ "Source address", "msdp.not.source_address",
FT_IPv4, BASE_NONE, NULL, 0,
"Source address in Notification messages", HFILL }
},
{ &hf_msdp_not_res,
{ "Reserved", "msdp.not.res",
FT_UINT24, BASE_HEX, NULL, 0,
"Reserved field in Notification messages", HFILL }
},
{ &hf_msdp_not_entry_count,
{ "Entry Count", "msdp.not.entry_count",
FT_UINT24, BASE_HEX, NULL, 0,
"Entry Count in Notification messages", HFILL }
},
{ &hf_msdp_not_sprefix_len,
{ "Sprefix len", "msdp.not.sprefix_len",
FT_UINT8, BASE_DEC, NULL, 0,
"Source prefix length in Notification messages", HFILL }
},
{ &hf_msdp_tlv_contents,
{ "TLV contents", "msdp.tlv_contents",
FT_BYTES, BASE_NONE, NULL, 0,
NULL, HFILL }
},
{ &hf_msdp_trailing_junk,
{ "Trailing junk", "msdp.trailing_junk",
FT_BYTES, BASE_NONE, NULL, 0,
NULL, HFILL }
},
{ &hf_msdp_unknown_encap,
{ "Packet with unknown encapsulation", "msdp.unknown_encap",
FT_BYTES, BASE_NONE, NULL, 0,
NULL, HFILL }
},
{ &hf_msdp_unknown_data,
{ "Unknown data", "msdp.unknown_data",
FT_BYTES, BASE_NONE, NULL, 0,
NULL, HFILL }
},
};
static gint *ett[] = {
&ett_msdp,
&ett_msdp_sa_entry,
&ett_msdp_sa_enc_data,
&ett_msdp_not_data,
};
proto_msdp = proto_register_protocol("Multicast Source Discovery Protocol",
"MSDP", "msdp");
proto_register_field_array(proto_msdp, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
}
dissect_q932_ie(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) {
gint offset;
proto_item *ti;
proto_tree *ie_tree;
guint8 ie_type, ie_len;
offset = 0;
ti = proto_tree_add_item(tree, proto_q932, tvb, offset, -1, ENC_NA);
proto_item_set_hidden(ti);
ie_type = tvb_get_guint8(tvb, offset);
ie_len = tvb_get_guint8(tvb, offset + 1);
ie_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_q932_ie, NULL,
val_to_str(ie_type, VALS(q932_str_ie_type), "unknown (0x%02X)"));
proto_tree_add_item(ie_tree, hf_q932_ie_type, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(ie_tree, hf_q932_ie_len, tvb, offset + 1, 1, ENC_BIG_ENDIAN);
offset += 2;
if (tvb_reported_length_remaining(tvb, offset) <= 0)
return offset;
switch (ie_type) {
case Q932_IE_FACILITY :
dissect_q932_facility_ie(tvb, offset, pinfo, ie_tree, ie_len);
break;
case Q932_IE_NOTIFICATION_INDICATOR :
dissect_q932_ni_ie(tvb, offset, pinfo, ie_tree, ie_len);
break;
default:
if (ie_len > 0) {
void
proto_register_btsmp(void)
{
static hf_register_info hf[] = {
{&hf_btsmp_opcode,
{"Opcode", "btsmp.opcode",
FT_UINT8, BASE_HEX, VALS(opcode_vals), 0x0,
NULL, HFILL}
},
{&hf_btsmp_reason,
{"Reason", "btsmp.reason",
FT_UINT8, BASE_HEX, VALS(reason_vals), 0x0,
NULL, HFILL}
},
{&hf_btsmp_io_capabilities,
{"IO Capability", "btsmp.io_capability",
FT_UINT8, BASE_HEX, VALS(io_capability_vals), 0x0,
NULL, HFILL}
},
{&hf_btsmp_oob_data_flags,
{"OOB Data Flags", "btsmp.oob_data_flags",
FT_UINT8, BASE_HEX, VALS(oob_data_flag_vals), 0x0,
NULL, HFILL}
},
{&hf_btsmp_cfm_value,
{"Confirm Value", "btsmp.cfm_value",
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL}
},
{&hf_btsmp_random,
{"Random Value", "btsmp.random_value",
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL}
},
{&hf_btsmp_long_term_key,
{"Long Term Key", "btsmp.long_term_key",
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL}
},
{&hf_btsmp_id_resolving_key,
{"Identity Resolving Key", "btsmp.id_resolving_key",
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL}
},
{&hf_btsmp_signature_key,
{"Signature Key", "btsmp.signature_key",
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL}
},
{&hf_btsmp_bonding_flags,
{"Bonding Flags", "btsmp.bonding_flags",
FT_UINT8, BASE_HEX, VALS(bonding_flag_vals), 0x03,
NULL, HFILL}
},
{&hf_btsmp_mitm_flag,
{"MITM Flag", "btsmp.mitm_flag",
FT_UINT8, BASE_DEC, NULL, 0x04,
NULL, HFILL}
},
{&hf_btsmp_max_enc_key_size,
{"Max Encryption Key Size", "btsmp.max_enc_key_size",
FT_UINT8, BASE_DEC, NULL, 0x00,
NULL, HFILL}
},
{&hf_btsmp_key_dist_enc,
{"Encryption Key (LTK)", "btsmp.key_dist_enc",
FT_UINT8, BASE_DEC, NULL, 0x01,
NULL, HFILL}
},
{&hf_btsmp_key_dist_id,
{"Id Key (IRK)", "btsmp.key_dist_id",
FT_UINT8, BASE_DEC, NULL, 0x02,
NULL, HFILL}
},
{&hf_btsmp_key_dist_sign,
{"Signature Key (CSRK)", "btsmp.key_dist_sign",
FT_UINT8, BASE_DEC, NULL, 0x04,
NULL, HFILL}
},
{&hf_btsmp_ediv,
{"Encrypted Diversifier (EDIV)", "btsmp.ediv",
FT_UINT16, BASE_HEX, NULL, 0x00,
NULL, HFILL}
},
{&hf_btsmp_authreq,
{"AuthReq", "btsmp.authreq",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL}
},
{&hf_btsmp_initiator_key_distribution,
{"Initiator Key Distribution", "btsmp.initiator_key_distribution",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL}
},
{&hf_btsmp_responder_key_distribution,
{"Responder Key Distribution", "btsmp.responder_key_distribution",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL}
},
{&hf_bd_addr,
{ "BD_ADDR", "btsmp.bd_addr",
FT_ETHER, BASE_NONE, NULL, 0x0,
"Bluetooth Device Address", HFILL}
},
{ &hf_address_type,
{ "Address Type", "btsmp.address_type",
FT_UINT8, BASE_HEX, VALS(bluetooth_address_type_vals), 0x0,
NULL, HFILL }
}
};
/* Setup protocol subtree array */
static gint *ett[] = {
&ett_btsmp,
&ett_btsmp_auth_req,
&ett_btsmp_key_dist
};
/* Register the protocol name and description */
proto_btsmp = proto_register_protocol("Bluetooth Security Manager Protocol",
"BT SMP", "btsmp");
btsmp_handle = new_register_dissector("btsmp", dissect_btsmp, proto_btsmp);
/* Required function calls to register the header fields and subtrees used */
proto_register_field_array(proto_btsmp, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
}
static dissector_handle_t sll_handle;
static dissector_handle_t ethertype_handle;
static dissector_handle_t netlink_handle;
static header_field_info *hfi_sll = NULL;
static int proto_sll;
static int sll_tap = -1;
#define SLL_HFI_INIT HFI_INIT(proto_sll)
static header_field_info hfi_sll_pkttype SLL_HFI_INIT =
{ "Packet type", "sll.pkttype", FT_UINT16, BASE_DEC,
VALS(packet_type_vals), 0x0, NULL, HFILL };
/* ARP hardware type? With Linux extensions? */
static header_field_info hfi_sll_hatype SLL_HFI_INIT =
{ "Link-layer address type", "sll.hatype", FT_UINT16, BASE_DEC,
NULL, 0x0, NULL, HFILL };
static header_field_info hfi_sll_halen SLL_HFI_INIT =
{ "Link-layer address length", "sll.halen", FT_UINT16, BASE_DEC,
NULL, 0x0, NULL, HFILL };
/* Source address if it's an Ethernet-type address */
static header_field_info hfi_sll_src_eth SLL_HFI_INIT =
{ "Source", "sll.src.eth", FT_ETHER, BASE_NONE,
NULL, 0x0, "Source link-layer address", HFILL };
void proto_register_pw_satop(void)
{
static hf_register_info hf[] = {
{ &hf_cw ,{"Control Word" ,"pwsatop.cw"
,FT_NONE ,BASE_NONE ,NULL
,0 ,NULL ,HFILL }},
{&hf_cw_bits03,{"Bits 0 to 3" ,"pwsatop.cw.bits03"
,FT_UINT8 ,BASE_DEC ,NULL
,0xf0 ,NULL ,HFILL }},
{&hf_cw_l, {"L bit: TDM payload state" ,"pwsatop.cw.lbit"
,FT_UINT8 ,BASE_DEC ,VALS(pwc_vals_cw_l_bit)
,0x08 ,NULL ,HFILL }},
{&hf_cw_r, {"R bit: Local CE-bound IWF" ,"pwsatop.cw.rbit"
,FT_UINT8 ,BASE_DEC ,VALS(pwc_vals_cw_r_bit)
,0x04 ,NULL ,HFILL }},
{&hf_cw_rsv, {"Reserved" ,"pwsatop.cw.rsv"
,FT_UINT8 ,BASE_DEC ,NULL
,0x03 ,NULL ,HFILL }},
{&hf_cw_frg, {"Fragmentation" ,"pwsatop.cw.frag"
,FT_UINT8 ,BASE_DEC ,VALS(pwc_vals_cw_frag)
,0xc0 ,NULL ,HFILL }},
{&hf_cw_len, {"Length" ,"pwsatop.cw.length"
,FT_UINT8 ,BASE_DEC ,NULL
,0x3f ,NULL ,HFILL }},
{&hf_cw_seq, {"Sequence number" ,"pwsatop.cw.seqno"
,FT_UINT16 ,BASE_DEC ,NULL
,0 ,NULL ,HFILL }},
{&hf_payload ,{"TDM payload" ,"pwsatop.payload"
,FT_BYTES ,BASE_NONE ,NULL
,0 ,NULL ,HFILL }},
{&hf_payload_l ,{"TDM payload length" ,"pwsatop.payload.len"
,FT_INT32 ,BASE_DEC ,NULL
,0 ,NULL ,HFILL }}
};
static gint *ett_array[] = {
&ett
};
static ei_register_info ei[] = {
{ &ei_cw_packet_size_too_small, { "pwsatop.packet_size_too_small", PI_MALFORMED, PI_ERROR, "PW packet size (%d) is too small to carry sensible information", EXPFILL }},
{ &ei_cw_bits03, { "pwsatop.cw.bits03.not_zero", PI_MALFORMED, PI_ERROR, "Bits 0..3 of Control Word must be 0", EXPFILL }},
{ &ei_cw_rsv, { "pwsatop.cw.rsv.not_zero", PI_MALFORMED, PI_ERROR, "RSV bits of Control Word must be 0", EXPFILL }},
{ &ei_cw_frg, { "pwsatop.cw.frag.not_allowed", PI_MALFORMED, PI_ERROR, "Fragmentation of payload is not allowed for SAToP", EXPFILL }},
{ &ei_payload_size_invalid, { "pwsatop.payload.size_invalid", PI_MALFORMED, PI_ERROR, "Bad Length: too small", EXPFILL }},
{ &ei_payload_size_invalid_undecoded, { "pwsatop.payload.undecoded", PI_UNDECODED, PI_NOTE, "SAToP payload: omitted to conserve bandwidth", EXPFILL }},
};
expert_module_t* expert_pwsatop;
proto = proto_register_protocol(pwc_longname_pw_satop, shortname, "pwsatopcw");
proto_register_field_array(proto, hf, array_length(hf));
proto_register_subtree_array(ett_array, array_length(ett_array));
expert_pwsatop = expert_register_protocol(proto);
expert_register_field_array(expert_pwsatop, ei, array_length(ei));
register_dissector("pw_satop_udp", dissect_pw_satop_udp, proto);
return;
}
/* Register the protocol with Wireshark */
void
proto_register_mrp_msrp(void)
{
static hf_register_info hf[] = {
{ &hf_msrp_proto_id,
{ "Protocol Version", "mrp-msrp.protocol_version",
FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }
},
{ &hf_msrp_message, /* Message is a group of fields */
{ "Message", "mrp-msrp.message",
FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }
},
{ &hf_msrp_attribute_type,
{ "Attribute Type", "mrp-msrp.attribute_type",
FT_UINT8, BASE_DEC, VALS(attribute_type_vals), 0x0, NULL, HFILL }
},
{ &hf_msrp_attribute_length,
{ "Attribute Length", "mrp-msrp.attribute_length",
FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }
},
{ &hf_msrp_attribute_list_length,
{ "Attribute List Length", "mrp-msrp.attribute_list_length",
FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }
},
{ &hf_msrp_attribute_list, /* AttributeList is a group of fields */
{ "Attribute List", "mrp-msrp.attribute_list",
FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }
},
{ &hf_msrp_vector_attribute, /* VectorAttribute is a group of fields */
{ "Vector Attribute", "mrp-msrp.vector_attribute",
FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }
},
{ &hf_msrp_vector_header,
{ "Vector Header", "mrp-msrp.vector_header",
FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }
},
{ &hf_msrp_leave_all_event,
{ "Leave All Event", "mrp-msrp.leave_all_event",
FT_UINT16, BASE_DEC, VALS(leave_all_vals), MSRP_LEAVE_ALL_EVENT_MASK, NULL, HFILL }
},
{ &hf_msrp_number_of_values,
{ "Number of Values", "mrp-msrp.number_of_values",
FT_UINT16, BASE_DEC, NULL, MSRP_NUMBER_OF_VALUES_MASK, NULL, HFILL }
},
{ &hf_msrp_first_value, /* FirstValue is a group of fields */
{ "First Value", "mrp-msrp.first_value",
FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }
},
{ &hf_msrp_stream_id,
{ "Stream ID", "mrp-msrp.stream_id",
FT_UINT64, BASE_HEX, NULL, 0x00, NULL, HFILL }
},
{ &hf_msrp_stream_da,
{ "Stream DA", "mrp-msrp.stream_da",
FT_ETHER, BASE_NONE, NULL, 0x00, NULL, HFILL }
},
{ &hf_msrp_vlan_id,
{ "VLAN ID", "mrp-msrp.vlan_id",
FT_UINT16, BASE_HEX, NULL, 0x00, NULL, HFILL }
},
{ &hf_msrp_tspec_max_frame_size,
{ "TSpec Max Frame Size", "mrp-msrp.tspec_max_frame_size",
FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL }
},
{ &hf_msrp_tspec_max_interval_frames,
{ "TSpec Max Frame Interval", "mrp-msrp.tspec_max_interval_frames",
FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL }
},
{ &hf_msrp_priority_and_rank,
{ "Priority and Rank", "mrp-msrp.priority_and_rank",
FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }
},
{ &hf_msrp_priority,
{ "Priority", "mrp-msrp.priority",
FT_UINT8, BASE_DEC, VALS(priority_vals), MSRP_PRIORITY_MASK, NULL, HFILL }
},
{ &hf_msrp_rank,
{ "Rank", "mrp-msrp.rank",
FT_UINT8, BASE_DEC, VALS(rank_vals), MSRP_RANK_MASK, NULL, HFILL }
},
{ &hf_msrp_reserved,
{ "Reserved", "mrp-msrp.reserved",
FT_UINT8, BASE_DEC, VALS(reserved_vals), MSRP_RESERVED_MASK, NULL, HFILL }
},
{ &hf_msrp_accumulated_latency,
{ "Accumulated Latency", "mrp-msrp.accumulated_latency",
FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
},
{ &hf_msrp_failure_bridge_id,
{ "Failure Bridge ID", "mrp-msrp.failure_bridge_id",
FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL }
},
{ &hf_msrp_failure_code,
{ "Failure Code", "mrp-msrp.failure_code",
FT_UINT8, BASE_DEC, VALS(failure_vals), 0x0, NULL, HFILL }
},
{ &hf_msrp_sr_class_id,
{ "SR Class ID", "mrp-msrp.sr_class_id",
FT_UINT8, BASE_DEC, VALS(sr_class_vals), 0x0, NULL, HFILL }
},
{ &hf_msrp_sr_class_priority,
{ "SR Class Priority", "mrp-msrp.sr_class_priority",
FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }
},
{ &hf_msrp_sr_class_vid,
{ "SR Class VID", "mrp-msrp.sr_class_vid",
FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }
},
{ &hf_msrp_three_packed_event,
{ "Attribute Event", "mrp-msrp.three_packed_event",
FT_UINT8, BASE_DEC, VALS(three_packed_vals), 0x0, NULL, HFILL }
},
{ &hf_msrp_four_packed_event,
{ "Declaration Type", "mrp-msrp.four_packed_event",
FT_UINT8, BASE_DEC, VALS(four_packed_vals), 0x0, NULL, HFILL }
},
{ &hf_msrp_end_mark,
{ "End Mark", "mrp-msrp.end_mark",
FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }
},
};
/* Setup protocol subtree array */
static gint *ett[] = {
&ett_msrp,
&ett_msg,
&ett_attr_list,
&ett_vect_attr,
&ett_vector_header,
&ett_first_value,
&ett_priority_and_rank
};
/* Register the protocol name and description */
proto_msrp = proto_register_protocol("Multiple Stream Reservation Protocol",
"MRP-MSRP", "mrp-msrp");
/* Required function calls to register the header fields and subtrees used */
proto_register_field_array(proto_msrp, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
}
void
proto_register_radiotap(void)
{
static const value_string phy_type[] = {
{ 0, "Unknown" },
{ IEEE80211_CHAN_A, "802.11a" },
{ IEEE80211_CHAN_A | IEEE80211_CHAN_HT20, "802.11a (ht20)" },
{ IEEE80211_CHAN_A | IEEE80211_CHAN_HT40U, "802.11a (ht40+)" },
{ IEEE80211_CHAN_A | IEEE80211_CHAN_HT40D, "802.11a (ht40-)" },
{ IEEE80211_CHAN_B, "802.11b" },
{ IEEE80211_CHAN_PUREG, "802.11g (pure-g)" },
{ IEEE80211_CHAN_G, "802.11g" },
{ IEEE80211_CHAN_G | IEEE80211_CHAN_HT20, "802.11g (ht20)" },
{ IEEE80211_CHAN_G | IEEE80211_CHAN_HT40U, "802.11g (ht40+)" },
{ IEEE80211_CHAN_G | IEEE80211_CHAN_HT40D, "802.11g (ht40-)" },
{ IEEE80211_CHAN_T, "802.11a (turbo)" },
{ IEEE80211_CHAN_108PUREG, "802.11g (pure-g, turbo)" },
{ IEEE80211_CHAN_108G, "802.11g (turbo)" },
{ IEEE80211_CHAN_FHSS, "FHSS" },
{ 0, NULL },
};
static const true_false_string preamble_type = {
"Short",
"Long",
};
static hf_register_info hf[] = {
{ &hf_radiotap_version,
{ "Header revision", "radiotap.version",
FT_UINT8, BASE_DEC, NULL, 0x0,
"Version of radiotap header format", HFILL } },
{ &hf_radiotap_pad,
{ "Header pad", "radiotap.pad",
FT_UINT8, BASE_DEC, NULL, 0x0,
"Padding", HFILL } },
{ &hf_radiotap_length,
{ "Header length", "radiotap.length",
FT_UINT16, BASE_DEC, NULL, 0x0,
"Length of header including version, pad, length and data fields", HFILL } },
{ &hf_radiotap_present,
{ "Present flags", "radiotap.present",
FT_UINT32, BASE_HEX, NULL, 0x0, "Bitmask indicating which fields are present", HFILL } },
#define RADIOTAP_MASK_TSFT 0x00000001
#define RADIOTAP_MASK_FLAGS 0x00000002
#define RADIOTAP_MASK_RATE 0x00000004
#define RADIOTAP_MASK_CHANNEL 0x00000008
#define RADIOTAP_MASK_FHSS 0x00000010
#define RADIOTAP_MASK_DBM_ANTSIGNAL 0x00000020
#define RADIOTAP_MASK_DBM_ANTNOISE 0x00000040
#define RADIOTAP_MASK_LOCK_QUALITY 0x00000080
#define RADIOTAP_MASK_TX_ATTENUATION 0x00000100
#define RADIOTAP_MASK_DB_TX_ATTENUATION 0x00000200
#define RADIOTAP_MASK_DBM_TX_ATTENUATION 0x00000400
#define RADIOTAP_MASK_ANTENNA 0x00000800
#define RADIOTAP_MASK_DB_ANTSIGNAL 0x00001000
#define RADIOTAP_MASK_DB_ANTNOISE 0x00002000
#define RADIOTAP_MASK_RX_FLAGS 0x00004000
#define RADIOTAP_MASK_XCHANNEL 0x00040000
#define RADIOTAP_MASK_EXT 0x80000000
/* Boolean 'present' flags */
{ &hf_radiotap_present_tsft,
{ "TSFT", "radiotap.present.tsft",
FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_TSFT,
"Specifies if the Time Synchronization Function Timer field is present", HFILL } },
{ &hf_radiotap_present_flags,
{ "Flags", "radiotap.present.flags",
FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_FLAGS,
"Specifies if the channel flags field is present", HFILL } },
{ &hf_radiotap_present_rate,
{ "Rate", "radiotap.present.rate",
FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_RATE,
"Specifies if the transmit/receive rate field is present", HFILL } },
{ &hf_radiotap_present_channel,
{ "Channel", "radiotap.present.channel",
FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_CHANNEL,
"Specifies if the transmit/receive frequency field is present", HFILL } },
{ &hf_radiotap_present_fhss,
{ "FHSS", "radiotap.present.fhss",
FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_FHSS,
"Specifies if the hop set and pattern is present for frequency hopping radios", HFILL } },
{ &hf_radiotap_present_dbm_antsignal,
{ "DBM Antenna Signal", "radiotap.present.dbm_antsignal",
FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_DBM_ANTSIGNAL,
"Specifies if the antenna signal strength in dBm is present", HFILL } },
{ &hf_radiotap_present_dbm_antnoise,
{ "DBM Antenna Noise", "radiotap.present.dbm_antnoise",
FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_DBM_ANTNOISE,
"Specifies if the RF noise power at antenna field is present", HFILL } },
{ &hf_radiotap_present_lock_quality,
{ "Lock Quality", "radiotap.present.lock_quality",
FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_LOCK_QUALITY,
"Specifies if the signal quality field is present", HFILL } },
{ &hf_radiotap_present_tx_attenuation,
{ "TX Attenuation", "radiotap.present.tx_attenuation",
FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_TX_ATTENUATION,
"Specifies if the transmit power from max power field is present", HFILL } },
{ &hf_radiotap_present_db_tx_attenuation,
{ "DB TX Attenuation", "radiotap.present.db_tx_attenuation",
FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_DB_TX_ATTENUATION,
"Specifies if the transmit power from max power (in dB) field is present", HFILL } },
{ &hf_radiotap_present_dbm_tx_attenuation,
{ "DBM TX Attenuation", "radiotap.present.dbm_tx_attenuation",
FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_DBM_TX_ATTENUATION,
"Specifies if the transmit power from max power (in dBm) field is present", HFILL } },
{ &hf_radiotap_present_antenna,
{ "Antenna", "radiotap.present.antenna",
FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_ANTENNA,
"Specifies if the antenna number field is present", HFILL } },
{ &hf_radiotap_present_db_antsignal,
{ "DB Antenna Signal", "radiotap.present.db_antsignal",
FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_DB_ANTSIGNAL,
"Specifies if the RF signal power at antenna in dB field is present", HFILL } },
{ &hf_radiotap_present_db_antnoise,
{ "DB Antenna Noise", "radiotap.present.db_antnoise",
FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_DB_ANTNOISE,
"Specifies if the RF signal power at antenna in dBm field is present", HFILL } },
{ &hf_radiotap_present_rxflags,
{ "RX flags", "radiotap.present.rxflags",
FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_RX_FLAGS,
"Specifies if the RX flags field is present", HFILL } },
{ &hf_radiotap_present_hdrfcs,
{ "FCS in header", "radiotap.present.fcs",
FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_RX_FLAGS,
"Specifies if the FCS field is present", HFILL } },
{ &hf_radiotap_present_xchannel,
{ "Channel+", "radiotap.present.xchannel",
FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_XCHANNEL,
"Specifies if the extended channel info field is present", HFILL } },
{ &hf_radiotap_present_ext,
{ "Ext", "radiotap.present.ext",
FT_BOOLEAN, 32, NULL, RADIOTAP_MASK_EXT,
"Specifies if there are any extensions to the header present", HFILL } },
/* Boolean 'present.flags' flags */
{ &hf_radiotap_flags,
{ "Flags", "radiotap.flags",
FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } },
{ &hf_radiotap_flags_cfp,
{ "CFP", "radiotap.flags.cfp",
FT_BOOLEAN, 8, NULL, IEEE80211_RADIOTAP_F_CFP,
"Sent/Received during CFP", HFILL } },
{ &hf_radiotap_flags_preamble,
{ "Preamble", "radiotap.flags.preamble",
FT_BOOLEAN, 8, TFS(&preamble_type), IEEE80211_RADIOTAP_F_SHORTPRE,
"Sent/Received with short preamble", HFILL } },
{ &hf_radiotap_flags_wep,
{ "WEP", "radiotap.flags.wep",
FT_BOOLEAN, 8, NULL, IEEE80211_RADIOTAP_F_WEP,
"Sent/Received with WEP encryption", HFILL } },
{ &hf_radiotap_flags_frag,
{ "Fragmentation", "radiotap.flags.frag",
FT_BOOLEAN, 8, NULL, IEEE80211_RADIOTAP_F_FRAG,
"Sent/Received with fragmentation", HFILL } },
{ &hf_radiotap_flags_fcs,
{ "FCS at end", "radiotap.flags.fcs",
FT_BOOLEAN, 8, NULL, IEEE80211_RADIOTAP_F_FCS,
"Frame includes FCS at end", HFILL } },
{ &hf_radiotap_flags_datapad,
{ "Data Pad", "radiotap.flags.datapad",
FT_BOOLEAN, 8, NULL, IEEE80211_RADIOTAP_F_DATAPAD,
"Frame has padding between 802.11 header and payload", HFILL } },
{ &hf_radiotap_flags_badfcs,
{ "Bad FCS", "radiotap.flags.badfcs",
FT_BOOLEAN, 8, NULL, IEEE80211_RADIOTAP_F_BADFCS,
"Frame received with bad FCS", HFILL } },
{ &hf_radiotap_flags_shortgi,
{ "Short GI", "radiotap.flags.shortgi",
FT_BOOLEAN, 8, NULL, IEEE80211_RADIOTAP_F_SHORTGI,
"Frame Sent/Received with HT short Guard Interval", HFILL } },
{ &hf_radiotap_mactime,
{ "MAC timestamp", "radiotap.mactime",
FT_UINT64, BASE_DEC, NULL, 0x0,
"Value in microseconds of the MAC's Time Synchronization Function timer when the first bit of the MPDU arrived at the MAC.", HFILL } },
{ &hf_radiotap_quality,
{ "Signal Quality", "radiotap.quality",
FT_UINT16, BASE_DEC, NULL, 0x0,
"Signal quality (unitless measure)", HFILL } },
{ &hf_radiotap_fcs,
{ "802.11 FCS", "radiotap.fcs",
FT_UINT32, BASE_HEX, NULL, 0x0,
"Frame check sequence of this frame", HFILL } },
{ &hf_radiotap_channel,
{ "Channel", "radiotap.channel",
FT_UINT32, BASE_DEC, NULL, 0x0,
"802.11 channel number that this frame was sent/received on", HFILL } },
{ &hf_radiotap_channel_frequency,
{ "Channel frequency", "radiotap.channel.freq",
FT_UINT32, BASE_DEC, NULL, 0x0,
"Channel frequency in megahertz that this frame was sent/received on", HFILL } },
{ &hf_radiotap_channel_flags,
{ "Channel type", "radiotap.channel.type",
FT_UINT16, BASE_HEX, VALS(phy_type), 0x0,
NULL, HFILL } },
{ &hf_radiotap_channel_flags_turbo,
{ "Turbo", "radiotap.channel.type.turbo",
FT_BOOLEAN, 16, NULL, 0x0010, "Channel Type Turbo", HFILL } },
{ &hf_radiotap_channel_flags_cck,
{ "Complementary Code Keying (CCK)", "radiotap.channel.type.cck",
FT_BOOLEAN, 16, NULL, 0x0020, "Channel Type Complementary Code Keying (CCK) Modulation", HFILL } },
{ &hf_radiotap_channel_flags_ofdm,
{ "Orthogonal Frequency-Division Multiplexing (OFDM)", "radiotap.channel.type.ofdm",
FT_BOOLEAN, 16, NULL, 0x0040, "Channel Type Orthogonal Frequency-Division Multiplexing (OFDM)", HFILL } },
{ &hf_radiotap_channel_flags_2ghz,
{ "2 GHz spectrum", "radiotap.channel.type.2ghz",
FT_BOOLEAN, 16, NULL, 0x0080, "Channel Type 2 GHz spectrum", HFILL } },
{ &hf_radiotap_channel_flags_5ghz,
{ "5 GHz spectrum", "radiotap.channel.type.5ghz",
FT_BOOLEAN, 16, NULL, 0x0100, "Channel Type 5 GHz spectrum", HFILL } },
{ &hf_radiotap_channel_flags_passive,
{ "Passive", "radiotap.channel.type.passive",
FT_BOOLEAN, 16, NULL, 0x0200, "Channel Type Passive", HFILL } },
{ &hf_radiotap_channel_flags_dynamic,
{ "Dynamic CCK-OFDM", "radiotap.channel.type.dynamic",
FT_BOOLEAN, 16, NULL, 0x0400, "Channel Type Dynamic CCK-OFDM Channel", HFILL } },
{ &hf_radiotap_channel_flags_gfsk,
{ "Gaussian Frequency Shift Keying (GFSK)", "radiotap.channel.type.gfsk",
FT_BOOLEAN, 16, NULL, 0x0800, "Channel Type Gaussian Frequency Shift Keying (GFSK) Modulation", HFILL } },
{ &hf_radiotap_channel_flags_gsm,
{ "GSM (900MHz)", "radiotap.channel.type.gsm",
FT_BOOLEAN, 16, NULL, 0x1000, "Channel Type GSM", HFILL } },
{ &hf_radiotap_channel_flags_sturbo,
{ "Static Turbo", "radiotap.channel.type.sturbo",
FT_BOOLEAN, 16, NULL, 0x2000, "Channel Type Status Turbo", HFILL } },
{ &hf_radiotap_channel_flags_half,
{ "Half Rate Channel (10MHz Channel Width)", "radiotap.channel.type.half",
FT_BOOLEAN, 16, NULL, 0x4000, "Channel Type Half Rate", HFILL } },
{ &hf_radiotap_channel_flags_quarter,
{ "Quarter Rate Channel (5MHz Channel Width)", "radiotap.channel.type.quarter",
FT_BOOLEAN, 16, NULL, 0x8000, "Channel Type Quarter Rate", HFILL } },
{ &hf_radiotap_rxflags,
{ "RX flags", "radiotap.rxflags",
FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } },
{ &hf_radiotap_rxflags_badplcp,
{ "Bad PLCP", "radiotap.rxflags.badplcp",
FT_BOOLEAN, 24, NULL, IEEE80211_RADIOTAP_F_RX_BADPLCP,
"Frame with bad PLCP", HFILL } },
{ &hf_radiotap_xchannel,
{ "Channel number", "radiotap.xchannel",
FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_radiotap_xchannel_frequency,
{ "Channel frequency", "radiotap.xchannel.freq",
FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_radiotap_xchannel_flags,
{ "Channel type", "radiotap.xchannel.flags",
FT_UINT32, BASE_HEX, VALS(phy_type), 0x0, NULL, HFILL } },
{ &hf_radiotap_xchannel_flags_turbo,
{ "Turbo", "radiotap.xchannel.type.turbo",
FT_BOOLEAN, 24, NULL, 0x0010, "Channel Type Turbo", HFILL } },
{ &hf_radiotap_xchannel_flags_cck,
{ "Complementary Code Keying (CCK)", "radiotap.xchannel.type.cck",
FT_BOOLEAN, 24, NULL, 0x0020, "Channel Type Complementary Code Keying (CCK) Modulation", HFILL } },
{ &hf_radiotap_xchannel_flags_ofdm,
{ "Orthogonal Frequency-Division Multiplexing (OFDM)", "radiotap.xchannel.type.ofdm",
FT_BOOLEAN, 24, NULL, 0x0040, "Channel Type Orthogonal Frequency-Division Multiplexing (OFDM)", HFILL } },
{ &hf_radiotap_xchannel_flags_2ghz,
{ "2 GHz spectrum", "radiotap.xchannel.type.2ghz",
FT_BOOLEAN, 24, NULL, 0x0080, "Channel Type 2 GHz spectrum", HFILL } },
{ &hf_radiotap_xchannel_flags_5ghz,
{ "5 GHz spectrum", "radiotap.xchannel.type.5ghz",
FT_BOOLEAN, 24, NULL, 0x0100, "Channel Type 5 GHz spectrum", HFILL } },
{ &hf_radiotap_xchannel_flags_passive,
{ "Passive", "radiotap.channel.xtype.passive",
FT_BOOLEAN, 24, NULL, 0x0200, "Channel Type Passive", HFILL } },
{ &hf_radiotap_xchannel_flags_dynamic,
{ "Dynamic CCK-OFDM", "radiotap.xchannel.type.dynamic",
FT_BOOLEAN, 24, NULL, 0x0400, "Channel Type Dynamic CCK-OFDM Channel", HFILL } },
{ &hf_radiotap_xchannel_flags_gfsk,
{ "Gaussian Frequency Shift Keying (GFSK)", "radiotap.xchannel.type.gfsk",
FT_BOOLEAN, 24, NULL, 0x0800, "Channel Type Gaussian Frequency Shift Keying (GFSK) Modulation", HFILL } },
{ &hf_radiotap_xchannel_flags_gsm,
{ "GSM (900MHz)", "radiotap.xchannel.type.gsm",
FT_BOOLEAN, 24, NULL, 0x1000, "Channel Type GSM", HFILL } },
{ &hf_radiotap_xchannel_flags_sturbo,
{ "Static Turbo", "radiotap.xchannel.type.sturbo",
FT_BOOLEAN, 24, NULL, 0x2000, "Channel Type Status Turbo", HFILL } },
{ &hf_radiotap_xchannel_flags_half,
{ "Half Rate Channel (10MHz Channel Width)", "radiotap.xchannel.type.half",
FT_BOOLEAN, 24, NULL, 0x4000, "Channel Type Half Rate", HFILL } },
{ &hf_radiotap_xchannel_flags_quarter,
{ "Quarter Rate Channel (5MHz Channel Width)", "radiotap.xchannel.type.quarter",
FT_BOOLEAN, 24, NULL, 0x8000, "Channel Type Quarter Rate", HFILL } },
{ &hf_radiotap_xchannel_flags_ht20,
{ "HT Channel (20MHz Channel Width)", "radiotap.xchannel.type.ht20",
FT_BOOLEAN, 24, NULL, 0x10000, "Channel Type HT/20", HFILL } },
{ &hf_radiotap_xchannel_flags_ht40u,
{ "HT Channel (40MHz Channel Width with Extension channel above)", "radiotap.xchannel.type.ht40u",
FT_BOOLEAN, 24, NULL, 0x20000, "Channel Type HT/40+", HFILL } },
{ &hf_radiotap_xchannel_flags_ht40d,
{ "HT Channel (40MHz Channel Width with Extension channel below)", "radiotap.xchannel.type.ht40d",
FT_BOOLEAN, 24, NULL, 0x40000, "Channel Type HT/40-", HFILL } },
#if 0
{ &hf_radiotap_xchannel_maxpower,
{ "Max transmit power", "radiotap.xchannel.maxpower",
FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL } },
#endif
{ &hf_radiotap_fhss_hopset,
{ "FHSS Hop Set", "radiotap.fhss.hopset",
FT_UINT8, BASE_DEC, NULL, 0x0,
"Frequency Hopping Spread Spectrum hopset", HFILL } },
{ &hf_radiotap_fhss_pattern,
{ "FHSS Pattern", "radiotap.fhss.pattern",
FT_UINT8, BASE_DEC, NULL, 0x0,
"Frequency Hopping Spread Spectrum hop pattern", HFILL } },
{ &hf_radiotap_datarate,
{ "Data rate", "radiotap.datarate",
FT_UINT32, BASE_DEC, NULL, 0x0,
"Speed this frame was sent/received at", HFILL } },
{ &hf_radiotap_antenna,
{ "Antenna", "radiotap.antenna",
FT_UINT32, BASE_DEC, NULL, 0x0,
"Antenna number this frame was sent/received over (starting at 0)", HFILL } },
{ &hf_radiotap_dbm_antsignal,
{ "SSI Signal (dBm)", "radiotap.dbm_antsignal",
FT_INT32, BASE_DEC, NULL, 0x0,
"RF signal power at the antenna from a fixed, arbitrary value in decibels from one milliwatt", HFILL } },
{ &hf_radiotap_db_antsignal,
{ "SSI Signal (dB)", "radiotap.db_antsignal",
FT_UINT32, BASE_DEC, NULL, 0x0,
"RF signal power at the antenna from a fixed, arbitrary value in decibels", HFILL } },
{ &hf_radiotap_dbm_antnoise,
{ "SSI Noise (dBm)", "radiotap.dbm_antnoise",
FT_INT32, BASE_DEC, NULL, 0x0,
"RF noise power at the antenna from a fixed, arbitrary value in decibels per one milliwatt", HFILL } },
{ &hf_radiotap_db_antnoise,
{ "SSI Noise (dB)", "radiotap.db_antnoise",
FT_UINT32, BASE_DEC, NULL, 0x0,
"RF noise power at the antenna from a fixed, arbitrary value in decibels", HFILL } },
{ &hf_radiotap_tx_attenuation,
{ "Transmit attenuation", "radiotap.txattenuation",
FT_UINT16, BASE_DEC, NULL, 0x0,
"Transmit power expressed as unitless distance from max power set at factory (0 is max power)", HFILL } },
{ &hf_radiotap_db_tx_attenuation,
{ "Transmit attenuation (dB)", "radiotap.db_txattenuation",
FT_UINT16, BASE_DEC, NULL, 0x0,
"Transmit power expressed as decibels from max power set at factory (0 is max power)", HFILL } },
{ &hf_radiotap_txpower,
{ "Transmit power", "radiotap.txpower",
FT_INT32, BASE_DEC, NULL, 0x0,
"Transmit power in decibels per one milliwatt (dBm)", HFILL } },
/* Special variables */
{ &hf_radiotap_fcs_bad,
{ "Bad FCS", "radiotap.fcs_bad",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Specifies if this frame has a bad frame check sequence", HFILL } },
};
static gint *ett[] = {
&ett_radiotap,
&ett_radiotap_present,
&ett_radiotap_flags,
&ett_radiotap_rxflags,
&ett_radiotap_channel_flags,
&ett_radiotap_xchannel_flags
};
module_t *radiotap_module;
proto_radiotap = proto_register_protocol("IEEE 802.11 Radiotap Capture header", "802.11 Radiotap", "radiotap");
proto_register_field_array(proto_radiotap, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
register_dissector("radiotap", dissect_radiotap, proto_radiotap);
radiotap_tap = register_tap("radiotap");
radiotap_module = prefs_register_protocol(proto_radiotap, NULL);
prefs_register_bool_preference(radiotap_module, "bit14_fcs_in_header",
"Assume bit 14 means FCS in header",
"Radiotap has a bit to indicate whether the FCS is still on the frame or not. "
"Some generators (e.g. AirPcap) use a non-standard radiotap flag 14 to put "
"the FCS into the header.",
&radiotap_bit14_fcs);
}
void
proto_register_hpsw(void)
{
static hf_register_info hf[] = {
{ &hf_hpsw_version,
{ "Version", "hpsw.version", FT_UINT8, BASE_HEX,
NULL, 0x0, NULL, HFILL }},
{ &hf_hpsw_type,
{ "Type", "hpsw.type", FT_UINT8, BASE_HEX,
NULL, 0x0, NULL, HFILL }},
{ &hf_hpsw_tlvtype,
{ "Type", "hpsw.tlv_type", FT_UINT8, BASE_HEX,
VALS(hpsw_tlv_type_vals), 0x0, NULL, HFILL }},
{ &hf_hpsw_tlvlength,
{ "Length", "hpsw.tlv_len", FT_UINT8, BASE_DEC,
NULL, 0x0, NULL, HFILL }},
{ &hf_hpsw_device_name,
{ "Device Name", "hpsw.device_name", FT_STRING, BASE_NONE,
NULL, 0x0, NULL, HFILL }},
{ &hf_hpsw_device_version,
{ "Version", "hpsw.device_version", FT_STRING, BASE_NONE,
NULL, 0x0, NULL, HFILL }},
{ &hf_hpsw_config_name,
{ "Config Name", "hpsw.config_name", FT_STRING, BASE_NONE,
NULL, 0x0, NULL, HFILL }},
{ &hf_hpsw_root_mac_addr,
{ "Root MAC Addr", "hpsw.root_mac_addr", FT_ETHER, BASE_NONE,
NULL, 0x0, NULL, HFILL }},
{ &hf_hpsw_ip_addr,
{ "IP Addr", "hpsw.ip_addr", FT_IPv4, BASE_NONE,
NULL, 0x0, NULL, HFILL }},
{ &hf_hpsw_field_6,
{ "Field 6", "hpsw.field_6", FT_UINT16, BASE_HEX,
NULL, 0x0, NULL, HFILL }},
{ &hf_hpsw_domain,
{ "Domain", "hpsw.domain", FT_STRING, BASE_NONE,
NULL, 0x0, NULL, HFILL }},
{ &hf_hpsw_field_8,
{ "Field 8", "hpsw.field_8", FT_UINT16, BASE_HEX,
NULL, 0x0, NULL, HFILL }},
{ &hf_hpsw_field_9,
{ "Field 9", "hpsw.field_9", FT_UINT16, BASE_HEX,
NULL, 0x0, NULL, HFILL }},
{ &hf_hpsw_field_10,
{ "Field 10", "hpsw.field_10", FT_UINT32, BASE_HEX,
NULL, 0x0, NULL, HFILL }},
{ &hf_hpsw_neighbor_mac_addr,
{ "MAC Addr", "hpsw.neighbor_mac_addr", FT_ETHER, BASE_NONE,
NULL, 0x0, NULL, HFILL }},
{ &hf_hpsw_field_12,
{ "Field 12", "hpsw.field_12", FT_UINT8, BASE_HEX,
NULL, 0x0, NULL, HFILL }},
{ &hf_hpsw_own_mac_addr,
{ "Own MAC Addr", "hpsw.own_mac_addr", FT_ETHER, BASE_NONE,
NULL, 0x0, NULL, HFILL }},
{ &hf_hpsw_device_id,
{ "Device ID", "hpsw.device_id", FT_ETHER, BASE_NONE,
NULL, 0x0, NULL, HFILL }},
{ &hf_hpsw_device_id_data,
{ "Data", "hpsw.device_id_data", FT_BYTES, BASE_NONE,
NULL, 0x0, NULL, HFILL }},
{ &hf_hpsw_data,
{ "Data", "hpsw.data", FT_BYTES, BASE_NONE,
NULL, 0x0, NULL, HFILL }},
};
static gint *ett[] = {
&ett_hpsw,
&ett_hpsw_tlv
};
static ei_register_info ei[] = {
{ &ei_hpsw_tlvlength_bad, { "hpsw.tlv_len.bad", PI_PROTOCOL, PI_WARN, "Bad length", EXPFILL }},
};
expert_module_t* expert_hpsw;
proto_hpsw = proto_register_protocol( "HP Switch Protocol", "HPSW", "hpsw");
proto_register_field_array(proto_hpsw, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
expert_hpsw = expert_register_protocol(proto_hpsw);
expert_register_field_array(expert_hpsw, ei, array_length(ei));
register_dissector("hpsw", dissect_hpsw, proto_hpsw);
}