diff --git a/src/compiler.h b/src/compiler.h
index 18e1a32..5a2b28e 100644
--- a/src/compiler.h
+++ b/src/compiler.h
@@ -19,6 +19,8 @@
 		      "`unused` attribute is required");
 	static_assert(__has_attribute(warn_unused_result),
 		      "`warn_unused_result` attribute is required");
+	static_assert(__has_attribute(cleanup),
+		      "`cleanup` attribute is required");
 	int compliance;
 } pldm_required_attributes __attribute__((unused));
 
@@ -30,6 +32,7 @@
 #error Missing definition for LIBPLDM_CC_NONNULL
 #endif
 
+#define LIBPLDM_CC_CLEANUP(fn)	      __attribute__((cleanup(fn)))
 #define LIBPLDM_CC_NONNULL_ARGS(...)  __attribute__((nonnull(__VA_ARGS__)))
 #define LIBPLDM_CC_UNUSED	      __attribute__((unused))
 #define LIBPLDM_CC_WARN_UNUSED_RESULT __attribute__((warn_unused_result))
diff --git a/src/dsp/firmware_update.c b/src/dsp/firmware_update.c
index cf27fe7..955fe1c 100644
--- a/src/dsp/firmware_update.c
+++ b/src/dsp/firmware_update.c
@@ -517,8 +517,7 @@
 int decode_pldm_descriptor_from_iter(struct pldm_descriptor_iter *iter,
 				     struct pldm_descriptor *desc)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (!iter || !iter->field || !desc) {
@@ -534,7 +533,7 @@
 	pldm_msgbuf_extract(buf, desc->descriptor_type);
 	rc = pldm_msgbuf_extract(buf, desc->descriptor_length);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	desc->descriptor_data = NULL;
@@ -816,9 +815,8 @@
 	const struct pldm_descriptor *descriptors, struct pldm_msg *msg,
 	size_t *payload_length)
 {
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
 
 	if (descriptors == NULL || msg == NULL || payload_length == NULL) {
 		return -EINVAL;
@@ -856,14 +854,14 @@
 		pldm_msgbuf_insert(buf, d->descriptor_type);
 		pldm_msgbuf_insert(buf, d->descriptor_length);
 		if (d->descriptor_data == NULL) {
-			return -EINVAL;
+			return pldm_msgbuf_discard(buf, -EINVAL);
 		}
 		rc = pldm_msgbuf_insert_array(
 			buf, d->descriptor_length,
 			(const uint8_t *)d->descriptor_data,
 			d->descriptor_length);
 		if (rc) {
-			return rc;
+			return pldm_msgbuf_discard(buf, rc);
 		}
 	}
 
@@ -992,9 +990,8 @@
 	const struct pldm_get_firmware_parameters_resp_full *resp_data,
 	struct pldm_msg *msg, size_t *payload_length)
 {
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
 
 	if (resp_data == NULL || msg == NULL || payload_length == NULL) {
 		return -EINVAL;
@@ -1028,14 +1025,14 @@
 		resp_data->active_comp_image_set_ver_str.str_data,
 		resp_data->active_comp_image_set_ver_str.str_len);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 	rc = pldm_msgbuf_insert_array(
 		buf, resp_data->pending_comp_image_set_ver_str.str_len,
 		resp_data->pending_comp_image_set_ver_str.str_data,
 		resp_data->pending_comp_image_set_ver_str.str_len);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	/* Further calls to encode_get_firmware_parameters_resp_comp_entry
@@ -1049,9 +1046,8 @@
 	const struct pldm_component_parameter_entry_full *comp,
 	uint8_t *payload, size_t *payload_length)
 {
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
 
 	if (comp == NULL || payload == NULL || payload_length == NULL) {
 		return -EINVAL;
@@ -1073,7 +1069,7 @@
 				      comp->active_ver.date,
 				      PLDM_FWUP_COMPONENT_RELEASE_DATA_LEN);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	pldm_msgbuf_insert(buf, comp->pending_ver.comparison_stamp);
@@ -1083,7 +1079,7 @@
 				      comp->pending_ver.date,
 				      PLDM_FWUP_COMPONENT_RELEASE_DATA_LEN);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	pldm_msgbuf_insert(buf, comp->comp_activation_methods.value);
@@ -1093,13 +1089,13 @@
 				      comp->active_ver.str.str_data,
 				      comp->active_ver.str.str_len);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 	rc = pldm_msgbuf_insert_array(buf, comp->pending_ver.str.str_len,
 				      comp->pending_ver.str.str_data,
 				      comp->pending_ver.str.str_len);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	return pldm_msgbuf_complete_used(buf, *payload_length, payload_length);
@@ -1200,8 +1196,7 @@
 	const struct pldm_msg *msg, size_t payload_length,
 	struct pldm_query_downstream_devices_resp *resp_data)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (msg == NULL || resp_data == NULL || !payload_length) {
@@ -1216,26 +1211,26 @@
 
 	rc = pldm_msgbuf_extract(buf, resp_data->completion_code);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 	if (PLDM_SUCCESS != resp_data->completion_code) {
 		// Return the CC directly without decoding the rest of the payload
-		return 0;
+		return pldm_msgbuf_complete(buf);
 	}
 
 	if (payload_length < PLDM_QUERY_DOWNSTREAM_DEVICES_RESP_BYTES) {
-		return -EBADMSG;
+		return pldm_msgbuf_discard(buf, -EBADMSG);
 	}
 
 	rc = pldm_msgbuf_extract(buf,
 				 resp_data->downstream_device_update_supported);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	if (!is_downstream_device_update_support_valid(
 		    resp_data->downstream_device_update_supported)) {
-		return -EINVAL;
+		return pldm_msgbuf_discard(buf, -EINVAL);
 	}
 
 	pldm_msgbuf_extract(buf, resp_data->number_of_downstream_devices);
@@ -1251,8 +1246,7 @@
 	const struct pldm_query_downstream_identifiers_req *params_req,
 	struct pldm_msg *msg, size_t payload_length)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (!msg || !params_req) {
@@ -1295,8 +1289,7 @@
 	struct pldm_query_downstream_identifiers_resp *resp_data,
 	struct pldm_downstream_device_iter *iter)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	void *remaining = NULL;
 	int rc = 0;
 
@@ -1313,14 +1306,14 @@
 
 	rc = pldm_msgbuf_extract(buf, resp_data->completion_code);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 	if (PLDM_SUCCESS != resp_data->completion_code) {
-		return 0;
+		return pldm_msgbuf_complete(buf);
 	}
 
 	if (payload_length < PLDM_QUERY_DOWNSTREAM_IDENTIFIERS_RESP_MIN_LEN) {
-		return -EBADMSG;
+		return pldm_msgbuf_discard(buf, -EBADMSG);
 	}
 
 	pldm_msgbuf_extract(buf, resp_data->next_data_transfer_handle);
@@ -1328,15 +1321,12 @@
 
 	rc = pldm_msgbuf_extract(buf, resp_data->downstream_devices_length);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	pldm_msgbuf_extract(buf, resp_data->number_of_downstream_devices);
-	rc = pldm_msgbuf_span_required(
-		buf, resp_data->downstream_devices_length, &remaining);
-	if (rc) {
-		return rc;
-	}
+	pldm_msgbuf_span_required(buf, resp_data->downstream_devices_length,
+				  &remaining);
 
 	rc = pldm_msgbuf_complete(buf);
 	if (rc) {
@@ -1355,11 +1345,10 @@
 	struct pldm_downstream_device_iter *iter,
 	struct pldm_downstream_device *dev)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
-	if (!iter || !dev) {
+	if (!iter || !iter->field.ptr || !dev) {
 		return -EINVAL;
 	}
 
@@ -1371,7 +1360,6 @@
 
 	pldm_msgbuf_extract(buf, dev->downstream_device_index);
 	pldm_msgbuf_extract(buf, dev->downstream_descriptor_count);
-	iter->field.ptr = NULL;
 	pldm_msgbuf_span_remaining(buf, (void **)&iter->field.ptr,
 				   &iter->field.length);
 
@@ -1384,8 +1372,7 @@
 	const struct pldm_get_downstream_firmware_parameters_req *params_req,
 	struct pldm_msg *msg, size_t payload_length)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (!msg || !params_req) {
@@ -1428,8 +1415,7 @@
 	struct pldm_get_downstream_firmware_parameters_resp *resp_data,
 	struct pldm_downstream_device_parameters_iter *iter)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	void *remaining = NULL;
 	size_t length;
 	int rc;
@@ -1446,15 +1432,15 @@
 
 	rc = pldm_msgbuf_extract(buf, resp_data->completion_code);
 	if (rc < 0) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 	if (PLDM_SUCCESS != resp_data->completion_code) {
-		return 0;
+		return pldm_msgbuf_complete(buf);
 	}
 
 	if (payload_length <
 	    PLDM_GET_DOWNSTREAM_FIRMWARE_PARAMETERS_RESP_MIN_LEN) {
-		return -EBADMSG;
+		return pldm_msgbuf_discard(buf, -EBADMSG);
 	}
 
 	pldm_msgbuf_extract(buf, resp_data->next_data_transfer_handle);
@@ -1465,7 +1451,7 @@
 
 	rc = pldm_msgbuf_span_remaining(buf, &remaining, &length);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	rc = pldm_msgbuf_complete(buf);
@@ -1485,14 +1471,13 @@
 	struct pldm_downstream_device_parameters_iter *iter,
 	struct pldm_downstream_device_parameters_entry *entry)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	void *comp_ver_str;
 	size_t remaining;
 	void *cursor;
 	int rc;
 
-	if (iter == NULL || entry == NULL) {
+	if (iter == NULL || iter->field.ptr == NULL || entry == NULL) {
 		return -EINVAL;
 	}
 
@@ -1508,14 +1493,14 @@
 	pldm_msgbuf_extract(buf, entry->active_comp_ver_str_type);
 	rc = pldm_msgbuf_extract(buf, entry->active_comp_ver_str_len);
 	if (rc < 0) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 	rc = pldm_msgbuf_extract_array(buf,
 				       PLDM_FWUP_COMPONENT_RELEASE_DATA_LEN,
 				       entry->active_comp_release_date,
 				       sizeof(entry->active_comp_release_date));
 	if (rc < 0) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	// Fill the last byte with NULL character
@@ -1526,7 +1511,7 @@
 	pldm_msgbuf_extract(buf, entry->pending_comp_ver_str_type);
 	rc = pldm_msgbuf_extract(buf, entry->pending_comp_ver_str_len);
 	if (rc < 0) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	rc = pldm_msgbuf_extract_array(
@@ -1534,7 +1519,7 @@
 		entry->pending_comp_release_date,
 		sizeof(entry->pending_comp_release_date));
 	if (rc < 0) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	// Fill the last byte with NULL character
@@ -1544,26 +1529,29 @@
 	pldm_msgbuf_extract(buf, entry->comp_activation_methods.value);
 	pldm_msgbuf_extract(buf, entry->capabilities_during_update.value);
 
-	comp_ver_str = NULL;
-	pldm_msgbuf_span_required(buf, entry->active_comp_ver_str_len,
-				  &comp_ver_str);
+	rc = pldm_msgbuf_span_required(buf, entry->active_comp_ver_str_len,
+				       &comp_ver_str);
+	if (rc < 0) {
+		return pldm_msgbuf_discard(buf, rc);
+	}
 	entry->active_comp_ver_str = comp_ver_str;
 
-	comp_ver_str = NULL;
-	pldm_msgbuf_span_required(buf, entry->pending_comp_ver_str_len,
-				  &comp_ver_str);
+	rc = pldm_msgbuf_span_required(buf, entry->pending_comp_ver_str_len,
+				       &comp_ver_str);
+	if (rc < 0) {
+		return pldm_msgbuf_discard(buf, rc);
+	}
 	entry->pending_comp_ver_str = comp_ver_str;
 
-	cursor = NULL;
 	rc = pldm_msgbuf_span_remaining(buf, &cursor, &remaining);
 	if (rc < 0) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	iter->field.ptr = cursor;
 	iter->field.length = remaining;
 
-	return 0;
+	return pldm_msgbuf_complete(buf);
 }
 
 LIBPLDM_ABI_STABLE
@@ -1632,8 +1620,7 @@
 {
 	int rc;
 	uint8_t t;
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 
 	if (msg == NULL || req == NULL) {
 		return -EINVAL;
@@ -1650,22 +1637,22 @@
 	pldm_msgbuf_extract(buf, req->pkg_data_len);
 	rc = pldm_msgbuf_extract(buf, t);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 	if (t > PLDM_STR_TYPE_UTF_16BE) {
-		return -EBADMSG;
+		return pldm_msgbuf_discard(buf, -EBADMSG);
 	}
 	req->image_set_ver.str_type = (enum pldm_firmware_update_string_type)t;
 	pldm_msgbuf_extract(buf, req->image_set_ver.str_len);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	rc = pldm_msgbuf_extract_array(buf, req->image_set_ver.str_len,
 				       req->image_set_ver.str_data,
 				       PLDM_FIRMWARE_MAX_STRING);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	return pldm_msgbuf_complete_consumed(buf);
@@ -1706,9 +1693,8 @@
 			       const struct pldm_request_update_resp *resp_data,
 			       struct pldm_msg *msg, size_t *payload_length)
 {
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
 
 	if (msg == NULL || payload_length == NULL) {
 		return -EINVAL;
@@ -1806,8 +1792,7 @@
 {
 	int rc;
 	uint8_t t;
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 
 	if (msg == NULL || pcomp == NULL) {
 		return -EINVAL;
@@ -1825,21 +1810,21 @@
 	pldm_msgbuf_extract(buf, pcomp->comp_comparison_stamp);
 	rc = pldm_msgbuf_extract(buf, t);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 	if (t > PLDM_STR_TYPE_UTF_16BE) {
-		return -EBADMSG;
+		return pldm_msgbuf_discard(buf, -EBADMSG);
 	}
 	pcomp->version.str_type = (enum pldm_firmware_update_string_type)t;
 	rc = pldm_msgbuf_extract(buf, pcomp->version.str_len);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 	rc = pldm_msgbuf_extract_array(buf, pcomp->version.str_len,
 				       pcomp->version.str_data,
 				       PLDM_FIRMWARE_MAX_STRING);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	return pldm_msgbuf_complete_consumed(buf);
@@ -1889,9 +1874,8 @@
 	const struct pldm_pass_component_table_resp *resp_data,
 	struct pldm_msg *msg, size_t *payload_length)
 {
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
 
 	if (msg == NULL || payload_length == NULL) {
 		return -EINVAL;
@@ -1981,8 +1965,7 @@
 {
 	int rc;
 	uint8_t t;
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 
 	if (msg == NULL || up == NULL) {
 		return -EINVAL;
@@ -2001,28 +1984,24 @@
 	pldm_msgbuf_extract(buf, up->update_option_flags.value);
 	rc = pldm_msgbuf_extract(buf, t);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 	if (t > PLDM_STR_TYPE_UTF_16BE) {
-		return -EBADMSG;
+		return pldm_msgbuf_discard(buf, -EBADMSG);
 	}
 	up->version.str_type = (enum pldm_firmware_update_string_type)t;
 	rc = pldm_msgbuf_extract(buf, up->version.str_len);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 	rc = pldm_msgbuf_extract_array(buf, up->version.str_len,
 				       up->version.str_data,
 				       PLDM_FIRMWARE_MAX_STRING);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
-	if (buf->remaining != 0) {
-		return -EINVAL;
-	}
-
-	return 0;
+	return pldm_msgbuf_complete_consumed(buf);
 }
 
 LIBPLDM_ABI_STABLE
@@ -2078,9 +2057,8 @@
 	uint8_t instance_id, const struct pldm_update_component_resp *resp_data,
 	struct pldm_msg *msg, size_t *payload_length)
 {
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
 
 	if (msg == NULL || payload_length == NULL) {
 		return -EINVAL;
@@ -2135,9 +2113,8 @@
 	const struct pldm_request_firmware_data_req *req_params,
 	struct pldm_msg *msg, size_t *payload_length)
 {
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
 
 	if (msg == NULL || payload_length == NULL) {
 		return -EINVAL;
@@ -2206,9 +2183,8 @@
 int encode_transfer_complete_req(uint8_t instance_id, uint8_t transfer_result,
 				 struct pldm_msg *msg, size_t *payload_length)
 {
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
 
 	if (msg == NULL || payload_length == NULL) {
 		return -EINVAL;
@@ -2225,10 +2201,7 @@
 		return rc;
 	}
 
-	rc = pldm_msgbuf_insert(buf, transfer_result);
-	if (rc) {
-		return rc;
-	}
+	pldm_msgbuf_insert(buf, transfer_result);
 
 	return pldm_msgbuf_complete_used(buf, *payload_length, payload_length);
 }
@@ -2280,9 +2253,8 @@
 int encode_verify_complete_req(uint8_t instance_id, uint8_t verify_result,
 			       struct pldm_msg *msg, size_t *payload_length)
 {
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
 
 	if (msg == NULL || payload_length == NULL) {
 		return -EINVAL;
@@ -2299,10 +2271,7 @@
 		return rc;
 	}
 
-	rc = pldm_msgbuf_insert(buf, verify_result);
-	if (rc) {
-		return rc;
-	}
+	pldm_msgbuf_insert(buf, verify_result);
 
 	return pldm_msgbuf_complete_used(buf, *payload_length, payload_length);
 }
@@ -2368,9 +2337,8 @@
 			      const struct pldm_apply_complete_req *req_data,
 			      struct pldm_msg *msg, size_t *payload_length)
 {
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
 
 	if (msg == NULL || payload_length == NULL) {
 		return -EINVAL;
@@ -2425,9 +2393,9 @@
 int decode_activate_firmware_req(const struct pldm_msg *msg,
 				 size_t payload_length, bool *self_contained)
 {
+	uint8_t self_contained_u8 = 0;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
 
 	if (msg == NULL || self_contained == NULL) {
 		return -EINVAL;
@@ -2438,14 +2406,13 @@
 		return 0;
 	}
 
-	uint8_t self_contained_u8 = 0;
-	rc = pldm_msgbuf_extract(buf, self_contained_u8);
+	pldm_msgbuf_extract(buf, self_contained_u8);
+
+	rc = pldm_msgbuf_complete_consumed(buf);
 	if (rc) {
 		return rc;
 	}
-	if (buf->remaining != 0) {
-		return -EOVERFLOW;
-	}
+
 	*self_contained = (bool)self_contained_u8;
 	return 0;
 }
@@ -2521,9 +2488,8 @@
 	const struct pldm_activate_firmware_resp *resp_data,
 	struct pldm_msg *msg, size_t *payload_length)
 {
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
 
 	if (msg == NULL || payload_length == NULL) {
 		return -EINVAL;
@@ -2643,9 +2609,8 @@
 			   const struct pldm_get_status_resp *status,
 			   struct pldm_msg *msg, size_t *payload_length)
 {
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
 
 	if (status == NULL || msg == NULL || payload_length == NULL) {
 		return -EINVAL;
@@ -2790,9 +2755,8 @@
 			      const struct pldm_cancel_update_resp *resp_data,
 			      struct pldm_msg *msg, size_t *payload_length)
 {
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
 
 	if (msg == NULL || payload_length == NULL) {
 		return -EINVAL;
diff --git a/src/dsp/pdr.c b/src/dsp/pdr.c
index 789ceeb..2d90821 100644
--- a/src/dsp/pdr.c
+++ b/src/dsp/pdr.c
@@ -1553,28 +1553,21 @@
 	int rc = 0;
 	uint16_t header_length = 0;
 	uint8_t num_children = 0;
-	struct pldm_msgbuf _src;
-	struct pldm_msgbuf *src = &_src;
-	struct pldm_msgbuf _dst;
-	struct pldm_msgbuf *dst = &_dst;
+	PLDM_MSGBUF_DEFINE_P(src);
+	PLDM_MSGBUF_DEFINE_P(dst);
 
 	pldm_pdr_find_record_by_handle(&record, &prev, pdr_record_handle);
 
 	if (!record) {
 		return -EINVAL;
 	}
-	// Initialize msg buffer for record and record->data
-	rc = pldm_msgbuf_init_errno(src, PDR_ENTITY_ASSOCIATION_MIN_SIZE,
-				    record->data, record->size);
-	if (rc) {
-		return rc;
-	}
 
 	// check if adding another entity to record causes overflow before
 	// allocating memory for new_record.
 	if (record->size + sizeof(pldm_entity) < sizeof(pldm_entity)) {
 		return -EOVERFLOW;
 	}
+
 	pldm_pdr_record *new_record = malloc(sizeof(pldm_pdr_record));
 	if (!new_record) {
 		return -ENOMEM;
@@ -1590,12 +1583,19 @@
 	new_record->size = record->size + sizeof(struct pldm_entity);
 	new_record->is_remote = record->is_remote;
 
+	// Initialize msg buffer for record and record->data
+	rc = pldm_msgbuf_init_errno(src, PDR_ENTITY_ASSOCIATION_MIN_SIZE,
+				    record->data, record->size);
+	if (rc) {
+		goto cleanup_new_record_data;
+	}
+
 	// Initialize new PDR record with data from original PDR record.
 	// Start with adding the header of original PDR
 	rc = pldm_msgbuf_init_errno(dst, PDR_ENTITY_ASSOCIATION_MIN_SIZE,
 				    new_record->data, new_record->size);
 	if (rc) {
-		goto cleanup_new_record_data;
+		goto cleanup_src_msgbuf;
 	}
 
 	pldm_msgbuf_copy(dst, src, uint32_t, hdr_record_handle);
@@ -1606,13 +1606,13 @@
 	// size of pldm_entity before inserting the value into new_record.
 	rc = pldm_msgbuf_extract(src, header_length);
 	if (rc) {
-		goto cleanup_new_record_data;
+		goto cleanup_dst_msgbuf;
 	}
 	static_assert(UINT16_MAX < (SIZE_MAX - sizeof(pldm_entity)),
 		      "Fix the following bounds check.");
 	if (header_length + sizeof(pldm_entity) > UINT16_MAX) {
 		rc = -EOVERFLOW;
-		goto cleanup_new_record_data;
+		goto cleanup_dst_msgbuf;
 	}
 	header_length += sizeof(pldm_entity);
 	pldm_msgbuf_insert(dst, header_length);
@@ -1625,11 +1625,11 @@
 	// by 1 before insert the value to new record.
 	rc = pldm_msgbuf_extract(src, num_children);
 	if (rc) {
-		goto cleanup_new_record_data;
+		goto cleanup_dst_msgbuf;
 	}
 	if (num_children == UINT8_MAX) {
 		rc = -EOVERFLOW;
-		goto cleanup_new_record_data;
+		goto cleanup_dst_msgbuf;
 	}
 	num_children += 1;
 	pldm_msgbuf_insert(dst, num_children);
@@ -1643,23 +1643,25 @@
 	// Add new contained entity as a child of new PDR
 	rc = pldm_msgbuf_complete(src);
 	if (rc) {
+		rc = pldm_msgbuf_discard(dst, rc);
 		goto cleanup_new_record_data;
 	}
 	rc = pldm_msgbuf_init_errno(src, sizeof(struct pldm_entity), entity,
 				    sizeof(struct pldm_entity));
 	if (rc) {
+		rc = pldm_msgbuf_discard(dst, rc);
 		goto cleanup_new_record_data;
 	}
 	pldm_msgbuf_copy(dst, src, uint16_t, child_entity_type);
 	pldm_msgbuf_copy(dst, src, uint16_t, child_entity_instance_num);
 	pldm_msgbuf_copy(dst, src, uint16_t, child_entity_container_id);
 
-	rc = pldm_msgbuf_complete(src);
-	if (rc) {
-		goto cleanup_new_record_data;
-	}
 	rc = pldm_msgbuf_complete(dst);
 	if (rc) {
+		goto cleanup_src_msgbuf;
+	}
+	rc = pldm_msgbuf_complete(src);
+	if (rc) {
 		goto cleanup_new_record_data;
 	}
 
@@ -1671,6 +1673,10 @@
 	free(record->data);
 	free(record);
 	return rc;
+cleanup_dst_msgbuf:
+	rc = pldm_msgbuf_discard(dst, rc);
+cleanup_src_msgbuf:
+	rc = pldm_msgbuf_discard(src, rc);
 cleanup_new_record_data:
 	free(new_record->data);
 cleanup_new_record:
@@ -1697,12 +1703,9 @@
 	uint16_t new_pdr_size;
 	uint16_t container_id = 0;
 	void *container_id_addr;
-	struct pldm_msgbuf _dst;
-	struct pldm_msgbuf *dst = &_dst;
-	struct pldm_msgbuf _src_p;
-	struct pldm_msgbuf *src_p = &_src_p;
-	struct pldm_msgbuf _src_c;
-	struct pldm_msgbuf *src_c = &_src_c;
+	PLDM_MSGBUF_DEFINE_P(dst);
+	PLDM_MSGBUF_DEFINE_P(src_p);
+	PLDM_MSGBUF_DEFINE_P(src_c);
 	int rc = 0;
 
 	pldm_pdr_record *prev = repo->first;
@@ -1757,13 +1760,13 @@
 	rc = pldm_msgbuf_init_errno(src_p, sizeof(struct pldm_entity), parent,
 				    sizeof(*parent));
 	if (rc) {
-		goto cleanup_new_record_data;
+		goto cleanup_msgbuf_dst;
 	}
 
 	rc = pldm_msgbuf_init_errno(src_c, sizeof(struct pldm_entity), entity,
 				    sizeof(*entity));
 	if (rc) {
-		goto cleanup_new_record_data;
+		goto cleanup_msgbuf_src_p;
 	}
 
 	container_id_addr = NULL;
@@ -1771,7 +1774,7 @@
 	rc = pldm_msgbuf_span_required(dst, sizeof(container_id),
 				       (void **)&container_id_addr);
 	if (rc) {
-		goto cleanup_new_record_data;
+		goto cleanup_msgbuf_src_c;
 	}
 	assert(container_id_addr);
 	pldm_msgbuf_insert_uint8(dst, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
@@ -1791,15 +1794,15 @@
 	container_id = htole16(container_id);
 	memcpy(container_id_addr, &container_id, sizeof(uint16_t));
 
-	rc = pldm_msgbuf_complete(dst);
+	rc = pldm_msgbuf_complete(src_c);
 	if (rc) {
-		goto cleanup_new_record_data;
+		goto cleanup_msgbuf_src_p;
 	}
 	rc = pldm_msgbuf_complete(src_p);
 	if (rc) {
-		goto cleanup_new_record_data;
+		goto cleanup_msgbuf_dst;
 	}
-	rc = pldm_msgbuf_complete(src_c);
+	rc = pldm_msgbuf_complete(dst);
 	if (rc) {
 		goto cleanup_new_record_data;
 	}
@@ -1810,6 +1813,12 @@
 	}
 
 	return rc;
+cleanup_msgbuf_src_c:
+	rc = pldm_msgbuf_discard(src_c, rc);
+cleanup_msgbuf_src_p:
+	rc = pldm_msgbuf_discard(src_p, rc);
+cleanup_msgbuf_dst:
+	rc = pldm_msgbuf_discard(dst, rc);
 cleanup_new_record_data:
 	free(new_record->data);
 cleanup_new_record:
@@ -1839,10 +1848,10 @@
 	int rc = 0;
 	size_t skip_data_size = 0;
 	pldm_pdr_record *record = repo->first;
-	struct pldm_msgbuf _dst;
-	struct pldm_msgbuf *dst = &_dst;
 
 	while (record != NULL) {
+		PLDM_MSGBUF_DEFINE_P(dst);
+
 		rc = pldm_msgbuf_init_errno(dst,
 					    PDR_ENTITY_ASSOCIATION_MIN_SIZE,
 					    record->data, record->size);
@@ -1851,7 +1860,10 @@
 		}
 		skip_data_size = sizeof(uint32_t) + sizeof(uint8_t);
 		pldm_msgbuf_span_required(dst, skip_data_size, NULL);
-		pldm_msgbuf_extract(dst, hdr_type);
+		rc = pldm_msgbuf_extract(dst, hdr_type);
+		if (rc) {
+			return pldm_msgbuf_discard(dst, rc);
+		}
 		if (record->is_remote != is_remote ||
 		    hdr_type != PLDM_PDR_ENTITY_ASSOCIATION) {
 			goto cleanup;
@@ -1860,7 +1872,10 @@
 				 sizeof(uint16_t) + sizeof(uint8_t) +
 				 sizeof(struct pldm_entity);
 		pldm_msgbuf_span_required(dst, skip_data_size, NULL);
-		pldm_msgbuf_extract(dst, num_children);
+		rc = pldm_msgbuf_extract(dst, num_children);
+		if (rc) {
+			return pldm_msgbuf_discard(dst, rc);
+		}
 		for (int i = 0; i < num_children; ++i) {
 			struct pldm_entity e;
 
@@ -1869,12 +1884,12 @@
 						      e.entity_instance_num)) ||
 			    (rc = pldm_msgbuf_extract(dst,
 						      e.entity_container_id))) {
-				return rc;
+				return pldm_msgbuf_discard(dst, rc);
 			}
 
 			if (pldm_entity_cmp(entity, &e)) {
 				*record_handle = record->record_handle;
-				return 0;
+				return pldm_msgbuf_complete(dst);
 			}
 		}
 	cleanup:
@@ -1894,10 +1909,8 @@
 {
 	uint16_t header_length = 0;
 	uint8_t num_children = 0;
-	struct pldm_msgbuf _src;
-	struct pldm_msgbuf *src = &_src;
-	struct pldm_msgbuf _dst;
-	struct pldm_msgbuf *dst = &_dst;
+	PLDM_MSGBUF_DEFINE_P(src);
+	PLDM_MSGBUF_DEFINE_P(dst);
 	int rc;
 	pldm_pdr_record *record;
 	pldm_pdr_record *prev;
@@ -1917,12 +1930,6 @@
 	if (!record) {
 		return -EINVAL;
 	}
-	// Initialize msg buffer for record and record->data
-	rc = pldm_msgbuf_init_errno(src, PDR_ENTITY_ASSOCIATION_MIN_SIZE,
-				    record->data, record->size);
-	if (rc) {
-		return rc;
-	}
 	// check if removing an entity from record causes overflow before
 	// allocating memory for new_record.
 	if (record->size < sizeof(pldm_entity)) {
@@ -1941,13 +1948,20 @@
 	new_record->size = record->size - sizeof(struct pldm_entity);
 	new_record->is_remote = record->is_remote;
 
+	// Initialize msg buffer for record and record->data
+	rc = pldm_msgbuf_init_errno(src, PDR_ENTITY_ASSOCIATION_MIN_SIZE,
+				    record->data, record->size);
+	if (rc) {
+		goto cleanup_new_record_data;
+	}
+
 	// Initialize new PDR record with data from original PDR record.
 	// Start with adding the header of original PDR
 	rc = pldm_msgbuf_init_errno(
 		dst, (PDR_ENTITY_ASSOCIATION_MIN_SIZE - sizeof(pldm_entity)),
 		new_record->data, new_record->size);
 	if (rc) {
-		goto cleanup_new_record_data;
+		goto cleanup_msgbuf_src;
 	}
 	pldm_msgbuf_copy(dst, src, uint32_t, hdr_record_handle);
 	pldm_msgbuf_copy(dst, src, uint8_t, hdr_version);
@@ -1957,11 +1971,11 @@
 	// size of pldm_entity before inserting the value into new_record.
 	rc = pldm_msgbuf_extract(src, header_length);
 	if (rc) {
-		goto cleanup_new_record_data;
+		goto cleanup_msgbuf_dst;
 	}
 	if (header_length < sizeof(pldm_entity)) {
 		rc = -EOVERFLOW;
-		goto cleanup_new_record_data;
+		goto cleanup_msgbuf_dst;
 	}
 	header_length -= sizeof(pldm_entity);
 	pldm_msgbuf_insert(dst, header_length);
@@ -1974,16 +1988,16 @@
 	// by 1 before insert the value to new record.
 	rc = pldm_msgbuf_extract(src, num_children);
 	if (rc) {
-		goto cleanup_new_record_data;
+		goto cleanup_msgbuf_dst;
 	}
 	if (num_children == 1) {
 		// This is the last child which is getting removed so we need to delete the Entity Association PDR.
 		pldm_pdr_remove_record(repo, record,
 				       pldm_pdr_get_prev_record(repo, record));
-		goto cleanup_new_record_data;
+		goto cleanup_msgbuf_dst;
 	} else if (num_children < 1) {
 		rc = -EOVERFLOW;
-		goto cleanup_new_record_data;
+		goto cleanup_msgbuf_dst;
 	}
 	num_children -= 1;
 	pldm_msgbuf_insert(dst, num_children);
@@ -1994,7 +2008,7 @@
 		if ((rc = pldm_msgbuf_extract(src, e.entity_type)) ||
 		    (rc = pldm_msgbuf_extract(src, e.entity_instance_num)) ||
 		    (rc = pldm_msgbuf_extract(src, e.entity_container_id))) {
-			goto cleanup_new_record_data;
+			goto cleanup_msgbuf_dst;
 		}
 
 		if (pldm_entity_cmp(entity, &e)) {
@@ -2006,9 +2020,18 @@
 		pldm_msgbuf_insert(dst, e.entity_container_id);
 	}
 
-	if ((rc = pldm_msgbuf_complete(src)) ||
-	    (rc = pldm_msgbuf_complete(dst)) ||
-	    (rc = pldm_pdr_replace_record(repo, record, prev, new_record))) {
+	rc = pldm_msgbuf_complete(dst);
+	if (rc) {
+		goto cleanup_msgbuf_src;
+	}
+
+	rc = pldm_msgbuf_complete(src);
+	if (rc) {
+		goto cleanup_new_record_data;
+	}
+
+	rc = pldm_pdr_replace_record(repo, record, prev, new_record);
+	if (rc) {
 		goto cleanup_new_record_data;
 	}
 
@@ -2016,6 +2039,10 @@
 	free(record);
 	return rc;
 
+cleanup_msgbuf_dst:
+	rc = pldm_msgbuf_discard(dst, rc);
+cleanup_msgbuf_src:
+	rc = pldm_msgbuf_discard(src, rc);
 cleanup_new_record_data:
 	free(new_record->data);
 cleanup_new_record:
@@ -2066,8 +2093,7 @@
 	uint16_t record_fru_rsi = 0;
 	uint8_t *skip_data = NULL;
 	uint8_t skip_data_size = 0;
-	struct pldm_msgbuf _dst;
-	struct pldm_msgbuf *dst = &_dst;
+	PLDM_MSGBUF_DEFINE_P(dst);
 	int rc = 0;
 
 	rc = pldm_msgbuf_init_errno(dst, PDR_FRU_RECORD_SET_MIN_SIZE,
@@ -2141,20 +2167,22 @@
 	record = repo->first;
 
 	while (record != NULL) {
-		struct pldm_msgbuf _buf;
-		struct pldm_msgbuf *buf = &_buf;
+		PLDM_MSGBUF_DEFINE_P(buf);
+
 		rc = pldm_msgbuf_init_errno(buf, PDR_FRU_RECORD_SET_MIN_SIZE,
 					    record->data, record->size);
 		if (rc) {
 			return rc;
 		}
 		pldm_msgbuf_span_required(buf, skip_data_size, NULL);
-		if ((rc = pldm_msgbuf_extract(buf, hdr_type))) {
+		pldm_msgbuf_extract(buf, hdr_type);
+		rc = pldm_msgbuf_complete(buf);
+		if (rc) {
 			return rc;
 		}
 		if (record->is_remote != is_remote ||
 		    hdr_type != PLDM_PDR_FRU_RECORD_SET) {
-			goto cleanup;
+			goto next;
 		}
 		match = pldm_pdr_record_matches_fru_rsi(record, fru_rsi);
 		if (match < 0) {
@@ -2165,11 +2193,7 @@
 			prev = pldm_pdr_get_prev_record(repo, record);
 			return pldm_pdr_remove_record(repo, record, prev);
 		}
-	cleanup:
-		rc = pldm_msgbuf_complete(buf);
-		if (rc) {
-			return rc;
-		}
+	next:
 		record = record->next;
 	}
 	return rc;
diff --git a/src/dsp/platform.c b/src/dsp/platform.c
index b37de42..0d5d917 100644
--- a/src/dsp/platform.c
+++ b/src/dsp/platform.c
@@ -265,8 +265,7 @@
 					 uint8_t *comp_effecter_count,
 					 set_effecter_state_field *field)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 	int i;
 
@@ -287,10 +286,13 @@
 	}
 
 	pldm_msgbuf_extract_p(buf, effecter_id);
-	pldm_msgbuf_extract_p(buf, comp_effecter_count);
+	rc = pldm_msgbuf_extract_p(buf, comp_effecter_count);
+	if (rc) {
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
+	}
 
 	if (*comp_effecter_count > 8) {
-		return PLDM_ERROR_INVALID_DATA;
+		return pldm_msgbuf_discard(buf, PLDM_ERROR_INVALID_DATA);
 	}
 
 	for (i = 0; i < *comp_effecter_count; i++) {
@@ -312,8 +314,7 @@
 		       uint8_t *transfer_op_flag, uint16_t *request_cnt,
 		       uint16_t *record_chg_num)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (msg == NULL || record_hndl == NULL || data_transfer_hndl == NULL ||
@@ -447,8 +448,7 @@
 	uint32_t *repository_size, uint32_t *largest_record_size,
 	uint8_t *data_transfer_handle_timeout)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (msg == NULL || completion_code == NULL ||
@@ -466,32 +466,35 @@
 		return pldm_xlate_errno(rc);
 	}
 
-	pldm_msgbuf_extract_p(buf, completion_code);
+	rc = pldm_msgbuf_extract_p(buf, completion_code);
+	if (rc) {
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
+	}
 	if (PLDM_SUCCESS != *completion_code) {
 		return PLDM_SUCCESS;
 	}
 
 	rc = pldm_msgbuf_extract_p(buf, repository_state);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 
 	if (*repository_state > PLDM_FAILED) {
-		return PLDM_ERROR_INVALID_DATA;
+		return pldm_msgbuf_discard(buf, PLDM_ERROR_INVALID_DATA);
 	}
 
 	/* NOTE: Memory safety */
 	rc = pldm_msgbuf_extract_array(buf, PLDM_TIMESTAMP104_SIZE, update_time,
 				       PLDM_TIMESTAMP104_SIZE);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 
 	/* NOTE: Memory safety */
 	rc = pldm_msgbuf_extract_array(buf, PLDM_TIMESTAMP104_SIZE,
 				       oem_update_time, PLDM_TIMESTAMP104_SIZE);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 
 	pldm_msgbuf_extract_p(buf, record_count);
@@ -512,8 +515,7 @@
 	const struct pldm_msg *msg, size_t payload_length,
 	struct pldm_pdr_repository_info_resp *resp)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (msg == NULL || resp == NULL) {
@@ -535,7 +537,7 @@
 
 	rc = pldm_msgbuf_extract(buf, resp->completion_code);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	pldm_msgbuf_extract(buf, resp->repository_state);
@@ -544,14 +546,14 @@
 				       resp->update_time,
 				       sizeof(resp->update_time));
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	rc = pldm_msgbuf_extract_array(buf, sizeof(resp->oem_update_time),
 				       resp->oem_update_time,
 				       sizeof(resp->oem_update_time));
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	pldm_msgbuf_extract(buf, resp->record_count);
@@ -606,8 +608,7 @@
 			uint8_t *record_data, size_t record_data_length,
 			uint8_t *transfer_crc)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (msg == NULL || completion_code == NULL ||
@@ -624,11 +625,11 @@
 
 	rc = pldm_msgbuf_extract_p(buf, completion_code);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 
 	if (PLDM_SUCCESS != *completion_code) {
-		return PLDM_SUCCESS;
+		return pldm_msgbuf_complete(buf);
 	}
 
 	pldm_msgbuf_extract_p(buf, next_record_hndl);
@@ -636,18 +637,19 @@
 	pldm_msgbuf_extract_p(buf, transfer_flag);
 	rc = pldm_msgbuf_extract_p(buf, resp_cnt);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 
 	if (*resp_cnt > 0 && record_data != NULL) {
 		if (record_data_length < *resp_cnt) {
-			return PLDM_ERROR_INVALID_LENGTH;
+			return pldm_msgbuf_discard(buf,
+						   PLDM_ERROR_INVALID_LENGTH);
 		}
 		/* NOTE: Memory safety */
 		rc = pldm_msgbuf_extract_array(buf, *resp_cnt, record_data,
 					       *resp_cnt);
 		if (rc) {
-			return pldm_xlate_errno(rc);
+			return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 		}
 	}
 
@@ -668,8 +670,7 @@
 			     struct pldm_get_pdr_resp *resp, size_t resp_len,
 			     uint8_t *transfer_crc)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (msg == NULL || resp == NULL || transfer_crc == NULL) {
@@ -694,19 +695,19 @@
 
 	rc = pldm_msgbuf_extract(buf, resp->transfer_flag);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	rc = pldm_msgbuf_extract(buf, resp->response_count);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	rc = pldm_msgbuf_extract_array(
 		buf, resp->response_count, resp->record_data,
 		resp_len - (sizeof(*resp) - sizeof(resp->record_data)));
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	if (resp->transfer_flag == PLDM_END) {
@@ -723,8 +724,7 @@
 					  uint8_t *effecter_data_size,
 					  uint8_t effecter_value[4])
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (msg == NULL || effecter_id == NULL || effecter_data_size == NULL ||
@@ -742,11 +742,11 @@
 	pldm_msgbuf_extract_p(buf, effecter_id);
 	rc = pldm_msgbuf_extract_p(buf, effecter_data_size);
 	if (rc) {
-		return PLDM_ERROR_INVALID_DATA;
+		return pldm_msgbuf_discard(buf, PLDM_ERROR_INVALID_DATA);
 	}
 
 	if (*effecter_data_size > PLDM_EFFECTER_DATA_SIZE_SINT32) {
-		return PLDM_ERROR_INVALID_DATA;
+		return pldm_msgbuf_discard(buf, PLDM_ERROR_INVALID_DATA);
 	}
 
 	pldm_msgbuf_extract_effecter_value(buf, *effecter_data_size,
@@ -948,8 +948,7 @@
 					  uint8_t *comp_sensor_count,
 					  get_sensor_state_field *field)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	uint8_t i;
 	int rc;
 
@@ -967,20 +966,20 @@
 
 	rc = pldm_msgbuf_extract_p(buf, completion_code);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 
 	if (PLDM_SUCCESS != *completion_code) {
-		return PLDM_SUCCESS;
+		return pldm_msgbuf_discard(buf, PLDM_SUCCESS);
 	}
 
 	rc = pldm_msgbuf_extract_p(buf, comp_sensor_count);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 
 	if (*comp_sensor_count < 0x1 || *comp_sensor_count > 0x8) {
-		return PLDM_ERROR_INVALID_DATA;
+		return pldm_msgbuf_discard(buf, PLDM_ERROR_INVALID_DATA);
 	}
 
 	for (i = 0; i < *comp_sensor_count; i++) {
@@ -1005,8 +1004,7 @@
 					 bitfield8_t *sensor_rearm,
 					 uint8_t *reserved)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (msg == NULL || sensor_id == NULL || sensor_rearm == NULL) {
@@ -1075,8 +1073,7 @@
 				      uint8_t *event_class,
 				      size_t *event_data_offset)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (msg == NULL || format_version == NULL || tid == NULL ||
@@ -1130,8 +1127,7 @@
 	uint8_t *format_version, uint8_t *transfer_operation_flag,
 	uint32_t *data_transfer_handle, uint16_t *event_id_to_acknowledge)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (msg == NULL || format_version == NULL ||
@@ -1150,22 +1146,22 @@
 	pldm_msgbuf_extract_p(buf, format_version);
 	rc = pldm_msgbuf_extract_p(buf, transfer_operation_flag);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 	if (*transfer_operation_flag > PLDM_ACKNOWLEDGEMENT_ONLY) {
-		return PLDM_ERROR_INVALID_DATA;
+		return pldm_msgbuf_discard(buf, PLDM_ERROR_INVALID_DATA);
 	}
 
 	pldm_msgbuf_extract_p(buf, data_transfer_handle);
 	rc = pldm_msgbuf_extract_p(buf, event_id_to_acknowledge);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 
 	rc = pldm_platform_poll_for_platform_event_message_validate(
 		*transfer_operation_flag, *event_id_to_acknowledge);
 	if (rc < 0) {
-		return PLDM_ERROR_INVALID_DATA;
+		return pldm_msgbuf_discard(buf, PLDM_ERROR_INVALID_DATA);
 	}
 
 	rc = pldm_msgbuf_complete(buf);
@@ -1217,8 +1213,7 @@
 	uint8_t *event_data, uint32_t checksum, struct pldm_msg *msg,
 	size_t payload_length)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (!msg) {
@@ -1247,13 +1242,14 @@
 	pldm_msgbuf_insert(buf, tid);
 	rc = pldm_msgbuf_insert(buf, event_id);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 
 	if (event_id == 0xffff || event_id == 0x0000) {
 		if (PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_MIN_RESP_BYTES !=
 		    payload_length) {
-			return PLDM_ERROR_INVALID_LENGTH;
+			return pldm_msgbuf_discard(buf,
+						   PLDM_ERROR_INVALID_LENGTH);
 		}
 
 		rc = pldm_msgbuf_complete(buf);
@@ -1265,7 +1261,7 @@
 	}
 
 	if ((event_data == NULL) && (event_data_size > 0)) {
-		return PLDM_ERROR_INVALID_DATA;
+		return pldm_msgbuf_discard(buf, PLDM_ERROR_INVALID_DATA);
 	}
 
 	pldm_msgbuf_insert(buf, next_data_transfer_handle);
@@ -1273,14 +1269,14 @@
 	pldm_msgbuf_insert(buf, event_class);
 	rc = pldm_msgbuf_insert(buf, event_data_size);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 
 	if ((event_data_size > 0) && event_data) {
 		rc = pldm_msgbuf_insert_array(buf, event_data_size, event_data,
 					      event_data_size);
 		if (rc) {
-			return pldm_xlate_errno(rc);
+			return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 		}
 	}
 
@@ -1357,8 +1353,7 @@
 				       uint8_t *completion_code,
 				       uint8_t *platform_event_status)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (msg == NULL || completion_code == NULL ||
@@ -1374,20 +1369,20 @@
 
 	rc = pldm_msgbuf_extract_p(buf, completion_code);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 
 	if (PLDM_SUCCESS != *completion_code) {
-		return PLDM_SUCCESS;
+		return pldm_msgbuf_discard(buf, PLDM_SUCCESS);
 	}
 
 	rc = pldm_msgbuf_extract_p(buf, platform_event_status);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 
 	if (*platform_event_status > PLDM_EVENT_LOGGING_REJECTED) {
-		return PLDM_ERROR_INVALID_DATA;
+		return pldm_msgbuf_discard(buf, PLDM_ERROR_INVALID_DATA);
 	}
 
 	rc = pldm_msgbuf_complete(buf);
@@ -1428,8 +1423,7 @@
 					  uint8_t *completion_code,
 					  uint16_t *terminus_max_buffer_size)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (msg == NULL || completion_code == NULL ||
@@ -1446,11 +1440,11 @@
 
 	rc = pldm_msgbuf_extract_p(buf, completion_code);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 
 	if (PLDM_SUCCESS != *completion_code) {
-		return PLDM_SUCCESS;
+		return pldm_msgbuf_discard(buf, PLDM_SUCCESS);
 	}
 
 	pldm_msgbuf_extract_p(buf, terminus_max_buffer_size);
@@ -1504,8 +1498,7 @@
 					uint8_t *event_class,
 					uint8_t event_class_count)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int i;
 	int rc;
 
@@ -1524,27 +1517,27 @@
 
 	rc = pldm_msgbuf_extract_p(buf, completion_code);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 
 	if (PLDM_SUCCESS != *completion_code) {
-		return PLDM_SUCCESS;
+		return pldm_msgbuf_discard(buf, PLDM_SUCCESS);
 	}
 
 	rc = pldm_msgbuf_extract_p(buf, synchrony_config);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 
 	if (*synchrony_config > PLDM_MESSAGE_TYPE_ASYNCHRONOUS_WITH_HEARTBEAT) {
-		return PLDM_ERROR_INVALID_DATA;
+		return pldm_msgbuf_discard(buf, PLDM_ERROR_INVALID_DATA);
 	}
 
 	pldm_msgbuf_extract_p(buf, &synchrony_config_support->byte);
 
 	rc = pldm_msgbuf_extract_p(buf, number_event_class_returned);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 
 	if (*number_event_class_returned == 0) {
@@ -1557,7 +1550,7 @@
 	}
 
 	if (event_class_count < *number_event_class_returned) {
-		return PLDM_ERROR_INVALID_LENGTH;
+		return pldm_msgbuf_discard(buf, PLDM_ERROR_INVALID_LENGTH);
 	}
 
 	for (i = 0; i < *number_event_class_returned; i++) {
@@ -1578,8 +1571,7 @@
 			     uint8_t *sensor_event_class_type,
 			     size_t *event_class_data_offset)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (event_data == NULL || sensor_id == NULL ||
@@ -1595,7 +1587,7 @@
 	}
 
 	if (event_data_length < PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES) {
-		return PLDM_ERROR_INVALID_LENGTH;
+		return pldm_msgbuf_discard(buf, PLDM_ERROR_INVALID_LENGTH);
 	}
 
 	size_t event_class_data_length =
@@ -1604,28 +1596,31 @@
 	pldm_msgbuf_extract_p(buf, sensor_id);
 	rc = pldm_msgbuf_extract_p(buf, sensor_event_class_type);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 
 	if (*sensor_event_class_type == PLDM_SENSOR_OP_STATE) {
 		if (event_class_data_length !=
 		    PLDM_SENSOR_EVENT_SENSOR_OP_STATE_DATA_LENGTH) {
-			return PLDM_ERROR_INVALID_LENGTH;
+			return pldm_msgbuf_discard(buf,
+						   PLDM_ERROR_INVALID_LENGTH);
 		}
 	} else if (*sensor_event_class_type == PLDM_STATE_SENSOR_STATE) {
 		if (event_class_data_length !=
 		    PLDM_SENSOR_EVENT_STATE_SENSOR_STATE_DATA_LENGTH) {
-			return PLDM_ERROR_INVALID_LENGTH;
+			return pldm_msgbuf_discard(buf,
+						   PLDM_ERROR_INVALID_LENGTH);
 		}
 	} else if (*sensor_event_class_type == PLDM_NUMERIC_SENSOR_STATE) {
 		if (event_class_data_length <
 			    PLDM_SENSOR_EVENT_NUMERIC_SENSOR_STATE_MIN_DATA_LENGTH ||
 		    event_class_data_length >
 			    PLDM_SENSOR_EVENT_NUMERIC_SENSOR_STATE_MAX_DATA_LENGTH) {
-			return PLDM_ERROR_INVALID_LENGTH;
+			return pldm_msgbuf_discard(buf,
+						   PLDM_ERROR_INVALID_LENGTH);
 		}
 	} else {
-		return PLDM_ERROR_INVALID_DATA;
+		return pldm_msgbuf_discard(buf, PLDM_ERROR_INVALID_DATA);
 	}
 
 	*event_class_data_offset =
@@ -1643,8 +1638,7 @@
 int decode_sensor_op_data(const uint8_t *sensor_data, size_t sensor_data_length,
 			  uint8_t *present_op_state, uint8_t *previous_op_state)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (sensor_data == NULL || present_op_state == NULL ||
@@ -1676,8 +1670,7 @@
 			     uint8_t *event_state,
 			     uint8_t *previous_event_state)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (sensor_data == NULL || sensor_offset == NULL ||
@@ -1711,8 +1704,7 @@
 			       uint8_t *sensor_data_size,
 			       uint32_t *present_reading)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (sensor_data == NULL || sensor_data_size == NULL ||
@@ -1737,7 +1729,7 @@
 	pldm_msgbuf_extract_p(buf, previous_event_state);
 	rc = pldm_msgbuf_extract_p(buf, sensor_data_size);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 
 	/*
@@ -1789,7 +1781,7 @@
 		break;
 	}
 	default:
-		return PLDM_ERROR_INVALID_DATA;
+		return pldm_msgbuf_discard(buf, PLDM_ERROR_INVALID_DATA);
 	}
 
 	rc = pldm_msgbuf_complete_consumed(buf);
@@ -1805,10 +1797,13 @@
 	const void *pdr_data, size_t pdr_data_length,
 	struct pldm_numeric_sensor_value_pdr *pdr_value)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
+	if (!pdr_data || !pdr_value) {
+		return PLDM_ERROR_INVALID_DATA;
+	}
+
 	rc = pldm_msgbuf_init_errno(buf, PLDM_PDR_NUMERIC_SENSOR_PDR_MIN_LENGTH,
 				    pdr_data, pdr_data_length);
 	if (rc) {
@@ -1819,7 +1814,7 @@
 		buf, &pdr_value->hdr, PLDM_PDR_NUMERIC_SENSOR_PDR_MIN_LENGTH,
 		pdr_data_length);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 
 	pldm_msgbuf_extract(buf, pdr_value->terminus_handle);
@@ -1842,10 +1837,10 @@
 
 	rc = pldm_msgbuf_extract(buf, pdr_value->sensor_data_size);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 	if (pdr_value->sensor_data_size > PLDM_SENSOR_DATA_SIZE_MAX) {
-		return PLDM_ERROR_INVALID_DATA;
+		return pldm_msgbuf_discard(buf, PLDM_ERROR_INVALID_DATA);
 	}
 
 	pldm_msgbuf_extract(buf, pdr_value->resolution);
@@ -1867,10 +1862,10 @@
 
 	rc = pldm_msgbuf_extract(buf, pdr_value->range_field_format);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 	if (pdr_value->range_field_format > PLDM_RANGE_FIELD_FORMAT_MAX) {
-		return PLDM_ERROR_INVALID_DATA;
+		return pldm_msgbuf_discard(buf, PLDM_ERROR_INVALID_DATA);
 	}
 
 	pldm_msgbuf_extract(buf, pdr_value->range_field_support.byte);
@@ -2014,8 +2009,7 @@
 					  size_t payload_length,
 					  uint16_t *effecter_id)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (msg == NULL || effecter_id == NULL) {
@@ -2048,8 +2042,7 @@
 					   uint8_t *pending_value,
 					   uint8_t *present_value)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (msg == NULL || effecter_data_size == NULL ||
@@ -2067,29 +2060,29 @@
 
 	rc = pldm_msgbuf_extract_p(buf, completion_code);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 
 	if (PLDM_SUCCESS != *completion_code) {
-		return PLDM_SUCCESS;
+		return pldm_msgbuf_discard(buf, PLDM_SUCCESS);
 	}
 
 	rc = pldm_msgbuf_extract_p(buf, effecter_data_size);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 
 	if (*effecter_data_size > PLDM_EFFECTER_DATA_SIZE_SINT32) {
-		return PLDM_ERROR_INVALID_DATA;
+		return pldm_msgbuf_discard(buf, PLDM_ERROR_INVALID_DATA);
 	}
 
 	rc = pldm_msgbuf_extract_p(buf, effecter_oper_state);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 
 	if (*effecter_oper_state > EFFECTER_OPER_STATE_INTEST) {
-		return PLDM_ERROR_INVALID_DATA;
+		return pldm_msgbuf_discard(buf, PLDM_ERROR_INVALID_DATA);
 	}
 
 	pldm_msgbuf_extract_effecter_value(buf, *effecter_data_size,
@@ -2176,8 +2169,7 @@
 					      uint8_t *number_of_change_records,
 					      size_t *change_record_data_offset)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (event_data == NULL || event_data_format == NULL ||
@@ -2212,8 +2204,7 @@
 	const void *event_data, size_t event_data_length,
 	struct pldm_message_poll_event *poll_event)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (!event_data || !poll_event) {
@@ -2229,11 +2220,11 @@
 	pldm_msgbuf_extract(buf, poll_event->format_version);
 	rc = pldm_msgbuf_extract(buf, poll_event->event_id);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	if (poll_event->event_id == 0x0000 || poll_event->event_id == 0xffff) {
-		return -EPROTO;
+		return pldm_msgbuf_discard(buf, -EPROTO);
 	}
 
 	pldm_msgbuf_extract(buf, poll_event->data_transfer_handle);
@@ -2246,8 +2237,7 @@
 	const struct pldm_message_poll_event *poll_event, void *event_data,
 	size_t event_data_length)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (poll_event == NULL || event_data == NULL) {
@@ -2276,8 +2266,7 @@
 	uint8_t *event_data_operation, uint8_t *number_of_change_entries,
 	size_t *change_entry_data_offset)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (change_record_data == NULL || event_data_operation == NULL ||
@@ -2344,8 +2333,7 @@
 	uint8_t *present_state, uint8_t *previous_state, uint8_t *event_state,
 	uint8_t *present_reading)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (msg == NULL || completion_code == NULL ||
@@ -2364,20 +2352,20 @@
 
 	rc = pldm_msgbuf_extract_p(buf, completion_code);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 
 	if (PLDM_SUCCESS != *completion_code) {
-		return PLDM_SUCCESS;
+		return pldm_msgbuf_discard(buf, PLDM_SUCCESS);
 	}
 
 	rc = pldm_msgbuf_extract_p(buf, sensor_data_size);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 
 	if (*sensor_data_size > PLDM_SENSOR_DATA_SIZE_SINT32) {
-		return PLDM_ERROR_INVALID_DATA;
+		return pldm_msgbuf_discard(buf, PLDM_ERROR_INVALID_DATA);
 	}
 
 	pldm_msgbuf_extract_p(buf, sensor_operational_state);
@@ -2473,8 +2461,7 @@
 				  size_t payload_length, uint16_t *sensor_id,
 				  uint8_t *rearm_event_state)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (msg == NULL || sensor_id == NULL || rearm_event_state == NULL) {
@@ -2548,8 +2535,7 @@
 				   size_t payload_length,
 				   uint8_t *completion_code)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (msg == NULL || completion_code == NULL) {
@@ -2581,8 +2567,7 @@
 				  uint16_t *heartbeat_timer)
 
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (msg == NULL || event_message_global_enable == NULL ||
@@ -2599,7 +2584,7 @@
 
 	pldm_msgbuf_extract_p(buf, event_message_global_enable);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 
 	pldm_msgbuf_extract_p(buf, transport_protocol_type);
@@ -2657,8 +2642,7 @@
 					       struct pldm_msg *msg,
 					       size_t payload_length)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (msg == NULL) {
@@ -2710,8 +2694,7 @@
 	uint8_t *event_class, uint32_t *event_data_size, void **event_data,
 	uint32_t *event_data_integrity_checksum)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (msg == NULL || completion_code == NULL || tid == NULL ||
@@ -2731,34 +2714,34 @@
 
 	rc = pldm_msgbuf_extract_p(buf, completion_code);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 	if (PLDM_SUCCESS != *completion_code) {
-		return *completion_code;
+		return pldm_msgbuf_discard(buf, *completion_code);
 	}
 
 	pldm_msgbuf_extract_p(buf, tid);
 	rc = pldm_msgbuf_extract_p(buf, event_id);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 	if ((*event_id == 0) || (*event_id == 0xffff)) {
-		return PLDM_SUCCESS;
+		return pldm_msgbuf_discard(buf, PLDM_SUCCESS);
 	}
 
 	pldm_msgbuf_extract_p(buf, next_data_transfer_handle);
 	rc = pldm_msgbuf_extract_p(buf, transfer_flag);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 
 	pldm_msgbuf_extract_p(buf, event_class);
 	rc = pldm_msgbuf_extract_p(buf, event_data_size);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 	if (*event_data_size > payload_length) {
-		return PLDM_ERROR_INVALID_DATA;
+		return pldm_msgbuf_discard(buf, PLDM_ERROR_INVALID_DATA);
 	}
 
 	if (*event_data_size > 0) {
@@ -2783,8 +2766,7 @@
 	const void *pdr_data, size_t pdr_data_length,
 	struct pldm_numeric_effecter_value_pdr *pdr_value)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	struct pldm_value_pdr_hdr hdr;
 	int rc;
 
@@ -2828,10 +2810,10 @@
 
 	rc = pldm_msgbuf_extract(buf, pdr_value->effecter_data_size);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 	if (pdr_value->effecter_data_size > PLDM_SENSOR_DATA_SIZE_MAX) {
-		return PLDM_ERROR_INVALID_DATA;
+		return pldm_msgbuf_discard(buf, PLDM_ERROR_INVALID_DATA);
 	}
 
 	pldm_msgbuf_extract(buf, pdr_value->resolution);
@@ -2848,10 +2830,10 @@
 
 	rc = pldm_msgbuf_extract(buf, pdr_value->range_field_format);
 	if (rc) {
-		return pldm_xlate_errno(rc);
+		return pldm_xlate_errno(pldm_msgbuf_discard(buf, rc));
 	}
 	if (pdr_value->range_field_format > PLDM_RANGE_FIELD_FORMAT_MAX) {
-		return PLDM_ERROR_INVALID_DATA;
+		return pldm_msgbuf_discard(buf, PLDM_ERROR_INVALID_DATA);
 	}
 
 	pldm_msgbuf_extract(buf, pdr_value->range_field_support.byte);
@@ -2880,8 +2862,7 @@
 					 struct pldm_msg *msg,
 					 size_t payload_length)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (msg == NULL) {
@@ -2916,8 +2897,7 @@
 					 size_t payload_length,
 					 uint16_t *effecter_id)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (msg == NULL || effecter_id == NULL) {
@@ -2941,8 +2921,7 @@
 	const struct pldm_msg *msg, size_t payload_length,
 	struct pldm_get_state_effecter_states_resp *resp)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	get_effecter_state_field *field;
 	int rc;
 	int i;
@@ -2960,23 +2939,23 @@
 
 	rc = pldm_msgbuf_extract(buf, resp->completion_code);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	if (PLDM_SUCCESS != resp->completion_code) {
-		return 0;
+		return pldm_msgbuf_complete(buf);
 	}
 
 	rc = pldm_msgbuf_extract(buf, resp->comp_effecter_count);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	uint8_t comp_effecter_count = resp->comp_effecter_count;
 
 	if (comp_effecter_count < PLDM_GET_EFFECTER_STATE_FIELD_COUNT_MIN ||
 	    comp_effecter_count > PLDM_GET_EFFECTER_STATE_FIELD_COUNT_MAX) {
-		return -EBADMSG;
+		return pldm_msgbuf_discard(buf, -EBADMSG);
 	}
 
 	for (i = 0, field = resp->field; i < comp_effecter_count;
@@ -2994,8 +2973,7 @@
 	uint8_t instance_id, struct pldm_get_state_effecter_states_resp *resp,
 	struct pldm_msg *msg, size_t payload_length)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	get_effecter_state_field *field;
 	int rc;
 	int i;
@@ -3047,12 +3025,9 @@
 	const void *data, size_t data_length,
 	struct pldm_entity_auxiliary_names_pdr *pdr, size_t pdr_length)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
-	struct pldm_msgbuf _src;
-	struct pldm_msgbuf *src = &_src;
-	struct pldm_msgbuf _dst;
-	struct pldm_msgbuf *dst = &_dst;
+	PLDM_MSGBUF_DEFINE_P(buf);
+	PLDM_MSGBUF_DEFINE_P(src);
+	PLDM_MSGBUF_DEFINE_P(dst);
 	size_t names_len = 0;
 	void *names = NULL;
 	int rc;
@@ -3085,7 +3060,7 @@
 		buf, &pdr->hdr, PLDM_PDR_ENTITY_AUXILIARY_NAME_PDR_MIN_LENGTH,
 		data_length);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	pldm_msgbuf_extract(buf, pdr->container.entity_type);
@@ -3094,7 +3069,7 @@
 	pldm_msgbuf_extract(buf, pdr->shared_name_count);
 	rc = pldm_msgbuf_extract(buf, pdr->name_string_count);
 	if (rc < 0) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	rc = pldm_msgbuf_span_remaining(buf, &names, &names_len);
@@ -3103,6 +3078,11 @@
 	}
 	assert(names);
 
+	rc = pldm_msgbuf_complete_consumed(buf);
+	if (rc) {
+		return rc;
+	}
+
 	pdr->auxiliary_name_data_size = pdr_length - sizeof(*pdr);
 
 	rc = pldm_msgbuf_init_errno(dst, pdr->auxiliary_name_data_size,
@@ -3121,51 +3101,54 @@
 	/* Initialise for the first pass to extract the UTF16-BE name strings */
 	rc = pldm_msgbuf_init_errno(src, names_len, names, names_len);
 	if (rc < 0) {
-		return rc;
+		goto cleanup_msgbuf_dst;
 	}
 
 	for (i = 0; i < pdr->name_string_count; i++) {
 		pldm_msgbuf_span_string_ascii(src, NULL, NULL);
 		rc = pldm_msgbuf_copy_string_utf16(dst, src);
 		if (rc) {
-			return rc;
+			goto cleanup_msgbuf_src;
 		}
 	}
 
 	rc = pldm_msgbuf_complete_consumed(src);
 	if (rc < 0) {
-		return rc;
+		goto cleanup_msgbuf_dst;
 	}
 
 	/* Reinitialise for the second pass to extract the ASCII tag strings */
 	rc = pldm_msgbuf_init_errno(src, names_len, names, names_len);
 	if (rc < 0) {
-		return rc;
+		goto cleanup_msgbuf_dst;
 	}
 
 	for (i = 0; i < pdr->name_string_count; i++) {
 		rc = pldm_msgbuf_copy_string_ascii(dst, src);
 		if (rc) {
-			return rc;
+			goto cleanup_msgbuf_src;
 		}
 		pldm_msgbuf_span_string_utf16(src, NULL, NULL);
 	}
 
-	if ((rc = pldm_msgbuf_complete(dst)) ||
-	    (rc = pldm_msgbuf_complete(src)) ||
-	    (rc = pldm_msgbuf_complete(buf))) {
-		return rc;
+	rc = pldm_msgbuf_complete(src);
+	if (rc) {
+		goto cleanup_msgbuf_dst;
 	}
 
-	return 0;
+	return pldm_msgbuf_complete(dst);
+
+cleanup_msgbuf_src:
+	rc = pldm_msgbuf_discard(src, rc);
+cleanup_msgbuf_dst:
+	return pldm_msgbuf_discard(dst, rc);
 }
 
 LIBPLDM_ABI_STABLE
 int decode_pldm_entity_auxiliary_names_pdr_index(
 	struct pldm_entity_auxiliary_names_pdr *pdr)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 	int i;
 
@@ -3227,8 +3210,7 @@
 				    struct pldm_platform_cper_event *cper_event,
 				    size_t cper_event_length)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (!cper_event || !event_data) {
@@ -3248,29 +3230,29 @@
 	pldm_msgbuf_extract(buf, cper_event->format_version);
 	rc = pldm_msgbuf_extract(buf, cper_event->format_type);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 	if (cper_event->format_type != PLDM_PLATFORM_CPER_EVENT_WITH_HEADER &&
 	    cper_event->format_type !=
 		    PLDM_PLATFORM_CPER_EVENT_WITHOUT_HEADER) {
-		return -EPROTO;
+		return pldm_msgbuf_discard(buf, -EPROTO);
 	}
 
 	rc = pldm_msgbuf_extract(buf, cper_event->event_data_length);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	if (cper_event->event_data_length >
 	    (cper_event_length - sizeof(*cper_event))) {
-		return -EOVERFLOW;
+		return pldm_msgbuf_discard(buf, -EOVERFLOW);
 	}
 
 	rc = pldm_msgbuf_extract_array_uint8(
 		buf, cper_event->event_data_length, cper_event->event_data,
 		cper_event_length - sizeof(*cper_event));
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	return pldm_msgbuf_complete_consumed(buf);
diff --git a/src/firmware_device/fd.c b/src/firmware_device/fd.c
index 9ac1ab8..0967033 100644
--- a/src/firmware_device/fd.c
+++ b/src/firmware_device/fd.c
@@ -276,8 +276,7 @@
 {
 	uint16_t entry_count;
 	const struct pldm_firmware_component_standalone **entries;
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	/* No request data */
@@ -311,20 +310,22 @@
 			fd->ops_ctx, &fwp.active_comp_image_set_ver_str,
 			&fwp.pending_comp_image_set_ver_str);
 		if (rc) {
-			return pldm_fd_reply_cc(PLDM_ERROR, hdr, resp,
-						resp_payload_len);
+			return pldm_msgbuf_discard(
+				buf, pldm_fd_reply_cc(PLDM_ERROR, hdr, resp,
+						      resp_payload_len));
 		}
 
 		size_t len = buf->remaining;
 		rc = encode_get_firmware_parameters_resp(hdr->instance, &fwp,
 							 resp, &len);
 		if (rc) {
-			return pldm_fd_reply_errno(rc, hdr, resp,
-						   resp_payload_len);
+			return pldm_msgbuf_discard(
+				buf, pldm_fd_reply_errno(rc, hdr, resp,
+							 resp_payload_len));
 		}
 		rc = pldm_msgbuf_skip(buf, len);
 		if (rc) {
-			return rc;
+			return pldm_msgbuf_discard(buf, rc);
 		}
 	}
 
@@ -349,18 +350,18 @@
 		};
 
 		if (pldm_msgbuf_peek_remaining(buf, &out, &len)) {
-			return rc;
+			return pldm_msgbuf_discard(buf, rc);
 		}
+
 		rc = encode_get_firmware_parameters_resp_comp_entry(&comp, out,
 								    &len);
 		if (rc) {
-			return pldm_fd_reply_errno(rc, hdr, resp,
-						   resp_payload_len);
+			return pldm_msgbuf_discard(
+				buf, pldm_fd_reply_errno(rc, hdr, resp,
+							 resp_payload_len));
 		}
-		rc = pldm_msgbuf_skip(buf, len);
-		if (rc) {
-			return rc;
-		}
+
+		pldm_msgbuf_skip(buf, len);
 	}
 
 	return pldm_msgbuf_complete_used(buf, *resp_payload_len,
diff --git a/src/msgbuf.h b/src/msgbuf.h
index cf30bad..d33d8e9 100644
--- a/src/msgbuf.h
+++ b/src/msgbuf.h
@@ -76,6 +76,37 @@
 	intmax_t remaining;
 };
 
+LIBPLDM_CC_NONNULL
+LIBPLDM_CC_ALWAYS_INLINE
+// NOLINTNEXTLINE(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp)
+void pldm__msgbuf_cleanup(struct pldm_msgbuf *ctx LIBPLDM_CC_UNUSED)
+{
+	assert(ctx->cursor == NULL && ctx->remaining == INTMAX_MIN);
+}
+
+#ifdef __cplusplus
+// NOLINTBEGIN(bugprone-macro-parentheses)
+#define PLDM_MSGBUF_DEFINE_P(name)                                             \
+	struct pldm_msgbuf _##name LIBPLDM_CC_CLEANUP(                         \
+		pldm__msgbuf_cleanup) = { NULL, INTMAX_MIN };                  \
+	auto *name = &(_##name)
+// NOLINTEND(bugprone-macro-parentheses)
+#else
+#define PLDM_MSGBUF_DEFINE_P(name)                                             \
+	struct pldm_msgbuf _##name LIBPLDM_CC_CLEANUP(                         \
+		pldm__msgbuf_cleanup) = { NULL, INTMAX_MIN };                  \
+	struct pldm_msgbuf *(name) = &(_##name)
+#endif
+
+LIBPLDM_CC_NONNULL
+LIBPLDM_CC_ALWAYS_INLINE
+// NOLINTNEXTLINE(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp)
+int pldm__msgbuf_invalidate(struct pldm_msgbuf *ctx)
+{
+	ctx->remaining = INTMAX_MIN;
+	return -EOVERFLOW;
+}
+
 /**
  * @brief Initialize pldm buf struct for buf extractor
  *
@@ -95,18 +126,20 @@
 pldm_msgbuf_init_errno(struct pldm_msgbuf *ctx, size_t minsize, const void *buf,
 		       size_t len)
 {
+	ctx->cursor = NULL;
+
 	if ((minsize > len)) {
-		return -EOVERFLOW;
+		return pldm__msgbuf_invalidate(ctx);
 	}
 
 #if INTMAX_MAX < SIZE_MAX
 	if (len > INTMAX_MAX) {
-		return -EOVERFLOW;
+		return pldm__msgbuf_invalidate(ctx);
 	}
 #endif
 
 	if (UINTPTR_MAX - (uintptr_t)buf < len) {
-		return -EOVERFLOW;
+		return pldm__msgbuf_invalidate(ctx);
 	}
 
 	ctx->cursor = (uint8_t *)buf;
@@ -165,6 +198,29 @@
 }
 
 /**
+ * @brief End use of a msgbuf under error conditions
+ *
+ * @param[in] ctx - The msgbuf instance to discard
+ * @param[in] error - The error value to propagate
+ *
+ * Under normal conditions use of a msgbuf instance must be ended using @ref
+ * pldm_msgbuf_complete or one of its related APIs. Under error conditions, @ref
+ * pldm_msgbuf_discard should be used instead, as it makes it straight-forward
+ * to finalise the msgbuf while propagating the existing error code.
+ *
+ * @return The value provided in @param error
+ */
+LIBPLDM_CC_NONNULL
+LIBPLDM_CC_ALWAYS_INLINE
+LIBPLDM_CC_WARN_UNUSED_RESULT
+int pldm_msgbuf_discard(struct pldm_msgbuf *ctx, int error)
+{
+	ctx->cursor = NULL;
+	pldm__msgbuf_invalidate(ctx);
+	return error;
+}
+
+/**
  * @brief Complete the pldm_msgbuf instance
  *
  * @param[in] ctx - pldm_msgbuf context for extractor
@@ -176,14 +232,7 @@
 LIBPLDM_CC_WARN_UNUSED_RESULT
 int pldm_msgbuf_complete(struct pldm_msgbuf *ctx)
 {
-	int valid;
-
-	valid = pldm_msgbuf_validate(ctx);
-
-	ctx->cursor = NULL;
-	ctx->remaining = 0;
-
-	return valid;
+	return pldm_msgbuf_discard(ctx, pldm_msgbuf_validate(ctx));
 }
 
 /**
@@ -202,14 +251,7 @@
 LIBPLDM_CC_WARN_UNUSED_RESULT
 int pldm_msgbuf_complete_consumed(struct pldm_msgbuf *ctx)
 {
-	int consumed;
-
-	consumed = pldm_msgbuf_consumed(ctx);
-
-	ctx->cursor = NULL;
-	ctx->remaining = 0;
-
-	return consumed;
+	return pldm_msgbuf_discard(ctx, pldm_msgbuf_consumed(ctx));
 }
 
 /*
@@ -317,22 +359,20 @@
 // NOLINTNEXTLINE(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp)
 pldm__msgbuf_extract_uint8(struct pldm_msgbuf *ctx, void *dst)
 {
-	if (!ctx->cursor) {
-		return -EINVAL;
-	}
-
 	if (ctx->remaining >= (intmax_t)sizeof(uint8_t)) {
+		assert(ctx->cursor);
 		memcpy(dst, ctx->cursor, sizeof(uint8_t));
 		ctx->cursor++;
 		ctx->remaining -= sizeof(uint8_t);
 		return 0;
 	}
 
-	if (ctx->remaining >= INTMAX_MIN + (intmax_t)sizeof(uint8_t)) {
+	if (ctx->remaining > INTMAX_MIN + (intmax_t)sizeof(uint8_t)) {
 		ctx->remaining -= sizeof(uint8_t);
+		return -EOVERFLOW;
 	}
 
-	return -EOVERFLOW;
+	return pldm__msgbuf_invalidate(ctx);
 }
 
 #define pldm_msgbuf_extract_int8(ctx, dst)                                     \
@@ -343,22 +383,20 @@
 // NOLINTNEXTLINE(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp)
 pldm__msgbuf_extract_int8(struct pldm_msgbuf *ctx, void *dst)
 {
-	if (!ctx->cursor) {
-		return -EINVAL;
-	}
-
 	if (ctx->remaining >= (intmax_t)sizeof(int8_t)) {
+		assert(ctx->cursor);
 		memcpy(dst, ctx->cursor, sizeof(int8_t));
 		ctx->cursor++;
 		ctx->remaining -= sizeof(int8_t);
 		return 0;
 	}
 
-	if (ctx->remaining >= INTMAX_MIN + (intmax_t)sizeof(int8_t)) {
+	if (ctx->remaining > INTMAX_MIN + (intmax_t)sizeof(int8_t)) {
 		ctx->remaining -= sizeof(int8_t);
+		return -EOVERFLOW;
 	}
 
-	return -EOVERFLOW;
+	return pldm__msgbuf_invalidate(ctx);
 }
 
 #define pldm_msgbuf_extract_uint16(ctx, dst)                                   \
@@ -371,10 +409,6 @@
 {
 	uint16_t ldst;
 
-	if (!ctx->cursor) {
-		return -EINVAL;
-	}
-
 	// Check for underflow while tracking the magnitude of the buffer overflow
 	static_assert(
 		// NOLINTNEXTLINE(bugprone-sizeof-expression)
@@ -382,6 +416,8 @@
 		"The following addition may not uphold the runtime assertion");
 
 	if (ctx->remaining >= (intmax_t)sizeof(ldst)) {
+		assert(ctx->cursor);
+
 		// Use memcpy() to have the compiler deal with any alignment
 		// issues on the target architecture
 		memcpy(&ldst, ctx->cursor, sizeof(ldst));
@@ -397,11 +433,12 @@
 		return 0;
 	}
 
-	if (ctx->remaining >= INTMAX_MIN + (intmax_t)sizeof(ldst)) {
+	if (ctx->remaining > INTMAX_MIN + (intmax_t)sizeof(ldst)) {
 		ctx->remaining -= sizeof(ldst);
+		return -EOVERFLOW;
 	}
 
-	return -EOVERFLOW;
+	return pldm__msgbuf_invalidate(ctx);
 }
 
 #define pldm_msgbuf_extract_int16(ctx, dst)                                    \
@@ -414,16 +451,13 @@
 {
 	int16_t ldst;
 
-	if (!ctx->cursor) {
-		return -EINVAL;
-	}
-
 	static_assert(
 		// NOLINTNEXTLINE(bugprone-sizeof-expression)
 		sizeof(ldst) < INTMAX_MAX,
 		"The following addition may not uphold the runtime assertion");
 
 	if (ctx->remaining >= (intmax_t)sizeof(ldst)) {
+		assert(ctx->cursor);
 		memcpy(&ldst, ctx->cursor, sizeof(ldst));
 		ldst = le16toh(ldst);
 		memcpy(dst, &ldst, sizeof(ldst));
@@ -432,11 +466,12 @@
 		return 0;
 	}
 
-	if (ctx->remaining >= INTMAX_MIN + (intmax_t)sizeof(ldst)) {
+	if (ctx->remaining > INTMAX_MIN + (intmax_t)sizeof(ldst)) {
 		ctx->remaining -= sizeof(ldst);
+		return -EOVERFLOW;
 	}
 
-	return -EOVERFLOW;
+	return pldm__msgbuf_invalidate(ctx);
 }
 
 #define pldm_msgbuf_extract_uint32(ctx, dst)                                   \
@@ -449,16 +484,13 @@
 {
 	uint32_t ldst;
 
-	if (!ctx->cursor) {
-		return -EINVAL;
-	}
-
 	static_assert(
 		// NOLINTNEXTLINE(bugprone-sizeof-expression)
 		sizeof(ldst) < INTMAX_MAX,
 		"The following addition may not uphold the runtime assertion");
 
 	if (ctx->remaining >= (intmax_t)sizeof(ldst)) {
+		assert(ctx->cursor);
 		memcpy(&ldst, ctx->cursor, sizeof(ldst));
 		ldst = le32toh(ldst);
 		memcpy(dst, &ldst, sizeof(ldst));
@@ -467,11 +499,12 @@
 		return 0;
 	}
 
-	if (ctx->remaining >= INTMAX_MIN + (intmax_t)sizeof(ldst)) {
+	if (ctx->remaining > INTMAX_MIN + (intmax_t)sizeof(ldst)) {
 		ctx->remaining -= sizeof(ldst);
+		return -EOVERFLOW;
 	}
 
-	return -EOVERFLOW;
+	return pldm__msgbuf_invalidate(ctx);
 }
 
 #define pldm_msgbuf_extract_int32(ctx, dst)                                    \
@@ -484,16 +517,13 @@
 {
 	int32_t ldst;
 
-	if (!ctx->cursor) {
-		return -EINVAL;
-	}
-
 	static_assert(
 		// NOLINTNEXTLINE(bugprone-sizeof-expression)
 		sizeof(ldst) < INTMAX_MAX,
 		"The following addition may not uphold the runtime assertion");
 
 	if (ctx->remaining >= (intmax_t)sizeof(ldst)) {
+		assert(ctx->cursor);
 		memcpy(&ldst, ctx->cursor, sizeof(ldst));
 		ldst = le32toh(ldst);
 		memcpy(dst, &ldst, sizeof(ldst));
@@ -502,11 +532,12 @@
 		return 0;
 	}
 
-	if (ctx->remaining >= INTMAX_MIN + (intmax_t)sizeof(ldst)) {
+	if (ctx->remaining > INTMAX_MIN + (intmax_t)sizeof(ldst)) {
 		ctx->remaining -= sizeof(ldst);
+		return -EOVERFLOW;
 	}
 
-	return -EOVERFLOW;
+	return pldm__msgbuf_invalidate(ctx);
 }
 
 #define pldm_msgbuf_extract_real32(ctx, dst)                                   \
@@ -522,16 +553,13 @@
 	static_assert(sizeof(real32_t) == sizeof(ldst),
 		      "Mismatched type sizes for dst and ldst");
 
-	if (!ctx->cursor) {
-		return -EINVAL;
-	}
-
 	static_assert(
 		// NOLINTNEXTLINE(bugprone-sizeof-expression)
 		sizeof(ldst) < INTMAX_MAX,
 		"The following addition may not uphold the runtime assertion");
 
 	if (ctx->remaining >= (intmax_t)sizeof(ldst)) {
+		assert(ctx->cursor);
 		memcpy(&ldst, ctx->cursor, sizeof(ldst));
 		ldst = le32toh(ldst);
 		memcpy(dst, &ldst, sizeof(ldst));
@@ -540,11 +568,12 @@
 		return 0;
 	}
 
-	if (ctx->remaining >= INTMAX_MIN + (intmax_t)sizeof(ldst)) {
+	if (ctx->remaining > INTMAX_MIN + (intmax_t)sizeof(ldst)) {
 		ctx->remaining -= sizeof(ldst);
+		return -EOVERFLOW;
 	}
 
-	return -EOVERFLOW;
+	return pldm__msgbuf_invalidate(ctx);
 }
 
 /**
@@ -595,7 +624,7 @@
 pldm__msgbuf_extract_array_void(struct pldm_msgbuf *ctx, size_t count,
 				void *dst, size_t dst_count)
 {
-	if (!ctx->cursor || count > dst_count) {
+	if (count > dst_count) {
 		return -EINVAL;
 	}
 
@@ -605,22 +634,24 @@
 
 #if INTMAX_MAX < SIZE_MAX
 	if (count > INTMAX_MAX) {
-		return -EOVERFLOW;
+		return pldm__msgbuf_invalidate(ctx);
 	}
 #endif
 
 	if (ctx->remaining >= (intmax_t)count) {
+		assert(ctx->cursor);
 		memcpy(dst, ctx->cursor, count);
 		ctx->cursor += count;
 		ctx->remaining -= (intmax_t)count;
 		return 0;
 	}
 
-	if (ctx->remaining >= INTMAX_MIN + (intmax_t)count) {
+	if (ctx->remaining > INTMAX_MIN + (intmax_t)count) {
 		ctx->remaining -= (intmax_t)count;
+		return -EOVERFLOW;
 	}
 
-	return -EOVERFLOW;
+	return pldm__msgbuf_invalidate(ctx);
 }
 
 /**
@@ -672,27 +703,25 @@
 {
 	uint64_t val = htole64(src);
 
-	if (!ctx->cursor) {
-		return -EINVAL;
-	}
-
 	static_assert(
 		// NOLINTNEXTLINE(bugprone-sizeof-expression)
 		sizeof(src) < INTMAX_MAX,
 		"The following addition may not uphold the runtime assertion");
 
 	if (ctx->remaining >= (intmax_t)sizeof(src)) {
+		assert(ctx->cursor);
 		memcpy(ctx->cursor, &val, sizeof(val));
 		ctx->cursor += sizeof(src);
 		ctx->remaining -= sizeof(src);
 		return 0;
 	}
 
-	if (ctx->remaining >= INTMAX_MIN + (intmax_t)sizeof(src)) {
+	if (ctx->remaining > INTMAX_MIN + (intmax_t)sizeof(src)) {
 		ctx->remaining -= sizeof(src);
+		return -EOVERFLOW;
 	}
 
-	return -EOVERFLOW;
+	return pldm__msgbuf_invalidate(ctx);
 }
 
 LIBPLDM_CC_NONNULL
@@ -701,27 +730,25 @@
 {
 	uint32_t val = htole32(src);
 
-	if (!ctx->cursor) {
-		return -EINVAL;
-	}
-
 	static_assert(
 		// NOLINTNEXTLINE(bugprone-sizeof-expression)
 		sizeof(src) < INTMAX_MAX,
 		"The following addition may not uphold the runtime assertion");
 
 	if (ctx->remaining >= (intmax_t)sizeof(src)) {
+		assert(ctx->cursor);
 		memcpy(ctx->cursor, &val, sizeof(val));
 		ctx->cursor += sizeof(src);
 		ctx->remaining -= sizeof(src);
 		return 0;
 	}
 
-	if (ctx->remaining >= INTMAX_MIN + (intmax_t)sizeof(src)) {
+	if (ctx->remaining > INTMAX_MIN + (intmax_t)sizeof(src)) {
 		ctx->remaining -= sizeof(src);
+		return -EOVERFLOW;
 	}
 
-	return -EOVERFLOW;
+	return pldm__msgbuf_invalidate(ctx);
 }
 
 LIBPLDM_CC_NONNULL
@@ -730,54 +757,50 @@
 {
 	uint16_t val = htole16(src);
 
-	if (!ctx->cursor) {
-		return -EINVAL;
-	}
-
 	static_assert(
 		// NOLINTNEXTLINE(bugprone-sizeof-expression)
 		sizeof(src) < INTMAX_MAX,
 		"The following addition may not uphold the runtime assertion");
 
 	if (ctx->remaining >= (intmax_t)sizeof(src)) {
+		assert(ctx->cursor);
 		memcpy(ctx->cursor, &val, sizeof(val));
 		ctx->cursor += sizeof(src);
 		ctx->remaining -= sizeof(src);
 		return 0;
 	}
 
-	if (ctx->remaining >= INTMAX_MIN + (intmax_t)sizeof(src)) {
+	if (ctx->remaining > INTMAX_MIN + (intmax_t)sizeof(src)) {
 		ctx->remaining -= sizeof(src);
+		return -EOVERFLOW;
 	}
 
-	return -EOVERFLOW;
+	return pldm__msgbuf_invalidate(ctx);
 }
 
 LIBPLDM_CC_NONNULL
 LIBPLDM_CC_ALWAYS_INLINE int pldm_msgbuf_insert_uint8(struct pldm_msgbuf *ctx,
 						      const uint8_t src)
 {
-	if (!ctx->cursor) {
-		return -EINVAL;
-	}
-
 	static_assert(
 		// NOLINTNEXTLINE(bugprone-sizeof-expression)
 		sizeof(src) < INTMAX_MAX,
 		"The following addition may not uphold the runtime assertion");
 
 	if (ctx->remaining >= (intmax_t)sizeof(src)) {
+		assert(ctx->cursor);
 		memcpy(ctx->cursor, &src, sizeof(src));
 		ctx->cursor += sizeof(src);
 		ctx->remaining -= sizeof(src);
 		return 0;
 	}
 
-	if (ctx->remaining >= INTMAX_MIN + (intmax_t)sizeof(src)) {
+	if (ctx->remaining > INTMAX_MIN + (intmax_t)sizeof(src)) {
 		ctx->remaining -= sizeof(src);
+		return -EOVERFLOW;
 	}
 
-	return -EOVERFLOW;
+	return pldm__msgbuf_invalidate(ctx);
 }
 
 LIBPLDM_CC_NONNULL
@@ -786,27 +809,25 @@
 {
 	int32_t val = htole32(src);
 
-	if (!ctx->cursor) {
-		return -EINVAL;
-	}
-
 	static_assert(
 		// NOLINTNEXTLINE(bugprone-sizeof-expression)
 		sizeof(src) < INTMAX_MAX,
 		"The following addition may not uphold the runtime assertion");
 
 	if (ctx->remaining >= (intmax_t)sizeof(src)) {
+		assert(ctx->cursor);
 		memcpy(ctx->cursor, &val, sizeof(val));
 		ctx->cursor += sizeof(src);
 		ctx->remaining -= sizeof(src);
 		return 0;
 	}
 
-	if (ctx->remaining >= INTMAX_MIN + (intmax_t)sizeof(src)) {
+	if (ctx->remaining > INTMAX_MIN + (intmax_t)sizeof(src)) {
 		ctx->remaining -= sizeof(src);
+		return -EOVERFLOW;
 	}
 
-	return -EOVERFLOW;
+	return pldm__msgbuf_invalidate(ctx);
 }
 
 LIBPLDM_CC_NONNULL
@@ -815,54 +836,50 @@
 {
 	int16_t val = htole16(src);
 
-	if (!ctx->cursor) {
-		return -EINVAL;
-	}
-
 	static_assert(
 		// NOLINTNEXTLINE(bugprone-sizeof-expression)
 		sizeof(src) < INTMAX_MAX,
 		"The following addition may not uphold the runtime assertion");
 
 	if (ctx->remaining >= (intmax_t)sizeof(src)) {
+		assert(ctx->cursor);
 		memcpy(ctx->cursor, &val, sizeof(val));
 		ctx->cursor += sizeof(src);
 		ctx->remaining -= sizeof(src);
 		return 0;
 	}
 
-	if (ctx->remaining >= INTMAX_MIN + (intmax_t)sizeof(src)) {
+	if (ctx->remaining > INTMAX_MIN + (intmax_t)sizeof(src)) {
 		ctx->remaining -= sizeof(src);
+		return -EOVERFLOW;
 	}
 
-	return -EOVERFLOW;
+	return pldm__msgbuf_invalidate(ctx);
 }
 
 LIBPLDM_CC_NONNULL
 LIBPLDM_CC_ALWAYS_INLINE int pldm_msgbuf_insert_int8(struct pldm_msgbuf *ctx,
 						     const int8_t src)
 {
-	if (!ctx->cursor) {
-		return -EINVAL;
-	}
-
 	static_assert(
 		// NOLINTNEXTLINE(bugprone-sizeof-expression)
 		sizeof(src) < INTMAX_MAX,
 		"The following addition may not uphold the runtime assertion");
 
 	if (ctx->remaining >= (intmax_t)sizeof(src)) {
+		assert(ctx->cursor);
 		memcpy(ctx->cursor, &src, sizeof(src));
 		ctx->cursor += sizeof(src);
 		ctx->remaining -= sizeof(src);
 		return 0;
 	}
 
-	if (ctx->remaining >= INTMAX_MIN + (intmax_t)sizeof(src)) {
+	if (ctx->remaining > INTMAX_MIN + (intmax_t)sizeof(src)) {
 		ctx->remaining -= sizeof(src);
+		return -EOVERFLOW;
 	}
 
-	return -EOVERFLOW;
+	return pldm__msgbuf_invalidate(ctx);
 }
 
 #define pldm_msgbuf_insert(dst, src)                                           \
@@ -885,7 +902,7 @@
 pldm__msgbuf_insert_array_void(struct pldm_msgbuf *ctx, size_t count,
 			       const void *src, size_t src_count)
 {
-	if (!ctx->cursor || count > src_count) {
+	if (count > src_count) {
 		return -EINVAL;
 	}
 
@@ -895,22 +912,24 @@
 
 #if INTMAX_MAX < SIZE_MAX
 	if (count > INTMAX_MAX) {
-		return -EOVERFLOW;
+		return pldm__msgbuf_invalidate(ctx);
 	}
 #endif
 
 	if (ctx->remaining >= (intmax_t)count) {
+		assert(ctx->cursor);
 		memcpy(ctx->cursor, src, count);
 		ctx->cursor += count;
 		ctx->remaining -= (intmax_t)count;
 		return 0;
 	}
 
-	if (ctx->remaining >= INTMAX_MIN + (intmax_t)count) {
+	if (ctx->remaining > INTMAX_MIN + (intmax_t)count) {
 		ctx->remaining -= (intmax_t)count;
+		return -EOVERFLOW;
 	}
 
-	return -EOVERFLOW;
+	return pldm__msgbuf_invalidate(ctx);
 }
 
 /**
@@ -962,17 +981,14 @@
 						       size_t required,
 						       void **cursor)
 {
-	if (!ctx->cursor) {
-		return -EINVAL;
-	}
-
 #if INTMAX_MAX < SIZE_MAX
 	if (required > INTMAX_MAX) {
-		return -EOVERFLOW;
+		return pldm__msgbuf_invalidate(ctx);
 	}
 #endif
 
 	if (ctx->remaining >= (intmax_t)required) {
+		assert(ctx->cursor);
 		if (cursor) {
 			*cursor = ctx->cursor;
 		}
@@ -981,11 +997,12 @@
 		return 0;
 	}
 
-	if (ctx->remaining >= INTMAX_MIN + (intmax_t)required) {
+	if (ctx->remaining > INTMAX_MIN + (intmax_t)required) {
 		ctx->remaining -= (intmax_t)required;
+		return -EOVERFLOW;
 	}
 
-	return -EOVERFLOW;
+	return pldm__msgbuf_invalidate(ctx);
 }
 
 LIBPLDM_CC_NONNULL_ARGS(1)
@@ -995,31 +1012,21 @@
 {
 	intmax_t measured;
 
-	if (!ctx->cursor) {
-		return -EINVAL;
-	}
-
 	if (ctx->remaining < 0) {
-		/* Tracking the amount of overflow gets disturbed here */
-		return -EOVERFLOW;
+		return pldm__msgbuf_invalidate(ctx);
 	}
+	assert(ctx->cursor);
 
 	measured = (intmax_t)strnlen((const char *)ctx->cursor, ctx->remaining);
 	if (measured == ctx->remaining) {
-		/*
-		 * We have hit the end of the buffer prior to the NUL terminator.
-		 * Optimistically, the NUL terminator was one-beyond-the-end. Setting
-		 * ctx->remaining negative ensures the `pldm_msgbuf_complete*()` APIs also
-		 * return an error.
-		 */
-		ctx->remaining = -1;
-		return -EOVERFLOW;
+		return pldm__msgbuf_invalidate(ctx);
 	}
 
 	/* Include the NUL terminator in the span length, as spans are opaque */
 	measured++;
 
 	if (ctx->remaining >= measured) {
+		assert(ctx->cursor);
 		if (cursor) {
 			*cursor = ctx->cursor;
 		}
@@ -1034,11 +1041,12 @@
 		return 0;
 	}
 
-	if (ctx->remaining >= INTMAX_MIN + measured) {
+	if (ctx->remaining > INTMAX_MIN + measured) {
 		ctx->remaining -= measured;
+		return -EOVERFLOW;
 	}
 
-	return -EOVERFLOW;
+	return pldm__msgbuf_invalidate(ctx);
 }
 
 LIBPLDM_CC_NONNULL_ARGS(1)
@@ -1050,14 +1058,10 @@
 	ptrdiff_t measured;
 	void *end;
 
-	if (!ctx->cursor) {
-		return -EINVAL;
-	}
-
 	if (ctx->remaining < 0) {
-		/* Tracking the amount of overflow gets disturbed here */
-		return -EOVERFLOW;
+		return pldm__msgbuf_invalidate(ctx);
 	}
+	assert(ctx->cursor);
 
 	/*
 	 * Avoid tripping up on UTF16-LE: We may have consecutive NUL _bytes_ that do
@@ -1084,8 +1088,7 @@
 		 * the buffer. Setting ctx->remaining negative ensures the
 		 * `pldm_msgbuf_complete*()` APIs also return an error.
 		 */
-		ctx->remaining = -1;
-		return -EOVERFLOW;
+		return pldm__msgbuf_invalidate(ctx);
 	}
 
 	end = (char *)end + sizeof(char16_t);
@@ -1093,11 +1096,12 @@
 
 #if INTMAX_MAX < PTRDIFF_MAX
 	if (measured >= INTMAX_MAX) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return pldm__msgbuf_invalidate(ctx);
 	}
 #endif
 
 	if (ctx->remaining >= (intmax_t)measured) {
+		assert(ctx->cursor);
 		if (cursor) {
 			*cursor = ctx->cursor;
 		}
@@ -1112,25 +1116,23 @@
 		return 0;
 	}
 
-	if (ctx->remaining >= INTMAX_MIN + (intmax_t)measured) {
+	if (ctx->remaining > INTMAX_MIN + (intmax_t)measured) {
 		ctx->remaining -= (intmax_t)measured;
+		return -EOVERFLOW;
 	}
 
-	return -EOVERFLOW;
+	return pldm__msgbuf_invalidate(ctx);
 }
 
 LIBPLDM_CC_NONNULL
 LIBPLDM_CC_ALWAYS_INLINE int
 pldm_msgbuf_span_remaining(struct pldm_msgbuf *ctx, void **cursor, size_t *len)
 {
-	if (!ctx->cursor) {
-		return -EINVAL;
-	}
-
 	if (ctx->remaining < 0) {
 		return -EOVERFLOW;
 	}
 
+	assert(ctx->cursor);
 	*cursor = ctx->cursor;
 	ctx->cursor += ctx->remaining;
 	*len = ctx->remaining;
@@ -1143,14 +1145,11 @@
 LIBPLDM_CC_ALWAYS_INLINE int
 pldm_msgbuf_peek_remaining(struct pldm_msgbuf *ctx, void **cursor, size_t *len)
 {
-	if (!ctx->cursor) {
-		return -EINVAL;
-	}
-
 	if (ctx->remaining < 0) {
 		return -EOVERFLOW;
 	}
 
+	assert(ctx->cursor);
 	*cursor = ctx->cursor;
 	*len = ctx->remaining;
 
@@ -1161,27 +1160,25 @@
 LIBPLDM_CC_ALWAYS_INLINE int pldm_msgbuf_skip(struct pldm_msgbuf *ctx,
 					      size_t count)
 {
-	if (!ctx->cursor) {
-		return -EINVAL;
-	}
-
 #if INTMAX_MAX < SIZE_MAX
 	if (count > INTMAX_MAX) {
-		return -EOVERFLOW;
+		return pldm__msgbuf_invalidate(ctx);
 	}
 #endif
 
 	if (ctx->remaining >= (intmax_t)count) {
+		assert(ctx->cursor);
 		ctx->cursor += count;
 		ctx->remaining -= (intmax_t)count;
 		return 0;
 	}
 
-	if (ctx->remaining >= INTMAX_MIN + (intmax_t)count) {
+	if (ctx->remaining > INTMAX_MIN + (intmax_t)count) {
 		ctx->remaining -= (intmax_t)count;
+		return -EOVERFLOW;
 	}
 
-	return -EOVERFLOW;
+	return pldm__msgbuf_invalidate(ctx);
 }
 
 /**
@@ -1207,17 +1204,20 @@
 {
 	int rc;
 
+	ctx->cursor = NULL;
 	rc = pldm_msgbuf_validate(ctx);
 	if (rc) {
+		pldm__msgbuf_invalidate(ctx);
 		return rc;
 	}
 
 	if ((size_t)ctx->remaining > orig_len) {
 		/* Caller passed incorrect orig_len */
-		return -EOVERFLOW;
+		return pldm__msgbuf_invalidate(ctx);
 	}
 
 	*ret_used_len = orig_len - ctx->remaining;
+	pldm__msgbuf_invalidate(ctx);
 	return 0;
 }
 
@@ -1241,18 +1241,17 @@
 pldm__msgbuf_copy(struct pldm_msgbuf *dst, struct pldm_msgbuf *src, size_t size,
 		  const char *description LIBPLDM_CC_UNUSED)
 {
-	if (!src->cursor || !dst->cursor) {
-		return -EINVAL;
-	}
-
 #if INTMAX_MAX < SIZE_MAX
 	if (size > INTMAX_MAX) {
+		pldm__msgbuf_invalidate(src);
+		pldm__msgbuf_invalidate(dst);
 		return -EOVERFLOW;
 	}
 #endif
 
 	if (src->remaining >= (intmax_t)size &&
 	    dst->remaining >= (intmax_t)size) {
+		assert(src->cursor && dst->cursor);
 		memcpy(dst->cursor, src->cursor, size);
 		src->cursor += size;
 		src->remaining -= (intmax_t)size;
@@ -1261,12 +1260,16 @@
 		return 0;
 	}
 
-	if (src->remaining >= INTMAX_MIN + (intmax_t)size) {
+	if (src->remaining > INTMAX_MIN + (intmax_t)size) {
 		src->remaining -= (intmax_t)size;
+	} else {
+		pldm__msgbuf_invalidate(src);
 	}
 
-	if (dst->remaining >= INTMAX_MIN + (intmax_t)size) {
+	if (dst->remaining > INTMAX_MIN + (intmax_t)size) {
 		dst->remaining -= (intmax_t)size;
+	} else {
+		pldm__msgbuf_invalidate(dst);
 	}
 
 	return -EOVERFLOW;
diff --git a/src/oem/meta/file_io.c b/src/oem/meta/file_io.c
index cd125ef..d3e7a6d 100644
--- a/src/oem/meta/file_io.c
+++ b/src/oem/meta/file_io.c
@@ -21,8 +21,7 @@
 	const struct pldm_msg *msg, size_t payload_length,
 	struct pldm_oem_meta_file_io_write_req *req, size_t req_length)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	int rc;
 
 	if (msg == NULL || req == NULL) {
@@ -43,13 +42,13 @@
 	pldm_msgbuf_extract(buf, req->handle);
 	rc = pldm_msgbuf_extract(buf, req->length);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	rc = pldm_msgbuf_extract_array(buf, req->length, req->data,
 				       req_length - sizeof(*req));
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	return pldm_msgbuf_complete_consumed(buf);
@@ -99,8 +98,7 @@
 				     size_t payload_length,
 				     struct pldm_oem_meta_file_io_read_req *req)
 {
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 
 	if (msg == NULL || req == NULL) {
 		return -EINVAL;
@@ -120,18 +118,18 @@
 	pldm_msgbuf_extract(buf, req->handle);
 	rc = pldm_msgbuf_extract(buf, req->option);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	rc = pldm_msgbuf_extract(buf, req->length);
 	if (rc) {
-		return rc;
+		return pldm_msgbuf_discard(buf, rc);
 	}
 
 	switch (req->option) {
 	case PLDM_OEM_META_FILE_IO_READ_ATTR:
 		if (req->length != 0) {
-			return -EPROTO;
+			return pldm_msgbuf_discard(buf, -EPROTO);
 		}
 		break;
 	case PLDM_OEM_META_FILE_IO_READ_DATA:
@@ -139,7 +137,7 @@
 		pldm_msgbuf_extract(buf, req->info.data.offset);
 		break;
 	default:
-		return -EPROTO;
+		return pldm_msgbuf_discard(buf, -EPROTO);
 	}
 
 	return pldm_msgbuf_complete_consumed(buf);
@@ -158,8 +156,7 @@
 	size_t resp_len, struct pldm_msg *responseMsg, size_t payload_length)
 {
 	int rc;
-	struct pldm_msgbuf _buf;
-	struct pldm_msgbuf *buf = &_buf;
+	PLDM_MSGBUF_DEFINE_P(buf);
 	struct pldm_header_info header = { 0 };
 
 	if (resp == NULL || responseMsg == NULL) {
@@ -207,11 +204,11 @@
 						    resp->data,
 						    resp_len - sizeof(*resp));
 		if (rc) {
-			return rc;
+			return pldm_msgbuf_discard(buf, rc);
 		}
 		break;
 	default:
-		return -EPROTO;
+		return pldm_msgbuf_discard(buf, -EPROTO);
 	}
 
 	return pldm_msgbuf_complete(buf);