void
proto_register_sbc(void)
{
module_t *module;
expert_module_t* expert_sbc;
static hf_register_info hf[] = {
{ &hf_sbc_fragmented,
{ "Fragmented", "sbc.fragmented",
FT_BOOLEAN, 8, NULL, 0x80,
NULL, HFILL }
},
{ &hf_sbc_starting_packet,
{ "Starting Packet", "sbc.starting_packet",
FT_BOOLEAN, 8, NULL, 0x40,
NULL, HFILL }
},
{ &hf_sbc_last_packet,
{ "Last Packet", "sbc.last_packet",
FT_BOOLEAN, 8, NULL, 0x20,
NULL, HFILL }
},
{ &hf_sbc_rfa,
{ "RFA", "sbc.rfa",
FT_BOOLEAN, 8, NULL, 0x10,
NULL, HFILL }
},
{ &hf_sbc_number_of_frames,
{ "Number of Frames", "sbc.number_of_frames",
FT_UINT8, BASE_DEC, NULL, 0x0F,
NULL, HFILL }
},
{ &hf_sbc_syncword,
{ "Sync Word", "sbc.syncword",
FT_UINT8, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_sbc_sampling_frequency,
{ "Sampling Frequency", "sbc.sampling_frequency",
FT_UINT8, BASE_HEX, VALS(sampling_frequency_vals), 0xC0,
NULL, HFILL }
},
{ &hf_sbc_blocks,
{ "Blocks", "sbc.blocks",
FT_UINT8, BASE_HEX, VALS(blocks_vals), 0x30,
NULL, HFILL }
},
{ &hf_sbc_channel_mode,
{ "Channel Mode", "sbc.channel_mode",
FT_UINT8, BASE_HEX, VALS(channel_mode_vals), 0x0C,
NULL, HFILL }
},
{ &hf_sbc_allocation_method,
{ "Allocation Method", "sbc.allocation_method",
FT_UINT8, BASE_HEX, VALS(allocation_method_vals), 0x02,
NULL, HFILL }
},
{ &hf_sbc_subbands,
{ "Subbands", "sbc.subbands",
FT_UINT8, BASE_HEX, VALS(subbands_vals), 0x01,
NULL, HFILL }
},
{ &hf_sbc_bitpool,
{ "Bitpool", "sbc.bitpool",
FT_UINT8, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_sbc_crc_check,
{ "CRC Check", "sbc.crc_check",
FT_UINT8, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_sbc_expected_data_speed,
{ "Expected data speed", "sbc.expected_speed_data",
FT_UINT32, BASE_DEC|BASE_UNIT_STRING, &units_kibps, 0x00,
NULL, HFILL }
},
{ &hf_sbc_frame_duration,
{ "Frame Duration", "sbc.frame_duration",
FT_DOUBLE, BASE_NONE|BASE_UNIT_STRING, &units_milliseconds, 0x00,
NULL, HFILL }
},
{ &hf_sbc_cumulative_frame_duration,
{ "Cumulative Frame Duration", "sbc.cumulative_frame_duration",
FT_DOUBLE, BASE_NONE|BASE_UNIT_STRING, &units_milliseconds, 0x00,
NULL, HFILL }
},
{ &hf_sbc_delta_time,
{ "Delta time", "sbc.delta_time",
FT_DOUBLE, BASE_NONE|BASE_UNIT_STRING, &units_milliseconds, 0x00,
NULL, HFILL }
},
{ &hf_sbc_delta_time_from_the_beginning,
{ "Delta time from the beginning", "sbc.delta_time_from_the_beginning",
FT_DOUBLE, BASE_NONE|BASE_UNIT_STRING, &units_milliseconds, 0x00,
NULL, HFILL }
},
{ &hf_sbc_cumulative_duration,
{ "Cumulative Music Duration", "sbc.cumulative_music_duration",
FT_DOUBLE, BASE_NONE|BASE_UNIT_STRING, &units_milliseconds, 0x00,
NULL, HFILL }
},
{ &hf_sbc_avrcp_song_position,
{ "AVRCP Song Position", "sbc.avrcp_song_position",
FT_DOUBLE, BASE_NONE|BASE_UNIT_STRING, &units_milliseconds, 0x00,
NULL, HFILL }
},
{ &hf_sbc_diff,
{ "Diff", "sbc.diff",
FT_DOUBLE, BASE_NONE|BASE_UNIT_STRING, &units_milliseconds, 0x00,
NULL, HFILL }
},
{ &hf_sbc_data,
{ "Frame Data", "sbc.data",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
};
static gint *ett[] = {
&ett_sbc,
&ett_sbc_list,
};
static ei_register_info ei[] = {
{ &ei_sbc_syncword, { "sbc.syncword.unexpected", PI_PROTOCOL, PI_WARN, "Unexpected syncword", EXPFILL }},
};
proto_sbc = proto_register_protocol("Bluetooth SBC Codec", "SBC", "sbc");
proto_register_field_array(proto_sbc, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
expert_sbc = expert_register_protocol(proto_sbc);
expert_register_field_array(expert_sbc, ei, array_length(ei));
register_dissector("sbc", dissect_sbc, proto_sbc);
module = prefs_register_protocol_subtree("Bluetooth", proto_sbc, NULL);
prefs_register_static_text_preference(module, "a2dp.version",
"Bluetooth Audio Codec SBC version based on A2DP 1.3",
"Version of codec supported by this dissector.");
}
void
proto_register_docsis_cmstatus (void)
{
/* Setup list of header fields See Section 1.6.1 for details*/
static hf_register_info hf[] = {
{&hf_docsis_cmstatus_tranid,
{"Transaction ID", "docsis_cmstatus.tranid",FT_UINT16, BASE_DEC, NULL, 0x0,NULL, HFILL}
},
/* See Table 10-3 in CM-SP-MULPIv3.0-I14-101008 */
{&hf_docsis_cmstatus_e_t_mdd_t,
{"Secondary Channel MDD timeout", "docsis_cmstatus.mdd_timeout", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL}
},
{&hf_docsis_cmstatus_e_t_qfl_f,
{"QAM/FEC lock failure", "docsis_cmstatus.qam_fec_lock_failure", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL}
},
{&hf_docsis_cmstatus_e_t_s_o,
{"Sequence out-of-range", "docsis_cmstatus.sequence_out_of_range", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL}
},
{&hf_docsis_cmstatus_e_t_mdd_r,
{"Secondary Channel MDD Recovery", "docsis_cmstatus.mdd_recovery", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL}
},
{&hf_docsis_cmstatus_e_t_qfl_r,
{"QAM/FEC Lock Recovery", "docsis_cmstatus.qam_fec_lock_recovery", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL}
},
{&hf_docsis_cmstatus_e_t_t4_t,
{"T4 timeout", "docsis_cmstatus.t4_timeout", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL}
},
{&hf_docsis_cmstatus_e_t_t3_e,
{"T3 retries exceeded", "docsis_cmstatus.t3_retries_exceeded", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL}
},
{&hf_docsis_cmstatus_e_t_rng_s,
{"Successful ranging after T3 retries exceeded", "docsis_cmstatus.successful_ranging_after_t3_retries_exceeded", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL}
},
{&hf_docsis_cmstatus_e_t_cm_b,
{"CM operating on battery backup", "docsis_cmstatus.cm_on_battery", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL}
},
{&hf_docsis_cmstatus_e_t_cm_a,
{"CM returned to A/C power", "docsis_cmstatus.cm_on_ac_power", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL}
},
{&hf_docsis_cmstatus_descr,
{"1.2 Description", "docsis_cmstatus.description",FT_BYTES, BASE_NONE, NULL, 0x0,"Description", HFILL}
},
{&hf_docsis_cmstatus_ds_ch_id,
{"1.4 Downstream Channel ID", "docsis_cmstatus.ds_chid",FT_UINT8, BASE_DEC, NULL, 0x0, "Downstream Channel ID", HFILL}
},
{&hf_docsis_cmstatus_us_ch_id,
{"1.5 Upstream Channel ID", "docsis_cmstatus.us_chid",FT_UINT8, BASE_DEC, NULL, 0x0, "Upstream Channel ID", HFILL}
},
{&hf_docsis_cmstatus_dsid,
{"1.6 DSID", "docsis_cmstatus.dsid", FT_UINT24, BASE_DEC, NULL, 0x0, "DSID", HFILL}
}
};
/* Setup protocol subtree array */
static gint *ett[] = {
&ett_docsis_cmstatus,
&ett_docsis_cmstatus_tlv
};
/* Register the protocol name and description */
proto_docsis_cmstatus = proto_register_protocol ("DOCSIS CM-STATUS Report", "DOCSIS CM-STATUS", "docsis_cmstatus");
/* Required function calls to register the header fields and subtrees used */
proto_register_field_array (proto_docsis_cmstatus, hf, array_length (hf));
proto_register_subtree_array (ett, array_length (ett));
register_dissector ("docsis_cmstatus", dissect_cmstatus, proto_docsis_cmstatus);
}
void
proto_register_nasdaq_itch(void)
{
/* Setup list of header fields See Section 1.6.1 for details*/
static hf_register_info hf[] = {
{ &hf_nasdaq_itch_version,
{ "Version", "nasdaq-itch.version",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_nasdaq_itch_message_type,
{ "Message Type", "nasdaq-itch.message_type",
FT_UINT8, BASE_DEC, VALS(message_types_val), 0x0,
NULL, HFILL }},
{ &hf_nasdaq_itch_second,
{ "Second", "nasdaq-itch.second",
FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_nasdaq_itch_millisecond,
{ "Millisecond", "nasdaq-itch.millisecond",
FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_nasdaq_itch_system_event,
{ "System Event", "nasdaq-itch.system_event",
FT_UINT8, BASE_DEC, VALS(system_event_val), 0x0,
NULL, HFILL }},
{ &hf_nasdaq_itch_market_category,
{ "Market Category", "nasdaq-itch.market_category",
FT_UINT8, BASE_DEC, VALS(market_category_val), 0x0,
NULL, HFILL }},
{ &hf_nasdaq_itch_financial_status,
{ "Financial Status Indicator", "nasdaq-itch.financial_status",
FT_UINT8, BASE_DEC, VALS(financial_status_val), 0x0,
NULL, HFILL }},
{ &hf_nasdaq_itch_stock,
{ "Stock", "nasdaq-itch.stock",
FT_STRING, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_nasdaq_itch_round_lot_size,
{ "Round Lot Size", "nasdaq-itch.round_lot_size",
FT_STRING, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_nasdaq_itch_round_lots_only,
{ "Round Lots Only", "nasdaq-itch.round_lots_only",
FT_UINT8, BASE_DEC, VALS(round_lots_only_val), 0x0,
NULL, HFILL }},
{ &hf_nasdaq_itch_trading_state,
{ "Trading State", "nasdaq-itch.trading_state",
FT_STRING, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_nasdaq_itch_reserved,
{ "Reserved", "nasdaq-itch.reserved",
FT_STRING, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_nasdaq_itch_reason,
{ "Reason", "nasdaq-itch.reason",
FT_STRING, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_nasdaq_itch_order_reference,
{ "Order Reference", "nasdaq-itch.order_reference",
FT_UINT32, BASE_DEC, NULL, 0x0,
"Order reference number", HFILL }},
{ &hf_nasdaq_itch_buy_sell,
{ "Buy/Sell", "nasdaq-itch.buy_sell",
FT_STRING, BASE_NONE, NULL, 0x0,
"Buy/Sell indicator", HFILL }},
{ &hf_nasdaq_itch_shares,
{ "Shares", "nasdaq-itch.shares",
FT_UINT32, BASE_DEC, NULL, 0x0,
"Number of shares", HFILL }},
{ &hf_nasdaq_itch_price,
{ "Price", "nasdaq-itch.price",
FT_DOUBLE, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_nasdaq_itch_attribution,
{ "Attribution", "nasdaq-itch.attribution",
FT_STRING, BASE_NONE, NULL, 0x0,
"Market participant identifier", HFILL }},
{ &hf_nasdaq_itch_executed,
{ "Executed Shares", "nasdaq-itch.executed",
FT_UINT32, BASE_DEC, NULL, 0x0,
"Number of shares executed", HFILL }},
{ &hf_nasdaq_itch_match,
{ "Matched", "nasdaq-itch.match",
FT_STRING, BASE_NONE, NULL, 0x0,
"Match number", HFILL }},
{ &hf_nasdaq_itch_printable,
{ "Printable", "nasdaq-itch.printable",
FT_STRING, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_nasdaq_itch_execution_price,
{ "Execution Price", "nasdaq-itch.execution_price",
FT_DOUBLE, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_nasdaq_itch_canceled,
{ "Canceled Shares", "nasdaq-itch.canceled",
FT_UINT32, BASE_DEC, NULL, 0x0,
"Number of shares to be removed", HFILL }},
{ &hf_nasdaq_itch_cross,
{ "Cross Type", "nasdaq-itch.cross",
FT_STRING, BASE_NONE, NULL, 0x0,
"Cross trade type", HFILL }},
{ &hf_nasdaq_itch_message,
{ "Message", "nasdaq-itch.message",
FT_STRING, BASE_NONE, NULL, 0x0,
NULL, HFILL }}
};
/* Setup protocol subtree array */
static gint *ett[] = {
&ett_nasdaq_itch
};
module_t *nasdaq_itch_module;
/* Register the protocol name and description */
proto_nasdaq_itch = proto_register_protocol("Nasdaq TotalView-ITCH", "NASDAQ-ITCH", "nasdaq_itch");
/* Required function calls to register the header fields and subtrees used */
proto_register_field_array(proto_nasdaq_itch, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
nasdaq_itch_module = prefs_register_protocol(proto_nasdaq_itch, NULL);
prefs_register_bool_preference(nasdaq_itch_module, "chi_x", "Decode Chi X extensions",
"Whether the Nasdaq ITCH dissector should decode Chi X extensions.",
&nasdaq_itch_chi_x);
register_dissector("nasdaq-itch", dissect_nasdaq_itch, proto_nasdaq_itch);
}
void
proto_register_tte_pcf(void)
{
static hf_register_info hf[] = {
{ &hf_tte_pcf,
{ "Protocol Control Frame", "tte.pcf",
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL }
},
{ &hf_tte_pcf_ic,
{ "Integration Cycle", "tte.pcf.ic",
FT_UINT32, BASE_HEX, NULL, 0x0,
NULL, HFILL }
},
{ &hf_tte_pcf_mn,
{ "Membership New", "tte.pcf.mn",
FT_UINT32, BASE_HEX, NULL, 0x0,
NULL, HFILL }
},
{ &hf_tte_pcf_res0,
{ "Reserved 0", "tte.pcf.res0",
FT_UINT32, BASE_HEX, NULL, 0x0,
NULL, HFILL }
},
{ &hf_tte_pcf_sp,
{ "Sync Priority", "tte.pcf.sp",
FT_UINT8, BASE_HEX, NULL, 0x0,
NULL, HFILL }
},
{ &hf_tte_pcf_sd,
{ "Sync Domain", "tte.pcf.sd",
FT_UINT8, BASE_HEX, NULL, 0x0,
NULL, HFILL }
},
{ &hf_tte_pcf_type,
{ "Type", "tte.pcf.type",
FT_UINT8, BASE_HEX, NULL, 0x0F,
NULL, HFILL }
},
{ &hf_tte_pcf_res1,
{ "Reserved 1", "tte.pcf.res1",
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL }
},
{ &hf_tte_pcf_tc,
{ "Transparent Clock", "tte.pcf.tc",
FT_UINT64, BASE_HEX, NULL, 0x0,
NULL, HFILL }
}
};
/* Setup protocol subtree array */
static gint *ett[] = {
&ett_tte_pcf
};
/* Register the protocol name and description */
proto_tte_pcf = proto_register_protocol("TTEthernet Protocol Control Frame",
"TTE PCF", "tte_pcf");
/* Required function calls to register header fields and subtrees used */
proto_register_field_array(proto_tte_pcf, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
register_dissector("tte_pcf", dissect_tte_pcf, proto_tte_pcf);
}
void
proto_register_fw1(void)
{
static hf_register_info hf[] = {
{ &hf_fw1_direction,
{ "Direction", "fw1.direction", FT_STRING, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_fw1_chain,
{ "Chain Position", "fw1.chain", FT_STRING, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_fw1_interface,
{ "Interface", "fw1.interface", FT_STRING, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_fw1_uuid,
{ "UUID", "fw1.uuid", FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
/* registered here but handled in ethertype.c */
{ &hf_fw1_type,
{ "Type", "fw1.type", FT_UINT16, BASE_HEX, VALS(etype_vals), 0x0,
NULL, HFILL }},
{ &hf_fw1_trailer,
{ "Trailer", "fw1.trailer", FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL }
}
};
/* Setup protocol subtree array */
static gint *ett[] = {
&ett_fw1,
};
module_t *fw1_module;
int i;
/* Register the protocol name and description */
proto_fw1 = proto_register_protocol("Checkpoint FW-1", "FW-1", "fw1");
/* Required function calls to register the header fields and subtrees used */
proto_register_field_array(proto_fw1, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
/* Register configuration preferences */
fw1_module = prefs_register_protocol(proto_fw1, NULL);
prefs_register_bool_preference(fw1_module, "summary_in_tree",
"Show FireWall-1 summary in protocol tree",
"Whether the FireWall-1 summary line should be shown in the protocol tree",
&fw1_summary_in_tree);
prefs_register_bool_preference(fw1_module, "with_uuid",
"Monitor file includes UUID",
"Whether the Firewall-1 monitor file includes UUID information",
&fw1_with_uuid);
prefs_register_bool_preference(fw1_module, "iflist_with_chain",
"Interface list includes chain position",
"Whether the interface list includes the chain position",
&fw1_iflist_with_chain);
register_dissector("fw1", dissect_fw1, proto_fw1);
for (i=0; i<MAX_INTERFACES; i++) {
p_interfaces[i] = NULL;
}
register_init_routine(fw1_init);
}
void proto_register_uasip(void)
{
module_t *uasip_module;
static hf_register_info hf_uasip[] = {
{
&hf_uasip_opcode,
{
"Opcode",
"uasip.opcode",
FT_UINT8,
BASE_DEC | BASE_EXT_STRING,
&uaudp_opcode_str_ext,
0x0,
"UA/SIP Opcode",
HFILL
}
},
{
&hf_uasip_version,
{
"Version",
"uasip.version",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
"UA/SIP Version",
HFILL
}
},
{
&hf_uasip_window_size,
{
"Window Size",
"uasip.window_size",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
"UA/SIP Window Size",
HFILL
}
},
{
&hf_uasip_mtu,
{
"MTU",
"uasip.mtu",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
"UA/SIP MTU",
HFILL
}
},
{
&hf_uasip_udp_lost,
{
"UDP Lost",
"uasip.udp_lost",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
"UA/SIP Lost",
HFILL
}
},
{
&hf_uasip_udp_lost_reinit,
{
"UDP lost reinit",
"uasip.udp_lost_reinit",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
"UA/SIP Lost Re-Init",
HFILL
}
},
{
&hf_uasip_keepalive,
{
"Keepalive",
"uasip.keepalive",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
"UA/SIP Keepalive",
HFILL
}
},
{
&hf_uasip_qos_ip_tos,
{
"QoS IP TOS",
"uasip.qos_ip_tos",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
"UA/SIP QoS IP TOS",
HFILL
}
},
{
&hf_uasip_qos_8021_vlid,
{
"QoS 802.1 VLID",
"uasip.qos_8021_vlid",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
"UA/SIP QoS 802.1 VLID",
HFILL
}
},
{
&hf_uasip_qos_8021_pri,
{
"QoS 802.1 PRI",
"uasip.qos_8021_pri",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
"UA/SIP QoS 802.1 PRI",
HFILL
}
},
{
&hf_uasip_expseq,
{
"Sequence Number (expected)",
"uasip.expseq",
FT_UINT16,
BASE_DEC,
NULL,
0x0,
"UA/SIP Expected Sequence Number",
HFILL
}
},
{
&hf_uasip_sntseq,
{
"Sequence Number (sent)",
"uasip.sntseq",
FT_UINT16,
BASE_DEC,
NULL,
0x0,
"UA/SIP Sent Sequence Number",
HFILL
}
},
};
static gint *ett[] =
{
&ett_uasip,
};
proto_uasip = proto_register_protocol("UA/SIP Protocol", "UASIP", "uasip");
uasip_handle = register_dissector("uasip", dissect_uasip, proto_uasip);
proto_register_field_array(proto_uasip, hf_uasip, array_length(hf_uasip));
proto_register_subtree_array(ett, array_length(ett));
uasip_module = prefs_register_protocol(proto_uasip, proto_reg_handoff_uasip);
prefs_register_bool_preference(uasip_module, "aplication_octet_stream", "Try to decode application/octet-stream as UASIP", "UA SIP Protocol enabled", &uasip_enabled);
prefs_register_bool_preference(uasip_module, "noesip", "Try to decode SIP NOE", "NOE SIP Protocol", &noesip_enabled);
prefs_register_string_preference(uasip_module, "proxy_ipaddr", "Proxy IP Address",
"IPv4 address of the proxy (Invalid values will be ignored)",
&pref_proxy_ipaddr_s);
#if 0
uasip_tap = register_tap("uasip");
#endif
}
void
proto_register_ses(void)
{
static hf_register_info hf[] =
{
{
&hf_ses_type,
{
"SPDU Type",
"ses.type",
FT_UINT8,
BASE_DEC,
VALS(ses_vals),
0x0,
NULL, HFILL
}
},
{
&hf_ses_type_0,
{
"SPDU Type",
"ses.type",
FT_UINT8,
BASE_DEC,
VALS(ses_category0_vals),
0x0,
NULL, HFILL
}
},
{
&hf_ses_length,
{
"Length",
"ses.length",
FT_UINT16,
BASE_DEC,
NULL,
0x0,
NULL, HFILL
}
},
#if 0
{
&hf_ses_version,
{
"Version",
"ses.version",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
NULL, HFILL
}
},
#endif
#if 0
{
&hf_ses_reserved,
{
"Reserved",
"ses.reserved",
FT_UINT8,
BASE_DEC,
NULL,
0x0,
NULL, HFILL
}
},
#endif
{
&hf_called_ss_user_reference,
{
"Called SS User Reference",
"ses.called_ss_user_reference",
FT_BYTES, BASE_NONE,
NULL,
0x0,
NULL,
HFILL
}
},
{
&hf_calling_ss_user_reference,
{
"Calling SS User Reference",
"ses.calling_ss_user_reference",
FT_BYTES, BASE_NONE,
NULL,
0x0,
NULL,
HFILL
}
},
{
&hf_common_reference,
{
"Common Reference",
"ses.common_reference",
FT_BYTES, BASE_NONE,
NULL,
0x0,
NULL,
HFILL
}
},
{
&hf_additional_reference_information,
{
"Additional Reference Information",
"ses.additional_reference_information",
FT_BYTES, BASE_NONE,
NULL,
0x0,
NULL,
HFILL
}
},
{
&hf_release_token,
{
"release token",
"ses.release_token",
FT_BOOLEAN, 8,
NULL,
RELEASE_TOKEN,
NULL,
HFILL
}
},
{
&hf_major_activity_token,
{
"major/activity token",
"ses.major.token",
FT_BOOLEAN, 8,
NULL,
MAJOR_ACTIVITY_TOKEN,
NULL,
HFILL
}
},
{
&hf_synchronize_minor_token,
{
"synchronize minor token",
"ses.synchronize_token",
FT_BOOLEAN, 8,
NULL,
SYNCHRONIZE_MINOR_TOKEN,
NULL,
HFILL
}
},
{
&hf_data_token,
{
"data token",
"ses.data_token",
FT_BOOLEAN, 8,
NULL,
DATA_TOKEN,
"data token",
HFILL
}
},
{
&hf_able_to_receive_extended_concatenated_SPDU,
{
"Able to receive extended concatenated SPDU",
"ses.connect.f1",
FT_BOOLEAN, 8,
NULL,
SES_EXT_CONT,
NULL,
HFILL
}
},
{
&hf_session_user_req_flags,
{
"Flags",
"ses.req.flags",
FT_UINT16,
BASE_HEX,
NULL,
0x0,
NULL,
HFILL
}
},
{
&hf_session_exception_report,
{
"Session exception report",
"ses.exception_report.",
FT_BOOLEAN, 16,
NULL,
SES_EXCEPTION_REPORT,
NULL,
HFILL
}
},
{
&hf_data_separation_function_unit,
{
"Data separation function unit",
"ses.data_sep",
FT_BOOLEAN, 16,
NULL,
DATA_SEPARATION_FUNCTION_UNIT,
NULL,
HFILL
}
},
{
&hf_symmetric_synchronize_function_unit,
{
"Symmetric synchronize function unit",
"ses.symm_sync",
FT_BOOLEAN, 16,
NULL,
SYMMETRIC_SYNCHRONIZE_FUNCTION_UNIT,
NULL,
HFILL
}
},
{
&hf_typed_data_function_unit,
{
"Typed data function unit",
"ses.typed_data",
FT_BOOLEAN, 16,
NULL,
TYPED_DATA_FUNCTION_UNIT,
NULL,
HFILL
}
},
{
&hf_exception_function_unit,
{
"Exception function unit",
"ses.exception_data",
FT_BOOLEAN, 16,
NULL,
EXCEPTION_FUNCTION_UNIT,
NULL,
HFILL
}
},
{
&hf_capability_function_unit,
{
"Capability function unit",
"ses.capability_data",
FT_BOOLEAN, 16,
NULL,
CAPABILITY_DATA_FUNCTION_UNIT,
NULL,
HFILL
}
},
{
&hf_negotiated_release_function_unit,
{
"Negotiated release function unit",
"ses.negotiated_release",
FT_BOOLEAN, 16,
NULL,
NEGOTIATED_RELEASE_FUNCTION_UNIT,
NULL,
HFILL
}
},
{
&hf_activity_management_function_unit,
{
"Activity management function unit",
"ses.activity_management",
FT_BOOLEAN, 16,
NULL,
ACTIVITY_MANAGEMENT_FUNCTION_UNIT,
NULL,
HFILL
}
},
{
&hf_resynchronize_function_unit,
{
"Resynchronize function unit",
"ses.resynchronize",
FT_BOOLEAN, 16,
NULL,
RESYNCHRONIZE_FUNCTION_UNIT,
NULL,
HFILL
}
},
{
&hf_major_resynchronize_function_unit,
{
"Major resynchronize function unit",
"ses.major_resynchronize",
FT_BOOLEAN, 16,
NULL,
MAJOR_SYNCHRONIZE_FUNCTION_UNIT,
NULL,
HFILL
}
},
{
&hf_minor_resynchronize_function_unit,
{
"Minor resynchronize function unit",
"ses.minor_resynchronize",
FT_BOOLEAN, 16,
NULL,
MINOR_SYNCHRONIZE_FUNCTION_UNIT,
NULL,
HFILL
}
},
{
&hf_expedited_data_resynchronize_function_unit,
{
"Expedited data function unit",
"ses.expedited_data",
FT_BOOLEAN, 16,
NULL,
EXPEDITED_DATA_FUNCTION_UNIT,
NULL,
HFILL
}
},
{
&hf_duplex_function_unit,
{
"Duplex functional unit",
"ses.duplex",
FT_BOOLEAN, 16,
NULL,
DUPLEX_FUNCTION_UNIT,
NULL,
HFILL
}
},
{
&hf_half_duplex_function_unit,
{
"Half-duplex functional unit",
"ses.half_duplex",
FT_BOOLEAN, 16,
NULL,
HALF_DUPLEX_FUNCTION_UNIT,
NULL,
HFILL
}
},
{
&hf_proposed_tsdu_maximum_size_i2r,
{
"Proposed TSDU Maximum Size, Initiator to Responder",
"ses.proposed_tsdu_maximum_size_i2r",
FT_UINT16,
BASE_DEC,
NULL,
0x0,
NULL,
HFILL
}
},
{
&hf_proposed_tsdu_maximum_size_r2i,
{
"Proposed TSDU Maximum Size, Responder to Initiator",
"ses.proposed_tsdu_maximum_size_r2i",
FT_UINT16,
BASE_DEC,
NULL,
0x0,
NULL,
HFILL
}
},
{
&hf_protocol_version_1,
{
"Protocol Version 1",
"ses.protocol_version1",
FT_BOOLEAN, 8,
NULL,
PROTOCOL_VERSION_1,
NULL,
HFILL
}
},
{
&hf_protocol_version_2,
{
"Protocol Version 2",
"ses.protocol_version2",
FT_BOOLEAN, 8,
NULL,
PROTOCOL_VERSION_2,
NULL,
HFILL
}
},
{
&hf_initial_serial_number,
{
"Initial Serial Number",
"ses.initial_serial_number",
FT_STRING, BASE_NONE,
NULL,
0x0,
NULL,
HFILL
}
},
{
&hf_beginning_of_SSDU,
{
"beginning of SSDU",
"ses.begininng_of_SSDU",
FT_BOOLEAN, 8,
NULL,
BEGINNING_SPDU,
NULL,
HFILL
}
},
{
&hf_end_of_SSDU,
{
"end of SSDU",
"ses.end_of_SSDU",
FT_BOOLEAN, 8,
NULL,
END_SPDU,
NULL,
HFILL
}
},
{
&hf_release_token_setting,
{
"release token setting",
"ses.release_token_setting",
FT_UINT8, BASE_HEX,
VALS(token_setting_vals),
0xC0,
NULL,
HFILL
}
},
{
&hf_major_activity_token_setting,
{
"major/activity setting",
"ses.major_activity_token_setting",
FT_UINT8, BASE_HEX,
VALS(token_setting_vals),
0x30,
"major/activity token setting",
HFILL
}
},
{
&hf_synchronize_minor_token_setting,
{
"synchronize-minor token setting",
"ses.synchronize_minor_token_setting",
FT_UINT8, BASE_HEX,
VALS(token_setting_vals),
0x0C,
NULL,
HFILL
}
},
{
&hf_data_token_setting,
{
"data token setting",
"ses.data_token_setting",
FT_UINT8, BASE_HEX,
VALS(token_setting_vals),
0x03,
NULL,
HFILL
}
},
{
&hf_activity_identifier,
{
"Activity Identifier",
"ses.activity_identifier",
FT_BYTES, BASE_NONE,
NULL,
0x0,
NULL,
HFILL
}
},
{
&hf_serial_number,
{
"Serial Number",
"ses.serial_number",
FT_STRING, BASE_NONE,
NULL,
0x0,
NULL,
HFILL
}
},
{
&hf_calling_session_selector,
{
"Calling Session Selector",
"ses.calling_session_selector",
FT_BYTES, BASE_NONE,
NULL,
0x0,
NULL,
HFILL
}
},
{
&hf_called_session_selector,
{
"Called Session Selector",
"ses.called_session_selector",
FT_BYTES, BASE_NONE,
NULL,
0x0,
NULL,
HFILL
}
},
{
&hf_second_serial_number,
{
"Second Serial Number",
"ses.second_serial_number",
FT_STRING, BASE_NONE,
NULL,
0x0,
NULL,
HFILL
}
},
{
&hf_second_initial_serial_number,
{
"Second Initial Serial Number",
"ses.second_initial_serial_number",
FT_STRING, BASE_NONE,
NULL,
0x0,
NULL,
HFILL
}
},
{
&hf_large_initial_serial_number,
{
"Large Initial Serial Number",
"ses.large_initial_serial_number",
FT_STRING, BASE_NONE,
NULL,
0x0,
NULL,
HFILL
}
},
{
&hf_large_second_initial_serial_number,
{
"Large Second Initial Serial Number",
"ses.large_second_initial_serial_number",
FT_STRING, BASE_NONE,
NULL,
0x0,
NULL,
HFILL
}
},
{
&hf_connect_protocol_options_flags,
{
"Flags",
"ses.connect.flags",
FT_UINT8,
BASE_HEX,
NULL,
0x0,
NULL,
HFILL
}
},
{
&hf_version_number_options_flags,
{
"Flags",
"ses.version.flags",
FT_UINT8,
BASE_HEX,
NULL,
0x0,
NULL,
HFILL
}
},
{
&hf_token_item_options_flags,
{
"Flags",
"ses.tken_item.flags",
FT_UINT8,
BASE_HEX,
NULL,
0x0,
NULL,
HFILL
}
},
{
&hf_enclosure_item_options_flags,
{
"Flags",
"ses.enclosure.flags",
FT_UINT8,
BASE_HEX,
NULL,
0x0,
NULL,
HFILL
}
},
{ &hf_ses_segment_data,
{ "SES segment data", "ses.segment.data", FT_NONE, BASE_NONE,
NULL, 0x00, NULL, HFILL } },
{ &hf_ses_segments,
{ "SES segments", "ses.segments", FT_NONE, BASE_NONE,
NULL, 0x00, NULL, HFILL } },
{ &hf_ses_segment,
{ "SES segment", "ses.segment", FT_FRAMENUM, BASE_NONE,
NULL, 0x00, NULL, HFILL } },
{ &hf_ses_segment_overlap,
{ "SES segment overlap", "ses.segment.overlap", FT_BOOLEAN,
BASE_NONE, NULL, 0x0, NULL, HFILL } },
{ &hf_ses_segment_overlap_conflicts,
{ "SES segment overlapping with conflicting data",
"ses.segment.overlap.conflicts", FT_BOOLEAN, BASE_NONE,
NULL, 0x0, NULL, HFILL } },
{ &hf_ses_segment_multiple_tails,
{ "SES has multiple tail segments",
"ses.segment.multiple_tails", FT_BOOLEAN, BASE_NONE,
NULL, 0x0, NULL, HFILL } },
{ &hf_ses_segment_too_long_segment,
{ "SES segment too long", "ses.segment.too_long_segment",
FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } },
{ &hf_ses_segment_error,
{ "SES desegmentation error", "ses.segment.error", FT_FRAMENUM,
BASE_NONE, NULL, 0x00, NULL, HFILL } },
{ &hf_ses_segment_count,
{ "SES segment count", "ses.segment.count", FT_UINT32, BASE_DEC,
NULL, 0x00, NULL, HFILL } },
{ &hf_ses_reassembled_in,
{ "Reassembled SES in frame", "ses.reassembled.in", FT_FRAMENUM, BASE_NONE,
NULL, 0x00, "This SES packet is reassembled in this frame", HFILL } },
{ &hf_ses_reassembled_length,
{ "Reassembled SES length", "ses.reassembled.length", FT_UINT32, BASE_DEC,
NULL, 0x00, "The total length of the reassembled payload", HFILL } }
};
static gint *ett[] =
{
&ett_ses,
&ett_ses_param,
&ett_connect_protocol_options_flags,
&ett_protocol_version_flags,
&ett_enclosure_item_flags,
&ett_token_item_flags,
&ett_ses_req_options_flags,
&ett_ses_segment,
&ett_ses_segments
};
module_t *ses_module;
proto_ses = proto_register_protocol(PROTO_STRING_SES, "SES", "ses");
proto_register_field_array(proto_ses, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
register_init_routine (&ses_reassemble_init);
ses_module = prefs_register_protocol(proto_ses, NULL);
prefs_register_bool_preference(ses_module, "desegment",
"Reassemble session packets ",
"Whether the session dissector should reassemble messages spanning multiple SES segments",
&ses_desegment);
/*
* Register the dissector by name, so other dissectors can
* grab it by name rather than just referring to it directly
* (you can't refer to it directly from a plugin dissector
* on Windows without stuffing it into the Big Transfer Vector).
*/
register_dissector("ses", dissect_ses, proto_ses);
}
/* Register the protocol with Wireshark */
void
proto_register_gsm_sms_ud(void)
{
module_t *gsm_sms_ud_module; /* Preferences for GSM SMS UD */
/* Setup list of header fields */
static hf_register_info hf[] = {
/*
* User Data Header
*/
{ &hf_gsm_sms_udh_iei,
{ "IE Id", "gsm_sms_ud.udh.iei",
FT_UINT8, BASE_HEX, VALS(vals_udh_iei), 0x00,
"Name of the User Data Header Information Element.",
HFILL
}
},
{ &hf_gsm_sms_udh_length,
{ "UDH Length", "gsm_sms_ud.udh.len",
FT_UINT8, BASE_DEC, NULL, 0x00,
"Length of the User Data Header (bytes)",
HFILL
}
},
#if 0
{ &hf_gsm_sms_udh_multiple_messages,
{ "Multiple messages UDH", "gsm_sms_ud.udh.mm",
FT_NONE, BASE_NONE, NULL, 0x00,
"Multiple messages User Data Header",
HFILL
}
},
#endif
{ &hf_gsm_sms_udh_multiple_messages_msg_id,
{ "Message identifier", "gsm_sms_ud.udh.mm.msg_id",
FT_UINT16, BASE_DEC, NULL, 0x00,
"Identification of the message",
HFILL
}
},
{ &hf_gsm_sms_udh_multiple_messages_msg_parts,
{ "Message parts", "gsm_sms_ud.udh.mm.msg_parts",
FT_UINT8, BASE_DEC, NULL, 0x00,
"Total number of message parts (fragments)",
HFILL
}
},
{ &hf_gsm_sms_udh_multiple_messages_msg_part,
{ "Message part number", "gsm_sms_ud.udh.mm.msg_part",
FT_UINT8, BASE_DEC, NULL, 0x00,
"Message part (fragment) sequence number",
HFILL
}
},
#if 0
{ &hf_gsm_sms_udh_ports,
{ "Port number UDH", "gsm_sms_ud.udh.ports",
FT_NONE, BASE_NONE, NULL, 0x00,
"Port number User Data Header",
HFILL
}
},
#endif
{ &hf_gsm_sms_udh_ports_src,
{ "Source port", "gsm_sms_ud.udh.ports.src",
FT_UINT8, BASE_DEC, NULL, 0x00,
NULL,
HFILL
}
},
{ &hf_gsm_sms_udh_ports_dst,
{ "Destination port", "gsm_sms_ud.udh.ports.dst",
FT_UINT8, BASE_DEC, NULL, 0x00,
NULL,
HFILL
}
},
/*
* Short Message fragment reassembly
*/
{ &hf_gsm_sms_ud_fragments,
{ "Short Message fragments", "gsm_sms_ud.fragments",
FT_NONE, BASE_NONE, NULL, 0x00,
"GSM Short Message fragments",
HFILL
}
},
{ &hf_gsm_sms_ud_fragment,
{ "Short Message fragment", "gsm_sms_ud.fragment",
FT_FRAMENUM, BASE_NONE, NULL, 0x00,
"GSM Short Message fragment",
HFILL
}
},
{ &hf_gsm_sms_ud_fragment_overlap,
{ "Short Message fragment overlap", "gsm_sms_ud.fragment.overlap",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"GSM Short Message fragment overlaps with other fragment(s)",
HFILL
}
},
{ &hf_gsm_sms_ud_fragment_overlap_conflicts,
{ "Short Message fragment overlapping with conflicting data",
"gsm_sms_ud.fragment.overlap.conflicts",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"GSM Short Message fragment overlaps with conflicting data",
HFILL
}
},
{ &hf_gsm_sms_ud_fragment_multiple_tails,
{ "Short Message has multiple tail fragments",
"gsm_sms_ud.fragment.multiple_tails",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"GSM Short Message fragment has multiple tail fragments",
HFILL
}
},
{ &hf_gsm_sms_ud_fragment_too_long_fragment,
{ "Short Message fragment too long",
"gsm_sms_ud.fragment.too_long_fragment",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"GSM Short Message fragment data goes beyond the packet end",
HFILL
}
},
{ &hf_gsm_sms_ud_fragment_error,
{ "Short Message defragmentation error", "gsm_sms_ud.fragment.error",
FT_FRAMENUM, BASE_NONE, NULL, 0x00,
"GSM Short Message defragmentation error due to illegal fragments",
HFILL
}
},
{ &hf_gsm_sms_ud_fragment_count,
{ "Short Message fragment count", "gsm_sms_ud.fragment.count",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL,
HFILL
}
},
{ &hf_gsm_sms_ud_reassembled_in,
{ "Reassembled in",
"gsm_sms_ud.reassembled.in",
FT_FRAMENUM, BASE_NONE, NULL, 0x00,
"GSM Short Message has been reassembled in this packet.",
HFILL
}
},
{ &hf_gsm_sms_ud_reassembled_length,
{ "Reassembled Short Message length",
"gsm_sms_ud.reassembled.length",
FT_UINT32, BASE_DEC, NULL, 0x00,
"The total length of the reassembled payload",
HFILL
}
},
};
static gint *ett[] = {
&ett_gsm_sms,
&ett_udh,
&ett_udh_ie,
&ett_gsm_sms_ud_fragment,
&ett_gsm_sms_ud_fragments,
};
/* Register the protocol name and description */
proto_gsm_sms_ud = proto_register_protocol(
"GSM Short Message Service User Data", /* Name */
"GSM SMS UD", /* Short name */
"gsm_sms_ud"); /* Filter name */
/* Required function calls to register header fields and subtrees used */
proto_register_field_array(proto_gsm_sms_ud, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
/* Subdissector code */
gsm_sms_dissector_table = register_dissector_table("gsm_sms_ud.udh.port",
"GSM SMS port IE in UDH", FT_UINT16, BASE_DEC);
/* Preferences for GSM SMS UD */
gsm_sms_ud_module = prefs_register_protocol(proto_gsm_sms_ud, NULL);
prefs_register_bool_preference(gsm_sms_ud_module,
"port_number_udh_means_wsp",
"Port Number IE in UDH always triggers CL-WSP dissection",
"Always decode a GSM Short Message as Connectionless WSP "
"if a Port Number Information Element is present "
"in the SMS User Data Header.",
&port_number_udh_means_wsp);
prefs_register_bool_preference(gsm_sms_ud_module, "try_dissect_1st_fragment",
"Always try subdissection of 1st Short Message fragment",
"Always try subdissection of the 1st fragment of a fragmented "
"GSM Short Message. If reassembly is possible, the Short Message "
"may be dissected twice (once as a short frame, once in its "
"entirety).",
&try_dissect_1st_frag);
prefs_register_bool_preference(gsm_sms_ud_module, "prevent_dissectors_chg_cols",
"Prevent sub-dissectors from changing column data",
"Prevent sub-dissectors from replacing column data with their "
"own. Eg. Prevent WSP dissector overwriting SMPP information.",
&prevent_subdissectors_changing_columns);
register_dissector("gsm_sms_ud", dissect_gsm_sms_ud, proto_gsm_sms_ud);
/* GSM SMS UD dissector initialization routines */
register_init_routine(gsm_sms_ud_defragment_init);
}
void
proto_register_ehdlc(void)
{
static hf_register_info hf[] = {
{ &hf_ehdlc_data_len,
{ "DataLen", "ehdlc.data_len",
FT_UINT8, BASE_DEC, NULL, 0x0,
"The length of the data (in bytes)", HFILL }
},
{ &hf_ehdlc_protocol,
{ "Protocol", "ehdlc.protocol",
FT_UINT8, BASE_HEX, VALS(ehdlc_protocol_vals), 0x0,
"The HDLC Sub-Protocol", HFILL }
},
#if 0
{ &hf_ehdlc_sapi,
{ "SAPI", "ehdlc.sapi",
FT_UINT8, BASE_DEC, NULL, 0x1f,
NULL, HFILL }
},
{ &hf_ehdlc_c_r,
{ "C/R", "ehdlc.c_r",
FT_UINT8, BASE_HEX, NULL, 0x20,
NULL, HFILL }
},
#endif
{ &hf_ehdlc_xid_payload,
{ "XID Payload", "ehdlc.xid_payload",
FT_BYTES, BASE_NONE, NULL, 0,
NULL, HFILL }
},
{ &hf_ehdlc_control,
{ "Control Field", "ehdlc.control",
FT_UINT16, BASE_HEX, NULL, 0,
NULL, HFILL }
},
{ &hf_ehdlc_n_r,
{ "N(R)", "ehdlc.control.n_r",
FT_UINT16, BASE_DEC, NULL, XDLC_N_R_EXT_MASK,
NULL, HFILL }
},
{ &hf_ehdlc_n_s,
{ "N(S)", "ehdlc.control.n_s",
FT_UINT16, BASE_DEC, NULL, XDLC_N_S_EXT_MASK,
NULL, HFILL }
},
{ &hf_ehdlc_p,
{ "Poll", "ehdlc.control.p",
FT_BOOLEAN, 8, TFS(&tfs_set_notset), XDLC_P_F,
NULL, HFILL }
},
{ &hf_ehdlc_p_ext,
{ "Poll", "ehdlc.control.p",
FT_BOOLEAN, 16, TFS(&tfs_set_notset), XDLC_P_F_EXT,
NULL, HFILL }
},
{ &hf_ehdlc_f,
{ "Final", "ehdlc.control.f",
FT_BOOLEAN, 8, TFS(&tfs_set_notset), XDLC_P_F,
NULL, HFILL }
},
{ &hf_ehdlc_f_ext,
{ "Final", "ehdlc.control.f",
FT_BOOLEAN, 16, TFS(&tfs_set_notset), XDLC_P_F_EXT,
NULL, HFILL }
},
{ &hf_ehdlc_s_ftype,
{ "Supervisory frame type", "ehdlc.control.s_ftype",
FT_UINT16, BASE_HEX, VALS(stype_vals), XDLC_S_FTYPE_MASK,
NULL, HFILL }
},
{ &hf_ehdlc_u_modifier_cmd,
{ "Command", "ehdlc.control.u_modifier_cmd",
FT_UINT8, BASE_HEX, VALS(modifier_vals_cmd), XDLC_U_MODIFIER_MASK,
NULL, HFILL }
},
{ &hf_ehdlc_u_modifier_resp,
{ "Response", "ehdlc.control.u_modifier_resp",
FT_UINT8, BASE_HEX, VALS(modifier_vals_resp), XDLC_U_MODIFIER_MASK,
NULL, HFILL }
},
{ &hf_ehdlc_ftype_i,
{ "Frame Type", "ehdlc.control.ftype",
FT_UINT16, BASE_HEX, VALS(ftype_vals), XDLC_I_MASK,
NULL, HFILL }
},
{ &hf_ehdlc_ftype_s_u,
{ "Frame Type", "ehdlc.control.ftype",
FT_UINT8, BASE_HEX, VALS(ftype_vals), XDLC_S_U_MASK,
NULL, HFILL }
},
{ &hf_ehdlc_ftype_s_u_ext,
{ "Frame Type", "ehdlc.control.ftype",
FT_UINT16, BASE_HEX, VALS(ftype_vals), XDLC_S_U_MASK,
NULL, HFILL }
},
};
static gint *ett[] = {
&ett_ehdlc,
&ett_ehdlc_control,
};
proto_ehdlc =
proto_register_protocol("Ericsson HDLC",
"Ericsson HDLC as used in A-bis over IP", "ehdlc");
proto_register_field_array(proto_ehdlc, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
register_dissector("ehdlc", dissect_ehdlc, proto_ehdlc);
}
void
proto_register_docsis_dcd (void)
{
/* Setup list of header fields See Section 1.6.1 for details*/
static hf_register_info hf[] = {
{&hf_docsis_dcd_config_ch_cnt,
{
"Configuration Change Count",
"docsis_dcd.config_ch_cnt",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL,
HFILL
}
},
{&hf_docsis_dcd_num_of_frag,
{
"Number of Fragments",
"docsis_dcd.num_of_frag",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL,
HFILL
}
},
{&hf_docsis_dcd_frag_sequence_num,
{
"Fragment Sequence Number",
"docsis_dcd.frag_sequence_num",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL,
HFILL
}
},
{&hf_docsis_dcd_cfr_id,
{
"Downstream Classifier Id",
"docsis_dcd.cfr_id",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL,
HFILL
}
},
{&hf_docsis_dcd_cfr_rule_pri,
{
"Downstream Classifier Rule Priority",
"docsis_dcd.cfr_rule_pri",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL,
HFILL
}
},
{&hf_docsis_dcd_cfr_ip_source_addr,
{
"Downstream Classifier IP Source Address",
"docsis_dcd.cfr_ip_source_addr",
FT_IPv4, BASE_NONE, NULL, 0x0,
NULL,
HFILL
}
},
{&hf_docsis_dcd_cfr_ip_source_mask,
{
"Downstream Classifier IP Source Mask",
"docsis_dcd.cfr_ip_source_mask",
FT_IPv4, BASE_NONE, NULL, 0x0,
NULL,
HFILL
}
},
{&hf_docsis_dcd_cfr_ip_dest_addr,
{
"Downstream Classifier IP Destination Address",
"docsis_dcd.cfr_ip_dest_addr",
FT_IPv4, BASE_NONE, NULL, 0x0,
NULL,
HFILL
}
},
{&hf_docsis_dcd_cfr_ip_dest_mask,
{
"Downstream Classifier IP Destination Mask",
"docsis_dcd.cfr_ip_dest_mask",
FT_IPv4, BASE_NONE, NULL, 0x0,
"Downstream Classifier IP Destination Address",
HFILL
}
},
{&hf_docsis_dcd_cfr_tcpudp_srcport_start,
{
"Downstream Classifier IP TCP/UDP Source Port Start",
"docsis_dcd.cfr_ip_tcpudp_srcport_start",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL,
HFILL
}
},
{&hf_docsis_dcd_cfr_tcpudp_srcport_end,
{
"Downstream Classifier IP TCP/UDP Source Port End",
"docsis_dcd.cfr_ip_tcpudp_srcport_end",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL,
HFILL
}
},
{&hf_docsis_dcd_cfr_tcpudp_dstport_start,
{
"Downstream Classifier IP TCP/UDP Destination Port Start",
"docsis_dcd.cfr_ip_tcpudp_dstport_start",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL,
HFILL
}
},
{&hf_docsis_dcd_cfr_tcpudp_dstport_end,
{
"Downstream Classifier IP TCP/UDP Destination Port End",
"docsis_dcd.cfr_ip_tcpudp_dstport_end",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL,
HFILL
}
},
{&hf_docsis_dcd_rule_id,
{
"DSG Rule Id",
"docsis_dcd.rule_id",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL,
HFILL
}
},
{&hf_docsis_dcd_rule_pri,
{
"DSG Rule Priority",
"docsis_dcd.rule_pri",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL,
HFILL
}
},
{&hf_docsis_dcd_rule_ucid_list,
{
"DSG Rule UCID Range",
"docsis_dcd.rule_ucid_list",
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL,
HFILL
}
},
{&hf_docsis_dcd_clid_known_mac_addr,
{
"DSG Rule Client ID Known MAC Address",
"docsis_dcd.clid_known_mac_addr",
FT_ETHER, BASE_NONE, NULL, 0x0,
NULL,
HFILL
}
},
{&hf_docsis_dcd_clid_ca_sys_id,
{
"DSG Rule Client ID CA System ID",
"docsis_dcd.clid_ca_sys_id",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL,
HFILL
}
},
{&hf_docsis_dcd_clid_app_id,
{
"DSG Rule Client ID Application ID",
"docsis_dcd.clid_app_id",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL,
HFILL
}
},
{&hf_docsis_dcd_rule_tunl_addr,
{
"DSG Rule Tunnel MAC Address",
"docsis_dcd.rule_tunl_addr",
FT_ETHER, BASE_NONE, NULL, 0x0,
NULL,
HFILL
}
},
{&hf_docsis_dcd_rule_cfr_id,
{
"DSG Rule Classifier ID",
"docsis_dcd.rule_cfr_id",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL,
HFILL
}
},
{&hf_docsis_dcd_rule_vendor_spec,
{
"DSG Rule Vendor Specific Parameters",
"docsis_dcd.rule_vendor_spec",
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL,
HFILL
}
},
{&hf_docsis_dcd_cfg_chan,
{
"DSG Configuration Channel",
"docsis_dcd.cfg_chan",
FT_UINT32, BASE_DEC, NULL, 0x0,
NULL,
HFILL
}
},
{&hf_docsis_dcd_cfg_tdsg1,
{
"DSG Initialization Timeout (Tdsg1)",
"docsis_dcd.cfg_tdsg1",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL,
HFILL
}
},
{&hf_docsis_dcd_cfg_tdsg2,
{
"DSG Operational Timeout (Tdsg2)",
"docsis_dcd.cfg_tdsg2",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL,
HFILL
}
},
{&hf_docsis_dcd_cfg_tdsg3,
{
"DSG Two-Way Retry Timer (Tdsg3)",
"docsis_dcd.cfg_tdsg3",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL,
HFILL
}
},
{&hf_docsis_dcd_cfg_tdsg4,
{
"DSG One-Way Retry Timer (Tdsg4)",
"docsis_dcd.cfg_tdsg4",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL,
HFILL
}
},
{&hf_docsis_dcd_cfg_vendor_spec,
{
"DSG Configuration Vendor Specific Parameters",
"docsis_dcd.cfg_vendor_spec",
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL,
HFILL
}
},
};
/* Setup protocol subtree array */
static gint *ett[] = {
&ett_docsis_dcd,
&ett_docsis_dcd_cfr,
&ett_docsis_dcd_cfr_ip,
&ett_docsis_dcd_rule,
&ett_docsis_dcd_clid,
&ett_docsis_dcd_cfg,
};
/* Register the protocol name and description */
proto_docsis_dcd =
proto_register_protocol ("DOCSIS Downstream Channel Descriptor",
"DOCSIS DCD", "docsis_dcd");
/* Required function calls to register the header fields and subtrees used */
proto_register_field_array (proto_docsis_dcd, hf, array_length (hf));
proto_register_subtree_array (ett, array_length (ett));
register_dissector ("docsis_dcd", dissect_dcd, proto_docsis_dcd);
}
void proto_register_ipa(void)
{
module_t *ipa_module;
static hf_register_info hf[] = {
{ &hf_ipa_data_len,
{ "DataLen", "gsm_ipa.data_len",
FT_UINT16, BASE_DEC, NULL, 0x0,
"The length of the data (in bytes)", HFILL
}
},
{ &hf_ipa_protocol,
{ "Protocol", "gsm_ipa.protocol",
FT_UINT8, BASE_HEX, VALS(ipa_protocol_vals), 0x0,
"The IPA Sub-Protocol", HFILL
}
},
{ &hf_ipa_hsl_debug,
{ "Debug Message", "gsm_ipa.hsl_debug",
FT_STRING, BASE_NONE, NULL, 0,
"Hay Systems Limited debug message", HFILL
}
},
{ &hf_ipa_osmo_proto,
{ "Osmo ext protocol", "gsm_ipa.osmo.protocol",
FT_UINT8, BASE_HEX, VALS(ipa_osmo_proto_vals), 0x0,
"The osmo extension protocol", HFILL
}
},
{ &hf_ipa_osmo_ctrl_data,
{ "CTRL data", "gsm_ipa.ctrl.data",
FT_STRING, BASE_NONE, NULL, 0x0,
"Control interface data", HFILL
}
},
};
static hf_register_info hf_ipa[] = {
{ &hf_ipaccess_msgtype,
{ "MessageType", "ipaccess.msg_type",
FT_UINT8, BASE_HEX, VALS(ipaccess_msgtype_vals), 0x0,
"Type of ip.access messsage", HFILL
}
},
{ &hf_ipaccess_attr_tag,
{ "Tag", "ipaccess.attr_tag",
FT_UINT8, BASE_HEX, VALS(ipaccess_idtag_vals), 0x0,
"Attribute Tag", HFILL
}
},
{ &hf_ipaccess_attr_string,
{ "String", "ipaccess.attr_string",
FT_STRING, BASE_NONE, NULL, 0x0,
"String attribute", HFILL
}
},
};
static gint *ett[] = {
&ett_ipa,
&ett_ipaccess,
};
proto_ipa =
proto_register_protocol("GSM over IP protocol as used by ip.access",
"GSM over IP", "gsm_ipa");
proto_ipaccess =
proto_register_protocol("GSM over IP ip.access CCM sub-protocol",
"IPA", "ipaccess");
proto_register_field_array(proto_ipa, hf, array_length(hf));
proto_register_field_array(proto_ipaccess, hf_ipa, array_length(hf_ipa));
proto_register_subtree_array(ett, array_length(ett));
register_dissector("gsm_ipa", dissect_ipa, proto_ipa);
/* Register table for subdissectors */
osmo_dissector_table = register_dissector_table("ipa.osmo.protocol",
"ip.access Protocol", FT_UINT8, BASE_DEC);
range_convert_str(&global_ipa_tcp_ports, IPA_TCP_PORTS, MAX_TCP_PORT);
range_convert_str(&global_ipa_udp_ports, IPA_UDP_PORTS, MAX_UDP_PORT);
ipa_module = prefs_register_protocol(proto_ipa,
proto_reg_handoff_gsm_ipa);
prefs_register_range_preference(ipa_module, "tcp_ports",
"GSM IPA TCP Port(s)",
"Set the port(s) for ip.access IPA"
" (default: " IPA_TCP_PORTS ")",
&global_ipa_tcp_ports, MAX_TCP_PORT);
prefs_register_range_preference(ipa_module, "udp_ports",
"GSM IPA UDP Port(s)",
"Set the port(s) for ip.access IPA"
" (default: " IPA_UDP_PORTS ")",
&global_ipa_udp_ports, MAX_UDP_PORT);
prefs_register_bool_preference(ipa_module, "hsl_debug_in_root_tree",
"HSL Debug messages in root protocol tree",
NULL, &global_ipa_in_root);
prefs_register_bool_preference(ipa_module, "hsl_debug_in_info",
"HSL Debug messages in INFO column",
NULL, &global_ipa_in_info);
}
void
proto_register_mtp3(void)
{
/* Setup list of header fields See Section 1.6.1 for details*/
static hf_register_info hf[] = {
{ &hf_mtp3_service_indicator, { "Service indicator", "mtp3.service_indicator", FT_UINT8, BASE_HEX, VALS(mtp3_service_indicator_code_vals), SERVICE_INDICATOR_MASK, NULL, HFILL }},
{ &hf_mtp3_network_indicator, { "Network indicator", "mtp3.network_indicator", FT_UINT8, BASE_HEX, VALS(mtp3_network_indicator_vals), NETWORK_INDICATOR_MASK, NULL, HFILL }},
{ &hf_mtp3_itu_spare, { "Spare", "mtp3.spare", FT_UINT8, BASE_HEX, NULL, SPARE_MASK, NULL, HFILL }},
{ &hf_mtp3_itu_priority, { "ITU priority", "mtp3.priority", FT_UINT8, BASE_DEC, NULL, SPARE_MASK, NULL, HFILL }},
{ &hf_mtp3_ansi_priority, { "ANSI Priority", "mtp3.priority", FT_UINT8, BASE_DEC, NULL, ANSI_PRIORITY_MASK, NULL, HFILL }},
{ &hf_mtp3_itu_opc, { "OPC", "mtp3.opc", FT_UINT32, BASE_DEC, NULL, ITU_OPC_MASK, NULL, HFILL }},
{ &hf_mtp3_itu_pc, { "PC", "mtp3.pc", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }},
{ &hf_mtp3_24bit_pc, { "PC", "mtp3.pc", FT_UINT32, BASE_DEC, NULL, ANSI_PC_MASK, NULL, HFILL }},
{ &hf_mtp3_24bit_opc, { "OPC", "mtp3.opc", FT_UINT32, BASE_DEC, NULL, ANSI_PC_MASK, NULL, HFILL }},
{ &hf_mtp3_ansi_opc, { "OPC", "mtp3.ansi_opc", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }},
{ &hf_mtp3_chinese_opc, { "OPC", "mtp3.chinese_opc", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }},
{ &hf_mtp3_opc_network, { "OPC Network", "mtp3.opc.network", FT_UINT24, BASE_DEC, NULL, ANSI_NETWORK_MASK, NULL, HFILL }},
{ &hf_mtp3_opc_cluster, { "OPC Cluster", "mtp3.opc.cluster", FT_UINT24, BASE_DEC, NULL, ANSI_CLUSTER_MASK, NULL, HFILL }},
{ &hf_mtp3_opc_member, { "OPC Member", "mtp3.opc.member", FT_UINT24, BASE_DEC, NULL, ANSI_MEMBER_MASK, NULL, HFILL }},
{ &hf_mtp3_japan_opc, { "OPC", "mtp3.opc", FT_UINT16, BASE_DEC, NULL, JAPAN_PC_MASK, NULL, HFILL }},
{ &hf_mtp3_japan_pc, { "PC", "mtp3.pc", FT_UINT16, BASE_DEC, NULL, JAPAN_PC_MASK, NULL, HFILL }},
{ &hf_mtp3_itu_dpc, { "DPC", "mtp3.dpc", FT_UINT32, BASE_DEC, NULL, ITU_DPC_MASK, NULL, HFILL }},
{ &hf_mtp3_24bit_dpc, { "DPC", "mtp3.dpc", FT_UINT32, BASE_DEC, NULL, ANSI_PC_MASK, NULL, HFILL }},
{ &hf_mtp3_ansi_dpc, { "DPC", "mtp3.ansi_dpc", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }},
{ &hf_mtp3_chinese_dpc, { "DPC", "mtp3.chinese_dpc", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }},
{ &hf_mtp3_dpc_network, { "DPC Network", "mtp3.dpc.network", FT_UINT24, BASE_DEC, NULL, ANSI_NETWORK_MASK, NULL, HFILL }},
{ &hf_mtp3_dpc_cluster, { "DPC Cluster", "mtp3.dpc.cluster", FT_UINT24, BASE_DEC, NULL, ANSI_CLUSTER_MASK, NULL, HFILL }},
{ &hf_mtp3_dpc_member, { "DPC Member", "mtp3.dpc.member", FT_UINT24, BASE_DEC, NULL, ANSI_MEMBER_MASK, NULL, HFILL }},
{ &hf_mtp3_japan_dpc, { "DPC", "mtp3.dpc", FT_UINT16, BASE_DEC, NULL, JAPAN_PC_MASK, NULL, HFILL }},
{ &hf_mtp3_itu_sls, { "Signalling Link Selector", "mtp3.sls", FT_UINT32, BASE_DEC, NULL, ITU_SLS_MASK, NULL, HFILL }},
{ &hf_mtp3_japan_4_bit_sls, { "Signalling Link Selector", "mtp3.sls", FT_UINT8, BASE_DEC, NULL, JAPAN_4_BIT_SLS_MASK, NULL, HFILL }},
{ &hf_mtp3_japan_4_bit_sls_spare, { "SLS Spare", "mtp3.sls_spare", FT_UINT8, BASE_HEX, NULL, JAPAN_4_BIT_SLS_SPARE_MASK, NULL, HFILL }},
{ &hf_mtp3_japan_5_bit_sls, { "Signalling Link Selector", "mtp3.sls", FT_UINT8, BASE_DEC, NULL, JAPAN_5_BIT_SLS_MASK, NULL, HFILL }},
{ &hf_mtp3_japan_5_bit_sls_spare, { "SLS Spare", "mtp3.sls_spare", FT_UINT8, BASE_HEX, NULL, JAPAN_5_BIT_SLS_SPARE_MASK, NULL, HFILL }},
{ &hf_mtp3_ansi_5_bit_sls, { "Signalling Link Selector", "mtp3.sls", FT_UINT8, BASE_DEC, NULL, ANSI_5BIT_SLS_MASK, NULL, HFILL }},
{ &hf_mtp3_ansi_8_bit_sls, { "Signalling Link Selector", "mtp3.sls", FT_UINT8, BASE_DEC, NULL, ANSI_8BIT_SLS_MASK, NULL, HFILL }},
{ &hf_mtp3_chinese_itu_sls, { "Signalling Link Selector", "mtp3.sls", FT_UINT8, BASE_DEC, NULL, CHINESE_ITU_SLS_MASK, NULL, HFILL }}
};
/* Setup protocol subtree array */
static gint *ett[] = {
&ett_mtp3,
&ett_mtp3_sio,
&ett_mtp3_label,
&ett_mtp3_label_dpc,
&ett_mtp3_label_opc
};
static const enum_val_t mtp3_options[] = {
{ "itu", "ITU", ITU_STANDARD },
{ "ansi", "ANSI", ANSI_STANDARD },
{ "chinese-itu", "Chinese ITU", CHINESE_ITU_STANDARD },
{ "japan", "Japan", JAPAN_STANDARD },
{ NULL, NULL, 0 }
};
static const enum_val_t mtp3_addr_fmt_str_e[] = {
{ "decimal", "Decimal", MTP3_ADDR_FMT_DEC },
{ "hexadecimal", "Hexadecimal", MTP3_ADDR_FMT_HEX },
{ "ni-decimal", "NI-Decimal", MTP3_ADDR_FMT_NI_DEC },
{ "ni-hexadecimal", "NI-Hexadecimal", MTP3_ADDR_FMT_NI_HEX },
{ "dashed", "Dashed", MTP3_ADDR_FMT_DASHED },
{ NULL, NULL, 0 }
};
static const enum_val_t itu_pc_structures[] = {
{ "unstructured", "Unstructured", ITU_PC_STRUCTURE_NONE},
{ "3-8-3", "3-8-3", ITU_PC_STRUCTURE_3_8_3 },
{ "4-3-4-3", "4-3-4-3", ITU_PC_STRUCTURE_4_3_4_3 },
{ NULL, NULL, 0 }
};
static const enum_val_t japan_pc_structures[] = {
{ "unstructured", "Unstructured", JAPAN_PC_STRUCTURE_NONE},
{ "7-4-5", "7-4-5", JAPAN_PC_STRUCTURE_7_4_5 },
{ "3-4-4-5", "3-4-4-5", JAPAN_PC_STRUCTURE_3_4_4_5 },
{ NULL, NULL, 0 }
};
/* Register the protocol name and description */
proto_mtp3 = proto_register_protocol("Message Transfer Part Level 3",
"MTP3", "mtp3");
mtp3_handle = register_dissector("mtp3", dissect_mtp3, proto_mtp3);
/* Required function calls to register the header fields and subtrees used */
proto_register_field_array(proto_mtp3, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
mtp3_sio_dissector_table = register_dissector_table("mtp3.service_indicator",
"MTP3 Service indicator",
FT_UINT8, BASE_HEX);
mtp3_tap = register_tap("mtp3");
mtp3_module = prefs_register_protocol(proto_mtp3, NULL);
prefs_register_bool_preference(mtp3_module, "heuristic_standard",
"Try to determine the MTP3 standard heuristically",
"This only works for SCCP traffic for now",
&mtp3_heuristic_standard);
prefs_register_enum_preference(mtp3_module, "standard", "MTP3 standard",
"The SS7 standard used in MTP3 packets",
&mtp3_standard, mtp3_options, FALSE);
prefs_register_enum_preference(mtp3_module, "itu_pc_structure", "ITU Pointcode structure",
"The structure of the pointcodes in ITU networks",
&itu_pc_structure, itu_pc_structures, FALSE);
prefs_register_enum_preference(mtp3_module, "japan_pc_structure", "Japan Pointcode structure",
"The structure of the pointcodes in Japan networks",
&japan_pc_structure, japan_pc_structures, FALSE);
prefs_register_bool_preference(mtp3_module, "ansi_5_bit_sls",
"Use 5-bit SLS (ANSI only)",
"Use 5-bit (instead of 8-bit) SLS in ANSI MTP3 packets",
&mtp3_use_ansi_5_bit_sls);
prefs_register_bool_preference(mtp3_module, "japan_5_bit_sls",
"Use 5-bit SLS (Japan only)",
"Use 5-bit (instead of 4-bit) SLS in Japan MTP3 packets",
&mtp3_use_japan_5_bit_sls);
prefs_register_enum_preference(mtp3_module, "addr_format", "Address Format",
"Format for point code in the address columns",
&mtp3_addr_fmt, mtp3_addr_fmt_str_e, FALSE);
prefs_register_bool_preference(mtp3_module, "itu_priority",
"Show MSU priority (national option, ITU and China ITU only)",
"Decode the spare bits of the SIO as the MSU priority (a national option in ITU)",
&mtp3_show_itu_priority);
}
void
proto_register_btmcap(void)
{
module_t *module;
static hf_register_info hf[] = {
{ &hf_btmcap_op_code,
{ "Op Code", "btmcap.op_code",
FT_UINT8, BASE_HEX, VALS(op_code_vals), 0x0,
NULL, HFILL }
},
{ &hf_btmcap_response_code,
{ "Response Code", "btmcap.response_code",
FT_UINT8, BASE_HEX, VALS(response_code_vals), 0x0,
NULL, HFILL }
},
{ &hf_btmcap_mdl_id,
{ "MDL ID", "btmcap.mdl_id",
FT_UINT16, BASE_HEX, NULL, 0x0,
NULL, HFILL }
},
{ &hf_btmcap_mdep_id,
{ "MDEP ID", "btmcap.mdep_id",
FT_UINT8, BASE_HEX, NULL, 0x0,
NULL, HFILL }
},
{ &hf_btmcap_configuration,
{ "Configuration", "btmcap.configuration",
FT_UINT8, BASE_HEX, NULL, 0x0,
NULL, HFILL }
},
{ &hf_btmcap_timestamp_required_accuracy,
{ "Timestamp Required Accuracy", "btmcap.timestamp_required_accuracy",
FT_UINT16, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_btmcap_timestamp_update_information,
{ "Timestamp Update Information", "btmcap.timestamp_update_information",
FT_UINT8, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_btmcap_bluetooth_clock_sync_time,
{ "Bluetooth Clock Sync Time", "btmcap.bluetooth_clock_sync_time",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_btmcap_timestamp_sync_time,
{ "Timestamp Sync Time", "btmcap.timestamp_sync_time",
FT_UINT64, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_btmcap_timestamp_sample_accuracy,
{ "Timestamp Sample Accuracy", "btmcap.timestamp_sample_accuracy",
FT_UINT16, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_btmcap_bluetooth_clock_access_resolution,
{ "Bluetooth Clock Access Resolution","btmcap.bluetooth_clock_access_resolution",
FT_UINT8, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_btmcap_sync_lead_time,
{ "Sync Lead Time", "btmcap.sync_lead_time",
FT_UINT16, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_btmcap_timestamp_native_resolution,
{ "Timestamp Native Resolution", "btmcap.timestamp_native_resolution",
FT_UINT16, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_btmcap_timestamp_native_accuracy,
{ "Timestamp Native Accuracy", "btmcap.timestamp_native_accuracy",
FT_UINT16, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_btmcap_response_parameters,
{ "Response Parameters", "btmcap.response_parameters",
FT_BYTES, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_btmcap_data,
{ "Data", "btmcap.data",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
};
static gint *ett[] = {
&ett_btmcap
};
proto_btmcap = proto_register_protocol("Bluetooth MCAP Protocol", "BT MCAP", "btmcap");
register_dissector("btmcap", dissect_btmcap, proto_btmcap);
proto_register_field_array(proto_btmcap, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
module = prefs_register_protocol(proto_btmcap, NULL);
prefs_register_static_text_preference(module, "mcap.version",
"Bluetooth Protocol MCAP version: 1.0",
"Version of protocol supported by this dissector.");
}
void
proto_register_ppi_gps(void) {
/* The following array initializes those header fields declared above to the values displayed */
static hf_register_info hf[] = {
{ &hf_ppi_gps_version,
{ "Header revision", "ppi_gps.version",
FT_UINT8, BASE_DEC, NULL, 0x0,
"Version of ppi_gps header format", HFILL } },
{ &hf_ppi_gps_pad,
{ "Header pad", "ppi_gps.pad",
FT_UINT8, BASE_DEC, NULL, 0x0,
"Padding", HFILL } },
{ &hf_ppi_gps_length,
{ "Header length", "ppi_gps.length",
FT_UINT16, BASE_DEC, NULL, 0x0,
"Length of header including version, pad, length and data fields", HFILL } },
{ &hf_ppi_gps_present, /* these flag fields are composed of a uint32 on the display */
{ "Present", "ppi_gps.present",
FT_UINT32, BASE_HEX, NULL, 0x0,
"Bitmask indicating which fields are present", HFILL } },
/* Boolean 'present' flags */
{ &hf_ppi_gps_present_gpsflags_flags, /* followed by a lot of booleans */
{ "GPSFlags", "ppi_gps.present.gpsflagss",
FT_BOOLEAN, 32, NULL, PPI_GPS_MASK_GPSFLAGS,
"32-bit bitmask indicating type of GPS fix (GPS/INS/software/etc)", HFILL } },
{ &hf_ppi_gps_present_lat,
{ "Lat", "ppi_gps.present.lat",
FT_BOOLEAN, 32, NULL, PPI_GPS_MASK_LAT,
"Specifies if the latitude field is present", HFILL } },
{ &hf_ppi_gps_present_lon,
{ "Lon", "ppi_gps.present.lon",
FT_BOOLEAN, 32, NULL, PPI_GPS_MASK_LON,
"Specifies if the longitude field is present", HFILL } },
{ &hf_ppi_gps_present_alt,
{ "Alt", "ppi_gps.present.alt",
FT_BOOLEAN, 32, NULL, PPI_GPS_MASK_ALT,
"Specifies if the altitude field is present", HFILL } },
{ &hf_ppi_gps_present_alt_gnd,
{ "Alt-gnd", "ppi_gps.present.alt_gnd",
FT_BOOLEAN, 32, NULL, PPI_GPS_MASK_ALT_G,
"Specifies if the altitude-g field is present", HFILL } },
{ &hf_ppi_gps_present_gpstime,
{ "GPStime", "ppi_gps.present.gpstime",
FT_BOOLEAN, 32, NULL, PPI_GPS_MASK_GPSTIME,
"Specifies if the GPS time field is present", HFILL } },
{ &hf_ppi_gps_present_fractime,
{ "fractime", "ppi_gps.present.fractime",
FT_BOOLEAN, 32, NULL, PPI_GPS_MASK_FRACTIME,
"Specifies if the fractional time field is present", HFILL } },
{ &hf_ppi_gps_present_eph,
{ "error_h", "ppi_gps.present.eph",
FT_BOOLEAN, 32, NULL, PPI_GPS_MASK_EPH,
"Specifies if the horizontal error field is present (eph)", HFILL } },
{ &hf_ppi_gps_present_epv,
{ "error_v", "ppi_gps.present.epv",
FT_BOOLEAN, 32, NULL, PPI_GPS_MASK_EPV,
"Specifies if the vertical error field present (epv)", HFILL } },
{ &hf_ppi_gps_present_ept,
{ "error_t", "ppi_gps.present.ept",
FT_BOOLEAN, 32, NULL, PPI_GPS_MASK_EPT,
"Specifies if the estimed time error field is present (ept)", HFILL } },
{ &hf_ppi_gps_present_descr,
{ "Description", "ppi_gps.present.descr",
FT_BOOLEAN, 32, NULL, PPI_GPS_MASK_DESCRSTR,
"Specifies if the (ASCII) description is present", HFILL } },
{ &hf_ppi_gps_present_appspecific_num,
{ "AppId", "ppi_gps.present.appid",
FT_BOOLEAN, 32, NULL, PPI_GPS_MASK_APPID,
"Specifies if the application specific field id is present", HFILL } },
{ &hf_ppi_gps_present_appspecific_data,
{ "AppData", "ppi_gps.present.appdata",
FT_BOOLEAN, 32, NULL, PPI_GPS_MASK_APPDATA,
"Specifies if the application specific data field is present", HFILL } },
{ &hf_ppi_gps_present_ext,
{ "Ext", "ppi_gps.present.ext",
FT_BOOLEAN, 32, NULL, PPI_GPS_MASK_EXT,
"Specifies if there are any extensions to the header present", HFILL } },
/* ---Now we get to the actual data fields--- */
{ &hf_ppi_gps_gpsflags_flags,
{ "GPSFlags", "ppi_gps.gpsflags",
FT_UINT32, BASE_HEX, NULL, 0x0,
"Bitmask indicating GPS/INS/manual fix", HFILL } },
{ &hf_ppi_gps_lat,
{ "Latitude", "ppi_gps.lat",
FT_DOUBLE, BASE_NONE, NULL, 0x0,
"Latitude packet was received at", HFILL } },
{ &hf_ppi_gps_lon,
{ "Longitude", "ppi_gps.lon",
FT_DOUBLE, BASE_NONE, NULL, 0x0,
"Longitude packet was received at", HFILL } },
{ &hf_ppi_gps_alt,
{ "Altitude", "ppi_gps.alt",
FT_DOUBLE, BASE_NONE, NULL, 0x0,
"Altitude packet was received at", HFILL } },
{ &hf_ppi_gps_alt_gnd,
{ "Altitude_gnd", "ppi_gps.alt_gnd",
FT_DOUBLE, BASE_NONE, NULL, 0x0,
"Altitude packet was received at (relative to ground)", HFILL } },
{ &hf_ppi_gps_gpstime,
{ "GPSTimestamp", "ppi_gps.gpstime",
FT_ABSOLUTE_TIME, ABSOLUTE_TIME_UTC, NULL, 0x0,
"GPSTimestamp packet was received at", HFILL } },
#if 0
{ &hf_ppi_gps_fractime,
{ "fractional Timestamp", "ppi_gps.fractime",
FT_DOUBLE, BASE_NONE, NULL, 0x0,
"fractional GPSTimestamp packet was received at", HFILL } },
#endif
{ &hf_ppi_gps_eph,
{ "Horizontal Error (m)", "ppi_gps.eph",
FT_DOUBLE, BASE_NONE, NULL, 0x0,
"Horizontal margin of error (meters)", HFILL } },
{ &hf_ppi_gps_epv,
{ "Vertical Error (m)", "ppi_gps.epv",
FT_DOUBLE, BASE_NONE, NULL, 0x0,
"Vertical margin of error (meters)", HFILL } },
{ &hf_ppi_gps_ept,
{ "Time Error (s)", "ppi_gps.ept",
FT_DOUBLE, BASE_NONE, NULL, 0x0,
"Time margin of error (secs)", HFILL } },
{ &hf_ppi_gps_descstr,
{ "Description", "ppi_gps.descr",
FT_STRING, BASE_NONE, NULL, 0x0,
NULL, HFILL } },
{ &hf_ppi_gps_appspecific_num,
{ "Application Specific id", "ppi_gps.appid",
FT_UINT32, BASE_HEX, NULL, 0x0,
NULL, HFILL } },
{ &hf_ppi_gps_appspecific_data,
{ "Application specific data", "ppi_gps.appdata",
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL } },
/* --- moving on to the 'FixType' flags --- */
#define PPI_GPS_GPSFLAGS_FLAG0_NOFIX 0x00000001
#define PPI_GPS_GPSFLAGS_FLAG1_GPS 0x00000002
#define PPI_GPS_GPSFLAGS_FLAG2_DIFFGPS 0x00000004
#define PPI_GPS_GPSFLAGS_FLAG3_PPS 0x00000008
#define PPI_GPS_GPSFLAGS_FLAG4_RTK 0x00000010
#define PPI_GPS_GPSFLAGS_FLAG5_FLOATRTK 0x00000020
#define PPI_GPS_GPSFLAGS_FLAG6_DEAD_RECK 0x00000040
#define PPI_GPS_GPSFLAGS_FLAG7_MANUAL 0x00000080
#define PPI_GPS_GPSFLAGS_FLAG8_SIM 0x00000100
{ &hf_ppi_gps_gpsflags_flag0_nofix, /* no fix available */
{ "No fix available", "ppi_gps.gpsflagss.nofix",
FT_BOOLEAN, 32, NULL, PPI_GPS_GPSFLAGS_FLAG0_NOFIX,
NULL, HFILL } },
{ &hf_ppi_gps_gpsflags_flag1_gpsfix, /* GPSfix available */
{ "GPS provided fix", "ppi_gps.gpsflagss.gps",
FT_BOOLEAN, 32, NULL, PPI_GPS_GPSFLAGS_FLAG1_GPS,
NULL, HFILL } },
{ &hf_ppi_gps_gpsflags_flag2_diffgps, /* Differential GPS fix available */
{ "Differential GPS provided fix", "ppi_gps.gpsflagss.diffgps",
FT_BOOLEAN, 32, NULL, PPI_GPS_GPSFLAGS_FLAG2_DIFFGPS,
NULL, HFILL } },
{ &hf_ppi_gps_gpsflags_flag3_PPS, /* PPS fix */
{ "PPS fix", "ppi_gps.gpsflagss.pps",
FT_BOOLEAN, 32, NULL, PPI_GPS_GPSFLAGS_FLAG3_PPS,
NULL, HFILL } },
{ &hf_ppi_gps_gpsflags_flag4_RTK, /* RTK fix*/
{ "RTK fix", "ppi_gps.gpsflagss.rtk",
FT_BOOLEAN, 32, NULL, PPI_GPS_GPSFLAGS_FLAG4_RTK,
NULL, HFILL } },
{ &hf_ppi_gps_gpsflags_flag5_floatRTK, /*float RTK */
{ "floatRTK fix", "ppi_gps.gpsflagss.frtk",
FT_BOOLEAN, 32, NULL, PPI_GPS_GPSFLAGS_FLAG5_FLOATRTK,
NULL, HFILL } },
{ &hf_ppi_gps_gpsflags_flag6_dead_reck, /*dead reckoning */
{ "dead reckoning fix", "ppi_gps.gpsflagss.dead_reck",
FT_BOOLEAN, 32, NULL, PPI_GPS_GPSFLAGS_FLAG6_DEAD_RECK,
NULL, HFILL } },
{ &hf_ppi_gps_gpsflags_flag7_manual, /* manual */
{ "manual fix", "ppi_gps.gpsflagss.manual",
FT_BOOLEAN, 32, NULL, PPI_GPS_GPSFLAGS_FLAG7_MANUAL,
NULL, HFILL } },
{ &hf_ppi_gps_gpsflags_flag8_sim, /* simulation */
{ "simulated fix", "ppi_gps.gpsflagss.simulation",
FT_BOOLEAN, 32, NULL, PPI_GPS_GPSFLAGS_FLAG8_SIM,
NULL, HFILL } },
};
static gint *ett[] = {
&ett_ppi_gps,
&ett_ppi_gps_present,
&ett_ppi_gps_gpsflags_flags
};
static ei_register_info ei[] = {
{ &ei_ppi_gps_present_bit, { "ppi_gps.present.unknown_bit", PI_PROTOCOL, PI_WARN, "Error: PPI-GEOLOCATION-GPS: unknown bit set in present field.", EXPFILL }},
};
expert_module_t* expert_ppi_gps;
proto_ppi_gps = proto_register_protocol("PPI Geotagging GPS tag decoder", "PPI GPS Decoder", "ppi_gps");
proto_register_field_array(proto_ppi_gps, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
expert_ppi_gps = expert_register_protocol(proto_ppi_gps);
expert_register_field_array(expert_ppi_gps, ei, array_length(ei));
register_dissector("ppi_gps", dissect_ppi_gps, proto_ppi_gps);
}
void
proto_register_frame(void)
{
static hf_register_info hf[] = {
{ &hf_frame_arrival_time,
{ "Arrival Time", "frame.time",
FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL, NULL, 0x0,
"Absolute time when this frame was captured", HFILL }},
{ &hf_frame_shift_offset,
{ "Time shift for this packet", "frame.offset_shift",
FT_RELATIVE_TIME, BASE_NONE, NULL, 0x0,
"Time shift applied to this packet", HFILL }},
{ &hf_frame_arrival_time_epoch,
{ "Epoch Time", "frame.time_epoch",
FT_RELATIVE_TIME, BASE_NONE, NULL, 0x0,
"Epoch time when this frame was captured", HFILL }},
{ &hf_frame_time_delta,
{ "Time delta from previous captured frame", "frame.time_delta",
FT_RELATIVE_TIME, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_frame_time_delta_displayed,
{ "Time delta from previous displayed frame", "frame.time_delta_displayed",
FT_RELATIVE_TIME, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_frame_time_relative,
{ "Time since reference or first frame", "frame.time_relative",
FT_RELATIVE_TIME, BASE_NONE, NULL, 0x0,
"Time relative to time reference or first frame", HFILL }},
{ &hf_frame_time_reference,
{ "This is a Time Reference frame", "frame.ref_time",
FT_NONE, BASE_NONE, NULL, 0x0,
"This frame is a Time Reference frame", HFILL }},
{ &hf_frame_number,
{ "Frame Number", "frame.number",
FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_frame_len,
{ "Frame length on the wire", "frame.len",
FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_frame_capture_len,
{ "Frame length stored into the capture file", "frame.cap_len",
FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_frame_md5_hash,
{ "Frame MD5 Hash", "frame.md5_hash",
FT_STRING, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_frame_p2p_dir,
{ "Point-to-Point Direction", "frame.p2p_dir",
FT_INT8, BASE_DEC, VALS(p2p_dirs), 0x0,
NULL, HFILL }},
{ &hf_link_number,
{ "Link Number", "frame.link_nr",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_frame_file_off,
{ "File Offset", "frame.file_off",
FT_INT64, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_frame_marked,
{ "Frame is marked", "frame.marked",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Frame is marked in the GUI", HFILL }},
{ &hf_frame_ignored,
{ "Frame is ignored", "frame.ignored",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Frame is ignored by the dissectors", HFILL }},
{ &hf_frame_protocols,
{ "Protocols in frame", "frame.protocols",
FT_STRING, BASE_NONE, NULL, 0x0,
"Protocols carried by this frame", HFILL }},
{ &hf_frame_color_filter_name,
{ "Coloring Rule Name", "frame.coloring_rule.name",
FT_STRING, BASE_NONE, NULL, 0x0,
"The frame matched the coloring rule with this name", HFILL }},
{ &hf_frame_color_filter_text,
{ "Coloring Rule String", "frame.coloring_rule.string",
FT_STRING, BASE_NONE, NULL, 0x0,
"The frame matched this coloring rule string", HFILL }},
{ &hf_frame_interface_id,
{ "Interface id", "frame.interface_id",
FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_frame_pack_flags,
{ "Packet flags", "frame.packet_flags",
FT_UINT32, BASE_HEX, NULL, 0x0,
NULL, HFILL }},
{ &hf_frame_pack_direction,
{ "Direction", "frame.packet_flags_direction",
FT_UINT32, BASE_HEX, VALS(&packet_word_directions), PACKET_WORD_DIRECTION_MASK,
NULL, HFILL }},
{ &hf_frame_pack_reception_type,
{ "Reception type", "frame.packet_flags_reception_type",
FT_UINT32, BASE_DEC, VALS(&packet_word_reception_types), PACKET_WORD_RECEPTION_TYPE_MASK,
NULL, HFILL }},
{ &hf_frame_pack_fcs_length,
{ "FCS length", "frame.packet_flags_fcs_length",
FT_UINT32, BASE_DEC, NULL, PACKET_WORD_FCS_LENGTH_MASK,
NULL, HFILL }},
{ &hf_frame_pack_reserved,
{ "Reserved", "frame.packet_flags_reserved",
FT_UINT32, BASE_DEC, NULL, PACKET_WORD_RESERVED_MASK,
NULL, HFILL }},
{ &hf_frame_pack_crc_error,
{ "CRC error", "frame.packet_flags_crc_error",
FT_BOOLEAN, 32, TFS(&tfs_set_notset), PACKET_WORD_CRC_ERR_MASK,
NULL, HFILL }},
{ &hf_frame_pack_wrong_packet_too_long_error,
{ "Packet too long error", "frame.packet_flags_packet_too_error",
FT_BOOLEAN, 32, TFS(&tfs_set_notset), PACKET_WORD_PACKET_TOO_LONG_ERR_MASK,
NULL, HFILL }},
{ &hf_frame_pack_wrong_packet_too_short_error,
{ "Packet too short error", "frame.packet_flags_packet_too_short_error",
FT_BOOLEAN, 32, TFS(&tfs_set_notset), PACKET_WORD_PACKET_TOO_SHORT_ERR_MASK,
NULL, HFILL }},
{ &hf_frame_pack_wrong_inter_frame_gap_error,
{ "Wrong interframe gap error", "frame.packet_flags_wrong_inter_frame_gap_error",
FT_BOOLEAN, 32, TFS(&tfs_set_notset), PACKET_WORD_WRONG_INTER_FRAME_GAP_ERR_MASK,
NULL, HFILL }},
{ &hf_frame_pack_unaligned_frame_error,
{ "Unaligned frame error", "frame.packet_flags_unaligned_frame_error",
FT_BOOLEAN, 32, TFS(&tfs_set_notset), PACKET_WORD_UNALIGNED_FRAME_ERR_MASK,
NULL, HFILL }},
{ &hf_frame_pack_start_frame_delimiter_error,
{ "Start frame delimiter error", "frame.packet_flags_start_frame_delimiter_error",
FT_BOOLEAN, 32, TFS(&tfs_set_notset), PACKET_WORD_START_FRAME_DELIMITER_ERR_MASK,
NULL, HFILL }},
{ &hf_frame_pack_preamble_error,
{ "Preamble error", "frame.packet_flags_preamble_error",
FT_BOOLEAN, 32, TFS(&tfs_set_notset), PACKET_WORD_PREAMBLE_ERR_MASK,
NULL, HFILL }},
{ &hf_frame_pack_symbol_error,
{ "Symbol error", "frame.packet_flags_symbol_error",
FT_BOOLEAN, 32, TFS(&tfs_set_notset), PACKET_WORD_SYMBOL_ERR_MASK,
NULL, HFILL }},
{ &hf_comments_text,
{ "Comment", "frame.comment",
FT_STRING, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_frame_num_p_prot_data,
{ "Number of per-protocol-data", "frame.p_prot_data",
FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
};
static hf_register_info hf_encap =
{ &hf_frame_wtap_encap,
{ "Encapsulation type", "frame.encap_type",
FT_INT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }};
static gint *ett[] = {
&ett_frame,
&ett_flags,
&ett_comments
};
static ei_register_info ei[] = {
{ &ei_comments_text, { "frame.comment.expert", PI_COMMENTS_GROUP, PI_COMMENT, "Formatted comment", EXPFILL }},
{ &ei_arrive_time_out_of_range, { "frame.time_invalid", PI_SEQUENCE, PI_NOTE, "Arrival Time: Fractional second out of range (0-1000000000)", EXPFILL }},
};
module_t *frame_module;
expert_module_t* expert_frame;
if (hf_encap.hfinfo.strings == NULL) {
int encap_count = wtap_get_num_encap_types();
value_string *arr;
int i;
hf_encap.hfinfo.strings = arr = g_new(value_string, encap_count+1);
for (i = 0; i < encap_count; i++) {
arr[i].value = i;
arr[i].strptr = wtap_encap_string(i);
}
arr[encap_count].value = 0;
arr[encap_count].strptr = NULL;
}
wtap_encap_dissector_table = register_dissector_table("wtap_encap",
"Wiretap encapsulation type", FT_UINT32, BASE_DEC);
proto_frame = proto_register_protocol("Frame", "Frame", "frame");
proto_pkt_comment = proto_register_protocol("Packet comments", "Pkt_Comment", "pkt_comment");
proto_register_field_array(proto_frame, hf, array_length(hf));
proto_register_field_array(proto_frame, &hf_encap, 1);
proto_register_subtree_array(ett, array_length(ett));
expert_frame = expert_register_protocol(proto_frame);
expert_register_field_array(expert_frame, ei, array_length(ei));
register_dissector("frame",dissect_frame,proto_frame);
/* You can't disable dissection of "Frame", as that would be
tantamount to not doing any dissection whatsoever. */
proto_set_cant_toggle(proto_frame);
/* Our preferences */
frame_module = prefs_register_protocol(proto_frame, NULL);
prefs_register_bool_preference(frame_module, "show_file_off",
"Show File Offset", "Show offset of frame in capture file", &show_file_off);
prefs_register_bool_preference(frame_module, "force_docsis_encap",
"Treat all frames as DOCSIS frames", "Treat all frames as DOCSIS Frames", &force_docsis_encap);
prefs_register_bool_preference(frame_module, "generate_md5_hash",
"Generate an MD5 hash of each frame",
"Whether or not MD5 hashes should be generated for each frame, useful for finding duplicate frames.",
&generate_md5_hash);
prefs_register_bool_preference(frame_module, "generate_epoch_time",
"Generate an epoch time entry for each frame",
"Whether or not an Epoch time entry should be generated for each frame.",
&generate_epoch_time);
prefs_register_bool_preference(frame_module, "generate_bits_field",
"Show the number of bits in the frame",
"Whether or not the number of bits in the frame should be shown.",
&generate_bits_field);
frame_tap=register_tap("frame");
}
void
proto_register_eapol(void)
{
static hf_register_info hf[] = {
{ &hf_eapol_version, {
"Version", "eapol.version",
FT_UINT8, BASE_DEC, VALS(eapol_version_vals), 0x0,
NULL, HFILL }},
{ &hf_eapol_type, {
"Type", "eapol.type",
FT_UINT8, BASE_DEC, VALS(eapol_type_vals), 0x0,
NULL, HFILL }},
{ &hf_eapol_len, {
"Length", "eapol.len",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_eapol_keydes_type, {
"Key Descriptor Type", "eapol.keydes.type",
FT_UINT8, BASE_DEC, VALS(eapol_keydes_type_vals), 0x0,
NULL, HFILL }},
{ &hf_eapol_keydes_key_len, {
"Key Length", "eapol.keydes.key_len",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_eapol_keydes_replay_counter, {
"Replay Counter", "eapol.keydes.replay_counter",
FT_UINT64, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_eapol_keydes_key_iv, {
"Key IV", "eapol.keydes.key_iv",
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_eapol_keydes_key_index, {
"Key Index", "eapol.keydes.key_index",
FT_UINT8, BASE_HEX, NULL, 0x0,
NULL, HFILL }},
{ &hf_eapol_keydes_key_index_type, {
"Type", "eapol.keydes.key_index.type",
FT_BOOLEAN, 8, TFS(&keytype_tfs), KEYDES_KEY_INDEX_TYPE_MASK ,
NULL, HFILL }},
{ &hf_eapol_keydes_key_index_number, {
"Number", "eapol.keydes.key_index.number",
FT_UINT8, BASE_DEC, NULL, KEYDES_KEY_INDEX_NUMBER_MASK,
NULL, HFILL }},
{ &hf_eapol_keydes_key_signature, {
"Key Signature", "eapol.keydes.key_signature",
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_eapol_keydes_key, {
"Key", "eapol.keydes.key",
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_eapol_keydes_key_generated_locally, {
"Key Generated Locally", "eapol.keydes.key.generated_locally",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_eapol_wpa_keydes_keyinfo, {
"Key Information", "eapol.keydes.key_info",
FT_UINT16, BASE_HEX, NULL, 0x0,
NULL, HFILL }},
{ &hf_eapol_wpa_keydes_keyinfo_keydes_version, {
"Key Descriptor Version", "eapol.keydes.key_info.keydes_version",
FT_UINT16, BASE_DEC, VALS(keydes_version_vals), KEY_INFO_KEYDES_VERSION_MASK,
NULL, HFILL }},
{ &hf_eapol_wpa_keydes_keyinfo_key_type, {
"Key Type", "eapol.keydes.key_info.key_type",
FT_BOOLEAN, 16, TFS(&keyinfo_key_type_tfs), KEY_INFO_KEY_TYPE_MASK,
NULL, HFILL }},
{ &hf_eapol_wpa_keydes_keyinfo_key_index, {
"Key Index", "eapol.keydes.key_info.key_index",
FT_UINT16, BASE_DEC, NULL, KEY_INFO_KEY_INDEX_MASK,
NULL, HFILL }},
{ &hf_eapol_wpa_keydes_keyinfo_install, {
"Install", "eapol.keydes.key_info.install",
FT_BOOLEAN, 16, TFS(&tfs_set_notset), KEY_INFO_INSTALL_MASK,
NULL, HFILL }},
{ &hf_eapol_wpa_keydes_keyinfo_key_ack, {
"Key ACK", "eapol.keydes.key_info.key_ack",
FT_BOOLEAN, 16, TFS(&tfs_set_notset), KEY_INFO_KEY_ACK_MASK,
NULL, HFILL }},
{ &hf_eapol_wpa_keydes_keyinfo_key_mic, {
"Key MIC", "eapol.keydes.key_info.key_mic",
FT_BOOLEAN, 16, TFS(&tfs_set_notset), KEY_INFO_KEY_MIC_MASK,
NULL, HFILL }},
{ &hf_eapol_wpa_keydes_keyinfo_secure, {
"Secure", "eapol.keydes.key_info.secure",
FT_BOOLEAN, 16, TFS(&tfs_set_notset), KEY_INFO_SECURE_MASK,
NULL, HFILL }},
{ &hf_eapol_wpa_keydes_keyinfo_error, {
"Error", "eapol.keydes.key_info.error",
FT_BOOLEAN, 16, TFS(&tfs_set_notset), KEY_INFO_ERROR_MASK,
NULL, HFILL }},
{ &hf_eapol_wpa_keydes_keyinfo_request, {
"Request", "eapol.keydes.key_info.request",
FT_BOOLEAN, 16, TFS(&tfs_set_notset), KEY_INFO_REQUEST_MASK,
NULL, HFILL }},
{ &hf_eapol_wpa_keydes_keyinfo_encrypted_key_data, {
"Encrypted Key Data", "eapol.keydes.key_info.encrypted_key_data",
FT_BOOLEAN, 16, TFS(&tfs_set_notset), KEY_INFO_ENCRYPTED_KEY_DATA_MASK,
NULL, HFILL }},
{ &hf_eapol_wpa_keydes_nonce, {
"WPA Key Nonce", "eapol.keydes.nonce",
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_eapol_wpa_keydes_rsc, {
"WPA Key RSC", "eapol.keydes.rsc",
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_eapol_wpa_keydes_id, {
"WPA Key ID", "eapol.keydes.id",
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_eapol_wpa_keydes_mic, {
"WPA Key MIC", "eapol.keydes.mic",
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_eapol_wpa_keydes_data_len, {
"WPA Key Data Length", "eapol.keydes.data_len",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_eapol_wpa_keydes_data, {
"WPA Key Data", "eapol.keydes.data",
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
};
static gint *ett[] = {
&ett_eapol,
&ett_eapol_keydes_data,
&ett_keyinfo,
&ett_eapol_key_index
};
proto_eapol = proto_register_protocol("802.1X Authentication", "EAPOL", "eapol");
eapol_handle = register_dissector("eapol", dissect_eapol, proto_eapol);
proto_register_field_array(proto_eapol, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
}
void
proto_register_nflog(void)
{
static hf_register_info hf[] = {
/* Header */
{ &hf_nflog_family,
{ "Family", "nflog.family", FT_UINT8, BASE_DEC, VALS(_linux_family_vals), 0x00, NULL, HFILL }
},
{ &hf_nflog_version,
{ "Version", "nflog.version", FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL }
},
{ &hf_nflog_resid,
{ "Resource id", "nflog.res_id", FT_UINT16, BASE_DEC, NULL, 0x00, NULL, HFILL }
},
{ &hf_nflog_encoding,
{ "Encoding", "nflog.encoding", FT_UINT32, BASE_HEX, VALS(_encoding_vals), 0x00, NULL, HFILL }
},
/* TLV */
{ &hf_nflog_tlv,
{ "TLV", "nflog.tlv", FT_BYTES, BASE_NONE, NULL, 0x00, NULL, HFILL }
},
{ &hf_nflog_tlv_length,
{ "Length", "nflog.tlv_length", FT_UINT16, BASE_DEC, NULL, 0x00, "TLV Length", HFILL }
},
{ &hf_nflog_tlv_type,
{ "Type", "nflog.tlv_type", FT_UINT16, BASE_DEC, VALS(nflog_tlv_vals), 0x7fff, "TLV Type", HFILL }
},
/* TLV values */
{ &hf_nflog_tlv_prefix,
{ "Prefix", "nflog.prefix", FT_STRINGZ, BASE_NONE, NULL, 0x00, "TLV Prefix Value", HFILL }
},
{ &hf_nflog_tlv_uid,
{ "UID", "nflog.uid", FT_INT32, BASE_DEC, NULL, 0x00, "TLV UID Value", HFILL }
},
{ &hf_nflog_tlv_gid,
{ "GID", "nflog.gid", FT_INT32, BASE_DEC, NULL, 0x00, "TLV GID Value", HFILL }
},
{ &hf_nflog_tlv_timestamp,
{ "Timestamp", "nflog.timestamp", FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL, NULL, 0x00, "TLV Timestamp Value", HFILL }
},
{ &hf_nflog_tlv_unknown,
{ "Value", "nflog.tlv_value", FT_BYTES, BASE_NONE, NULL, 0x00, "TLV Value", HFILL }
},
};
static gint *ett[] = {
&ett_nflog,
&ett_nflog_tlv
};
module_t *pref;
proto_nflog = proto_register_protocol("Linux Netfilter NFLOG", "NFLOG", "nflog");
pref = prefs_register_protocol(proto_nflog, NULL);
prefs_register_enum_preference(pref, "byte_order_type", "Byte Order", "Byte Order",
&nflog_byte_order, byte_order_types, FALSE);
register_dissector("nflog", dissect_nflog, proto_nflog);
proto_register_field_array(proto_nflog, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
}
void
proto_register_bacnet(void)
{
static hf_register_info hf[] = {
{ &hf_bacnet_version,
{ "Version", "bacnet.version",
FT_UINT8, BASE_DEC, NULL, 0,
"BACnet Version", HFILL }
},
{ &hf_bacnet_control,
{ "Control", "bacnet.control",
FT_UINT8, BASE_HEX, NULL, 0,
"BACnet Control", HFILL }
},
{ &hf_bacnet_control_net,
{ "NSDU contains",
"bacnet.control_net",
FT_BOOLEAN, 8, TFS(&control_net_set_high),
BAC_CONTROL_NET, "BACnet Control", HFILL }
},
{ &hf_bacnet_control_res1,
{ "Reserved",
"bacnet.control_res1",
FT_BOOLEAN, 8, TFS(&control_res_high),
BAC_CONTROL_RES1, "BACnet Control", HFILL }
},
{ &hf_bacnet_control_dest,
{ "Destination Specifier",
"bacnet.control_dest",
FT_BOOLEAN, 8, TFS(&control_dest_high),
BAC_CONTROL_DEST, "BACnet Control", HFILL }
},
{ &hf_bacnet_control_res2,
{ "Reserved",
"bacnet.control_res2",
FT_BOOLEAN, 8, TFS(&control_res_high),
BAC_CONTROL_RES2, "BACnet Control", HFILL }
},
{ &hf_bacnet_control_src,
{ "Source specifier",
"bacnet.control_src",
FT_BOOLEAN, 8, TFS(&control_src_high),
BAC_CONTROL_SRC, "BACnet Control", HFILL }
},
{ &hf_bacnet_control_expect,
{ "Expecting Reply",
"bacnet.control_expect",
FT_BOOLEAN, 8, TFS(&control_expect_high),
BAC_CONTROL_EXPECT, "BACnet Control", HFILL }
},
{ &hf_bacnet_control_prio_high,
{ "Priority",
"bacnet.control_prio_high",
FT_BOOLEAN, 8, TFS(&control_prio_high_high),
BAC_CONTROL_PRIO_HIGH, "BACnet Control", HFILL }
},
{ &hf_bacnet_control_prio_low,
{ "Priority",
"bacnet.control_prio_low",
FT_BOOLEAN, 8, TFS(&control_prio_low_high),
BAC_CONTROL_PRIO_LOW, "BACnet Control", HFILL }
},
{ &hf_bacnet_dnet,
{ "Destination Network Address", "bacnet.dnet",
FT_UINT16, BASE_DEC, NULL, 0,
NULL, HFILL }
},
{ &hf_bacnet_dlen,
{ "Destination MAC Layer Address Length", "bacnet.dlen",
FT_UINT8, BASE_DEC, NULL, 0,
NULL, HFILL }
},
{ &hf_bacnet_dadr_eth,
{ "Destination ISO 8802-3 MAC Address", "bacnet.dadr_eth",
FT_ETHER, BASE_NONE, NULL, 0,
NULL, HFILL }
},
{ &hf_bacnet_dadr_mstp,
{ "DADR", "bacnet.dadr_mstp",
FT_UINT8, BASE_DEC, NULL, 0,
"Destination MS/TP or ARCNET MAC Address", HFILL }
},
{ &hf_bacnet_dadr_tmp,
{ "Unknown Destination MAC", "bacnet.dadr_tmp",
FT_BYTES, BASE_NONE, NULL, 0,
NULL, HFILL }
},
{ &hf_bacnet_snet,
{ "Source Network Address", "bacnet.snet",
FT_UINT16, BASE_DEC, NULL, 0,
NULL, HFILL }
},
{ &hf_bacnet_slen,
{ "Source MAC Layer Address Length", "bacnet.slen",
FT_UINT8, BASE_DEC, NULL, 0,
NULL, HFILL }
},
{ &hf_bacnet_sadr_eth,
{ "SADR", "bacnet.sadr_eth",
FT_ETHER, BASE_NONE, NULL, 0,
"Source ISO 8802-3 MAC Address", HFILL }
},
{ &hf_bacnet_sadr_mstp,
{ "SADR", "bacnet.sadr_mstp",
FT_UINT8, BASE_DEC, NULL, 0,
"Source MS/TP or ARCNET MAC Address", HFILL }
},
{ &hf_bacnet_sadr_tmp,
{ "Unknown Source MAC", "bacnet.sadr_tmp",
FT_BYTES, BASE_NONE, NULL, 0,
NULL, HFILL }
},
{ &hf_bacnet_hopc,
{ "Hop Count", "bacnet.hopc",
FT_UINT8, BASE_DEC, NULL, 0,
NULL, HFILL }
},
{ &hf_bacnet_mesgtyp,
{ "Network Layer Message Type", "bacnet.mesgtyp",
FT_UINT8, BASE_HEX, NULL, 0,
NULL, HFILL }
},
{ &hf_bacnet_vendor,
{ "Vendor ID", "bacnet.vendor",
FT_UINT16, BASE_DEC, NULL, 0,
NULL, HFILL }
},
{ &hf_bacnet_perf,
{ "Performance Index", "bacnet.perf",
FT_UINT8, BASE_DEC, NULL, 0,
NULL, HFILL }
},
{ &hf_bacnet_rejectreason,
{ "Reject Reason", "bacnet.rejectreason",
FT_UINT8, BASE_DEC, NULL, 0,
NULL, HFILL }
},
{ &hf_bacnet_rportnum,
{ "Number of Port Mappings", "bacnet.rportnum",
FT_UINT8, BASE_DEC, NULL, 0,
NULL, HFILL }
},
{ &hf_bacnet_pinfolen,
{ "Port Info Length", "bacnet.pinfolen",
FT_UINT8, BASE_DEC, NULL, 0,
NULL, HFILL }
},
{ &hf_bacnet_portid,
{ "Port ID", "bacnet.portid",
FT_UINT8, BASE_HEX, NULL, 0,
NULL, HFILL }
},
{ &hf_bacnet_term_time_value,
{ "Termination Time Value (seconds)", "bacnet.term_time_value",
FT_UINT8, BASE_DEC, NULL, 0,
"Termination Time Value", HFILL }
}
};
static gint *ett[] = {
&ett_bacnet,
&ett_bacnet_control,
};
proto_bacnet = proto_register_protocol("Building Automation and Control Network NPDU",
"BACnet", "bacnet");
proto_register_field_array(proto_bacnet, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
register_dissector("bacnet", dissect_bacnet, proto_bacnet);
bacnet_dissector_table = register_dissector_table("bacnet.vendor",
"BACnet Vendor Identifier",
FT_UINT8, BASE_HEX);
}
void
proto_register_ax25_kiss(void)
{
/* Setup list of header fields */
static hf_register_info hf[] = {
{ &hf_ax25_kiss_cmd,
{ "Cmd", "ax25_kiss.cmd",
FT_UINT8, BASE_DEC, VALS(kiss_frame_types), KISS_CMD_MASK,
NULL, HFILL }
},
{ &hf_ax25_kiss_port,
{ "Port", "ax25_kiss.port",
FT_UINT8, BASE_DEC, NULL, KISS_PORT_MASK,
NULL, HFILL }
},
{ &hf_ax25_kiss_txdelay,
{ "Tx delay", "ax25_kiss.txdelay",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
{ &hf_ax25_kiss_persistence,
{ "Persistence", "ax25_kiss.persistence",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
{ &hf_ax25_kiss_slottime,
{ "Slot time", "ax25_kiss.slottime",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
{ &hf_ax25_kiss_txtail,
{ "Tx tail", "ax25_kiss.txtail",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
{ &hf_ax25_kiss_fullduplex,
{ "Full duplex", "ax25_kiss.fullduplex",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
{ &hf_ax25_kiss_sethardware,
{ "Set hardware", "ax25_kiss.sethardware",
FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
};
/* Setup protocol subtree array */
static gint *ett[] = {
&ett_ax25_kiss,
};
/* Register the protocol name and description */
proto_ax25_kiss = proto_register_protocol( "AX.25 KISS", "AX.25 KISS", "ax25_kiss" );
/* Register the dissector */
register_dissector( "ax25_kiss", dissect_ax25_kiss, proto_ax25_kiss );
/* Required function calls to register the header fields and subtrees used */
proto_register_field_array( proto_ax25_kiss, hf, array_length( hf ) );
proto_register_subtree_array( ett, array_length( ett ) );
}
void
proto_register_pktap(void)
{
static hf_register_info hf[] = {
{ &hf_pktap_hdrlen,
{ "Header length", "pktap.hdrlen",
FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_pktap_rectype,
{ "Record type", "pktap.rectype",
FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_pktap_dlt,
{ "DLT", "pktap.dlt",
FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_pktap_ifname, /* fixed length *and* null-terminated */
{ "Interface name", "pktap.ifname",
FT_STRINGZ, BASE_NONE, NULL, 0x0, NULL, HFILL } },
{ &hf_pktap_flags,
{ "Flags", "pktap.flags",
FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
{ &hf_pktap_pfamily,
{ "Protocol family", "pktap.pfamily",
FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_pktap_llhdrlen,
{ "Link-layer header length", "pktap.llhdrlen",
FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_pktap_lltrlrlen,
{ "Link-layer trailer length", "pktap.lltrlrlen",
FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_pktap_pid,
{ "Process ID", "pktap.pid",
FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_pktap_cmdname, /* fixed length *and* null-terminated */
{ "Command name", "pktap.cmdname",
FT_STRINGZ, BASE_NONE, NULL, 0x0, NULL, HFILL } },
{ &hf_pktap_svc_class,
{ "Service class", "pktap.svc_class",
FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_pktap_iftype,
{ "Interface type", "pktap.iftype",
FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_pktap_ifunit,
{ "Interface unit", "pktap.ifunit",
FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_pktap_epid,
{ "Effective process ID", "pktap.epid",
FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_pktap_ecmdname, /* fixed length *and* null-terminated */
{ "Effective command name", "pktap.ecmdname",
FT_STRINGZ, BASE_NONE, NULL, 0x0, NULL, HFILL } },
};
static gint *ett[] = {
&ett_pktap,
};
static ei_register_info ei[] = {
{ &ei_pktap_hdrlen_too_short,
{ "pktap.hdrlen_too_short", PI_MALFORMED, PI_ERROR,
"Header length is too short", EXPFILL }},
};
expert_module_t* expert_pktap;
proto_pktap = proto_register_protocol("PKTAP packet header", "PKTAP",
"pktap");
proto_register_field_array(proto_pktap, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
expert_pktap = expert_register_protocol(proto_pktap);
expert_register_field_array(expert_pktap, ei, array_length(ei));
pktap_handle = register_dissector("pktap", dissect_pktap, proto_pktap);
}
void
proto_register_wai(void)
{
static hf_register_info hf[] = {
{ &hf_wai_version, { "Version", "wai.version", FT_UINT16, BASE_DEC, NULL,
0x0, "Version of authentication infrastructure", HFILL }},
{ &hf_wai_type, { "Type", "wai.type", FT_UINT8, BASE_HEX, VALS(wai_type_names),
0x0, "Protocol type", HFILL }},
{ &hf_wai_subtype, { "Subtype", "wai.subtype", FT_UINT8, BASE_DEC, VALS(wai_subtype_names),
0x0, NULL, HFILL }},
{ &hf_wai_reserved, { "Reserved", "wai.reserved", FT_UINT16, BASE_HEX, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_length, { "Length", "wai.length", FT_UINT16, BASE_DEC, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_seq, { "Sequence number", "wai.seq", FT_UINT16, BASE_DEC, NULL,
0x0, "Packet sequence number", HFILL }},
{ &hf_wai_fragm_seq, { "Fragment sequence number", "wai.fragm.seq", FT_UINT8, BASE_DEC, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_flag, { "Flag", "wai.flag", FT_UINT8, BASE_HEX, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_data, { "Data", "wai.data", FT_BYTES, BASE_NONE, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_bk_rekeying_flag, {"BK rekeying", "wai.bk.rekeying.flag", FT_BOOLEAN, 8, TFS (&wai_bk_rekeying_flag),
FLAG_BIT0, "BK rekeying flag", HFILL }},
{ &hf_wai_preauthentication_flag,{"Pre-Authentication", "wai.preauthentication.flag", FT_BOOLEAN, 8, TFS (&wai_preauthentication_flag),
FLAG_BIT1, "Pre-Authentication flag", HFILL }},
{ &hf_wai_certificate_flag,{"Certificate", "wai.certificate.flag", FT_BOOLEAN, 8, TFS (&wai_certificate_flag),
FLAG_BIT2, "Certificate flag", HFILL }},
{ &hf_wai_optional_flag,{"Optional", "wai.optional.flag", FT_BOOLEAN, 8, TFS (&wai_optional_flag),
FLAG_BIT3, "Optional flag", HFILL }},
{ &hf_wai_usk_rekeying_flag,{"USK rekeying", "wai.usk.rekeying.flag", FT_BOOLEAN, 8, TFS (&wai_usk_rekeying_flag),
FLAG_BIT4, "USK rekeying flag", HFILL }},
{ &hf_wai_negotiation_flag,{"STA negotiation", "wai.negotiation.flag", FT_BOOLEAN, 8, TFS (&wai_negotiation_flag),
FLAG_BIT5, "STA negotiation flag", HFILL }},
{ &hf_wai_revoking_flag,{"STA revoking", "wai.revoking.flag", FT_BOOLEAN, 8, TFS (&wai_revoking_flag),
FLAG_BIT6, "STA revoking flag", HFILL }},
{ &hf_wai_reserved_flag,{"Reserved", "wai.reserved.flag", FT_BOOLEAN, 8, TFS (&wai_reserved_flag),
FLAG_BIT7, "Reserved flag", HFILL }},
{ &hf_wai_cert, {"Certificate", "wai.cert", FT_BYTES, BASE_NONE, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_cert_id, {"Id", "wai.cert.id", FT_UINT16, BASE_HEX, NULL,
0x0, "Certificate Id", HFILL }},
{ &hf_wai_cert_data, {"Data", "wai.cert.data", FT_BYTES, BASE_NONE, NULL,
0x0, "Certificate data", HFILL }},
{ &hf_wai_cert_len, {"Length", "wai.cert.len", FT_UINT16, BASE_DEC, NULL,
0x0, "Certificate length", HFILL }},
{ &hf_wai_addid, {"ADDID", "wai.addid", FT_STRING, BASE_NONE, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_ae_mac, {"AE MAC", "wai.ae.mac", FT_ETHER, BASE_NONE, NULL,
0x0, "AE MAC address", HFILL }},
{ &hf_wai_asue_mac, {"ASUE MAC", "wai.asue.mac", FT_ETHER, BASE_NONE, NULL,
0x0, "ASUE MAC address", HFILL }},
{ &hf_wai_bkid, {"BKID", "wai.bkid", FT_BYTES, BASE_NONE, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_uskid, {"USKID", "wai.uskid", FT_BYTES, BASE_NONE, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_wie, {"WIE from ASUE", "wai.wie", FT_BYTES, BASE_NONE, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_message_auth_code, {"Message Authentication Code", "wai.message.auth.code", FT_BYTES, BASE_NONE, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_mskid, {"MSKID/STAKeyID", "wai.mskid", FT_BYTES, BASE_NONE, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_data_pack_num, {"Data packet number", "wai.data.packet.num", FT_BYTES, BASE_NONE, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_key_data, {"Key Data", "wai.key.data", FT_BYTES, BASE_NONE, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_key_data_len, {"Length", "wai.key.data.len", FT_UINT8, BASE_DEC, NULL,
0x0, "Key data length", HFILL }},
{ &hf_wai_key_data_content, {"Content", "wai.key.data.content", FT_BYTES, BASE_NONE, NULL,
0x0, "Key data content", HFILL }},
{ &hf_wai_key_ann_id, {"Key Announcement Identifier", "wai.key.ann.id", FT_BYTES, BASE_NONE, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_auth_id, {"Authentication Identifier", "wai.auth.id", FT_BYTES, BASE_NONE, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_identity, {"Identifier", "wai.identity", FT_BYTES, BASE_NONE, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_identity_id, {"Id", "wai.identity.id", FT_UINT16, BASE_HEX, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_identity_len, {"Length", "wai.identity.len", FT_UINT16, BASE_DEC, NULL,
0x0, "Identity length", HFILL }},
{ &hf_wai_identity_data, {"Data", "wai.identity.data", FT_BYTES, BASE_NONE, NULL,
0x0, "Identity data", HFILL }},
{ &hf_wai_ecdh, {"ECDH Parameter", "wai.ecdhp", FT_BYTES, BASE_NONE, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_ecdh_id, {"ID", "wai.edch.id", FT_UINT8, BASE_HEX, NULL,
0x0, "ECDH Parameter Identifier", HFILL }},
{ &hf_wai_ecdh_len, {"Length", "wai.ecdh.len", FT_UINT16, BASE_DEC, NULL,
0x0, "ECDH Parameter Length", HFILL }},
{ &hf_wai_ecdh_content, {"Content", "wai.ecdh.content", FT_BYTES, BASE_NONE, NULL,
0x0, "ECDH Parameter Content", HFILL }},
{ &hf_wai_counter, {"Replay counter", "wai.counter", FT_BYTES, BASE_NONE, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_sta_key_id, {"STAKeyID", "wai.sta.key.id", FT_UINT8, BASE_HEX, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_challenge, {"Challenge", "wai.challenge", FT_BYTES, BASE_NONE, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_cert_ver, {"Multiple Certificate Verification Result", "wai.cert.ver", FT_BYTES, BASE_NONE, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_nonce, {"Nonce", "wai.nonce", FT_BYTES, BASE_NONE, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_ver_res, {"Verification result", "wai.ver.res", FT_UINT8, BASE_HEX, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_sign_alg, {"Signature Algorithm", "wai.sign.alg", FT_BYTES, BASE_NONE, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_hash_alg_id, {"Hash Algorithm Identifier", "wai.hash.alg.id", FT_UINT8, BASE_HEX, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_sign_alg_id, {"Signature Algorithm Identifier", "wai.sign.alg.id", FT_UINT8, BASE_HEX, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_param, {"Parameter", "wai.param", FT_BYTES, BASE_NONE, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_param_id, {"Parameter Identifier", "wai.param.id", FT_BYTES, BASE_NONE, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_param_content, {"Parameter Content", "wai.param.content", FT_BYTES, BASE_NONE, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_sign_val, {"Signature Value", "wai.sign.val", FT_BYTES, BASE_NONE, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_sign_content, {"Signature Content", "wai.sign.content", FT_BYTES, BASE_NONE, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_sign, {"Signature", "wai.sign", FT_BYTES, BASE_NONE, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_identity_list, {"ASU List trusted by ASUE", "wai.identity_list", FT_BYTES, BASE_NONE, NULL,
0x0, "Identity list", HFILL }},
{ &hf_wai_reserved_byte, {"Reserved", "wai.reserved.byte", FT_UINT8, BASE_HEX, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_no_of_ids, {"Number of Identities", "wai.no.of.ids", FT_UINT16, BASE_DEC, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_access_res, {"Access result", "wai.access_result", FT_UINT8, BASE_HEX, NULL,
0x0, NULL, HFILL }},
{ &hf_wai_fragments,{"Message fragments", "wai.fragments",FT_NONE, BASE_NONE, NULL,
0x00, NULL, HFILL }},
{ &hf_wai_fragment,{"Message fragment", "wai.fragment",FT_FRAMENUM, BASE_NONE, NULL,
0x00, NULL, HFILL }},
{ &hf_wai_fragment_overlap,{"Message fragment overlap", "wai.fragment.overlap",FT_BOOLEAN, BASE_NONE, NULL,
0x00, NULL, HFILL }},
{ &hf_wai_fragment_overlap_conflicts,{"Message fragment overlapping with conflicting data","wai.fragment.overlap.conflicts",FT_BOOLEAN, BASE_NONE, NULL,
0x00, NULL, HFILL }},
{ &hf_wai_fragment_multiple_tails,{"Message has multiple tail fragments","wai.fragment.multiple_tails",FT_BOOLEAN, BASE_NONE, NULL,
0x00, NULL, HFILL }},
{ &hf_wai_fragment_too_long_fragment,{"Message fragment too long", "wai.fragment.too_long_fragment",FT_BOOLEAN, BASE_NONE, NULL,
0x00, NULL, HFILL }},
{ &hf_wai_fragment_error,{"Message defragmentation error", "wai.fragment.error",FT_FRAMENUM, BASE_NONE, NULL,
0x00, NULL, HFILL }},
{ &hf_wai_fragment_count,{"Message fragment count", "wai.fragment.count",FT_UINT32, BASE_DEC, NULL,
0x00, NULL, HFILL }},
{ &hf_wai_reassembled_in,{"Reassembled in", "wai.reassembled.in",FT_FRAMENUM, BASE_NONE, NULL,
0x00, NULL, HFILL }},
{ &hf_wai_reassembled_length,{"Reassembled length", "wai.reassembled.length",FT_UINT32, BASE_DEC, NULL,
0x00, NULL, HFILL }}
};
static gint *ett[] = {
&ett_wai,
&ett_wai_data,
&ett_wai_flags,
&ett_wai_certificate,
&ett_wai_mac,
&ett_wai_identity,
&ett_wai_key_data,
&ett_wai_ecdh_param,
&ett_wai_certificate_verification,
&ett_wai_identity_list,
&ett_wai_sign,
&ett_wai_sign_alg,
&ett_wai_sign_val,
&ett_wai_parameter,
&ett_wai_fragment,
&ett_wai_fragments
};
proto_wai = proto_register_protocol("WAI Protocol", "WAI", "wai");
register_init_routine(&wai_reassemble_init);
proto_register_field_array(proto_wai, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
register_dissector("wai", dissect_wai, proto_wai);
}
void
proto_register_frame(void)
{
static hf_register_info hf[] = {
{ &hf_frame_arrival_time,
{ "Arrival Time", "frame.time", FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL, NULL, 0x0,
"Absolute time when this frame was captured", HFILL }},
{ &hf_frame_arrival_time_epoch,
{ "Epoch Time", "frame.time_epoch", FT_RELATIVE_TIME, BASE_NONE, NULL, 0x0,
"Epoch time when this frame was captured", HFILL }},
{ &hf_frame_time_invalid,
{ "Arrival Timestamp invalid", "frame.time_invalid", FT_NONE, BASE_NONE, NULL, 0x0,
"The timestamp from the capture is out of the valid range", HFILL }},
{ &hf_frame_time_delta,
{ "Time delta from previous captured frame", "frame.time_delta", FT_RELATIVE_TIME, BASE_NONE, NULL,
0x0,
NULL, HFILL }},
{ &hf_frame_time_delta_displayed,
{ "Time delta from previous displayed frame", "frame.time_delta_displayed", FT_RELATIVE_TIME, BASE_NONE, NULL,
0x0,
NULL, HFILL }},
{ &hf_frame_time_relative,
{ "Time since reference or first frame", "frame.time_relative", FT_RELATIVE_TIME, BASE_NONE, NULL,
0x0,
"Time relative to time reference or first frame", HFILL }},
{ &hf_frame_time_reference,
{ "This is a Time Reference frame", "frame.ref_time", FT_NONE, BASE_NONE, NULL, 0x0,
"This frame is a Time Reference frame", HFILL }},
{ &hf_frame_number,
{ "Frame Number", "frame.number", FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_frame_len,
{ "Frame length on the wire", "frame.len", FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_frame_capture_len,
{ "Frame length stored into the capture file", "frame.cap_len", FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_frame_md5_hash,
{ "Frame MD5 Hash", "frame.md5_hash", FT_STRING, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_frame_p2p_dir,
{ "Point-to-Point Direction", "frame.p2p_dir", FT_INT8, BASE_DEC, VALS(p2p_dirs), 0x0,
NULL, HFILL }},
{ &hf_link_number,
{ "Link Number", "frame.link_nr", FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_frame_file_off,
{ "File Offset", "frame.file_off", FT_INT64, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_frame_marked,
{ "Frame is marked", "frame.marked", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Frame is marked in the GUI", HFILL }},
{ &hf_frame_ignored,
{ "Frame is ignored", "frame.ignored", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Frame is ignored by the dissectors", HFILL }},
{ &hf_frame_protocols,
{ "Protocols in frame", "frame.protocols", FT_STRING, BASE_NONE, NULL, 0x0,
"Protocols carried by this frame", HFILL }},
{ &hf_frame_color_filter_name,
{ "Coloring Rule Name", "frame.coloring_rule.name", FT_STRING, BASE_NONE, NULL, 0x0,
"The frame matched the coloring rule with this name", HFILL }},
{ &hf_frame_color_filter_text,
{ "Coloring Rule String", "frame.coloring_rule.string", FT_STRING, BASE_NONE, NULL, 0x0,
"The frame matched this coloring rule string", HFILL }}
};
static gint *ett[] = {
&ett_frame
};
module_t *frame_module;
wtap_encap_dissector_table = register_dissector_table("wtap_encap",
"Wiretap encapsulation type", FT_UINT32, BASE_DEC);
proto_frame = proto_register_protocol("Frame", "Frame", "frame");
proto_register_field_array(proto_frame, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
register_dissector("frame",dissect_frame,proto_frame);
/* You can't disable dissection of "Frame", as that would be
tantamount to not doing any dissection whatsoever. */
proto_set_cant_toggle(proto_frame);
proto_short = proto_register_protocol("Short Frame", "Short frame", "short");
proto_malformed = proto_register_protocol("Malformed Packet",
"Malformed packet", "malformed");
proto_unreassembled = proto_register_protocol(
"Unreassembled Fragmented Packet",
"Unreassembled fragmented packet", "unreassembled");
/* "Short Frame", "Malformed Packet", and "Unreassembled Fragmented
Packet" aren't really protocols, they're error indications;
disabling them makes no sense. */
proto_set_cant_toggle(proto_short);
proto_set_cant_toggle(proto_malformed);
proto_set_cant_toggle(proto_unreassembled);
/* Our preferences */
frame_module = prefs_register_protocol(proto_frame, NULL);
prefs_register_bool_preference(frame_module, "show_file_off",
"Show File Offset", "Show offset of frame in capture file", &show_file_off);
prefs_register_bool_preference(frame_module, "force_docsis_encap",
"Treat all frames as DOCSIS frames", "Treat all frames as DOCSIS Frames", &force_docsis_encap);
prefs_register_bool_preference(frame_module, "generate_md5_hash",
"Generate an MD5 hash of each frame",
"Whether or not MD5 hashes should be generated for each frame, useful for finding duplicate frames.",
&generate_md5_hash);
prefs_register_bool_preference(frame_module, "generate_epoch_time",
"Generate an epoch time entry for each frame",
"Whether or not an Epoch time entry should be generated for each frame.",
&generate_epoch_time);
prefs_register_bool_preference(frame_module, "generate_bits_field",
"Show the number of bits in the frame",
"Whether or not the number of bits in the frame should be shown.",
&generate_bits_field);
frame_tap=register_tap("frame");
}
/* Wireshark Protocol Registration */
void
proto_register_t38(void)
{
static hf_register_info hf[] =
{
#include "packet-t38-hfarr.c"
{ &hf_t38_setup,
{ "Stream setup", "t38.setup", FT_STRING, BASE_NONE,
NULL, 0x0, "Stream setup, method and frame number", HFILL }},
{ &hf_t38_setup_frame,
{ "Stream frame", "t38.setup-frame", FT_FRAMENUM, BASE_NONE,
NULL, 0x0, "Frame that set up this stream", HFILL }},
{ &hf_t38_setup_method,
{ "Stream Method", "t38.setup-method", FT_STRING, BASE_NONE,
NULL, 0x0, "Method used to set up this stream", HFILL }},
{&hf_t38_fragments,
{"Message fragments", "t38.fragments",
FT_NONE, BASE_NONE, NULL, 0x00, NULL, HFILL } },
{&hf_t38_fragment,
{"Message fragment", "t38.fragment",
FT_FRAMENUM, BASE_NONE, NULL, 0x00, NULL, HFILL } },
{&hf_t38_fragment_overlap,
{"Message fragment overlap", "t38.fragment.overlap",
FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } },
{&hf_t38_fragment_overlap_conflicts,
{"Message fragment overlapping with conflicting data",
"t38.fragment.overlap.conflicts",
FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } },
{&hf_t38_fragment_multiple_tails,
{"Message has multiple tail fragments",
"t38.fragment.multiple_tails",
FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } },
{&hf_t38_fragment_too_long_fragment,
{"Message fragment too long", "t38.fragment.too_long_fragment",
FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } },
{&hf_t38_fragment_error,
{"Message defragmentation error", "t38.fragment.error",
FT_FRAMENUM, BASE_NONE, NULL, 0x00, NULL, HFILL } },
{&hf_t38_reassembled_in,
{"Reassembled in", "t38.reassembled.in",
FT_FRAMENUM, BASE_NONE, NULL, 0x00, NULL, HFILL } },
};
static gint *ett[] =
{
&ett_t38,
#include "packet-t38-ettarr.c"
&ett_t38_setup,
&ett_data_fragment,
&ett_data_fragments
};
module_t *t38_module;
proto_t38 = proto_register_protocol("T.38", "T.38", "t38");
proto_register_field_array(proto_t38, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
register_dissector("t38", dissect_t38, proto_t38);
/* Init reassemble tables for HDLC */
register_init_routine(t38_defragment_init);
t38_tap = register_tap("t38");
t38_module = prefs_register_protocol(proto_t38, proto_reg_handoff_t38);
prefs_register_bool_preference(t38_module, "use_pre_corrigendum_asn1_specification",
"Use the Pre-Corrigendum ASN.1 specification",
"Whether the T.38 dissector should decode using the Pre-Corrigendum T.38 "
"ASN.1 specification (1998).",
&use_pre_corrigendum_asn1_specification);
prefs_register_bool_preference(t38_module, "dissect_possible_rtpv2_packets_as_rtp",
"Dissect possible RTP version 2 packets with RTP dissector",
"Whether a UDP packet that looks like RTP version 2 packet will "
"be dissected as RTP packet or T.38 packet. If enabled there is a risk that T.38 UDPTL "
"packets with sequence number higher than 32767 may be dissected as RTP.",
&dissect_possible_rtpv2_packets_as_rtp);
prefs_register_uint_preference(t38_module, "tcp.port",
"T.38 TCP Port",
"Set the TCP port for T.38 messages",
10, &global_t38_tcp_port);
prefs_register_uint_preference(t38_module, "udp.port",
"T.38 UDP Port",
"Set the UDP port for T.38 messages",
10, &global_t38_udp_port);
prefs_register_bool_preference(t38_module, "reassembly",
"Reassemble T.38 PDUs over TPKT over TCP",
"Whether the dissector should reassemble T.38 PDUs spanning multiple TCP segments "
"when TPKT is used over TCP. "
"To use this option, you must also enable \"Allow subdissectors to reassemble "
"TCP streams\" in the TCP protocol settings.",
&t38_tpkt_reassembly);
prefs_register_enum_preference(t38_module, "tpkt_usage",
"TPKT used over TCP",
"Whether T.38 is used with TPKT for TCP",
(gint *)&t38_tpkt_usage,t38_tpkt_options,FALSE);
prefs_register_bool_preference(t38_module, "show_setup_info",
"Show stream setup information",
"Where available, show which protocol and frame caused "
"this T.38 stream to be created",
&global_t38_show_setup_info);
}
void
proto_register_rtsp(void)
{
static gint *ett[] = {
&ett_rtspframe,
&ett_rtsp,
&ett_rtsp_method,
};
static hf_register_info hf[] = {
{ &hf_rtsp_request,
{ "Request", "rtsp.request", FT_STRING, BASE_NONE, NULL, 0,
NULL, HFILL }},
{ &hf_rtsp_response,
{ "Response", "rtsp.response", FT_STRING, BASE_NONE, NULL, 0,
NULL, HFILL }},
{ &hf_rtsp_method,
{ "Method", "rtsp.method", FT_STRING, BASE_NONE, NULL, 0,
NULL, HFILL }},
{ &hf_rtsp_content_type,
{ "Content-type", "rtsp.content-type", FT_STRING, BASE_NONE, NULL, 0,
NULL, HFILL }},
{ &hf_rtsp_content_length,
{ "Content-length", "rtsp.content-length", FT_UINT32, BASE_DEC, NULL, 0,
NULL, HFILL }},
{ &hf_rtsp_url,
{ "URL", "rtsp.url", FT_STRING, BASE_NONE, NULL, 0,
NULL, HFILL }},
{ &hf_rtsp_status,
{ "Status", "rtsp.status", FT_UINT32, BASE_DEC, NULL, 0,
NULL, HFILL }},
{ &hf_rtsp_session,
{ "Session", "rtsp.session", FT_STRING, BASE_NONE, NULL, 0,
NULL, HFILL }},
{ &hf_rtsp_transport,
{ "Transport", "rtsp.transport", FT_STRING, BASE_NONE, NULL, 0,
NULL, HFILL }},
{ &hf_rtsp_rdtfeaturelevel,
{ "RDTFeatureLevel", "rtsp.rdt-feature-level", FT_UINT32, BASE_DEC, NULL, 0,
NULL, HFILL }},
{ &hf_rtsp_X_Vig_Msisdn,
{ "X-Vig-Msisdn", "X_Vig_Msisdn", FT_STRING, BASE_NONE, NULL, 0,
NULL, HFILL }},
};
module_t *rtsp_module;
proto_rtsp = proto_register_protocol("Real Time Streaming Protocol",
"RTSP", "rtsp");
proto_register_field_array(proto_rtsp, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
/* Make this dissector findable by name */
register_dissector("rtsp", dissect_rtsp, proto_rtsp);
/* Register our configuration options, particularly our ports */
rtsp_module = prefs_register_protocol(proto_rtsp, proto_reg_handoff_rtsp);
prefs_register_uint_preference(rtsp_module, "tcp.port",
"RTSP TCP Port",
"Set the TCP port for RTSP messages",
10, &global_rtsp_tcp_port);
prefs_register_uint_preference(rtsp_module, "tcp.alternate_port",
"Alternate RTSP TCP Port",
"Set the alternate TCP port for RTSP messages",
10, &global_rtsp_tcp_alternate_port);
prefs_register_bool_preference(rtsp_module, "desegment_headers",
"Reassemble RTSP headers spanning multiple TCP segments",
"Whether the RTSP dissector should reassemble headers "
"of a request spanning multiple TCP segments. "
" To use this option, you must also enable \"Allow subdissectors to reassemble TCP streams\" in the TCP protocol settings.",
&rtsp_desegment_headers);
prefs_register_bool_preference(rtsp_module, "desegment_body",
"Trust the \"Content-length:\" header and\ndesegment RTSP "
"bodies\nspanning multiple TCP segments",
"Whether the RTSP dissector should use the "
"\"Content-length:\" value to desegment the body "
"of a request spanning multiple TCP segments",
&rtsp_desegment_body);
}
void proto_register_turbocell(void)
{
static hf_register_info hf[] = {
{ &hf_turbocell_type,
{ "Packet Type", "turbocell.type",
FT_UINT8, BASE_HEX, VALS(turbocell_type_values), 0,
NULL, HFILL }
},
{ &hf_turbocell_satmode,
{ "Satellite Mode", "turbocell.satmode",
FT_UINT8, BASE_HEX, VALS(turbocell_satmode_values), 0xF0,
NULL, HFILL }
},
{ &hf_turbocell_nwid,
{ "Network ID", "turbocell.nwid",
FT_UINT8, BASE_DEC, NULL, 0x0F,
NULL, HFILL }
},
{ &hf_turbocell_counter,
{ "Counter", "turbocell.counter",
FT_UINT24, BASE_DEC_HEX, NULL, 0,
"Increments every frame (per station)", HFILL }
},
{ &hf_turbocell_dst,
{ "Destination", "turbocell.dst",
FT_ETHER, BASE_NONE, NULL, 0,
"Seems to be the destination", HFILL }
},
{ &hf_turbocell_ip,
{ "IP", "turbocell.ip",
FT_IPv4, BASE_NONE, NULL, 0,
"IP address of base station ?", HFILL }
},
{ &hf_turbocell_unknown,
{ "Unknown", "turbocell.unknown",
FT_UINT16, BASE_HEX, NULL, 0,
"Always 0000", HFILL }
},
{ &hf_turbocell_timestamp,
{ "Timestamp (in 10 ms)", "turbocell.timestamp",
FT_UINT24, BASE_DEC_HEX, NULL, 0,
"Timestamp per station (since connection?)", HFILL }
},
{ &hf_turbocell_name,
{ "Network Name", "turbocell.name",
FT_STRINGZ, BASE_NONE, NULL, 0,
NULL, HFILL }
},
{ &hf_turbocell_station,
{ "Station", "turbocell.station",
FT_ETHER, BASE_NONE, NULL, 0,
"connected stations / satellites ?", HFILL },
}
};
static hf_register_info aggregate_fields[] = {
{ &hf_turbocell_aggregate_msdu_header_text,
{"MAC Service Data Unit (MSDU)", "turbocell_aggregate.msduheader",
FT_UINT16, BASE_DEC, 0, 0x0000, NULL, HFILL }
},
{ &hf_turbocell_aggregate_msdu_len,
{"MSDU length", "turbocell_aggregate.msdulen",
FT_UINT16, BASE_DEC_HEX, 0, 0x0FFF, NULL, HFILL }
},
{ &hf_turbocell_aggregate_len,
{ "Total Length", "turbocell_aggregate.len",
FT_UINT16, BASE_DEC_HEX, NULL, 0,
"Total reported length", HFILL }
},
{ &hf_turbocell_aggregate_unknown1,
{ "Unknown", "turbocell_aggregate.unknown1",
FT_UINT16, BASE_HEX, NULL, 0,
"Always 0x7856", HFILL }
},
{ &hf_turbocell_aggregate_unknown2,
{ "Unknown", "turbocell_aggregate.unknown2",
FT_UINT8, BASE_HEX, NULL, 0xF0,
"have the values 0x4,0xC or 0x8", HFILL }
},
};
static gint *ett[] = {
&ett_turbocell,
&ett_network,
&ett_msdu_aggregation_parent_tree,
&ett_msdu_aggregation_subframe_tree
};
proto_turbocell = proto_register_protocol("Turbocell Header", "Turbocell", "turbocell");
proto_aggregate = proto_register_protocol("Turbocell Aggregate Data",
"Turbocell Aggregate Data", "turbocell_aggregate");
proto_register_field_array(proto_aggregate, aggregate_fields, array_length(aggregate_fields));
register_dissector("turbocell", dissect_turbocell, proto_turbocell);
proto_register_field_array(proto_turbocell, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
}
/*FUNCTION:------------------------------------------------------
* NAME
* proto_register_zep
* DESCRIPTION
* IEEE 802.15.4 protocol registration routine.
* PARAMETERS
* none
* RETURNS
* void
*---------------------------------------------------------------
*/
void proto_register_zep(void)
{
module_t *zep_module;
static hf_register_info hf[] = {
{ &hf_zep_version,
{ "Protocol Version", "zep.version", FT_UINT8, BASE_DEC, NULL, 0x0,
"The version of the sniffer.", HFILL }},
{ &hf_zep_type,
{ "Type", "zep.type", FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_zep_channel_id,
{ "Channel ID", "zep.channel_id", FT_UINT8, BASE_DEC, NULL, 0x0,
"The logical channel on which this packet was detected.", HFILL }},
{ &hf_zep_device_id,
{ "Device ID", "zep.device_id", FT_UINT16, BASE_DEC, NULL, 0x0,
"The ID of the device that detected this packet.", HFILL }},
{ &hf_zep_lqi_mode,
{ "LQI/CRC Mode", "zep.lqi_mode", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Determines what format the last two bytes of the MAC frame use.", HFILL }},
{ &hf_zep_lqi,
{ "Link Quality Indication", "zep.lqi", FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_zep_timestamp,
{ "Timestamp", "zep.time", FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL, NULL, 0x0,
NULL, HFILL }},
{ &hf_zep_seqno,
{ "Sequence Number", "zep.seqno", FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_zep_ieee_length,
{ "Length", "zep.length", FT_UINT8, BASE_DEC, NULL, 0x0,
"The length (in bytes) of the encapsulated IEEE 802.15.4 MAC frame.", HFILL }},
};
static gint *ett[] = {
&ett_zep
};
/* Register protocol name and description. */
proto_zep = proto_register_protocol("ZigBee Encapsulation Protocol", "ZEP", "zep");
/* Register header fields and subtrees. */
proto_register_field_array(proto_zep, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
/* Register preferences module */
zep_module = prefs_register_protocol(proto_zep, proto_reg_handoff_zep);
/* Register preferences */
prefs_register_uint_preference(zep_module, "udp.port", "ZEP UDP port",
"Set the port for ZEP Protocol\n"
"Default port is 17754",
10, &gPREF_zep_udp_port);
/* Register dissector with Wireshark. */
zep_handle = register_dissector("zep", dissect_zep, proto_zep);
} /* proto_register_zep */
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 }},
};
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);
}
void
proto_register_btobex(void)
{
static hf_register_info hf[] = {
{ &hf_opcode,
{ "Opcode", "btobex.opcode",
FT_UINT8, BASE_HEX|BASE_EXT_STRING, &code_vals_ext, BTOBEX_CODE_VALS_MASK,
"Request Opcode", HFILL}
},
{ &hf_response_code,
{ "Response Code", "btobex.resp_code",
FT_UINT8, BASE_HEX|BASE_EXT_STRING, &code_vals_ext, BTOBEX_CODE_VALS_MASK,
NULL, HFILL}
},
{ &hf_final_flag,
{ "Final Flag", "btobex.final_flag",
FT_BOOLEAN, 8, NULL, 0x80,
NULL, HFILL}
},
{ &hf_length,
{ "Packet Length", "btobex.pkt_len",
FT_UINT16, BASE_DEC, NULL, 0,
NULL, HFILL}
},
{ &hf_version,
{ "Version", "btobex.version",
FT_UINT8, BASE_HEX, VALS(version_vals), 0x00,
"Obex Protocol Version", HFILL}
},
{ &hf_flags,
{ "Flags", "btobex.flags",
FT_UINT8, BASE_HEX, NULL, 0x00,
NULL, HFILL}
},
{ &hf_constants,
{ "Constants", "btobex.constants",
FT_UINT8, BASE_HEX, NULL, 0x00,
NULL, HFILL}
},
{ &hf_max_pkt_len,
{ "Max. Packet Length", "btobex.max_pkt_len",
FT_UINT16, BASE_DEC, NULL, 0,
NULL, HFILL}
},
{ &hf_set_path_flags_0,
{ "Go back one folder (../) first", "btobex.set_path_flags_0",
FT_BOOLEAN, 8, NULL, 0x01,
NULL, HFILL}
},
{ &hf_set_path_flags_1,
{ "Do not create folder, if not existing", "btobex.set_path_flags_1",
FT_BOOLEAN, 8, NULL, 0x02,
NULL, HFILL}
},
{ &hf_hdr_id,
{ "Header Id", "btobex.hdr_id",
FT_UINT8, BASE_HEX|BASE_EXT_STRING, &header_id_vals_ext, 0x00,
NULL, HFILL}
},
{ &hf_hdr_length,
{ "Length", "btobex.pkt_hdr_len",
FT_UINT16, BASE_DEC, NULL, 0,
"Header Length", HFILL}
},
{ &hf_hdr_val_unicode,
{ "Value", "btobex.pkt_hdr_val_uc",
FT_STRING, BASE_NONE, NULL, 0,
"Unicode Value", HFILL }
},
{ &hf_hdr_val_byte_seq,
{ "Value", "btobex.hdr_val_byte_seq",
FT_BYTES, BASE_NONE, NULL, 0,
"Byte Value", HFILL}
},
{ &hf_hdr_val_byte,
{ "Value", "btobex.hdr_val_byte",
FT_UINT8, BASE_HEX, NULL, 0,
"Byte Sequence Value", HFILL}
},
{ &hf_hdr_val_long,
{ "Value", "btobex.hdr_val_long",
FT_UINT32, BASE_DEC, NULL, 0,
"4-byte Value", HFILL}
},
/* for fragmentation */
{ &hf_btobex_fragment_overlap,
{ "Fragment overlap", "btobex.fragment.overlap", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Fragment overlaps with other fragments", HFILL }
},
{ &hf_btobex_fragment_overlap_conflict,
{ "Conflicting data in fragment overlap", "btobex.fragment.overlap.conflict", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Overlapping fragments contained conflicting data", HFILL }
},
{ &hf_btobex_fragment_multiple_tails,
{ "Multiple tail fragments found", "btobex.fragment.multipletails", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Several tails were found when defragmenting the packet", HFILL }
},
{ &hf_btobex_fragment_too_long_fragment,
{ "Fragment too long", "btobex.fragment.toolongfragment", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Fragment contained data past end of packet", HFILL }
},
{ &hf_btobex_fragment_error,
{ "Defragmentation error", "btobex.fragment.error", FT_FRAMENUM, BASE_NONE, NULL, 0x0,
"Defragmentation error due to illegal fragments", HFILL }
},
{ &hf_btobex_fragment_count,
{ "Fragment count", "btobex.fragment.count", FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
{ &hf_btobex_fragment,
{ "OBEX Fragment", "btobex.fragment", FT_FRAMENUM, BASE_NONE, NULL, 0x0,
"btobex Fragment", HFILL }
},
{ &hf_btobex_fragments,
{ "OBEX Fragments", "btobex.fragments", FT_NONE, BASE_NONE, NULL, 0x0,
"btobex Fragments", HFILL }
},
{ &hf_btobex_reassembled_in,
{ "Reassembled OBEX in frame", "btobex.reassembled_in", FT_FRAMENUM, BASE_NONE, NULL, 0x0,
"This OBEX frame is reassembled in this frame", HFILL }
},
{ &hf_btobex_reassembled_length,
{ "Reassembled OBEX length", "btobex.reassembled.length", FT_UINT32, BASE_DEC, NULL, 0x0,
"The total length of the reassembled payload", HFILL }
}
};
/* Setup protocol subtree array */
static gint *ett[] = {
&ett_btobex,
&ett_btobex_hdrs,
&ett_btobex_hdr,
&ett_btobex_fragment,
&ett_btobex_fragments
};
proto_btobex = proto_register_protocol("Bluetooth OBEX Protocol", "OBEX", "btobex");
register_dissector("btobex", dissect_btobex, proto_btobex);
/* Required function calls to register the header fields and subtrees used */
proto_register_field_array(proto_btobex, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
register_init_routine(&defragment_init);
}
/*--- proto_register_sv -------------------------------------------*/
void proto_register_sv(void) {
/* List of fields */
static hf_register_info hf[] = {
{ &hf_sv_appid,
{ "APPID", "sv.appid", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }},
{ &hf_sv_length,
{ "Length", "sv.length", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }},
{ &hf_sv_reserve1,
{ "Reserved 1", "sv.reserve1", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL }},
{ &hf_sv_reserve2,
{ "Reserved 2", "sv.reserve2", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL }},
{ &hf_sv_phmeas_instmag_i,
{ "value", "sv.meas_value", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL}},
{ &hf_sv_phsmeas_q,
{ "quality", "sv.meas_quality", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL}},
{ &hf_sv_phsmeas_q_validity,
{ "validity", "sv.meas_quality.validity", FT_UINT32, BASE_HEX, VALS(sv_q_validity_vals), Q_VALIDITY_MASK, NULL, HFILL}},
{ &hf_sv_phsmeas_q_overflow,
{ "overflow", "sv.meas_quality.overflow", FT_BOOLEAN, 32, NULL, Q_OVERFLOW, NULL, HFILL}},
{ &hf_sv_phsmeas_q_outofrange,
{ "out of range", "sv.meas_quality.outofrange", FT_BOOLEAN, 32, NULL, Q_OUTOFRANGE, NULL, HFILL}},
{ &hf_sv_phsmeas_q_badreference,
{ "bad reference", "sv.meas_quality.badreference", FT_BOOLEAN, 32, NULL, Q_BADREFERENCE, NULL, HFILL}},
{ &hf_sv_phsmeas_q_oscillatory,
{ "oscillatory", "sv.meas_quality.oscillatory", FT_BOOLEAN, 32, NULL, Q_OSCILLATORY, NULL, HFILL}},
{ &hf_sv_phsmeas_q_failure,
{ "failure", "sv.meas_quality.failure", FT_BOOLEAN, 32, NULL, Q_FAILURE, NULL, HFILL}},
{ &hf_sv_phsmeas_q_olddata,
{ "old data", "sv.meas_quality.olddata", FT_BOOLEAN, 32, NULL, Q_OLDDATA, NULL, HFILL}},
{ &hf_sv_phsmeas_q_inconsistent,
{ "inconsistent", "sv.meas_quality.inconsistent", FT_BOOLEAN, 32, NULL, Q_INCONSISTENT, NULL, HFILL}},
{ &hf_sv_phsmeas_q_inaccurate,
{ "inaccurate", "sv.meas_quality.inaccurate", FT_BOOLEAN, 32, NULL, Q_INACCURATE, NULL, HFILL}},
{ &hf_sv_phsmeas_q_source,
{ "source", "sv.meas_quality.source", FT_UINT32, BASE_HEX, VALS(sv_q_source_vals), Q_SOURCE_MASK, NULL, HFILL}},
{ &hf_sv_phsmeas_q_test,
{ "test", "sv.meas_quality.teset", FT_BOOLEAN, 32, NULL, Q_TEST, NULL, HFILL}},
{ &hf_sv_phsmeas_q_operatorblocked,
{ "operator blocked", "sv.meas_quality.operatorblocked", FT_BOOLEAN, 32, NULL, Q_OPERATORBLOCKED, NULL, HFILL}},
{ &hf_sv_phsmeas_q_derived,
{ "derived", "sv.meas_quality.derived", FT_BOOLEAN, 32, NULL, Q_DERIVED, NULL, HFILL}},
#include "packet-sv-hfarr.c"
};
/* List of subtrees */
static gint *ett[] = {
&ett_sv,
&ett_phsmeas,
&ett_phsmeas_q,
#include "packet-sv-ettarr.c"
};
static ei_register_info ei[] = {
{ &ei_sv_mal_utctime, { "sv.malformed.utctime", PI_MALFORMED, PI_WARN, "BER Error: malformed UTCTime encoding", EXPFILL }},
{ &ei_sv_zero_pdu, { "sv.zero_pdu", PI_PROTOCOL, PI_ERROR, "Internal error, zero-byte SV PDU", EXPFILL }},
};
expert_module_t* expert_sv;
module_t *sv_module;
/* Register protocol */
proto_sv = proto_register_protocol(PNAME, PSNAME, PFNAME);
register_dissector("sv", dissect_sv, proto_sv);
/* Register fields and subtrees */
proto_register_field_array(proto_sv, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
expert_sv = expert_register_protocol(proto_sv);
expert_register_field_array(expert_sv, ei, array_length(ei));
sv_module = prefs_register_protocol(proto_sv, NULL);
prefs_register_bool_preference(sv_module, "decode_data_as_phsmeas",
"Force decoding of seqData as PhsMeas",
NULL, &sv_decode_data_as_phsmeas);
/* Register tap */
sv_tap = register_tap("sv");
}
/*--- proto_register_rtse -------------------------------------------*/
void proto_register_rtse(void) {
/* List of fields */
static hf_register_info hf[] =
{
/* Fragment entries */
{ &hf_rtse_fragments,
{ "RTSE fragments", "rtse.fragments", FT_NONE, BASE_NONE,
NULL, 0x00, "Message fragments", HFILL } },
{ &hf_rtse_fragment,
{ "RTSE fragment", "rtse.fragment", FT_FRAMENUM, BASE_NONE,
NULL, 0x00, "Message fragment", HFILL } },
{ &hf_rtse_fragment_overlap,
{ "RTSE fragment overlap", "rtse.fragment.overlap", FT_BOOLEAN,
BASE_NONE, NULL, 0x0, "Message fragment overlap", HFILL } },
{ &hf_rtse_fragment_overlap_conflicts,
{ "RTSE fragment overlapping with conflicting data",
"rtse.fragment.overlap.conflicts", FT_BOOLEAN, BASE_NONE, NULL,
0x0, "Message fragment overlapping with conflicting data", HFILL } },
{ &hf_rtse_fragment_multiple_tails,
{ "RTSE has multiple tail fragments",
"rtse.fragment.multiple_tails", FT_BOOLEAN, BASE_NONE,
NULL, 0x0, "Message has multiple tail fragments", HFILL } },
{ &hf_rtse_fragment_too_long_fragment,
{ "RTSE fragment too long", "rtse.fragment.too_long_fragment",
FT_BOOLEAN, BASE_NONE, NULL, 0x0, "Message fragment too long",
HFILL } },
{ &hf_rtse_fragment_error,
{ "RTSE defragmentation error", "rtse.fragment.error", FT_FRAMENUM,
BASE_NONE, NULL, 0x00, "Message defragmentation error", HFILL } },
{ &hf_rtse_reassembled_in,
{ "Reassembled RTSE in frame", "rtse.reassembled.in", FT_FRAMENUM, BASE_NONE,
NULL, 0x00, "This RTSE packet is reassembled in this frame", HFILL } },
#include "packet-rtse-hfarr.c"
};
/* List of subtrees */
static gint *ett[] = {
&ett_rtse,
&ett_rtse_unknown,
&ett_rtse_fragment,
&ett_rtse_fragments,
#include "packet-rtse-ettarr.c"
};
module_t *rtse_module;
/* Register protocol */
proto_rtse = proto_register_protocol(PNAME, PSNAME, PFNAME);
register_dissector("rtse", dissect_rtse, proto_rtse);
/* Register fields and subtrees */
proto_register_field_array(proto_rtse, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
register_init_routine (&rtse_reassemble_init);
rtse_module = prefs_register_protocol_subtree("OSI", proto_rtse, NULL);
prefs_register_bool_preference(rtse_module, "reassemble",
"Reassemble segmented RTSE datagrams",
"Whether segmented RTSE datagrams should be reassembled."
" To use this option, you must also enable"
" \"Allow subdissectors to reassemble TCP streams\""
" in the TCP protocol settings.", &rtse_reassemble);
rtse_oid_dissector_table = register_dissector_table("rtse.oid", "RTSE OID Dissectors", FT_STRING, BASE_NONE);
oid_table=g_hash_table_new(g_str_hash, g_str_equal);
}