osmith
/
wireshark
forked from osmocom/wireshark
1
0
Fork 0
Code Pull Requests Releases Wiki Activity

Add proto_tree_add_checksum. 

This is an attempt to standardize display/handling of checksum fields for all dissectors.
The main target is for dissectors that do validation, but dissectors that just report the
checksum were also included just to make them easier to find in the future.

Bug: 10620
Bug: 12058
Ping-Bug: 8859
Change-Id: Ia8abd86e42eaf8ed50de6b173409e914b17993bf
Reviewed-on: https://code.wireshark.org/review/16380
Petri-Dish: Michael Mann <mmann78@netscape.net>
Tested-by: Petri Dish Buildbot <buildbot-no-reply@wireshark.org>
Reviewed-by: Jeff Morriss <jeff.morriss.ws@gmail.com>
Reviewed-by: Michael Mann <mmann78@netscape.net>
This commit is contained in:
Michael Mann 2016-07-10 23:47:28 -04:00
parent 1e19f55f0c
commit ad6fc87d64
127 changed files with 1114 additions and 2314 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
colorfilters
View File

@ -9,7 +9,7 @@
@TCP RST@tcp.flags.reset eq 1@[42148,0,0][65535,64764,40092] @TCP RST@tcp.flags.reset eq 1@[42148,0,0][65535,64764,40092]
@SCTP ABORT@sctp.chunk_type eq ABORT@[42148,0,0][65535,64764,40092] @SCTP ABORT@sctp.chunk_type eq ABORT@[42148,0,0][65535,64764,40092]
@TTL low or unexpected@( ! ip.dst == 224.0.0.0/4 && ip.ttl < 5 && !pim && !ospf) || (ip.dst == 224.0.0.0/24 && ip.dst != 224.0.0.251 && ip.ttl != 1 && !(vrrp || carp))@[42148,0,0][60652,61680,60395] @TTL low or unexpected@( ! ip.dst == 224.0.0.0/4 && ip.ttl < 5 && !pim && !ospf) || (ip.dst == 224.0.0.0/24 && ip.dst != 224.0.0.251 && ip.ttl != 1 && !(vrrp || carp))@[42148,0,0][60652,61680,60395]
@Checksum Errors@eth.fcs_bad==1 || ip.checksum_bad==1 || tcp.checksum_bad==1 || udp.checksum_bad==1 || sctp.checksum_bad==1 || mstp.checksum_bad==1 || cdp.checksum_bad==1 || edp.checksum_bad==1 || wlan.fcs_bad==1 || stt.checksum.bad==1@[4718,10030,11796][63479,34695,34695] @Checksum Errors@eth.fcs.status=="Bad" || ip.checksum.status=="Bad" || tcp.checksum.status=="Bad" || udp.checksum.status=="Bad" || sctp.checksum.status=="Bad" || mstp.checksum.status=="Bad" || cdp.checksum.status=="Bad" || edp.checksum.status=="Bad" || wlan.fcs.status=="Bad" || stt.checksum.status=="Bad"@[4718,10030,11796][63479,34695,34695]
@SMB@smb || nbss || nbns || nbipx || ipxsap || netbios@[65278,65535,53456][4718,10030,11796] @SMB@smb || nbss || nbns || nbipx || ipxsap || netbios@[65278,65535,53456][4718,10030,11796]
@HTTP@http || tcp.port == 80 || http2@[58596,65535,51143][4718,10030,11796] @HTTP@http || tcp.port == 80 || http2@[58596,65535,51143][4718,10030,11796]
@IPX@ipx || spx@[65534,58325,58808][4718,10030,11796] @IPX@ipx || spx@[65534,58325,58808][4718,10030,11796]

1
debian/libwireshark0.symbols vendored
View File

@ -1053,6 +1053,7 @@ libwireshark.so.0 libwireshark0 #MINVER#
proto_tree_add_bytes_format_value@Base 1.9.1 proto_tree_add_bytes_format_value@Base 1.9.1
proto_tree_add_bytes_item@Base 1.12.0~rc1 proto_tree_add_bytes_item@Base 1.12.0~rc1
proto_tree_add_bytes_with_length@Base 1.99.3 proto_tree_add_bytes_with_length@Base 1.99.3
proto_tree_add_checksum@Base 2.1.1
proto_tree_add_debug_text@Base 1.9.1 proto_tree_add_debug_text@Base 1.9.1
proto_tree_add_double@Base 1.9.1 proto_tree_add_double@Base 1.9.1
proto_tree_add_double_format@Base 1.9.1 proto_tree_add_double_format@Base 1.9.1

3
doc/README.dissector
View File

@ -1996,8 +1996,7 @@ presented as a subtree, where the result is enclosed in square brackets
indicating a generated field. indicating a generated field.
Header checksum: 0x3d42 [correct] Header checksum: 0x3d42 [correct]
[Good: True] [Checksum Status: Good (1)]
[Bad: False]
PROTO_ITEM_SET_HIDDEN() PROTO_ITEM_SET_HIDDEN()
----------------------- -----------------------

7
docbook/release-notes.asciidoc
View File

@ -41,6 +41,13 @@ since version 2.1.0:
* The RTP player now allows up to 30 minutes of silence frames. * The RTP player now allows up to 30 minutes of silence frames.
* Packet bytes can now be displayed as EBCDIC. * Packet bytes can now be displayed as EBCDIC.
* The Qt UI loads captures faster on Windows. * The Qt UI loads captures faster on Windows.
* proto_tree_add_checksum was added as an API. This attempts to
standardize how checksums are reported and filtered for within
*Shark. There are no more individual "good" and "bad" filter
fields, protocols now have a "checksum.status" field that records
"Good", "Bad" and "Unverified" (neither good or bad). Color filters
provided with Wireshark have been adjusted to the new display filter
names, but custom ones may need to be updated.
The following features are new (or have been significantly updated) The following features are new (or have been significantly updated)
since version 2.0.0: since version 2.0.0:

24
epan/dissectors/asn1/c1222/packet-c1222-template.c
View File

@ -123,6 +123,7 @@ static int hf_c1222_write_size = -1;
static int hf_c1222_write_data = -1; static int hf_c1222_write_data = -1;
static int hf_c1222_procedure_num = -1; static int hf_c1222_procedure_num = -1;
static int hf_c1222_write_chksum = -1; static int hf_c1222_write_chksum = -1;
static int hf_c1222_write_chksum_status = -1;
static int hf_c1222_wait_secs = -1; static int hf_c1222_wait_secs = -1;
static int hf_c1222_neg_pkt_size = -1; static int hf_c1222_neg_pkt_size = -1;
static int hf_c1222_neg_nbr_pkts = -1; static int hf_c1222_neg_nbr_pkts = -1;
@ -380,7 +381,6 @@ parse_c1222_detailed(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int cm
gchar *auth_req = NULL; gchar *auth_req = NULL;
guint16 table = 0; guint16 table = 0;
guint16 tblsize = 0; guint16 tblsize = 0;
guint8 chksum = 0;
guint16 calcsum = 0; guint16 calcsum = 0;
guint8 wait_seconds = 0; guint8 wait_seconds = 0;
int numrates = 0; int numrates = 0;
@ -392,7 +392,6 @@ parse_c1222_detailed(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int cm
guint8 inter_char; guint8 inter_char;
guint8 resp_to; guint8 resp_to;
guint8 nbr_retries; guint8 nbr_retries;
proto_item *item = NULL;
/* special case to simplify handling of Negotiate service */ /* special case to simplify handling of Negotiate service */
if ((cmd & 0xF0) == C1222_CMD_NEGOTIATE) { if ((cmd & 0xF0) == C1222_CMD_NEGOTIATE) {
@ -509,16 +508,14 @@ parse_c1222_detailed(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int cm
proto_tree_add_item(tree, hf_c1222_write_data, tvb, *offset, tblsize, ENC_NA); proto_tree_add_item(tree, hf_c1222_write_data, tvb, *offset, tblsize, ENC_NA);
*offset += tblsize; *offset += tblsize;
*length -= tblsize; *length -= tblsize;
chksum = tvb_get_guint8(tvb, *offset);
item = proto_tree_add_uint(tree, hf_c1222_write_chksum, tvb, *offset, 1, chksum);
if (table == 7) {/* is it a procedure call? */ if (table == 7) {/* is it a procedure call? */
calcsum = c1222_cksum(tvb, (*offset)-tblsize-2, tblsize+2); calcsum = c1222_cksum(tvb, (*offset)-tblsize-2, tblsize+2);
} else { } else {
calcsum = c1222_cksum(tvb, (*offset)-tblsize, tblsize); calcsum = c1222_cksum(tvb, (*offset)-tblsize, tblsize);
} }
if (chksum != calcsum) { proto_tree_add_checksum(tree, tvb, *offset, hf_c1222_write_chksum, hf_c1222_write_chksum_status,
expert_add_info_format(pinfo, item, &ei_c1222_bad_checksum, "Bad checksum [should be 0x%02x]", calcsum); &ei_c1222_bad_checksum, pinfo, calcsum, ENC_NA, PROTO_CHECKSUM_VERIFY);
}
if (table == 7) {/* is it a procedure call? */ if (table == 7) {/* is it a procedure call? */
proto_item_set_text(tree, "C12.22 EPSEM: %s (%s-%d, %s-%d)", proto_item_set_text(tree, "C12.22 EPSEM: %s (%s-%d, %s-%d)",
val_to_str(cmd,commandnames,"Unknown (0x%02x)"), val_to_str(cmd,commandnames,"Unknown (0x%02x)"),
@ -555,12 +552,9 @@ parse_c1222_detailed(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int cm
proto_tree_add_item(tree, hf_c1222_write_data, tvb, *offset, tblsize, ENC_NA); proto_tree_add_item(tree, hf_c1222_write_data, tvb, *offset, tblsize, ENC_NA);
*offset += tblsize; *offset += tblsize;
*length -= tblsize; *length -= tblsize;
chksum = tvb_get_guint8(tvb, *offset);
item = proto_tree_add_uint(tree, hf_c1222_write_chksum, tvb, *offset, 1, chksum);
calcsum = c1222_cksum(tvb, (*offset)-tblsize, tblsize); calcsum = c1222_cksum(tvb, (*offset)-tblsize, tblsize);
if (chksum != calcsum) { proto_tree_add_checksum(tree, tvb, *offset, hf_c1222_write_chksum, hf_c1222_write_chksum_status,
expert_add_info_format(pinfo, item, &ei_c1222_bad_checksum, "Bad checksum [should be 0x%02x]", calcsum); &ei_c1222_bad_checksum, pinfo, calcsum, ENC_NA, PROTO_CHECKSUM_VERIFY);
}
proto_item_set_text(tree, "C12.22 EPSEM: %s (%s-%d)", proto_item_set_text(tree, "C12.22 EPSEM: %s (%s-%d)",
val_to_str(cmd,commandnames,"Unknown (0x%02x)"), val_to_str(cmd,commandnames,"Unknown (0x%02x)"),
val_to_str((table >> 8) & 0xF8, tableflags,"Unknown (0x%04x)"), table & 0x7FF); val_to_str((table >> 8) & 0xF8, tableflags,"Unknown (0x%04x)"), table & 0x7FF);
@ -1259,6 +1253,12 @@ void proto_register_c1222(void) {
NULL, 0x0, NULL, 0x0,
NULL, HFILL } NULL, HFILL }
}, },
{ &hf_c1222_write_chksum_status,
{ "C12.22 Table Data Checksum Status", "c1222.write.chksum.status",
FT_UINT8, BASE_NONE,
VALS(proto_checksum_vals), 0x0,
NULL, HFILL }
},
{ &hf_c1222_procedure_num, { &hf_c1222_procedure_num,
{ "C12.22 Procedure Number", "c1222.procedure.num", { "C12.22 Procedure Number", "c1222.procedure.num",
FT_UINT16, BASE_DEC, FT_UINT16, BASE_DEC,

3
epan/dissectors/packet-6lowpan.c
View File

@ -2088,9 +2088,8 @@ dissect_6lowpan_iphc_nhc(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gi
if (!(udp_flags & LOWPAN_NHC_UDP_CHECKSUM)) { if (!(udp_flags & LOWPAN_NHC_UDP_CHECKSUM)) {
/* Parse the checksum. */ /* Parse the checksum. */
udp.checksum = tvb_get_ntohs(tvb, offset); udp.checksum = tvb_get_ntohs(tvb, offset);
proto_tree_add_uint(tree, hf_6lowpan_udp_checksum, tvb, offset, 2, udp.checksum); proto_tree_add_checksum(tree, tvb, offset, hf_6lowpan_udp_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
offset += 2; offset += 2;
udp.checksum = g_ntohs(udp.checksum);
} }
else { else {
udp.checksum = 0; udp.checksum = 0;

2
epan/dissectors/packet-aol.c
View File

@ -226,7 +226,7 @@ static int dissect_aol_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
/* Add the first few P3 fields */ /* Add the first few P3 fields */
proto_tree_add_item(aol_tree,hf_aol_start,tvb,offset,1,ENC_NA); offset += 1; proto_tree_add_item(aol_tree,hf_aol_start,tvb,offset,1,ENC_NA); offset += 1;
proto_tree_add_item(aol_tree,hf_aol_crc, tvb,offset,2,ENC_BIG_ENDIAN); offset += 2; proto_tree_add_checksum(aol_tree, tvb, offset, hf_aol_crc, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS); offset += 2;
proto_tree_add_item(aol_tree,hf_aol_len, tvb,offset,2,ENC_BIG_ENDIAN); offset += 2; proto_tree_add_item(aol_tree,hf_aol_len, tvb,offset,2,ENC_BIG_ENDIAN); offset += 2;
/* Add sequence fields */ /* Add sequence fields */

3
epan/dissectors/packet-artnet.c
View File

@ -3141,8 +3141,7 @@ dissect_artnet_file_tn_master(tvbuff_t *tvb, guint offset, proto_tree *tree)
offset, 14, ENC_ASCII|ENC_NA); offset, 14, ENC_ASCII|ENC_NA);
offset += 14; offset += 14;
proto_tree_add_item(tree, hf_artnet_file_tn_master_checksum, tvb, proto_tree_add_checksum(tree, tvb, offset, hf_artnet_file_tn_master_checksum, -1, NULL, NULL, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
offset, 2, ENC_BIG_ENDIAN);
offset += 2; offset += 2;
proto_tree_add_item(tree, hf_artnet_file_tn_master_spare, tvb, proto_tree_add_item(tree, hf_artnet_file_tn_master_spare, tvb,

5
epan/dissectors/packet-asap.c
View File

@ -567,13 +567,12 @@ dissect_pe_identifier_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_t
proto_item_append_text(parameter_item, " (0x%x)", tvb_get_ntohl(parameter_tvb, PE_IDENTIFIER_OFFSET)); proto_item_append_text(parameter_item, " (0x%x)", tvb_get_ntohl(parameter_tvb, PE_IDENTIFIER_OFFSET));
} }
#define PE_CHECKSUM_LENGTH 2
#define PE_CHECKSUM_OFFSET PARAMETER_VALUE_OFFSET #define PE_CHECKSUM_OFFSET PARAMETER_VALUE_OFFSET
static void static void
dissect_pe_checksum_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item) dissect_pe_checksum_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{ {
proto_tree_add_item(parameter_tree, hf_pe_checksum, parameter_tvb, PE_CHECKSUM_OFFSET, PE_CHECKSUM_LENGTH, ENC_BIG_ENDIAN); proto_tree_add_checksum(parameter_tree, parameter_tvb, PE_CHECKSUM_OFFSET, hf_pe_checksum, -1, NULL, NULL, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
proto_item_append_text(parameter_item, " (0x%x)", tvb_get_ntohs(parameter_tvb, PE_CHECKSUM_OFFSET)); proto_item_append_text(parameter_item, " (0x%x)", tvb_get_ntohs(parameter_tvb, PE_CHECKSUM_OFFSET));
} }
@ -893,7 +892,7 @@ proto_register_asap(void)
{ &hf_reg_life, { "Registration Life", "asap.pool_element_registration_life", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_reg_life, { "Registration Life", "asap.pool_element_registration_life", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_cookie, { "Cookie", "asap.cookie", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_cookie, { "Cookie", "asap.cookie", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } },
{ &hf_pe_identifier, { "PE Identifier", "asap.pe_identifier", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_pe_identifier, { "PE Identifier", "asap.pe_identifier", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
{ &hf_pe_checksum, { "PE Checksum", "asap.pe_checksum", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_pe_checksum, { "PE Checksum", "asap.pe_checksum", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } },
{ &hf_hropt_items, { "Items", "asap.hropt_items", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_hropt_items, { "Items", "asap.hropt_items", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_server_identifier, { "Server Identifier", "asap.server_identifier", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_server_identifier, { "Server Identifier", "asap.server_identifier", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
{ &hf_home_enrp_server_bit, { "H Bit", "asap.h_bit", FT_BOOLEAN, 8, TFS(&home_enrp_server_bit_value), HOME_ENRP_SERVER_BIT_MASK, NULL, HFILL } }, { &hf_home_enrp_server_bit, { "H Bit", "asap.h_bit", FT_BOOLEAN, 8, TFS(&home_enrp_server_bit_value), HOME_ENRP_SERVER_BIT_MASK, NULL, HFILL } },

106
epan/dissectors/packet-atalk.c
View File

@ -367,23 +367,6 @@ static dissector_table_t ddp_dissector_table;
#define DDP_SHORT_HEADER_SIZE 5 #define DDP_SHORT_HEADER_SIZE 5
/*
* P = Padding, H = Hops, L = Len
*
* PPHHHHLL LLLLLLLL
*
* Assumes the argument is in host byte order.
*/
#define ddp_hops(x) ( ( x >> 10) & 0x3C )
#define ddp_len(x) ( x & 0x03ff )
typedef struct _e_ddp {
guint16 hops_len; /* combines pad, hops, and len */
guint16 sum,dnet,snet;
guint8 dnode,snode;
guint8 dport,sport;
guint8 type;
} e_ddp;
#define DDP_HEADER_SIZE 13 #define DDP_HEADER_SIZE 13
@ -1484,76 +1467,55 @@ dissect_ddp_short(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* dat
static int static int
dissect_ddp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) dissect_ddp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
{ {
e_ddp ddp;
proto_tree *ddp_tree; proto_tree *ddp_tree;
proto_item *ti, *hidden_item; proto_item *ti, *hidden_item;
struct atalk_ddp_addr *src = wmem_new0(pinfo->pool, struct atalk_ddp_addr), struct atalk_ddp_addr *src = wmem_new0(pinfo->pool, struct atalk_ddp_addr),
*dst = wmem_new0(pinfo->pool, struct atalk_ddp_addr); *dst = wmem_new0(pinfo->pool, struct atalk_ddp_addr);
tvbuff_t *new_tvb; tvbuff_t *new_tvb;
guint type;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "DDP"); col_set_str(pinfo->cinfo, COL_PROTOCOL, "DDP");
col_clear(pinfo->cinfo, COL_INFO); col_clear(pinfo->cinfo, COL_INFO);
tvb_memcpy(tvb, (guint8 *)&ddp, 0, sizeof(e_ddp)); pinfo->ptype = PT_DDP;
ddp.dnet=g_ntohs(ddp.dnet);
ddp.snet=g_ntohs(ddp.snet); ti = proto_tree_add_item(tree, proto_ddp, tvb, 0, DDP_HEADER_SIZE, ENC_NA);
ddp.sum=g_ntohs(ddp.sum); ddp_tree = proto_item_add_subtree(ti, ett_ddp);
ddp.hops_len=g_ntohs(ddp.hops_len);
hidden_item = proto_tree_add_string(ddp_tree, hf_ddp_src, tvb,
4, 3, address_to_str(wmem_packet_scope(), &pinfo->src));
PROTO_ITEM_SET_HIDDEN(hidden_item);
hidden_item = proto_tree_add_string(ddp_tree, hf_ddp_dst, tvb,
6, 3, address_to_str(wmem_packet_scope(), &pinfo->dst));
PROTO_ITEM_SET_HIDDEN(hidden_item);
proto_tree_add_item(ddp_tree, hf_ddp_hopcount, tvb, 0, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(ddp_tree, hf_ddp_len, tvb, 0, 2, ENC_BIG_ENDIAN);
proto_tree_add_checksum(ddp_tree, tvb, 0, hf_ddp_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
dst->net = tvb_get_ntohs(tvb, 4);
proto_tree_add_uint(ddp_tree, hf_ddp_dst_net, tvb, 4, 2, dst->net);
src->net = tvb_get_ntohs(tvb, 6);
proto_tree_add_uint(ddp_tree, hf_ddp_src_net, tvb, 6, 2, src->net);
dst->node = tvb_get_guint8(tvb, 8);
proto_tree_add_uint(ddp_tree, hf_ddp_dst_node, tvb, 8, 1, dst->node);
src->node = tvb_get_guint8(tvb, 9);
proto_tree_add_uint(ddp_tree, hf_ddp_src_node, tvb, 9, 1, src->node);
proto_tree_add_item_ret_uint(ddp_tree, hf_ddp_dst_socket, tvb, 10, 1, ENC_NA, &pinfo->destport);
proto_tree_add_item_ret_uint(ddp_tree, hf_ddp_src_socket, tvb, 11, 1, ENC_NA, &pinfo->srcport);
proto_tree_add_item_ret_uint(ddp_tree, hf_ddp_type, tvb, 12, 1, ENC_NA, &type);
col_add_str(pinfo->cinfo, COL_INFO,
val_to_str_ext(type, &op_vals_ext, "Unknown DDP protocol (%02x)"));
src->net = ddp.snet;
src->node = ddp.snode;
dst->net = ddp.dnet;
dst->node = ddp.dnode;
set_address(&pinfo->net_src, atalk_address_type, sizeof(struct atalk_ddp_addr), src); set_address(&pinfo->net_src, atalk_address_type, sizeof(struct atalk_ddp_addr), src);
copy_address_shallow(&pinfo->src, &pinfo->net_src); copy_address_shallow(&pinfo->src, &pinfo->net_src);
set_address(&pinfo->net_dst, atalk_address_type, sizeof(struct atalk_ddp_addr), dst); set_address(&pinfo->net_dst, atalk_address_type, sizeof(struct atalk_ddp_addr), dst);
copy_address_shallow(&pinfo->dst, &pinfo->net_dst); copy_address_shallow(&pinfo->dst, &pinfo->net_dst);
pinfo->ptype = PT_DDP;
pinfo->destport = ddp.dport;
pinfo->srcport = ddp.sport;
col_add_str(pinfo->cinfo, COL_INFO,
val_to_str_ext(ddp.type, &op_vals_ext, "Unknown DDP protocol (%02x)"));
if (tree) {
ti = proto_tree_add_item(tree, proto_ddp, tvb, 0, DDP_HEADER_SIZE,
ENC_NA);
ddp_tree = proto_item_add_subtree(ti, ett_ddp);
hidden_item = proto_tree_add_string(ddp_tree, hf_ddp_src, tvb,
4, 3, address_to_str(wmem_packet_scope(), &pinfo->src));
PROTO_ITEM_SET_HIDDEN(hidden_item);
hidden_item = proto_tree_add_string(ddp_tree, hf_ddp_dst, tvb,
6, 3, address_to_str(wmem_packet_scope(), &pinfo->dst));
PROTO_ITEM_SET_HIDDEN(hidden_item);
proto_tree_add_uint(ddp_tree, hf_ddp_hopcount, tvb, 0, 1,
ddp_hops(ddp.hops_len));
proto_tree_add_uint(ddp_tree, hf_ddp_len, tvb, 0, 2,
ddp_len(ddp.hops_len));
proto_tree_add_uint(ddp_tree, hf_ddp_checksum, tvb, 2, 2,
ddp.sum);
proto_tree_add_uint(ddp_tree, hf_ddp_dst_net, tvb, 4, 2,
ddp.dnet);
proto_tree_add_uint(ddp_tree, hf_ddp_src_net, tvb, 6, 2,
ddp.snet);
proto_tree_add_uint(ddp_tree, hf_ddp_dst_node, tvb, 8, 1,
ddp.dnode);
proto_tree_add_uint(ddp_tree, hf_ddp_src_node, tvb, 9, 1,
ddp.snode);
proto_tree_add_uint(ddp_tree, hf_ddp_dst_socket, tvb, 10, 1,
ddp.dport);
proto_tree_add_uint(ddp_tree, hf_ddp_src_socket, tvb, 11, 1,
ddp.sport);
proto_tree_add_uint(ddp_tree, hf_ddp_type, tvb, 12, 1,
ddp.type);
}
new_tvb = tvb_new_subset_remaining(tvb, DDP_HEADER_SIZE); new_tvb = tvb_new_subset_remaining(tvb, DDP_HEADER_SIZE);
if (!dissector_try_uint(ddp_dissector_table, ddp.type, new_tvb, pinfo, tree)) if (!dissector_try_uint(ddp_dissector_table, type, new_tvb, pinfo, tree))
{ {
call_data_dissector(new_tvb, pinfo, tree); call_data_dissector(new_tvb, pinfo, tree);
} }
@ -1666,11 +1628,11 @@ proto_register_atalk(void)
static hf_register_info hf_ddp[] = { static hf_register_info hf_ddp[] = {
{ &hf_ddp_hopcount, { &hf_ddp_hopcount,
{ "Hop count", "ddp.hopcount", FT_UINT8, BASE_DEC, NULL, 0x0, { "Hop count", "ddp.hopcount", FT_UINT16, BASE_DEC, NULL, 0x3C00,
NULL, HFILL }}, NULL, HFILL }},
{ &hf_ddp_len, { &hf_ddp_len,
{ "Datagram length", "ddp.len", FT_UINT16, BASE_DEC, NULL, 0x0, { "Datagram length", "ddp.len", FT_UINT16, BASE_DEC, NULL, 0x0300,
NULL, HFILL }}, NULL, HFILL }},
{ &hf_ddp_checksum, { &hf_ddp_checksum,

12
epan/dissectors/packet-ax25-kiss.c
View File

@ -335,17 +335,17 @@ dissect_ax25_kiss( tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, v
} }
if ( gPREF_CKSUM_MODE ) if ( gPREF_CKSUM_MODE )
{ {
kiss_cksum = 0; kiss_cksum = 0;
kiss_tvb_length = tvb_captured_length_remaining( tvb, 0 ) - 1; kiss_tvb_length = tvb_captured_length(tvb) - 1;
if ( kiss_tvb_length > 0 ) if ( kiss_tvb_length > 0 )
{ {
for ( kiss_cksum_index = 0; kiss_cksum_index < kiss_tvb_length; kiss_cksum_index++ ) for ( kiss_cksum_index = 0; kiss_cksum_index < kiss_tvb_length; kiss_cksum_index++ )
kiss_cksum ^= (tvb_get_guint8( tvb, kiss_cksum_index ) & 0xff); kiss_cksum ^= (tvb_get_guint8( tvb, kiss_cksum_index ) & 0xff);
proto_tree_add_uint( kiss_tree, hf_ax25_kiss_cksum,
tvb, kiss_cksum_index, 1, kiss_cksum ); proto_tree_add_checksum(kiss_tree, tvb, 0, hf_ax25_kiss_cksum, -1, NULL, pinfo, kiss_cksum, ENC_NA, PROTO_CHECKSUM_GENERATED);
}
} }
}
} }
/* Call sub-dissectors here */ /* Call sub-dissectors here */

2
epan/dissectors/packet-bitcoin.c
View File

@ -1554,7 +1554,7 @@ static int dissect_bitcoin_tcp_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree
proto_tree_add_item(tree, &hfi_bitcoin_magic, tvb, 0, 4, ENC_BIG_ENDIAN); proto_tree_add_item(tree, &hfi_bitcoin_magic, tvb, 0, 4, ENC_BIG_ENDIAN);
proto_tree_add_item_ret_string(tree, hfi_bitcoin_command.id, tvb, 4, 12, ENC_ASCII|ENC_NA, wmem_packet_scope(), &command); proto_tree_add_item_ret_string(tree, hfi_bitcoin_command.id, tvb, 4, 12, ENC_ASCII|ENC_NA, wmem_packet_scope(), &command);
proto_tree_add_item(tree, &hfi_bitcoin_length, tvb, 16, 4, ENC_LITTLE_ENDIAN); proto_tree_add_item(tree, &hfi_bitcoin_length, tvb, 16, 4, ENC_LITTLE_ENDIAN);
proto_tree_add_item(tree, &hfi_bitcoin_checksum, tvb, 20, 4, ENC_BIG_ENDIAN); proto_tree_add_checksum(tree, tvb, 20, hfi_bitcoin_checksum.id, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
offset = 24; offset = 24;

2
epan/dissectors/packet-btatt.c
View File

@ -8960,7 +8960,7 @@ dissect_attribute_value(proto_tree *tree, proto_item *patron_item, packet_info *
break; break;
case 0x03: /* Calculate Checksum */ case 0x03: /* Calculate Checksum */
proto_tree_add_item(tree, hf_btatt_ots_checksum, tvb, offset, 4, ENC_LITTLE_ENDIAN); proto_tree_add_checksum(tree, tvb, offset, hf_btatt_ots_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
offset += 4; offset += 4;
break; break;

28
epan/dissectors/packet-c1222.c
View File

@ -161,6 +161,7 @@ static int hf_c1222_write_size = -1;
static int hf_c1222_write_data = -1; static int hf_c1222_write_data = -1;
static int hf_c1222_procedure_num = -1; static int hf_c1222_procedure_num = -1;
static int hf_c1222_write_chksum = -1; static int hf_c1222_write_chksum = -1;
static int hf_c1222_write_chksum_status = -1;
static int hf_c1222_wait_secs = -1; static int hf_c1222_wait_secs = -1;
static int hf_c1222_neg_pkt_size = -1; static int hf_c1222_neg_pkt_size = -1;
static int hf_c1222_neg_nbr_pkts = -1; static int hf_c1222_neg_nbr_pkts = -1;
@ -224,7 +225,7 @@ static gint ett_c1222_Calling_authentication_value_c1222_U = -1;
static gint ett_c1222_Calling_authentication_value_c1221_U = -1; static gint ett_c1222_Calling_authentication_value_c1221_U = -1;
/*--- End of included file: packet-c1222-ett.c ---*/ /*--- End of included file: packet-c1222-ett.c ---*/
#line 177 "./asn1/c1222/packet-c1222-template.c" #line 178 "./asn1/c1222/packet-c1222-template.c"
static expert_field ei_c1222_command_truncated = EI_INIT; static expert_field ei_c1222_command_truncated = EI_INIT;
static expert_field ei_c1222_bad_checksum = EI_INIT; static expert_field ei_c1222_bad_checksum = EI_INIT;
@ -431,7 +432,6 @@ parse_c1222_detailed(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int cm
gchar *auth_req = NULL; gchar *auth_req = NULL;
guint16 table = 0; guint16 table = 0;
guint16 tblsize = 0; guint16 tblsize = 0;
guint8 chksum = 0;
guint16 calcsum = 0; guint16 calcsum = 0;
guint8 wait_seconds = 0; guint8 wait_seconds = 0;
int numrates = 0; int numrates = 0;
@ -443,7 +443,6 @@ parse_c1222_detailed(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int cm
guint8 inter_char; guint8 inter_char;
guint8 resp_to; guint8 resp_to;
guint8 nbr_retries; guint8 nbr_retries;
proto_item *item = NULL;
/* special case to simplify handling of Negotiate service */ /* special case to simplify handling of Negotiate service */
if ((cmd & 0xF0) == C1222_CMD_NEGOTIATE) { if ((cmd & 0xF0) == C1222_CMD_NEGOTIATE) {
@ -560,16 +559,14 @@ parse_c1222_detailed(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int cm
proto_tree_add_item(tree, hf_c1222_write_data, tvb, *offset, tblsize, ENC_NA); proto_tree_add_item(tree, hf_c1222_write_data, tvb, *offset, tblsize, ENC_NA);
*offset += tblsize; *offset += tblsize;
*length -= tblsize; *length -= tblsize;
chksum = tvb_get_guint8(tvb, *offset);
item = proto_tree_add_uint(tree, hf_c1222_write_chksum, tvb, *offset, 1, chksum);
if (table == 7) {/* is it a procedure call? */ if (table == 7) {/* is it a procedure call? */
calcsum = c1222_cksum(tvb, (*offset)-tblsize-2, tblsize+2); calcsum = c1222_cksum(tvb, (*offset)-tblsize-2, tblsize+2);
} else { } else {
calcsum = c1222_cksum(tvb, (*offset)-tblsize, tblsize); calcsum = c1222_cksum(tvb, (*offset)-tblsize, tblsize);
} }
if (chksum != calcsum) { proto_tree_add_checksum(tree, tvb, *offset, hf_c1222_write_chksum, hf_c1222_write_chksum_status,
expert_add_info_format(pinfo, item, &ei_c1222_bad_checksum, "Bad checksum [should be 0x%02x]", calcsum); &ei_c1222_bad_checksum, pinfo, calcsum, ENC_NA, PROTO_CHECKSUM_VERIFY);
}
if (table == 7) {/* is it a procedure call? */ if (table == 7) {/* is it a procedure call? */
proto_item_set_text(tree, "C12.22 EPSEM: %s (%s-%d, %s-%d)", proto_item_set_text(tree, "C12.22 EPSEM: %s (%s-%d, %s-%d)",
val_to_str(cmd,commandnames,"Unknown (0x%02x)"), val_to_str(cmd,commandnames,"Unknown (0x%02x)"),
@ -606,12 +603,9 @@ parse_c1222_detailed(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int cm
proto_tree_add_item(tree, hf_c1222_write_data, tvb, *offset, tblsize, ENC_NA); proto_tree_add_item(tree, hf_c1222_write_data, tvb, *offset, tblsize, ENC_NA);
*offset += tblsize; *offset += tblsize;
*length -= tblsize; *length -= tblsize;
chksum = tvb_get_guint8(tvb, *offset);
item = proto_tree_add_uint(tree, hf_c1222_write_chksum, tvb, *offset, 1, chksum);
calcsum = c1222_cksum(tvb, (*offset)-tblsize, tblsize); calcsum = c1222_cksum(tvb, (*offset)-tblsize, tblsize);
if (chksum != calcsum) { proto_tree_add_checksum(tree, tvb, *offset, hf_c1222_write_chksum, hf_c1222_write_chksum_status,
expert_add_info_format(pinfo, item, &ei_c1222_bad_checksum, "Bad checksum [should be 0x%02x]", calcsum); &ei_c1222_bad_checksum, pinfo, calcsum, ENC_NA, PROTO_CHECKSUM_VERIFY);
}
proto_item_set_text(tree, "C12.22 EPSEM: %s (%s-%d)", proto_item_set_text(tree, "C12.22 EPSEM: %s (%s-%d)",
val_to_str(cmd,commandnames,"Unknown (0x%02x)"), val_to_str(cmd,commandnames,"Unknown (0x%02x)"),
val_to_str((table >> 8) & 0xF8, tableflags,"Unknown (0x%04x)"), table & 0x7FF); val_to_str((table >> 8) & 0xF8, tableflags,"Unknown (0x%04x)"), table & 0x7FF);
@ -1566,7 +1560,7 @@ static int dissect_MESSAGE_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_
/*--- End of included file: packet-c1222-fn.c ---*/ /*--- End of included file: packet-c1222-fn.c ---*/
#line 1048 "./asn1/c1222/packet-c1222-template.c" #line 1042 "./asn1/c1222/packet-c1222-template.c"
/** /**
* Dissects a a full (reassembled) C12.22 message. * Dissects a a full (reassembled) C12.22 message.
@ -1781,6 +1775,12 @@ void proto_register_c1222(void) {
NULL, 0x0, NULL, 0x0,
NULL, HFILL } NULL, HFILL }
}, },
{ &hf_c1222_write_chksum_status,
{ "C12.22 Table Data Checksum Status", "c1222.write.chksum.status",
FT_UINT8, BASE_NONE,
VALS(proto_checksum_vals), 0x0,
NULL, HFILL }
},
{ &hf_c1222_procedure_num, { &hf_c1222_procedure_num,
{ "C12.22 Procedure Number", "c1222.procedure.num", { "C12.22 Procedure Number", "c1222.procedure.num",
FT_UINT16, BASE_DEC, FT_UINT16, BASE_DEC,

14
epan/dissectors/packet-carp.c
View File

@ -90,7 +90,6 @@ dissect_carp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
proto_item *ti, *tv; proto_item *ti, *tv;
proto_tree *carp_tree, *ver_type_tree; proto_tree *carp_tree, *ver_type_tree;
guint8 ver_type; guint8 ver_type;
guint16 cksum, computed_cksum;
/* Make sure it's a CARP packet */ /* Make sure it's a CARP packet */
if (!test_carp_packet(tvb, pinfo, tree, data)) if (!test_carp_packet(tvb, pinfo, tree, data))
@ -133,20 +132,15 @@ dissect_carp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
proto_tree_add_item(carp_tree, hf_carp_advbase, tvb, offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(carp_tree, hf_carp_advbase, tvb, offset, 1, ENC_BIG_ENDIAN);
offset++; offset++;
cksum = tvb_get_ntohs(tvb, offset);
ti = proto_tree_add_item(carp_tree, hf_carp_checksum, tvb, offset, 2, ENC_BIG_ENDIAN);
carp_len = tvb_reported_length(tvb); carp_len = tvb_reported_length(tvb);
if (!pinfo->fragmented && tvb_captured_length(tvb) >= carp_len) { if (!pinfo->fragmented && tvb_captured_length(tvb) >= carp_len) {
/* The packet isn't part of a fragmented datagram /* The packet isn't part of a fragmented datagram
and isn't truncated, so we can checksum it. */ and isn't truncated, so we can checksum it. */
SET_CKSUM_VEC_TVB(cksum_vec[0], tvb, 0, carp_len); SET_CKSUM_VEC_TVB(cksum_vec[0], tvb, 0, carp_len);
computed_cksum = in_cksum(&cksum_vec[0], 1); proto_tree_add_checksum(carp_tree, tvb, offset, hf_carp_checksum, -1, NULL, pinfo, in_cksum(&cksum_vec[0], 1),
if (computed_cksum == 0) { ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_IN_CKSUM);
proto_item_append_text(ti, " [correct]"); } else {
} else { proto_tree_add_checksum(carp_tree, tvb, offset, hf_carp_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
proto_item_append_text(ti, " [incorrect, should be 0x%04x]",
in_cksum_shouldbe(cksum, computed_cksum));
}
} }
offset+=2; offset+=2;

29
epan/dissectors/packet-cattp.c
View File

@ -87,6 +87,7 @@ static int hf_cattp_seq = -1;
static int hf_cattp_ack = -1; static int hf_cattp_ack = -1;
static int hf_cattp_windowsize = -1; static int hf_cattp_windowsize = -1;
static int hf_cattp_checksum = -1; static int hf_cattp_checksum = -1;
static int hf_cattp_checksum_status = -1;
static int hf_cattp_identification = -1; static int hf_cattp_identification = -1;
static int hf_cattp_iccid = -1; static int hf_cattp_iccid = -1;
static int hf_cattp_idlen = -1; static int hf_cattp_idlen = -1;
@ -218,12 +219,11 @@ dissect_cattp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U
const char *pdutype = "[Unknown PDU]"; const char *pdutype = "[Unknown PDU]";
proto_item *ti, *cattp_tree; proto_item *ti, *cattp_tree;
guint32 offset; guint32 offset;
gushort computed_chksum;
vec_t cksum_vec[1]; vec_t cksum_vec[1];
int header_offset; int header_offset;
guint cksum_data_len; guint cksum_data_len;
guint8 flags, first_byte, hlen, ver; guint8 flags, first_byte, hlen, ver;
guint16 plen, chksum, ackno, seqno, wsize, sport, dport; guint16 plen, ackno, seqno, wsize, sport, dport;
col_set_str(pinfo->cinfo, COL_PROTOCOL, CATTP_SHORTNAME); col_set_str(pinfo->cinfo, COL_PROTOCOL, CATTP_SHORTNAME);
@ -294,28 +294,16 @@ dissect_cattp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U
/* Parse and verify checksum */ /* Parse and verify checksum */
header_offset = 0; header_offset = 0;
cksum_data_len = hlen + plen; cksum_data_len = hlen + plen;
chksum = tvb_get_ntohs(tvb, offset);
if (!cattp_check_checksum) { if (!cattp_check_checksum) {
/* We have turned checksum checking off; we do NOT checksum it. */ /* We have turned checksum checking off; we do NOT checksum it. */
proto_tree_add_uint_format_value(cattp_tree, hf_cattp_checksum, tvb, offset, 2, proto_tree_add_checksum(cattp_tree, tvb, offset, hf_cattp_checksum, hf_cattp_checksum_status, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
chksum, "0x%X [validation disabled]", chksum);
} else { } else {
/* We haven't turned checksum checking off; checksum it. */ /* We haven't turned checksum checking off; checksum it. */
/* Unlike TCP, CATTP does not make use of a pseudo-header for checksum */ /* Unlike TCP, CATTP does not make use of a pseudo-header for checksum */
SET_CKSUM_VEC_TVB(cksum_vec[0], tvb, header_offset, cksum_data_len); SET_CKSUM_VEC_TVB(cksum_vec[0], tvb, header_offset, cksum_data_len);
computed_chksum = in_cksum(cksum_vec, 1); proto_tree_add_checksum(cattp_tree, tvb, offset, hf_cattp_checksum, hf_cattp_checksum_status, NULL, pinfo, in_cksum(cksum_vec, 1),
ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_IN_CKSUM);
if (computed_chksum == 0) {
/* Checksum is valid */
proto_tree_add_uint_format_value(cattp_tree, hf_cattp_checksum, tvb, offset, 2,
chksum, "0x%X [validated]", chksum);
} else {
/* Checksum is invalid. Let's compute the expected checksum, based on the data we have */
proto_tree_add_uint_format_value(cattp_tree, hf_cattp_checksum, tvb, offset, 2, chksum,
"0x%X [incorrect, correct: 0x%X]", chksum,
in_cksum_shouldbe(chksum, computed_chksum));
}
} /* End of checksum code */ } /* End of checksum code */
offset += 2; offset += 2;
@ -477,6 +465,13 @@ proto_register_cattp(void)
NULL, HFILL NULL, HFILL
} }
}, },
{
&hf_cattp_checksum_status,
{
"Checksum Status", "cattp.checksum.status", FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0,
NULL, HFILL
}
},
{ {
&hf_cattp_identification, &hf_cattp_identification,
{ {

70
epan/dissectors/packet-cdp.c
View File

@ -53,8 +53,7 @@ void proto_reg_handoff_cdp(void);
static int proto_cdp = -1; static int proto_cdp = -1;
static int hf_cdp_version = -1; static int hf_cdp_version = -1;
static int hf_cdp_checksum = -1; static int hf_cdp_checksum = -1;
static int hf_cdp_checksum_good = -1; static int hf_cdp_checksum_status = -1;
static int hf_cdp_checksum_bad = -1;
static int hf_cdp_ttl = -1; static int hf_cdp_ttl = -1;
static int hf_cdp_tlvtype = -1; static int hf_cdp_tlvtype = -1;
static int hf_cdp_tlvlength = -1; static int hf_cdp_tlvlength = -1;
@ -271,12 +270,11 @@ static const value_string type_nrgyz_vals[] = {
static int static int
dissect_cdp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) dissect_cdp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
{ {
proto_item *ti, *checksum_item; proto_item *ti;
proto_tree *cdp_tree = NULL, *checksum_tree; proto_tree *cdp_tree;
int offset = 0; int offset = 0;
guint16 type; guint16 type;
guint16 length, packet_checksum, computed_checksum, data_length; guint16 length, data_length;
gboolean checksum_good, checksum_bad;
proto_item *tlvi = NULL; proto_item *tlvi = NULL;
proto_tree *tlv_tree = NULL; proto_tree *tlv_tree = NULL;
int real_length; int real_length;
@ -289,25 +287,20 @@ dissect_cdp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
col_set_str(pinfo->cinfo, COL_PROTOCOL, "CDP"); col_set_str(pinfo->cinfo, COL_PROTOCOL, "CDP");
col_clear(pinfo->cinfo, COL_INFO); col_clear(pinfo->cinfo, COL_INFO);
if (tree) { ti = proto_tree_add_item(tree, proto_cdp, tvb, offset, -1, ENC_NA);
ti = proto_tree_add_item(tree, proto_cdp, tvb, offset, -1, ENC_NA); cdp_tree = proto_item_add_subtree(ti, ett_cdp);
cdp_tree = proto_item_add_subtree(ti, ett_cdp);
/* CDP header */ /* CDP header */
proto_tree_add_item(cdp_tree, hf_cdp_version, tvb, offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(cdp_tree, hf_cdp_version, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1; offset += 1;
proto_tree_add_uint_format_value(cdp_tree, hf_cdp_ttl, tvb, offset, 1, proto_tree_add_uint_format_value(cdp_tree, hf_cdp_ttl, tvb, offset, 1,
tvb_get_guint8(tvb, offset), tvb_get_guint8(tvb, offset),
"%u seconds", "%u seconds",
tvb_get_guint8(tvb, offset)); tvb_get_guint8(tvb, offset));
offset += 1; offset += 1;
} else {
offset += 2; /* The version/ttl fields from above */
}
/* Checksum display & verification code */ /* Checksum display & verification code */
packet_checksum = tvb_get_ntohs(tvb, offset);
data_length = tvb_reported_length(tvb); data_length = tvb_reported_length(tvb);
@ -343,29 +336,8 @@ dissect_cdp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
SET_CKSUM_VEC_TVB(cksum_vec[0], tvb, 0, data_length); SET_CKSUM_VEC_TVB(cksum_vec[0], tvb, 0, data_length);
} }
computed_checksum = in_cksum(cksum_vec, 1); proto_tree_add_checksum(cdp_tree, tvb, offset, hf_cdp_checksum, hf_cdp_checksum_status, NULL, pinfo, in_cksum(cksum_vec, 1),
checksum_good = (computed_checksum == 0); ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_IN_CKSUM);
checksum_bad = !checksum_good;
if (checksum_good) {
checksum_item = proto_tree_add_uint_format_value(cdp_tree,
hf_cdp_checksum, tvb, offset, 2, packet_checksum,
"0x%04x [correct]", packet_checksum);
} else {
checksum_item = proto_tree_add_uint_format_value(cdp_tree,
hf_cdp_checksum, tvb, offset, 2, packet_checksum,
"0x%04x [incorrect, should be 0x%04x]",
packet_checksum,
in_cksum_shouldbe(packet_checksum, computed_checksum));
}
checksum_tree = proto_item_add_subtree(checksum_item, ett_cdp_checksum);
checksum_item = proto_tree_add_boolean(checksum_tree, hf_cdp_checksum_good,
tvb, offset, 2, checksum_good);
PROTO_ITEM_SET_GENERATED(checksum_item);
checksum_item = proto_tree_add_boolean(checksum_tree, hf_cdp_checksum_bad,
tvb, offset, 2, checksum_bad);
PROTO_ITEM_SET_GENERATED(checksum_item);
offset += 2; offset += 2;
while (tvb_reported_length_remaining(tvb, offset) != 0) { while (tvb_reported_length_remaining(tvb, offset) != 0) {
@ -1290,13 +1262,9 @@ proto_register_cdp(void)
{ "Checksum", "cdp.checksum", FT_UINT16, BASE_HEX, NULL, 0x0, { "Checksum", "cdp.checksum", FT_UINT16, BASE_HEX, NULL, 0x0,
NULL, HFILL }}, NULL, HFILL }},
{ &hf_cdp_checksum_good, { &hf_cdp_checksum_status,
{ "Good", "cdp.checksum_good", FT_BOOLEAN, BASE_NONE, NULL, 0x0, { "Checksum Status", "cdp.checksum.status", FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0,
"True: checksum matches packet content; False: doesn't match content or not checked", HFILL }}, NULL, HFILL }},
{ &hf_cdp_checksum_bad,
{ "Bad", "cdp.checksum_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"True: checksum doesn't match packet content; False: matches content or not checked", HFILL }},
{ &hf_cdp_tlvtype, { &hf_cdp_tlvtype,
{ "Type", "cdp.tlv.type", FT_UINT16, BASE_HEX, VALS(type_vals), 0x0, { "Type", "cdp.tlv.type", FT_UINT16, BASE_HEX, VALS(type_vals), 0x0,

2
epan/dissectors/packet-cfdp.c
View File

@ -927,7 +927,7 @@ static guint32 dissect_cfdp_eof_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tre
col_add_fstr(pinfo->cinfo, COL_INFO, "EOF (%s)", val_to_str_const((aux_byte & 0xF0) >> 4, cfdp_condition_codes, "Reserved Code")); col_add_fstr(pinfo->cinfo, COL_INFO, "EOF (%s)", val_to_str_const((aux_byte & 0xF0) >> 4, cfdp_condition_codes, "Reserved Code"));
proto_tree_add_item(tree, hf_cfdp_file_checksum, tvb, offset, 4, ENC_BIG_ENDIAN); proto_tree_add_checksum(tree, tvb, offset, hf_cfdp_file_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
offset += 4; offset += 4;
proto_tree_add_item(tree, hf_cfdp_file_size, tvb, offset, 4, ENC_BIG_ENDIAN); proto_tree_add_item(tree, hf_cfdp_file_size, tvb, offset, 4, ENC_BIG_ENDIAN);

48
epan/dissectors/packet-clnp.c
View File

@ -221,7 +221,7 @@ dissect_clnp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_
guint16 segment_offset = 0; guint16 segment_offset = 0;
guint16 total_length; guint16 total_length;
guint16 cnf_cksum; guint16 cnf_cksum;
cksum_status_t cksum_status; gboolean cksum_valid = TRUE;
int offset; int offset;
guchar src_len, dst_len, nsel, opt_len = 0; guchar src_len, dst_len, nsel, opt_len = 0;
guint next_length; guint next_length;
@ -320,39 +320,19 @@ dissect_clnp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_
return 7; return 7;
} }
cnf_cksum = tvb_get_ntohs(tvb, P_CLNP_CKSUM); cnf_cksum = tvb_get_ntohs(tvb, P_CLNP_CKSUM);
cksum_status = calc_checksum(tvb, 0, cnf_hdr_len, cnf_cksum); if (cnf_cksum == 0) {
switch (cksum_status) { /* No checksum present */
default: proto_tree_add_checksum(clnp_tree, tvb, P_CLNP_CKSUM, hf_clnp_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NOT_PRESENT);
/* } else {
* No checksum present, or not enough of the header present to guint32 c0 = 0, c1 = 0;
* checksum it.
*/
proto_tree_add_uint(clnp_tree, hf_clnp_checksum, tvb,
P_CLNP_CKSUM, 2,
cnf_cksum);
break;
case CKSUM_OK: if (osi_calc_checksum(tvb, 0, cnf_hdr_len, &c0, &c1)) {
/* /* Successfully processed checksum, verify it */
* Checksum is correct. proto_tree_add_checksum(clnp_tree, tvb, P_CLNP_CKSUM, hf_clnp_checksum, -1, NULL, pinfo, c0 | c1, ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_ZERO);
*/ cksum_valid = (c0 | c1) ? FALSE : TRUE;
proto_tree_add_uint_format_value(clnp_tree, hf_clnp_checksum, tvb, } else {
P_CLNP_CKSUM, 2, proto_tree_add_checksum(clnp_tree, tvb, P_CLNP_CKSUM, hf_clnp_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
cnf_cksum, }
"0x%04x (correct)",
cnf_cksum);
break;
case CKSUM_NOT_OK:
/*
* Checksum is not correct.
*/
proto_tree_add_uint_format_value(clnp_tree, hf_clnp_checksum, tvb,
P_CLNP_CKSUM, 2,
cnf_cksum,
"0x%04x (incorrect)",
cnf_cksum);
break;
} }
opt_len = cnf_hdr_len; opt_len = cnf_hdr_len;
@ -475,7 +455,7 @@ dissect_clnp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_
((cnf_type & CNF_MORE_SEGS) || segment_offset != 0) && ((cnf_type & CNF_MORE_SEGS) || segment_offset != 0) &&
tvb_bytes_exist(tvb, offset, segment_length - cnf_hdr_len) && tvb_bytes_exist(tvb, offset, segment_length - cnf_hdr_len) &&
segment_length > cnf_hdr_len && segment_length > cnf_hdr_len &&
cksum_status != CKSUM_NOT_OK) { cksum_valid != FALSE) {
fd_head = fragment_add_check(&clnp_reassembly_table, fd_head = fragment_add_check(&clnp_reassembly_table,
tvb, offset, pinfo, du_id, NULL, tvb, offset, pinfo, du_id, NULL,
segment_offset, segment_length - cnf_hdr_len, segment_offset, segment_length - cnf_hdr_len,

36
epan/dissectors/packet-dccp.c
View File

@ -175,7 +175,7 @@ static int hf_dccp_data_offset = -1;
static int hf_dccp_ccval = -1; static int hf_dccp_ccval = -1;
static int hf_dccp_cscov = -1; static int hf_dccp_cscov = -1;
static int hf_dccp_checksum = -1; static int hf_dccp_checksum = -1;
static int hf_dccp_checksum_bad = -1; static int hf_dccp_checksum_status = -1;
static int hf_dccp_res1 = -1; static int hf_dccp_res1 = -1;
static int hf_dccp_type = -1; static int hf_dccp_type = -1;
static int hf_dccp_x = -1; static int hf_dccp_x = -1;
@ -600,7 +600,6 @@ dissect_dccp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_
proto_item *hidden_item, *offset_item; proto_item *hidden_item, *offset_item;
vec_t cksum_vec[4]; vec_t cksum_vec[4];
guint32 phdr[2]; guint32 phdr[2];
guint16 computed_cksum;
guint offset = 0; guint offset = 0;
guint len = 0; guint len = 0;
guint reported_len = 0; guint reported_len = 0;
@ -695,30 +694,11 @@ dissect_dccp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_
break; break;
} }
SET_CKSUM_VEC_TVB(cksum_vec[3], tvb, 0, csum_coverage_len); SET_CKSUM_VEC_TVB(cksum_vec[3], tvb, 0, csum_coverage_len);
computed_cksum = in_cksum(&cksum_vec[0], 4); proto_tree_add_checksum(dccp_tree, tvb, offset, hf_dccp_checksum, hf_dccp_checksum_status, NULL, pinfo, in_cksum(&cksum_vec[0], 4),
if (computed_cksum == 0) { ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_IN_CKSUM);
proto_tree_add_uint_format_value(dccp_tree,
hf_dccp_checksum, tvb,
offset, 2,
dccph->checksum,
"0x%04x [correct]",
dccph->checksum);
} else {
hidden_item =
proto_tree_add_boolean(dccp_tree, hf_dccp_checksum_bad,
tvb, offset, 2, TRUE);
PROTO_ITEM_SET_HIDDEN(hidden_item);
proto_tree_add_uint_format_value(
dccp_tree, hf_dccp_checksum, tvb, offset, 2,
dccph->checksum,
"0x%04x [incorrect, should be 0x%04x]",
dccph->checksum,
in_cksum_shouldbe(dccph->checksum, computed_cksum));
}
} else { } else {
proto_tree_add_uint_format_value(dccp_tree, hf_dccp_checksum, tvb, proto_tree_add_checksum(dccp_tree, tvb, offset, hf_dccp_checksum, hf_dccp_checksum_status, NULL, pinfo, 0,
offset, 2, dccph->checksum, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
"0x%04x", dccph->checksum);
} }
offset += 2; offset += 2;
@ -1078,10 +1058,10 @@ proto_register_dccp(void)
} }
}, },
{ {
&hf_dccp_checksum_bad, &hf_dccp_checksum_status,
{ {
"Bad Checksum", "dccp.checksum_bad", "Checksum Status", "dccp.checksum.status",
FT_BOOLEAN, BASE_NONE, NULL, 0x0, FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0,
NULL, HFILL NULL, HFILL
} }
}, },

20
epan/dissectors/packet-dec-dnart.c
View File

@ -123,6 +123,7 @@ static int hf_dec_rt_reserved = -1;
static int hf_dec_rt_fcnval = -1; static int hf_dec_rt_fcnval = -1;
static int hf_dec_rt_test_data = -1; static int hf_dec_rt_test_data = -1;
static int hf_dec_rt_segment = -1; static int hf_dec_rt_segment = -1;
static int hf_dec_rt_checksum = -1;
static int hf_dec_rt_id = -1; static int hf_dec_rt_id = -1;
static int hf_dec_rt_iinfo = -1; static int hf_dec_rt_iinfo = -1;
static int hf_dec_rt_iinfo_node_type = -1; static int hf_dec_rt_iinfo_node_type = -1;
@ -632,7 +633,6 @@ do_routing_msg(
{ {
guint my_offset = offset; guint my_offset = offset;
guint32 my_checksum = 1; guint32 my_checksum = 1;
guint16 checksum;
guint16 count, startid, rtginfo; guint16 count, startid, rtginfo;
guint remainder_count; guint remainder_count;
@ -667,18 +667,8 @@ do_routing_msg(
/* fold 32 bit sum into 16 bits */ /* fold 32 bit sum into 16 bits */
while (my_checksum>>16) while (my_checksum>>16)
my_checksum = (my_checksum & 0xffff) + (my_checksum >> 16); my_checksum = (my_checksum & 0xffff) + (my_checksum >> 16);
checksum = tvb_get_letohs(tvb, my_offset);
if (checksum != my_checksum) { proto_tree_add_checksum(tree, tvb, my_offset, hf_dec_rt_checksum, -1, NULL, pinfo, my_checksum, ENC_LITTLE_ENDIAN, PROTO_CHECKSUM_VERIFY);
proto_tree_add_none_format(tree, hf_dec_rt_segment, tvb,
my_offset, 2,
"Checksum mismatch(computed 0x%x <> received 0x%x)",
my_checksum, checksum);
} else {
proto_tree_add_none_format(tree, hf_dec_rt_segment, tvb,
my_offset, 2,
"Checksum: match (computed 0x%x = received 0x%x)",
my_checksum, checksum);
}
my_offset += 2; my_offset += 2;
return (my_offset); return (my_offset);
} }
@ -1343,6 +1333,10 @@ proto_register_dec_rt(void)
{ "Segment", "dec_dna.ctl.segment", { "Segment", "dec_dna.ctl.segment",
FT_NONE, BASE_NONE, NULL, 0x0, FT_NONE, BASE_NONE, NULL, 0x0,
"Routing Segment", HFILL }}, "Routing Segment", HFILL }},
{ &hf_dec_rt_checksum,
{ "Checksum", "dec_dna.ctl.checksum",
FT_UINT16, BASE_HEX, NULL, 0x0,
NULL, HFILL }},
{ &hf_dec_rt_id, { &hf_dec_rt_id,
{ "Transmitting system ID", "dec_dna.ctl.id", { "Transmitting system ID", "dec_dna.ctl.id",
FT_ETHER, BASE_NONE, NULL, 0x0, FT_ETHER, BASE_NONE, NULL, 0x0,

3
epan/dissectors/packet-dji-uav.c
View File

@ -245,8 +245,7 @@ dissect_djiuav_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *da
offset += pdu_length - 1 - offset; offset += pdu_length - 1 - offset;
} }
/* FIXME: calculate XOR and validate transmitted value */ /* FIXME: calculate XOR and validate transmitted value */
proto_tree_add_item(djiuav_tree, hf_djiuav_checksum, tvb, offset, 1, proto_tree_add_checksum(djiuav_tree, tvb, offset, hf_djiuav_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
ENC_BIG_ENDIAN);
offset += 1; offset += 1;
} }

54
epan/dissectors/packet-dmp.c
View File

@ -358,8 +358,7 @@ static int hf_ack_diagnostic = -1;
static int hf_ack_recips = -1; static int hf_ack_recips = -1;
static int hf_checksum = -1; static int hf_checksum = -1;
static int hf_checksum_good = -1; static int hf_checksum_status = -1;
static int hf_checksum_bad = -1;
static int hf_analysis_ack_time = -1; static int hf_analysis_ack_time = -1;
static int hf_analysis_total_time = -1; static int hf_analysis_total_time = -1;
@ -371,10 +370,10 @@ static int hf_analysis_retrans_no = -1;
static int hf_analysis_ack_num = -1; static int hf_analysis_ack_num = -1;
static int hf_analysis_ack_missing = -1; static int hf_analysis_ack_missing = -1;
static int hf_analysis_ack_dup_no = -1; static int hf_analysis_ack_dup_no = -1;
static int hf_analysis_rep_num = -1; /* static int hf_analysis_rep_num = -1; */
static int hf_analysis_acks_rep_num = -1; static int hf_analysis_acks_rep_num = -1;
static int hf_analysis_rep_time = -1; static int hf_analysis_rep_time = -1;
static int hf_analysis_not_num = -1; /* static int hf_analysis_not_num = -1; */
static int hf_analysis_acks_not_num = -1; static int hf_analysis_acks_not_num = -1;
static int hf_analysis_not_time = -1; static int hf_analysis_not_time = -1;
static int hf_analysis_msg_resend_from = -1; static int hf_analysis_msg_resend_from = -1;
@ -475,8 +474,6 @@ static gint ett_notif_acp127recip = -1;
static gint ett_ack = -1; static gint ett_ack = -1;
static gint ett_ack_recips = -1; static gint ett_ack_recips = -1;
static gint ett_checksum = -1;
static gint ett_analysis = -1; static gint ett_analysis = -1;
static expert_field ei_reserved_value = EI_INIT; static expert_field ei_reserved_value = EI_INIT;
@ -3968,8 +3965,8 @@ static gint dissect_dmp_extensions (tvbuff_t *tvb, packet_info *pinfo _U_,
static int dissect_dmp (tvbuff_t *tvb, packet_info *pinfo, static int dissect_dmp (tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, void *data _U_) proto_tree *tree, void *data _U_)
{ {
proto_tree *dmp_tree = NULL, *checksum_tree = NULL; proto_tree *dmp_tree;
proto_item *ti = NULL, *en = NULL; proto_item *ti;
guint16 checksum1 = 0, checksum2 = 1; guint16 checksum1 = 0, checksum2 = 1;
gint length, offset = 0; gint length, offset = 0;
gboolean retrans_or_dup_ack = FALSE; gboolean retrans_or_dup_ack = FALSE;
@ -4006,29 +4003,8 @@ static int dissect_dmp (tvbuff_t *tvb, packet_info *pinfo,
if (dmp.checksum) { if (dmp.checksum) {
length = tvb_captured_length (tvb); length = tvb_captured_length (tvb);
checksum1 = crc16_x25_ccitt_tvb (tvb, length - 2); checksum1 = crc16_x25_ccitt_tvb (tvb, length - 2);
checksum2 = tvb_get_ntohs (tvb, offset);
en = proto_tree_add_item (dmp_tree, hf_checksum, tvb, offset, 2, ENC_BIG_ENDIAN); proto_tree_add_checksum(dmp_tree, tvb, offset, hf_checksum, hf_checksum_status, &ei_checksum_bad, pinfo, checksum1, ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
checksum_tree = proto_item_add_subtree (en, ett_checksum);
if (checksum1 == checksum2) {
proto_item_append_text (en, " (correct)");
en = proto_tree_add_boolean (checksum_tree, hf_checksum_good, tvb,
offset, 2, TRUE);
PROTO_ITEM_SET_GENERATED (en);
en = proto_tree_add_boolean (checksum_tree, hf_checksum_bad, tvb,
offset, 2, FALSE);
PROTO_ITEM_SET_GENERATED (en);
} else {
proto_item_append_text (en, " (incorrect, should be 0x%04x)",
checksum1);
expert_add_info(pinfo, en, &ei_checksum_bad);
en = proto_tree_add_boolean (checksum_tree, hf_checksum_good, tvb,
offset, 2, FALSE);
PROTO_ITEM_SET_GENERATED (en);
en = proto_tree_add_boolean (checksum_tree, hf_checksum_bad, tvb,
offset, 2, TRUE);
PROTO_ITEM_SET_GENERATED (en);
}
offset += 2; offset += 2;
} }
@ -4773,12 +4749,9 @@ void proto_register_dmp (void)
{ &hf_checksum, { &hf_checksum,
{ "Checksum", "dmp.checksum", FT_UINT16, BASE_HEX, { "Checksum", "dmp.checksum", FT_UINT16, BASE_HEX,
NULL, 0x0, NULL, HFILL } }, NULL, 0x0, NULL, HFILL } },
{ &hf_checksum_good, { &hf_checksum_status,
{ "Good", "dmp.checksum_good", FT_BOOLEAN, BASE_NONE, { "Checksum Status", "dmp.checksum.status", FT_UINT8, BASE_NONE,
NULL, 0x0, "True: checksum matches packet content; False: doesn't match content or not checked", HFILL } }, VALS(proto_checksum_vals), 0x0, NULL, HFILL } },
{ &hf_checksum_bad,
{ "Bad", "dmp.checksum_bad", FT_BOOLEAN, BASE_NONE,
NULL, 0x0, "True: checksum doesn't match packet content; False: matches content or not checked", HFILL } },
/* /*
** Ack matching / Resend ** Ack matching / Resend
@ -4810,15 +4783,17 @@ void proto_register_dmp (void)
{ &hf_analysis_ack_num, { &hf_analysis_ack_num,
{ "Acknowledgement in", "dmp.analysis.ack_in", FT_FRAMENUM, BASE_NONE, { "Acknowledgement in", "dmp.analysis.ack_in", FT_FRAMENUM, BASE_NONE,
NULL, 0x0, "This packet has an Acknowledgement in this frame", HFILL } }, NULL, 0x0, "This packet has an Acknowledgement in this frame", HFILL } },
{ &hf_analysis_rep_num,
{ "Report in", "dmp.analysis.report_in", FT_FRAMENUM, BASE_NONE,
NULL, 0x0, "This packet has a Report in this frame", HFILL } },
{ &hf_analysis_acks_rep_num, { &hf_analysis_acks_rep_num,
{ "This is an Ack to the Report in", "dmp.analysis.acks_report_in", FT_FRAMENUM, BASE_NONE, { "This is an Ack to the Report in", "dmp.analysis.acks_report_in", FT_FRAMENUM, BASE_NONE,
FRAMENUM_TYPE(FT_FRAMENUM_ACK), 0x0, "This packet ACKs a Report in this frame", HFILL } }, FRAMENUM_TYPE(FT_FRAMENUM_ACK), 0x0, "This packet ACKs a Report in this frame", HFILL } },
#if 0
{ &hf_analysis_rep_num,
{ "Report in", "dmp.analysis.report_in", FT_FRAMENUM, BASE_NONE,
NULL, 0x0, "This packet has a Report in this frame", HFILL } },
{ &hf_analysis_not_num, { &hf_analysis_not_num,
{ "Notification in", "dmp.analysis.notif_in", FT_FRAMENUM, BASE_NONE, { "Notification in", "dmp.analysis.notif_in", FT_FRAMENUM, BASE_NONE,
NULL, 0x0, "This packet has a Notification in this frame", HFILL } }, NULL, 0x0, "This packet has a Notification in this frame", HFILL } },
#endif
{ &hf_analysis_acks_not_num, { &hf_analysis_acks_not_num,
{ "This is an Ack to the Notification in", "dmp.analysis.acks_notif_in", FT_FRAMENUM, BASE_NONE, { "This is an Ack to the Notification in", "dmp.analysis.acks_notif_in", FT_FRAMENUM, BASE_NONE,
FRAMENUM_TYPE(FT_FRAMENUM_ACK), 0x0, "This packet ACKs a Notification in this frame", HFILL } }, FRAMENUM_TYPE(FT_FRAMENUM_ACK), 0x0, "This packet ACKs a Notification in this frame", HFILL } },
@ -4962,7 +4937,6 @@ void proto_register_dmp (void)
&ett_notif_acp127recip, &ett_notif_acp127recip,
&ett_ack, &ett_ack,
&ett_ack_recips, &ett_ack_recips,
&ett_checksum,
&ett_analysis &ett_analysis
}; };

48
epan/dissectors/packet-dmx.c
View File

@ -92,8 +92,7 @@ static int hf_dmx_sip_fourth_dev_id = -1;
static int hf_dmx_sip_fifth_dev_id = -1; static int hf_dmx_sip_fifth_dev_id = -1;
static int hf_dmx_sip_reserved = -1; static int hf_dmx_sip_reserved = -1;
static int hf_dmx_sip_checksum = -1; static int hf_dmx_sip_checksum = -1;
static int hf_dmx_sip_checksum_good = -1; static int hf_dmx_sip_checksum_status = -1;
static int hf_dmx_sip_checksum_bad = -1;
static int hf_dmx_sip_trailer = -1; static int hf_dmx_sip_trailer = -1;
static int hf_dmx_test_data = -1; static int hf_dmx_test_data = -1;
@ -201,9 +200,6 @@ dissect_dmx_sip(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data
if (tree != NULL) { if (tree != NULL) {
guint offset = 0; guint offset = 0;
guint byte_count; guint byte_count;
guint checksum, checksum_shouldbe;
proto_item *item;
proto_tree *checksum_tree;
proto_tree *ti = proto_tree_add_item(tree, proto_dmx_sip, tvb, proto_tree *ti = proto_tree_add_item(tree, proto_dmx_sip, tvb,
offset, -1, ENC_NA); offset, -1, ENC_NA);
@ -273,34 +269,7 @@ dissect_dmx_sip(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data
offset += (byte_count - offset); offset += (byte_count - offset);
} }
dmx_sip_checksum(tvb, offset); proto_tree_add_checksum(dmx_sip_tree, tvb, offset, hf_dmx_sip_checksum, hf_dmx_sip_checksum_status, NULL, pinfo, dmx_sip_checksum(tvb, offset), ENC_NA, PROTO_CHECKSUM_VERIFY);
checksum_shouldbe = dmx_sip_checksum(tvb, offset);
checksum = tvb_get_guint8(tvb, offset);
item = proto_tree_add_item(dmx_sip_tree, hf_dmx_sip_checksum, tvb,
offset, 1, ENC_BIG_ENDIAN);
if (checksum == checksum_shouldbe) {
proto_item_append_text(item, " [correct]");
checksum_tree = proto_item_add_subtree(item, ett_dmx_sip);
item = proto_tree_add_boolean(checksum_tree, hf_dmx_sip_checksum_good, tvb,
offset, 1, TRUE);
PROTO_ITEM_SET_GENERATED(item);
item = proto_tree_add_boolean(checksum_tree, hf_dmx_sip_checksum_bad, tvb,
offset, 1, FALSE);
PROTO_ITEM_SET_GENERATED(item);
} else {
proto_item_append_text(item, " [incorrect, should be 0x%02x]", checksum_shouldbe);
checksum_tree = proto_item_add_subtree(item, ett_dmx_sip);
item = proto_tree_add_boolean(checksum_tree, hf_dmx_sip_checksum_good, tvb,
offset, 1, FALSE);
PROTO_ITEM_SET_GENERATED(item);
item = proto_tree_add_boolean(checksum_tree, hf_dmx_sip_checksum_bad, tvb,
offset, 1, TRUE);
PROTO_ITEM_SET_GENERATED(item);
}
offset += 1; offset += 1;
if (offset < tvb_reported_length(tvb)) if (offset < tvb_reported_length(tvb))
@ -600,15 +569,10 @@ proto_register_dmx_sip(void)
FT_UINT8, BASE_HEX, NULL, 0x0, FT_UINT8, BASE_HEX, NULL, 0x0,
NULL, HFILL }}, NULL, HFILL }},
{ &hf_dmx_sip_checksum_good, { &hf_dmx_sip_checksum_status,
{ "Good Checksum", "dmx_sip.checksum_good", { "Checksum Status", "dmx_sip.checksum.status",
FT_BOOLEAN, BASE_NONE, NULL, 0x0, FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0,
"True: checksum matches packet content; False: doesn't match content", HFILL }}, NULL, HFILL }},
{ &hf_dmx_sip_checksum_bad,
{ "Bad Checksum", "dmx_sip.checksum_bad",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"True: checksum doesn't match packet content; False: matches content", HFILL }},
{ &hf_dmx_sip_trailer, { &hf_dmx_sip_trailer,
{ "Trailer", "dmx_sip.trailer", { "Trailer", "dmx_sip.trailer",

12
epan/dissectors/packet-dvb-s2-bb.c
View File

@ -784,13 +784,9 @@ static int dissect_dvb_s2_bb(tvbuff_t *tvb, int cur_off, proto_tree *tree, packe
input8 = tvb_get_guint8(tvb, cur_off + DVB_S2_BB_OFFS_CRC); input8 = tvb_get_guint8(tvb, cur_off + DVB_S2_BB_OFFS_CRC);
new_off += 1; new_off += 1;
if (check_crc8(tvb, DVB_S2_BB_HEADER_LEN - 1, cur_off, input8)) {
proto_tree_add_uint_format(dvb_s2_bb_tree, hf_dvb_s2_bb_crc, tvb, proto_tree_add_checksum(dvb_s2_bb_tree, tvb, cur_off + DVB_S2_BB_OFFS_CRC, hf_dvb_s2_bb_crc, -1, NULL, pinfo,
cur_off + DVB_S2_BB_OFFS_CRC, 1, 1, "Checksum: correct (0x%2.2x)", input8); check_crc8(tvb, DVB_S2_BB_HEADER_LEN - 1, cur_off, input8), ENC_NA, PROTO_CHECKSUM_VERIFY);
} else {
proto_tree_add_uint_format(dvb_s2_bb_tree, hf_dvb_s2_bb_crc, tvb,
cur_off + DVB_S2_BB_OFFS_CRC, 1, -1, "Checksum: incorrect! (0x%2.2x)", input8);
}
while (bb_data_len) { while (bb_data_len) {
/* start DVB-GSE dissector */ /* start DVB-GSE dissector */
@ -987,7 +983,7 @@ void proto_register_dvb_s2_modeadapt(void)
"Distance to first user packet", HFILL} "Distance to first user packet", HFILL}
}, },
{&hf_dvb_s2_bb_crc, { {&hf_dvb_s2_bb_crc, {
"CRC", "dvb-s2_bb.crc", "Checksum", "dvb-s2_bb.crc",
FT_UINT8, BASE_HEX, NULL, 0x0, FT_UINT8, BASE_HEX, NULL, 0x0,
"CRC-8", HFILL} "CRC-8", HFILL}
} }

12
epan/dissectors/packet-dvmrp.c
View File

@ -63,7 +63,7 @@ static int hf_version = -1;
static int hf_type = -1; static int hf_type = -1;
static int hf_code_v1 = -1; static int hf_code_v1 = -1;
static int hf_checksum = -1; static int hf_checksum = -1;
static int hf_checksum_bad = -1; static int hf_checksum_status = -1;
static int hf_reserved = -1; static int hf_reserved = -1;
static int hf_commands = -1; static int hf_commands = -1;
static int hf_command = -1; static int hf_command = -1;
@ -336,7 +336,7 @@ dissect_dvmrp_v3(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, int
"Unknown Type:0x%02x")); "Unknown Type:0x%02x"));
/* checksum */ /* checksum */
igmp_checksum(parent_tree, tvb, hf_checksum, hf_checksum_bad, pinfo, 0); igmp_checksum(parent_tree, tvb, hf_checksum, hf_checksum_status, pinfo, 0);
offset += 2; offset += 2;
/* skip unused byte */ /* skip unused byte */
@ -525,7 +525,7 @@ dissect_dvmrp_v1(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, int
"Unknown Type:0x%02x")); "Unknown Type:0x%02x"));
/* checksum */ /* checksum */
igmp_checksum(parent_tree, tvb, hf_checksum, hf_checksum_bad, pinfo, 0); igmp_checksum(parent_tree, tvb, hf_checksum, hf_checksum_status, pinfo, 0);
offset += 2; offset += 2;
/* decode all the v1 commands */ /* decode all the v1 commands */
@ -720,9 +720,9 @@ proto_register_dvmrp(void)
{ "Checksum", "dvmrp.checksum", FT_UINT16, BASE_HEX, { "Checksum", "dvmrp.checksum", FT_UINT16, BASE_HEX,
NULL, 0, "DVMRP Checksum", HFILL }}, NULL, 0, "DVMRP Checksum", HFILL }},
{ &hf_checksum_bad, { &hf_checksum_status,
{ "Bad Checksum", "dvmrp.checksum_bad", FT_BOOLEAN, BASE_NONE, { "Checksum Status", "dvmrp.checksum.status", FT_UINT8, BASE_NONE,
NULL, 0x0, "Bad DVMRP Checksum", HFILL }}, VALS(proto_checksum_vals), 0x0, NULL, HFILL }},
{ &hf_reserved, { &hf_reserved,
{ "Reserved", "dvmrp.reserved", FT_UINT16, BASE_HEX, { "Reserved", "dvmrp.reserved", FT_UINT16, BASE_HEX,

17
epan/dissectors/packet-eigrp.c
View File

@ -2416,9 +2416,9 @@ static int
dissect_eigrp (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_) dissect_eigrp (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
{ {
proto_item *ti; proto_item *ti;
proto_tree *eigrp_tree = NULL, *tlv_tree; proto_tree *eigrp_tree, *tlv_tree;
guint opcode, vrid; guint opcode, vrid;
guint16 tlv, checksum, cacl_checksum; guint16 tlv;
guint32 ack, size, offset = EIGRP_HEADER_LENGTH; guint32 ack, size, offset = EIGRP_HEADER_LENGTH;
/* Make entries in Protocol column and Info column on summary display */ /* Make entries in Protocol column and Info column on summary display */
@ -2463,18 +2463,7 @@ dissect_eigrp (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _
ENC_BIG_ENDIAN); ENC_BIG_ENDIAN);
size = tvb_captured_length(tvb); size = tvb_captured_length(tvb);
checksum = tvb_get_ntohs(tvb, 2); proto_tree_add_checksum(eigrp_tree, tvb, 2, hf_eigrp_checksum, -1, &ei_eigrp_checksum_bad, pinfo, ip_checksum_tvb(tvb, 0, size), ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
cacl_checksum = ip_checksum_tvb(tvb, 0, size);
if (cacl_checksum == checksum) {
proto_tree_add_uint_format_value(eigrp_tree, hf_eigrp_checksum, tvb, 2, 2,
checksum, "0x%02x [incorrect]",
checksum);
expert_add_info(pinfo, ti, &ei_eigrp_checksum_bad);
} else {
proto_tree_add_uint_format_value(eigrp_tree, hf_eigrp_checksum, tvb, 2, 2,
checksum, "0x%02x [correct]", checksum);
}
/* Decode the EIGRP Flags Field */ /* Decode the EIGRP Flags Field */
proto_tree_add_bitmask(eigrp_tree, tvb, 4, hf_eigrp_flags, ett_eigrp_flags, proto_tree_add_bitmask(eigrp_tree, tvb, 4, hf_eigrp_flags, ett_eigrp_flags,

12
epan/dissectors/packet-epon.c
View File

@ -172,16 +172,8 @@ dissect_epon(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
sent_checksum = tvb_get_guint8(tvb, 5+offset); sent_checksum = tvb_get_guint8(tvb, 5+offset);
checksum = get_crc8_ieee8023_epon(tvb, 5, 0+offset); checksum = get_crc8_ieee8023_epon(tvb, 5, 0+offset);
if (sent_checksum == checksum) { proto_tree_add_checksum(epon_tree, tvb, 5+offset, hf_epon_checksum, -1, &ei_epon_checksum_bad, pinfo, checksum, ENC_NA, PROTO_CHECKSUM_VERIFY);
proto_tree_add_uint_format_value(epon_tree, hf_epon_checksum, tvb, if (sent_checksum != checksum) {
5+offset, 1, sent_checksum,
"0x%01x [correct]", sent_checksum);
} else {
item = proto_tree_add_uint_format_value(epon_tree, hf_epon_checksum, tvb,
5+offset, 1, sent_checksum,
"0x%01x [incorrect, should be 0x%01x]",
sent_checksum, checksum);
expert_add_info(pinfo, item, &ei_epon_checksum_bad);
col_append_str(pinfo->cinfo, COL_INFO, " [EPON PREAMBLE CHECKSUM INCORRECT]"); col_append_str(pinfo->cinfo, COL_INFO, " [EPON PREAMBLE CHECKSUM INCORRECT]");
} }

35
epan/dissectors/packet-esis.c
View File

@ -250,7 +250,6 @@ dissect_esis(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_
proto_tree *esis_tree = NULL; proto_tree *esis_tree = NULL;
guint8 variable_len, type; guint8 variable_len, type;
guint16 holdtime, checksum; guint16 holdtime, checksum;
const char *cksum_status;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "ESIS"); col_set_str(pinfo->cinfo, COL_PROTOCOL, "ESIS");
col_clear(pinfo->cinfo, COL_INFO); col_clear(pinfo->cinfo, COL_INFO);
@ -285,31 +284,19 @@ dissect_esis(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_
holdtime, "%u seconds", holdtime); holdtime, "%u seconds", holdtime);
checksum = tvb_get_ntohs(tvb, 7); checksum = tvb_get_ntohs(tvb, 7);
switch (calc_checksum( tvb, 0, length, checksum)) { if (checksum == 0) {
/* No checksum present */
proto_tree_add_checksum(esis_tree, tvb, 7, hf_esis_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NOT_PRESENT);
} else {
guint32 c0 = 0, c1 = 0;
case NO_CKSUM: if (osi_calc_checksum(tvb, 0, length, &c0, &c1)) {
cksum_status = "Not Used"; /* Successfully processed checksum, verify it */
break; proto_tree_add_checksum(esis_tree, tvb, 7, hf_esis_checksum, -1, NULL, pinfo, c0 | c1, ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_ZERO);
} else {
case DATA_MISSING: proto_tree_add_checksum(esis_tree, tvb, 7, hf_esis_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
cksum_status = "Not checkable - not all of packet was captured"; }
break;
case CKSUM_OK:
cksum_status = "Is good";
break;
case CKSUM_NOT_OK:
cksum_status = "Is wrong";
break;
default:
cksum_status = NULL;
DISSECTOR_ASSERT_NOT_REACHED();
} }
proto_tree_add_uint_format_value( esis_tree, hf_esis_checksum, tvb, 7, 2,
checksum, "0x%x ( %s )", checksum, cksum_status );
/* /*
* Let us make sure we use the same names for all our decodes * Let us make sure we use the same names for all our decodes

57
epan/dissectors/packet-eth.c
View File

@ -78,14 +78,12 @@ static int hf_eth_ig = -1;
static int hf_eth_padding = -1; static int hf_eth_padding = -1;
static int hf_eth_trailer = -1; static int hf_eth_trailer = -1;
static int hf_eth_fcs = -1; static int hf_eth_fcs = -1;
static int hf_eth_fcs_good = -1; static int hf_eth_fcs_status = -1;
static int hf_eth_fcs_bad = -1;
static gint ett_ieee8023 = -1; static gint ett_ieee8023 = -1;
static gint ett_ether2 = -1; static gint ett_ether2 = -1;
static gint ett_ether = -1; static gint ett_ether = -1;
static gint ett_addr = -1; static gint ett_addr = -1;
static gint ett_eth_fcs = -1;
static expert_field ei_eth_invalid_lentype = EI_INIT; static expert_field ei_eth_invalid_lentype = EI_INIT;
static expert_field ei_eth_src_not_group = EI_INIT; static expert_field ei_eth_src_not_group = EI_INIT;
@ -647,8 +645,6 @@ add_ethernet_trailer(packet_info *pinfo, proto_tree *tree, proto_tree *fh_tree,
have had 64 or more bytes - i.e., it was at least an FCS worth of data have had 64 or more bytes - i.e., it was at least an FCS worth of data
longer than the minimum payload size - we could assume the last 4 bytes longer than the minimum payload size - we could assume the last 4 bytes
of the trailer are an FCS. */ of the trailer are an FCS. */
proto_item *item;
proto_tree *checksum_tree;
heur_dtbl_entry_t *hdtbl_entry; heur_dtbl_entry_t *hdtbl_entry;
if (trailer_tvb) { if (trailer_tvb) {
@ -749,43 +745,13 @@ add_ethernet_trailer(packet_info *pinfo, proto_tree *tree, proto_tree *fh_tree,
guint32 sent_fcs = tvb_get_ntohl(trailer_tvb, padding_length+trailer_length); guint32 sent_fcs = tvb_get_ntohl(trailer_tvb, padding_length+trailer_length);
if(eth_check_fcs){ if(eth_check_fcs){
guint32 fcs = crc32_802_tvb(tvb, tvb_captured_length(tvb) - 4); guint32 fcs = crc32_802_tvb(tvb, tvb_captured_length(tvb) - 4);
if (fcs == sent_fcs) { proto_tree_add_checksum(fh_tree, trailer_tvb, padding_length+trailer_length, hf_eth_fcs, hf_eth_fcs_status, &ei_eth_fcs_bad, pinfo, fcs, ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
item = proto_tree_add_uint_format_value(fh_tree, hf_eth_fcs, trailer_tvb,
padding_length+trailer_length, 4, sent_fcs, if (fcs != sent_fcs) {
"0x%08x [correct]", sent_fcs);
checksum_tree = proto_item_add_subtree(item, ett_eth_fcs);
item = proto_tree_add_boolean(checksum_tree, hf_eth_fcs_good, trailer_tvb,
padding_length+trailer_length, 4, TRUE);
PROTO_ITEM_SET_GENERATED(item);
item = proto_tree_add_boolean(checksum_tree, hf_eth_fcs_bad, trailer_tvb,
padding_length+trailer_length, 4, FALSE);
PROTO_ITEM_SET_GENERATED(item);
} else {
item = proto_tree_add_uint_format_value(fh_tree, hf_eth_fcs, trailer_tvb,
padding_length+trailer_length, 4, sent_fcs,
"0x%08x [incorrect, should be 0x%08x]",
sent_fcs, fcs);
checksum_tree = proto_item_add_subtree(item, ett_eth_fcs);
item = proto_tree_add_boolean(checksum_tree, hf_eth_fcs_good, trailer_tvb,
padding_length+trailer_length, 4, FALSE);
PROTO_ITEM_SET_GENERATED(item);
item = proto_tree_add_boolean(checksum_tree, hf_eth_fcs_bad, trailer_tvb,
padding_length+trailer_length, 4, TRUE);
PROTO_ITEM_SET_GENERATED(item);
expert_add_info(pinfo, item, &ei_eth_fcs_bad);
col_append_str(pinfo->cinfo, COL_INFO, " [ETHERNET FRAME CHECK SEQUENCE INCORRECT]"); col_append_str(pinfo->cinfo, COL_INFO, " [ETHERNET FRAME CHECK SEQUENCE INCORRECT]");
} }
}else{ }else{
item = proto_tree_add_uint_format_value(fh_tree, hf_eth_fcs, trailer_tvb, proto_tree_add_checksum(fh_tree, trailer_tvb, padding_length+trailer_length, hf_eth_fcs, hf_eth_fcs_status, &ei_eth_fcs_bad, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
padding_length+trailer_length, 4, sent_fcs,
"0x%08x [validation disabled]", sent_fcs);
checksum_tree = proto_item_add_subtree(item, ett_eth_fcs);
item = proto_tree_add_boolean(checksum_tree, hf_eth_fcs_good, trailer_tvb,
padding_length+trailer_length, 4, FALSE);
PROTO_ITEM_SET_GENERATED(item);
item = proto_tree_add_boolean(checksum_tree, hf_eth_fcs_bad, trailer_tvb,
padding_length+trailer_length, 4, FALSE);
PROTO_ITEM_SET_GENERATED(item);
} }
trailer_length += 4; trailer_length += 4;
} }
@ -919,13 +885,9 @@ proto_register_eth(void)
{ "Frame check sequence", "eth.fcs", FT_UINT32, BASE_HEX, NULL, 0x0, { "Frame check sequence", "eth.fcs", FT_UINT32, BASE_HEX, NULL, 0x0,
"Ethernet checksum", HFILL }}, "Ethernet checksum", HFILL }},
{ &hf_eth_fcs_good, { &hf_eth_fcs_status,
{ "FCS Good", "eth.fcs_good", FT_BOOLEAN, BASE_NONE, NULL, 0x0, { "FCS Status", "eth.fcs.status", FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0,
"True: checksum matches packet content; False: doesn't match content or not checked", HFILL }}, NULL, HFILL }},
{ &hf_eth_fcs_bad,
{ "FCS Bad", "eth.fcs_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"True: checksum doesn't match packet content; False: does match content or not checked", HFILL }},
{ &hf_eth_lg, { &hf_eth_lg,
{ "LG bit", "eth.lg", FT_BOOLEAN, 24, { "LG bit", "eth.lg", FT_BOOLEAN, 24,
@ -942,13 +904,12 @@ proto_register_eth(void)
&ett_ether2, &ett_ether2,
&ett_ether, &ett_ether,
&ett_addr, &ett_addr,
&ett_eth_fcs
}; };
static ei_register_info ei[] = { static ei_register_info ei[] = {
{ &ei_eth_invalid_lentype, { "eth.invalid_lentype.expert", PI_PROTOCOL, PI_WARN, "Invalid length/type", EXPFILL }}, { &ei_eth_invalid_lentype, { "eth.invalid_lentype.expert", PI_PROTOCOL, PI_WARN, "Invalid length/type", EXPFILL }},
{ &ei_eth_src_not_group, { "eth.src_not_group", PI_PROTOCOL, PI_WARN, "Source MAC must not be a group address: IEEE 802.3-2002, Section 3.2.3(b)", EXPFILL }}, { &ei_eth_src_not_group, { "eth.src_not_group", PI_PROTOCOL, PI_WARN, "Source MAC must not be a group address: IEEE 802.3-2002, Section 3.2.3(b)", EXPFILL }},
{ &ei_eth_fcs_bad, { "eth.fcs_bad.expert", PI_CHECKSUM, PI_ERROR, "Bad checksum", EXPFILL }}, { &ei_eth_fcs_bad, { "eth.fcs_bad", PI_CHECKSUM, PI_ERROR, "Bad checksum", EXPFILL }},
{ &ei_eth_len, { "eth.len.past_end", PI_MALFORMED, PI_ERROR, "Length field value goes past the end of the payload", EXPFILL }}, { &ei_eth_len, { "eth.len.past_end", PI_MALFORMED, PI_ERROR, "Length field value goes past the end of the payload", EXPFILL }},
}; };

49
epan/dissectors/packet-extreme.c
View File

@ -159,8 +159,7 @@ static int hf_edp_version = -1;
static int hf_edp_reserved = -1; static int hf_edp_reserved = -1;
static int hf_edp_length = -1; static int hf_edp_length = -1;
static int hf_edp_checksum = -1; static int hf_edp_checksum = -1;
static int hf_edp_checksum_good = -1; static int hf_edp_checksum_status = -1;
static int hf_edp_checksum_bad = -1;
static int hf_edp_seqno = -1; static int hf_edp_seqno = -1;
static int hf_edp_midtype = -1; static int hf_edp_midtype = -1;
@ -255,7 +254,6 @@ static int hf_edp_null = -1;
static expert_field ei_edp_short_tlv = EI_INIT; static expert_field ei_edp_short_tlv = EI_INIT;
static gint ett_edp = -1; static gint ett_edp = -1;
static gint ett_edp_checksum = -1;
static gint ett_edp_tlv_header = -1; static gint ett_edp_tlv_header = -1;
static gint ett_edp_display = -1; static gint ett_edp_display = -1;
static gint ett_edp_info = -1; static gint ett_edp_info = -1;
@ -950,11 +948,7 @@ dissect_edp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
{ {
proto_item *ti; proto_item *ti;
proto_tree *edp_tree; proto_tree *edp_tree;
proto_item *checksum_item;
proto_tree *checksum_tree;
guint32 offset = 0; guint32 offset = 0;
guint16 packet_checksum, computed_checksum;
gboolean checksum_good, checksum_bad;
gboolean last = FALSE; gboolean last = FALSE;
guint8 tlv_type; guint8 tlv_type;
guint16 tlv_length; guint16 tlv_length;
@ -982,40 +976,18 @@ dissect_edp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
data_length); data_length);
offset += 2; offset += 2;
packet_checksum = tvb_get_ntohs(tvb, offset);
/* /*
* If we have the entire ESP packet available, check the checksum. * If we have the entire ESP packet available, check the checksum.
*/ */
if (tvb_captured_length(tvb) >= data_length) { if (tvb_captured_length(tvb) >= data_length) {
/* Checksum from version to null tlv */ /* Checksum from version to null tlv */
SET_CKSUM_VEC_TVB(cksum_vec[0], tvb, 0, data_length); SET_CKSUM_VEC_TVB(cksum_vec[0], tvb, 0, data_length);
computed_checksum = in_cksum(&cksum_vec[0], 1);
checksum_good = (computed_checksum == 0); proto_tree_add_checksum(edp_tree, tvb, offset, hf_edp_checksum, hf_edp_checksum_status, NULL, pinfo, in_cksum(&cksum_vec[0], 1),
checksum_bad = !checksum_good; ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_IN_CKSUM);
if (checksum_good) {
checksum_item = proto_tree_add_uint_format(edp_tree,
hf_edp_checksum, tvb, offset, 2, packet_checksum,
"Checksum: 0x%04x [correct]",
packet_checksum);
} else {
checksum_item = proto_tree_add_uint_format(edp_tree,
hf_edp_checksum, tvb, offset, 2, packet_checksum,
"Checksum: 0x%04x [incorrect, should be 0x%04x]",
packet_checksum,
in_cksum_shouldbe(packet_checksum, computed_checksum));
}
} else { } else {
checksum_good = checksum_bad = FALSE; proto_tree_add_checksum(edp_tree, tvb, offset, hf_edp_checksum, hf_edp_checksum_status, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
checksum_item = proto_tree_add_uint(edp_tree, hf_edp_checksum,
tvb, offset, 2, packet_checksum);
} }
checksum_tree = proto_item_add_subtree(checksum_item, ett_edp_checksum);
checksum_item = proto_tree_add_boolean(checksum_tree, hf_edp_checksum_good,
tvb, offset, 2, checksum_good);
PROTO_ITEM_SET_GENERATED(checksum_item);
checksum_item = proto_tree_add_boolean(checksum_tree, hf_edp_checksum_bad,
tvb, offset, 2, checksum_bad);
PROTO_ITEM_SET_GENERATED(checksum_item);
offset += 2; offset += 2;
seqno = tvb_get_ntohs(tvb, offset); seqno = tvb_get_ntohs(tvb, offset);
@ -1114,13 +1086,9 @@ proto_register_edp(void)
{ "EDP checksum", "edp.checksum", FT_UINT16, BASE_HEX, NULL, 0x0, { "EDP checksum", "edp.checksum", FT_UINT16, BASE_HEX, NULL, 0x0,
NULL, HFILL }}, NULL, HFILL }},
{ &hf_edp_checksum_good, { &hf_edp_checksum_status,
{ "Good", "edp.checksum_good", FT_BOOLEAN, BASE_NONE, NULL, 0x0, { "EDP checksum status", "edp.checksum.status", FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0,
"True: checksum matches packet content; False: doesn't match content or not checked", HFILL }}, NULL, HFILL }},
{ &hf_edp_checksum_bad,
{ "Bad", "edp.checksum_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"True: checksum doesn't match packet content; False: matches content or not checked", HFILL }},
{ &hf_edp_seqno, { &hf_edp_seqno,
{ "Sequence number", "edp.seqno", FT_UINT16, BASE_DEC, NULL, { "Sequence number", "edp.seqno", FT_UINT16, BASE_DEC, NULL,
@ -1455,7 +1423,6 @@ proto_register_edp(void)
static gint *ett[] = { static gint *ett[] = {
&ett_edp, &ett_edp,
&ett_edp_checksum,
&ett_edp_tlv_header, &ett_edp_tlv_header,
&ett_edp_vlan_flags, &ett_edp_vlan_flags,
&ett_edp_display, &ett_edp_display,

46
epan/dissectors/packet-fc.c
View File

@ -1270,37 +1270,28 @@ dissect_fc_ifcp (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data
static int static int
dissect_fcsof(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) { dissect_fcsof(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) {
proto_item *it = NULL; proto_item *it;
proto_tree *fcsof_tree = NULL; proto_tree *fcsof_tree;
tvbuff_t *next_tvb, *checksum_tvb; tvbuff_t *next_tvb;
guint32 sof = 0; guint32 sof;
guint32 crc = 0; guint32 crc_computed;
guint32 crc_computed = 0; guint32 eof;
guint32 eof = 0;
gint crc_offset = 0;
gint eof_offset = 0;
gint sof_offset = 0;
const gint FCSOF_TRAILER_LEN = 8; const gint FCSOF_TRAILER_LEN = 8;
const gint FCSOF_HEADER_LEN = 4; const gint FCSOF_HEADER_LEN = 4;
gint frame_len_for_checksum = 0; gint crc_offset = tvb_reported_length(tvb) - FCSOF_TRAILER_LEN;
gint eof_offset = crc_offset + 4;
gint sof_offset = 0;
gint frame_len_for_checksum;
fc_data_t fc_data; fc_data_t fc_data;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "FC"); col_set_str(pinfo->cinfo, COL_PROTOCOL, "FC");
crc_offset = tvb_reported_length(tvb) - FCSOF_TRAILER_LEN;
eof_offset = crc_offset + 4;
sof_offset = 0;
/* Get SOF */ /* Get SOF */
sof = tvb_get_ntohl(tvb, 0); sof = tvb_get_ntohl(tvb, 0);
/* GET CRC */
crc = tvb_get_ntohl(tvb, crc_offset);
/* GET Computed CRC */ /* GET Computed CRC */
frame_len_for_checksum = crc_offset - FCSOF_HEADER_LEN; frame_len_for_checksum = crc_offset - FCSOF_HEADER_LEN;
checksum_tvb = tvb_new_subset_length(tvb, 4, frame_len_for_checksum); crc_computed = crc32_802_tvb(tvb_new_subset_length(tvb, 4, frame_len_for_checksum), frame_len_for_checksum);
crc_computed = crc32_802_tvb(checksum_tvb, frame_len_for_checksum);
/* Get EOF */ /* Get EOF */
eof = tvb_get_ntohl(tvb, eof_offset); eof = tvb_get_ntohl(tvb, eof_offset);
@ -1314,20 +1305,7 @@ dissect_fcsof(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U
proto_tree_add_uint(fcsof_tree, hf_fcsof, tvb, sof_offset, 4, sof); proto_tree_add_uint(fcsof_tree, hf_fcsof, tvb, sof_offset, 4, sof);
if (crc == crc_computed) { proto_tree_add_checksum(fcsof_tree, tvb, crc_offset, hf_fccrc, -1, &ei_fccrc, pinfo, crc_computed, ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
proto_tree_add_uint_format_value(fcsof_tree, hf_fccrc, tvb,
crc_offset, 4, crc,
"%8.8x [valid]", crc);
} else {
it = proto_tree_add_uint_format_value(fcsof_tree, hf_fccrc, tvb,
crc_offset, 4, crc,
"%8.8x [error: should be %8.8x]",
crc, crc_computed);
expert_add_info_format(pinfo, it, &ei_fccrc,
"Bad FC CRC %8.8x %8.x",
crc, crc_computed);
}
proto_tree_add_uint(fcsof_tree, hf_fceof, tvb, eof_offset, 4, eof); proto_tree_add_uint(fcsof_tree, hf_fceof, tvb, eof_offset, 4, eof);

42
epan/dissectors/packet-fcoe.c
View File

@ -95,11 +95,9 @@ static int hf_fcoe_len = -1;
static int hf_fcoe_sof = -1; static int hf_fcoe_sof = -1;
static int hf_fcoe_eof = -1; static int hf_fcoe_eof = -1;
static int hf_fcoe_crc = -1; static int hf_fcoe_crc = -1;
static int hf_fcoe_crc_bad = -1; static int hf_fcoe_crc_status = -1;
static int hf_fcoe_crc_good = -1;
static int ett_fcoe = -1; static int ett_fcoe = -1;
static int ett_fcoe_crc = -1;
static expert_field ei_fcoe_crc = EI_INIT; static expert_field ei_fcoe_crc = EI_INIT;
@ -122,9 +120,7 @@ dissect_fcoe(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_
const char *crc_msg; const char *crc_msg;
const char *len_msg; const char *len_msg;
proto_item *ti; proto_item *ti;
proto_item *item;
proto_tree *fcoe_tree; proto_tree *fcoe_tree;
proto_tree *crc_tree;
tvbuff_t *next_tvb; tvbuff_t *next_tvb;
gboolean crc_exists; gboolean crc_exists;
guint32 crc_computed = 0; guint32 crc_computed = 0;
@ -213,34 +209,12 @@ dissect_fcoe(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_
* Create the CRC information. * Create the CRC information.
*/ */
if (crc_exists) { if (crc_exists) {
if (crc == crc_computed) { proto_tree_add_checksum(fcoe_tree, tvb, crc_offset, hf_fcoe_crc, hf_fcoe_crc_status, &ei_fcoe_crc, pinfo, crc_computed, ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
item = proto_tree_add_uint_format_value(fcoe_tree, hf_fcoe_crc, tvb,
crc_offset, 4, crc,
"%8.8x [valid]", crc);
} else {
item = proto_tree_add_uint_format_value(fcoe_tree, hf_fcoe_crc, tvb,
crc_offset, 4, crc,
"%8.8x [error: should be %8.8x]",
crc, crc_computed);
expert_add_info_format(pinfo, item, &ei_fcoe_crc,
"Bad FC CRC %8.8x %8.x",
crc, crc_computed);
}
proto_tree_set_appendix(fcoe_tree, tvb, crc_offset, proto_tree_set_appendix(fcoe_tree, tvb, crc_offset,
tvb_captured_length_remaining (tvb, crc_offset)); tvb_captured_length_remaining (tvb, crc_offset));
} else { } else {
item = proto_tree_add_uint_format_value(fcoe_tree, hf_fcoe_crc, tvb, crc_offset, 0, proto_tree_add_checksum(fcoe_tree, tvb, crc_offset, hf_fcoe_crc, hf_fcoe_crc_status, &ei_fcoe_crc, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NOT_PRESENT);
0, "CRC: [missing]");
} }
crc_tree = proto_item_add_subtree(item, ett_fcoe_crc);
ti = proto_tree_add_boolean(crc_tree, hf_fcoe_crc_bad, tvb,
crc_offset, 4,
crc_exists && crc != crc_computed);
PROTO_ITEM_SET_GENERATED(ti);
ti = proto_tree_add_boolean(crc_tree, hf_fcoe_crc_good, tvb,
crc_offset, 4,
crc_exists && crc == crc_computed);
PROTO_ITEM_SET_GENERATED(ti);
/* /*
* Interpret the EOF. * Interpret the EOF.
@ -294,16 +268,12 @@ proto_register_fcoe(void)
BASE_DEC, NULL, 0, NULL, HFILL}}, BASE_DEC, NULL, 0, NULL, HFILL}},
{ &hf_fcoe_crc, { &hf_fcoe_crc,
{"CRC", "fcoe.crc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL}}, {"CRC", "fcoe.crc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL}},
{ &hf_fcoe_crc_good, { &hf_fcoe_crc_status,
{"CRC good", "fcoe.crc_good", FT_BOOLEAN, BASE_NONE, NULL, 0x0, {"CRC Status", "fcoe.crc.status", FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0,
"True: CRC matches packet content; False: doesn't match or not checked.", HFILL }}, NULL, HFILL }}
{ &hf_fcoe_crc_bad,
{"CRC bad", "fcoe.crc_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"True: CRC doesn't match packet content; False: matches or not checked.", HFILL }}
}; };
static gint *ett[] = { static gint *ett[] = {
&ett_fcoe, &ett_fcoe,
&ett_fcoe_crc
}; };
static ei_register_info ei[] = { static ei_register_info ei[] = {

42
epan/dissectors/packet-fcoib.c
View File

@ -96,11 +96,9 @@ static int hf_fcoib_sig = -1;
static int hf_fcoib_sof = -1; static int hf_fcoib_sof = -1;
static int hf_fcoib_eof = -1; static int hf_fcoib_eof = -1;
static int hf_fcoib_crc = -1; static int hf_fcoib_crc = -1;
static int hf_fcoib_crc_bad = -1; static int hf_fcoib_crc_status = -1;
static int hf_fcoib_crc_good = -1;
static int ett_fcoib = -1; static int ett_fcoib = -1;
static int ett_fcoib_crc = -1;
static expert_field ei_fcoib_crc = EI_INIT; static expert_field ei_fcoib_crc = EI_INIT;
@ -161,9 +159,7 @@ dissect_fcoib(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U
const char *crc_msg; const char *crc_msg;
const char *len_msg; const char *len_msg;
proto_item *ti; proto_item *ti;
proto_item *item;
proto_tree *fcoib_tree; proto_tree *fcoib_tree;
proto_tree *crc_tree;
tvbuff_t *next_tvb; tvbuff_t *next_tvb;
gboolean crc_exists; gboolean crc_exists;
guint32 crc_computed = 0; guint32 crc_computed = 0;
@ -268,34 +264,12 @@ dissect_fcoib(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U
* Create the CRC information. * Create the CRC information.
*/ */
if (crc_exists) { if (crc_exists) {
if (crc == crc_computed) { proto_tree_add_checksum(fcoib_tree, tvb, crc_offset, hf_fcoib_crc, hf_fcoib_crc_status, &ei_fcoib_crc, pinfo, crc_computed, ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
item = proto_tree_add_uint_format_value(fcoib_tree, hf_fcoib_crc, tvb,
crc_offset, 4, crc,
"%8.8x [valid]", crc);
} else {
item = proto_tree_add_uint_format_value(fcoib_tree, hf_fcoib_crc, tvb,
crc_offset, 4, crc,
"%8.8x [error: should be %8.8x]",
crc, crc_computed);
expert_add_info_format(pinfo, item, &ei_fcoib_crc,
"Bad FC CRC %8.8x %8.x",
crc, crc_computed);
}
proto_tree_set_appendix(fcoib_tree, tvb, crc_offset, proto_tree_set_appendix(fcoib_tree, tvb, crc_offset,
tvb_captured_length_remaining (tvb, crc_offset)); tvb_captured_length_remaining (tvb, crc_offset));
} else { } else {
item = proto_tree_add_uint_format_value(fcoib_tree, hf_fcoib_crc, tvb, crc_offset, 0, proto_tree_add_checksum(fcoib_tree, tvb, crc_offset, hf_fcoib_crc, hf_fcoib_crc_status, &ei_fcoib_crc, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NOT_PRESENT);
0, "CRC: [missing]");
} }
crc_tree = proto_item_add_subtree(item, ett_fcoib_crc);
ti = proto_tree_add_boolean(crc_tree, hf_fcoib_crc_bad, tvb,
crc_offset, 4,
crc_exists && crc != crc_computed);
PROTO_ITEM_SET_GENERATED(ti);
ti = proto_tree_add_boolean(crc_tree, hf_fcoib_crc_good, tvb,
crc_offset, 4,
crc_exists && crc == crc_computed);
PROTO_ITEM_SET_GENERATED(ti);
/* /*
* Interpret the EOF. * Interpret the EOF.
@ -349,16 +323,12 @@ proto_register_fcoib(void)
{"Version", "fcoib.ver", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, {"Version", "fcoib.ver", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}},
{ &hf_fcoib_crc, { &hf_fcoib_crc,
{"CRC", "fcoib.crc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL}}, {"CRC", "fcoib.crc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL}},
{ &hf_fcoib_crc_good, { &hf_fcoib_crc_status,
{"CRC good", "fcoib.crc_good", FT_BOOLEAN, BASE_NONE, NULL, 0x0, {"CRC Status", "fcoib.crc.status", FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0,
"True: CRC matches packet content; False: doesn't match or not checked.", HFILL }}, NULL, HFILL }},
{ &hf_fcoib_crc_bad,
{"CRC bad", "fcoib.crc_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"True: CRC doesn't match packet content; False: matches or not checked.", HFILL }}
}; };
static gint *ett[] = { static gint *ett[] = {
&ett_fcoib, &ett_fcoib,
&ett_fcoib_crc
}; };
static ei_register_info ei[] = { static ei_register_info ei[] = {

2
epan/dissectors/packet-fcswils.c
View File

@ -1015,7 +1015,7 @@ dissect_swils_fspf_lsrechdr(tvbuff_t *tvb, proto_tree *tree, int offset)
proto_tree_add_item(tree, hf_swils_lsrh_lsid, tvb, offset+11, 1, ENC_BIG_ENDIAN); proto_tree_add_item(tree, hf_swils_lsrh_lsid, tvb, offset+11, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(tree, hf_swils_lsrh_adv_domid, tvb, offset+15, 1, ENC_BIG_ENDIAN); proto_tree_add_item(tree, hf_swils_lsrh_adv_domid, tvb, offset+15, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(tree, hf_swils_lsrh_ls_incid, tvb, offset+16, 4, ENC_BIG_ENDIAN); proto_tree_add_item(tree, hf_swils_lsrh_ls_incid, tvb, offset+16, 4, ENC_BIG_ENDIAN);
proto_tree_add_item(tree, hf_swils_lsrh_checksum, tvb, offset+20, 2, ENC_BIG_ENDIAN); proto_tree_add_checksum(tree, tvb, offset+20, hf_swils_lsrh_checksum, -1, NULL, NULL, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
proto_tree_add_item(tree, hf_swils_lsrh_lsr_length, tvb, offset+22, 2, ENC_BIG_ENDIAN); proto_tree_add_item(tree, hf_swils_lsrh_lsr_length, tvb, offset+22, 2, ENC_BIG_ENDIAN);
} }

39
epan/dissectors/packet-fefd.c
View File

@ -94,31 +94,30 @@ dissect_fefd(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_
guint16 length; guint16 length;
proto_tree *tlv_tree; proto_tree *tlv_tree;
int real_length; int real_length;
static const int * flags[] = {
&hf_fefd_flags_rt,
&hf_fefd_flags_rsy,
NULL
};
static const int * headers[] = {
&hf_fefd_version,
&hf_fefd_opcode,
NULL
};
col_set_str(pinfo->cinfo, COL_PROTOCOL, "FEFD"); col_set_str(pinfo->cinfo, COL_PROTOCOL, "FEFD");
col_clear(pinfo->cinfo, COL_INFO); col_clear(pinfo->cinfo, COL_INFO);
if (tree) { ti = proto_tree_add_item(tree, proto_fefd, tvb, offset, -1, ENC_NA);
proto_item *flags_ti; fefd_tree = proto_item_add_subtree(ti, ett_fefd);
proto_tree *flags_tree;
ti = proto_tree_add_item(tree, proto_fefd, tvb, offset, -1, ENC_NA); /* FEFD header */
fefd_tree = proto_item_add_subtree(ti, ett_fefd); proto_tree_add_bitmask_list(fefd_tree, tvb, offset, 1, headers, ENC_BIG_ENDIAN);
offset += 1;
/* FEFD header */ proto_tree_add_bitmask(fefd_tree, tvb, offset, hf_fefd_flags, ett_fefd_flags, flags, ENC_BIG_ENDIAN);
proto_tree_add_item(fefd_tree, hf_fefd_version, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1;
proto_tree_add_item(fefd_tree, hf_fefd_opcode, tvb, offset, 1, ENC_BIG_ENDIAN); proto_tree_add_checksum(fefd_tree, tvb, offset, hf_fefd_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
offset += 1; offset += 2;
flags_ti = proto_tree_add_item(fefd_tree, hf_fefd_flags, tvb, offset, 1, ENC_BIG_ENDIAN);
flags_tree = proto_item_add_subtree(flags_ti, ett_fefd_flags);
proto_tree_add_item(flags_tree, hf_fefd_flags_rt, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(flags_tree, hf_fefd_flags_rsy, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
proto_tree_add_item(fefd_tree, hf_fefd_checksum, tvb, offset, 2, ENC_BIG_ENDIAN);
offset += 2;
} else {
offset += 4; /* The version/opcode/flags/checksum fields from above */
}
while (tvb_reported_length_remaining(tvb, offset) != 0) { while (tvb_reported_length_remaining(tvb, offset) != 0) {
type = tvb_get_ntohs(tvb, offset + TLV_TYPE); type = tvb_get_ntohs(tvb, offset + TLV_TYPE);

2
epan/dissectors/packet-foundry.c
View File

@ -284,7 +284,7 @@ dissect_fdp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
offset += 1; offset += 1;
proto_tree_add_item(fdp_tree, hf_fdp_holdtime, tvb, offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(fdp_tree, hf_fdp_holdtime, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1; offset += 1;
proto_tree_add_item(fdp_tree, hf_fdp_checksum, tvb, offset, 2, ENC_BIG_ENDIAN); proto_tree_add_checksum(fdp_tree, tvb, offset, hf_fdp_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
offset += 2; offset += 2;
/* Decode the individual TLVs */ /* Decode the individual TLVs */

3
epan/dissectors/packet-gdb.c
View File

@ -104,8 +104,7 @@ dissect_gdb_token(void *tvbparse_data, const void *wanted_data, tvbparse_elem_t
case GDB_TOK_CHKSUM: case GDB_TOK_CHKSUM:
/* the spec is not really explicit but it seems that the /* the spec is not really explicit but it seems that the
checksum is big endian */ checksum is big endian */
proto_tree_add_item(tree, hf_gdb_chksum, proto_tree_add_checksum(tree, tok->tvb, tok->offset, hf_gdb_chksum, -1, NULL, NULL, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
tok->tvb, tok->offset, tok->len, ENC_BIG_ENDIAN);
break; break;
default: default:
break; break;

76
epan/dissectors/packet-gfp.c
View File

@ -53,8 +53,7 @@ void proto_register_gfp(void);
static int proto_gfp = -1; static int proto_gfp = -1;
static int hf_gfp_pli = -1; static int hf_gfp_pli = -1;
static int hf_gfp_chec = -1; static int hf_gfp_chec = -1;
static int hf_gfp_chec_good = -1; static int hf_gfp_chec_status = -1;
static int hf_gfp_chec_bad = -1;
static int hf_gfp_type = -1; static int hf_gfp_type = -1;
static int hf_gfp_pti = -1; static int hf_gfp_pti = -1;
static int hf_gfp_pfi = -1; static int hf_gfp_pfi = -1;
@ -62,12 +61,10 @@ static int hf_gfp_exi = -1;
static int hf_gfp_upi_data = -1; static int hf_gfp_upi_data = -1;
static int hf_gfp_upi_management = -1; static int hf_gfp_upi_management = -1;
static int hf_gfp_thec = -1; static int hf_gfp_thec = -1;
static int hf_gfp_thec_good = -1; static int hf_gfp_thec_status = -1;
static int hf_gfp_thec_bad = -1;
static int hf_gfp_cid = -1; static int hf_gfp_cid = -1;
static int hf_gfp_ehec = -1; static int hf_gfp_ehec = -1;
static int hf_gfp_ehec_good = -1; static int hf_gfp_ehec_status = -1;
static int hf_gfp_ehec_bad = -1;
static int hf_gfp_fcs = -1; static int hf_gfp_fcs = -1;
static int hf_gfp_fcs_good = -1; static int hf_gfp_fcs_good = -1;
static int hf_gfp_fcs_bad = -1; static int hf_gfp_fcs_bad = -1;
@ -93,10 +90,7 @@ static expert_field ei_gfp_fcs_bad = EI_INIT;
/* Initialize the subtree pointers */ /* Initialize the subtree pointers */
static gint ett_gfp = -1; static gint ett_gfp = -1;
static gint ett_gfp_chec = -1;
static gint ett_gfp_type = -1; static gint ett_gfp_type = -1;
static gint ett_gfp_thec = -1;
static gint ett_gfp_ehec = -1;
static gint ett_gfp_fcs = -1; static gint ett_gfp_fcs = -1;
static dissector_table_t gfp_dissector_table; static dissector_table_t gfp_dissector_table;
@ -205,34 +199,15 @@ static gpointer gfp_value(packet_info *pinfo)
/* GFP has several identical 16 bit CRCs in its header (HECs). Note that /* GFP has several identical 16 bit CRCs in its header (HECs). Note that
* this function increases the offset. */ * this function increases the offset. */
static void static void
gfp_add_hec_tree(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint *offset, const guint len, const int field, const int field_good, const int field_bad, const gint ett, expert_field *ei_bad) gfp_add_hec_tree(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint *offset, const guint len, const int field, const int field_status, expert_field *ei_bad)
{ {
proto_item* ti = NULL; guint hec_calc;
proto_tree* hec_tree = NULL;
guint hec, hec_calc;
hec_calc = crc16_r3_ccitt_tvb(tvb, *offset, len); hec_calc = crc16_r3_ccitt_tvb(tvb, *offset, len);
*offset += len; *offset += len;
hec = tvb_get_ntohs(tvb, *offset);
if ( hec == hec_calc ) {
ti = proto_tree_add_uint_format_value(tree, field, tvb, *offset, 2, hec, "0x%04x [correct]", hec);
hec_tree = proto_item_add_subtree(ti, ett);
ti = proto_tree_add_boolean(hec_tree, field_good, tvb, *offset, 2, TRUE);
PROTO_ITEM_SET_GENERATED(ti);
ti = proto_tree_add_boolean(hec_tree, field_bad, tvb, *offset, 2, FALSE);
PROTO_ITEM_SET_GENERATED(ti);
} else {
ti = proto_tree_add_uint_format_value(tree, field, tvb, *offset, 2, hec, "0x%04x [incorrect, should be 0x%04x]", hec, hec_calc);
hec_tree = proto_item_add_subtree(ti, ett);
ti = proto_tree_add_boolean(hec_tree, field_good, tvb, *offset, 2, FALSE);
PROTO_ITEM_SET_GENERATED(ti);
ti = proto_tree_add_boolean(hec_tree, field_bad, tvb, *offset, 2, TRUE);
PROTO_ITEM_SET_GENERATED(ti);
expert_add_info(pinfo, ti, ei_bad);
}
proto_tree_add_checksum(tree, tvb, *offset, field, field_status, ei_bad, pinfo, hec_calc, ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
*offset += 2; *offset += 2;
} }
@ -283,7 +258,7 @@ dissect_gfp_payload(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, proto_t
} }
/* G.7041 6.1.2.1.2 Type HEC (tHEC) - mandatory 2 bytes */ /* G.7041 6.1.2.1.2 Type HEC (tHEC) - mandatory 2 bytes */
gfp_add_hec_tree(tvb, pinfo, gfp_tree, offset, 2, hf_gfp_thec, hf_gfp_thec_good, hf_gfp_thec_bad, ett_gfp_thec, &ei_gfp_thec_bad); gfp_add_hec_tree(tvb, pinfo, gfp_tree, offset, 2, hf_gfp_thec, hf_gfp_thec_status, &ei_gfp_thec_bad);
switch (exi) { switch (exi) {
case GFP_EXT_NULL: case GFP_EXT_NULL:
@ -303,7 +278,7 @@ dissect_gfp_payload(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, proto_t
/* Next byte spare field, reserved */ /* Next byte spare field, reserved */
/* 6.1.2.1.4 Extension HEC field */ /* 6.1.2.1.4 Extension HEC field */
gfp_add_hec_tree(tvb, pinfo, gfp_tree, offset, 2, hf_gfp_ehec, hf_gfp_ehec_good, hf_gfp_ehec_bad, ett_gfp_ehec, &ei_gfp_ehec_bad); gfp_add_hec_tree(tvb, pinfo, gfp_tree, offset, 2, hf_gfp_ehec, hf_gfp_ehec_status, &ei_gfp_ehec_bad);
break; break;
case GFP_EXT_RING: case GFP_EXT_RING:
/* 6.1.2.1.3.3 Extension header for a ring frame */ /* 6.1.2.1.3.3 Extension header for a ring frame */
@ -429,7 +404,7 @@ dissect_gfp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
col_set_str(pinfo->cinfo, COL_INFO, rval_to_str_const(pli, gfp_pli_rvals, "Unknown")); col_set_str(pinfo->cinfo, COL_INFO, rval_to_str_const(pli, gfp_pli_rvals, "Unknown"));
/* 6.1.1.2 Core HEC field */ /* 6.1.1.2 Core HEC field */
gfp_add_hec_tree(tvb, pinfo, gfp_tree, &offset, len, hf_gfp_chec, hf_gfp_chec_good, hf_gfp_chec_bad, ett_gfp_chec, &ei_gfp_chec_bad); gfp_add_hec_tree(tvb, pinfo, gfp_tree, &offset, len, hf_gfp_chec, hf_gfp_chec_status, &ei_gfp_chec_bad);
if (pli == 0) { /* 6.2.1 GFP idle frames */ if (pli == 0) { /* 6.2.1 GFP idle frames */
if (tvb_reported_length_remaining(tvb, offset)) { if (tvb_reported_length_remaining(tvb, offset)) {
@ -465,13 +440,9 @@ proto_register_gfp(void)
{ "Core HEC", "gfp.chec", FT_UINT16, BASE_HEX, { "Core HEC", "gfp.chec", FT_UINT16, BASE_HEX,
NULL, 0x0, NULL, HFILL } NULL, 0x0, NULL, HFILL }
}, },
{ &hf_gfp_chec_good, { &hf_gfp_chec_status,
{ "Good cHEC", "gfp.chec_good", FT_BOOLEAN, BASE_NONE, NULL, 0x0, { "cHEC Status", "gfp.chec.status", FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0,
"True: cHEC matches core header; False: doesn't match", HFILL } NULL, HFILL }
},
{ &hf_gfp_chec_bad,
{ "Bad cHEC", "gfp.chec_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"True: cHEC doesn't match core header; False: matches", HFILL }
}, },
{ &hf_gfp_type, { &hf_gfp_type,
{ "Type Field", "gfp.type", FT_UINT16, BASE_HEX, NULL, 0x0, { "Type Field", "gfp.type", FT_UINT16, BASE_HEX, NULL, 0x0,
@ -503,13 +474,9 @@ proto_register_gfp(void)
{ "Type HEC", "gfp.thec", FT_UINT16, BASE_HEX, NULL, 0x0, { "Type HEC", "gfp.thec", FT_UINT16, BASE_HEX, NULL, 0x0,
NULL, HFILL } NULL, HFILL }
}, },
{ &hf_gfp_thec_good, { &hf_gfp_thec_status,
{ "Good tHEC", "gfp.thec_good", FT_BOOLEAN, BASE_NONE, NULL, 0x0, { "tHEC Status", "gfp.thec.status", FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0,
"True: tHEC matches type header; False: doesn't match", HFILL } NULL, HFILL }
},
{ &hf_gfp_thec_bad,
{ "Bad tHEC", "gfp.thec_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"True: tHEC doesn't match type header; False: matches", HFILL }
}, },
{ &hf_gfp_cid, { &hf_gfp_cid,
{ "Channel ID", "gfp.cid", FT_UINT8, BASE_HEX, NULL, 0x0, { "Channel ID", "gfp.cid", FT_UINT8, BASE_HEX, NULL, 0x0,
@ -519,13 +486,9 @@ proto_register_gfp(void)
{ "Extension HEC", "gfp.ehec", FT_UINT16, BASE_HEX, NULL, 0x0, { "Extension HEC", "gfp.ehec", FT_UINT16, BASE_HEX, NULL, 0x0,
NULL, HFILL } NULL, HFILL }
}, },
{ &hf_gfp_ehec_good, { &hf_gfp_ehec_status,
{ "Good eHEC", "gfp.ehec_good", FT_BOOLEAN, BASE_NONE, NULL, 0x0, { "eHEC Status", "gfp.ehec.status", FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0,
"True: eHEC matches extension header; False: doesn't match", HFILL } NULL, HFILL }
},
{ &hf_gfp_ehec_bad,
{ "Bad eHEC", "gfp.ehec_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"True: eHEC doesn't match extension header; False: matches", HFILL }
}, },
{ &hf_gfp_fcs, { &hf_gfp_fcs,
{ "Payload FCS", "gfp.fcs", FT_UINT32, BASE_HEX, NULL, 0x0, { "Payload FCS", "gfp.fcs", FT_UINT32, BASE_HEX, NULL, 0x0,
@ -544,10 +507,7 @@ proto_register_gfp(void)
/* Setup protocol subtree array */ /* Setup protocol subtree array */
static gint *ett[] = { static gint *ett[] = {
&ett_gfp, &ett_gfp,
&ett_gfp_chec,
&ett_gfp_type, &ett_gfp_type,
&ett_gfp_thec,
&ett_gfp_ehec,
&ett_gfp_fcs &ett_gfp_fcs
}; };

18
epan/dissectors/packet-gre.c
View File

@ -410,29 +410,21 @@ dissect_gre(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
if (flags_and_ver & GRE_CHECKSUM || flags_and_ver & GRE_ROUTING) { if (flags_and_ver & GRE_CHECKSUM || flags_and_ver & GRE_ROUTING) {
guint length, reported_length; guint length, reported_length;
proto_item *it_checksum;
vec_t cksum_vec[1]; vec_t cksum_vec[1];
guint16 cksum, computed_cksum;
it_checksum = proto_tree_add_item(gre_tree, hf_gre_checksum, tvb, offset, 2, ENC_BIG_ENDIAN);
/* Checksum check !... */ /* Checksum check !... */
cksum = tvb_get_ntohs(tvb, offset);
length = tvb_captured_length(tvb); length = tvb_captured_length(tvb);
reported_length = tvb_reported_length(tvb); reported_length = tvb_reported_length(tvb);
/* The Checksum Present bit is set, and the packet isn't part of a /* The Checksum Present bit is set, and the packet isn't part of a
fragmented datagram and isn't truncated, so we can checksum it. */ fragmented datagram and isn't truncated, so we can checksum it. */
if ((flags_and_ver & GRE_CHECKSUM) && !pinfo->fragmented && length >= reported_length) { if ((flags_and_ver & GRE_CHECKSUM) && !pinfo->fragmented && length >= reported_length) {
SET_CKSUM_VEC_TVB(cksum_vec[0], tvb, 0, reported_length); SET_CKSUM_VEC_TVB(cksum_vec[0], tvb, 0, reported_length);
computed_cksum = in_cksum(cksum_vec, 1); proto_tree_add_checksum(gre_tree, tvb, offset, hf_gre_checksum, -1, &ei_gre_checksum_incorrect, pinfo, in_cksum(cksum_vec, 1),
if (computed_cksum == 0) { ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_IN_CKSUM);
proto_item_append_text(it_checksum," [correct]"); } else {
} else { proto_tree_add_checksum(gre_tree, tvb, offset, hf_gre_checksum, -1, &ei_gre_checksum_incorrect, pinfo, 0,
proto_item_append_text(it_checksum," [incorrect, should be 0x%04x]",in_cksum_shouldbe(cksum, computed_cksum)); ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
expert_add_info(pinfo, it_checksum, &ei_gre_checksum_incorrect);
}
} }
offset += 2; offset += 2;
proto_tree_add_item(gre_tree, hf_gre_offset, tvb, offset, 2, ENC_BIG_ENDIAN); proto_tree_add_item(gre_tree, hf_gre_offset, tvb, offset, 2, ENC_BIG_ENDIAN);

16
epan/dissectors/packet-h223.c
View File

@ -95,7 +95,7 @@ static int hf_h223_al2_sequenced = -1;
static int hf_h223_al2_unsequenced = -1; static int hf_h223_al2_unsequenced = -1;
static int hf_h223_al2_seqno = -1; static int hf_h223_al2_seqno = -1;
static int hf_h223_al2_crc = -1; static int hf_h223_al2_crc = -1;
static int hf_h223_al2_crc_bad = -1; static int hf_h223_al2_crc_status = -1;
static int hf_h223_al_payload = -1; static int hf_h223_al_payload = -1;
@ -697,15 +697,9 @@ dissect_mux_al_pdu( tvbuff_t *tvb, packet_info *pinfo, proto_tree *vc_tree,
calc_checksum = h223_al2_crc8bit(tvb); calc_checksum = h223_al2_crc8bit(tvb);
real_checksum = tvb_get_guint8(tvb, len - 1); real_checksum = tvb_get_guint8(tvb, len - 1);
if( calc_checksum == real_checksum ) { proto_tree_add_checksum(al_tree, tvb, len - 1, hf_h223_al2_crc, hf_h223_al2_crc_status, NULL, pinfo, calc_checksum, ENC_NA, PROTO_CHECKSUM_VERIFY);
proto_tree_add_uint_format_value(al_tree, hf_h223_al2_crc, tvb, len - 1, 1, real_checksum,
"0x%02x (correct)", real_checksum );
} else {
proto_tree_add_uint_format_value(al_tree, hf_h223_al2_crc, tvb, len - 1, 1, real_checksum,
"0x%02x (incorrect, should be 0x%02x)", real_checksum, calc_checksum );
tmp_item = proto_tree_add_boolean( al_tree, hf_h223_al2_crc_bad, tvb, len - 1, 1, TRUE );
PROTO_ITEM_SET_GENERATED(tmp_item);
if( calc_checksum != real_checksum ) {
/* don't pass pdus which fail checksums on to the subdissector */ /* don't pass pdus which fail checksums on to the subdissector */
subdissector = data_handle; subdissector = data_handle;
} }
@ -1610,8 +1604,8 @@ void proto_register_h223 (void)
{ "CRC", "h223.al2.crc", FT_UINT8, BASE_HEX, NULL, 0x0, { "CRC", "h223.al2.crc", FT_UINT8, BASE_HEX, NULL, 0x0,
NULL, HFILL }}, NULL, HFILL }},
{ &hf_h223_al2_crc_bad, { &hf_h223_al2_crc_status,
{ "Bad CRC","h223.al2.crc_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0, { "CRC Status","h223.al2.crc.status", FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0,
NULL, HFILL }}, NULL, HFILL }},
{ &hf_h223_al_payload, { &hf_h223_al_payload,

2
epan/dissectors/packet-hartip.c
View File

@ -788,7 +788,7 @@ dissect_pass_through(proto_tree *body_tree, tvbuff_t *tvb, gint offset,
length = 1; length = 1;
} }
if (length > 0) { if (length > 0) {
proto_tree_add_item(body_tree, hf_hartip_pt_checksum, tvb, offset, 1, ENC_BIG_ENDIAN); proto_tree_add_checksum(body_tree, tvb, offset, hf_hartip_pt_checksum, -1, NULL, NULL, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
} }
return bodylen; return bodylen;

32
epan/dissectors/packet-hip.c
View File

@ -421,7 +421,7 @@ dissect_hip_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolean
proto_tree *hip_tree, *hip_tlv_tree=NULL; proto_tree *hip_tree, *hip_tlv_tree=NULL;
proto_item *ti, *ti_tlv; proto_item *ti, *ti_tlv;
int length, offset = 0, newoffset = 0; int length, offset = 0, newoffset = 0;
guint16 control_h, checksum_h, computed_checksum; guint16 control_h, checksum_h;
guint16 tlv_type_h, tlv_length_h; /* For storing in host order */ guint16 tlv_type_h, tlv_length_h; /* For storing in host order */
guint len; guint len;
guint reported_len; guint reported_len;
@ -510,32 +510,16 @@ dissect_hip_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolean
} }
/* pointer to the HIP header (packet data) */ /* pointer to the HIP header (packet data) */
SET_CKSUM_VEC_TVB(cksum_vec[3], tvb, 0, reported_len); SET_CKSUM_VEC_TVB(cksum_vec[3], tvb, 0, reported_len);
computed_checksum = in_cksum(cksum_vec, 4); if (checksum_h == 0 && udp) {
if (computed_checksum == 0) { proto_tree_add_checksum(hip_tree, tvb, offset+4, hf_hip_checksum, -1, NULL, pinfo, 0,
proto_tree_add_uint_format_value(hip_tree, hf_hip_checksum, tvb, ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
offset+4, 2, checksum_h,
"0x%04x (correct)",
checksum_h);
} else { } else {
if (checksum_h == 0 && udp) { proto_tree_add_checksum(hip_tree, tvb, offset+4, hf_hip_checksum, -1, NULL, pinfo, in_cksum(cksum_vec, 4),
proto_tree_add_uint_format_value(hip_tree, hf_hip_checksum, tvb, ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_IN_CKSUM);
offset+4, 2, checksum_h,
"0x%04x (correct)",
checksum_h);
} else {
proto_tree_add_uint_format_value(hip_tree, hf_hip_checksum, tvb,
offset+4, 2, checksum_h,
"0x%04x (incorrect, should be 0x%04x)",
checksum_h,
in_cksum_shouldbe(checksum_h,
computed_checksum));
}
} }
} else { } else {
proto_tree_add_uint_format_value(hip_tree, hf_hip_checksum, tvb, proto_tree_add_checksum(hip_tree, tvb, offset+4, hf_hip_checksum, -1, NULL, pinfo, 0,
offset+4, 2, checksum_h, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
"0x%04x (unverified)",
checksum_h);
} }
ti = proto_tree_add_item(hip_tree, hf_hip_controls, tvb, offset+6, 2, ENC_BIG_ENDIAN); ti = proto_tree_add_item(hip_tree, hf_hip_controls, tvb, offset+6, 2, ENC_BIG_ENDIAN);

8
epan/dissectors/packet-homeplug-av.c
View File

@ -3674,19 +3674,19 @@ proto_register_homeplug_av(void)
}, },
{ &hf_homeplug_av_st_mac_req_img_load, { &hf_homeplug_av_st_mac_req_img_load,
{ "Image Load Starting Address", "homeplug_av.st_mac_req.img_load", { "Image Load Starting Address", "homeplug_av.st_mac_req.img_load",
FT_UINT32, BASE_HEX, NULL, 0x00, "Unknown", HFILL } FT_UINT32, BASE_HEX, NULL, 0x00, NULL, HFILL }
}, },
{ &hf_homeplug_av_st_mac_req_img_len, { &hf_homeplug_av_st_mac_req_img_len,
{ "Image Length", "homeplug_av.st_mac_req.img_len", { "Image Length", "homeplug_av.st_mac_req.img_len",
FT_UINT32, BASE_HEX, NULL, 0x00, "Unknown", HFILL } FT_UINT32, BASE_HEX, NULL, 0x00, NULL, HFILL }
}, },
{ &hf_homeplug_av_st_mac_req_img_chksum, { &hf_homeplug_av_st_mac_req_img_chksum,
{ "Image Checksum", "homeplug_av.st_mac_req.img_chksum", { "Image Checksum", "homeplug_av.st_mac_req.img_chksum",
FT_UINT32, BASE_HEX, NULL, 0x00, "Unknown", HFILL } FT_UINT32, BASE_HEX, NULL, 0x00, NULL, HFILL }
}, },
{ &hf_homeplug_av_st_mac_req_img_start, { &hf_homeplug_av_st_mac_req_img_start,
{ "Image Starting Address", "homeplug_av.st_mac_req.img_start", { "Image Starting Address", "homeplug_av.st_mac_req.img_start",
FT_UINT32, BASE_HEX, NULL, 0x00, "Unknown", HFILL } FT_UINT32, BASE_HEX, NULL, 0x00, NULL, HFILL }
}, },
/* Start MAC Confirmation */ /* Start MAC Confirmation */
{ &hf_homeplug_av_st_mac_cnf, { &hf_homeplug_av_st_mac_cnf,

68
epan/dissectors/packet-icmp.c
View File

@ -80,7 +80,7 @@ int proto_icmp = -1;
static int hf_icmp_type = -1; static int hf_icmp_type = -1;
static int hf_icmp_code = -1; static int hf_icmp_code = -1;
static int hf_icmp_checksum = -1; static int hf_icmp_checksum = -1;
static int hf_icmp_checksum_bad = -1; static int hf_icmp_checksum_status = -1;
static int hf_icmp_unused = -1; static int hf_icmp_unused = -1;
static int hf_icmp_reserved = -1; static int hf_icmp_reserved = -1;
static int hf_icmp_ident = -1; static int hf_icmp_ident = -1;
@ -129,7 +129,7 @@ static int hf_icmp_ext = -1;
static int hf_icmp_ext_version = -1; static int hf_icmp_ext_version = -1;
static int hf_icmp_ext_reserved = -1; static int hf_icmp_ext_reserved = -1;
static int hf_icmp_ext_checksum = -1; static int hf_icmp_ext_checksum = -1;
static int hf_icmp_ext_checksum_bad = -1; static int hf_icmp_ext_checksum_status = -1;
static int hf_icmp_ext_length = -1; static int hf_icmp_ext_length = -1;
static int hf_icmp_ext_class = -1; static int hf_icmp_ext_class = -1;
static int hf_icmp_ext_c_type = -1; static int hf_icmp_ext_c_type = -1;
@ -760,9 +760,8 @@ dissect_extensions(tvbuff_t * tvb, gint offset, proto_tree * tree)
guint8 version; guint8 version;
guint8 class_num; guint8 class_num;
guint8 c_type; guint8 c_type;
guint16 cksum, computed_cksum;
guint16 obj_length, obj_trunc_length; guint16 obj_length, obj_trunc_length;
proto_item *ti, *tf_object, *hidden_item; proto_item *ti, *tf_object;
proto_tree *ext_tree, *ext_object_tree; proto_tree *ext_tree, *ext_object_tree;
gint obj_end_offset; gint obj_end_offset;
guint reported_length; guint reported_length;
@ -798,31 +797,8 @@ dissect_extensions(tvbuff_t * tvb, gint offset, proto_tree * tree)
tvb, offset, 2, ENC_BIG_ENDIAN); tvb, offset, 2, ENC_BIG_ENDIAN);
/* Checksum */ /* Checksum */
cksum = tvb_get_ntohs(tvb, offset + 2); proto_tree_add_checksum(ext_tree, tvb, offset + 2, hf_icmp_ext_checksum, hf_icmp_ext_checksum_status, NULL, NULL, ip_checksum_tvb(tvb, 0, reported_length),
ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_IN_CKSUM);
computed_cksum = ip_checksum_tvb(tvb, offset, reported_length);
if (computed_cksum == 0) {
proto_tree_add_uint_format_value(ext_tree, hf_icmp_ext_checksum,
tvb, offset + 2, 2, cksum,
"0x%04x [correct]",
cksum);
hidden_item =
proto_tree_add_boolean(ext_tree,
hf_icmp_ext_checksum_bad, tvb,
offset + 2, 2, FALSE);
} else {
proto_tree_add_uint_format_value(ext_tree, hf_icmp_ext_checksum,
tvb, offset + 2, 2, cksum,
"0x%04x [incorrect, should be 0x%04x]",
cksum, in_cksum_shouldbe(cksum,
computed_cksum));
hidden_item =
proto_tree_add_boolean(ext_tree,
hf_icmp_ext_checksum_bad, tvb,
offset + 2, 2, TRUE);
}
PROTO_ITEM_SET_HIDDEN(hidden_item);
if (version != 1 && version != 2) { if (version != 1 && version != 2) {
/* Unsupported version */ /* Unsupported version */
@ -1194,14 +1170,12 @@ dissect_icmp(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, void* data)
guint8 icmp_code; guint8 icmp_code;
guint8 icmp_original_dgram_length; guint8 icmp_original_dgram_length;
guint captured_length, reported_length; guint captured_length, reported_length;
guint16 cksum, computed_cksum;
const gchar *type_str, *code_str; const gchar *type_str, *code_str;
guint32 num_addrs = 0; guint32 num_addrs = 0;
guint32 addr_entry_size = 0; guint32 addr_entry_size = 0;
guint32 i; guint32 i;
gboolean save_in_error_pkt; gboolean save_in_error_pkt;
tvbuff_t *next_tvb; tvbuff_t *next_tvb;
proto_item *item;
guint32 conv_key[2]; guint32 conv_key[2];
icmp_transaction_t *trans = NULL; icmp_transaction_t *trans = NULL;
nstime_t ts, time_relative; nstime_t ts, time_relative;
@ -1213,7 +1187,6 @@ dissect_icmp(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, void* data)
/* To do: check for runts, errs, etc. */ /* To do: check for runts, errs, etc. */
icmp_type = tvb_get_guint8(tvb, 0); icmp_type = tvb_get_guint8(tvb, 0);
icmp_code = tvb_get_guint8(tvb, 1); icmp_code = tvb_get_guint8(tvb, 1);
cksum = tvb_get_ntohs(tvb, 2);
/*length of original datagram carried in the ICMP payload. In terms of 32 bit /*length of original datagram carried in the ICMP payload. In terms of 32 bit
* words.*/ * words.*/
icmp_original_dgram_length = tvb_get_guint8(tvb, 5); icmp_original_dgram_length = tvb_get_guint8(tvb, 5);
@ -1291,27 +1264,16 @@ dissect_icmp(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, void* data)
proto_item_append_text(ti, " (%s)", code_str); proto_item_append_text(ti, " (%s)", code_str);
} }
checksum_item = proto_tree_add_item(icmp_tree, hf_icmp_checksum, tvb, 2, 2, ENC_BIG_ENDIAN);
if (!pinfo->fragmented && captured_length >= reported_length if (!pinfo->fragmented && captured_length >= reported_length
&& !pinfo->flags.in_error_pkt) { && !pinfo->flags.in_error_pkt) {
/* The packet isn't part of a fragmented datagram, isn't /* The packet isn't part of a fragmented datagram, isn't
truncated, and isn't the payload of an error packet, so we can checksum truncated, and isn't the payload of an error packet, so we can checksum
it. */ it. */
proto_tree_add_checksum(icmp_tree, tvb, 2, hf_icmp_checksum, hf_icmp_checksum_status, &ei_icmp_checksum, pinfo, ip_checksum_tvb(tvb, 0, reported_length),
computed_cksum = ip_checksum_tvb(tvb, 0, reported_length); ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_IN_CKSUM);
if (computed_cksum == 0) {
item = proto_tree_add_boolean(icmp_tree, hf_icmp_checksum_bad, tvb, 2, 2, FALSE);
PROTO_ITEM_SET_HIDDEN(item);
proto_item_append_text(checksum_item, " [correct]");
} else {
item = proto_tree_add_boolean(icmp_tree, hf_icmp_checksum_bad, tvb, 2, 2, TRUE);
PROTO_ITEM_SET_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, &ei_icmp_checksum,
"ICMPv4 Checksum Incorrect, should be 0x%04x", in_cksum_shouldbe(cksum, computed_cksum));
}
} else { } else {
checksum_item = proto_tree_add_checksum(icmp_tree, tvb, 2, hf_icmp_checksum, hf_icmp_checksum_status, &ei_icmp_checksum, pinfo, 0,
ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
proto_item_append_text(checksum_item, " [%s]", proto_item_append_text(checksum_item, " [%s]",
pinfo->flags.in_error_pkt ? "in ICMP error packet" : "fragmented datagram"); pinfo->flags.in_error_pkt ? "in ICMP error packet" : "fragmented datagram");
} }
@ -1631,9 +1593,9 @@ void proto_register_icmp(void)
0x0, 0x0,
NULL, HFILL}}, NULL, HFILL}},
{&hf_icmp_checksum_bad, {&hf_icmp_checksum_status,
{"Bad Checksum", "icmp.checksum_bad", FT_BOOLEAN, {"Checksum Status", "icmp.checksum.status", FT_UINT8, BASE_NONE,
BASE_NONE, NULL, 0x0, VALS(proto_checksum_vals), 0x0,
NULL, HFILL}}, NULL, HFILL}},
{&hf_icmp_unused, {&hf_icmp_unused,
@ -1844,9 +1806,9 @@ void proto_register_icmp(void)
NULL, 0x0, NULL, 0x0,
NULL, HFILL}}, NULL, HFILL}},
{&hf_icmp_ext_checksum_bad, {&hf_icmp_ext_checksum_status,
{"Bad Checksum", "icmp.ext.checksum_bad", FT_BOOLEAN, {"Checksum Status", "icmp.ext.checksum.status", FT_UINT8, BASE_NONE,
BASE_NONE, NULL, VALS(proto_checksum_vals),
0x0, 0x0,
NULL, HFILL}}, NULL, HFILL}},

71
epan/dissectors/packet-icmpv6.c
View File

@ -97,7 +97,7 @@ static int proto_icmpv6 = -1;
static int hf_icmpv6_type = -1; static int hf_icmpv6_type = -1;
static int hf_icmpv6_code = -1; static int hf_icmpv6_code = -1;
static int hf_icmpv6_checksum = -1; static int hf_icmpv6_checksum = -1;
static int hf_icmpv6_checksum_bad = -1; static int hf_icmpv6_checksum_status = -1;
static int hf_icmpv6_reserved = -1; static int hf_icmpv6_reserved = -1;
static int hf_icmpv6_data = -1; static int hf_icmpv6_data = -1;
static int hf_icmpv6_unknown_data = -1; static int hf_icmpv6_unknown_data = -1;
@ -3470,12 +3470,12 @@ static int
dissect_icmpv6(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data) dissect_icmpv6(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
{ {
proto_tree *icmp6_tree = NULL, *flag_tree = NULL; proto_tree *icmp6_tree = NULL, *flag_tree = NULL;
proto_item *ti = NULL, *hidden_item, *checksum_item = NULL, *code_item = NULL, *ti_flag = NULL; proto_item *ti = NULL, *checksum_item = NULL, *code_item = NULL, *ti_flag = NULL;
const char *code_name = NULL; const char *code_name = NULL;
guint length = 0, reported_length; guint length = 0, reported_length;
vec_t cksum_vec[4]; vec_t cksum_vec[4];
guint32 phdr[2]; guint32 phdr[2];
guint16 cksum, computed_cksum; guint16 cksum;
int offset; int offset;
tvbuff_t *next_tvb; tvbuff_t *next_tvb;
guint8 icmp6_type, icmp6_code; guint8 icmp6_type, icmp6_code;
@ -3540,46 +3540,32 @@ dissect_icmpv6(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
col_set_str(pinfo->cinfo, COL_INFO, "Direct IPv6 Connectivity Test"); col_set_str(pinfo->cinfo, COL_INFO, "Direct IPv6 Connectivity Test");
} }
if (tree) { if (code_name)
if (code_name) proto_item_append_text(code_item, " (%s)", code_name);
proto_item_append_text(code_item, " (%s)", code_name);
checksum_item = proto_tree_add_item(icmp6_tree, hf_icmpv6_checksum, tvb, offset, 2, ENC_BIG_ENDIAN);
}
cksum = tvb_get_ntohs(tvb, offset); cksum = tvb_get_ntohs(tvb, offset);
length = tvb_captured_length(tvb);
reported_length = tvb_reported_length(tvb);
if (!pinfo->fragmented && length >= reported_length && !pinfo->flags.in_error_pkt) {
/* The packet isn't part of a fragmented datagram, isn't truncated,
* and we aren't in an ICMP error packet, so we can checksum it.
*/
if (1) { /* There's an expert info in here so always execute */ /* Set up the fields of the pseudo-header. */
length = tvb_captured_length(tvb); SET_CKSUM_VEC_PTR(cksum_vec[0], (const guint8 *)pinfo->src.data, pinfo->src.len);
reported_length = tvb_reported_length(tvb); SET_CKSUM_VEC_PTR(cksum_vec[1], (const guint8 *)pinfo->dst.data, pinfo->dst.len);
if (!pinfo->fragmented && length >= reported_length && !pinfo->flags.in_error_pkt) { phdr[0] = g_htonl(reported_length);
/* The packet isn't part of a fragmented datagram, isn't truncated, phdr[1] = g_htonl(IP_PROTO_ICMPV6);
* and we aren't in an ICMP error packet, so we can checksum it. SET_CKSUM_VEC_PTR(cksum_vec[2], (const guint8 *)&phdr, 8);
*/ SET_CKSUM_VEC_TVB(cksum_vec[3], tvb, 0, reported_length);
/* Set up the fields of the pseudo-header. */ proto_tree_add_checksum(icmp6_tree, tvb, 2, hf_icmpv6_checksum, hf_icmpv6_checksum_status, &ei_icmpv6_checksum, pinfo, in_cksum(cksum_vec, 4),
SET_CKSUM_VEC_PTR(cksum_vec[0], (const guint8 *)pinfo->src.data, pinfo->src.len); ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_IN_CKSUM);
SET_CKSUM_VEC_PTR(cksum_vec[1], (const guint8 *)pinfo->dst.data, pinfo->dst.len); } else {
phdr[0] = g_htonl(reported_length); checksum_item = proto_tree_add_checksum(icmp6_tree, tvb, 2, hf_icmpv6_checksum, hf_icmpv6_checksum_status, &ei_icmpv6_checksum, pinfo, 0,
phdr[1] = g_htonl(IP_PROTO_ICMPV6); ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
SET_CKSUM_VEC_PTR(cksum_vec[2], (const guint8 *)&phdr, 8); proto_item_append_text(checksum_item, " [%s]",
SET_CKSUM_VEC_TVB(cksum_vec[3], tvb, 0, reported_length); pinfo->flags.in_error_pkt ? "in ICMP error packet" : "fragmented datagram");
computed_cksum = in_cksum(cksum_vec, 4);
if (computed_cksum == 0) {
hidden_item = proto_tree_add_boolean(icmp6_tree, hf_icmpv6_checksum_bad, tvb, offset, 2, FALSE);
PROTO_ITEM_SET_HIDDEN(hidden_item);
proto_item_append_text(checksum_item, " [correct]");
} else {
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, &ei_icmpv6_checksum,
"ICMPv6 Checksum Incorrect, should be 0x%04x", in_cksum_shouldbe(cksum, computed_cksum));
}
} else {
proto_item_append_text(checksum_item, " [%s]",
pinfo->flags.in_error_pkt ? "in ICMP error packet" : "fragmented datagram");
}
} }
offset += 2; offset += 2;
@ -3612,8 +3598,7 @@ dissect_icmpv6(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
* Shouldn't the nonce be at least 8 then? Why not just use (-1), * Shouldn't the nonce be at least 8 then? Why not just use (-1),
* as it could really be any length, couldn't it? * as it could really be any length, couldn't it?
*/ */
if (tree) proto_tree_add_item(icmp6_tree, hf_icmpv6_nonce, tvb, offset, 4, ENC_NA);
proto_tree_add_item(icmp6_tree, hf_icmpv6_nonce, tvb, offset, 4, ENC_NA);
offset += 4; offset += 4;
} else { } else {
if (!pinfo->flags.in_error_pkt) { if (!pinfo->flags.in_error_pkt) {
@ -4158,8 +4143,8 @@ proto_register_icmpv6(void)
{ &hf_icmpv6_checksum, { &hf_icmpv6_checksum,
{ "Checksum", "icmpv6.checksum", FT_UINT16, BASE_HEX, NULL, 0x0, { "Checksum", "icmpv6.checksum", FT_UINT16, BASE_HEX, NULL, 0x0,
"Used to detect data corruption in the ICMPv6 message and parts of the IPv6 header", HFILL }}, "Used to detect data corruption in the ICMPv6 message and parts of the IPv6 header", HFILL }},
{ &hf_icmpv6_checksum_bad, { &hf_icmpv6_checksum_status,
{ "Bad Checksum", "icmpv6.checksum_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0, { "Checksum Status", "icmpv6.checksum.status", FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0,
NULL, HFILL }}, NULL, HFILL }},
{ &hf_icmpv6_reserved, { &hf_icmpv6_reserved,
{ "Reserved", "icmpv6.reserved", FT_BYTES, BASE_NONE, NULL, 0x0, { "Reserved", "icmpv6.reserved", FT_BYTES, BASE_NONE, NULL, 0x0,

2
epan/dissectors/packet-idp.c
View File

@ -88,7 +88,7 @@ dissect_idp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
ti = proto_tree_add_item(tree, proto_idp, tvb, 0, IDP_HEADER_LEN, ENC_NA); ti = proto_tree_add_item(tree, proto_idp, tvb, 0, IDP_HEADER_LEN, ENC_NA);
idp_tree = proto_item_add_subtree(ti, ett_idp); idp_tree = proto_item_add_subtree(ti, ett_idp);
proto_tree_add_item(idp_tree, hf_idp_checksum, tvb, 0, 2, ENC_BIG_ENDIAN); proto_tree_add_checksum(idp_tree, tvb, 0, hf_idp_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
length = tvb_get_ntohs(tvb, 2); length = tvb_get_ntohs(tvb, 2);
proto_tree_add_uint_format_value(idp_tree, hf_idp_len, tvb, 2, 2, length, proto_tree_add_uint_format_value(idp_tree, hf_idp_len, tvb, 2, 2, length,
"%u bytes", length); "%u bytes", length);

57
epan/dissectors/packet-ieee80211.c
View File

@ -2978,8 +2978,7 @@ static int hf_ieee80211_seq_number = -1;
/* Header values for Frame Check field */ /* Header values for Frame Check field */
/* ************************************************************************* */ /* ************************************************************************* */
static int hf_ieee80211_fcs = -1; static int hf_ieee80211_fcs = -1;
static int hf_ieee80211_fcs_good = -1; static int hf_ieee80211_fcs_status = -1;
static int hf_ieee80211_fcs_bad = -1;
/* ************************************************************************* */ /* ************************************************************************* */
/* Header values for reassembly */ /* Header values for reassembly */
@ -16429,14 +16428,12 @@ dissect_ieee80211_common(tvbuff_t *tvb, packet_info *pinfo,
guint32 seq_number, frag_number; guint32 seq_number, frag_number;
gboolean more_frags; gboolean more_frags;
proto_item *ti = NULL; proto_item *ti = NULL;
proto_item *fcs_item = NULL;
proto_item *cw_item = NULL; proto_item *cw_item = NULL;
proto_item *hidden_item; proto_item *hidden_item;
proto_tree *fcs_tree = NULL;
proto_tree *cw_tree = NULL; proto_tree *cw_tree = NULL;
guint16 hdr_len, ohdr_len; guint16 hdr_len, ohdr_len;
guint16 htc_len = 0; guint16 htc_len = 0;
gboolean has_fcs, fcs_good, fcs_bad; gboolean has_fcs;
gint len, reported_len, ivlen; gint len, reported_len, ivlen;
gint sta_addr_offset = 0; gint sta_addr_offset = 0;
const gchar *station_name; const gchar *station_name;
@ -17527,7 +17524,7 @@ dissect_ieee80211_common(tvbuff_t *tvb, packet_info *pinfo,
*/ */
len -= 4; len -= 4;
reported_len -= 4; reported_len -= 4;
if (tree) if (wlan_check_checksum)
{ {
guint32 sent_fcs = tvb_get_ntohl(tvb, hdr_len + len); guint32 sent_fcs = tvb_get_ntohl(tvb, hdr_len + len);
guint32 fcs; guint32 fcs;
@ -17536,40 +17533,13 @@ dissect_ieee80211_common(tvbuff_t *tvb, packet_info *pinfo,
fcs = crc32_802_tvb_padded(tvb, ohdr_len, hdr_len, len); fcs = crc32_802_tvb_padded(tvb, ohdr_len, hdr_len, len);
else else
fcs = crc32_802_tvb(tvb, hdr_len + len); fcs = crc32_802_tvb(tvb, hdr_len + len);
if (fcs == sent_fcs) { if (fcs != sent_fcs) {
fcs_good = TRUE;
fcs_bad = FALSE;
} else {
fcs_good = FALSE;
fcs_bad = TRUE;
}
fcs_item = proto_tree_add_item(hdr_tree, hf_ieee80211_fcs, tvb,
hdr_len + len, 4, ENC_LITTLE_ENDIAN);
if (fcs_good) {
proto_item_append_text(fcs_item, " [correct]");
} else {
proto_item_append_text(fcs_item, " [incorrect, should be 0x%08x]", fcs);
flag_str[8] = '.'; flag_str[8] = '.';
} }
proto_tree_set_appendix(hdr_tree, tvb, hdr_len + len, 4); proto_tree_add_checksum(hdr_tree, tvb, hdr_len + len, hf_ieee80211_fcs, hf_ieee80211_fcs_status, NULL, pinfo, fcs, ENC_LITTLE_ENDIAN, PROTO_CHECKSUM_VERIFY);
} else {
if(wlan_check_checksum) { proto_tree_add_checksum(hdr_tree, tvb, hdr_len + len, hf_ieee80211_fcs, hf_ieee80211_fcs_status, NULL, pinfo, 0, ENC_LITTLE_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
fcs_tree = proto_item_add_subtree(fcs_item, ett_fcs);
fcs_item = proto_tree_add_boolean(fcs_tree,
hf_ieee80211_fcs_good, tvb,
hdr_len + len, 4,
fcs_good);
PROTO_ITEM_SET_GENERATED(fcs_item);
fcs_item = proto_tree_add_boolean(fcs_tree,
hf_ieee80211_fcs_bad, tvb,
hdr_len + len, 4,
fcs_bad);
PROTO_ITEM_SET_GENERATED(fcs_item);
}
} }
} }
} }
@ -19154,15 +19124,10 @@ proto_register_ieee80211(void)
FT_UINT32, BASE_HEX, NULL, 0, FT_UINT32, BASE_HEX, NULL, 0,
"Frame Check Sequence (FCS)", HFILL }}, "Frame Check Sequence (FCS)", HFILL }},
{&hf_ieee80211_fcs_good, {&hf_ieee80211_fcs_status,
{"Good", "wlan.fcs_good", {"FCS Status", "wlan.fcs.status",
FT_BOOLEAN, BASE_NONE, NULL, 0x0, FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0,
"True if the FCS is correct", HFILL }}, NULL, HFILL }},
{&hf_ieee80211_fcs_bad,
{"Bad", "wlan.fcs_bad",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"True if the FCS is incorrect", HFILL }},
{&hf_ieee80211_fragment_overlap, {&hf_ieee80211_fragment_overlap,
{"Fragment overlap", "wlan.fragment.overlap", {"Fragment overlap", "wlan.fragment.overlap",

10
epan/dissectors/packet-igap.c
View File

@ -52,7 +52,7 @@ static int proto_igap = -1;
static int hf_type = -1; static int hf_type = -1;
static int hf_max_resp = -1; static int hf_max_resp = -1;
static int hf_checksum = -1; static int hf_checksum = -1;
static int hf_checksum_bad = -1; static int hf_checksum_status = -1;
static int hf_maddr = -1; static int hf_maddr = -1;
static int hf_version = -1; static int hf_version = -1;
static int hf_subtype = -1; static int hf_subtype = -1;
@ -157,7 +157,7 @@ dissect_igap(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, void* d
"%.1f sec (0x%02x)", tsecs * 0.1, tsecs); "%.1f sec (0x%02x)", tsecs * 0.1, tsecs);
offset += 1; offset += 1;
igmp_checksum(tree, tvb, hf_checksum, hf_checksum_bad, pinfo, 0); igmp_checksum(tree, tvb, hf_checksum, hf_checksum_status, pinfo, 0);
offset += 2; offset += 2;
proto_tree_add_item(tree, hf_maddr, tvb, offset, 4, ENC_BIG_ENDIAN); proto_tree_add_item(tree, hf_maddr, tvb, offset, 4, ENC_BIG_ENDIAN);
@ -256,9 +256,9 @@ proto_register_igap(void)
FT_UINT16, BASE_HEX, NULL, 0, FT_UINT16, BASE_HEX, NULL, 0,
NULL, HFILL } NULL, HFILL }
}, },
{ &hf_checksum_bad, { &hf_checksum_status,
{ "Bad Checksum", "igap.checksum_bad", { "Checksum Status", "igap.checksum.status",
FT_BOOLEAN, BASE_NONE, NULL, 0x0, FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0,
NULL, HFILL } NULL, HFILL }
}, },
{ &hf_maddr, { &hf_maddr,

43
epan/dissectors/packet-igmp.c
View File

@ -127,7 +127,7 @@ static int hf_group_type = -1;
static int hf_reply_code = -1; static int hf_reply_code = -1;
static int hf_reply_pending = -1; static int hf_reply_pending = -1;
static int hf_checksum = -1; static int hf_checksum = -1;
static int hf_checksum_bad = -1; static int hf_checksum_status = -1;
static int hf_identifier = -1; static int hf_identifier = -1;
static int hf_access_key = -1; static int hf_access_key = -1;
static int hf_max_resp = -1; static int hf_max_resp = -1;
@ -282,11 +282,9 @@ static const value_string mtrace_fwd_code_vals[] = {
}; };
void igmp_checksum(proto_tree *tree, tvbuff_t *tvb, int hf_index, void igmp_checksum(proto_tree *tree, tvbuff_t *tvb, int hf_index,
int hf_index_bad, packet_info *pinfo, guint len) int hf_index_status, packet_info *pinfo, guint len)
{ {
guint16 cksum, hdrcksum;
vec_t cksum_vec[1]; vec_t cksum_vec[1];
proto_item *hidden_item;
if (len == 0) { if (len == 0) {
/* /*
@ -295,29 +293,16 @@ void igmp_checksum(proto_tree *tree, tvbuff_t *tvb, int hf_index,
len = tvb_reported_length(tvb); len = tvb_reported_length(tvb);
} }
hdrcksum = tvb_get_ntohs(tvb, 2);
if (!pinfo->fragmented && tvb_captured_length(tvb) >= len) { if (!pinfo->fragmented && tvb_captured_length(tvb) >= len) {
/* /*
* The packet isn't part of a fragmented datagram and isn't * The packet isn't part of a fragmented datagram and isn't
* truncated, so we can checksum it. * truncated, so we can checksum it.
*/ */
SET_CKSUM_VEC_TVB(cksum_vec[0], tvb, 0, len); SET_CKSUM_VEC_TVB(cksum_vec[0], tvb, 0, len);
proto_tree_add_checksum(tree, tvb, 2, hf_index, hf_index_status, NULL, pinfo, in_cksum(&cksum_vec[0], 1),
cksum = in_cksum(&cksum_vec[0],1); ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_IN_CKSUM);
if (cksum == 0) {
proto_tree_add_uint_format(tree, hf_index, tvb, 2, 2, hdrcksum,
"Header checksum: 0x%04x [correct]", hdrcksum);
} else {
hidden_item = proto_tree_add_boolean(tree, hf_index_bad,
tvb, 2, 2, TRUE);
PROTO_ITEM_SET_HIDDEN(hidden_item);
proto_tree_add_uint_format(tree, hf_index, tvb, 2, 2, hdrcksum,
"Header checksum: 0x%04x [incorrect, should be 0x%04x]",
hdrcksum, in_cksum_shouldbe(hdrcksum,cksum));
}
} else } else
proto_tree_add_uint(tree, hf_index, tvb, 2, 2, hdrcksum); proto_tree_add_checksum(tree, tvb, 2, hf_index, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
return; return;
} }
@ -563,7 +548,7 @@ dissect_igmp_v3_report(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tre
offset += 1; offset += 1;
/* checksum */ /* checksum */
igmp_checksum(tree, tvb, hf_checksum, hf_checksum_bad, pinfo, 0); igmp_checksum(tree, tvb, hf_checksum, hf_checksum_status, pinfo, 0);
offset += 2; offset += 2;
proto_tree_add_item(tree, hf_reserved, tvb, offset, 2, ENC_NA); proto_tree_add_item(tree, hf_reserved, tvb, offset, 2, ENC_NA);
@ -598,7 +583,7 @@ dissect_igmp_v3_query(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree
offset = dissect_v3_max_resp(tvb, tree, offset); offset = dissect_v3_max_resp(tvb, tree, offset);
/* checksum */ /* checksum */
igmp_checksum(tree, tvb, hf_checksum, hf_checksum_bad, pinfo, 0); igmp_checksum(tree, tvb, hf_checksum, hf_checksum_status, pinfo, 0);
offset += 2; offset += 2;
/* group address */ /* group address */
@ -653,7 +638,7 @@ dissect_igmp_v2(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, void
offset += 1; offset += 1;
/* checksum */ /* checksum */
igmp_checksum(tree, tvb, hf_checksum, hf_checksum_bad, pinfo, 8); igmp_checksum(tree, tvb, hf_checksum, hf_checksum_status, pinfo, 8);
offset += 2; offset += 2;
/* group address */ /* group address */
@ -695,7 +680,7 @@ dissect_igmp_v1(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, void
offset += 1; offset += 1;
/* checksum */ /* checksum */
igmp_checksum(tree, tvb, hf_checksum, hf_checksum_bad, pinfo, 8); igmp_checksum(tree, tvb, hf_checksum, hf_checksum_status, pinfo, 8);
offset += 2; offset += 2;
/* group address */ /* group address */
@ -730,7 +715,7 @@ dissect_igmp_v0(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, void
offset += 1; offset += 1;
/* checksum */ /* checksum */
igmp_checksum(tree, tvb, hf_checksum, hf_checksum_bad, pinfo, 20); igmp_checksum(tree, tvb, hf_checksum, hf_checksum_status, pinfo, 20);
offset += 2; offset += 2;
/* identifier */ /* identifier */
@ -813,7 +798,7 @@ dissect_igmp_mtrace(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree,
offset += 1; offset += 1;
/* checksum */ /* checksum */
igmp_checksum(tree, tvb, hf_checksum, hf_checksum_bad, pinfo, 0); igmp_checksum(tree, tvb, hf_checksum, hf_checksum_status, pinfo, 0);
offset += 2; offset += 2;
/* group address to be traced */ /* group address to be traced */
@ -952,9 +937,9 @@ proto_register_igmp(void)
{ "Checksum", "igmp.checksum", FT_UINT16, BASE_HEX, { "Checksum", "igmp.checksum", FT_UINT16, BASE_HEX,
NULL, 0, "IGMP Checksum", HFILL }}, NULL, 0, "IGMP Checksum", HFILL }},
{ &hf_checksum_bad, { &hf_checksum_status,
{ "Bad Checksum", "igmp.checksum_bad", FT_BOOLEAN, BASE_NONE, { "Checksum Status", "igmp.checksum.status", FT_UINT8, BASE_NONE,
NULL, 0x0, "Bad IGMP Checksum", HFILL }}, VALS(proto_checksum_vals), 0x0, NULL, HFILL }},
{ &hf_identifier, { &hf_identifier,
{ "Identifier", "igmp.identifier", FT_UINT32, BASE_DEC, { "Identifier", "igmp.identifier", FT_UINT32, BASE_DEC,

2
epan/dissectors/packet-igmp.h
View File

@ -55,7 +55,7 @@
#define IGMP_RGMP_HELLO 0xFF #define IGMP_RGMP_HELLO 0xFF
void igmp_checksum(proto_tree *tree, tvbuff_t *tvb, int hf_index, void igmp_checksum(proto_tree *tree, tvbuff_t *tvb, int hf_index,
int hf_index_bad, packet_info *pinfo, guint len); int hf_index_status, packet_info *pinfo, guint len);
#endif #endif

2
epan/dissectors/packet-igrp.c
View File

@ -147,7 +147,7 @@ static int dissect_igrp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, voi
offset+=IGRP_ENTRY_LENGTH; offset+=IGRP_ENTRY_LENGTH;
} }
proto_tree_add_item(igrp_tree, hf_igrp_checksum, tvb, 10, 2, ENC_BIG_ENDIAN); proto_tree_add_checksum(igrp_tree, tvb, 10, hf_igrp_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
} }
return tvb_captured_length(tvb); return tvb_captured_length(tvb);
} }

88
epan/dissectors/packet-ip.c
View File

@ -124,8 +124,7 @@ static int hf_ip_ttl = -1;
static int hf_ip_proto = -1; static int hf_ip_proto = -1;
static int hf_ip_checksum = -1; static int hf_ip_checksum = -1;
static int hf_ip_checksum_calculated = -1; static int hf_ip_checksum_calculated = -1;
static int hf_ip_checksum_good = -1; static int hf_ip_checksum_status = -1;
static int hf_ip_checksum_bad = -1;
/* IP option fields */ /* IP option fields */
static int hf_ip_opt_type = -1; static int hf_ip_opt_type = -1;
@ -243,7 +242,6 @@ static gint ett_ip_option_qs = -1;
static gint ett_ip_option_other = -1; static gint ett_ip_option_other = -1;
static gint ett_ip_fragments = -1; static gint ett_ip_fragments = -1;
static gint ett_ip_fragment = -1; static gint ett_ip_fragment = -1;
static gint ett_ip_checksum = -1;
static gint ett_ip_opt_type = -1; static gint ett_ip_opt_type = -1;
static gint ett_ip_opt_sec_prot_auth_flags = -1; static gint ett_ip_opt_sec_prot_auth_flags = -1;
static gint ett_unknown_ip_tcp_opt = -1; static gint ett_unknown_ip_tcp_opt = -1;
@ -1999,7 +1997,6 @@ dissect_ip_v4(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, void*
guint hlen, optlen; guint hlen, optlen;
guint16 flags; guint16 flags;
guint16 ipsum; guint16 ipsum;
guint16 expected_cksum;
fragment_head *ipfd_head = NULL; fragment_head *ipfd_head = NULL;
tvbuff_t *next_tvb; tvbuff_t *next_tvb;
gboolean update_col_info = TRUE; gboolean update_col_info = TRUE;
@ -2008,7 +2005,6 @@ dissect_ip_v4(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, void*
guint32 src32, dst32; guint32 src32, dst32;
proto_tree *tree; proto_tree *tree;
proto_item *item = NULL, *ttl_item; proto_item *item = NULL, *ttl_item;
proto_tree *checksum_tree;
guint16 ttl; guint16 ttl;
int bit_offset; int bit_offset;
tree = parent_tree; tree = parent_tree;
@ -2207,55 +2203,25 @@ dissect_ip_v4(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, void*
*/ */
if (ip_check_checksum && tvb_bytes_exist(tvb, offset, hlen)&&(!pinfo->flags.in_error_pkt)) { if (ip_check_checksum && tvb_bytes_exist(tvb, offset, hlen)&&(!pinfo->flags.in_error_pkt)) {
ipsum = ip_checksum_tvb(tvb, offset, hlen); ipsum = ip_checksum_tvb(tvb, offset, hlen);
if (tree) { item = proto_tree_add_checksum(ip_tree, tvb, offset + 10, hf_ip_checksum, hf_ip_checksum_status, &ei_ip_checksum_bad, pinfo, ipsum,
if (ipsum == 0) { ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_IN_CKSUM);
item = proto_tree_add_uint_format_value(ip_tree, hf_ip_checksum, tvb, if (ipsum == 0) {
offset + 10, 2, iph->ip_sum, /* XXX - Keeping hf_ip_checksum_calculated field for now. Doesn't fit into the
"0x%04x [correct]", proto_tree_add_checksum design, but IP is a popular enough dissector that somebody
iph->ip_sum); may have a legitimate reason for wanting it filtered */
checksum_tree = proto_item_add_subtree(item, ett_ip_checksum); item = proto_tree_add_uint(ip_tree, hf_ip_checksum_calculated, tvb,
item = proto_tree_add_uint(checksum_tree, hf_ip_checksum_calculated, tvb, offset + 10, 2, iph->ip_sum);
offset + 10, 2, iph->ip_sum); PROTO_ITEM_SET_GENERATED(item);
PROTO_ITEM_SET_GENERATED(item); } else {
item = proto_tree_add_boolean(checksum_tree, hf_ip_checksum_good, tvb, proto_item_append_text(item, "(may be caused by \"IP checksum offload\"?)");
offset + 10, 2, TRUE);
PROTO_ITEM_SET_GENERATED(item);
item = proto_tree_add_boolean(checksum_tree, hf_ip_checksum_bad, tvb,
offset + 10, 2, FALSE);
PROTO_ITEM_SET_GENERATED(item);
} else {
expected_cksum = in_cksum_shouldbe(iph->ip_sum, ipsum);
item = proto_tree_add_uint_format_value(ip_tree, hf_ip_checksum, tvb, item = proto_tree_add_uint(ip_tree, hf_ip_checksum_calculated, tvb,
offset + 10, 2, iph->ip_sum, offset + 10, 2, in_cksum_shouldbe(iph->ip_sum, ipsum));
"0x%04x " PROTO_ITEM_SET_GENERATED(item);
"[incorrect, should be 0x%04x "
"(may be caused by \"IP checksum "
"offload\"?)]", iph->ip_sum,
expected_cksum);
checksum_tree = proto_item_add_subtree(item, ett_ip_checksum);
item = proto_tree_add_uint(checksum_tree, hf_ip_checksum_calculated, tvb,
offset + 10, 2, expected_cksum);
PROTO_ITEM_SET_GENERATED(item);
item = proto_tree_add_boolean(checksum_tree, hf_ip_checksum_good, tvb,
offset + 10, 2, FALSE);
PROTO_ITEM_SET_GENERATED(item);
item = proto_tree_add_boolean(checksum_tree, hf_ip_checksum_bad, tvb,
offset + 10, 2, TRUE);
PROTO_ITEM_SET_GENERATED(item);
}
}
if (ipsum != 0) {
/* Add expert item always (so tap gets called if present);
if (tree == NULL) then item will be NULL
else item should be from the
add_boolean(..., hf_ip_checksum_bad, ...) above */
expert_add_info(pinfo, item, &ei_ip_checksum_bad);
} }
} else { } else {
ipsum = 0; ipsum = 0;
if (tree) { proto_tree_add_uint_format_value(ip_tree, hf_ip_checksum, tvb,
item = proto_tree_add_uint_format_value(ip_tree, hf_ip_checksum, tvb,
offset + 10, 2, iph->ip_sum, offset + 10, 2, iph->ip_sum,
"0x%04x [%s]", "0x%04x [%s]",
iph->ip_sum, iph->ip_sum,
@ -2264,14 +2230,9 @@ dissect_ip_v4(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, void*
"in ICMP error packet" : "in ICMP error packet" :
"not all data available") : "not all data available") :
"validation disabled"); "validation disabled");
checksum_tree = proto_item_add_subtree(item, ett_ip_checksum); item = proto_tree_add_uint(ip_tree, hf_ip_checksum_status, tvb,
item = proto_tree_add_boolean(checksum_tree, hf_ip_checksum_good, tvb, offset + 10, 0, PROTO_CHECKSUM_E_UNVERIFIED);
offset + 10, 2, FALSE); PROTO_ITEM_SET_GENERATED(item);
PROTO_ITEM_SET_GENERATED(item);
item = proto_tree_add_boolean(checksum_tree, hf_ip_checksum_bad, tvb,
offset + 10, 2, FALSE);
PROTO_ITEM_SET_GENERATED(item);
}
} }
src32 = tvb_get_ntohl(tvb, offset + IPH_SRC); src32 = tvb_get_ntohl(tvb, offset + IPH_SRC);
set_address_tvb(&pinfo->net_src, AT_IPv4, 4, tvb, offset + IPH_SRC); set_address_tvb(&pinfo->net_src, AT_IPv4, 4, tvb, offset + IPH_SRC);
@ -2801,13 +2762,9 @@ proto_register_ip(void)
{ "Calculated Checksum", "ip.checksum_calculated", FT_UINT16, BASE_HEX, NULL, 0x0, { "Calculated Checksum", "ip.checksum_calculated", FT_UINT16, BASE_HEX, NULL, 0x0,
"The expected IP checksum field as calculated from the IP datagram", HFILL }}, "The expected IP checksum field as calculated from the IP datagram", HFILL }},
{ &hf_ip_checksum_good, { &hf_ip_checksum_status,
{ "Good", "ip.checksum_good", FT_BOOLEAN, BASE_NONE, NULL, 0x0, { "Header checksum status", "ip.checksum.status", FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0,
"True: checksum matches packet content; False: doesn't match content or not checked", HFILL }}, NULL, HFILL }},
{ &hf_ip_checksum_bad,
{ "Bad", "ip.checksum_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"True: checksum doesn't match packet content; False: matches content or not checked", HFILL }},
/* IP options related fields */ /* IP options related fields */
{ &hf_ip_opt_type, { &hf_ip_opt_type,
@ -3080,7 +3037,6 @@ proto_register_ip(void)
&ett_ip_option_other, &ett_ip_option_other,
&ett_ip_fragments, &ett_ip_fragments,
&ett_ip_fragment, &ett_ip_fragment,
&ett_ip_checksum,
&ett_ip_opt_type, &ett_ip_opt_type,
&ett_ip_opt_sec_prot_auth_flags, &ett_ip_opt_sec_prot_auth_flags,
&ett_unknown_ip_tcp_opt, &ett_unknown_ip_tcp_opt,

4
epan/dissectors/packet-ipv6.c
View File

@ -1426,8 +1426,8 @@ dissect_opt_calipso(tvbuff_t *tvb, gint offset, packet_info *pinfo, proto_tree *
offset, 1, ENC_BIG_ENDIAN); offset, 1, ENC_BIG_ENDIAN);
offset += 1; offset += 1;
proto_tree_add_item(opt_tree, hf_ipv6_opt_calipso_checksum, tvb, proto_tree_add_checksum(opt_tree, tvb, offset, hf_ipv6_opt_calipso_checksum, -1,
offset, 2, ENC_BIG_ENDIAN); NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
offset += 2; offset += 2;
proto_tree_add_item(opt_tree, hf_ipv6_opt_calipso_cmpt_bitmap, tvb, proto_tree_add_item(opt_tree, hf_ipv6_opt_calipso_cmpt_bitmap, tvb,

2
epan/dissectors/packet-ipx.c
View File

@ -345,7 +345,7 @@ dissect_ipx(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
hidden_item = proto_tree_add_string(ipx_tree, hf_ipx_addr, tvb, 0, 0, str); hidden_item = proto_tree_add_string(ipx_tree, hf_ipx_addr, tvb, 0, 0, str);
PROTO_ITEM_SET_HIDDEN(hidden_item); PROTO_ITEM_SET_HIDDEN(hidden_item);
proto_tree_add_item(ipx_tree, hf_ipx_checksum, tvb, 0, 2, ENC_BIG_ENDIAN); proto_tree_add_checksum(ipx_tree, tvb, 0, hf_ipx_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
proto_tree_add_uint_format_value(ipx_tree, hf_ipx_len, tvb, 2, 2, ipxh->ipx_length, proto_tree_add_uint_format_value(ipx_tree, hf_ipx_len, tvb, 2, 2, ipxh->ipx_length,
"%d bytes", ipxh->ipx_length); "%d bytes", ipxh->ipx_length);
ipx_hops = tvb_get_guint8(tvb, 4); ipx_hops = tvb_get_guint8(tvb, 4);

31
epan/dissectors/packet-isis-hello.c
View File

@ -765,29 +765,18 @@ dissect_hello_checksum_clv(tvbuff_t *tvb, packet_info* pinfo,
* which is offseted 17 bytes in IIHs (relative to the beginning of the IS-IS packet) */ * which is offseted 17 bytes in IIHs (relative to the beginning of the IS-IS packet) */
pdu_length = tvb_get_ntohs(tvb, 17); pdu_length = tvb_get_ntohs(tvb, 17);
/* unlike the LSP checksum verification which starts at an offset of 12 we start at offset 0*/ if (checksum == 0) {
switch (check_and_get_checksum(tvb, 0, pdu_length, checksum, offset, &cacl_checksum)) /* No checksum present */
{ proto_tree_add_checksum(tree, tvb, offset, hf_isis_hello_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NOT_PRESENT);
case NO_CKSUM : } else {
proto_tree_add_uint_format_value( tree, hf_isis_hello_checksum, tvb, offset, length, checksum, if (osi_check_and_get_checksum(tvb, 0, pdu_length, offset, &cacl_checksum)) {
"0x%04x [unused]", checksum); /* Successfully processed checksum, verify it */
break; proto_tree_add_checksum(tree, tvb, offset, hf_isis_hello_checksum, -1, NULL, pinfo, cacl_checksum, ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
case DATA_MISSING : } else {
proto_tree_add_checksum(tree, tvb, offset, hf_isis_hello_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
proto_tree_add_expert_format(tree, pinfo, &ei_isis_hello_long_packet, tvb, offset, -1, proto_tree_add_expert_format(tree, pinfo, &ei_isis_hello_long_packet, tvb, offset, -1,
"Packet length %d went beyond packet", tvb_captured_length(tvb) ); "Packet length %d went beyond packet", tvb_captured_length(tvb) );
break; }
case CKSUM_NOT_OK :
proto_tree_add_uint_format_value( tree, hf_isis_hello_checksum, tvb, offset, length, checksum,
"0x%04x [incorrect, should be 0x%04x]",
checksum,
cacl_checksum);
break;
case CKSUM_OK :
proto_tree_add_uint_format_value( tree, hf_isis_hello_checksum, tvb, offset, length, checksum,
"0x%04x [correct]", checksum);
break;
default :
g_message("'check_and_get_checksum' returned an invalid value");
} }
} }

70
epan/dissectors/packet-isis-lsp.c
View File

@ -156,8 +156,7 @@ static int hf_isis_lsp_srlg_ipv4_local = -1;
static int hf_isis_lsp_srlg_ipv4_remote = -1; static int hf_isis_lsp_srlg_ipv4_remote = -1;
static int hf_isis_lsp_srlg_value = -1; static int hf_isis_lsp_srlg_value = -1;
static int hf_isis_lsp_checksum = -1; static int hf_isis_lsp_checksum = -1;
static int hf_isis_lsp_checksum_bad = -1; static int hf_isis_lsp_checksum_status = -1;
static int hf_isis_lsp_checksum_good = -1;
static int hf_isis_lsp_clv_ipv4_int_addr = -1; static int hf_isis_lsp_clv_ipv4_int_addr = -1;
static int hf_isis_lsp_clv_ipv6_int_addr = -1; static int hf_isis_lsp_clv_ipv6_int_addr = -1;
static int hf_isis_lsp_clv_te_router_id = -1; static int hf_isis_lsp_clv_te_router_id = -1;
@ -3105,25 +3104,6 @@ dissect_lsp_prefix_neighbors_clv(tvbuff_t *tvb, packet_info* pinfo, proto_tree *
} }
} }
static void isis_lsp_checkum_additional_info(tvbuff_t * tvb, packet_info * pinfo,
proto_item * it_cksum, int offset, gboolean is_cksum_correct)
{
proto_tree * checksum_tree;
proto_item * item;
checksum_tree = proto_item_add_subtree(it_cksum, ett_isis_lsp_cksum);
item = proto_tree_add_boolean(checksum_tree, hf_isis_lsp_checksum_good, tvb,
offset, 2, is_cksum_correct);
PROTO_ITEM_SET_GENERATED(item);
item = proto_tree_add_boolean(checksum_tree, hf_isis_lsp_checksum_bad, tvb,
offset, 2, !is_cksum_correct);
PROTO_ITEM_SET_GENERATED(item);
if (!is_cksum_correct) {
expert_add_info(pinfo, item, &ie_isis_lsp_checksum_bad);
col_append_str(pinfo->cinfo, COL_INFO, " [ISIS CHECKSUM INCORRECT]");
}
}
static const isis_clv_handle_t clv_l1_lsp_opts[] = { static const isis_clv_handle_t clv_l1_lsp_opts[] = {
{ {
ISIS_CLV_AREA_ADDRESS, ISIS_CLV_AREA_ADDRESS,
@ -3475,7 +3455,6 @@ dissect_isis_lsp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset
guint16 pdu_length, lifetime, checksum, cacl_checksum=0; guint16 pdu_length, lifetime, checksum, cacl_checksum=0;
guint8 lsp_info; guint8 lsp_info;
int len, offset_checksum; int len, offset_checksum;
proto_item *it_cksum;
char* system_id; char* system_id;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "ISIS LSP"); col_set_str(pinfo->cinfo, COL_PROTOCOL, "ISIS LSP");
@ -3511,28 +3490,23 @@ dissect_isis_lsp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset
offset += 4; offset += 4;
checksum = lifetime ? tvb_get_ntohs(tvb, offset) : 0; checksum = lifetime ? tvb_get_ntohs(tvb, offset) : 0;
switch (check_and_get_checksum(tvb, offset_checksum, pdu_length-12, checksum, offset, &cacl_checksum)) { if (checksum == 0) {
case NO_CKSUM : /* No checksum present */
checksum = tvb_get_ntohs(tvb, offset); proto_tree_add_checksum(lsp_tree, tvb, offset_checksum, hf_isis_lsp_checksum, hf_isis_lsp_checksum_status, &ie_isis_lsp_checksum_bad, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NOT_PRESENT);
proto_tree_add_uint_format_value(lsp_tree, hf_isis_lsp_checksum, tvb, offset, 2, checksum, } else {
"0x%04x [unused]", checksum); if (osi_check_and_get_checksum(tvb, offset_checksum, pdu_length-12, offset, &cacl_checksum)) {
break; /* Successfully processed checksum, verify it */
case DATA_MISSING : proto_tree_add_checksum(lsp_tree, tvb, offset_checksum, hf_isis_lsp_checksum, hf_isis_lsp_checksum_status, &ie_isis_lsp_checksum_bad, pinfo, cacl_checksum, ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
if (cacl_checksum != checksum) {
col_append_str(pinfo->cinfo, COL_INFO, " [ISIS CHECKSUM INCORRECT]");
}
} else {
proto_tree_add_checksum(lsp_tree, tvb, offset_checksum, hf_isis_lsp_checksum, hf_isis_lsp_checksum_status, &ie_isis_lsp_checksum_bad, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
proto_tree_add_expert_format(tree, pinfo, &ei_isis_lsp_long_packet, tvb, offset, -1, proto_tree_add_expert_format(tree, pinfo, &ei_isis_lsp_long_packet, tvb, offset, -1,
"Packet length %d went beyond packet", "Packet length %d went beyond packet",
tvb_reported_length_remaining(tvb, offset_checksum)); tvb_reported_length_remaining(tvb, offset_checksum));
break; }
case CKSUM_NOT_OK :
it_cksum = proto_tree_add_uint_format_value(lsp_tree, hf_isis_lsp_checksum, tvb, offset, 2, checksum,
"0x%04x [incorrect, should be 0x%04x]",
checksum, cacl_checksum);
isis_lsp_checkum_additional_info(tvb, pinfo, it_cksum, offset, FALSE);
break;
case CKSUM_OK :
it_cksum = proto_tree_add_uint_format_value(lsp_tree, hf_isis_lsp_checksum, tvb, offset, 2, checksum,
"0x%04x [correct]", checksum);
isis_lsp_checkum_additional_info(tvb, pinfo, it_cksum, offset, TRUE);
break;
} }
offset += 2; offset += 2;
@ -3675,16 +3649,10 @@ proto_register_isis_lsp(void)
NULL, HFILL } NULL, HFILL }
}, },
{ &hf_isis_lsp_checksum_good, { &hf_isis_lsp_checksum_status,
{ "Good Checksum", "isis.lsp.checksum_good", { "Checksum Status", "isis.lsp.checksum.status",
FT_BOOLEAN, BASE_NONE, NULL, 0x0, FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0,
"Good IS-IS LSP Checksum", HFILL } NULL, HFILL }
},
{ &hf_isis_lsp_checksum_bad,
{ "Bad Checksum", "isis.lsp.checksum_bad",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Bad IS-IS LSP Checksum", HFILL }
}, },
{ &hf_isis_lsp_clv_ipv4_int_addr, { &hf_isis_lsp_clv_ipv4_int_addr,

27
epan/dissectors/packet-isis-snp.c
View File

@ -134,7 +134,6 @@ dissect_snp_checksum_clv(tvbuff_t *tvb, packet_info* pinfo,
return; return;
} }
ti = proto_tree_add_item( tree, hf_isis_csnp_checksum, tvb, offset, length, ENC_BIG_ENDIAN);
checksum = tvb_get_ntohs(tvb, offset); checksum = tvb_get_ntohs(tvb, offset);
@ -145,22 +144,18 @@ dissect_snp_checksum_clv(tvbuff_t *tvb, packet_info* pinfo,
pdu_length = tvb_get_ntohs(tvb, 8); pdu_length = tvb_get_ntohs(tvb, 8);
/* unlike the LSP checksum verification which starts at an offset of 12 we start at offset 0*/ if (checksum == 0) {
switch (check_and_get_checksum(tvb, 0, pdu_length, checksum, offset, &cacl_checksum)) /* No checksum present */
{ proto_tree_add_checksum(tree, tvb, offset, hf_isis_csnp_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NOT_PRESENT);
case NO_CKSUM : } else {
proto_item_append_text(ti, " [unused]"); if (osi_check_and_get_checksum(tvb, 0, pdu_length, offset, &cacl_checksum)) {
break; /* Successfully processed checksum, verify it */
case DATA_MISSING : proto_tree_add_checksum(tree, tvb, offset, hf_isis_csnp_checksum, -1, NULL, pinfo, cacl_checksum, ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
expert_add_info_format(pinfo, ti, &ei_isis_csnp_long_packet, } else {
ti = proto_tree_add_checksum(tree, tvb, offset, hf_isis_csnp_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
expert_add_info_format(pinfo, ti, &ei_isis_csnp_long_packet,
"Packet length %d went beyond packet", tvb_captured_length(tvb)); "Packet length %d went beyond packet", tvb_captured_length(tvb));
break; }
case CKSUM_NOT_OK :
proto_item_append_text(ti, " [incorrect, should be 0x%04x]", cacl_checksum);
break;
case CKSUM_OK :
proto_item_append_text(ti, " [correct]");
break;
} }
} }

4
epan/dissectors/packet-itdm.c
View File

@ -225,7 +225,7 @@ dissect_itdm_125usec(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
proto_tree_add_item(itdm_tree, hf_itdm_last_pack, tvb, offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(itdm_tree, hf_itdm_last_pack, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(itdm_tree, hf_itdm_pktlen, tvb, offset, 2, ENC_BIG_ENDIAN); proto_tree_add_item(itdm_tree, hf_itdm_pktlen, tvb, offset, 2, ENC_BIG_ENDIAN);
offset += 2; offset += 2;
proto_tree_add_item(itdm_tree, hf_itdm_chksum, tvb, offset, 2, ENC_BIG_ENDIAN); proto_tree_add_checksum(itdm_tree, tvb, offset, hf_itdm_chksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
offset += 2; offset += 2;
proto_tree_add_item(itdm_tree, hf_itdm_uid, tvb, offset, 3, ENC_BIG_ENDIAN); proto_tree_add_item(itdm_tree, hf_itdm_uid, tvb, offset, 3, ENC_BIG_ENDIAN);
offset += 3; offset += 3;
@ -318,7 +318,7 @@ dissect_itdm_control(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
proto_tree_add_item(itdm_ctl_tree, hf_itdm_last_pack, tvb, offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(itdm_ctl_tree, hf_itdm_last_pack, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(itdm_ctl_tree, hf_itdm_pktlen, tvb, offset, 2, ENC_BIG_ENDIAN); proto_tree_add_item(itdm_ctl_tree, hf_itdm_pktlen, tvb, offset, 2, ENC_BIG_ENDIAN);
offset += 2; offset += 2;
proto_tree_add_item(itdm_ctl_tree, hf_itdm_chksum, tvb, offset, 2, ENC_BIG_ENDIAN); proto_tree_add_checksum(itdm_ctl_tree, tvb, offset, hf_itdm_chksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
offset += 2; offset += 2;
proto_tree_add_item(itdm_ctl_tree, hf_itdm_uid, tvb, offset, 3, ENC_BIG_ENDIAN); proto_tree_add_item(itdm_ctl_tree, hf_itdm_uid, tvb, offset, 3, ENC_BIG_ENDIAN);
offset += 3; offset += 3;

8
epan/dissectors/packet-kingfisher.c
View File

@ -294,7 +294,7 @@ dissect_kingfisher(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolean
proto_tree_add_uint_format_value(kingfisher_tree, hf_kingfisher_message, tvb, 5, 1, kfp.message, "%u (0x%02X, %s)", message, kfp.message, ((kfp.message & 0xf0)?"Response":"Request")); proto_tree_add_uint_format_value(kingfisher_tree, hf_kingfisher_message, tvb, 5, 1, kfp.message, "%u (0x%02X, %s)", message, kfp.message, ((kfp.message & 0xf0)?"Response":"Request"));
/* message function code */ /* message function code */
proto_tree_add_uint_format(kingfisher_tree, hf_kingfisher_function, tvb, 6, 1, kfp.function, "Message Function Code: %u (0x%02X, %s)", kfp.function, kfp.function, func_string); proto_tree_add_uint_format_value(kingfisher_tree, hf_kingfisher_function, tvb, 6, 1, kfp.function, "%u (0x%02X, %s)", kfp.function, kfp.function, func_string);
/* message data */ /* message data */
if(kfp.length > ((kfp.version==3)?11:8)){ if(kfp.length > ((kfp.version==3)?11:8)){
@ -302,9 +302,7 @@ dissect_kingfisher(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolean
} }
/* checksum */ /* checksum */
proto_tree_add_uint_format_value(kingfisher_tree, hf_kingfisher_checksum, tvb, kfp.length-1, 2, kfp.checksum, "0x%04X [%s]", kfp.checksum, ((checksum != kfp.checksum)?"incorrect":"correct")); proto_tree_add_checksum(kingfisher_tree, tvb, kfp.length-1, hf_kingfisher_checksum, -1, NULL, pinfo, checksum, ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
return TRUE; return TRUE;
} }
@ -351,7 +349,7 @@ proto_register_kingfisher( void )
{ &hf_kingfisher_target, { "Target RTU", "kingfisher.target", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_kingfisher_target, { "Target RTU", "kingfisher.target", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } },
{ &hf_kingfisher_via, { "Via RTU", "kingfisher.via", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_kingfisher_via, { "Via RTU", "kingfisher.via", FT_UINT16, BASE_DEC_HEX, NULL, 0x0, NULL, HFILL } },
{ &hf_kingfisher_message, { "Message Number", "kingfisher.message", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_kingfisher_message, { "Message Number", "kingfisher.message", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_kingfisher_function, { "Function Code", "kingfisher.function", FT_UINT8, BASE_DEC, VALS( function_code_vals ), 0x0, NULL, HFILL } }, { &hf_kingfisher_function, { "Message Function Code", "kingfisher.function", FT_UINT8, BASE_DEC, VALS( function_code_vals ), 0x0, NULL, HFILL } },
{ &hf_kingfisher_checksum, { "Checksum", "kingfisher.checksum", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_kingfisher_checksum, { "Checksum", "kingfisher.checksum", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_kingfisher_message_data, { "Message Data", "kingfisher.message_data", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_kingfisher_message_data, { "Message Data", "kingfisher.message_data", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } },
}; };

39
epan/dissectors/packet-lapd.c
View File

@ -74,8 +74,7 @@ static int hf_lapd_ftype_i = -1;
static int hf_lapd_ftype_s_u = -1; static int hf_lapd_ftype_s_u = -1;
static int hf_lapd_ftype_s_u_ext = -1; static int hf_lapd_ftype_s_u_ext = -1;
static int hf_lapd_checksum = -1; static int hf_lapd_checksum = -1;
static int hf_lapd_checksum_good = -1; static int hf_lapd_checksum_status = -1;
static int hf_lapd_checksum_bad = -1;
static gint ett_lapd = -1; static gint ett_lapd = -1;
static gint ett_lapd_address = -1; static gint ett_lapd_address = -1;
@ -417,10 +416,10 @@ dissect_lapd(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_
static void static void
dissect_lapd_full(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolean has_crc) dissect_lapd_full(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolean has_crc)
{ {
proto_tree *lapd_tree, *addr_tree, *checksum_tree; proto_tree *lapd_tree, *addr_tree;
proto_item *lapd_ti, *addr_ti, *checksum_ti; proto_item *lapd_ti, *addr_ti;
int direction; int direction;
guint16 control, checksum, checksum_calculated; guint16 control;
int lapd_header_len, checksum_offset; int lapd_header_len, checksum_offset;
guint16 addr, cr, sapi, tei; guint16 addr, cr, sapi, tei;
gboolean is_response = 0; gboolean is_response = 0;
@ -543,25 +542,9 @@ dissect_lapd_full(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolean
/* check checksum */ /* check checksum */
checksum_offset = tvb_reported_length(tvb) - 2; checksum_offset = tvb_reported_length(tvb) - 2;
checksum = tvb_get_guint8(tvb, checksum_offset); /* high byte */
checksum <<= 8;
checksum |= tvb_get_guint8(tvb, checksum_offset+1) & 0x00FF; /* low byte */
checksum_calculated = crc16_ccitt_tvb(tvb, tvb_reported_length(tvb) - 2);
checksum_calculated = g_htons(checksum_calculated); /* Note: g_htons() macro may eval arg multiple times */
if (checksum == checksum_calculated) { proto_tree_add_checksum(lapd_tree, tvb, checksum_offset, hf_lapd_checksum, hf_lapd_checksum_status, &ei_lapd_checksum_bad, pinfo,
checksum_ti = proto_tree_add_uint_format_value(lapd_tree, hf_lapd_checksum, tvb, checksum_offset, 2, 0,"0x%04x [correct]", checksum); crc16_ccitt_tvb(tvb, tvb_reported_length(tvb) - 2), ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
checksum_tree = proto_item_add_subtree(checksum_ti, ett_lapd_checksum);
proto_tree_add_boolean(checksum_tree, hf_lapd_checksum_good, tvb, checksum_offset, 2, TRUE);
proto_tree_add_boolean(checksum_tree, hf_lapd_checksum_bad, tvb, checksum_offset, 2, FALSE);
} else {
proto_item *pi;
checksum_ti = proto_tree_add_uint_format_value(lapd_tree, hf_lapd_checksum, tvb, checksum_offset, 2, 0,"0x%04x [incorrect, should be 0x%04x]", checksum, checksum_calculated);
checksum_tree = proto_item_add_subtree(checksum_ti, ett_lapd_checksum);
proto_tree_add_boolean(checksum_tree, hf_lapd_checksum_good, tvb, checksum_offset, 2, FALSE);
pi = proto_tree_add_boolean(checksum_tree, hf_lapd_checksum_bad, tvb, checksum_offset, 2, TRUE);
expert_add_info(pinfo, pi, &ei_lapd_checksum_bad);
}
next_tvb = tvb_new_subset_length(tvb, lapd_header_len, tvb_reported_length_remaining(tvb,lapd_header_len) - 2); next_tvb = tvb_new_subset_length(tvb, lapd_header_len, tvb_reported_length_remaining(tvb,lapd_header_len) - 2);
@ -702,13 +685,9 @@ proto_register_lapd(void)
{ "Checksum", "lapd.checksum", FT_UINT16, BASE_HEX, { "Checksum", "lapd.checksum", FT_UINT16, BASE_HEX,
NULL, 0x0, "Details at: http://www.wireshark.org/docs/wsug_html_chunked/ChAdvChecksums.html", HFILL }}, NULL, 0x0, "Details at: http://www.wireshark.org/docs/wsug_html_chunked/ChAdvChecksums.html", HFILL }},
{ &hf_lapd_checksum_good, { &hf_lapd_checksum_status,
{ "Good Checksum", "lapd.checksum_good", FT_BOOLEAN, BASE_NONE, { "Checksum Status", "lapd.checksum.status", FT_UINT8, BASE_NONE,
NULL, 0x0, "True: checksum matches packet content; False: doesn't match content or not checked", HFILL }}, VALS(proto_checksum_vals), 0x0, NULL, HFILL }},
{ &hf_lapd_checksum_bad,
{ "Bad Checksum", "lapd.checksum_bad", FT_BOOLEAN, BASE_NONE,
NULL, 0x0, "True: checksum doesn't match packet content; False: matches content or not checked", HFILL }},
}; };
static gint *ett[] = { static gint *ett[] = {
&ett_lapd, &ett_lapd,

19
epan/dissectors/packet-lmp.c
View File

@ -707,7 +707,6 @@ dissect_lmp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
proto_item *hidden_item, *msg_item; proto_item *hidden_item, *msg_item;
guint8 message_type; guint8 message_type;
guint16 cksum, computed_cksum;
vec_t cksum_vec[1]; vec_t cksum_vec[1];
int j, k, l, len; int j, k, l, len;
int msg_length; int msg_length;
@ -759,24 +758,16 @@ dissect_lmp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
} }
if (lmp_checksum_config) { if (lmp_checksum_config) {
cksum = tvb_get_ntohs(tvb, offset+6);
ti = proto_tree_add_item(lmp_header_tree, hf_lmp_filter[LMPF_CHECKSUM], tvb,
offset+6, 2, ENC_BIG_ENDIAN);
if (!pinfo->fragmented && (int) tvb_captured_length(tvb) >= msg_length) { if (!pinfo->fragmented && (int) tvb_captured_length(tvb) >= msg_length) {
/* The packet isn't part of a fragmented datagram and isn't truncated, so we can checksum it. */ /* The packet isn't part of a fragmented datagram and isn't truncated, so we can checksum it. */
SET_CKSUM_VEC_TVB(cksum_vec[0], tvb, 0, msg_length); SET_CKSUM_VEC_TVB(cksum_vec[0], tvb, 0, msg_length);
computed_cksum = in_cksum(cksum_vec, 1); proto_tree_add_checksum(lmp_header_tree, tvb, offset+6, hf_lmp_filter[LMPF_CHECKSUM], -1, &ei_lmp_checksum_incorrect, pinfo,
in_cksum(cksum_vec, 1), ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_IN_CKSUM);
if (computed_cksum == 0) { } else {
proto_item_append_text( ti, " [correct]"); proto_tree_add_checksum(lmp_header_tree, tvb, offset+6, hf_lmp_filter[LMPF_CHECKSUM], -1, &ei_lmp_checksum_incorrect, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
}
else {
expert_add_info_format(pinfo, ti, &ei_lmp_checksum_incorrect, "[incorrect, should be 0x%04x]",
in_cksum_shouldbe(cksum, computed_cksum));
}
} }
} else { } else {
proto_tree_add_uint_format_value(lmp_header_tree, hf_lmp_filter[LMPF_CHECKSUM], tvb, offset+6, 2, 0, "[None]"); proto_tree_add_checksum(lmp_header_tree, tvb, offset+6, hf_lmp_filter[LMPF_CHECKSUM], -1, &ei_lmp_checksum_incorrect, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NOT_PRESENT);
} }
offset += 8; offset += 8;

4
epan/dissectors/packet-manolito.c
View File

@ -90,8 +90,8 @@ dissect_manolito(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* diss
manolito_tree = proto_item_add_subtree(ti, ett_manolito); manolito_tree = proto_item_add_subtree(ti, ett_manolito);
/* MANOLITO packet header (network byte order) */ /* MANOLITO packet header (network byte order) */
proto_tree_add_item(manolito_tree, proto_tree_add_checksum(manolito_tree, tvb, offset, hf_manolito_checksum,
hf_manolito_checksum, tvb, offset, 4, ENC_BIG_ENDIAN); -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
offset += 4; offset += 4;
proto_tree_add_item(manolito_tree, proto_tree_add_item(manolito_tree,
hf_manolito_seqno, tvb, offset, 4, ENC_BIG_ENDIAN); hf_manolito_seqno, tvb, offset, 4, ENC_BIG_ENDIAN);

13
epan/dissectors/packet-mbtcp.c
View File

@ -517,14 +517,14 @@ static int
dissect_mbrtu_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) dissect_mbrtu_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
{ {
/* Set up structures needed to add the protocol subtree and manage it */ /* Set up structures needed to add the protocol subtree and manage it */
proto_item *mi, *crc_item; proto_item *mi;
proto_tree *mbrtu_tree; proto_tree *mbrtu_tree;
int offset, packet_type; int offset, packet_type;
tvbuff_t *next_tvb; tvbuff_t *next_tvb;
const char *func_string = ""; const char *func_string = "";
const char *pkt_type_str = ""; const char *pkt_type_str = "";
const char *err_str = ""; const char *err_str = "";
guint16 len, crc16, calc_crc16; guint16 len, calc_crc16;
guint8 unit_id, function_code, exception_code, subfunction_code; guint8 unit_id, function_code, exception_code, subfunction_code;
/* Make entries in Protocol column on summary display */ /* Make entries in Protocol column on summary display */
@ -535,7 +535,6 @@ dissect_mbrtu_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* dat
unit_id = tvb_get_guint8(tvb, 0); unit_id = tvb_get_guint8(tvb, 0);
function_code = tvb_get_guint8(tvb, 1) & 0x7F; function_code = tvb_get_guint8(tvb, 1) & 0x7F;
crc16 = tvb_get_ntohs(tvb, len-2);
offset = 0; offset = 0;
@ -618,14 +617,16 @@ dissect_mbrtu_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* dat
/* Add items to protocol tree specific to Modbus RTU */ /* Add items to protocol tree specific to Modbus RTU */
proto_tree_add_uint(mbrtu_tree, hf_mbrtu_unitid, tvb, offset, 1, unit_id); proto_tree_add_uint(mbrtu_tree, hf_mbrtu_unitid, tvb, offset, 1, unit_id);
crc_item = proto_tree_add_uint(mbrtu_tree, hf_mbrtu_crc16, tvb, len-2, 2, crc16);
/* CRC validation */ /* CRC validation */
if (mbrtu_crc) if (mbrtu_crc)
{ {
calc_crc16 = crc16_plain_tvb_offset_seed(tvb, offset, len-2, 0xFFFF); calc_crc16 = crc16_plain_tvb_offset_seed(tvb, offset, len-2, 0xFFFF);
if (g_htons(calc_crc16) != crc16) proto_tree_add_checksum(mbrtu_tree, tvb, len-2, hf_mbrtu_crc16, -1, &ei_mbrtu_crc16_incorrect, pinfo, g_htons(calc_crc16), ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
expert_add_info_format(pinfo, crc_item, &ei_mbrtu_crc16_incorrect, "Incorrect CRC - should be 0x%04x", g_htons(calc_crc16)); }
else
{
proto_tree_add_checksum(mbrtu_tree, tvb, len-2, hf_mbrtu_crc16, -1, &ei_mbrtu_crc16_incorrect, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
} }
/* when determining payload length, make sure to ignore the unit ID header & CRC-16 footer bytes */ /* when determining payload length, make sure to ignore the unit ID header & CRC-16 footer bytes */

4
epan/dissectors/packet-mip6.c
View File

@ -4093,8 +4093,8 @@ dissect_mip6(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_
proto_tree_add_item(mip6_tree, hf_mip6_reserved, tvb, proto_tree_add_item(mip6_tree, hf_mip6_reserved, tvb,
MIP6_RES_OFF, 1, ENC_BIG_ENDIAN); MIP6_RES_OFF, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(mip6_tree, hf_mip6_csum, tvb, proto_tree_add_checksum(mip6_tree, tvb, MIP6_CSUM_OFF, hf_mip6_csum,
MIP6_CSUM_OFF, 2, ENC_BIG_ENDIAN); -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
/* Process mobility header */ /* Process mobility header */
type = tvb_get_guint8(tvb, MIP6_TYPE_OFF); type = tvb_get_guint8(tvb, MIP6_TYPE_OFF);

4
epan/dissectors/packet-mpeg-dsmcc.c
View File

@ -800,8 +800,8 @@ dissect_dsmcc_ts(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree_in, void *d
} }
} else { } else {
/* TODO: actually check the checksum */ /* TODO: actually check the checksum */
proto_tree_add_item(tree, hf_dsmcc_checksum, tvb, proto_tree_add_checksum(tree, tvb, crc_len, hf_dsmcc_checksum,
crc_len, 4, ENC_BIG_ENDIAN); -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
} }
return tvb_reported_length(tvb); return tvb_reported_length(tvb);

35
epan/dissectors/packet-mpeg-sect.c
View File

@ -37,6 +37,7 @@ static int hf_mpeg_sect_syntax_indicator = -1;
static int hf_mpeg_sect_reserved = -1; static int hf_mpeg_sect_reserved = -1;
static int hf_mpeg_sect_length = -1; static int hf_mpeg_sect_length = -1;
static int hf_mpeg_sect_crc = -1; static int hf_mpeg_sect_crc = -1;
static int hf_mpeg_sect_crc_status = -1;
static gint ett_mpeg_sect = -1; static gint ett_mpeg_sect = -1;
@ -247,30 +248,12 @@ guint
packet_mpeg_sect_crc(tvbuff_t *tvb, packet_info *pinfo, packet_mpeg_sect_crc(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, guint start, guint end) proto_tree *tree, guint start, guint end)
{ {
guint32 crc, calculated_crc;
const char *label;
crc = tvb_get_ntohl(tvb, end);
calculated_crc = crc;
label = "Unverified";
if (mpeg_sect_check_crc) { if (mpeg_sect_check_crc) {
label = "Verified"; proto_tree_add_checksum(tree, tvb, end, hf_mpeg_sect_crc, hf_mpeg_sect_crc_status, &ei_mpeg_sect_crc, pinfo, crc32_mpeg2_tvb_offset(tvb, start, end),
calculated_crc = crc32_mpeg2_tvb_offset(tvb, start, end); ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
}
if (calculated_crc == crc) {
proto_tree_add_uint_format( tree, hf_mpeg_sect_crc, tvb,
end, 4, crc, "CRC: 0x%08x [%s]", crc, label);
} else { } else {
proto_item *msg_error; proto_tree_add_checksum(tree, tvb, end, hf_mpeg_sect_crc, hf_mpeg_sect_crc_status, &ei_mpeg_sect_crc, pinfo, crc32_mpeg2_tvb_offset(tvb, start, end),
ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
msg_error = proto_tree_add_uint_format( tree, hf_mpeg_sect_crc, tvb,
end, 4, crc,
"CRC: 0x%08x [Failed Verification (Calculated: 0x%08x)]",
crc, calculated_crc );
PROTO_ITEM_SET_GENERATED(msg_error);
expert_add_info( pinfo, msg_error, &ei_mpeg_sect_crc);
} }
return 4; return 4;
@ -348,7 +331,13 @@ proto_register_mpeg_sect(void)
{ &hf_mpeg_sect_crc, { { &hf_mpeg_sect_crc, {
"CRC 32", "mpeg_sect.crc", "CRC 32", "mpeg_sect.crc",
FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL
} } } },
{ &hf_mpeg_sect_crc_status, {
"CRC 32 Status", "mpeg_sect.crc.status",
FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0, NULL, HFILL
} },
}; };
static gint *ett[] = { static gint *ett[] = {

12
epan/dissectors/packet-mrdisc.c
View File

@ -46,7 +46,7 @@ void proto_reg_handoff_mrdisc(void);
static int proto_mrdisc = -1; static int proto_mrdisc = -1;
static int hf_checksum = -1; static int hf_checksum = -1;
static int hf_checksum_bad = -1; static int hf_checksum_status = -1;
static int hf_type = -1; static int hf_type = -1;
static int hf_advint = -1; static int hf_advint = -1;
static int hf_numopts = -1; static int hf_numopts = -1;
@ -91,7 +91,7 @@ dissect_mrdisc_mra(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, i
offset += 1; offset += 1;
/* checksum */ /* checksum */
igmp_checksum(parent_tree, tvb, hf_checksum, hf_checksum_bad, pinfo, 0); igmp_checksum(parent_tree, tvb, hf_checksum, hf_checksum_status, pinfo, 0);
offset += 2; offset += 2;
/* skip unused bytes */ /* skip unused bytes */
@ -160,7 +160,7 @@ dissect_mrdisc_mrst(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree,
offset += 1; offset += 1;
/* checksum */ /* checksum */
igmp_checksum(parent_tree, tvb, hf_checksum, hf_checksum_bad, pinfo, 0); igmp_checksum(parent_tree, tvb, hf_checksum, hf_checksum_status, pinfo, 0);
offset += 2; offset += 2;
return offset; return offset;
@ -222,9 +222,9 @@ proto_register_mrdisc(void)
{ "Checksum", "mrdisc.checksum", FT_UINT16, BASE_HEX, { "Checksum", "mrdisc.checksum", FT_UINT16, BASE_HEX,
NULL, 0, "MRDISC Checksum", HFILL }}, NULL, 0, "MRDISC Checksum", HFILL }},
{ &hf_checksum_bad, { &hf_checksum_status,
{ "Bad Checksum", "mrdisc.checksum_bad", FT_BOOLEAN, BASE_NONE, { "Checksum Status", "mrdisc.checksum.status", FT_UINT8, BASE_NONE,
NULL, 0x0, "Bad MRDISC Checksum", HFILL }}, VALS(proto_checksum_vals), 0x0, NULL, HFILL }},
{ &hf_advint, { &hf_advint,
{ "Advertising Interval", "mrdisc.adv_int", FT_UINT8, BASE_DEC, { "Advertising Interval", "mrdisc.adv_int", FT_UINT8, BASE_DEC,

14
epan/dissectors/packet-msnip.c
View File

@ -44,7 +44,7 @@ void proto_reg_handoff_msnip(void);
static int proto_msnip = -1; static int proto_msnip = -1;
static int hf_checksum = -1; static int hf_checksum = -1;
static int hf_checksum_bad = -1; static int hf_checksum_status = -1;
static int hf_type = -1; static int hf_type = -1;
static int hf_count = -1; static int hf_count = -1;
static int hf_holdtime = -1; static int hf_holdtime = -1;
@ -89,7 +89,7 @@ dissect_msnip_rmr(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, in
offset += 1; offset += 1;
/* checksum */ /* checksum */
igmp_checksum(parent_tree, tvb, hf_checksum, hf_checksum_bad, pinfo, 0); igmp_checksum(parent_tree, tvb, hf_checksum, hf_checksum_status, pinfo, 0);
offset += 2; offset += 2;
while (count--) { while (count--) {
@ -135,7 +135,7 @@ dissect_msnip_is(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, int
offset += 1; offset += 1;
/* checksum */ /* checksum */
igmp_checksum(parent_tree, tvb, hf_checksum, hf_checksum_bad, pinfo, 0); igmp_checksum(parent_tree, tvb, hf_checksum, hf_checksum_status, pinfo, 0);
offset += 2; offset += 2;
/* 16 bit holdtime */ /* 16 bit holdtime */
@ -161,7 +161,7 @@ dissect_msnip_gm(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, int
offset += 1; offset += 1;
/* checksum */ /* checksum */
igmp_checksum(parent_tree, tvb, hf_checksum, hf_checksum_bad, pinfo, 0); igmp_checksum(parent_tree, tvb, hf_checksum, hf_checksum_status, pinfo, 0);
offset += 2; offset += 2;
/* holdtime */ /* holdtime */
@ -264,9 +264,9 @@ proto_register_msnip(void)
{ "Checksum", "msnip.checksum", FT_UINT16, BASE_HEX, { "Checksum", "msnip.checksum", FT_UINT16, BASE_HEX,
NULL, 0, "MSNIP Checksum", HFILL }}, NULL, 0, "MSNIP Checksum", HFILL }},
{ &hf_checksum_bad, { &hf_checksum_status,
{ "Bad Checksum", "msnip.checksum_bad", FT_BOOLEAN, BASE_NONE, { "Checksum Status", "msnip.checksum.status", FT_UINT8, BASE_NONE,
NULL, 0x0, "Bad MSNIP Checksum", HFILL }}, VALS(proto_checksum_vals), 0x0, NULL, HFILL }},
{ &hf_count, { &hf_count,
{ "Count", "msnip.count", FT_UINT8, BASE_DEC, { "Count", "msnip.count", FT_UINT8, BASE_DEC,

97
epan/dissectors/packet-mstp.c
View File

@ -86,8 +86,7 @@ static int hf_mstp_frame_vendor_id = -1;
static int hf_mstp_frame_pdu_len = -1; static int hf_mstp_frame_pdu_len = -1;
static int hf_mstp_frame_crc8 = -1; static int hf_mstp_frame_crc8 = -1;
static int hf_mstp_frame_crc16 = -1; static int hf_mstp_frame_crc16 = -1;
static int hf_mstp_frame_checksum_bad = -1; static int hf_mstp_frame_checksum_status = -1;
static int hf_mstp_frame_checksum_good = -1;
static expert_field ei_mstp_frame_pdu_len = EI_INIT; static expert_field ei_mstp_frame_pdu_len = EI_INIT;
static expert_field ei_mstp_frame_checksum_bad = EI_INIT; static expert_field ei_mstp_frame_checksum_bad = EI_INIT;
@ -190,12 +189,11 @@ dissect_mstp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
proto_item *item; proto_item *item;
#if defined(BACNET_MSTP_CHECKSUM_VALIDATE) #if defined(BACNET_MSTP_CHECKSUM_VALIDATE)
/* used to calculate the crc value */ /* used to calculate the crc value */
guint8 crc8 = 0xFF, framecrc8; guint8 crc8 = 0xFF;
guint16 crc16 = 0xFFFF, framecrc16; guint16 crc16 = 0xFFFF;
guint8 crcdata; guint8 crcdata;
guint16 i; /* loop counter */ guint16 i; /* loop counter */
guint16 max_len = 0; guint16 max_len = 0;
proto_tree *checksum_tree;
#endif #endif
col_set_str(pinfo->cinfo, COL_PROTOCOL, "BACnet"); col_set_str(pinfo->cinfo, COL_PROTOCOL, "BACnet");
@ -228,39 +226,11 @@ dissect_mstp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
crc8 = CRC_Calc_Header(crcdata, crc8); crc8 = CRC_Calc_Header(crcdata, crc8);
} }
crc8 = ~crc8; crc8 = ~crc8;
framecrc8 = tvb_get_guint8(tvb, offset+5); proto_tree_add_checksum(subtree, tvb, offset+5, hf_mstp_frame_crc8, hf_mstp_frame_checksum_status, &ei_mstp_frame_checksum_bad, pinfo, crc8,
if (framecrc8 == crc8) { ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
item = proto_tree_add_uint_format_value(subtree, hf_mstp_frame_crc8,
tvb, offset+5, 1, framecrc8,
"0x%02x [correct]", framecrc8);
checksum_tree = proto_item_add_subtree(item, ett_bacnet_mstp_checksum);
item = proto_tree_add_boolean(checksum_tree,
hf_mstp_frame_checksum_good,
tvb, offset+5, 1, TRUE);
PROTO_ITEM_SET_GENERATED(item);
item = proto_tree_add_boolean(checksum_tree,
hf_mstp_frame_checksum_bad,
tvb, offset+5, 1, FALSE);
PROTO_ITEM_SET_GENERATED(item);
} else {
item = proto_tree_add_uint_format_value(subtree, hf_mstp_frame_crc8,
tvb, offset+5, 1, framecrc8,
"0x%02x [incorrect, should be 0x%02x]",
framecrc8, crc8);
checksum_tree = proto_item_add_subtree(item, ett_bacnet_mstp_checksum);
item = proto_tree_add_boolean(checksum_tree,
hf_mstp_frame_checksum_good,
tvb, offset+5, 1, FALSE);
PROTO_ITEM_SET_GENERATED(item);
item = proto_tree_add_boolean(checksum_tree,
hf_mstp_frame_checksum_bad,
tvb, offset+5, 1, TRUE);
PROTO_ITEM_SET_GENERATED(item);
expert_add_info(pinfo, item, &ei_mstp_frame_checksum_bad);
}
#else #else
proto_tree_add_item(subtree, hf_mstp_frame_crc8, proto_tree_add_checksum(subtree, tvb, offset+5, hf_mstp_frame_crc8, hf_mstp_frame_checksum_status, &ei_mstp_frame_checksum_bad, pinfo, 0,
tvb, offset+5, 1, ENC_LITTLE_ENDIAN); PROTO_CHECKSUM_NO_FLAGS);
#endif #endif
/* dissect BACnet PDU if there is one */ /* dissect BACnet PDU if there is one */
@ -300,42 +270,12 @@ dissect_mstp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
crc16 = ~crc16; crc16 = ~crc16;
/* convert it to on-the-wire format */ /* convert it to on-the-wire format */
crc16 = g_htons(crc16); crc16 = g_htons(crc16);
/* get the actual CRC from the frame */
framecrc16 = tvb_get_ntohs(tvb, offset+mstp_frame_pdu_len); proto_tree_add_checksum(subtree, tvb, offset+mstp_frame_pdu_len, hf_mstp_frame_crc16, hf_mstp_frame_checksum_status, &ei_mstp_frame_checksum_bad, pinfo, crc16,
if (framecrc16 == crc16) { ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
item = proto_tree_add_uint_format_value(subtree, hf_mstp_frame_crc16,
tvb, offset+mstp_frame_pdu_len, 2, framecrc16,
"0x%04x [correct]", framecrc16);
checksum_tree = proto_item_add_subtree(item,
ett_bacnet_mstp_checksum);
item = proto_tree_add_boolean(checksum_tree,
hf_mstp_frame_checksum_good,
tvb, offset+mstp_frame_pdu_len, 2, TRUE);
PROTO_ITEM_SET_GENERATED(item);
item = proto_tree_add_boolean(checksum_tree,
hf_mstp_frame_checksum_bad,
tvb, offset+mstp_frame_pdu_len, 2, FALSE);
PROTO_ITEM_SET_GENERATED(item);
} else {
item = proto_tree_add_uint_format_value(subtree, hf_mstp_frame_crc16,
tvb, offset+mstp_frame_pdu_len, 2, framecrc16,
"0x%04x [incorrect, should be 0x%04x]",
framecrc16, crc16);
checksum_tree = proto_item_add_subtree(item,
ett_bacnet_mstp_checksum);
item = proto_tree_add_boolean(checksum_tree,
hf_mstp_frame_checksum_good,
tvb, offset+mstp_frame_pdu_len, 2, FALSE);
PROTO_ITEM_SET_GENERATED(item);
item = proto_tree_add_boolean(checksum_tree,
hf_mstp_frame_checksum_bad,
tvb, offset+mstp_frame_pdu_len, 2, TRUE);
PROTO_ITEM_SET_GENERATED(item);
expert_add_info(pinfo, item, &ei_mstp_frame_checksum_bad);
}
#else #else
proto_tree_add_item(subtree, hf_mstp_frame_crc16, proto_tree_add_checksum(subtree, tvb, offset+mstp_frame_pdu_len, hf_mstp_frame_crc16, hf_mstp_frame_checksum_status, &ei_mstp_frame_checksum_bad, pinfo, 0,
tvb, offset+mstp_frame_pdu_len, 2, ENC_LITTLE_ENDIAN); ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
#endif #endif
} }
} }
@ -427,16 +367,11 @@ proto_register_mstp(void)
FT_UINT16, BASE_HEX, NULL, 0, FT_UINT16, BASE_HEX, NULL, 0,
"MS/TP Data CRC", HFILL } "MS/TP Data CRC", HFILL }
}, },
{ &hf_mstp_frame_checksum_bad, { &hf_mstp_frame_checksum_status,
{ "Bad", "mstp.checksum_bad", { "Checksum status", "mstp.checksum.status",
FT_BOOLEAN, BASE_NONE, NULL, 0x0, FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0,
"True: checksum doesn't match packet content; False: matches content or not checked", HFILL } NULL, HFILL }
}, },
{ &hf_mstp_frame_checksum_good,
{ "Good", "mstp.checksum_good",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"True: checksum matches packet content; False: doesn't match content or not checked", HFILL }
}
}; };
static gint *ett[] = { static gint *ett[] = {

3
epan/dissectors/packet-mswsp.c
View File

@ -6324,8 +6324,7 @@ dissect_mswsp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolean in,
"(Unknown: 0x%x)")); "(Unknown: 0x%x)"));
} }
proto_tree_add_item(hdr_tree, hf_mswsp_hdr_checksum, tvb, proto_tree_add_checksum(hdr_tree, tvb, 8, hf_mswsp_hdr_checksum, -1, NULL, pinfo, 0, ENC_LITTLE_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
8, 4, ENC_LITTLE_ENDIAN);
/* todo: validate checksum */ /* todo: validate checksum */
proto_tree_add_item(hdr_tree, hf_mswsp_hdr_reserved, tvb, proto_tree_add_item(hdr_tree, hf_mswsp_hdr_reserved, tvb,

16
epan/dissectors/packet-mtp2.c
View File

@ -148,11 +148,7 @@ mtp2_decode_crc16(tvbuff_t *tvb, proto_tree *fh_tree, packet_info *pinfo)
{ {
tvbuff_t *next_tvb; tvbuff_t *next_tvb;
gint len, reported_len; gint len, reported_len;
int rx_fcs_offset;
guint32 rx_fcs_exp;
guint32 rx_fcs_got;
int proto_offset=0; int proto_offset=0;
proto_item *cause;
/* /*
* Do we have the entire packet, and does it include a 2-byte FCS? * Do we have the entire packet, and does it include a 2-byte FCS?
@ -191,16 +187,8 @@ mtp2_decode_crc16(tvbuff_t *tvb, proto_tree *fh_tree, packet_info *pinfo)
/* /*
* Compute the FCS and put it into the tree. * Compute the FCS and put it into the tree.
*/ */
rx_fcs_offset = proto_offset + len; proto_tree_add_checksum(fh_tree, tvb, proto_offset + len, hf_mtp2_fcs_16, -1, &ei_mtp2_checksum_error, pinfo, mtp2_fcs16(tvb),
rx_fcs_exp = mtp2_fcs16(tvb); ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
rx_fcs_got = tvb_get_letohs(tvb, rx_fcs_offset);
cause=proto_tree_add_item(fh_tree, hf_mtp2_fcs_16, tvb, rx_fcs_offset, 2, ENC_LITTLE_ENDIAN);
if (rx_fcs_got != rx_fcs_exp) {
proto_item_append_text(cause, " [incorrect, should be 0x%04x]", rx_fcs_exp);
expert_add_info(pinfo, cause, &ei_mtp2_checksum_error);
} else {
proto_item_append_text(cause, " [correct]");
}
} }
return next_tvb; return next_tvb;
} }

4
epan/dissectors/packet-netsync.c
View File

@ -535,8 +535,8 @@ dissect_netsync_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* d
offset += size; offset += size;
proto_tree_add_item(netsync_tree, hf_netsync_checksum, tvb, proto_tree_add_checksum(netsync_tree, tvb, offset, hf_netsync_checksum,
offset, 4, ENC_BIG_ENDIAN ); -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS );
offset += 4; offset += 4;

27
epan/dissectors/packet-nhrp.c
View File

@ -282,14 +282,6 @@ typedef struct _e_nhrp {
guint8 ar_sstl; guint8 ar_sstl;
} e_nhrp_hdr; } e_nhrp_hdr;
static guint16 nhrp_checksum(tvbuff_t *tvb, int len)
{
vec_t cksum_vec[1];
SET_CKSUM_VEC_TVB(cksum_vec[0], tvb, 0, len);
return in_cksum(&cksum_vec[0], 1);
}
static void dissect_nhrp_hdr(tvbuff_t *tvb, static void dissect_nhrp_hdr(tvbuff_t *tvb,
packet_info *pinfo, packet_info *pinfo,
proto_tree *tree, proto_tree *tree,
@ -302,7 +294,6 @@ static void dissect_nhrp_hdr(tvbuff_t *tvb,
gint offset = *pOffset; gint offset = *pOffset;
const gchar *pro_type_str; const gchar *pro_type_str;
guint total_len = tvb_reported_length(tvb); guint total_len = tvb_reported_length(tvb);
guint16 ipcsum, rx_chksum;
proto_tree *nhrp_tree; proto_tree *nhrp_tree;
proto_item *shtl_tree_item; proto_item *shtl_tree_item;
@ -379,20 +370,14 @@ static void dissect_nhrp_hdr(tvbuff_t *tvb,
proto_tree_add_item(nhrp_tree, hf_nhrp_hdr_pktsz, tvb, offset, 2, ENC_BIG_ENDIAN); proto_tree_add_item(nhrp_tree, hf_nhrp_hdr_pktsz, tvb, offset, 2, ENC_BIG_ENDIAN);
offset += 2; offset += 2;
rx_chksum = tvb_get_ntohs(tvb, offset);
if (tvb_bytes_exist(tvb, 0, total_len)) { if (tvb_bytes_exist(tvb, 0, total_len)) {
ipcsum = nhrp_checksum(tvb, total_len); vec_t cksum_vec[1];
if (ipcsum == 0) { SET_CKSUM_VEC_TVB(cksum_vec[0], tvb, 0, total_len);
proto_tree_add_uint_format_value(nhrp_tree, hf_nhrp_hdr_chksum, tvb, offset, 2, rx_chksum,
"0x%04x [correct]", rx_chksum); proto_tree_add_checksum(nhrp_tree, tvb, offset, hf_nhrp_hdr_chksum, -1, NULL, pinfo, in_cksum(&cksum_vec[0], 1),
} else { ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_IN_CKSUM);
proto_tree_add_uint_format_value(nhrp_tree, hf_nhrp_hdr_chksum, tvb, offset, 2, rx_chksum,
"0x%04x [incorrect, should be 0x%04x]", rx_chksum,
in_cksum_shouldbe(rx_chksum, ipcsum));
}
} else { } else {
proto_tree_add_uint_format_value(nhrp_tree, hf_nhrp_hdr_chksum, tvb, offset, 2, rx_chksum, proto_tree_add_checksum(nhrp_tree, tvb, offset, hf_nhrp_hdr_chksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
"0x%04x [not all data available]", rx_chksum);
} }
offset += 2; offset += 2;

8
epan/dissectors/packet-nlsp.c
View File

@ -945,9 +945,7 @@ nlsp_dissect_nlsp_lsp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
offset += 4; offset += 4;
/* XXX -> we could validate the cksum here! */ /* XXX -> we could validate the cksum here! */
proto_tree_add_item(tree, hf_nlsp_lsp_checksum, tvb, proto_tree_add_checksum(tree, tvb, offset, hf_nlsp_lsp_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
offset, 2, ENC_BIG_ENDIAN );
offset += 2; offset += 2;
if (tree) { if (tree) {
@ -1027,7 +1025,7 @@ dissect_csnp_lsp_entries(tvbuff_t *tvb, packet_info* pinfo, proto_tree *tree, in
proto_tree_add_uint_format_value(subtree, hf_nlsp_csnp_remaining_lifetime, tvb, offset, 2, proto_tree_add_uint_format_value(subtree, hf_nlsp_csnp_remaining_lifetime, tvb, offset, 2,
tvb_get_ntohs(tvb, offset), "%us", tvb_get_ntohs(tvb, offset)); tvb_get_ntohs(tvb, offset), "%us", tvb_get_ntohs(tvb, offset));
proto_tree_add_item(subtree, hf_nlsp_csnp_lsp_checksum, tvb, offset+14, 2, ENC_BIG_ENDIAN); proto_tree_add_checksum(subtree, tvb, offset+14, hf_nlsp_csnp_lsp_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
length -= 16; length -= 16;
offset += 16; offset += 16;
@ -1063,7 +1061,7 @@ dissect_psnp_lsp_entries(tvbuff_t *tvb, packet_info* pinfo, proto_tree *tree, in
proto_tree_add_uint_format_value(subtree, hf_nlsp_psnp_remaining_lifetime, tvb, offset, 2, proto_tree_add_uint_format_value(subtree, hf_nlsp_psnp_remaining_lifetime, tvb, offset, 2,
tvb_get_ntohs(tvb, offset), "%us", tvb_get_ntohs(tvb, offset)); tvb_get_ntohs(tvb, offset), "%us", tvb_get_ntohs(tvb, offset));
proto_tree_add_item(subtree, hf_nlsp_psnp_lsp_checksum, tvb, offset+14, 2, ENC_BIG_ENDIAN); proto_tree_add_checksum(subtree, tvb, offset+14, hf_nlsp_psnp_lsp_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
length -= 16; length -= 16;
offset += 16; offset += 16;

4
epan/dissectors/packet-nsrp.c
View File

@ -243,7 +243,7 @@ dissect_nsrp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_
proto_tree_add_item(nsrp_tree, hf_nsrp_no_used, tvb, offset, 2, ENC_BIG_ENDIAN); proto_tree_add_item(nsrp_tree, hf_nsrp_no_used, tvb, offset, 2, ENC_BIG_ENDIAN);
offset += 2; offset += 2;
proto_tree_add_item(nsrp_tree, hf_nsrp_checksum, tvb, offset, 2, ENC_BIG_ENDIAN); proto_tree_add_checksum(nsrp_tree, tvb, offset, hf_nsrp_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
offset += 2; offset += 2;
proto_tree_add_item(nsrp_tree, hf_nsrp_data, tvb, offset, -1, ENC_ASCII|ENC_NA); proto_tree_add_item(nsrp_tree, hf_nsrp_data, tvb, offset, -1, ENC_ASCII|ENC_NA);
@ -293,7 +293,7 @@ dissect_nsrp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_
proto_tree_add_item(nsrp_tree, hf_nsrp_dummy, tvb, offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(nsrp_tree, hf_nsrp_dummy, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1; offset += 1;
proto_tree_add_item(nsrp_tree, hf_nsrp_authchecksum, tvb, offset, 2, ENC_BIG_ENDIAN); proto_tree_add_checksum(nsrp_tree, tvb, offset, hf_nsrp_authchecksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
offset += 2; offset += 2;
proto_tree_add_item(nsrp_tree, hf_nsrp_data, tvb, offset, -1, ENC_ASCII|ENC_NA); proto_tree_add_item(nsrp_tree, hf_nsrp_data, tvb, offset, -1, ENC_ASCII|ENC_NA);

71
epan/dissectors/packet-osi.c
View File

@ -52,23 +52,18 @@ static dissector_handle_t osi_handle;
static gboolean tpkt_desegment = FALSE; static gboolean tpkt_desegment = FALSE;
static guint global_tcp_port_osi_over_tpkt = 0; static guint global_tcp_port_osi_over_tpkt = 0;
cksum_status_t gboolean
calc_checksum( tvbuff_t *tvb, int offset, guint len, guint checksum) { osi_calc_checksum( tvbuff_t *tvb, int offset, guint len, guint32* c0, guint32* c1) {
const gchar *buffer;
guint available_len; guint available_len;
const guint8 *p; const guint8 *p;
guint32 c0, c1;
guint seglen; guint seglen;
guint i; guint i;
if ( 0 == checksum )
return( NO_CKSUM );
available_len = tvb_captured_length_remaining( tvb, offset ); available_len = tvb_captured_length_remaining( tvb, offset );
if ( available_len < len ) if ( available_len < len )
return( DATA_MISSING ); return FALSE;
buffer = tvb_get_ptr( tvb, offset, len ); p = tvb_get_ptr( tvb, offset, len );
/* /*
* The maximum values of c0 and c1 will occur if all bytes have the * The maximum values of c0 and c1 will occur if all bytes have the
@ -81,33 +76,29 @@ calc_checksum( tvbuff_t *tvb, int offset, guint len, guint checksum) {
* we can solve this by taking c0 and c1 mod 255 every * we can solve this by taking c0 and c1 mod 255 every
* 5803 bytes. * 5803 bytes.
*/ */
p = buffer; *c0 = 0;
c0 = 0; *c1 = 0;
c1 = 0;
while (len != 0) { while (len != 0) {
seglen = len; seglen = len;
if (seglen > 5803) if (seglen > 5803)
seglen = 5803; seglen = 5803;
for (i = 0; i < seglen; i++) { for (i = 0; i < seglen; i++) {
c0 = c0 + *(p++); (*c0) += *(p++);
c1 += c0; (*c1) += (*c0);
} }
c0 = c0 % 255; (*c0) = (*c0) % 255;
c1 = c1 % 255; (*c1) = (*c1) % 255;
len -= seglen; len -= seglen;
} }
if (c0 != 0 || c1 != 0)
return( CKSUM_NOT_OK ); /* XXX - what should the checksum field be? */ return TRUE;
else
return( CKSUM_OK );
} }
cksum_status_t gboolean
check_and_get_checksum( tvbuff_t *tvb, int offset, guint len, guint checksum, int offset_check, guint16* result) { osi_check_and_get_checksum( tvbuff_t *tvb, int offset, guint len, int offset_check, guint16* result) {
const gchar *buffer;
guint available_len; guint available_len;
const guint8 *p; const guint8 *p;
guint8 discard = 0; guint8 discard = 0;
@ -116,15 +107,12 @@ check_and_get_checksum( tvbuff_t *tvb, int offset, guint len, guint checksum, in
guint i; guint i;
int block, x, y; int block, x, y;
if ( 0 == checksum )
return( NO_CKSUM );
available_len = tvb_captured_length_remaining( tvb, offset ); available_len = tvb_captured_length_remaining( tvb, offset );
offset_check -= offset; offset_check -= offset;
if ( ( available_len < len ) || ( offset_check < 0 ) || ( (guint)(offset_check+2) > len ) ) if ( ( available_len < len ) || ( offset_check < 0 ) || ( (guint)(offset_check+2) > len ) )
return( DATA_MISSING ); return FALSE;
buffer = tvb_get_ptr( tvb, offset, len ); p = tvb_get_ptr( tvb, offset, len );
block = offset_check / 5803; block = offset_check / 5803;
/* /*
@ -138,7 +126,6 @@ check_and_get_checksum( tvbuff_t *tvb, int offset, guint len, guint checksum, in
* we can solve this by taking c0 and c1 mod 255 every * we can solve this by taking c0 and c1 mod 255 every
* 5803 bytes. * 5803 bytes.
*/ */
p = buffer;
c0 = 0; c0 = 0;
c1 = 0; c1 = 0;
@ -189,11 +176,7 @@ check_and_get_checksum( tvbuff_t *tvb, int offset, guint len, guint checksum, in
if (y == 0) y = 0x01; if (y == 0) y = 0x01;
*result = ( x << 8 ) | ( y & 0xFF ); *result = ( x << 8 ) | ( y & 0xFF );
return TRUE;
if (*result != checksum)
return( CKSUM_NOT_OK ); /* XXX - what should the checksum field be? */
else
return( CKSUM_OK );
} }
/* 4 octet ATN extended checksum: ICAO doc 9705 Ed3 Volume V section 5.5.4.6.4 */ /* 4 octet ATN extended checksum: ICAO doc 9705 Ed3 Volume V section 5.5.4.6.4 */
@ -201,7 +184,7 @@ check_and_get_checksum( tvbuff_t *tvb, int offset, guint len, guint checksum, in
/* of length SRC-NSAP, SRC-NSAP, length DST-NSAP, DST-NSAP and ATN extended checksum. */ /* of length SRC-NSAP, SRC-NSAP, length DST-NSAP, DST-NSAP and ATN extended checksum. */
/* In case of a CR TPDU, the value of the ISO 8073 16-bit fletcher checksum parameter shall */ /* In case of a CR TPDU, the value of the ISO 8073 16-bit fletcher checksum parameter shall */
/* be set to zero. */ /* be set to zero. */
gboolean check_atn_ec_32( guint32 check_atn_ec_32(
tvbuff_t *tvb, guint tpdu_len, tvbuff_t *tvb, guint tpdu_len,
guint offset_ec_32_val, /* offset ATN extended checksum value, calculated at last as part of pseudo trailer */ guint offset_ec_32_val, /* offset ATN extended checksum value, calculated at last as part of pseudo trailer */
guint offset_iso8073_val, /* offset ISO 8073 fletcher checksum, CR only*/ guint offset_iso8073_val, /* offset ISO 8073 fletcher checksum, CR only*/
@ -314,12 +297,8 @@ gboolean check_atn_ec_32(
c3 -= 0x000000FF; c3 -= 0x000000FF;
} }
sum = (c3 << 24) + (c2 << 16 ) + (c1 << 8) + c0 ; sum = (c3 << 24) + (c2 << 16 ) + (c1 << 8) + c0;
return sum;
if(!sum)
return TRUE;
else
return FALSE;
} }
/* 2 octet ATN extended checksum: ICAO doc 9705 Ed3 Volume V section 5.5.4.6.4 */ /* 2 octet ATN extended checksum: ICAO doc 9705 Ed3 Volume V section 5.5.4.6.4 */
@ -328,7 +307,7 @@ gboolean check_atn_ec_32(
/* In case of a CR TPDU, the value of the ISO 8073 16-bit fletcher checksum parameter shall */ /* In case of a CR TPDU, the value of the ISO 8073 16-bit fletcher checksum parameter shall */
/* be set to zero. */ /* be set to zero. */
/* this routine is currently *untested* because of the unavailability of samples.*/ /* this routine is currently *untested* because of the unavailability of samples.*/
gboolean check_atn_ec_16( guint16 check_atn_ec_16(
tvbuff_t *tvb, tvbuff_t *tvb,
guint tpdu_len, guint tpdu_len,
guint offset_ec_16_val, /* offset ATN extended checksum value, calculated at last as part of pseudo trailer */ guint offset_ec_16_val, /* offset ATN extended checksum value, calculated at last as part of pseudo trailer */
@ -341,7 +320,7 @@ gboolean check_atn_ec_16(
guint i = 0; guint i = 0;
guint16 c0 = 0; guint16 c0 = 0;
guint16 c1 = 0; guint16 c1 = 0;
guint16 sum = 0; guint16 sum;
/* sum across complete TPDU */ /* sum across complete TPDU */
for ( i =0; i< tpdu_len; i++){ for ( i =0; i< tpdu_len; i++){
@ -405,11 +384,7 @@ gboolean check_atn_ec_16(
} }
sum = (c1 << 8) + c0 ; sum = (c1 << 8) + c0 ;
return sum;
if(!sum)
return TRUE;
else
return FALSE;
} }

15
epan/dissectors/packet-osi.h
View File

@ -57,19 +57,12 @@
* published API functions * published API functions
*/ */
typedef enum {
NO_CKSUM, /* checksum field is 0 */
DATA_MISSING, /* not all the data covered by the checksum was captured */
CKSUM_OK, /* checksum is OK */
CKSUM_NOT_OK /* checksum is not OK */
} cksum_status_t;
/* Exposed to be used by packet-osi-options.c */ /* Exposed to be used by packet-osi-options.c */
extern int proto_osi; extern int proto_osi;
extern cksum_status_t calc_checksum(tvbuff_t *, int, guint, guint); extern gboolean osi_calc_checksum( tvbuff_t *tvb, int offset, guint len, guint32* c0, guint32* c1);
extern cksum_status_t check_and_get_checksum(tvbuff_t *, int, guint, guint, int, guint16*); extern gboolean osi_check_and_get_checksum( tvbuff_t *tvb, int offset, guint len, int offset_check, guint16* result);
extern gboolean check_atn_ec_32(tvbuff_t *tvb, guint tpdu_len, guint offset_ec_32_val, guint offset_iso8073_val, guint clnp_dst_len, const guint8 *clnp_dst, guint clnp_src_len, const guint8 *clnp_src); extern guint32 check_atn_ec_32(tvbuff_t *tvb, guint tpdu_len, guint offset_ec_32_val, guint offset_iso8073_val, guint clnp_dst_len, const guint8 *clnp_dst, guint clnp_src_len, const guint8 *clnp_src);
extern gboolean check_atn_ec_16(tvbuff_t *tvb, guint tpdu_len, guint offset_ec_16_val, guint offset_iso8073_val, guint clnp_dst_len, const guint8 *clnp_dst, guint clnp_src_len, const guint8 *clnp_src); extern guint16 check_atn_ec_16(tvbuff_t *tvb, guint tpdu_len, guint offset_ec_16_val, guint offset_iso8073_val, guint clnp_dst_len, const guint8 *clnp_dst, guint clnp_src_len, const guint8 *clnp_src);
#endif /* _PACKET_OSI_H */ #endif /* _PACKET_OSI_H */

61
epan/dissectors/packet-ositp.c
View File

@ -68,7 +68,8 @@ static int hf_cotp_eot_extended = -1;
static int hf_cotp_parameter_code = -1; static int hf_cotp_parameter_code = -1;
static int hf_cotp_parameter_length = -1; static int hf_cotp_parameter_length = -1;
static int hf_cotp_parameter_value = -1; static int hf_cotp_parameter_value = -1;
static int hf_cotp_atn_extended_checksum = -1; static int hf_cotp_atn_extended_checksum16 = -1;
static int hf_cotp_atn_extended_checksum32 = -1;
static int hf_cotp_ack_time = -1; static int hf_cotp_ack_time = -1;
static int hf_cotp_res_error_rate_target_value = -1; static int hf_cotp_res_error_rate_target_value = -1;
static int hf_cotp_res_error_rate_min_accept = -1; static int hf_cotp_res_error_rate_min_accept = -1;
@ -440,10 +441,8 @@ static gboolean ositp_decode_var_part(tvbuff_t *tvb, int offset, int vp_length,
gint32 i = 0; gint32 i = 0;
guint8 tmp_code = 0; guint8 tmp_code = 0;
guint tmp_len = 0; guint tmp_len = 0;
cksum_status_t cksum_status;
gboolean checksum_ok = FALSE;
guint32 pref_max_tpdu_size; guint32 pref_max_tpdu_size;
proto_item *ti, *hidden_item; proto_item *hidden_item;
while (vp_length != 0) { while (vp_length != 0) {
code = tvb_get_guint8(tvb, offset); code = tvb_get_guint8(tvb, offset);
@ -462,6 +461,7 @@ static gboolean ositp_decode_var_part(tvbuff_t *tvb, int offset, int vp_length,
case VP_ATN_EC_16 : /* ATN */ case VP_ATN_EC_16 : /* ATN */
if (cotp_decode_atn) { if (cotp_decode_atn) {
guint16 sum;
/* if an alternate OSI checksum is present in the currently unprocessed /* if an alternate OSI checksum is present in the currently unprocessed
* VP section to the checksum algorithm has to know. * VP section to the checksum algorithm has to know.
* this may be the case for backward compatible CR TPDU */ * this may be the case for backward compatible CR TPDU */
@ -477,12 +477,11 @@ static gboolean ositp_decode_var_part(tvbuff_t *tvb, int offset, int vp_length,
i += tmp_len; i += tmp_len;
} }
} }
checksum_ok = check_atn_ec_16(tvb, tpdu_len , offset, sum = check_atn_ec_16(tvb, tpdu_len , offset,
offset_iso8073_checksum, offset_iso8073_checksum,
pinfo->dst.len, (const guint8 *)pinfo->dst.data, pinfo->dst.len, (const guint8 *)pinfo->dst.data,
pinfo->src.len, (const guint8 *)pinfo->src.data); pinfo->src.len, (const guint8 *)pinfo->src.data);
ti = proto_tree_add_item(tree, hf_cotp_atn_extended_checksum, tvb, offset, 2, ENC_BIG_ENDIAN); proto_tree_add_checksum(tree, tvb, offset, hf_cotp_atn_extended_checksum16, -1, NULL, pinfo, sum, ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_ZERO);
proto_item_append_text(ti, checksum_ok ? " (correct)" : " (incorrect)");
} else { } else {
proto_tree_add_bytes_format_value(tree, hf_cotp_parameter_value, tvb, offset, length, NULL, "<not shown>"); proto_tree_add_bytes_format_value(tree, hf_cotp_parameter_value, tvb, offset, length, NULL, "<not shown>");
} }
@ -492,6 +491,7 @@ static gboolean ositp_decode_var_part(tvbuff_t *tvb, int offset, int vp_length,
case VP_ATN_EC_32 : /* ATN */ case VP_ATN_EC_32 : /* ATN */
if (cotp_decode_atn) { if (cotp_decode_atn) {
guint32 sum;
/* if an alternate OSI checksum is present in the currently unprocessed /* if an alternate OSI checksum is present in the currently unprocessed
* VP section the checksum algorithm has to know. * VP section the checksum algorithm has to know.
* this may be the case for backward compatible CR TPDU */ * this may be the case for backward compatible CR TPDU */
@ -507,12 +507,11 @@ static gboolean ositp_decode_var_part(tvbuff_t *tvb, int offset, int vp_length,
i += tmp_len; i += tmp_len;
} }
} }
checksum_ok = check_atn_ec_32(tvb, tpdu_len , offset, sum = check_atn_ec_32(tvb, tpdu_len , offset,
offset_iso8073_checksum, offset_iso8073_checksum,
pinfo->dst.len, (const guint8 *)pinfo->dst.data, pinfo->dst.len, (const guint8 *)pinfo->dst.data,
pinfo->src.len, (const guint8 *)pinfo->src.data); pinfo->src.len, (const guint8 *)pinfo->src.data);
ti = proto_tree_add_item(tree, hf_cotp_atn_extended_checksum, tvb, offset, 4, ENC_BIG_ENDIAN); proto_tree_add_checksum(tree, tvb, offset, hf_cotp_atn_extended_checksum32, -1, NULL, pinfo, sum, ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_ZERO);
proto_item_append_text(ti, checksum_ok ? " (correct)" : " (incorrect)");
} else { } else {
proto_tree_add_bytes_format_value(tree, hf_cotp_parameter_value, tvb, offset, length, NULL, "<not shown>"); proto_tree_add_bytes_format_value(tree, hf_cotp_parameter_value, tvb, offset, length, NULL, "<not shown>");
} }
@ -691,36 +690,21 @@ static gboolean ositp_decode_var_part(tvbuff_t *tvb, int offset, int vp_length,
case VP_CHECKSUM: case VP_CHECKSUM:
offset_iso8073_checksum = offset; /* save ISO 8073 checksum offset for ATN extended checksum calculation */ offset_iso8073_checksum = offset; /* save ISO 8073 checksum offset for ATN extended checksum calculation */
cksum_status = calc_checksum(tvb, 0, tpdu_len,
tvb_get_ntohs(tvb, offset));
switch (cksum_status) {
default: if (tvb_get_ntohs(tvb, offset) == 0) {
/* /* No checksum present */
* No checksum present, or not enough of the packet present to proto_tree_add_checksum(tree, tvb, offset, hf_cotp_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NOT_PRESENT);
* checksum it. } else {
*/ guint32 calc_c0 = 0, calc_c1 = 0;
proto_tree_add_item(tree, hf_cotp_checksum, tvb, offset, 2, ENC_BIG_ENDIAN);
break;
case CKSUM_OK: if (osi_calc_checksum(tvb, 0, length, &calc_c0, &calc_c1)) {
/* /* Successfully processed checksum, verify it */
* Checksum is correct. proto_tree_add_checksum(tree, tvb, offset, hf_cotp_checksum, -1, NULL, pinfo, calc_c0 | calc_c1, ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_ZERO);
*/ } else {
s = tvb_get_ntohs(tvb, offset); proto_tree_add_checksum(tree, tvb, offset, hf_cotp_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
proto_tree_add_uint_format_value(tree, hf_cotp_checksum, tvb, offset, 2, }
s, "0x%04x (correct)", s);
break;
case CKSUM_NOT_OK:
/*
* Checksum is not correct.
*/
s = tvb_get_ntohs(tvb, offset);
proto_tree_add_uint_format_value(tree, hf_cotp_checksum, tvb, offset, 2,
s, "0x%04x (incorrect)", s);
break;
} }
offset += length; offset += length;
vp_length -= length; vp_length -= length;
break; break;
@ -2338,7 +2322,8 @@ void proto_register_cotp(void)
{ &hf_cotp_parameter_code, { "Parameter code", "cotp.parameter_code", FT_UINT8, BASE_HEX, VALS(tp_vpart_type_vals), 0x0, NULL, HFILL }}, { &hf_cotp_parameter_code, { "Parameter code", "cotp.parameter_code", FT_UINT8, BASE_HEX, VALS(tp_vpart_type_vals), 0x0, NULL, HFILL }},
{ &hf_cotp_parameter_length, { "Parameter length", "cotp.parameter_length", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_cotp_parameter_length, { "Parameter length", "cotp.parameter_length", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
{ &hf_cotp_parameter_value, { "Parameter value", "cotp.parameter_value", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_cotp_parameter_value, { "Parameter value", "cotp.parameter_value", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
{ &hf_cotp_atn_extended_checksum, { "ATN extended checksum", "cotp.atn_extended_checksum", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { &hf_cotp_atn_extended_checksum16, { "ATN extended checksum", "cotp.atn_extended_checksum", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }},
{ &hf_cotp_atn_extended_checksum32, { "ATN extended checksum", "cotp.atn_extended_checksum", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }},
{ &hf_cotp_ack_time, { "Ack time (ms)", "cotp.ack_time", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_cotp_ack_time, { "Ack time (ms)", "cotp.ack_time", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }},
{ &hf_cotp_res_error_rate_target_value, { "Residual error rate, target value", "cotp.res_error_rate.target_value", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_cotp_res_error_rate_target_value, { "Residual error rate, target value", "cotp.res_error_rate.target_value", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
{ &hf_cotp_res_error_rate_min_accept, { "Residual error rate, minimum acceptable", "cotp.res_error_rate.min_accept", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_cotp_res_error_rate_min_accept, { "Residual error rate, minimum acceptable", "cotp.res_error_rate.min_accept", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},

2
epan/dissectors/packet-ospf.c
View File

@ -1470,7 +1470,7 @@ dissect_ospf_lls_data_block(tvbuff_t *tvb, packet_info *pinfo, int offset, proto
ospf_lls_data_block_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_ospf_lls_data_block, NULL, "OSPF LLS Data Block"); ospf_lls_data_block_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_ospf_lls_data_block, NULL, "OSPF LLS Data Block");
/* TODO: verify checksum */ /* TODO: verify checksum */
proto_tree_add_item(ospf_lls_data_block_tree, hf_ospf_lls_checksum, tvb, offset, 2, ENC_BIG_ENDIAN); proto_tree_add_checksum(ospf_lls_data_block_tree, tvb, offset, hf_ospf_lls_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
proto_tree_add_uint_format_value(ospf_lls_data_block_tree, hf_ospf_lls_data_length, tvb, offset + 2, 2, proto_tree_add_uint_format_value(ospf_lls_data_block_tree, hf_ospf_lls_data_length, tvb, offset + 2, 2,
ospf_lls_len, "%d bytes", ospf_lls_len); ospf_lls_len, "%d bytes", ospf_lls_len);

28
epan/dissectors/packet-pgm.c
View File

@ -148,7 +148,7 @@ static int hf_pgm_main_opts_netsig = -1;
static int hf_pgm_main_opts_varlen = -1; static int hf_pgm_main_opts_varlen = -1;
static int hf_pgm_main_opts_parity = -1; static int hf_pgm_main_opts_parity = -1;
static int hf_pgm_main_cksum = -1; static int hf_pgm_main_cksum = -1;
static int hf_pgm_main_cksum_bad = -1; static int hf_pgm_main_cksum_status = -1;
static int hf_pgm_main_gsi = -1; static int hf_pgm_main_gsi = -1;
static int hf_pgm_main_tsdulen = -1; static int hf_pgm_main_tsdulen = -1;
static int hf_pgm_spm_sqn = -1; static int hf_pgm_spm_sqn = -1;
@ -910,30 +910,18 @@ dissect_pgm(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
if ((pgmhdr_type != PGM_RDATA_PCKT) && (pgmhdr_type != PGM_ODATA_PCKT) && if ((pgmhdr_type != PGM_RDATA_PCKT) && (pgmhdr_type != PGM_ODATA_PCKT) &&
(pgmhdr_cksum == 0)) (pgmhdr_cksum == 0))
{ {
proto_tree_add_uint_format_value(pgm_tree, hf_pgm_main_cksum, tvb, proto_tree_add_checksum(pgm_tree, tvb, ptvcursor_current_offset(cursor), hf_pgm_main_cksum, hf_pgm_main_cksum_status, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NOT_PRESENT);
ptvcursor_current_offset(cursor), 2, pgmhdr_cksum, "not available");
} else { } else {
reportedlen = tvb_reported_length(tvb); reportedlen = tvb_reported_length(tvb);
pgmlen = tvb_captured_length(tvb); pgmlen = tvb_captured_length(tvb);
if (pgm_check_checksum && pgmlen >= reportedlen) { if (pgm_check_checksum && pgmlen >= reportedlen) {
vec_t cksum_vec[1]; vec_t cksum_vec[1];
guint16 computed_cksum;
SET_CKSUM_VEC_TVB(cksum_vec[0], tvb, 0, pgmlen); SET_CKSUM_VEC_TVB(cksum_vec[0], tvb, 0, pgmlen);
computed_cksum = in_cksum(&cksum_vec[0], 1); proto_tree_add_checksum(pgm_tree, tvb, ptvcursor_current_offset(cursor), hf_pgm_main_cksum_status, -1, NULL, pinfo,
if (computed_cksum == 0) { in_cksum(&cksum_vec[0], 1), ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_IN_CKSUM);
proto_tree_add_uint_format_value(pgm_tree, hf_pgm_main_cksum, tvb,
ptvcursor_current_offset(cursor), 2, pgmhdr_cksum, "0x%04x [correct]", pgmhdr_cksum);
} else {
hidden_item = proto_tree_add_boolean(pgm_tree, hf_pgm_main_cksum_bad, tvb,
ptvcursor_current_offset(cursor), 2, TRUE);
PROTO_ITEM_SET_HIDDEN(hidden_item);
proto_tree_add_uint_format_value(pgm_tree, hf_pgm_main_cksum, tvb,
ptvcursor_current_offset(cursor), 2, pgmhdr_cksum, "0x%04x [incorrect, should be 0x%04x]",
pgmhdr_cksum, in_cksum_shouldbe(pgmhdr_cksum, computed_cksum));
}
} else { } else {
ptvcursor_add_no_advance(cursor, hf_pgm_main_cksum, 2, ENC_BIG_ENDIAN); proto_tree_add_checksum(pgm_tree, tvb, ptvcursor_current_offset(cursor), hf_pgm_main_cksum, hf_pgm_main_cksum_status, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
} }
} }
ptvcursor_advance(cursor, 2); ptvcursor_advance(cursor, 2);
@ -1120,9 +1108,9 @@ proto_register_pgm(void)
{ &hf_pgm_main_cksum, { &hf_pgm_main_cksum,
{ "Checksum", "pgm.hdr.cksum", FT_UINT16, BASE_HEX, { "Checksum", "pgm.hdr.cksum", FT_UINT16, BASE_HEX,
NULL, 0x0, NULL, HFILL }}, NULL, 0x0, NULL, HFILL }},
{ &hf_pgm_main_cksum_bad, { &hf_pgm_main_cksum_status,
{ "Bad Checksum", "pgm.hdr.cksum_bad", FT_BOOLEAN, BASE_NONE, { "Checksum Status", "pgm.hdr.cksum.status", FT_UINT8, BASE_NONE,
NULL, 0x0, NULL, HFILL }}, VALS(proto_checksum_vals), 0x0, NULL, HFILL }},
{ &hf_pgm_main_gsi, { &hf_pgm_main_gsi,
{ "Global Source Identifier", "pgm.hdr.gsi", FT_BYTES, BASE_NONE, { "Global Source Identifier", "pgm.hdr.gsi", FT_BYTES, BASE_NONE,
NULL, 0x0, NULL, HFILL }}, NULL, 0x0, NULL, HFILL }},

37
epan/dissectors/packet-pim.c
View File

@ -327,12 +327,10 @@ dissect_pimv1(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U
guint8 pim_type; guint8 pim_type;
guint8 pim_ver; guint8 pim_ver;
guint length, pim_length; guint length, pim_length;
guint16 pim_cksum, computed_cksum;
vec_t cksum_vec[1]; vec_t cksum_vec[1];
proto_tree *pim_tree = NULL; proto_tree *pim_tree = NULL;
proto_item *ti; proto_item *ti;
proto_tree *pimopt_tree = NULL; proto_tree *pimopt_tree = NULL;
proto_item *ticksum;
int offset = 0; int offset = 0;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "PIMv1"); col_set_str(pinfo->cinfo, COL_PROTOCOL, "PIMv1");
@ -353,10 +351,10 @@ dissect_pimv1(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U
proto_tree_add_uint(pim_tree, hf_pim_code, tvb, offset, 1, pim_type); proto_tree_add_uint(pim_tree, hf_pim_code, tvb, offset, 1, pim_type);
offset += 1; offset += 1;
pim_cksum = tvb_get_ntohs(tvb, offset);
ticksum = proto_tree_add_item(pim_tree, hf_pim_cksum, tvb, offset, 2, ENC_BIG_ENDIAN);
pim_ver = PIM_VER(tvb_get_guint8(tvb, offset + 2)); pim_ver = PIM_VER(tvb_get_guint8(tvb, offset + 2));
if (pim_ver != 1) { if (pim_ver != 1) {
proto_tree_add_checksum(pim_tree, tvb, offset, hf_pim_cksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
/* /*
* Not PIMv1; should we bother dissecting the PIM drafts * Not PIMv1; should we bother dissecting the PIM drafts
* with a version number of 2 and with PIM running atop * with a version number of 2 and with PIM running atop
@ -403,12 +401,10 @@ dissect_pimv1(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U
* truncated, so we can checksum it. * truncated, so we can checksum it.
*/ */
SET_CKSUM_VEC_TVB(cksum_vec[0], tvb, 0, pim_length); SET_CKSUM_VEC_TVB(cksum_vec[0], tvb, 0, pim_length);
computed_cksum = in_cksum(&cksum_vec[0], 1); proto_tree_add_checksum(pim_tree, tvb, offset, hf_pim_cksum, -1, NULL, pinfo, in_cksum(&cksum_vec[0], 1),
if (computed_cksum == 0) { ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_IN_CKSUM);
proto_item_append_text(ticksum, " [correct]"); } else {
} else { proto_tree_add_checksum(pim_tree, tvb, offset, hf_pim_cksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
proto_item_append_text(ticksum, " [incorrect, should be 0x%04x]", in_cksum_shouldbe(pim_cksum, computed_cksum));
}
} }
offset += 2; offset += 2;
@ -805,14 +801,13 @@ dissect_pim(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
guint8 pim_typever; guint8 pim_typever;
guint8 pim_bidir_subtype = 0; guint8 pim_bidir_subtype = 0;
guint length, pim_length; guint length, pim_length;
guint16 pim_cksum, computed_cksum;
vec_t cksum_vec[4]; vec_t cksum_vec[4];
guint32 phdr[2]; guint32 phdr[2];
const char *typestr; const char *typestr;
proto_tree *pim_tree = NULL; proto_tree *pim_tree = NULL;
proto_item *ti; proto_item *ti;
proto_tree *pimopt_tree = NULL; proto_tree *pimopt_tree = NULL;
proto_item *tiopt, *ticksum; proto_item *tiopt;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "PIM"); col_set_str(pinfo->cinfo, COL_PROTOCOL, "PIM");
col_clear(pinfo->cinfo, COL_INFO); col_clear(pinfo->cinfo, COL_INFO);
@ -846,10 +841,9 @@ dissect_pim(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
else { else {
proto_tree_add_item(pim_tree, hf_pim_res_bytes, tvb, offset + 1, 1, ENC_NA); proto_tree_add_item(pim_tree, hf_pim_res_bytes, tvb, offset + 1, 1, ENC_NA);
} }
pim_cksum = tvb_get_ntohs(tvb, offset + 2);
ticksum = proto_tree_add_item(pim_tree, hf_pim_cksum, tvb, offset + 2, 2, ENC_BIG_ENDIAN);
if (PIM_VER(pim_typever) != 2) { if (PIM_VER(pim_typever) != 2) {
proto_tree_add_checksum(pim_tree, tvb, offset+2, hf_pim_cksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
/* /*
* We don't know this version, so we don't know how much of the * We don't know this version, so we don't know how much of the
* packet the checksum covers. * packet the checksum covers.
@ -891,7 +885,8 @@ dissect_pim(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
switch (pinfo->src.type) { switch (pinfo->src.type) {
case AT_IPv4: case AT_IPv4:
SET_CKSUM_VEC_TVB(cksum_vec[0], tvb, 0, pim_length); SET_CKSUM_VEC_TVB(cksum_vec[0], tvb, 0, pim_length);
computed_cksum = in_cksum(&cksum_vec[0], 1); proto_tree_add_checksum(pim_tree, tvb, offset+2, hf_pim_cksum, -1, NULL, pinfo, in_cksum(&cksum_vec[0], 1),
ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_IN_CKSUM);
break; break;
case AT_IPv6: case AT_IPv6:
/* Set up the fields of the pseudo-header. */ /* Set up the fields of the pseudo-header. */
@ -901,20 +896,16 @@ dissect_pim(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
phdr[1] = g_htonl(IP_PROTO_PIM); phdr[1] = g_htonl(IP_PROTO_PIM);
SET_CKSUM_VEC_PTR(cksum_vec[2], (const guint8 *)&phdr, 8); SET_CKSUM_VEC_PTR(cksum_vec[2], (const guint8 *)&phdr, 8);
SET_CKSUM_VEC_TVB(cksum_vec[3], tvb, 0, pim_length); SET_CKSUM_VEC_TVB(cksum_vec[3], tvb, 0, pim_length);
computed_cksum = in_cksum(&cksum_vec[0], 4); proto_tree_add_checksum(pim_tree, tvb, offset+2, hf_pim_cksum, -1, NULL, pinfo, in_cksum(&cksum_vec[0], 4),
ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_IN_CKSUM);
break; break;
default: default:
/* PIM is available for IPv4 and IPv6 right now */ /* PIM is available for IPv4 and IPv6 right now */
DISSECTOR_ASSERT_NOT_REACHED(); DISSECTOR_ASSERT_NOT_REACHED();
break; break;
} }
} else {
if (computed_cksum == 0) { proto_tree_add_checksum(pim_tree, tvb, offset+2, hf_pim_cksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
proto_item_append_text(ticksum, " [correct]");
} else {
proto_item_append_text(ticksum, " [incorrect, should be 0x%04x]", in_cksum_shouldbe(pim_cksum, computed_cksum));
}
} }
offset += 4; offset += 4;

29
epan/dissectors/packet-ppp.c
View File

@ -1829,9 +1829,6 @@ decode_fcs(tvbuff_t *tvb, proto_tree *fh_tree, int fcs_decode, int proto_offset)
{ {
tvbuff_t *next_tvb; tvbuff_t *next_tvb;
gint len, reported_len; gint len, reported_len;
int rx_fcs_offset;
guint32 rx_fcs_exp;
guint32 rx_fcs_got;
/* /*
* Remove the FCS, if any, from the packet data. * Remove the FCS, if any, from the packet data.
@ -1880,17 +1877,8 @@ decode_fcs(tvbuff_t *tvb, proto_tree *fh_tree, int fcs_decode, int proto_offset)
/* /*
* Compute the FCS and put it into the tree. * Compute the FCS and put it into the tree.
*/ */
rx_fcs_offset = proto_offset + len; proto_tree_add_checksum(fh_tree, tvb, proto_offset + len, hf_ppp_fcs_16, -1, NULL, NULL, fcs16(tvb),
rx_fcs_exp = fcs16(tvb); ENC_LITTLE_ENDIAN, PROTO_CHECKSUM_VERIFY);
rx_fcs_got = tvb_get_letohs(tvb, rx_fcs_offset);
if (rx_fcs_got != rx_fcs_exp) {
proto_tree_add_uint_format_value(fh_tree, hf_ppp_fcs_16, tvb, rx_fcs_offset, 2,
rx_fcs_got, "0x%04x [incorrect, should be 0x%04x]",
rx_fcs_got, rx_fcs_exp);
} else {
proto_tree_add_uint_format_value(fh_tree, hf_ppp_fcs_16, tvb, rx_fcs_offset, 2,
rx_fcs_got, "0x%04x [correct]", rx_fcs_got);
}
} }
break; break;
@ -1931,17 +1919,8 @@ decode_fcs(tvbuff_t *tvb, proto_tree *fh_tree, int fcs_decode, int proto_offset)
/* /*
* Compute the FCS and put it into the tree. * Compute the FCS and put it into the tree.
*/ */
rx_fcs_offset = proto_offset + len; proto_tree_add_checksum(fh_tree, tvb, proto_offset + len, hf_ppp_fcs_32, -1, NULL, NULL, fcs32(tvb),
rx_fcs_exp = fcs32(tvb); ENC_LITTLE_ENDIAN, PROTO_CHECKSUM_VERIFY);
rx_fcs_got = tvb_get_letohl(tvb, rx_fcs_offset);
if (rx_fcs_got != rx_fcs_exp) {
proto_tree_add_uint_format_value(fh_tree, hf_ppp_fcs_32, tvb, rx_fcs_offset, 4,
rx_fcs_got, "0x%08x [incorrect, should be 0x%08x]",
rx_fcs_got, rx_fcs_exp);
} else {
proto_tree_add_uint_format_value(fh_tree, hf_ppp_fcs_32, tvb, rx_fcs_offset, 4,
rx_fcs_got, "0x%08x [correct]", rx_fcs_got);
}
} }
break; break;

5
epan/dissectors/packet-quake2.c
View File

@ -137,7 +137,6 @@ dissect_quake2_client_commands_move(tvbuff_t *tvb, packet_info *pinfo _U_,
#define BUTTON_USE 2 #define BUTTON_USE 2
#define BUTTON_ANY 128 #define BUTTON_ANY 128
guint8 chksum;
guint32 lastframe; guint32 lastframe;
int i, offset = 0; int i, offset = 0;
enum { Q_OFFSET, Q_VALUE, Q_SIZE }; enum { Q_OFFSET, Q_VALUE, Q_SIZE };
@ -151,7 +150,6 @@ dissect_quake2_client_commands_move(tvbuff_t *tvb, packet_info *pinfo _U_,
guint8 impulse[Q_SIZE]; guint8 impulse[Q_SIZE];
} move[MOVES+1]; } move[MOVES+1];
chksum = tvb_get_guint8(tvb, offset);
offset++; offset++;
lastframe = tvb_get_letohl(tvb, offset); lastframe = tvb_get_letohl(tvb, offset);
offset += 4; offset += 4;
@ -212,8 +210,7 @@ dissect_quake2_client_commands_move(tvbuff_t *tvb, packet_info *pinfo _U_,
if (!tree) if (!tree)
return offset; return offset;
proto_tree_add_uint(tree, hf_quake2_game_client_command_move_chksum, tvb, proto_tree_add_checksum(tree, tvb, 0, hf_quake2_game_client_command_move_chksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
0, 1, chksum);
proto_tree_add_uint(tree, hf_quake2_game_client_command_move_lframe, tvb, proto_tree_add_uint(tree, hf_quake2_game_client_command_move_lframe, tvb,
1, 4, lastframe); 1, 4, lastframe);

48
epan/dissectors/packet-rdm.c
View File

@ -540,8 +540,7 @@ static int hf_rdm_parameter_data = -1;
static int hf_rdm_parameter_data_raw = -1; static int hf_rdm_parameter_data_raw = -1;
static int hf_rdm_intron = -1; static int hf_rdm_intron = -1;
static int hf_rdm_checksum = -1; static int hf_rdm_checksum = -1;
static int hf_rdm_checksum_good = -1; static int hf_rdm_checksum_status = -1;
static int hf_rdm_checksum_bad = -1;
static int hf_rdm_trailer = -1; static int hf_rdm_trailer = -1;
static int hf_rdm_pd_device_label = -1; static int hf_rdm_pd_device_label = -1;
@ -2051,9 +2050,7 @@ dissect_rdm(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
gint padding_size; gint padding_size;
guint16 man_id; guint16 man_id;
guint32 dev_id; guint32 dev_id;
guint message_length, checksum, checksum_shouldbe, offset = 0; guint message_length, offset = 0;
proto_item *item;
proto_tree *checksum_tree;
proto_tree *ti = proto_tree_add_item(tree, proto_rdm, tvb, proto_tree *ti = proto_tree_add_item(tree, proto_rdm, tvb,
offset, -1, ENC_NA); offset, -1, ENC_NA);
@ -2096,32 +2093,8 @@ dissect_rdm(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
offset += padding_size; offset += padding_size;
} }
checksum_shouldbe = rdm_checksum(tvb, offset); proto_tree_add_checksum(rdm_tree, tvb, offset, hf_rdm_checksum, hf_rdm_checksum_status, NULL, pinfo, rdm_checksum(tvb, offset),
checksum = tvb_get_ntohs(tvb, offset); ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
item = proto_tree_add_item(rdm_tree, hf_rdm_checksum, tvb,
offset, 2, ENC_BIG_ENDIAN);
if (checksum == checksum_shouldbe) {
proto_item_append_text(item, " [correct]");
checksum_tree = proto_item_add_subtree(item, ett_rdm);
item = proto_tree_add_boolean(checksum_tree, hf_rdm_checksum_good, tvb,
offset, 2, TRUE);
PROTO_ITEM_SET_GENERATED(item);
item = proto_tree_add_boolean(checksum_tree, hf_rdm_checksum_bad, tvb,
offset, 2, FALSE);
PROTO_ITEM_SET_GENERATED(item);
} else {
proto_item_append_text(item, " [incorrect, should be 0x%04x]", checksum_shouldbe);
checksum_tree = proto_item_add_subtree(item, ett_rdm);
item = proto_tree_add_boolean(checksum_tree, hf_rdm_checksum_good, tvb,
offset, 2, FALSE);
PROTO_ITEM_SET_GENERATED(item);
item = proto_tree_add_boolean(checksum_tree, hf_rdm_checksum_bad, tvb,
offset, 2, TRUE);
PROTO_ITEM_SET_GENERATED(item);
}
offset += 2; offset += 2;
if (offset < tvb_reported_length(tvb)) if (offset < tvb_reported_length(tvb))
@ -2220,15 +2193,10 @@ proto_register_rdm(void)
FT_UINT16, BASE_HEX, NULL, 0x0, FT_UINT16, BASE_HEX, NULL, 0x0,
NULL, HFILL }}, NULL, HFILL }},
{ &hf_rdm_checksum_good, { &hf_rdm_checksum_status,
{ "Good Checksum", "rdm.checksum_good", { "Checksum Status", "rdm.checksum.status",
FT_BOOLEAN, BASE_NONE, NULL, 0x0, FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0,
"True: checksum matches packet content; False: doesn't match content", HFILL }}, NULL, HFILL }},
{ &hf_rdm_checksum_bad,
{ "Bad Checksum", "rdm.checksum_bad",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"True: checksum doesn't match packet content; False: matches content", HFILL }},
{ &hf_rdm_trailer, { &hf_rdm_trailer,
{ "Trailer", "rdm.trailer", { "Trailer", "rdm.trailer",

6
epan/dissectors/packet-rfid-pn532-hci.c
View File

@ -137,15 +137,13 @@ dissect_pn532_hci(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *dat
call_dissector_with_data(pn532_handle, next_tvb, pinfo, tree, usb_conv_info); call_dissector_with_data(pn532_handle, next_tvb, pinfo, tree, usb_conv_info);
offset += length; offset += length;
proto_tree_add_item(main_tree, hf_data_checksum, tvb, offset, 1, ENC_BIG_ENDIAN);
checksum = tvb_get_guint8(tvb, offset); checksum = tvb_get_guint8(tvb, offset);
while (length) { while (length) {
checksum += tvb_get_guint8(tvb, offset - length); checksum += tvb_get_guint8(tvb, offset - length);
length -= 1; length -= 1;
} }
if (checksum != 0) { proto_tree_add_checksum(main_tree, tvb, offset, hf_data_checksum, -1, &ei_invalid_data_checksum, pinfo, 0,
proto_tree_add_expert(main_tree, pinfo, &ei_invalid_data_checksum, tvb, offset, 1); ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_ZERO);
}
offset += 1; offset += 1;
} else { /* Normal Information Frame */ } else { /* Normal Information Frame */
col_set_str(pinfo->cinfo, COL_INFO, "Normal Information Frame"); col_set_str(pinfo->cinfo, COL_INFO, "Normal Information Frame");

10
epan/dissectors/packet-rgmp.c
View File

@ -39,7 +39,7 @@ static int proto_rgmp = -1;
static int hf_type = -1; static int hf_type = -1;
static int hf_reserved = -1; static int hf_reserved = -1;
static int hf_checksum = -1; static int hf_checksum = -1;
static int hf_checksum_bad = -1; static int hf_checksum_status = -1;
static int hf_maddr = -1; static int hf_maddr = -1;
static int ett_rgmp = -1; static int ett_rgmp = -1;
@ -86,7 +86,7 @@ dissect_rgmp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, void* d
proto_tree_add_item(tree, hf_reserved, tvb, offset, 1, ENC_NA); proto_tree_add_item(tree, hf_reserved, tvb, offset, 1, ENC_NA);
offset += 1; offset += 1;
igmp_checksum(tree, tvb, hf_checksum, hf_checksum_bad, pinfo, 0); igmp_checksum(tree, tvb, hf_checksum, hf_checksum_status, pinfo, 0);
offset += 2; offset += 2;
proto_tree_add_item(tree, hf_maddr, tvb, offset, 4, ENC_BIG_ENDIAN); proto_tree_add_item(tree, hf_maddr, tvb, offset, 4, ENC_BIG_ENDIAN);
@ -115,9 +115,9 @@ proto_register_rgmp(void)
NULL, 0, NULL, HFILL } NULL, 0, NULL, HFILL }
}, },
{ &hf_checksum_bad, { &hf_checksum_status,
{ "Bad Checksum", "rgmp.checksum_bad", FT_BOOLEAN, BASE_NONE, { "Checksum Status", "rgmp.checksum.status", FT_UINT8, BASE_NONE,
NULL, 0x0, NULL, HFILL } VALS(proto_checksum_vals), 0x0, NULL, HFILL }
}, },
{ &hf_maddr, { &hf_maddr,

4
epan/dissectors/packet-rohc.c
View File

@ -1461,7 +1461,7 @@ dissect_rohc_ir_rtp_profile_dynamic(tvbuff_t *tvb, packet_info *pinfo, proto_tre
dynamic_udp_tree = proto_item_add_subtree(root_ti, ett_rohc_dynamic_udp); dynamic_udp_tree = proto_item_add_subtree(root_ti, ett_rohc_dynamic_udp);
id = tvb_get_ntohs(tvb, offset); id = tvb_get_ntohs(tvb, offset);
rohc_cid_context->udp_checksum_present = id ? TRUE : FALSE; rohc_cid_context->udp_checksum_present = id ? TRUE : FALSE;
proto_tree_add_item(dynamic_udp_tree, hf_rohc_dynamic_udp_checksum, tvb, offset, 2, ENC_BIG_ENDIAN); proto_tree_add_checksum(dynamic_udp_tree, tvb, offset, hf_rohc_dynamic_udp_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
offset +=2; offset +=2;
proto_item_set_len(item, offset - start_offset); proto_item_set_len(item, offset - start_offset);
} }
@ -2334,7 +2334,7 @@ start_over:
/* UDP Checksum */ /* UDP Checksum */
if (rohc_cid_context->udp_checksum_present) { if (rohc_cid_context->udp_checksum_present) {
proto_tree_add_item(rohc_tree, hf_rohc_udp_checksum, tvb, offset, 2, ENC_BIG_ENDIAN); proto_tree_add_checksum(rohc_tree, tvb, offset, hf_rohc_udp_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
offset += 2; offset += 2;
} }

4
epan/dissectors/packet-roofnet.c
View File

@ -116,7 +116,9 @@ static void dissect_roofnet_header(proto_tree *tree, tvbuff_t *tvb, guint *offse
ptvcursor_add(cursor, hf_roofnet_nlinks, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_roofnet_nlinks, 1, ENC_BIG_ENDIAN);
ptvcursor_add(cursor, hf_roofnet_next, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_roofnet_next, 1, ENC_BIG_ENDIAN);
ptvcursor_add(cursor, hf_roofnet_ttl, 2, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_roofnet_ttl, 2, ENC_BIG_ENDIAN);
ptvcursor_add(cursor, hf_roofnet_cksum, 2, ENC_BIG_ENDIAN); proto_tree_add_checksum(ptvcursor_tree(cursor), ptvcursor_tvbuff(cursor), ptvcursor_current_offset(cursor),
hf_roofnet_cksum, -1, NULL, NULL, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
ptvcursor_advance(cursor, 2);
ptvcursor_add(cursor, hf_roofnet_flags, 2, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_roofnet_flags, 2, ENC_BIG_ENDIAN);
ptvcursor_add(cursor, hf_roofnet_data_length, 2, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_roofnet_data_length, 2, ENC_BIG_ENDIAN);
ptvcursor_add(cursor, hf_roofnet_query_dst, 4, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_roofnet_query_dst, 4, ENC_BIG_ENDIAN);

12
epan/dissectors/packet-rtp-midi.c
View File

@ -2528,7 +2528,7 @@ static int hf_rtp_midi_controller_value = -1;
static int hf_rtp_midi_program = -1; static int hf_rtp_midi_program = -1;
static int hf_rtp_midi_channel_pressure = -1; static int hf_rtp_midi_channel_pressure = -1;
static int hf_rtp_midi_pitch_bend = -1; static int hf_rtp_midi_pitch_bend = -1;
static int hf_rtp_midi_pitch_bend_truncated = -1; /* static int hf_rtp_midi_pitch_bend_truncated = -1; */
static int hf_rtp_midi_manu_short = -1; static int hf_rtp_midi_manu_short = -1;
static int hf_rtp_midi_manu_long = -1; static int hf_rtp_midi_manu_long = -1;
@ -2733,7 +2733,7 @@ static int hf_rtp_midi_sj_chapter_x_invalid_data = -1;
static int hf_rtp_midi_quarter_frame_type = -1; static int hf_rtp_midi_quarter_frame_type = -1;
static int hf_rtp_midi_quarter_frame_value = -1; static int hf_rtp_midi_quarter_frame_value = -1;
static int hf_rtp_midi_spp_truncated = -1; /* static int hf_rtp_midi_spp_truncated = -1; */
static int hf_rtp_midi_spp = -1; static int hf_rtp_midi_spp = -1;
static int hf_rtp_midi_song_select = -1; static int hf_rtp_midi_song_select = -1;
static int hf_rtp_midi_manu_data = -1; static int hf_rtp_midi_manu_data = -1;
@ -3515,7 +3515,7 @@ decode_sysex_common_nrt_fd( tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *t
offset += ( data_len - 1 ); offset += ( data_len - 1 );
} }
proto_tree_add_item( tree, hf_rtp_midi_sysex_common_nrt_fd_checksum, tvb, offset, 1, ENC_BIG_ENDIAN ); proto_tree_add_checksum(tree, tvb, offset, hf_rtp_midi_sysex_common_nrt_fd_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
offset++; offset++;
} else if ( sub_id == RTP_MIDI_SYSEX_COMMON_NRT_FD_REQUEST ) { } else if ( sub_id == RTP_MIDI_SYSEX_COMMON_NRT_FD_REQUEST ) {
@ -3589,7 +3589,7 @@ decode_sysex_common_tuning( tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *t
} }
/* checksum */ /* checksum */
proto_tree_add_item( tree, hf_rtp_midi_sysex_common_tune_checksum, tvb, offset, 1, ENC_BIG_ENDIAN ); proto_tree_add_checksum(tree, tvb, offset, hf_rtp_midi_sysex_common_tune_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
offset++; offset++;
} else if ( sub_id == RTP_MIDI_SYSEX_COMMON_TUNING_NOTE_CHANGE ) { } else if ( sub_id == RTP_MIDI_SYSEX_COMMON_TUNING_NOTE_CHANGE ) {
@ -6599,6 +6599,7 @@ proto_register_rtp_midi( void )
NULL, HFILL NULL, HFILL
} }
}, },
#if 0
{ {
&hf_rtp_midi_pitch_bend_truncated, &hf_rtp_midi_pitch_bend_truncated,
{ {
@ -6611,6 +6612,7 @@ proto_register_rtp_midi( void )
NULL, HFILL NULL, HFILL
} }
}, },
#endif
{ {
&hf_rtp_midi_manu_short, &hf_rtp_midi_manu_short,
{ {
@ -8939,6 +8941,7 @@ proto_register_rtp_midi( void )
NULL, HFILL NULL, HFILL
} }
}, },
#if 0
{ {
&hf_rtp_midi_spp_truncated, &hf_rtp_midi_spp_truncated,
{ {
@ -8951,6 +8954,7 @@ proto_register_rtp_midi( void )
NULL, HFILL NULL, HFILL
} }
}, },
#endif
{ {
&hf_rtp_midi_song_select, &hf_rtp_midi_song_select,
{ {

4
epan/dissectors/packet-rtps.c
View File

@ -5477,8 +5477,8 @@ static gboolean dissect_parameter_sequence_v1(proto_tree *rtps_parameter_tree, p
case PID_TYPE_CHECKSUM: case PID_TYPE_CHECKSUM:
ENSURE_LENGTH(4); ENSURE_LENGTH(4);
proto_tree_add_item(rtps_parameter_tree, hf_rtps_type_checksum, tvb, offset, 4, proto_tree_add_checksum(rtps_parameter_tree, tvb, offset, hf_rtps_type_checksum, -1, NULL, pinfo, 0,
little_endian ? ENC_LITTLE_ENDIAN : ENC_BIG_ENDIAN); little_endian ? ENC_LITTLE_ENDIAN : ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
break; break;
case PID_EXPECTS_ACK: case PID_EXPECTS_ACK:

2
epan/dissectors/packet-rudp.c
View File

@ -116,7 +116,7 @@ dissect_rudp(tvbuff_t *tvb, packet_info *pinfo _U_ , proto_tree *tree, void* dat
/* If the header is more than 4 bytes the next 2 bytes are the checksum */ /* If the header is more than 4 bytes the next 2 bytes are the checksum */
if (hlen > 4) { if (hlen > 4) {
proto_tree_add_item(rudp_tree, hf_rudp_cksum, tvb, 4, 2, ENC_BIG_ENDIAN); proto_tree_add_checksum(rudp_tree, tvb, 4, hf_rudp_cksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
} }
/* If we have even more bytes their meaning is unknown - we have seen this /* If we have even more bytes their meaning is unknown - we have seen this

2
epan/dissectors/packet-s7comm.c
View File

@ -4438,7 +4438,7 @@ s7comm_decode_ud_block_subfunc(tvbuff_t *tvb,
offset += 1; offset += 1;
proto_tree_add_item(data_tree, hf_s7comm_ud_blockinfo_res_unknown, tvb, offset, 1, ENC_NA); proto_tree_add_item(data_tree, hf_s7comm_ud_blockinfo_res_unknown, tvb, offset, 1, ENC_NA);
offset += 1; offset += 1;
proto_tree_add_item(data_tree, hf_s7comm_ud_blockinfo_checksum, tvb, offset, 2, ENC_BIG_ENDIAN); proto_tree_add_checksum(data_tree, tvb, offset, hf_s7comm_ud_blockinfo_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
offset += 2; offset += 2;
proto_tree_add_item(data_tree, hf_s7comm_ud_blockinfo_reserved1, tvb, offset, 4, ENC_BIG_ENDIAN); proto_tree_add_item(data_tree, hf_s7comm_ud_blockinfo_reserved1, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4; offset += 4;

31
epan/dissectors/packet-sbus.c
View File

@ -240,7 +240,7 @@ static int hf_sbus_week_day = -1;
static int hf_sbus_date = -1; static int hf_sbus_date = -1;
static int hf_sbus_time = -1; static int hf_sbus_time = -1;
static int hf_sbus_crc = -1; static int hf_sbus_crc = -1;
static int hf_sbus_crc_bad = -1; static int hf_sbus_crc_status = -1;
static int hf_sbus_flags_accu = -1; static int hf_sbus_flags_accu = -1;
static int hf_sbus_flags_error = -1; static int hf_sbus_flags_error = -1;
static int hf_sbus_flags_negative = -1; static int hf_sbus_flags_negative = -1;
@ -650,7 +650,7 @@ dissect_sbus(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_
{ {
/* Set up structures needed to add the protocol subtree and manage it */ /* Set up structures needed to add the protocol subtree and manage it */
proto_item *ti, *hi, *cs; proto_item *ti, *hi;
proto_tree *sbus_tree, *ethsbus_tree, *sbusdata_tree; proto_tree *sbus_tree, *ethsbus_tree, *sbusdata_tree;
gint i; /*for CRC calculation*/ gint i; /*for CRC calculation*/
@ -1855,22 +1855,9 @@ dissect_sbus(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_
sbus_crc_calc = 0; sbus_crc_calc = 0;
for (i = 0; i < sbus_eth_len - 2; i++) for (i = 0; i < sbus_eth_len - 2; i++)
sbus_crc_calc = crc_calc (sbus_crc_calc, tvb_get_guint8(tvb, i)); sbus_crc_calc = crc_calc (sbus_crc_calc, tvb_get_guint8(tvb, i));
/*Show CRC and add hidden item for wrong CRC*/
sbus_helper = tvb_get_ntohs(tvb, offset); proto_tree_add_checksum(sbus_tree, tvb, offset, hf_sbus_crc, hf_sbus_crc_status, &ei_sbus_crc_bad, pinfo, sbus_crc_calc,
if (sbus_helper == sbus_crc_calc) { ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
proto_tree_add_uint_format_value(sbus_tree,
hf_sbus_crc, tvb, offset, 2, sbus_helper,
"0x%04x (correct)", sbus_helper);
} else {
cs = proto_tree_add_uint_format_value(sbus_tree,
hf_sbus_crc, tvb, offset, 2, sbus_helper,
"0x%04x (NOT correct)", sbus_helper);
expert_add_info(pinfo, cs, &ei_sbus_crc_bad);
hi = proto_tree_add_boolean(sbus_tree,
hf_sbus_crc_bad, tvb, offset, 2, TRUE);
PROTO_ITEM_SET_HIDDEN(hi);
PROTO_ITEM_SET_GENERATED(hi);
}
offset += 2; /*now at the end of the telegram*/ offset += 2; /*now at the end of the telegram*/
} }
return offset; return offset;
@ -2231,10 +2218,10 @@ proto_register_sbus(void)
"CRC 16", HFILL } "CRC 16", HFILL }
}, },
{ &hf_sbus_crc_bad, { &hf_sbus_crc_status,
{ "Bad Checksum", "sbus.crc_bad", { "Checksum Status", "sbus.crc.status",
FT_BOOLEAN, BASE_NONE, NULL, 0x0, FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0,
"A bad checksum in the telegram", HFILL }}, NULL, HFILL }},
{ &hf_sbus_flags_accu, { &hf_sbus_flags_accu,
{ "ACCU", "sbus.flags.accu", { "ACCU", "sbus.flags.accu",

68
epan/dissectors/packet-sctp.c
View File

@ -94,7 +94,9 @@ static int hf_source_port = -1;
static int hf_destination_port = -1; static int hf_destination_port = -1;
static int hf_verification_tag = -1; static int hf_verification_tag = -1;
static int hf_checksum = -1; static int hf_checksum = -1;
static int hf_checksum_bad = -1; static int hf_checksum_adler = -1;
static int hf_checksum_crc32c = -1;
static int hf_checksum_status = -1;
static int hf_chunk_type = -1; static int hf_chunk_type = -1;
static int hf_chunk_flags = -1; static int hf_chunk_flags = -1;
@ -272,7 +274,6 @@ static int exported_pdu_tap = -1;
/* Initialize the subtree pointers */ /* Initialize the subtree pointers */
static gint ett_sctp = -1; static gint ett_sctp = -1;
static gint ett_sctp_checksum = -1;
static gint ett_sctp_chunk = -1; static gint ett_sctp_chunk = -1;
static gint ett_sctp_chunk_parameter = -1; static gint ett_sctp_chunk_parameter = -1;
static gint ett_sctp_chunk_cause = -1; static gint ett_sctp_chunk_cause = -1;
@ -4573,8 +4574,8 @@ dissect_sctp_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolea
guint16 source_port, destination_port; guint16 source_port, destination_port;
guint captured_length, reported_length; guint captured_length, reported_length;
gboolean crc32c_correct = FALSE, adler32_correct = FALSE; gboolean crc32c_correct = FALSE, adler32_correct = FALSE;
proto_item *sctp_item, *hidden_item, *item; proto_item *sctp_item, *hidden_item;
proto_tree *sctp_tree, *checksum_tree; proto_tree *sctp_tree;
guint32 vtag; guint32 vtag;
sctp_half_assoc_t *ha = NULL; sctp_half_assoc_t *ha = NULL;
proto_item *pi, *vt = NULL; proto_item *pi, *vt = NULL;
@ -4654,58 +4655,36 @@ dissect_sctp_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolea
switch(sctp_checksum) { switch(sctp_checksum) {
case SCTP_CHECKSUM_NONE: case SCTP_CHECKSUM_NONE:
proto_tree_add_uint_format_value(sctp_tree, hf_checksum, tvb, CHECKSUM_OFFSET, CHECKSUM_LENGTH, checksum, "0x%08x (not verified)", checksum); proto_tree_add_checksum(sctp_tree, tvb, CHECKSUM_OFFSET, hf_checksum, hf_checksum_status, &ei_sctp_bad_sctp_checksum, pinfo, 0,
ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
break; break;
case SCTP_CHECKSUM_ADLER32: case SCTP_CHECKSUM_ADLER32:
if (adler32_correct) proto_tree_add_checksum(sctp_tree, tvb, CHECKSUM_OFFSET, hf_checksum_adler, hf_checksum_status, &ei_sctp_bad_sctp_checksum, pinfo, calculated_adler32,
item = proto_tree_add_uint_format_value(sctp_tree, hf_checksum, tvb, CHECKSUM_OFFSET, CHECKSUM_LENGTH, ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
checksum, "0x%08x [correct Adler32]", checksum);
else {
item = proto_tree_add_uint_format_value(sctp_tree, hf_checksum, tvb, CHECKSUM_OFFSET, CHECKSUM_LENGTH, checksum,
"0x%08x [incorrect Adler32, should be 0x%08x]",
checksum, calculated_adler32);
expert_add_info(pinfo, item, &ei_sctp_bad_sctp_checksum);
}
checksum_tree = proto_item_add_subtree(item, ett_sctp_checksum);
proto_tree_add_boolean(checksum_tree, hf_checksum_bad, tvb, CHECKSUM_OFFSET, CHECKSUM_LENGTH, !(adler32_correct));
break; break;
case SCTP_CHECKSUM_CRC32C: case SCTP_CHECKSUM_CRC32C:
if (crc32c_correct) proto_tree_add_checksum(sctp_tree, tvb, CHECKSUM_OFFSET, hf_checksum_crc32c, hf_checksum_status, &ei_sctp_bad_sctp_checksum, pinfo, calculated_crc32c,
item = proto_tree_add_uint_format_value(sctp_tree, hf_checksum, tvb, CHECKSUM_OFFSET, CHECKSUM_LENGTH, ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
checksum, "0x%08x [correct CRC32C]", checksum);
else {
item = proto_tree_add_uint_format_value(sctp_tree, hf_checksum, tvb, CHECKSUM_OFFSET, CHECKSUM_LENGTH, checksum,
"0x%08x [incorrect CRC32C, should be 0x%08x]",
checksum, calculated_crc32c);
expert_add_info(pinfo, item, &ei_sctp_bad_sctp_checksum);
}
checksum_tree = proto_item_add_subtree(item, ett_sctp_checksum);
proto_tree_add_boolean(checksum_tree, hf_checksum_bad, tvb, CHECKSUM_OFFSET, CHECKSUM_LENGTH, !(crc32c_correct));
break; break;
case SCTP_CHECKSUM_AUTOMATIC: case SCTP_CHECKSUM_AUTOMATIC:
if ((adler32_correct) && !(crc32c_correct)) if ((adler32_correct) && !(crc32c_correct))
item = proto_tree_add_uint_format_value(sctp_tree, hf_checksum, tvb, CHECKSUM_OFFSET, CHECKSUM_LENGTH, proto_tree_add_checksum(sctp_tree, tvb, CHECKSUM_OFFSET, hf_checksum_adler, hf_checksum_status, &ei_sctp_bad_sctp_checksum, pinfo, calculated_adler32,
checksum, "0x%08x [correct Adler32]", checksum); ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
else if ((!adler32_correct) && (crc32c_correct)) else if ((!adler32_correct) && (crc32c_correct))
item = proto_tree_add_uint_format_value(sctp_tree, hf_checksum, tvb, CHECKSUM_OFFSET, CHECKSUM_LENGTH, proto_tree_add_checksum(sctp_tree, tvb, CHECKSUM_OFFSET, hf_checksum_crc32c, hf_checksum_status, &ei_sctp_bad_sctp_checksum, pinfo, calculated_crc32c,
checksum, "0x%08x [correct CRC32C]", checksum); ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
else if ((adler32_correct) && (crc32c_correct))
item = proto_tree_add_uint_format_value(sctp_tree, hf_checksum, tvb, CHECKSUM_OFFSET, CHECKSUM_LENGTH,
checksum, "0x%08x [correct Adler32 and CRC32C]", checksum);
else { else {
item = proto_tree_add_uint_format_value(sctp_tree, hf_checksum, tvb, CHECKSUM_OFFSET, CHECKSUM_LENGTH, checksum, proto_tree_add_checksum(sctp_tree, tvb, CHECKSUM_OFFSET, hf_checksum_adler, hf_checksum_status, &ei_sctp_bad_sctp_checksum, pinfo, calculated_adler32,
"0x%08x [incorrect, should be 0x%08x (Adler32) or 0x%08x (CRC32C)]", ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
checksum, calculated_adler32, calculated_crc32c); proto_tree_add_checksum(sctp_tree, tvb, CHECKSUM_OFFSET, hf_checksum_crc32c, hf_checksum_status, &ei_sctp_bad_sctp_checksum, pinfo, calculated_crc32c,
expert_add_info(pinfo, item, &ei_sctp_bad_sctp_checksum); ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
} }
checksum_tree = proto_item_add_subtree(item, ett_sctp_checksum);
proto_tree_add_boolean(checksum_tree, hf_checksum_bad, tvb, CHECKSUM_OFFSET, CHECKSUM_LENGTH, !(crc32c_correct || adler32_correct));
break; break;
} }
} else { } else {
/* We don't have the whole packet so we can't verify the checksum */ /* We don't have the whole packet so we can't verify the checksum */
proto_tree_add_uint_format_value(sctp_tree, hf_checksum, tvb, CHECKSUM_OFFSET, CHECKSUM_LENGTH, proto_tree_add_checksum(sctp_tree, tvb, CHECKSUM_OFFSET, hf_checksum, hf_checksum_status, &ei_sctp_bad_sctp_checksum, pinfo, 0,
checksum, "0x%08x [unchecked, not all data available]", checksum); ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
} }
/* add all chunks of the sctp datagram to the protocol tree */ /* add all chunks of the sctp datagram to the protocol tree */
@ -4789,7 +4768,9 @@ proto_register_sctp(void)
{ &hf_port, { "Port", "sctp.port", FT_UINT16, BASE_PT_SCTP, NULL, 0x0, NULL, HFILL } }, { &hf_port, { "Port", "sctp.port", FT_UINT16, BASE_PT_SCTP, NULL, 0x0, NULL, HFILL } },
{ &hf_verification_tag, { "Verification tag", "sctp.verification_tag", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_verification_tag, { "Verification tag", "sctp.verification_tag", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
{ &hf_checksum, { "Checksum", "sctp.checksum", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_checksum, { "Checksum", "sctp.checksum", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
{ &hf_checksum_bad, { "Bad checksum", "sctp.checksum_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_checksum_adler, { "Checksum (Adler)", "sctp.checksum", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
{ &hf_checksum_crc32c, { "Checksum (CRC32C)", "sctp.checksum", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
{ &hf_checksum_status, { "Checksum Status", "sctp.checksum.status", FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0, NULL, HFILL } },
{ &hf_chunk_type, { "Chunk type", "sctp.chunk_type", FT_UINT8, BASE_DEC, VALS(chunk_type_values), 0x0, NULL, HFILL } }, { &hf_chunk_type, { "Chunk type", "sctp.chunk_type", FT_UINT8, BASE_DEC, VALS(chunk_type_values), 0x0, NULL, HFILL } },
{ &hf_chunk_flags, { "Chunk flags", "sctp.chunk_flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_chunk_flags, { "Chunk flags", "sctp.chunk_flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } },
{ &hf_chunk_bit_1, { "Bit", "sctp.chunk_bit_1", FT_BOOLEAN, 8, TFS(&sctp_chunk_bit_1_value), SCTP_CHUNK_BIT_1, NULL, HFILL } }, { &hf_chunk_bit_1, { "Bit", "sctp.chunk_bit_1", FT_BOOLEAN, 8, TFS(&sctp_chunk_bit_1_value), SCTP_CHUNK_BIT_1, NULL, HFILL } },
@ -4944,7 +4925,6 @@ proto_register_sctp(void)
/* Setup protocol subtree array */ /* Setup protocol subtree array */
static gint *ett[] = { static gint *ett[] = {
&ett_sctp, &ett_sctp,
&ett_sctp_checksum,
&ett_sctp_chunk, &ett_sctp_chunk,
&ett_sctp_chunk_parameter, &ett_sctp_chunk_parameter,
&ett_sctp_chunk_cause, &ett_sctp_chunk_cause,

14
epan/dissectors/packet-selfm.c
View File

@ -1103,10 +1103,9 @@ dissect_relaydef_frame(tvbuff_t *tvb, proto_tree *tree, int offset)
offset += 1; offset += 1;
} }
proto_tree_add_item(relaydef_tree, hf_selfm_checksum, tvb, offset, 1, ENC_BIG_ENDIAN); proto_tree_add_checksum(relaydef_tree, tvb, offset, hf_selfm_checksum, -1, NULL, NULL, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
return tvb_reported_length(tvb); return tvb_reported_length(tvb);
} }
/******************************************************************************************************/ /******************************************************************************************************/
@ -1208,7 +1207,7 @@ dissect_fmconfig_frame(tvbuff_t *tvb, proto_tree *tree, int offset)
offset += 1; offset += 1;
} }
proto_tree_add_item(fmconfig_tree, hf_selfm_checksum, tvb, offset, 1, ENC_BIG_ENDIAN); proto_tree_add_checksum(fmconfig_tree, tvb, offset, hf_selfm_checksum, -1, NULL, NULL, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
return tvb_reported_length(tvb); return tvb_reported_length(tvb);
@ -1424,7 +1423,7 @@ dissect_fmdata_frame(tvbuff_t *tvb, proto_tree *tree, packet_info *pinfo, int of
offset += 1; offset += 1;
} }
proto_tree_add_item(fmdata_tree, hf_selfm_checksum, tvb, offset, 1, ENC_BIG_ENDIAN); proto_tree_add_checksum(fmdata_tree, tvb, offset, hf_selfm_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
} /* matching config frame message was found */ } /* matching config frame message was found */
@ -1517,8 +1516,7 @@ dissect_foconfig_frame(tvbuff_t *tvb, proto_tree *tree, int offset)
offset += 1; offset += 1;
} }
proto_tree_add_item(foconfig_tree, hf_selfm_checksum, tvb, offset, 1, ENC_BIG_ENDIAN); proto_tree_add_checksum(foconfig_tree, tvb, offset, hf_selfm_checksum, -1, NULL, NULL, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
return tvb_reported_length(tvb); return tvb_reported_length(tvb);
@ -1606,8 +1604,8 @@ dissect_fastop_frame(tvbuff_t *tvb, proto_tree *tree, packet_info *pinfo, int of
proto_tree_add_item(fastop_tree, hf_selfm_fastop_valid, tvb, offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(fastop_tree, hf_selfm_fastop_valid, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1; offset += 1;
/* Add checksum */ /* Add checksum */
proto_tree_add_item(fastop_tree, hf_selfm_checksum, tvb, offset, 1, ENC_BIG_ENDIAN); proto_tree_add_checksum(fastop_tree, tvb, offset, hf_selfm_checksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
return tvb_reported_length(tvb); return tvb_reported_length(tvb);

49
epan/dissectors/packet-shim6.c
View File

@ -102,8 +102,7 @@ static int hf_shim6_ct = -1;
static int hf_shim6_type = -1; static int hf_shim6_type = -1;
static int hf_shim6_proto = -1; static int hf_shim6_proto = -1;
static int hf_shim6_checksum = -1; static int hf_shim6_checksum = -1;
static int hf_shim6_checksum_bad = -1; static int hf_shim6_checksum_status= -1;
static int hf_shim6_checksum_good = -1;
static int hf_shim6_inonce = -1; /* also for request nonce */ static int hf_shim6_inonce = -1; /* also for request nonce */
static int hf_shim6_rnonce = -1; static int hf_shim6_rnonce = -1;
static int hf_shim6_reserved = -1; static int hf_shim6_reserved = -1;
@ -563,26 +562,6 @@ static const value_string shimctrlvals[] = {
{ 0, NULL } { 0, NULL }
}; };
static void
add_shim6_checksum_additional_info(tvbuff_t * tvb, packet_info * pinfo,
proto_item * it_cksum, int offset, gboolean is_cksum_correct)
{
proto_tree *checksum_tree;
proto_item *item;
checksum_tree = proto_item_add_subtree(it_cksum, ett_shim6_cksum);
item = proto_tree_add_boolean(checksum_tree, hf_shim6_checksum_good, tvb,
offset, 2, is_cksum_correct);
PROTO_ITEM_SET_GENERATED(item);
item = proto_tree_add_boolean(checksum_tree, hf_shim6_checksum_bad, tvb,
offset, 2, !is_cksum_correct);
PROTO_ITEM_SET_GENERATED(item);
if (!is_cksum_correct) {
expert_add_info(pinfo, item, &ei_shim6_checksum_bad);
col_append_str(pinfo->cinfo, COL_INFO, " [Shim6 CHECKSUM INCORRECT]");
}
}
static int static int
dissect_shim6(tvbuff_t *tvb, packet_info * pinfo, proto_tree *tree, void* data _U_) dissect_shim6(tvbuff_t *tvb, packet_info * pinfo, proto_tree *tree, void* data _U_)
{ {
@ -656,17 +635,10 @@ dissect_shim6(tvbuff_t *tvb, packet_info * pinfo, proto_tree *tree, void* data _
/* Checksum */ /* Checksum */
csum = shim6_checksum(tvb, offset, len); csum = shim6_checksum(tvb, offset, len);
proto_tree_add_checksum(shim_tree, tvb, p, hf_shim6_checksum, hf_shim6_checksum_status, &ei_shim6_checksum_bad, pinfo, csum,
if (csum == 0) { ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_IN_CKSUM);
ti = proto_tree_add_uint_format_value(shim_tree, hf_shim6_checksum, tvb, p, 2, if (csum != 0)
tvb_get_ntohs(tvb, p), "0x%04x [correct]", tvb_get_ntohs(tvb, p)); col_append_str(pinfo->cinfo, COL_INFO, " [Shim6 CHECKSUM INCORRECT]");
add_shim6_checksum_additional_info(tvb, pinfo, ti, p, TRUE);
} else {
ti = proto_tree_add_uint_format_value(shim_tree, hf_shim6_checksum, tvb, p, 2,
tvb_get_ntohs(tvb, p), "0x%04x [incorrect: should be 0x%04x]",
tvb_get_ntohs(tvb, p), in_cksum_shouldbe(tvb_get_ntohs(tvb, p), csum));
add_shim6_checksum_additional_info(tvb, pinfo, ti, p, FALSE);
}
p += 2; p += 2;
/* Type specific data */ /* Type specific data */
@ -726,14 +698,9 @@ proto_register_shim6(void)
FT_UINT16, BASE_HEX, NULL, 0x0, FT_UINT16, BASE_HEX, NULL, 0x0,
"Shim6 Checksum", HFILL } "Shim6 Checksum", HFILL }
}, },
{ &hf_shim6_checksum_bad, { &hf_shim6_checksum_status,
{ "Bad Checksum", "shim6.checksum_bad", { "Checksum Status", "shim6.checksum.status",
FT_BOOLEAN, BASE_NONE, NULL, 0x0, FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0,
"Shim6 Bad Checksum", HFILL }
},
{ &hf_shim6_checksum_good,
{ "Good Checksum", "shim6.checksum_good",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
NULL, HFILL } NULL, HFILL }
}, },
{ &hf_shim6_inonce, { &hf_shim6_inonce,

23
epan/dissectors/packet-simple.c
View File

@ -247,7 +247,7 @@ static gint hf_simple_status_link11_pu = -1;
static gint hf_simple_status_link11_dts_host_status = -1; static gint hf_simple_status_link11_dts_host_status = -1;
static gint hf_simple_status_spare_3 = -1; static gint hf_simple_status_spare_3 = -1;
static gint hf_simple_checksum = -1; static gint hf_simple_checksum = -1;
static gint hf_simple_checksum_bad = -1; static gint hf_simple_checksum_status = -1;
static gint ett_simple = -1; static gint ett_simple = -1;
static gint ett_packet = -1; static gint ett_packet = -1;
@ -409,10 +409,6 @@ static void dissect_simple_status(tvbuff_t *tvb, packet_info *pinfo, proto_tree
static void dissect_checksum(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gint offset) static void dissect_checksum(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gint offset)
{ {
gint checksum = tvb_get_letohs(tvb, offset);
proto_item *checksum_item = proto_tree_add_item(tree, hf_simple_checksum, tvb, offset, 2, ENC_BIG_ENDIAN);
proto_item *hidden_item;
const guint8 * v = tvb_get_ptr(tvb, 0, offset); const guint8 * v = tvb_get_ptr(tvb, 0, offset);
guint16 expected_checksum = 0; guint16 expected_checksum = 0;
gint i; gint i;
@ -420,17 +416,8 @@ static void dissect_checksum(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree
for (i = 0; i < offset; i++) for (i = 0; i < offset; i++)
expected_checksum += v[i]; expected_checksum += v[i];
if (checksum == expected_checksum) { proto_tree_add_checksum(tree, tvb, offset, hf_simple_checksum, hf_simple_checksum_status, &ei_simple_checksum_bad, pinfo, expected_checksum,
hidden_item = proto_tree_add_boolean(tree, hf_simple_checksum_bad, tvb, offset, 2, FALSE); ENC_LITTLE_ENDIAN, PROTO_CHECKSUM_VERIFY);
PROTO_ITEM_SET_HIDDEN(hidden_item);
proto_item_append_text(checksum_item, " [correct]");
} else {
hidden_item = proto_tree_add_boolean(tree, hf_simple_checksum_bad, tvb, offset, 2, TRUE);
PROTO_ITEM_SET_HIDDEN(hidden_item);
proto_item_append_text(checksum_item, " [incorrect, should be 0x%04x]", expected_checksum);
expert_add_info_format(pinfo, checksum_item, &ei_simple_checksum_bad,
"SIMPLE Checksum Incorrect, should be 0x%04x", expected_checksum);
}
} }
static int dissect_simple(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_) static int dissect_simple(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
@ -669,8 +656,8 @@ void proto_register_simple(void)
{ &hf_simple_checksum, { &hf_simple_checksum,
{ "Checksum", "simple.checksum", FT_UINT16, BASE_HEX, NULL, 0x0, { "Checksum", "simple.checksum", FT_UINT16, BASE_HEX, NULL, 0x0,
NULL, HFILL }}, NULL, HFILL }},
{ &hf_simple_checksum_bad, { &hf_simple_checksum_status,
{ "Bad Checksum", "simple.checksum_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0, { "Checksum Status", "simple.checksum.status", FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0,
NULL, HFILL }} NULL, HFILL }}
}; };
static gint *ett[] = { static gint *ett[] = {

48
epan/dissectors/packet-sml.c
View File

@ -93,6 +93,7 @@ static int hf_sml_datatype = -1;
static int hf_sml_abortOnError = -1; static int hf_sml_abortOnError = -1;
static int hf_sml_MessageBody = -1; static int hf_sml_MessageBody = -1;
static int hf_sml_crc16 = -1; static int hf_sml_crc16 = -1;
static int hf_sml_crc16_status = -1;
static int hf_sml_endOfSmlMsg = -1; static int hf_sml_endOfSmlMsg = -1;
static int hf_sml_end = -1; static int hf_sml_end = -1;
static int hf_sml_codepage = -1; static int hf_sml_codepage = -1;
@ -2391,31 +2392,22 @@ static void dissect_sml_file(tvbuff_t *tvb, packet_info *pinfo, gint *offset, pr
proto_tree_add_item (crc16_tree, hf_sml_datatype, tvb, *offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item (crc16_tree, hf_sml_datatype, tvb, *offset, 1, ENC_BIG_ENDIAN);
*offset+=1; *offset+=1;
crc16 = proto_tree_add_item (crc16_tree, hf_sml_crc16, tvb, *offset, data, ENC_BIG_ENDIAN);
*offset+=data;
if (sml_crc_enabled) { if (sml_crc_enabled) {
crc_msg_len = (*offset - crc_msg_len - data - 1); crc_msg_len = (*offset - crc_msg_len - 1);
crc_check = crc16_ccitt_tvb_offset(tvb, (*offset - crc_msg_len - data - 1), crc_msg_len); crc_check = crc16_ccitt_tvb_offset(tvb, (*offset - crc_msg_len - 1), crc_msg_len);
crc_ref = tvb_get_letohs(tvb, *offset-2);
if (data == 1){ if (data == 1){
crc_ref = crc_ref & 0xFF00; crc_ref = crc_ref & 0xFF00;
} }
if (crc_check == crc_ref) { proto_tree_add_checksum(crc16_tree, tvb, *offset, hf_sml_crc16, hf_sml_crc16_status, &ei_sml_crc_error, pinfo, crc_check,
proto_item_append_text(crc16, " [CRC Okay]"); ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
}
else {
/*(little to big endian convert) to display in correct order*/
crc_check = ((crc_check >> 8) & 0xFF) + ((crc_check << 8 & 0xFF00));
proto_item_append_text(crc16, " [CRC Bad 0x%X]", crc_check);
expert_add_info(pinfo, crc16, &ei_sml_crc_error);
}
} }
else { else {
proto_item_append_text(crc16, " [CRC validation disabled]"); proto_tree_add_checksum(crc16_tree, tvb, *offset, hf_sml_crc16, hf_sml_crc16_status, &ei_sml_crc_error, pinfo, 0,
ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
} }
*offset+=data;
/*Message END*/ /*Message END*/
if (tvb_get_guint8 (tvb, *offset) == 0){ if (tvb_get_guint8 (tvb, *offset) == 0){
@ -2477,27 +2469,19 @@ static void dissect_sml_file(tvbuff_t *tvb, packet_info *pinfo, gint *offset, pr
*offset+=1; *offset+=1;
proto_tree_add_item (msgend_tree, hf_sml_padding, tvb, *offset, 1, ENC_NA); proto_tree_add_item (msgend_tree, hf_sml_padding, tvb, *offset, 1, ENC_NA);
*offset+=1; *offset+=1;
crc16 = proto_tree_add_item (msgend_tree, hf_sml_crc16, tvb, *offset, 2, ENC_BIG_ENDIAN);
*offset+=2;
if (sml_crc_enabled && sml_reassemble){ if (sml_crc_enabled && sml_reassemble){
crc_file_len = *offset - crc_file_len - 2; crc_file_len = *offset - crc_file_len;
crc_check = crc16_ccitt_tvb_offset(tvb,*offset-crc_file_len-2, crc_file_len); crc_check = crc16_ccitt_tvb_offset(tvb,*offset-crc_file_len, crc_file_len);
crc_ref = tvb_get_letohs(tvb, *offset-2);
if (crc_check == crc_ref){ proto_tree_add_checksum(msgend_tree, tvb, *offset, hf_sml_crc16, hf_sml_crc16_status, &ei_sml_crc_error, pinfo, crc_check,
proto_item_append_text(crc16, " [CRC Okay]"); ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
}
else{
/*(little to big endian convert) to display in correct order*/
crc_check = ((crc_check >> 8) & 0xFF) + ((crc_check << 8) & 0xFF00);
proto_item_append_text(crc16, " [CRC Bad 0x%X]", crc_check);
expert_add_info_format(pinfo, msgend, &ei_sml_crc_error, "CRC error (messages not reassembled ?)");
}
} }
else { else {
proto_item_append_text(crc16, " [CRC validation disabled]"); proto_tree_add_checksum(msgend_tree, tvb, *offset, hf_sml_crc16, hf_sml_crc16_status, &ei_sml_crc_error, pinfo, crc_check,
ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
} }
*offset+=2;
available = tvb_reported_length_remaining(tvb, *offset); available = tvb_reported_length_remaining(tvb, *offset);
if (available <= 0){ if (available <= 0){
@ -2556,6 +2540,8 @@ void proto_register_sml (void) {
{ "SML Version", "sml.version", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { "SML Version", "sml.version", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
{ &hf_sml_crc16, { &hf_sml_crc16,
{ "CRC16", "sml.crc", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { "CRC16", "sml.crc", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }},
{ &hf_sml_crc16_status,
{ "CRC16 Status", "sml.crc.status", FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0, NULL, HFILL }},
{ &hf_sml_endOfSmlMsg, { &hf_sml_endOfSmlMsg,
{ "End of SML Msg", "sml.end", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }}, { "End of SML Msg", "sml.end", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
{ &hf_sml_transactionId, { &hf_sml_transactionId,

75
epan/dissectors/packet-stt.c
View File

@ -74,9 +74,7 @@ static int hf_stt_pkt_len = -1;
static int hf_stt_seg_off = -1; static int hf_stt_seg_off = -1;
static int hf_stt_pkt_id = -1; static int hf_stt_pkt_id = -1;
static int hf_stt_checksum = -1; static int hf_stt_checksum = -1;
static int hf_stt_checksum_bad = -1; static int hf_stt_checksum_status = -1;
static int hf_stt_checksum_good = -1;
static int hf_stt_checksum_calculated = -1;
static int hf_stt_tcp_data = -1; static int hf_stt_tcp_data = -1;
static int hf_stt_tcp_data_offset = -1; static int hf_stt_tcp_data_offset = -1;
static int hf_stt_tcp_flags = -1; static int hf_stt_tcp_flags = -1;
@ -122,7 +120,6 @@ static int hf_reassembled_in = -1;
static int hf_reassembled_length = -1; static int hf_reassembled_length = -1;
static int ett_stt = -1; static int ett_stt = -1;
static int ett_stt_checksum = -1;
static int ett_stt_tcp_data = -1; static int ett_stt_tcp_data = -1;
static int ett_stt_tcp_flags = -1; static int ett_stt_tcp_flags = -1;
static int ett_stt_flgs = -1; static int ett_stt_flgs = -1;
@ -221,18 +218,7 @@ handle_segment(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
static void static void
dissect_stt_checksum(tvbuff_t *tvb, packet_info *pinfo, proto_tree *stt_tree) dissect_stt_checksum(tvbuff_t *tvb, packet_info *pinfo, proto_tree *stt_tree)
{ {
proto_tree *checksum_tree; gboolean can_checksum = !pinfo->fragmented &&
proto_item *item;
guint16 checksum = tvb_get_ntohs(tvb, 16);
gboolean can_checksum;
guint16 computed_cksum;
gboolean checksum_good = FALSE, checksum_bad = FALSE;
item = proto_tree_add_uint_format_value(stt_tree, hf_stt_checksum,
tvb, 16, 2, checksum,
"0x%04x", checksum);
can_checksum = !pinfo->fragmented &&
tvb_bytes_exist(tvb, 0, tvb_reported_length(tvb)); tvb_bytes_exist(tvb, 0, tvb_reported_length(tvb));
if (can_checksum && pref_check_checksum) { if (can_checksum && pref_check_checksum) {
@ -262,41 +248,13 @@ dissect_stt_checksum(tvbuff_t *tvb, packet_info *pinfo, proto_tree *stt_tree)
break; break;
} }
SET_CKSUM_VEC_TVB(cksum_vec[3], tvb, 0, tvb_reported_length(tvb)); SET_CKSUM_VEC_TVB(cksum_vec[3], tvb, 0, tvb_reported_length(tvb));
computed_cksum = in_cksum(cksum_vec, 4);
checksum_good = (computed_cksum == 0); proto_tree_add_checksum(stt_tree, tvb, 16, hf_stt_checksum, hf_stt_checksum_status, &ei_stt_checksum_bad, pinfo,
checksum_bad = !checksum_good; in_cksum(cksum_vec, 4), ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
if (checksum_good) {
proto_item_append_text(item, " [correct]");
} else if (checksum_bad) {
guint16 expected_cksum = in_cksum_shouldbe(checksum, computed_cksum);
proto_item_append_text(item, " [incorrect, should be 0x%04x (maybe caused by \"TCP checksum offload\"?)]",
expected_cksum);
expert_add_info(pinfo, item, &ei_stt_checksum_bad);
checksum = expected_cksum;
}
} else if (pref_check_checksum) {
proto_item_append_text(item, " [unchecked, not all data available]");
} else { } else {
proto_item_append_text(item, " [validation disabled]"); proto_tree_add_checksum(stt_tree, tvb, 16, hf_stt_checksum, hf_stt_checksum_status, &ei_stt_checksum_bad, pinfo,
0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
} }
checksum_tree = proto_item_add_subtree(item, ett_stt_checksum);
if (checksum_good || checksum_bad) {
item = proto_tree_add_uint(checksum_tree, hf_stt_checksum_calculated,
tvb, 16, 2, checksum);
PROTO_ITEM_SET_GENERATED(item);
}
item = proto_tree_add_boolean(checksum_tree, hf_stt_checksum_good, tvb,
16, 2, checksum_good);
PROTO_ITEM_SET_GENERATED(item);
item = proto_tree_add_boolean(checksum_tree, hf_stt_checksum_bad, tvb,
16, 2, checksum_bad);
PROTO_ITEM_SET_GENERATED(item);
} }
static int static int
@ -834,22 +792,10 @@ proto_register_stt(void)
"Details at: http://www.wireshark.org/docs/wsug_html_chunked/ChAdvChecksums.html", HFILL "Details at: http://www.wireshark.org/docs/wsug_html_chunked/ChAdvChecksums.html", HFILL
}, },
}, },
{ &hf_stt_checksum_good, { &hf_stt_checksum_status,
{ "Good Checksum", "stt.checksum.good", { "Checksum Status", "stt.checksum.status",
FT_BOOLEAN, BASE_NONE, NULL, 0x0, FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0,
"True: checksum matches packet content; False: doesn't match content or not checked", HFILL NULL, HFILL
},
},
{ &hf_stt_checksum_bad,
{ "Bad Checksum", "stt.checksum.bad",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"True: checksum doesn't match packet content; False: matches content or not checked", HFILL
},
},
{ &hf_stt_checksum_calculated,
{ "Calculated Checksum", "stt.checksum.calculated",
FT_UINT16, BASE_HEX, NULL, 0x0,
"The expected STT checksum field as calculated from the STT segment", HFILL
}, },
}, },
@ -923,7 +869,6 @@ proto_register_stt(void)
&ett_stt_tcp_flags, &ett_stt_tcp_flags,
&ett_stt_flgs, &ett_stt_flgs,
&ett_stt_vlan, &ett_stt_vlan,
&ett_stt_checksum,
&ett_segment, &ett_segment,
&ett_segments &ett_segments
}; };

Some files were not shown because too many files have changed in this diff Show More