From 34ee3cbc489444bf07818826519e176dc63f3307 Mon Sep 17 00:00:00 2001 From: David Perry Date: Wed, 28 Jul 2021 15:50:57 -0400 Subject: Change some `wmem_packet_scope()` to `pinfo->pool` As requested [here][1], help with replacing calls to `wmem_packet_scope()` with references to `pinfo->pool`. My principles were: * Plugins chosen semi-randomly. * When a calling function already has a `pinfo` argument, just use that. * Remove `_U_` from its signature if it was there. * Don't go more than 2 or 3 levels deep of changing signatures. * If a function is clearly allocing memory to return, change the function signature to take a `wmem_allocator_t *`. Otherwise, either that or take a `packet_info *` as seems to make sense. * No mention of `wmem_packet_scope()` should remain in the files I've touched. * I didn't always succeed at this, but I made a dent. [1]: https://www.wireshark.org/lists/wireshark-dev/202107/msg00052.html --- epan/dissectors/packet-opensafety.c | 42 ++++++++++++++++++------------------- 1 file changed, 21 insertions(+), 21 deletions(-) (limited to 'epan/dissectors/packet-opensafety.c') diff --git a/epan/dissectors/packet-opensafety.c b/epan/dissectors/packet-opensafety.c index d36804fbf9..b6559416e2 100644 --- a/epan/dissectors/packet-opensafety.c +++ b/epan/dissectors/packet-opensafety.c @@ -438,7 +438,7 @@ opensafety_packet_response(tvbuff_t *message_tvb, proto_tree *sub_tree, opensafe } static proto_tree * -opensafety_packet_payloadtree(tvbuff_t *message_tvb, proto_tree *opensafety_tree, +opensafety_packet_payloadtree(packet_info *pinfo, tvbuff_t *message_tvb, proto_tree *opensafety_tree, opensafety_packet_info *packet, gint ett_tree) { proto_item *item = NULL; @@ -447,21 +447,21 @@ opensafety_packet_payloadtree(tvbuff_t *message_tvb, proto_tree *opensafety_tree proto_item_set_generated(item); if ( packet->msg_type == OPENSAFETY_SNMT_MESSAGE_TYPE) - packet->payload.snmt = wmem_new0(wmem_packet_scope(), opensafety_packet_snmt); + packet->payload.snmt = wmem_new0(pinfo->pool, opensafety_packet_snmt); else if ( packet->msg_type == OPENSAFETY_SSDO_MESSAGE_TYPE || packet->msg_type == OPENSAFETY_SLIM_SSDO_MESSAGE_TYPE ) { - packet->payload.ssdo = wmem_new0(wmem_packet_scope(), opensafety_packet_ssdo); + packet->payload.ssdo = wmem_new0(pinfo->pool, opensafety_packet_ssdo); if ( packet->msg_type == OPENSAFETY_SLIM_SSDO_MESSAGE_TYPE ) packet->payload.ssdo->is_slim = TRUE; } else if ( packet->msg_type == OPENSAFETY_SPDO_MESSAGE_TYPE ) - packet->payload.spdo = wmem_new0(wmem_packet_scope(), opensafety_packet_spdo); + packet->payload.spdo = wmem_new0(pinfo->pool, opensafety_packet_spdo); return proto_item_add_subtree(item, ett_tree); } static guint16 -findFrame1Position ( tvbuff_t *message_tvb, guint16 byte_offset, guint8 dataLength, gboolean checkIfSlimMistake ) +findFrame1Position ( packet_info *pinfo, tvbuff_t *message_tvb, guint16 byte_offset, guint8 dataLength, gboolean checkIfSlimMistake ) { guint16 i_wFrame1Position = 0; guint16 i_payloadLength, i_calculatedLength = 0; @@ -489,7 +489,7 @@ findFrame1Position ( tvbuff_t *message_tvb, guint16 byte_offset, guint8 dataLeng else frameCRC = tvb_get_guint8(message_tvb, byte_offset + i_wFrame1Position + dataLength + OSS_FRAME_POS_DATA); - bytes = (guint8*)tvb_memdup(wmem_packet_scope(), message_tvb, byte_offset + i_wFrame1Position, dataLength + 4); + bytes = (guint8*)tvb_memdup(pinfo->pool, message_tvb, byte_offset + i_wFrame1Position, dataLength + 4); if ( dataLength > OSS_PAYLOAD_MAXSIZE_FOR_CRC8 ) { calcCRC = crc16_0x755B(bytes, dataLength + 4, 0); @@ -529,7 +529,7 @@ findFrame1Position ( tvbuff_t *message_tvb, guint16 byte_offset, guint8 dataLeng return i_wFrame1Position; } -static gboolean findSafetyFrame ( tvbuff_t *message_tvb, guint u_Offset, gboolean b_frame2first, +static gboolean findSafetyFrame ( packet_info *pinfo, tvbuff_t *message_tvb, guint u_Offset, gboolean b_frame2first, guint *u_frameOffset, guint *u_frameLength, opensafety_packet_info *packet ) { guint ctr, rem_length; @@ -609,7 +609,7 @@ static gboolean findSafetyFrame ( tvbuff_t *message_tvb, guint u_Offset, gboolea if ( b_Length != 0x00 || crc != 0x00 || b_CTl != 0x00 ) { /* calculate checksum */ - bytes = (guint8 *)tvb_memdup(wmem_packet_scope(), message_tvb, ctr - 1, b_Length + 5 ); + bytes = (guint8 *)tvb_memdup(pinfo->pool, message_tvb, ctr - 1, b_Length + 5 ); if ( b_Length > 8 ) { crc = tvb_get_letohs ( message_tvb, ctr + 3 + b_Length ); @@ -815,7 +815,7 @@ dissect_opensafety_spdo_message(tvbuff_t *message_tvb, packet_info *pinfo, proto addr, OSS_FRAME_POS_ADDR + packet->frame.subframe1, packet->frame.subframe2, sdn ); proto_item_append_text(opensafety_item, "; Producer: 0x%03X (%d)", addr, addr); - spdo_tree = opensafety_packet_payloadtree ( message_tvb, opensafety_tree, packet, ett_opensafety_spdo ); + spdo_tree = opensafety_packet_payloadtree ( pinfo, message_tvb, opensafety_tree, packet, ett_opensafety_spdo ); /* Determine SPDO Flags. Attention packet->payload.spdo exists ONLY AFTER opensafety_packet_payloadtree */ packet->payload.spdo->flags.enabled40bit = FALSE; @@ -1147,7 +1147,7 @@ dissect_opensafety_ssdo_message(tvbuff_t *message_tvb, packet_info *pinfo, proto ( OSS_FRAME_ADDR_T2(message_tvb, packet->frame.subframe2, packet->scm_udid[0], packet->scm_udid[1]) ) ) ); } - ssdo_tree = opensafety_packet_payloadtree ( message_tvb, opensafety_tree, packet, ett_opensafety_ssdo ); + ssdo_tree = opensafety_packet_payloadtree ( pinfo, message_tvb, opensafety_tree, packet, ett_opensafety_ssdo ); opensafety_packet_response ( message_tvb, ssdo_tree, packet, isResponse ); @@ -1385,7 +1385,7 @@ opensafety_parse_scm_udid ( tvbuff_t* tvb, packet_info *pinfo, proto_tree *tree, item = proto_tree_add_item(tree, hf_oss_snmt_udid, tvb, offset, 6, ENC_NA); - scm_udid_test = tvb_bytes_to_str_punct(wmem_packet_scope(), tvb, offset, 6, ':' ); + scm_udid_test = tvb_bytes_to_str_punct(pinfo->pool, tvb, offset, 6, ':' ); if ( scm_udid_test != NULL && strlen( scm_udid_test ) == 17 ) { @@ -1447,7 +1447,7 @@ dissect_opensafety_snmt_message(tvbuff_t *message_tvb, packet_info *pinfo, proto packet->frame.subframe2, sdn ); } - snmt_tree = opensafety_packet_payloadtree ( message_tvb, opensafety_tree, packet, ett_opensafety_snmt ); + snmt_tree = opensafety_packet_payloadtree ( pinfo, message_tvb, opensafety_tree, packet, ett_opensafety_snmt ); /* Just a precaution, cause payloadtree actually sets the snmt pointer */ if ( packet->payload.snmt == NULL ) return; @@ -1618,8 +1618,8 @@ dissect_opensafety_snmt_message(tvbuff_t *message_tvb, packet_info *pinfo, proto { if (dataLength > 0) { - packet->payload.snmt->sn_udid = wmem_strdup(wmem_packet_scope(), - tvb_bytes_to_str_punct(wmem_packet_scope(), message_tvb, OSS_FRAME_POS_DATA + packet->frame.subframe1 + 1, 6, ':' ) ); + packet->payload.snmt->sn_udid = wmem_strdup(pinfo->pool, + tvb_bytes_to_str_punct(pinfo->pool, message_tvb, OSS_FRAME_POS_DATA + packet->frame.subframe1 + 1, 6, ':' ) ); proto_tree_add_item(snmt_tree, hf_oss_snmt_udid, message_tvb, OSS_FRAME_POS_DATA + packet->frame.subframe1, 6, ENC_NA); } } @@ -1665,7 +1665,7 @@ dissect_opensafety_checksum(tvbuff_t *message_tvb, packet_info *pinfo, proto_tre checksum_tree = proto_item_add_subtree(item, ett_opensafety_checksum); - bytesf1 = (guint8*)tvb_memdup(wmem_packet_scope(), message_tvb, packet->frame.subframe1, dataLength + 4); + bytesf1 = (guint8*)tvb_memdup(pinfo->pool, message_tvb, packet->frame.subframe1, dataLength + 4); crcType = packet->crc.type; calc1_crc = packet->crc.frame1; @@ -1704,7 +1704,7 @@ dissect_opensafety_checksum(tvbuff_t *message_tvb, packet_info *pinfo, proto_tre * to calculate the second crc, meaning, if the SCM udid is known, or if we have an SNMT msg */ if ( isSNMT || packet->scm_udid_valid ) { - bytesf2 = (guint8*)tvb_memdup(wmem_packet_scope(), message_tvb, packet->frame.subframe2, frame2Length + length); + bytesf2 = (guint8*)tvb_memdup(pinfo->pool, message_tvb, packet->frame.subframe2, frame2Length + length); /* SLIM SSDO messages, do not contain a payload in frame2 */ if ( isSlim == TRUE ) @@ -2034,10 +2034,10 @@ opensafety_package_dissector(const gchar *protocolName, const gchar *sub_diss_ha /* Resetting packet, to ensure, that findSafetyFrame starts with a fresh frame. * As only packet_scope is used, this will not polute memory too much and get's * cleared with the next packet anyway */ - packet = wmem_new0(wmem_packet_scope(), opensafety_packet_info); + packet = wmem_new0(pinfo->pool, opensafety_packet_info); /* Finding the start of the first possible safety frame */ - if ( findSafetyFrame(message_tvb, frameOffset, b_frame2First, &frameOffset, &frameLength, packet) ) + if ( findSafetyFrame(pinfo, message_tvb, frameOffset, b_frame2First, &frameOffset, &frameLength, packet) ) { /* if packet msg_id is not null, it still might be an incorrect frame, as there is no validity * check in findSafetyFrame for the msg id (this happens later in this routine) @@ -2052,7 +2052,7 @@ opensafety_package_dissector(const gchar *protocolName, const gchar *sub_diss_ha /* We determine a possible position for frame 1 and frame 2 */ if ( b_frame2First ) { - frameStart1 = findFrame1Position (message_tvb, byte_offset, frameLength, FALSE ); + frameStart1 = findFrame1Position (pinfo, message_tvb, byte_offset, frameLength, FALSE ); frameStart2 = 0; } else @@ -2089,7 +2089,7 @@ opensafety_package_dissector(const gchar *protocolName, const gchar *sub_diss_ha if ( b_frame2First ) { /* Now let's check again, but this time calculate the CRC */ - frameStart1 = findFrame1Position(message_tvb, ( b_frame2First ? 0 : frameOffset ), frameLength, TRUE ); + frameStart1 = findFrame1Position(pinfo, message_tvb, ( b_frame2First ? 0 : frameOffset ), frameLength, TRUE ); frameStart2 = 0; packet->msg_id = OSS_FRAME_ID_T(message_tvb, byte_offset + frameStart1); @@ -2481,7 +2481,7 @@ dissect_opensafety_udpdata(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree /* check for openSAFETY frame at beginning of data */ - frameFound = findSafetyFrame(message_tvb, 0, global_udp_frame2_first, &frameOffset, &frameLength, NULL ); + frameFound = findSafetyFrame(pinfo, message_tvb, 0, global_udp_frame2_first, &frameOffset, &frameLength, NULL ); if ( ! frameFound || ( frameOffset >= 11 ) ) { dissector_handle_t udp_transport = find_dissector ( "opensafety_udp_transport" ); -- cgit v1.2.3