static gint ett_svalidator_cmd_data = -1;
static gint ett_svalidator_type = -1;
+static expert_field ei_cipsafety_tbd2_not_complemented = EI_INIT;
+static expert_field ei_cipsafety_tbd_not_copied = EI_INIT;
+static expert_field ei_cipsafety_run_idle_not_complemented = EI_INIT;
+static expert_field ei_mal_io = EI_INIT;
+static expert_field ei_mal_sercosiii_link_error_count_p1p2 = EI_INIT;
+static expert_field ei_mal_tcpip_ssn = EI_INIT;
+
+static expert_field ei_mal_ssupervisor_exception_detail_alarm_ced = EI_INIT;
+static expert_field ei_mal_ssupervisor_exception_detail_alarm_ded = EI_INIT;
+static expert_field ei_mal_ssupervisor_exception_detail_alarm_med = EI_INIT;
+static expert_field ei_mal_ssupervisor_detail_warning_ced = EI_INIT;
+static expert_field ei_mal_ssupervisor_detail_warning_ded = EI_INIT;
+static expert_field ei_mal_ssupervisor_detail_warning_med = EI_INIT;
+static expert_field ei_mal_ssupervisor_configuration_unid = EI_INIT;
+static expert_field ei_mal_ssupervisor_safety_configuration_id = EI_INIT;
+static expert_field ei_mal_ssupervisor_target_unid = EI_INIT;
+static expert_field ei_mal_ssupervisor_cp_owners = EI_INIT;
+static expert_field ei_mal_ssupervisor_cp_owners_entry = EI_INIT;
+static expert_field ei_mal_ssupervisor_cp_owners_app_path_size = EI_INIT;
+static expert_field ei_mal_ssupervisor_proposed_tunid = EI_INIT;
+
+static expert_field ei_mal_svalidator_type = EI_INIT;
+static expert_field ei_mal_svalidator_time_coord_msg_min_mult = EI_INIT;
+static expert_field ei_mal_svalidator_network_time_multiplier = EI_INIT;
+static expert_field ei_mal_svalidator_timeout_multiplier = EI_INIT;
+static expert_field ei_mal_svalidator_coordination_conn_inst = EI_INIT;
+static expert_field ei_mal_svalidator_prod_cons_fault_count = EI_INIT;
+
const value_string cipsafety_ssn_date_vals[8] = {
{ 0, "NULL SSN" },
hf_cip_ssupervisor_exception_detail_alarm_ced_detail);
if (size == 0)
{
- expert_add_info_format(pinfo, item, PI_MALFORMED, PI_ERROR,
- "Malformed Safety Supervisor Attribute 13 (Common Exception Detail)");
+ expert_add_info(pinfo, item, &ei_mal_ssupervisor_exception_detail_alarm_ced);
return total_len;
}
total_size += size;
hf_cip_ssupervisor_exception_detail_alarm_ded_detail);
if (size == 0)
{
- expert_add_info_format(pinfo, item, PI_MALFORMED, PI_ERROR,
- "Malformed Safety Supervisor Attribute 13 (Device Exception Detail)");
+ expert_add_info(pinfo, item, &ei_mal_ssupervisor_exception_detail_alarm_ded);
return total_len;
}
total_size += size;
hf_cip_ssupervisor_exception_detail_alarm_med_detail);
if (size == 0)
{
- expert_add_info_format(pinfo, item, PI_MALFORMED, PI_ERROR,
- "Malformed Safety Supervisor Attribute 13 (Manufacturer Exception Detail)");
+ expert_add_info(pinfo, item, &ei_mal_ssupervisor_exception_detail_alarm_med);
return total_len;
}
total_size += size;
hf_cip_ssupervisor_exception_detail_warning_ced_detail);
if (size == 0)
{
- expert_add_info_format(pinfo, item, PI_MALFORMED, PI_ERROR,
- "Malformed Safety Supervisor Attribute 14 (Common Exception Detail)");
+ expert_add_info(pinfo, item, &ei_mal_ssupervisor_detail_warning_ced);
return total_len;
}
total_size += size;
hf_cip_ssupervisor_exception_detail_warning_ded_detail);
if (size == 0)
{
- expert_add_info_format(pinfo, item, PI_MALFORMED, PI_ERROR,
- "Malformed Safety Supervisor Attribute 14 (Device Exception Detail)");
+ expert_add_info(pinfo, item, &ei_mal_ssupervisor_detail_warning_ded);
return total_len;
}
total_size += size;
hf_cip_ssupervisor_exception_detail_warning_med_detail);
if (size == 0)
{
- expert_add_info_format(pinfo, item, PI_MALFORMED, PI_ERROR,
- "Malformed Safety Supervisor Attribute 14 (Manufacturer Exception Detail)");
+ expert_add_info(pinfo, item, &ei_mal_ssupervisor_detail_warning_med);
return total_len;
}
total_size += size;
{
if (total_len < 10)
{
- expert_add_info_format(pinfo, item, PI_MALFORMED, PI_ERROR,
- "Malformed Safety Supervisor Attribute 25");
+ expert_add_info(pinfo, item, &ei_mal_ssupervisor_configuration_unid);
return total_len;
}
{
if (total_len < 10)
{
- expert_add_info_format(pinfo, item, PI_MALFORMED, PI_ERROR,
- "Malformed Safety Supervisor Attribute 26");
+ expert_add_info(pinfo, item, &ei_mal_ssupervisor_safety_configuration_id);
return total_len;
}
{
if (total_len < 10)
{
- expert_add_info_format(pinfo, item, PI_MALFORMED, PI_ERROR,
- "Malformed Safety Supervisor Attribute 27");
+ expert_add_info(pinfo, item, &ei_mal_ssupervisor_target_unid);
return total_len;
}
if (total_len < 2)
{
- expert_add_info_format(pinfo, item, PI_MALFORMED, PI_ERROR,
- "Malformed Safety Supervisor Attribute 28");
+ expert_add_info(pinfo, item, &ei_mal_ssupervisor_cp_owners);
return total_len;
}
{
if (total_len < attr_len+11)
{
- expert_add_info_format(pinfo, entry_item, PI_MALFORMED, PI_ERROR, "Malformed Safety Supervisor Attribute 28 (UNID)");
+ expert_add_info(pinfo, item, &ei_mal_ssupervisor_cp_owners_entry);
return total_len;
}
if (total_len < attr_len+app_path_size)
{
- expert_add_info_format(pinfo, entry_item, PI_MALFORMED, PI_ERROR,
- "Malformed Safety Supervisor Attribute 28 (EPATH)");
+ expert_add_info(pinfo, item, &ei_mal_ssupervisor_cp_owners_app_path_size);
return total_len;
}
{
if (total_len < 10)
{
- expert_add_info_format(pinfo, item, PI_MALFORMED, PI_ERROR,
- "Malformed Safety Supervisor Attribute 29");
+ expert_add_info(pinfo, item, &ei_mal_ssupervisor_proposed_tunid);
return total_len;
}
if (total_len < 1)
{
- expert_add_info_format(pinfo, item, PI_MALFORMED, PI_ERROR,
- "Malformed Safety Validator Attribute 2");
+ expert_add_info(pinfo, item, &ei_mal_svalidator_type);
return total_len;
}
if (total_len < size+1)
{
- expert_add_info_format(pinfo, item, PI_MALFORMED, PI_ERROR,
- "Malformed Safety Validator Attribute 4");
+ expert_add_info(pinfo, item, &ei_mal_svalidator_time_coord_msg_min_mult);
return total_len;
}
if (total_len < size+1)
{
- expert_add_info_format(pinfo, item, PI_MALFORMED, PI_ERROR,
- "Malformed Safety Validator Attribute 5");
+ expert_add_info(pinfo, item, &ei_mal_svalidator_network_time_multiplier);
return total_len;
}
if (total_len < size+1)
{
- expert_add_info_format(pinfo, item, PI_MALFORMED, PI_ERROR,
- "Malformed Safety Validator Attribute 6");
+ expert_add_info(pinfo, item, &ei_mal_svalidator_timeout_multiplier);
return total_len;
}
if (total_len < size+1)
{
- expert_add_info_format(pinfo, item, PI_MALFORMED, PI_ERROR,
- "Malformed Safety Validator Attribute 9");
+ expert_add_info(pinfo, item, &ei_mal_svalidator_coordination_conn_inst);
return total_len;
}
if (total_len < size+1)
{
- expert_add_info_format(pinfo, item, PI_MALFORMED, PI_ERROR,
- "Malformed Safety Validator Attribute 15");
+ expert_add_info(pinfo, item, &ei_mal_svalidator_prod_cons_fault_count);
return total_len;
}
/* verify Mode Byte bits */
/* TBD */
if ((((mode_byte & 0x20) >> 5) & 0x01) == (((mode_byte & 0x04) >> 2) & 0x01))
- expert_add_info_format(pinfo, tbd_item, PI_PROTOCOL, PI_WARN, "TBD_2_bit not complemented");
+ expert_add_info(pinfo, tbd_item, &ei_cipsafety_tbd2_not_complemented);
/* TBD 2 */
if ((((mode_byte & 0x40) >> 6) & 0x01) != (((mode_byte & 0x08) >> 3) & 0x01))
- expert_add_info_format(pinfo, tbd2_item, PI_PROTOCOL, PI_WARN, "TBD bit not copied");
+ expert_add_info(pinfo, tbd2_item, &ei_cipsafety_tbd_not_copied);
/* Run/Idle */
if ((((mode_byte & 0x80) >> 7) & 0x01) == (((mode_byte & 0x10) >> 4) & 0x01))
- expert_add_info_format(pinfo, run_idle_item, PI_PROTOCOL, PI_WARN, "Run/Idle bit not complemented");
+ expert_add_info(pinfo, run_idle_item, &ei_cipsafety_run_idle_not_complemented);
}
static void
if (item_length%2 == 1)
{
/* Malformed packet */
- expert_add_info_format(pinfo, item, PI_MALFORMED, PI_ERROR,
- "Malformed CIP Safety I/O packet");
+ expert_add_info(pinfo, item, &ei_mal_io);
return;
}
if (item_length%2 == 1)
{
/* Malformed packet */
- expert_add_info_format(pinfo, item, PI_MALFORMED, PI_ERROR, "Malformed CIP Safety I/O packet");
+ expert_add_info(pinfo, item, &ei_mal_io);
return;
}
{
if (total_len < 4)
{
- expert_add_info_format(pinfo, item, PI_MALFORMED, PI_ERROR, "Malformed SERCOS III Attribute 5");
+ expert_add_info(pinfo, item, &ei_mal_sercosiii_link_error_count_p1p2);
return total_len;
}
{
if (total_len < 6)
{
- expert_add_info_format(pinfo, item, PI_MALFORMED, PI_ERROR, "Malformed TCP/IP Object Attribute 7");
+ expert_add_info(pinfo, item, &ei_mal_tcpip_ssn);
return total_len;
}
&ett_svalidator_type
};
+ static ei_register_info ei[] = {
+ { &ei_cipsafety_tbd2_not_complemented, { "cipsafety.tbd2_not_complemented", PI_PROTOCOL, PI_WARN, "TBD_2_bit not complemented", EXPFILL }},
+ { &ei_cipsafety_tbd_not_copied, { "cipsafety.tbd_not_copied", PI_PROTOCOL, PI_WARN, "TBD bit not copied", EXPFILL }},
+ { &ei_cipsafety_run_idle_not_complemented, { "cipsafety.run_idle_not_complemented", PI_PROTOCOL, PI_WARN, "Run/Idle bit not complemented", EXPFILL }},
+ { &ei_mal_io, { "cipsafety.malformed.io", PI_MALFORMED, PI_ERROR, "Malformed CIP Safety I/O packet", EXPFILL }},
+ { &ei_mal_sercosiii_link_error_count_p1p2, { "cipsafety.malformed.sercosiii_link.error_count_p1p2", PI_MALFORMED, PI_ERROR, "Malformed SERCOS III Attribute 5", EXPFILL }},
+ { &ei_mal_tcpip_ssn, { "cip.malformed.tcpip.ssn", PI_MALFORMED, PI_ERROR, "Malformed TCP/IP Object Safety Network Number", EXPFILL }},
+ };
+
+ static ei_register_info ei_ssupervisor[] = {
+ { &ei_mal_ssupervisor_exception_detail_alarm_ced, { "cipsafety.ssupervisor.malformed.exception_detail_alarm.ced", PI_MALFORMED, PI_ERROR,
+ "Malformed Safety Supervisor Exception Detail Alarm (Common Exception Detail)", EXPFILL }},
+ { &ei_mal_ssupervisor_exception_detail_alarm_ded, { "cipsafety.ssupervisor.malformed.exception_detail_alarm.ded", PI_MALFORMED, PI_ERROR,
+ "Malformed Safety Supervisor Exception Detail Alarm (Device Exception Detail)", EXPFILL }},
+ { &ei_mal_ssupervisor_exception_detail_alarm_med, { "cipsafety.ssupervisor.malformed.exception_detail_alarm.med", PI_MALFORMED, PI_ERROR,
+ "Malformed Safety Supervisor Exception Detail Alarm (Manufacturer Exception Detail)", EXPFILL }},
+ { &ei_mal_ssupervisor_detail_warning_ced, { "cipsafety.ssupervisor.malformed.detail_warning.ced", PI_MALFORMED, PI_ERROR,
+ "Malformed Safety Supervisor Exception Detail Warning (Common Exception Detail)", EXPFILL }},
+ { &ei_mal_ssupervisor_detail_warning_ded, { "cipsafety.ssupervisor.malformed.detail_warning.ded", PI_MALFORMED, PI_ERROR,
+ "Malformed Safety Supervisor Exception Detail Warning (Device Exception Detail)", EXPFILL }},
+ { &ei_mal_ssupervisor_detail_warning_med, { "cipsafety.ssupervisor.malformed.detail_warning.med", PI_MALFORMED, PI_ERROR,
+ "Malformed Safety Supervisor Exception Detail Warning (Manufacturer Exception Detail)", EXPFILL }},
+ { &ei_mal_ssupervisor_configuration_unid, { "cipsafety.ssupervisor.malformed.configuration_unid", PI_MALFORMED, PI_ERROR,
+ "Malformed Safety Supervisor Configuration UNID", EXPFILL }},
+ { &ei_mal_ssupervisor_safety_configuration_id, { "cipsafety.ssupervisor.malformed.safety_configuration_id", PI_MALFORMED, PI_ERROR,
+ "Malformed Safety Supervisor Safety Configuration Identifier", EXPFILL }},
+ { &ei_mal_ssupervisor_target_unid, { "cipsafety.ssupervisor.malformed.target_unid", PI_MALFORMED, PI_ERROR,
+ "Malformed Safety Supervisor Target UNID", EXPFILL }},
+ { &ei_mal_ssupervisor_cp_owners, { "cipsafety.ssupervisor.malformed.cp_owners", PI_MALFORMED, PI_ERROR,
+ "Malformed Safety Supervisor Output Connection Point Owners", EXPFILL }},
+ { &ei_mal_ssupervisor_cp_owners_entry, { "cipsafety.ssupervisor.malformed.cp_owners.entry", PI_MALFORMED, PI_ERROR,
+ "Malformed Safety Supervisor Output Connection Point Owners (UNID)", EXPFILL }},
+ { &ei_mal_ssupervisor_cp_owners_app_path_size, { "cipsafety.ssupervisor.malformed.cp_owners.app_path_size", PI_MALFORMED, PI_ERROR,
+ "Malformed Safety Supervisor Output Connection Point Owners (EPATH)", EXPFILL }},
+ { &ei_mal_ssupervisor_proposed_tunid, { "cipsafety.ssupervisor.malformed.proposed_tunid", PI_MALFORMED, PI_ERROR,
+ "Malformed Safety Supervisor Proposed TUNID", EXPFILL }},
+ };
+
+ static ei_register_info ei_svalidator[] = {
+ { &ei_mal_svalidator_type, { "cipsafety.ssupervisor.malformed.svalidator.type", PI_MALFORMED, PI_ERROR,
+ "Malformed Safety Validator Type", EXPFILL }},
+ { &ei_mal_svalidator_time_coord_msg_min_mult, { "cipsafety.ssupervisor.malformed.svalidator.time_coord_msg_min_mult", PI_MALFORMED, PI_ERROR,
+ "Malformed Safety Validator Time Coord Msg Min Multiplier", EXPFILL }},
+ { &ei_mal_svalidator_network_time_multiplier, { "cipsafety.ssupervisor.malformed.svalidator.network_time_multiplier", PI_MALFORMED, PI_ERROR,
+ "Malformed Safety Validator Network Time Expectation Multiplier", EXPFILL }},
+ { &ei_mal_svalidator_timeout_multiplier, { "cipsafety.ssupervisor.malformed.svalidator.timeout_multiplier", PI_MALFORMED, PI_ERROR,
+ "Malformed Safety Validator Timeout Multiplier", EXPFILL }},
+ { &ei_mal_svalidator_coordination_conn_inst, { "cipsafety.ssupervisor.malformed.svalidator.coordination_conn_inst", PI_MALFORMED, PI_ERROR,
+ "Malformed Safety Validator Coordination Connection Instance", EXPFILL }},
+ { &ei_mal_svalidator_prod_cons_fault_count, { "cipsafety.ssupervisor.malformed.svalidator.prod_cons_fault_count", PI_MALFORMED, PI_ERROR,
+ "Malformed Safety Validator Produce/Consume Fault Counters", EXPFILL }},
+ };
+
+ expert_module_t* expert_cip_safety;
+ expert_module_t* expert_cip_class_s_supervisor;
+ expert_module_t* expert_cip_class_s_validator;
+
/* Create a CIP Safety protocol handle */
proto_cipsafety = proto_register_protocol("Common Industrial Protocol, Safety", "CIP Safety", "cipsafety");
proto_register_field_array(proto_cipsafety, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
+ expert_cip_safety = expert_register_protocol(proto_cipsafety);
+ expert_register_field_array(expert_cip_safety, ei, array_length(ei));
register_dissector( "cipsafety", dissect_cipsafety, proto_cipsafety);
"CIPSSupervisor", "cipssupervisor");
proto_register_field_array(proto_cip_class_s_supervisor, hf_ssupervisor, array_length(hf_ssupervisor));
proto_register_subtree_array(ett_ssupervisor, array_length(ett_ssupervisor));
+ expert_cip_class_s_supervisor = expert_register_protocol(proto_cip_class_s_supervisor);
+ expert_register_field_array(expert_cip_class_s_supervisor, ei_ssupervisor, array_length(ei_ssupervisor));
proto_cip_class_s_validator = proto_register_protocol("CIP Safety Validator",
"CIPSValidator", "cipsvalidator");
proto_register_field_array(proto_cip_class_s_validator, hf_svalidator, array_length(hf_svalidator));
proto_register_subtree_array(ett_svalidator, array_length(ett_svalidator));
+ expert_cip_class_s_validator = expert_register_protocol(proto_cip_class_s_validator);
+ expert_register_field_array(expert_cip_class_s_validator, ei_svalidator, array_length(ei_svalidator));
}
/*
static gint ett_fo_payload = -1;
static gint ett_fo_option = -1;
+static expert_field ei_dhcpfo_bad_length = EI_INIT;
+static expert_field ei_dhcpfo_message_digest_type_not_allowed = EI_INIT;
+
+
/* Length of fixed-length portion of header */
#define DHCPFO_FL_HDR_LEN 12
case DHCP_FO_PD_ASSIGNED_IP_ADDRESS:
if (option_length != 4) {
- expert_add_info_format(pinfo, oi, PI_PROTOCOL, PI_WARN, "assigned ip address is not 4 bytes long");
+ expert_add_info_format_text(pinfo, oi, &ei_dhcpfo_bad_length, "assigned ip address is not 4 bytes long");
break;
}
proto_item_append_text(oi, ", %s ", tvb_ip_to_str(tvb, offset));
case DHCP_FO_PD_SENDING_SERVER_IP_ADDRESS:
if (option_length != 4) {
- expert_add_info_format(pinfo, oi, PI_PROTOCOL, PI_WARN, "sending server ip address is not 4 bytes long");
+ expert_add_info_format_text(pinfo, oi, &ei_dhcpfo_bad_length, "sending server ip address is not 4 bytes long");
break;
}
case DHCP_FO_PD_ADDRESSES_TRANSFERED:
if (option_length != 4) {
- expert_add_info_format(pinfo, oi, PI_PROTOCOL, PI_WARN, "addresses transferred is not 4 bytes long");
+ expert_add_info_format_text(pinfo, oi, &ei_dhcpfo_bad_length, "addresses transferred is not 4 bytes long");
break;
}
case DHCP_FO_PD_CLIENT_HARDWARE_ADDRESS:
if (option_length < 2) {
- expert_add_info_format(pinfo, oi, PI_PROTOCOL, PI_WARN, "hardware address is too short");
+ expert_add_info_format_text(pinfo, oi, &ei_dhcpfo_bad_length, "hardware address is too short");
break;
}
htype = tvb_get_guint8(tvb, offset);
case DHCP_FO_PD_REJECT_REASON:
if (option_length != 1) {
- expert_add_info_format(pinfo, oi, PI_PROTOCOL, PI_WARN, "Reject reason is not 1 byte long");
+ expert_add_info_format_text(pinfo, oi, &ei_dhcpfo_bad_length, "Reject reason is not 1 byte long");
break;
}
reject_reason = tvb_get_guint8(tvb, offset);
case DHCP_FO_PD_MCLT:
if (option_length != 4) {
- expert_add_info_format(pinfo, oi, PI_PROTOCOL, PI_WARN, "MCLT is not 4 bytes long");
+ expert_add_info_format_text(pinfo, oi, &ei_dhcpfo_bad_length, "MCLT is not 4 bytes long");
break;
}
mclt = tvb_get_ntohl(tvb, offset);
case DHCP_FO_PD_LEASE_EXPIRATION_TIME:
if (option_length != 4) {
- expert_add_info_format(pinfo, oi, PI_PROTOCOL, PI_WARN, "Lease expiration time is not 4 bytes long");
+ expert_add_info_format_text(pinfo, oi, &ei_dhcpfo_bad_length, "Lease expiration time is not 4 bytes long");
break;
}
lease_expiration_time =
case DHCP_FO_PD_POTENTIAL_EXPIRATION_TIME:
if (option_length != 4) {
- expert_add_info_format(pinfo, oi, PI_PROTOCOL, PI_WARN, "Potential expiration time is not 4 bytes long");
+ expert_add_info_format_text(pinfo, oi, &ei_dhcpfo_bad_length, "Potential expiration time is not 4 bytes long");
break;
}
potential_expiration_time =
case DHCP_FO_PD_GRACE_EXPIRATION_TIME:
if (option_length != 4) {
- expert_add_info_format(pinfo, oi, PI_PROTOCOL, PI_WARN, "Grace expiration time is not 4 bytes long");
+ expert_add_info_format_text(pinfo, oi, &ei_dhcpfo_bad_length, "Grace expiration time is not 4 bytes long");
break;
}
grace_expiration_time =
case DHCP_FO_PD_CLIENT_LAST_TRANSACTION_TIME:
if (option_length != 4) {
- expert_add_info_format(pinfo, oi, PI_PROTOCOL, PI_WARN, "Last transaction time is not 4 bytes long");
+ expert_add_info_format_text(pinfo, oi, &ei_dhcpfo_bad_length, "Last transaction time is not 4 bytes long");
break;
}
client_last_transaction_time =
case DHCP_FO_PD_START_TIME_OF_STATE:
if (option_length != 4) {
- expert_add_info_format(pinfo, oi, PI_PROTOCOL, PI_WARN, "Start time of state is not 4 bytes long");
+ expert_add_info_format_text(pinfo, oi, &ei_dhcpfo_bad_length, "Start time of state is not 4 bytes long");
break;
}
start_time_of_state =
case DHCP_FO_PD_SERVERSTATE:
if (option_length != 1) {
- expert_add_info_format(pinfo, oi, PI_PROTOCOL, PI_WARN, "server status is not 1 byte long");
+ expert_add_info_format_text(pinfo, oi, &ei_dhcpfo_bad_length, "server status is not 1 byte long");
break;
}
server_state = tvb_get_guint8(tvb, offset);
case DHCP_FO_PD_SERVERFLAG:
if (option_length != 1) {
- expert_add_info_format(pinfo, oi, PI_PROTOCOL, PI_WARN, "Serverflag is not 1 byte long");
+ expert_add_info_format_text(pinfo, oi, &ei_dhcpfo_bad_length, "Serverflag is not 1 byte long");
break;
}
serverflag = tvb_get_guint8(tvb, offset);
case DHCP_FO_PD_MAX_UNACKED_BNDUPD:
if (option_length != 4) {
- expert_add_info_format(pinfo, oi, PI_PROTOCOL, PI_WARN, "Max unacked BNDUPD is not 4 bytes long");
+ expert_add_info_format_text(pinfo, oi, &ei_dhcpfo_bad_length, "Max unacked BNDUPD is not 4 bytes long");
break;
}
max_unacked_bndupd = tvb_get_ntohl(tvb, offset);
case DHCP_FO_PD_RECEIVE_TIMER:
if (option_length != 4) {
- expert_add_info_format(pinfo, oi, PI_PROTOCOL, PI_WARN, "Receive timer is not 4 bytes long");
+ expert_add_info_format_text(pinfo, oi, &ei_dhcpfo_bad_length, "Receive timer is not 4 bytes long");
break;
}
receive_timer = tvb_get_ntohl(tvb, offset);
case DHCP_FO_PD_MESSAGE_DIGEST:
if (option_length < 2) {
- expert_add_info_format(pinfo, oi, PI_PROTOCOL, PI_WARN, "Message digest is too short");
+ expert_add_info_format_text(pinfo, oi, &ei_dhcpfo_bad_length, "Message digest is too short");
break;
}
proto_item_append_text(oi, ", HMAC-MD5");
} else {
proto_item_append_text(oi, ", type not allowed");
- expert_add_info_format(pinfo, ti, PI_PROTOCOL, PI_WARN, "Message digest type: %u, not allowed", message_digest_type);
+ expert_add_info_format_text(pinfo, ti, &ei_dhcpfo_message_digest_type_not_allowed, "Message digest type: %u, not allowed", message_digest_type);
}
proto_tree_add_item(option_tree,
case DHCP_FO_PD_PROTOCOL_VERSION:
if (option_length != 1) {
- expert_add_info_format(pinfo, oi, PI_PROTOCOL, PI_WARN, "Protocol version is not 1 byte long");
+ expert_add_info_format_text(pinfo, oi, &ei_dhcpfo_bad_length, "Protocol version is not 1 byte long");
break;
}
proto_item_append_text(oi, ", version: %u", tvb_get_guint8(tvb, offset));
case DHCP_FO_PD_TLS_REQUEST:
if (option_length != 2) {
- expert_add_info_format(pinfo, oi, PI_PROTOCOL, PI_WARN, "TLS request is not 2 bytes long");
+ expert_add_info_format_text(pinfo, oi, &ei_dhcpfo_bad_length, "TLS request is not 2 bytes long");
break;
}
tls_request = tvb_get_ntohs(tvb, offset);
&ett_fo_option,
};
+ static ei_register_info ei[] = {
+ { &ei_dhcpfo_bad_length, { "dhcpfo.bad_length", PI_PROTOCOL, PI_WARN, "Bad length", EXPFILL }},
+ { &ei_dhcpfo_message_digest_type_not_allowed, { "dhcpfo.message_digest_type_not_allowed", PI_PROTOCOL, PI_WARN, "Message digest type not allowed", EXPFILL }},
+ };
+
module_t *dhcpfo_module;
+ expert_module_t* expert_dhcpfo;
/* Register the protocol name and description */
proto_dhcpfo = proto_register_protocol("DHCP Failover", "DHCPFO",
/* Required function calls to register the header fields and subtrees used */
proto_register_field_array(proto_dhcpfo, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
+ expert_dhcpfo = expert_register_protocol(proto_dhcpfo);
+ expert_register_field_array(expert_dhcpfo, ei, array_length(ei));
dhcpfo_module = prefs_register_protocol(proto_dhcpfo, proto_reg_handoff_dhcpfo);
prefs_register_uint_preference(dhcpfo_module, "tcp_port",
};
static ei_register_info ei[] = {
- { &ei_mal_tcpip_status, { "cip.malformed.tcpip.status", PI_MALFORMED, PI_ERROR, "Malformed TCP/IP Attribute 1", EXPFILL }},
- { &ei_mal_tcpip_config_cap, { "cip.malformed.tcpip.config_cap", PI_MALFORMED, PI_ERROR, "Malformed TCP/IP Attribute 2", EXPFILL }},
- { &ei_mal_tcpip_config_control, { "cip.malformed.tcpip.config_control", PI_MALFORMED, PI_ERROR, "Malformed TCP/IP Attribute 3", EXPFILL }},
- { &ei_mal_tcpip_physical_link_size, { "cip.malformed.tcpip.physical_link_size", PI_MALFORMED, PI_ERROR, "Malformed TCP/IP Attribute 4", EXPFILL }},
- { &ei_mal_tcpip_interface_config, { "cip.malformed.tcpip.interface_config", PI_MALFORMED, PI_ERROR, "Malformed TCP/IP Attribute 5", EXPFILL }},
- { &ei_mal_tcpip_mcast_config, { "cip.malformed.tcpip.mcast_config", PI_MALFORMED, PI_ERROR, "Malformed TCP/IP Attribute 9", EXPFILL }},
- { &ei_mal_tcpip_last_conflict, { "cip.malformed.tcpip.last_conflict", PI_MALFORMED, PI_ERROR, "Malformed TCP/IP Attribute 11", EXPFILL }},
- { &ei_mal_elink_interface_flags, { "cip.malformed.elink.interface_flags", PI_MALFORMED, PI_ERROR, "Malformed Ethernet Link Attribute 2", EXPFILL }},
- { &ei_mal_elink_interface_counters, { "cip.malformed.elink.interface_counters", PI_MALFORMED, PI_ERROR, "Malformed Ethernet Link Attribute 4", EXPFILL }},
- { &ei_mal_elink_media_counters, { "cip.malformed.elink.media_counters", PI_MALFORMED, PI_ERROR, "Malformed Ethernet Link Attribute 5", EXPFILL }},
- { &ei_mal_elink_interface_control, { "cip.malformed.elink.interface_control", PI_MALFORMED, PI_ERROR, "Malformed Ethernet Link Attribute 6", EXPFILL }},
- { &ei_mal_dlr_ring_supervisor_config, { "cip.malformed.dlr.ring_supervisor_config", PI_MALFORMED, PI_ERROR, "Malformed DLR Attribute 4", EXPFILL }},
- { &ei_mal_dlr_last_active_node_on_port_1, { "cip.malformed.dlr.last_active_node_on_port_1", PI_MALFORMED, PI_ERROR, "Malformed DLR Attribute 6", EXPFILL }},
- { &ei_mal_dlr_last_active_node_on_port_2, { "cip.malformed.dlr.last_active_node_on_port_2", PI_MALFORMED, PI_ERROR, "Malformed DLR Attribute 7", EXPFILL }},
- { &ei_mal_dlr_ring_protocol_participants_list, { "cip.malformed.dlr.ring_protocol_participants_list", PI_MALFORMED, PI_ERROR, "Malformed DLR Attribute 9", EXPFILL }},
- { &ei_mal_dlr_active_supervisor_address, { "cip.malformed.dlr.active_supervisor_address", PI_MALFORMED, PI_ERROR, "Malformed DLR Attribute 10", EXPFILL }},
- { &ei_mal_dlr_capability_flags, { "cip.malformed.dlr.capability_flags", PI_MALFORMED, PI_ERROR, "Malformed DLR Attribute 12", EXPFILL }},
- { &ei_mal_dlr_redundant_gateway_config, { "cip.malformed.dlr.redundant_gateway_config", PI_MALFORMED, PI_ERROR, "Malformed DLR Attribute 13", EXPFILL }},
- { &ei_mal_dlr_active_gateway_address, { "cip.malformed.dlr.active_gateway_address", PI_MALFORMED, PI_ERROR, "Malformed DLR Attribute 15", EXPFILL }},
+ { &ei_mal_tcpip_status, { "cip.malformed.tcpip.status", PI_MALFORMED, PI_ERROR, "Malformed TCP/IP Status", EXPFILL }},
+ { &ei_mal_tcpip_config_cap, { "cip.malformed.tcpip.config_cap", PI_MALFORMED, PI_ERROR, "Malformed TCP/IP Configuration Capability", EXPFILL }},
+ { &ei_mal_tcpip_config_control, { "cip.malformed.tcpip.config_control", PI_MALFORMED, PI_ERROR, "Malformed TCP/IP Configuration Control", EXPFILL }},
+ { &ei_mal_tcpip_physical_link_size, { "cip.malformed.tcpip.physical_link_size", PI_MALFORMED, PI_ERROR, "Malformed TCP/IP Physical Link Object", EXPFILL }},
+ { &ei_mal_tcpip_interface_config, { "cip.malformed.tcpip.interface_config", PI_MALFORMED, PI_ERROR, "Malformed TCP/IP Interface Configuration", EXPFILL }},
+ { &ei_mal_tcpip_mcast_config, { "cip.malformed.tcpip.mcast_config", PI_MALFORMED, PI_ERROR, "Malformed TCP/IP Multicast Config", EXPFILL }},
+ { &ei_mal_tcpip_last_conflict, { "cip.malformed.tcpip.last_conflict", PI_MALFORMED, PI_ERROR, "Malformed TCP/IP Last Conflict Detected", EXPFILL }},
+ { &ei_mal_elink_interface_flags, { "cip.malformed.elink.interface_flags", PI_MALFORMED, PI_ERROR, "Malformed Ethernet Link Interface Flags", EXPFILL }},
+ { &ei_mal_elink_interface_counters, { "cip.malformed.elink.interface_counters", PI_MALFORMED, PI_ERROR, "Malformed Ethernet Link Interface Counters", EXPFILL }},
+ { &ei_mal_elink_media_counters, { "cip.malformed.elink.media_counters", PI_MALFORMED, PI_ERROR, "Malformed Ethernet Link Media Counters", EXPFILL }},
+ { &ei_mal_elink_interface_control, { "cip.malformed.elink.interface_control", PI_MALFORMED, PI_ERROR, "Malformed Ethernet Link Interface Control", EXPFILL }},
+ { &ei_mal_dlr_ring_supervisor_config, { "cip.malformed.dlr.ring_supervisor_config", PI_MALFORMED, PI_ERROR, "Malformed DLR Ring Supervisor Config", EXPFILL }},
+ { &ei_mal_dlr_last_active_node_on_port_1, { "cip.malformed.dlr.last_active_node_on_port_1", PI_MALFORMED, PI_ERROR, "Malformed DLR Last Active Node on Port 1", EXPFILL }},
+ { &ei_mal_dlr_last_active_node_on_port_2, { "cip.malformed.dlr.last_active_node_on_port_2", PI_MALFORMED, PI_ERROR, "Malformed DLR Last Active Node on Port 2", EXPFILL }},
+ { &ei_mal_dlr_ring_protocol_participants_list, { "cip.malformed.dlr.ring_protocol_participants_list", PI_MALFORMED, PI_ERROR, "Malformed DLR Ring Protocol Participants List", EXPFILL }},
+ { &ei_mal_dlr_active_supervisor_address, { "cip.malformed.dlr.active_supervisor_address", PI_MALFORMED, PI_ERROR, "Malformed DLR Active Supervisor Address", EXPFILL }},
+ { &ei_mal_dlr_capability_flags, { "cip.malformed.dlr.capability_flags", PI_MALFORMED, PI_ERROR, "Malformed DLR Capability Flag", EXPFILL }},
+ { &ei_mal_dlr_redundant_gateway_config, { "cip.malformed.dlr.redundant_gateway_config", PI_MALFORMED, PI_ERROR, "Malformed DLR Redundant Gateway Config", EXPFILL }},
+ { &ei_mal_dlr_active_gateway_address, { "cip.malformed.dlr.active_gateway_address", PI_MALFORMED, PI_ERROR, "Malformed DLR Active Gateway Address", EXPFILL }},
};
/* Setup list of header fields for DLR See Section 1.6.1 for details*/
static gint ett_icmpv6_opt_name = -1;
static gint ett_icmpv6_cga_param_name = -1;
+static expert_field ei_icmpv6_invalid_option_length = EI_INIT;
+static expert_field ei_icmpv6_undecoded_option = EI_INIT;
+static expert_field ei_icmpv6_unknown_data = EI_INIT;
+static expert_field ei_icmpv6_undecoded_rpl_option = EI_INIT;
+static expert_field ei_icmpv6_undecoded_type = EI_INIT;
+static expert_field ei_icmpv6_rr_pco_mp_matchlen = EI_INIT;
+static expert_field ei_icmpv6_rr_pco_mp_matchedlen = EI_INIT;
+static expert_field ei_icmpv6_checksum = EI_INIT;
+
+
static dissector_handle_t ipv6_handle;
static dissector_handle_t data_handle;
proto_item_append_text(ti_opt_len, " (%i bytes)", opt_len);
if(opt_len == 0){
- expert_add_info_format(pinfo, ti_opt_len, PI_MALFORMED, PI_ERROR, "Invalid option length (Zero)");
+ expert_add_info_format_text(pinfo, ti_opt_len, &ei_icmpv6_invalid_option_length, "Invalid option length (Zero)");
return opt_offset;
}
opt_offset += 16;
break;
default:
- expert_add_info_format(pinfo, ti_opt_len, PI_MALFORMED, PI_ERROR, "Invalid Option Length");
+ expert_add_info(pinfo, ti_opt_len, &ei_icmpv6_invalid_option_length);
break;
}
break;
opt_offset += 16;
break;
default:
- expert_add_info_format(pinfo, ti_opt_len, PI_MALFORMED, PI_ERROR, "Invalid Option Length");
+ expert_add_info(pinfo, ti_opt_len, &ei_icmpv6_invalid_option_length);
break;
}
/* Update the 6LoWPAN dissectors with new context information. */
break;
default :
- expert_add_info_format(pinfo, ti, PI_UNDECODED, PI_NOTE,
+ expert_add_info_format_text(pinfo, ti, &ei_icmpv6_undecoded_option,
"Dissector for ICMPv6 Option (%d)"
" code not implemented, Contact Wireshark developers"
" if you want this supported", opt_type);
if(offset > opt_offset){
ti_opt = proto_tree_add_item(icmp6opt_tree, hf_icmpv6_unknown_data, tvb, opt_offset, offset - opt_offset, ENC_NA);
- expert_add_info_format(pinfo, ti_opt, PI_MALFORMED, PI_ERROR, "Unknown Data (not interpreted)");
+ expert_add_info(pinfo, ti_opt, &ei_icmpv6_unknown_data);
}
/* Close the ) to option root label */
proto_item_append_text(ti, ")");
opt_offset += 16;
break;
default:
- expert_add_info_format(pinfo, ti_opt_len, PI_MALFORMED, PI_ERROR, "Invalid Option Length");
+ expert_add_info(pinfo, ti_opt_len, &ei_icmpv6_invalid_option_length);
break;
}
break;
opt_offset += 16;
break;
default:
- expert_add_info_format(pinfo, ti_opt_len, PI_MALFORMED, PI_ERROR, "Invalid Option Length");
+ expert_add_info(pinfo, ti_opt_len, &ei_icmpv6_invalid_option_length);
break;
}
break;
break;
}
default :
- expert_add_info_format(pinfo, ti, PI_UNDECODED, PI_NOTE,
+ expert_add_info_format_text(pinfo, ti, &ei_icmpv6_undecoded_rpl_option,
"Dissector for ICMPv6 RPL Option"
" (%d) code not implemented, Contact"
" Wireshark developers if you want this supported", opt_type);
if(offset > opt_offset){
ti_opt = proto_tree_add_item(icmp6opt_tree, hf_icmpv6_unknown_data, tvb, opt_offset, offset - opt_offset, ENC_NA);
- expert_add_info_format(pinfo, ti_opt, PI_MALFORMED, PI_ERROR, "Unknown Data (not interpreted)");
+ expert_add_info(pinfo, ti_opt, &ei_icmpv6_unknown_data);
}
/* Close the ) to option root label */
proto_tree_add_item(mp_tree, hf_icmpv6_rr_pco_mp_matchlen, tvb, rr_offset, 1, ENC_BIG_ENDIAN);
matchlen = tvb_get_guint8(tvb, rr_offset);
if (matchlen > 128) {
- expert_add_info_format(pinfo, ti, PI_PROTOCOL, PI_WARN,
- "MatchLen is greater than 128");
+ expert_add_info(pinfo, ti, &ei_icmpv6_rr_pco_mp_matchlen);
}
rr_offset += 1;
ti = proto_tree_add_item(rm_tree, hf_icmpv6_rr_rm_matchedlen, tvb, rr_offset, 1, ENC_BIG_ENDIAN);
matchlen = tvb_get_guint8(tvb, rr_offset);
if (matchlen > 128) {
- expert_add_info_format(pinfo, ti, PI_PROTOCOL, PI_WARN,
- "MatchedLen is greater than 128");
+ expert_add_info(pinfo, ti, &ei_icmpv6_rr_pco_mp_matchedlen);
}
rr_offset +=1;
hidden_item = proto_tree_add_boolean(icmp6_tree, hf_icmpv6_checksum_bad, tvb, offset, 2, TRUE);
PROTO_ITEM_SET_HIDDEN(hidden_item);
proto_item_append_text(checksum_item, " [incorrect, should be 0x%04x]", in_cksum_shouldbe(cksum, computed_cksum));
- expert_add_info_format(pinfo, checksum_item, PI_CHECKSUM, PI_WARN,
+ expert_add_info_format_text(pinfo, checksum_item, &ei_icmpv6_checksum,
"ICMPv6 Checksum Incorrect, should be 0x%04x", in_cksum_shouldbe(cksum, computed_cksum));
}
}
break;
}
default:
- expert_add_info_format(pinfo, ti, PI_UNDECODED, PI_NOTE,
+ expert_add_info_format_text(pinfo, ti, &ei_icmpv6_undecoded_type,
"Dissector for ICMPv6 Type (%d)"
" code not implemented, Contact Wireshark"
" developers if you want this supported", icmp6_type);
&ett_icmpv6_cga_param_name
};
+ static ei_register_info ei[] = {
+ { &ei_icmpv6_invalid_option_length, { "icmpv6.invalid_option_length", PI_MALFORMED, PI_ERROR, "Invalid Option Length", EXPFILL }},
+ { &ei_icmpv6_undecoded_option, { "icmpv6.undecoded.option", PI_UNDECODED, PI_NOTE, "Undecoded option", EXPFILL }},
+ { &ei_icmpv6_unknown_data, { "icmpv6.unknown_data.expert", PI_MALFORMED, PI_ERROR, "Unknown Data (not interpreted)", EXPFILL }},
+ { &ei_icmpv6_undecoded_rpl_option, { "icmpv6.undecoded.rpl_option", PI_UNDECODED, PI_NOTE, "Undecoded RPL Option", EXPFILL }},
+ { &ei_icmpv6_undecoded_type, { "icmpv6.undecoded.type", PI_UNDECODED, PI_NOTE, "Undecoded type", EXPFILL }},
+ { &ei_icmpv6_rr_pco_mp_matchlen, { "icmpv6.rr.pco.mp.matchlen.gt128", PI_PROTOCOL, PI_WARN, "MatchLen is greater than 128", EXPFILL }},
+ { &ei_icmpv6_rr_pco_mp_matchedlen, { "icmpv6.rr.pco.mp.matchedlen.gt128", PI_PROTOCOL, PI_WARN, "MatchedLen is greater than 128", EXPFILL }},
+ { &ei_icmpv6_checksum, { "icmpv6.checksum_bad.expert", PI_CHECKSUM, PI_WARN, "Bad checksum", EXPFILL }},
+ };
+
+ expert_module_t* expert_icmpv6;
+
proto_icmpv6 = proto_register_protocol("Internet Control Message Protocol v6",
"ICMPv6", "icmpv6");
proto_register_field_array(proto_icmpv6, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
+ expert_icmpv6 = expert_register_protocol(proto_icmpv6);
+ expert_register_field_array(expert_icmpv6, ei, array_length(ei));
new_register_dissector("icmpv6", dissect_icmpv6, proto_icmpv6);
icmpv6_tap = register_tap("icmpv6");
static gint ett_ip_opt_type = -1;
static gint ett_ip_opt_sec_prot_auth_flags = -1;
+static expert_field ei_ip_opt_len_invalid = EI_INIT;
+static expert_field ei_ip_opt_sec_prot_auth_fti = EI_INIT;
+static expert_field ei_ip_extraneous_data = EI_INIT;
+static expert_field ei_ip_opt_ptr_before_address = EI_INIT;
+static expert_field ei_ip_opt_ptr_middle_address = EI_INIT;
+static expert_field ei_ip_subopt_too_long = EI_INIT;
+static expert_field ei_ip_nop = EI_INIT;
+static expert_field ei_ip_bogus_ip_length = EI_INIT;
+static expert_field ei_ip_evil_packet = EI_INIT;
+static expert_field ei_ip_checksum_bad = EI_INIT;
+static expert_field ei_ip_ttl_lncb = EI_INIT;
+static expert_field ei_ip_ttl_too_small = EI_INIT;
+
+
#ifdef HAVE_GEOIP
static gint ett_geoip_info = -1;
#endif /* HAVE_GEOIP */
curr_offset++;
tf_sub = proto_tree_add_item(field_tree, hf_ip_opt_len, tvb, curr_offset, 1, ENC_NA);
if (optlen > IPOLEN_MAX)
- expert_add_info_format(pinfo, tf_sub, PI_PROTOCOL, PI_WARN,
- "Invalid length for option");
+ expert_add_info(pinfo, tf_sub, &ei_ip_opt_len_invalid);
curr_offset++;
if (optlen == 11) {
curr_offset++;
while (val & 0x01) {
if ((val & 0x01) && ((curr_offset - offset) == optlen)) {
- expert_add_info_format(pinfo, tf_sub, PI_PROTOCOL, PI_WARN,
- "Field Termination Indicator set to 1 for last byte of option");
+ expert_add_info(pinfo, tf_sub, &ei_ip_opt_sec_prot_auth_fti);
break;
}
val = tvb_get_guint8(tvb, curr_offset);
curr_offset++;
}
if ((curr_offset - offset) < optlen) {
- expert_add_info_format(pinfo, tf, PI_PROTOCOL, PI_WARN,
- "Extraneous data in option");
+ expert_add_info(pinfo, tf, &ei_ip_extraneous_data);
}
}
curr_offset++;
tf_sub = proto_tree_add_item(field_tree, hf_ip_opt_len, tvb, curr_offset, 1, ENC_NA);
if (optlen > IPOLEN_MAX)
- expert_add_info_format(pinfo, tf_sub, PI_PROTOCOL, PI_WARN,
- "Invalid length for option");
+ expert_add_info(pinfo, tf_sub, &ei_ip_opt_len_invalid);
curr_offset++;
proto_tree_add_item(field_tree, hf_ip_opt_ext_sec_add_sec_info_format_code, tvb, curr_offset, 1, ENC_BIG_ENDIAN);
curr_offset++;
dissect_ipopt_type(tvb, offset, field_tree);
tf = proto_tree_add_item(field_tree, hf_ip_opt_len, tvb, offset + 1, 1, ENC_NA);
if (optlen > IPOLEN_MAX)
- expert_add_info_format(pinfo, tf, PI_PROTOCOL, PI_WARN,
- "Invalid length for option");
+ expert_add_info(pinfo, tf, &ei_ip_opt_len_invalid);
offset += 2;
dissect_ipopt_type(tvb, offset, field_tree);
tf = proto_tree_add_item(field_tree, hf_ip_opt_len, tvb, offset + 1, 1, ENC_NA);
if (optlen > IPOLEN_MAX)
- expert_add_info_format(pinfo, tf, PI_PROTOCOL, PI_WARN,
- "Invalid length for option");
+ expert_add_info(pinfo, tf, &ei_ip_opt_len_invalid);
ptr = tvb_get_guint8(tvb, offset + 2);
tf = proto_tree_add_item(field_tree, hf_ip_opt_ptr, tvb, offset + 2, 1, ENC_NA);
if ((ptr < (optp->optlen + 1)) || (ptr & 3)) {
if (ptr < (optp->optlen + 1)) {
- expert_add_info_format(pinfo, tf, PI_PROTOCOL, PI_WARN,
- "Pointer points before first address");
+ expert_add_info(pinfo, tf, &ei_ip_opt_ptr_before_address);
}
else {
- expert_add_info_format(pinfo, tf, PI_PROTOCOL, PI_WARN,
- "Pointer points to middle of address");
+ expert_add_info(pinfo, tf, &ei_ip_opt_ptr_middle_address);
}
return;
}
optoffset = 3; /* skip past type, length and pointer */
for (optlen -= 3; optlen > 0; optlen -= 4, optoffset += 4) {
if (optlen < 4) {
- expert_add_info_format(pinfo, tf, PI_PROTOCOL, PI_WARN,
- "Suboption would go past end of option");
+ expert_add_info(pinfo, tf, &ei_ip_subopt_too_long);
break;
}
dissect_ipopt_type(tvb, offset, field_tree);
tf = proto_tree_add_item(field_tree, hf_ip_opt_len, tvb, offset + 1, 1, ENC_NA);
if (optlen > IPOLEN_MAX)
- expert_add_info_format(pinfo, tf, PI_PROTOCOL, PI_WARN,
- "Invalid length for option");
+ expert_add_info(pinfo, tf, &ei_ip_opt_len_invalid);
ptr = tvb_get_guint8(tvb, offset + 2);
tf = proto_tree_add_item(field_tree, hf_ip_opt_ptr, tvb, offset + 2, 1, ENC_NA);
if ((ptr < (optp->optlen + 1)) || (ptr & 3)) {
if (ptr < (optp->optlen + 1)) {
- expert_add_info_format(pinfo, tf, PI_PROTOCOL, PI_WARN,
- "Pointer points before first address");
+ expert_add_info(pinfo, tf, &ei_ip_opt_ptr_before_address);
}
else {
- expert_add_info_format(pinfo, tf, PI_PROTOCOL, PI_WARN,
- "Pointer points to middle of address");
+ expert_add_info(pinfo, tf, &ei_ip_opt_ptr_middle_address);
}
return;
}
optoffset = 3; /* skip past type, length and pointer */
for (optlen -= 3; optlen > 0; optlen -= 4, optoffset += 4) {
if (optlen < 4) {
- expert_add_info_format(pinfo, tf, PI_PROTOCOL, PI_WARN,
- "Suboption would go past end of option");
+ expert_add_info(pinfo, tf, &ei_ip_subopt_too_long);
break;
}
dissect_ipopt_type(tvb, offset, field_tree);
tf = proto_tree_add_item(field_tree, hf_ip_opt_len, tvb, offset + 1, 1, ENC_NA);
if (optlen != (guint)optp->optlen)
- expert_add_info_format(pinfo, tf, PI_PROTOCOL, PI_WARN,
- "Invalid length for option");
+ expert_add_info(pinfo, tf, &ei_ip_opt_len_invalid);
proto_tree_add_item(field_tree, hf_ip_opt_sid, tvb, offset + 2, 2, ENC_BIG_ENDIAN);
}
dissect_ipopt_type(tvb, offset, field_tree);
tf = proto_tree_add_item(field_tree, hf_ip_opt_len, tvb, offset + 1, 1, ENC_NA);
if (optlen != (guint)optp->optlen)
- expert_add_info_format(pinfo, tf, PI_PROTOCOL, PI_WARN,
- "Invalid length for option");
+ expert_add_info(pinfo, tf, &ei_ip_opt_len_invalid);
proto_tree_add_item(field_tree, hf_ip_opt_mtu, tvb, offset + 2, 2, ENC_BIG_ENDIAN);
}
dissect_ipopt_type(tvb, offset, field_tree);
tf = proto_tree_add_item(field_tree, hf_ip_opt_len, tvb, offset + 1, 1, ENC_NA);
if (optlen != (guint)optp->optlen)
- expert_add_info_format(pinfo, tf, PI_PROTOCOL, PI_WARN,
- "Invalid length for option");
+ expert_add_info(pinfo, tf, &ei_ip_opt_len_invalid);
proto_tree_add_item(field_tree, hf_ip_opt_id_number, tvb, offset + 2, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(field_tree, hf_ip_opt_ohc, tvb, offset + 4, 2, ENC_BIG_ENDIAN);
dissect_ipopt_type(tvb, offset, field_tree);
tf = proto_tree_add_item(field_tree, hf_ip_opt_len, tvb, offset + 1, 1, ENC_NA);
if (optlen > IPOLEN_MAX)
- expert_add_info_format(pinfo, tf, PI_PROTOCOL, PI_WARN,
- "Invalid length for option");
+ expert_add_info(pinfo, tf, &ei_ip_opt_len_invalid);
optoffset += 2; /* skip past type and length */
optlen -= 2; /* subtract size of type and length */
dissect_ipopt_type(tvb, offset, field_tree);
tf = proto_tree_add_item(field_tree, hf_ip_opt_len, tvb, offset + 1, 1, ENC_NA);
if (optlen != (guint)optp->optlen)
- expert_add_info_format(pinfo, tf, PI_PROTOCOL, PI_WARN,
- "Invalid length for option");
+ expert_add_info(pinfo, tf, &ei_ip_opt_len_invalid);
proto_tree_add_item(field_tree, hf_ip_opt_ra, tvb, offset + 2, 2, ENC_BIG_ENDIAN);
}
dissect_ipopt_type(tvb, offset, field_tree);
tf = proto_tree_add_item(field_tree, hf_ip_opt_len, tvb, offset + 1, 1, ENC_NA);
if (optlen > IPOLEN_MAX)
- expert_add_info_format(pinfo, tf, PI_PROTOCOL, PI_WARN,
- "Invalid length for option");
+ expert_add_info(pinfo, tf, &ei_ip_opt_len_invalid);
for (offset += 2, optlen -= 2; optlen >= 4; offset += 4, optlen -= 4)
proto_tree_add_item(field_tree, hf_ip_opt_addr, tvb, offset, 4, ENC_BIG_ENDIAN);
dissect_ipopt_type(tvb, offset, field_tree);
ti = proto_tree_add_item(field_tree, hf_ip_opt_len, tvb, offset + 1, 1, ENC_NA);
if (optlen != (guint)optp->optlen)
- expert_add_info_format(pinfo, ti, PI_PROTOCOL, PI_WARN,
- "Invalid length for option");
+ expert_add_info(pinfo, tf, &ei_ip_opt_len_invalid);
proto_tree_add_item(field_tree, hf_ip_opt_qs_func, tvb, offset + 2, 1, ENC_NA);
if (function == QS_RATE_REQUEST) {
offset += 1;
if (nop_count == 4 && strcmp (name, "No-Operation (NOP)") == 0) {
- expert_add_info_format(pinfo, opt_item, PI_PROTOCOL, PI_WARN,
- "4 NOP in a row - a router may have removed "
- "some options");
+ expert_add_info(pinfo, opt_item, &ei_ip_nop);
}
}
if (opt == eol)
"Total length: %u bytes (bogus, less than header length %u)",
iph->ip_len, hlen);
}
- expert_add_info_format(pinfo, tf, PI_PROTOCOL, PI_ERROR, "Bogus IP length");
+ expert_add_info(pinfo, tf, &ei_ip_bogus_ip_length);
/* Can't dissect any further */
return;
}
bit_offset + 0, 1, ENC_BIG_ENDIAN);
if (iph->ip_off & IP_RF) {
proto_item_append_text(tf, " (Evil packet!)");
- expert_add_info_format(pinfo, sf, PI_SECURITY, PI_WARN,
- "This is an Evil packet (RFC 3514)");
+ expert_add_info(pinfo, sf, &ei_ip_evil_packet);
}
} else {
proto_tree_add_bits_item(field_tree, hf_ip_flags_rf, tvb, bit_offset + 0,
if (tree == NULL) then item will be NULL
else item should be from the
add_boolean(..., hf_ip_checksum_bad, ...) above */
- expert_add_info_format(pinfo, item, PI_CHECKSUM, PI_ERROR,
- "Bad checksum");
+ expert_add_info(pinfo, item, &ei_ip_checksum_bad);
}
} else {
ipsum = 0;
if (is_a_local_network_control_block_addr(dst32)) {
ttl = local_network_control_block_addr_valid_ttl(dst32);
if (ttl != iph->ip_ttl && ttl != IPLOCAL_NETWRK_CTRL_BLK_ANY_TTL) {
- expert_add_info_format(pinfo, ttl_item, PI_SEQUENCE, PI_NOTE,
- "\"Time To Live\" != %d for a packet sent to the "
+ expert_add_info_format_text(pinfo, ttl_item, &ei_ip_ttl_lncb, "\"Time To Live\" != %d for a packet sent to the "
"Local Network Control Block (see RFC 3171)",
ttl);
}
} else if (!is_a_multicast_addr(dst32) && iph->ip_ttl < 5 &&
(iph->ip_p != IP_PROTO_PIM)) {
- expert_add_info_format(pinfo, ttl_item, PI_SEQUENCE, PI_NOTE,
- "\"Time To Live\" only %u", iph->ip_ttl);
+ expert_add_info_format_text(pinfo, ttl_item, &ei_ip_ttl_too_small, "\"Time To Live\" only %u", iph->ip_ttl);
}
if (tree) {
&ett_geoip_info
#endif
};
+ static ei_register_info ei[] = {
+ { &ei_ip_opt_len_invalid, { "ip.opt.len.invalid", PI_PROTOCOL, PI_WARN, "Invalid length for option", EXPFILL }},
+ { &ei_ip_opt_sec_prot_auth_fti, { "ip.opt.len.invalid", PI_PROTOCOL, PI_WARN, "Field Termination Indicator set to 1 for last byte of option", EXPFILL }},
+ { &ei_ip_extraneous_data, { "ip.opt.len.invalid", PI_PROTOCOL, PI_WARN, "Extraneous data in option", EXPFILL }},
+ { &ei_ip_opt_ptr_before_address, { "ip.opt.ptr.before_address", PI_PROTOCOL, PI_WARN, "Pointer points before first address", EXPFILL }},
+ { &ei_ip_opt_ptr_middle_address, { "ip.opt.ptr.middle_address", PI_PROTOCOL, PI_WARN, "Pointer points to middle of address", EXPFILL }},
+ { &ei_ip_subopt_too_long, { "ip.subopt_too_long", PI_PROTOCOL, PI_WARN, "Suboption would go past end of option", EXPFILL }},
+ { &ei_ip_nop, { "ip.nop", PI_PROTOCOL, PI_WARN, "4 NOP in a row - a router may have removed some options", EXPFILL }},
+ { &ei_ip_bogus_ip_length, { "ip.bogus_ip_length", PI_PROTOCOL, PI_ERROR, "Bogus IP length", EXPFILL }},
+ { &ei_ip_evil_packet, { "ip.evil_packet", PI_PROTOCOL, PI_WARN, "Suboption would go past end of option", EXPFILL }},
+ { &ei_ip_checksum_bad, { "ip.checksum_bad.expert", PI_CHECKSUM, PI_ERROR, "Bad checksum", EXPFILL }},
+ { &ei_ip_ttl_lncb, { "ip.ttl.lncb", PI_SEQUENCE, PI_NOTE, "Time To Live", EXPFILL }},
+ { &ei_ip_ttl_too_small, { "ip.ttl.too_small", PI_SEQUENCE, PI_NOTE, "Time To Live", EXPFILL }},
+ };
+
module_t *ip_module;
+ expert_module_t* expert_ip;
proto_ip = proto_register_protocol("Internet Protocol Version 4", "IPv4", "ip");
proto_register_field_array(proto_ip, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
+ expert_ip = expert_register_protocol(proto_ip);
+ expert_register_field_array(expert_ip, ei, array_length(ei));
/* subdissector code */
ip_dissector_table = register_dissector_table("ip.proto", "IPv4 protocol",
static gint ett_geoip_info = -1;
#endif /* HAVE_GEOIP_V6 */
+static expert_field ei_ipv6_dst_addr_not_multicast = EI_INIT;
+static expert_field ei_ipv6_src_route_list_mult_inst_same_addr = EI_INIT;
+static expert_field ei_ipv6_src_route_list_src_addr = EI_INIT;
+static expert_field ei_ipv6_src_route_list_dst_addr = EI_INIT;
+static expert_field ei_ipv6_src_route_list_multicast_addr = EI_INIT;
+static expert_field ei_ipv6_cmpri_cmpre_pad = EI_INIT;
+static expert_field ei_ipv6_routing_hdr_rpl_reserved = EI_INIT;
+static expert_field ei_ipv6_opt_tel_invalid_len = EI_INIT;
+static expert_field ei_ipv6_opt_jumbo_invalid_len = EI_INIT;
+static expert_field ei_ipv6_opt_rtalert_invalid_len = EI_INIT;
+static expert_field ei_ipv6_mipv6_home_address_invalid_len = EI_INIT;
+static expert_field ei_ipv6_shim6_opt_elemlen_invalid = EI_INIT;
+static expert_field ei_ipv6_shim6_checksum_bad = EI_INIT;
+static expert_field ei_ipv6_routing_hdr_rpl_segments_ge0 = EI_INIT;
static const fragment_items ipv6_frag_items = {
&ett_ipv6_fragment,
len = (rt.ip6r_len + 1) << 3;
/* Assigning seg_left and the if (seg_left) {} blocks of code that follow,
- * along with any expert_add_info_format() calls, all need to execute when
+ * along with any expert_add_info() calls, all need to execute when
* appropriate, regardless of whether the tree is NULL or not. */
if (1) {
/* !!! specify length */
/* from RFC6554: Multicast addresses MUST NOT appear in the IPv6 Destination Address field */
if(g_ipv6_rpl_srh_strict_rfc_checking && E_IN6_IS_ADDR_MULTICAST(&dstAddr)){
- expert_add_info_format(pinfo, ti, PI_PROTOCOL, PI_WARN, "Destination address must not be a multicast address ");
+ expert_add_info(pinfo, ti, &ei_ipv6_dst_addr_not_multicast);
}
proto_tree_add_item(rthdr_tree, hf_ipv6_routing_hdr_rpl_cmprI, tvb, offset, 4, ENC_BIG_ENDIAN);
/* from RFC6554: when CmprI and CmprE are both 0, Pad MUST carry a value of 0 */
if(g_ipv6_rpl_srh_strict_rfc_checking && (cmprI == 0 && cmprE == 0 && pad != 0)){
- expert_add_info_format(pinfo, ti, PI_PROTOCOL, PI_WARN, "When cmprI equals 0 and cmprE equals 0, pad MUST equal 0 but instead was %d", pad);
+ expert_add_info_format_text(pinfo, ti, &ei_ipv6_cmpri_cmpre_pad, "When cmprI equals 0 and cmprE equals 0, pad MUST equal 0 but instead was %d", pad);
}
proto_tree_add_item(rthdr_tree, hf_ipv6_routing_hdr_rpl_reserved, tvb, offset, 4, ENC_BIG_ENDIAN);
reserved = tvb_get_bits32(tvb, ((offset + 1) * 8) + 4, 20, ENC_BIG_ENDIAN);
if(g_ipv6_rpl_srh_strict_rfc_checking && reserved != 0){
- expert_add_info_format(pinfo, ti, PI_PROTOCOL, PI_WARN, "Reserved field must equal 0 but instead was %d", reserved);
+ expert_add_info_format_text(pinfo, ti, &ei_ipv6_routing_hdr_rpl_reserved, "Reserved field must equal 0 but instead was %d", reserved);
}
/* from RFC6554:
if (segments < 0) {
/* This error should always be reported */
- expert_add_info_format(pinfo, ti, PI_MALFORMED, PI_ERROR, "Calculated total segments must be greater than or equal to 0, instead was %d", segments);
+ expert_add_info_format_text(pinfo, ti, &ei_ipv6_routing_hdr_rpl_segments_ge0, "Calculated total segments must be greater than or equal to 0, instead was %d", segments);
} else {
offset += 4;
/* Compare the addresses */
if (memcmp(addr.bytes, tempAddr.bytes, 16) == 0) {
/* Found a later address that is the same */
- expert_add_info_format(pinfo, ti, PI_PROTOCOL, PI_ERROR, "Multiple instances of the same address must not appear in the source route list");
+ expert_add_info(pinfo, ti, &ei_ipv6_src_route_list_mult_inst_same_addr);
break;
}
tempOffset += (16-cmprI);
/* Compare the addresses */
if (memcmp(addr.bytes, tempAddr.bytes, 16) == 0) {
/* Found a later address that is the same */
- expert_add_info_format(pinfo, ti, PI_PROTOCOL, PI_ERROR, "Multiple instances of the same address must not appear in the source route list");
+ expert_add_info(pinfo, ti, &ei_ipv6_src_route_list_mult_inst_same_addr);
}
}
/* IPv6 Source and Destination addresses of the encapsulating datagram (MUST) not appear in the SRH*/
if (memcmp(addr.bytes, srcAddr.bytes, 16) == 0) {
- expert_add_info_format(pinfo, ti, PI_PROTOCOL, PI_ERROR, "Source address must not appear in the source route list");
+ expert_add_info(pinfo, ti, &ei_ipv6_src_route_list_src_addr);
}
if (memcmp(addr.bytes, dstAddr.bytes, 16) == 0) {
- expert_add_info_format(pinfo, ti, PI_PROTOCOL, PI_ERROR, "Destination address must not appear in the source route list");
+ expert_add_info(pinfo, ti, &ei_ipv6_src_route_list_dst_addr);
}
/* Multicast addresses MUST NOT appear in the in SRH */
if(E_IN6_IS_ADDR_MULTICAST(&addr)){
- expert_add_info_format(pinfo, ti, PI_PROTOCOL, PI_ERROR, "Multicast addresses must not appear in the source route list");
+ expert_add_info(pinfo, ti, &ei_ipv6_src_route_list_multicast_addr);
}
}
}
if(g_ipv6_rpl_srh_strict_rfc_checking){
/* IPv6 Source and Destination addresses of the encapsulating datagram (MUST) not appear in the SRH*/
if (memcmp(addr.bytes, srcAddr.bytes, 16) == 0) {
- expert_add_info_format(pinfo, ti, PI_PROTOCOL, PI_ERROR, "Source address must not appear in the source route list");
+ expert_add_info(pinfo, ti, &ei_ipv6_src_route_list_src_addr);
}
if (memcmp(addr.bytes, dstAddr.bytes, 16) == 0) {
- expert_add_info_format(pinfo, ti, PI_PROTOCOL, PI_ERROR, "Destination address must not appear in the source route list");
+ expert_add_info(pinfo, ti, &ei_ipv6_src_route_list_dst_addr);
}
/* Multicast addresses MUST NOT appear in the in SRH */
if(E_IN6_IS_ADDR_MULTICAST(&addr)){
- expert_add_info_format(pinfo, ti, PI_PROTOCOL, PI_ERROR, "Multicast addresses must not appear in the source route list");
+ expert_add_info(pinfo, ti, &ei_ipv6_src_route_list_multicast_addr);
}
}
}
break;
case IP6OPT_TEL:
if (opt_len != 1) {
- expert_add_info_format(pinfo, ti_opt_len, PI_MALFORMED, PI_ERROR,
+ expert_add_info_format_text(pinfo, ti_opt_len, &ei_ipv6_opt_tel_invalid_len,
"Tunnel Encapsulation Limit: Invalid length (%u bytes)", opt_len);
}
proto_tree_add_item(opt_tree, hf_ipv6_opt_tel, tvb,
break;
case IP6OPT_JUMBO:
if (opt_len != 4) {
- expert_add_info_format(pinfo, ti_opt_len, PI_MALFORMED, PI_ERROR,
+ expert_add_info_format_text(pinfo, ti_opt_len, &ei_ipv6_opt_jumbo_invalid_len,
"Jumbo payload: Invalid length (%u bytes)", opt_len);
}
proto_tree_add_item(opt_tree, hf_ipv6_opt_jumbo, tvb,
case IP6OPT_RTALERT:
{
if (opt_len != 2) {
- expert_add_info_format(pinfo, ti_opt_len, PI_MALFORMED, PI_ERROR,
+ expert_add_info_format_text(pinfo, ti_opt_len, &ei_ipv6_opt_rtalert_invalid_len,
"Router alert: Invalid Length (%u bytes)",
opt_len + 2);
}
}
case IP6OPT_HOME_ADDRESS:
if (opt_len != 16) {
- expert_add_info_format(pinfo, ti_opt_len, PI_MALFORMED, PI_ERROR,
+ expert_add_info_format_text(pinfo, ti_opt_len, &ei_ipv6_mipv6_home_address_invalid_len,
"Home Address: Invalid length (%u bytes)", opt_len);
}
proto_tree_add_item(opt_tree, hf_ipv6_mipv6_home_address, tvb,
if (optlen < 1 || optlen > 3) {
it = proto_tree_add_text(opt_tree, tvb, p, 1,
"Invalid element length: %u", optlen);
- expert_add_info_format(pinfo, it, PI_MALFORMED, PI_ERROR,
+ expert_add_info_format_text(pinfo, it, &ei_ipv6_shim6_opt_elemlen_invalid,
"Invalid element length: %u", optlen);
return;
}
offset, 2, !is_cksum_correct);
PROTO_ITEM_SET_GENERATED(item);
if (!is_cksum_correct) {
- expert_add_info_format(pinfo, item, PI_CHECKSUM, PI_ERROR, "Bad checksum");
+ expert_add_info(pinfo, item, &ei_ipv6_shim6_checksum_bad);
col_append_str(pinfo->cinfo, COL_INFO, " [Shim6 CHECKSUM INCORRECT]");
}
}
&ett_geoip_info
#endif /* HAVE_GEOIP_V6 */
};
+ static ei_register_info ei[] = {
+ { &ei_ipv6_dst_addr_not_multicast, { "ipv6.dst_addr.not_multicast", PI_PROTOCOL, PI_WARN, "Destination address must not be a multicast address", EXPFILL }},
+ { &ei_ipv6_src_route_list_mult_inst_same_addr, { "ipv6.src_route_list.mult_inst_same_addr", PI_PROTOCOL, PI_ERROR, "Multiple instances of the same address must not appear in the source route list", EXPFILL }},
+ { &ei_ipv6_src_route_list_src_addr, { "ipv6.src_route_list.src_addr", PI_PROTOCOL, PI_ERROR, "Source address must not appear in the source route list", EXPFILL }},
+ { &ei_ipv6_src_route_list_dst_addr, { "ipv6.src_route_list.dst_addr", PI_PROTOCOL, PI_ERROR, "Destination address must not appear in the source route list", EXPFILL }},
+ { &ei_ipv6_src_route_list_multicast_addr, { "ipv6.src_route_list.multicast_addr", PI_PROTOCOL, PI_ERROR, "Multicast addresses must not appear in the source route list", EXPFILL }},
+ { &ei_ipv6_cmpri_cmpre_pad, { "ipv6.routing_hdr.rpl.cmprI.cmprE.pad", PI_PROTOCOL, PI_WARN, "When cmprI equals 0 and cmprE equals 0, pad MUST equal 0 but instead was X", EXPFILL }},
+ { &ei_ipv6_routing_hdr_rpl_reserved, { "ipv6.routing_hdr.rpl.reserved.not0", PI_PROTOCOL, PI_WARN, "Reserved field must equal 0 but instead was X", EXPFILL }},
+ { &ei_ipv6_opt_tel_invalid_len, { "ipv6.opt.tel.invalid_len", PI_MALFORMED, PI_ERROR, "Tunnel Encapsulation Limit: Invalid length", EXPFILL }},
+ { &ei_ipv6_opt_jumbo_invalid_len, { "ipv6.opt.jumbo.invalid_len", PI_MALFORMED, PI_ERROR, "Jumbo payload: Invalid length", EXPFILL }},
+ { &ei_ipv6_opt_rtalert_invalid_len, { "ipv6.opt.router_alert.invalid_len", PI_MALFORMED, PI_ERROR, "Router alert: Invalid Length", EXPFILL }},
+ { &ei_ipv6_mipv6_home_address_invalid_len, { "ipv6.mipv6_home_address.invalid_len", PI_MALFORMED, PI_ERROR, "Home Address: Invalid length", EXPFILL }},
+ { &ei_ipv6_shim6_opt_elemlen_invalid, { "ipv6.shim6.opt.elemlen.invalid", PI_MALFORMED, PI_ERROR, "Invalid element length", EXPFILL }},
+ { &ei_ipv6_shim6_checksum_bad, { "ipv6.shim6.checksum_bad.expert", PI_CHECKSUM, PI_ERROR, "Bad checksum", EXPFILL }},
+ { &ei_ipv6_routing_hdr_rpl_segments_ge0, { "ipv6.routing_hdr.rpl.segments.ge0", PI_MALFORMED, PI_ERROR, "Calculated total segments must be greater than or equal to 0, instead was X", EXPFILL }},
+ };
+
module_t *ipv6_module;
+ expert_module_t* expert_ipv6;
proto_ipv6 = proto_register_protocol("Internet Protocol Version 6", "IPv6", "ipv6");
proto_register_field_array(proto_ipv6, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
+ expert_ipv6 = expert_register_protocol(proto_ipv6);
+ expert_register_field_array(expert_ipv6, ei, array_length(ei));
/* Register configuration options */
ipv6_module = prefs_register_protocol(proto_ipv6, NULL);
git.samba.org / metze / wireshark / wip.git / commitdiff