diff --git a/src/dsp/firmware_update.c b/src/dsp/firmware_update.c
index 61bb953..c492a05 100644
--- a/src/dsp/firmware_update.c
+++ b/src/dsp/firmware_update.c
@@ -1,4 +1,5 @@
 /* SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later */
+#include "api.h"
 #include "dsp/base.h"
 #include "msgbuf.h"
 #include <libpldm/firmware_update.h>
@@ -904,15 +905,15 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	rc = pldm_msgbuf_init_cc(buf, PLDM_OPTIONAL_COMMAND_RESP_MIN_LEN,
-				 msg->payload, payload_length);
+	rc = pldm_msgbuf_init_errno(buf, PLDM_OPTIONAL_COMMAND_RESP_MIN_LEN,
+				    msg->payload, payload_length);
 	if (rc) {
 		return rc;
 	}
 
 	rc = pldm_msgbuf_extract(buf, resp_data->completion_code);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 	if (PLDM_SUCCESS != resp_data->completion_code) {
 		// Return the CC directly without decoding the rest of the payload
@@ -926,7 +927,7 @@
 	rc = pldm_msgbuf_extract(buf,
 				 resp_data->downstream_device_update_supported);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	if (!is_downstream_device_update_support_valid(
@@ -938,7 +939,12 @@
 	pldm_msgbuf_extract(buf, resp_data->max_number_of_downstream_devices);
 	pldm_msgbuf_extract(buf, resp_data->capabilities.value);
 
-	return pldm_msgbuf_destroy_consumed(buf);
+	rc = pldm_msgbuf_destroy_consumed(buf);
+	if (rc) {
+		pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_TESTING
@@ -969,18 +975,23 @@
 		return rc;
 	}
 
-	rc = pldm_msgbuf_init_cc(buf,
-				 PLDM_QUERY_DOWNSTREAM_IDENTIFIERS_REQ_BYTES,
-				 msg->payload, payload_length);
+	rc = pldm_msgbuf_init_errno(buf,
+				    PLDM_QUERY_DOWNSTREAM_IDENTIFIERS_REQ_BYTES,
+				    msg->payload, payload_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	pldm_msgbuf_insert(buf, data_transfer_handle);
 	// Data correctness has been verified, cast it to 1-byte data directly.
 	pldm_msgbuf_insert(buf, (uint8_t)transfer_operation_flag);
 
-	return pldm_msgbuf_destroy(buf);
+	rc = pldm_msgbuf_destroy(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_TESTING
@@ -998,15 +1009,15 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	rc = pldm_msgbuf_init_cc(buf, PLDM_OPTIONAL_COMMAND_RESP_MIN_LEN,
-				 msg->payload, payload_length);
+	rc = pldm_msgbuf_init_errno(buf, PLDM_OPTIONAL_COMMAND_RESP_MIN_LEN,
+				    msg->payload, payload_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	rc = pldm_msgbuf_extract(buf, resp_data->completion_code);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 	if (PLDM_SUCCESS != resp_data->completion_code) {
 		return PLDM_SUCCESS;
@@ -1021,7 +1032,7 @@
 
 	rc = pldm_msgbuf_extract(buf, resp_data->downstream_devices_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	pldm_msgbuf_extract(buf, resp_data->number_of_downstream_devices);
@@ -1029,11 +1040,16 @@
 				       resp_data->downstream_devices_length,
 				       (void **)&downstream_devices->ptr);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 	downstream_devices->length = resp_data->downstream_devices_length;
 
-	return pldm_msgbuf_destroy(buf);
+	rc = pldm_msgbuf_destroy(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_TESTING
diff --git a/src/dsp/platform.c b/src/dsp/platform.c
index 4b6898e..52caa53 100644
--- a/src/dsp/platform.c
+++ b/src/dsp/platform.c
@@ -1,4 +1,6 @@
 /* SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later */
+#include "api.h"
+#include "compiler.h"
 #include "dsp/base.h"
 #include "msgbuf.h"
 #include "msgbuf/platform.h"
@@ -272,10 +274,11 @@
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
 
-	rc = pldm_msgbuf_init_cc(buf, PLDM_SET_STATE_EFFECTER_STATES_MIN_SIZE,
-				 msg->payload, payload_length);
+	rc = pldm_msgbuf_init_errno(buf,
+				    PLDM_SET_STATE_EFFECTER_STATES_MIN_SIZE,
+				    msg->payload, payload_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	pldm_msgbuf_extract_p(buf, effecter_id);
@@ -290,7 +293,12 @@
 		pldm_msgbuf_extract(buf, field[i].effecter_state);
 	}
 
-	return pldm_msgbuf_destroy(buf);
+	rc = pldm_msgbuf_destroy(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_STABLE
@@ -313,10 +321,10 @@
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
 
-	rc = pldm_msgbuf_init_cc(buf, PLDM_GET_PDR_REQ_BYTES, msg->payload,
-				 payload_length);
+	rc = pldm_msgbuf_init_errno(buf, PLDM_GET_PDR_REQ_BYTES, msg->payload,
+				    payload_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	pldm_msgbuf_extract_p(buf, record_hndl);
@@ -325,7 +333,12 @@
 	pldm_msgbuf_extract_p(buf, request_cnt);
 	pldm_msgbuf_extract_p(buf, record_chg_num);
 
-	return pldm_msgbuf_destroy(buf);
+	rc = pldm_msgbuf_destroy(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_STABLE
@@ -441,10 +454,11 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	rc = pldm_msgbuf_init_cc(buf, PLDM_GET_PDR_REPOSITORY_INFO_RESP_BYTES,
-				 msg->payload, payload_length);
+	rc = pldm_msgbuf_init_errno(buf,
+				    PLDM_GET_PDR_REPOSITORY_INFO_RESP_BYTES,
+				    msg->payload, payload_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	pldm_msgbuf_extract_p(buf, completion_code);
@@ -452,7 +466,11 @@
 		return PLDM_SUCCESS;
 	}
 
-	pldm_msgbuf_extract_p(buf, repository_state);
+	rc = pldm_msgbuf_extract_p(buf, repository_state);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
 	if (*repository_state > PLDM_FAILED) {
 		return PLDM_ERROR_INVALID_DATA;
 	}
@@ -461,14 +479,14 @@
 	rc = pldm_msgbuf_extract_array(buf, PLDM_TIMESTAMP104_SIZE, update_time,
 				       PLDM_TIMESTAMP104_SIZE);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	/* NOTE: Memory safety */
 	rc = pldm_msgbuf_extract_array(buf, PLDM_TIMESTAMP104_SIZE,
 				       oem_update_time, PLDM_TIMESTAMP104_SIZE);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	pldm_msgbuf_extract_p(buf, record_count);
@@ -476,7 +494,12 @@
 	pldm_msgbuf_extract_p(buf, largest_record_size);
 	pldm_msgbuf_extract_p(buf, data_transfer_handle_timeout);
 
-	return pldm_msgbuf_destroy(buf);
+	rc = pldm_msgbuf_destroy(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_TESTING
@@ -588,13 +611,17 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	rc = pldm_msgbuf_init_cc(buf, PLDM_GET_PDR_MIN_RESP_BYTES, msg->payload,
-				 payload_length);
+	rc = pldm_msgbuf_init_errno(buf, PLDM_GET_PDR_MIN_RESP_BYTES,
+				    msg->payload, payload_length);
 	if (rc) {
-		return rc;
+		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(rc);
+	}
+
 	if (PLDM_SUCCESS != *completion_code) {
 		return PLDM_SUCCESS;
 	}
@@ -604,7 +631,7 @@
 	pldm_msgbuf_extract_p(buf, transfer_flag);
 	rc = pldm_msgbuf_extract_p(buf, resp_cnt);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	if (*resp_cnt > 0 && record_data != NULL) {
@@ -615,7 +642,7 @@
 		rc = pldm_msgbuf_extract_array(buf, *resp_cnt, record_data,
 					       *resp_cnt);
 		if (rc) {
-			return rc;
+			return pldm_xlate_errno(rc);
 		}
 	}
 
@@ -623,7 +650,12 @@
 		pldm_msgbuf_extract_p(buf, transfer_crc);
 	}
 
-	return pldm_msgbuf_destroy(buf);
+	rc = pldm_msgbuf_destroy(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_TESTING
@@ -695,11 +727,11 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	rc = pldm_msgbuf_init_cc(buf,
-				 PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES,
-				 msg->payload, payload_length);
+	rc = pldm_msgbuf_init_errno(
+		buf, PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES,
+		msg->payload, payload_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	pldm_msgbuf_extract_p(buf, effecter_id);
@@ -715,7 +747,12 @@
 	pldm_msgbuf_extract_effecter_value(buf, *effecter_data_size,
 					   effecter_value);
 
-	return pldm_msgbuf_destroy(buf);
+	rc = pldm_msgbuf_destroy(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_STABLE
@@ -916,16 +953,16 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	rc = pldm_msgbuf_init_cc(buf,
-				 PLDM_GET_STATE_SENSOR_READINGS_MIN_RESP_BYTES,
-				 msg->payload, payload_length);
+	rc = pldm_msgbuf_init_errno(
+		buf, PLDM_GET_STATE_SENSOR_READINGS_MIN_RESP_BYTES,
+		msg->payload, payload_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	rc = pldm_msgbuf_extract_p(buf, completion_code);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	if (PLDM_SUCCESS != *completion_code) {
@@ -934,7 +971,7 @@
 
 	rc = pldm_msgbuf_extract_p(buf, comp_sensor_count);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	if (*comp_sensor_count < 0x1 || *comp_sensor_count > 0x8) {
@@ -948,7 +985,12 @@
 		pldm_msgbuf_extract(buf, field[i].event_state);
 	}
 
-	return pldm_msgbuf_destroy_consumed(buf);
+	rc = pldm_msgbuf_destroy_consumed(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_STABLE
@@ -966,17 +1008,23 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	rc = pldm_msgbuf_init_cc(buf, PLDM_GET_STATE_SENSOR_READINGS_REQ_BYTES,
-				 msg->payload, payload_length);
+	rc = pldm_msgbuf_init_errno(buf,
+				    PLDM_GET_STATE_SENSOR_READINGS_REQ_BYTES,
+				    msg->payload, payload_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	pldm_msgbuf_extract_p(buf, sensor_id);
 	pldm_msgbuf_extract(buf, sensor_rearm->byte);
 	pldm_msgbuf_extract_p(buf, reserved);
 
-	return pldm_msgbuf_destroy(buf);
+	rc = pldm_msgbuf_destroy(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_STABLE
@@ -1031,19 +1079,26 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	rc = pldm_msgbuf_init_cc(buf, PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES,
-				 msg->payload, payload_length);
+	rc = pldm_msgbuf_init_errno(buf,
+				    PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES,
+				    msg->payload, payload_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	pldm_msgbuf_extract_p(buf, format_version);
 	pldm_msgbuf_extract_p(buf, tid);
 	pldm_msgbuf_extract_p(buf, event_class);
+
+	rc = pldm_msgbuf_destroy(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
 	*event_data_offset =
 		sizeof(*format_version) + sizeof(*tid) + sizeof(*event_class);
 
-	return pldm_msgbuf_destroy(buf);
+	return PLDM_SUCCESS;
 }
 
 static int pldm_platform_poll_for_platform_event_message_validate(
@@ -1080,17 +1135,17 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	rc = pldm_msgbuf_init_cc(buf,
-				 PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_REQ_BYTES,
-				 msg->payload, payload_length);
+	rc = pldm_msgbuf_init_errno(
+		buf, PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_REQ_BYTES,
+		msg->payload, payload_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	pldm_msgbuf_extract_p(buf, format_version);
 	rc = pldm_msgbuf_extract_p(buf, transfer_operation_flag);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 	if (*transfer_operation_flag > PLDM_ACKNOWLEDGEMENT_ONLY) {
 		return PLDM_ERROR_INVALID_DATA;
@@ -1099,7 +1154,7 @@
 	pldm_msgbuf_extract_p(buf, data_transfer_handle);
 	rc = pldm_msgbuf_extract_p(buf, event_id_to_acknowledge);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	rc = pldm_platform_poll_for_platform_event_message_validate(
@@ -1108,7 +1163,12 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	return pldm_msgbuf_destroy(buf);
+	rc = pldm_msgbuf_destroy(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_STABLE
@@ -1171,23 +1231,32 @@
 		return rc;
 	}
 
-	rc = pldm_msgbuf_init_cc(
+	rc = pldm_msgbuf_init_errno(
 		buf, PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_MIN_RESP_BYTES,
 		msg->payload, payload_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	pldm_msgbuf_insert(buf, completion_code);
 	pldm_msgbuf_insert(buf, tid);
-	pldm_msgbuf_insert(buf, event_id);
+	rc = pldm_msgbuf_insert(buf, event_id);
+	if (rc) {
+		return pldm_xlate_errno(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_destroy(buf);
+
+		rc = pldm_msgbuf_destroy(buf);
+		if (rc) {
+			return pldm_xlate_errno(rc);
+		}
+
+		return PLDM_SUCCESS;
 	}
 
 	if ((event_data == NULL) && (event_data_size > 0)) {
@@ -1197,13 +1266,16 @@
 	pldm_msgbuf_insert(buf, next_data_transfer_handle);
 	pldm_msgbuf_insert(buf, transfer_flag);
 	pldm_msgbuf_insert(buf, event_class);
-	pldm_msgbuf_insert(buf, event_data_size);
+	rc = pldm_msgbuf_insert(buf, event_data_size);
+	if (rc) {
+		return pldm_xlate_errno(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 rc;
+			return pldm_xlate_errno(rc);
 		}
 	}
 
@@ -1211,7 +1283,12 @@
 		pldm_msgbuf_insert(buf, checksum);
 	}
 
-	return pldm_msgbuf_destroy(buf);
+	rc = pldm_msgbuf_destroy(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_STABLE
@@ -1279,15 +1356,15 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	rc = pldm_msgbuf_init_cc(buf, PLDM_PLATFORM_EVENT_MESSAGE_RESP_BYTES,
-				 msg->payload, payload_length);
+	rc = pldm_msgbuf_init_errno(buf, PLDM_PLATFORM_EVENT_MESSAGE_RESP_BYTES,
+				    msg->payload, payload_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	rc = pldm_msgbuf_extract_p(buf, completion_code);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	if (PLDM_SUCCESS != *completion_code) {
@@ -1296,14 +1373,19 @@
 
 	rc = pldm_msgbuf_extract_p(buf, platform_event_status);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	if (*platform_event_status > PLDM_EVENT_LOGGING_REJECTED) {
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	return pldm_msgbuf_destroy(buf);
+	rc = pldm_msgbuf_destroy(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_STABLE
@@ -1345,15 +1427,16 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	rc = pldm_msgbuf_init_cc(buf, PLDM_EVENT_MESSAGE_BUFFER_SIZE_RESP_BYTES,
-				 msg->payload, payload_length);
+	rc = pldm_msgbuf_init_errno(buf,
+				    PLDM_EVENT_MESSAGE_BUFFER_SIZE_RESP_BYTES,
+				    msg->payload, payload_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	rc = pldm_msgbuf_extract_p(buf, completion_code);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	if (PLDM_SUCCESS != *completion_code) {
@@ -1362,7 +1445,12 @@
 
 	pldm_msgbuf_extract_p(buf, terminus_max_buffer_size);
 
-	return pldm_msgbuf_destroy_consumed(buf);
+	rc = pldm_msgbuf_destroy_consumed(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_STABLE
@@ -1417,16 +1505,16 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	rc = pldm_msgbuf_init_cc(buf,
-				 PLDM_EVENT_MESSAGE_SUPPORTED_MIN_RESP_BYTES,
-				 msg->payload, payload_length);
+	rc = pldm_msgbuf_init_errno(buf,
+				    PLDM_EVENT_MESSAGE_SUPPORTED_MIN_RESP_BYTES,
+				    msg->payload, payload_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	rc = pldm_msgbuf_extract_p(buf, completion_code);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	if (PLDM_SUCCESS != *completion_code) {
@@ -1435,7 +1523,7 @@
 
 	rc = pldm_msgbuf_extract_p(buf, synchrony_config);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	if (*synchrony_config > PLDM_MESSAGE_TYPE_ASYNCHRONOUS_WITH_HEARTBEAT) {
@@ -1446,11 +1534,16 @@
 
 	rc = pldm_msgbuf_extract_p(buf, number_event_class_returned);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	if (*number_event_class_returned == 0) {
-		return pldm_msgbuf_destroy(buf);
+		rc = pldm_msgbuf_destroy(buf);
+		if (rc) {
+			return pldm_xlate_errno(rc);
+		}
+
+		return PLDM_SUCCESS;
 	}
 
 	if (event_class_count < *number_event_class_returned) {
@@ -1461,7 +1554,12 @@
 		pldm_msgbuf_extract(buf, event_class[i]);
 	}
 
-	return pldm_msgbuf_destroy_consumed(buf);
+	rc = pldm_msgbuf_destroy_consumed(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_STABLE
@@ -1480,10 +1578,14 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	rc = pldm_msgbuf_init_cc(buf, PLDM_SENSOR_EVENT_DATA_MIN_LENGTH,
-				 event_data, event_data_length);
+	rc = pldm_msgbuf_init_errno(buf, PLDM_SENSOR_EVENT_DATA_MIN_LENGTH,
+				    event_data, event_data_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
+	}
+
+	if (event_data_length < PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES) {
+		return PLDM_ERROR_INVALID_LENGTH;
 	}
 
 	size_t event_class_data_length =
@@ -1492,7 +1594,7 @@
 	pldm_msgbuf_extract_p(buf, sensor_id);
 	rc = pldm_msgbuf_extract_p(buf, sensor_event_class_type);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	if (*sensor_event_class_type == PLDM_SENSOR_OP_STATE) {
@@ -1519,7 +1621,12 @@
 	*event_class_data_offset =
 		sizeof(*sensor_id) + sizeof(*sensor_event_class_type);
 
-	return pldm_msgbuf_destroy(buf);
+	rc = pldm_msgbuf_destroy(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_STABLE
@@ -1535,17 +1642,22 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	rc = pldm_msgbuf_init_cc(buf,
-				 PLDM_SENSOR_EVENT_SENSOR_OP_STATE_DATA_LENGTH,
-				 sensor_data, sensor_data_length);
+	rc = pldm_msgbuf_init_errno(
+		buf, PLDM_SENSOR_EVENT_SENSOR_OP_STATE_DATA_LENGTH, sensor_data,
+		sensor_data_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	pldm_msgbuf_extract_p(buf, present_op_state);
 	pldm_msgbuf_extract_p(buf, previous_op_state);
 
-	return pldm_msgbuf_destroy_consumed(buf);
+	rc = pldm_msgbuf_destroy_consumed(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_STABLE
@@ -1563,18 +1675,23 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	rc = pldm_msgbuf_init_cc(
+	rc = pldm_msgbuf_init_errno(
 		buf, PLDM_SENSOR_EVENT_STATE_SENSOR_STATE_DATA_LENGTH,
 		sensor_data, sensor_data_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	pldm_msgbuf_extract_p(buf, sensor_offset);
 	pldm_msgbuf_extract_p(buf, event_state);
 	pldm_msgbuf_extract_p(buf, previous_event_state);
 
-	return pldm_msgbuf_destroy_consumed(buf);
+	rc = pldm_msgbuf_destroy_consumed(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_STABLE
@@ -1599,18 +1716,18 @@
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
 
-	rc = pldm_msgbuf_init_cc(
+	rc = pldm_msgbuf_init_errno(
 		buf, PLDM_SENSOR_EVENT_NUMERIC_SENSOR_STATE_MIN_DATA_LENGTH,
 		sensor_data, sensor_data_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	pldm_msgbuf_extract_p(buf, event_state);
 	pldm_msgbuf_extract_p(buf, previous_event_state);
 	rc = pldm_msgbuf_extract_p(buf, sensor_data_size);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	/*
@@ -1665,7 +1782,12 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	return pldm_msgbuf_destroy_consumed(buf);
+	rc = pldm_msgbuf_destroy_consumed(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_STABLE
@@ -1677,15 +1799,15 @@
 	struct pldm_msgbuf *buf = &_buf;
 	int rc;
 
-	rc = pldm_msgbuf_init_cc(buf, PLDM_PDR_NUMERIC_SENSOR_PDR_MIN_LENGTH,
-				 pdr_data, pdr_data_length);
+	rc = pldm_msgbuf_init_errno(buf, PLDM_PDR_NUMERIC_SENSOR_PDR_MIN_LENGTH,
+				    pdr_data, pdr_data_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	rc = pldm_msgbuf_extract_value_pdr_hdr(buf, &pdr_value->hdr);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	rc = pldm_platform_pdr_hdr_validate(
@@ -1715,7 +1837,7 @@
 
 	rc = pldm_msgbuf_extract(buf, pdr_value->sensor_data_size);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 	if (pdr_value->sensor_data_size > PLDM_SENSOR_DATA_SIZE_MAX) {
 		return PLDM_ERROR_INVALID_DATA;
@@ -1740,7 +1862,7 @@
 
 	rc = pldm_msgbuf_extract(buf, pdr_value->range_field_format);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 	if (pdr_value->range_field_format > PLDM_RANGE_FIELD_FORMAT_MAX) {
 		return PLDM_ERROR_INVALID_DATA;
@@ -1766,7 +1888,12 @@
 	pldm_msgbuf_extract_range_field_format(
 		buf, pdr_value->range_field_format, pdr_value->fatal_low);
 
-	return pldm_msgbuf_destroy(buf);
+	rc = pldm_msgbuf_destroy(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_STABLE
@@ -1890,15 +2017,21 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	rc = pldm_msgbuf_init_cc(buf, PLDM_GET_NUMERIC_EFFECTER_VALUE_REQ_BYTES,
-				 msg->payload, payload_length);
+	rc = pldm_msgbuf_init_errno(buf,
+				    PLDM_GET_NUMERIC_EFFECTER_VALUE_REQ_BYTES,
+				    msg->payload, payload_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	pldm_msgbuf_extract_p(buf, effecter_id);
 
-	return pldm_msgbuf_destroy_consumed(buf);
+	rc = pldm_msgbuf_destroy_consumed(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_STABLE
@@ -1920,16 +2053,16 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	rc = pldm_msgbuf_init_cc(buf,
-				 PLDM_GET_NUMERIC_EFFECTER_VALUE_MIN_RESP_BYTES,
-				 msg->payload, payload_length);
+	rc = pldm_msgbuf_init_errno(
+		buf, PLDM_GET_NUMERIC_EFFECTER_VALUE_MIN_RESP_BYTES,
+		msg->payload, payload_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	rc = pldm_msgbuf_extract_p(buf, completion_code);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	if (PLDM_SUCCESS != *completion_code) {
@@ -1938,7 +2071,7 @@
 
 	rc = pldm_msgbuf_extract_p(buf, effecter_data_size);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	if (*effecter_data_size > PLDM_EFFECTER_DATA_SIZE_SINT32) {
@@ -1947,7 +2080,7 @@
 
 	rc = pldm_msgbuf_extract_p(buf, effecter_oper_state);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	if (*effecter_oper_state > EFFECTER_OPER_STATE_INTEST) {
@@ -1959,7 +2092,12 @@
 	pldm_msgbuf_extract_effecter_value(buf, *effecter_data_size,
 					   present_value);
 
-	return pldm_msgbuf_destroy_consumed(buf);
+	rc = pldm_msgbuf_destroy_consumed(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_STABLE
@@ -2043,10 +2181,11 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	rc = pldm_msgbuf_init_cc(buf, PLDM_PDR_REPOSITORY_CHG_EVENT_MIN_LENGTH,
-				 event_data, event_data_size);
+	rc = pldm_msgbuf_init_errno(buf,
+				    PLDM_PDR_REPOSITORY_CHG_EVENT_MIN_LENGTH,
+				    event_data, event_data_size);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	pldm_msgbuf_extract_p(buf, event_data_format);
@@ -2055,7 +2194,12 @@
 	*change_record_data_offset =
 		sizeof(*event_data_format) + sizeof(*number_of_change_records);
 
-	return pldm_msgbuf_destroy(buf);
+	rc = pldm_msgbuf_destroy(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_STABLE
@@ -2137,11 +2281,11 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	rc = pldm_msgbuf_init_cc(buf,
-				 PLDM_PDR_REPOSITORY_CHANGE_RECORD_MIN_LENGTH,
-				 change_record_data, change_record_data_size);
+	rc = pldm_msgbuf_init_errno(
+		buf, PLDM_PDR_REPOSITORY_CHANGE_RECORD_MIN_LENGTH,
+		change_record_data, change_record_data_size);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	pldm_msgbuf_extract_p(buf, event_data_operation);
@@ -2150,7 +2294,12 @@
 	*change_entry_data_offset = sizeof(*event_data_operation) +
 				    sizeof(*number_of_change_entries);
 
-	return pldm_msgbuf_destroy(buf);
+	rc = pldm_msgbuf_destroy(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_STABLE
@@ -2202,15 +2351,15 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	rc = pldm_msgbuf_init_cc(buf, PLDM_GET_SENSOR_READING_MIN_RESP_BYTES,
-				 msg->payload, payload_length);
+	rc = pldm_msgbuf_init_errno(buf, PLDM_GET_SENSOR_READING_MIN_RESP_BYTES,
+				    msg->payload, payload_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	rc = pldm_msgbuf_extract_p(buf, completion_code);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	if (PLDM_SUCCESS != *completion_code) {
@@ -2219,7 +2368,7 @@
 
 	rc = pldm_msgbuf_extract_p(buf, sensor_data_size);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	if (*sensor_data_size > PLDM_SENSOR_DATA_SIZE_SINT32) {
@@ -2235,7 +2384,12 @@
 	pldm_msgbuf_extract_sensor_value(buf, *sensor_data_size,
 					 present_reading);
 
-	return pldm_msgbuf_destroy_consumed(buf);
+	rc = pldm_msgbuf_destroy_consumed(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_STABLE
@@ -2322,16 +2476,21 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	rc = pldm_msgbuf_init_cc(buf, PLDM_GET_SENSOR_READING_REQ_BYTES,
-				 msg->payload, payload_length);
+	rc = pldm_msgbuf_init_errno(buf, PLDM_GET_SENSOR_READING_REQ_BYTES,
+				    msg->payload, payload_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	pldm_msgbuf_extract_p(buf, sensor_id);
 	pldm_msgbuf_extract_p(buf, rearm_event_state);
 
-	return pldm_msgbuf_destroy(buf);
+	rc = pldm_msgbuf_destroy(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_STABLE
@@ -2392,15 +2551,20 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	rc = pldm_msgbuf_init_cc(buf, PLDM_SET_EVENT_RECEIVER_RESP_BYTES,
-				 msg->payload, payload_length);
+	rc = pldm_msgbuf_init_errno(buf, PLDM_SET_EVENT_RECEIVER_RESP_BYTES,
+				    msg->payload, payload_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	pldm_msgbuf_extract_p(buf, completion_code);
 
-	return pldm_msgbuf_destroy(buf);
+	rc = pldm_msgbuf_destroy(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_STABLE
@@ -2422,10 +2586,10 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	rc = pldm_msgbuf_init_cc(buf, PLDM_SET_EVENT_RECEIVER_REQ_BYTES,
-				 msg->payload, payload_length);
+	rc = pldm_msgbuf_init_errno(buf, PLDM_SET_EVENT_RECEIVER_REQ_BYTES,
+				    msg->payload, payload_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	pldm_msgbuf_extract_p(buf, event_message_global_enable);
@@ -2435,7 +2599,7 @@
 
 	rc = pldm_msgbuf_destroy(buf);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	if ((*event_message_global_enable ==
@@ -2506,11 +2670,11 @@
 		return rc;
 	}
 
-	rc = pldm_msgbuf_init_cc(
+	rc = pldm_msgbuf_init_errno(
 		buf, PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_MIN_RESP_BYTES,
 		msg->payload, payload_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	pldm_msgbuf_insert(buf, format_version);
@@ -2518,7 +2682,12 @@
 	pldm_msgbuf_insert(buf, data_transfer_handle);
 	pldm_msgbuf_insert(buf, event_id_to_acknowledge);
 
-	return pldm_msgbuf_destroy(buf);
+	rc = pldm_msgbuf_destroy(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_STABLE
@@ -2541,16 +2710,16 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	rc = pldm_msgbuf_init_cc(
+	rc = pldm_msgbuf_init_errno(
 		buf, PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_MIN_RESP_BYTES,
 		msg->payload, payload_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	rc = pldm_msgbuf_extract_p(buf, completion_code);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 	if (PLDM_SUCCESS != *completion_code) {
 		return *completion_code;
@@ -2559,7 +2728,7 @@
 	pldm_msgbuf_extract_p(buf, tid);
 	rc = pldm_msgbuf_extract_p(buf, event_id);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 	if ((*event_id == 0) || (*event_id == 0xffff)) {
 		return PLDM_SUCCESS;
@@ -2568,13 +2737,13 @@
 	pldm_msgbuf_extract_p(buf, next_data_transfer_handle);
 	rc = pldm_msgbuf_extract_p(buf, transfer_flag);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	pldm_msgbuf_extract_p(buf, event_class);
 	rc = pldm_msgbuf_extract_p(buf, event_data_size);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 	if (*event_data_size > payload_length) {
 		return PLDM_ERROR_INVALID_DATA;
@@ -2589,7 +2758,12 @@
 		pldm_msgbuf_extract_p(buf, event_data_integrity_checksum);
 	}
 
-	return pldm_msgbuf_destroy_consumed(buf);
+	rc = pldm_msgbuf_destroy_consumed(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_TESTING
@@ -2606,15 +2780,16 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	rc = pldm_msgbuf_init_cc(buf, PLDM_PDR_NUMERIC_EFFECTER_PDR_MIN_LENGTH,
-				 pdr_data, pdr_data_length);
+	rc = pldm_msgbuf_init_errno(buf,
+				    PLDM_PDR_NUMERIC_EFFECTER_PDR_MIN_LENGTH,
+				    pdr_data, pdr_data_length);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	rc = pldm_msgbuf_extract_value_pdr_hdr(buf, &hdr);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 
 	rc = pldm_platform_pdr_hdr_validate(
@@ -2646,7 +2821,7 @@
 
 	rc = pldm_msgbuf_extract(buf, pdr_value->effecter_data_size);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 	if (pdr_value->effecter_data_size > PLDM_SENSOR_DATA_SIZE_MAX) {
 		return PLDM_ERROR_INVALID_DATA;
@@ -2666,7 +2841,7 @@
 
 	rc = pldm_msgbuf_extract(buf, pdr_value->range_field_format);
 	if (rc) {
-		return rc;
+		return pldm_xlate_errno(rc);
 	}
 	if (pdr_value->range_field_format > PLDM_RANGE_FIELD_FORMAT_MAX) {
 		return PLDM_ERROR_INVALID_DATA;
@@ -2684,7 +2859,12 @@
 	pldm_msgbuf_extract_range_field_format(
 		buf, pdr_value->range_field_format, pdr_value->rated_min);
 
-	return pldm_msgbuf_destroy_consumed(buf);
+	rc = pldm_msgbuf_destroy_consumed(buf);
+	if (rc) {
+		return pldm_xlate_errno(rc);
+	}
+
+	return PLDM_SUCCESS;
 }
 
 LIBPLDM_ABI_STABLE
diff --git a/src/msgbuf.h b/src/msgbuf.h
index 2a03f05..c7871da 100644
--- a/src/msgbuf.h
+++ b/src/msgbuf.h
@@ -68,79 +68,15 @@
 		"Extraction and insertion value comparisons may be broken");
 	static_assert(INTMAX_MIN + INTMAX_MAX <= 0,
 		      "Extraction and insertion arithmetic may be broken");
-	static_assert(PLDM_SUCCESS == 0, "Error handling is broken");
 	int compliance;
 } build_assertions LIBPLDM_CC_UNUSED;
 
-enum pldm_msgbuf_error_mode {
-	PLDM_MSGBUF_PLDM_CC = 0x5a,
-	PLDM_MSGBUF_C_ERRNO = 0xa5,
-};
-
 struct pldm_msgbuf {
 	uint8_t *cursor;
 	intmax_t remaining;
-	enum pldm_msgbuf_error_mode mode;
 };
 
 /**
- * @brief Either negate an errno value or return a value mapped to a PLDM
- * completion code.
- *
- * Note that `pldm_msgbuf_status()` is purely internal to the msgbuf API
- * for ergonomics. It's preferred that we don't try to unify this with
- * `pldm_xlate_errno()` from src/api.h despite the similarities.
- *
- * @param[in] ctx - The msgbuf context providing the personality info
- * @param[in] err - The positive errno value to translate
- *
- * @return Either the negated value of @p err if the context's error mode is
- *         `PLDM_MSGBUF_C_ERRNO`, or the equivalent PLDM completion code if the
- *         error mode is `PLDM_MSGBUF_PLDM_CC`.
- */
-LIBPLDM_CC_NONNULL
-LIBPLDM_CC_ALWAYS_INLINE int pldm_msgbuf_status(struct pldm_msgbuf *ctx,
-						unsigned int err)
-{
-	int rc;
-
-	assert(err != 0);
-	assert(err <= INT_MAX);
-
-	if (ctx->mode == PLDM_MSGBUF_C_ERRNO) {
-		if (err > INT_MAX) {
-			return -EINVAL;
-		}
-
-		static_assert(INT_MIN + INT_MAX < 0,
-			      "Arithmetic assumption failure");
-		return -((int)err);
-	}
-
-	if (err > INT_MAX) {
-		return PLDM_ERROR;
-	}
-
-	assert(ctx->mode == PLDM_MSGBUF_PLDM_CC);
-	switch (err) {
-	case EINVAL:
-		rc = PLDM_ERROR_INVALID_DATA;
-		break;
-	case EBADMSG:
-	case EOVERFLOW:
-		rc = PLDM_ERROR_INVALID_LENGTH;
-		break;
-	default:
-		assert(false);
-		rc = PLDM_ERROR;
-		break;
-	}
-
-	assert(rc > 0);
-	return rc;
-}
-
-/**
  * @brief Initialize pldm buf struct for buf extractor
  *
  * @param[out] ctx - pldm_msgbuf context for extractor
@@ -154,24 +90,21 @@
 LIBPLDM_CC_NONNULL
 LIBPLDM_CC_ALWAYS_INLINE int
 // NOLINTNEXTLINE(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp)
-pldm__msgbuf_init(struct pldm_msgbuf *ctx, size_t minsize, const void *buf,
-		  size_t len)
+pldm_msgbuf_init_errno(struct pldm_msgbuf *ctx, size_t minsize, const void *buf,
+		       size_t len)
 {
-	assert(ctx->mode == PLDM_MSGBUF_PLDM_CC ||
-	       ctx->mode == PLDM_MSGBUF_C_ERRNO);
-
 	if ((minsize > len)) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 #if INTMAX_MAX < SIZE_MAX
 	if (len > INTMAX_MAX) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 #endif
 
 	if ((uintptr_t)buf + len < len) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	ctx->cursor = (uint8_t *)buf;
@@ -181,52 +114,6 @@
 }
 
 /**
- * @brief Initialise a msgbuf instance to return errors as PLDM completion codes
- *
- * @see pldm__msgbuf_init
- *
- * @param[out] ctx - pldm_msgbuf context for extractor
- * @param[in] minsize - The minimum required length of buffer `buf`
- * @param[in] buf - buffer to be extracted
- * @param[in] len - size of buffer
- *
- * @return PLDM_SUCCESS if the provided buffer region is sensible,
- *         otherwise PLDM_ERROR_INVALID_DATA if pointer parameters are invalid,
- *         or PLDM_ERROR_INVALID_LENGTH if length constraints are violated.
- */
-LIBPLDM_CC_NONNULL
-LIBPLDM_CC_ALWAYS_INLINE int pldm_msgbuf_init_cc(struct pldm_msgbuf *ctx,
-						 size_t minsize,
-						 const void *buf, size_t len)
-{
-	ctx->mode = PLDM_MSGBUF_PLDM_CC;
-	return pldm__msgbuf_init(ctx, minsize, buf, len);
-}
-
-/**
- * @brief Initialise a msgbuf instance to return errors as negative errno values
- *
- * @see pldm__msgbuf_init
- *
- * @param[out] ctx - pldm_msgbuf context for extractor
- * @param[in] minsize - The minimum required length of buffer `buf`
- * @param[in] buf - buffer to be extracted
- * @param[in] len - size of buffer
- *
- * @return 0 if the provided buffer region is sensible, otherwise -EINVAL if
- *         pointer parameters are invalid, or -EOVERFLOW if length constraints
- *         are violated.
- */
-LIBPLDM_CC_NONNULL
-LIBPLDM_CC_ALWAYS_INLINE int pldm_msgbuf_init_errno(struct pldm_msgbuf *ctx,
-						    size_t minsize,
-						    const void *buf, size_t len)
-{
-	ctx->mode = PLDM_MSGBUF_C_ERRNO;
-	return pldm__msgbuf_init(ctx, minsize, buf, len);
-}
-
-/**
  * @brief Validate buffer overflow state
  *
  * @param[in] ctx - pldm_msgbuf context for extractor
@@ -241,7 +128,7 @@
 LIBPLDM_CC_ALWAYS_INLINE int pldm_msgbuf_validate(struct pldm_msgbuf *ctx)
 {
 	if (ctx->remaining < 0) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	return 0;
@@ -262,7 +149,7 @@
 LIBPLDM_CC_ALWAYS_INLINE int pldm_msgbuf_consumed(struct pldm_msgbuf *ctx)
 {
 	if (ctx->remaining != 0) {
-		return pldm_msgbuf_status(ctx, EBADMSG);
+		return -EBADMSG;
 	}
 
 	return 0;
@@ -422,17 +309,17 @@
 pldm__msgbuf_extract_uint8(struct pldm_msgbuf *ctx, void *dst)
 {
 	if (!ctx->cursor) {
-		return pldm_msgbuf_status(ctx, EINVAL);
+		return -EINVAL;
 	}
 
 	if (ctx->remaining == INTMAX_MIN) {
 		assert(ctx->remaining < 0);
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 	ctx->remaining -= sizeof(uint8_t);
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	memcpy(dst, ctx->cursor, sizeof(uint8_t));
@@ -450,17 +337,17 @@
 pldm__msgbuf_extract_int8(struct pldm_msgbuf *ctx, void *dst)
 {
 	if (!ctx->cursor) {
-		return pldm_msgbuf_status(ctx, EINVAL);
+		return -EINVAL;
 	}
 
 	if (ctx->remaining == INTMAX_MIN) {
 		assert(ctx->remaining < 0);
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 	ctx->remaining -= sizeof(int8_t);
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	memcpy(dst, ctx->cursor, sizeof(int8_t));
@@ -479,7 +366,7 @@
 	uint16_t ldst;
 
 	if (!ctx->cursor) {
-		return pldm_msgbuf_status(ctx, EINVAL);
+		return -EINVAL;
 	}
 
 	// Check for underflow while tracking the magnitude of the buffer overflow
@@ -489,7 +376,7 @@
 		"The following addition may not uphold the runtime assertion");
 	if (ctx->remaining < INTMAX_MIN + (intmax_t)sizeof(ldst)) {
 		assert(ctx->remaining < 0);
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	// Check for buffer overflow. If we overflow, account for the request as
@@ -502,7 +389,7 @@
 	// -DNDEBUG by explicitly testing that the access is valid.
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	// Use memcpy() to have the compiler deal with any alignment
@@ -531,7 +418,7 @@
 	int16_t ldst;
 
 	if (!ctx->cursor) {
-		return pldm_msgbuf_status(ctx, EINVAL);
+		return -EINVAL;
 	}
 
 	static_assert(
@@ -540,12 +427,12 @@
 		"The following addition may not uphold the runtime assertion");
 	if (ctx->remaining < INTMAX_MIN + (intmax_t)sizeof(ldst)) {
 		assert(ctx->remaining < 0);
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 	ctx->remaining -= sizeof(ldst);
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	memcpy(&ldst, ctx->cursor, sizeof(ldst));
@@ -568,7 +455,7 @@
 	uint32_t ldst;
 
 	if (!ctx->cursor) {
-		return pldm_msgbuf_status(ctx, EINVAL);
+		return -EINVAL;
 	}
 
 	static_assert(
@@ -577,12 +464,12 @@
 		"The following addition may not uphold the runtime assertion");
 	if (ctx->remaining < INTMAX_MIN + (intmax_t)sizeof(ldst)) {
 		assert(ctx->remaining < 0);
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 	ctx->remaining -= sizeof(ldst);
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	memcpy(&ldst, ctx->cursor, sizeof(ldst));
@@ -604,7 +491,7 @@
 	int32_t ldst;
 
 	if (!ctx->cursor) {
-		return pldm_msgbuf_status(ctx, EINVAL);
+		return -EINVAL;
 	}
 
 	static_assert(
@@ -613,12 +500,12 @@
 		"The following addition may not uphold the runtime assertion");
 	if (ctx->remaining < INTMAX_MIN + (intmax_t)sizeof(ldst)) {
 		assert(ctx->remaining < 0);
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 	ctx->remaining -= sizeof(ldst);
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	memcpy(&ldst, ctx->cursor, sizeof(ldst));
@@ -643,7 +530,7 @@
 		      "Mismatched type sizes for dst and ldst");
 
 	if (!ctx->cursor) {
-		return pldm_msgbuf_status(ctx, EINVAL);
+		return -EINVAL;
 	}
 
 	static_assert(
@@ -652,12 +539,12 @@
 		"The following addition may not uphold the runtime assertion");
 	if (ctx->remaining < INTMAX_MIN + (intmax_t)sizeof(ldst)) {
 		assert(ctx->remaining < 0);
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 	ctx->remaining -= sizeof(ldst);
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	memcpy(&ldst, ctx->cursor, sizeof(ldst));
@@ -717,7 +604,7 @@
 				void *dst, size_t dst_count)
 {
 	if (!ctx->cursor || count > dst_count) {
-		return pldm_msgbuf_status(ctx, EINVAL);
+		return -EINVAL;
 	}
 
 	if (!count) {
@@ -726,17 +613,17 @@
 
 #if INTMAX_MAX < SIZE_MAX
 	if (count > INTMAX_MAX) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 #endif
 
 	if (ctx->remaining < INTMAX_MIN + (intmax_t)count) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 	ctx->remaining -= (intmax_t)count;
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	memcpy(dst, ctx->cursor, count);
@@ -795,7 +682,7 @@
 	uint32_t val = htole32(src);
 
 	if (!ctx->cursor) {
-		return pldm_msgbuf_status(ctx, EINVAL);
+		return -EINVAL;
 	}
 
 	static_assert(
@@ -804,12 +691,12 @@
 		"The following addition may not uphold the runtime assertion");
 	if (ctx->remaining < INTMAX_MIN + (intmax_t)sizeof(src)) {
 		assert(ctx->remaining < 0);
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 	ctx->remaining -= sizeof(src);
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	memcpy(ctx->cursor, &val, sizeof(val));
@@ -825,7 +712,7 @@
 	uint16_t val = htole16(src);
 
 	if (!ctx->cursor) {
-		return pldm_msgbuf_status(ctx, EINVAL);
+		return -EINVAL;
 	}
 
 	static_assert(
@@ -834,12 +721,12 @@
 		"The following addition may not uphold the runtime assertion");
 	if (ctx->remaining < INTMAX_MIN + (intmax_t)sizeof(src)) {
 		assert(ctx->remaining < 0);
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 	ctx->remaining -= sizeof(src);
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	memcpy(ctx->cursor, &val, sizeof(val));
@@ -853,7 +740,7 @@
 						      const uint8_t src)
 {
 	if (!ctx->cursor) {
-		return pldm_msgbuf_status(ctx, EINVAL);
+		return -EINVAL;
 	}
 
 	static_assert(
@@ -862,12 +749,12 @@
 		"The following addition may not uphold the runtime assertion");
 	if (ctx->remaining < INTMAX_MIN + (intmax_t)sizeof(src)) {
 		assert(ctx->remaining < 0);
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 	ctx->remaining -= sizeof(src);
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	memcpy(ctx->cursor, &src, sizeof(src));
@@ -883,7 +770,7 @@
 	int32_t val = htole32(src);
 
 	if (!ctx->cursor) {
-		return pldm_msgbuf_status(ctx, EINVAL);
+		return -EINVAL;
 	}
 
 	static_assert(
@@ -892,12 +779,12 @@
 		"The following addition may not uphold the runtime assertion");
 	if (ctx->remaining < INTMAX_MIN + (intmax_t)sizeof(src)) {
 		assert(ctx->remaining < 0);
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 	ctx->remaining -= sizeof(src);
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	memcpy(ctx->cursor, &val, sizeof(val));
@@ -913,7 +800,7 @@
 	int16_t val = htole16(src);
 
 	if (!ctx->cursor) {
-		return pldm_msgbuf_status(ctx, EINVAL);
+		return -EINVAL;
 	}
 
 	static_assert(
@@ -922,12 +809,12 @@
 		"The following addition may not uphold the runtime assertion");
 	if (ctx->remaining < INTMAX_MIN + (intmax_t)sizeof(src)) {
 		assert(ctx->remaining < 0);
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 	ctx->remaining -= sizeof(src);
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	memcpy(ctx->cursor, &val, sizeof(val));
@@ -941,7 +828,7 @@
 						     const int8_t src)
 {
 	if (!ctx->cursor) {
-		return pldm_msgbuf_status(ctx, EINVAL);
+		return -EINVAL;
 	}
 
 	static_assert(
@@ -950,12 +837,12 @@
 		"The following addition may not uphold the runtime assertion");
 	if (ctx->remaining < INTMAX_MIN + (intmax_t)sizeof(src)) {
 		assert(ctx->remaining < 0);
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 	ctx->remaining -= sizeof(src);
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	memcpy(ctx->cursor, &src, sizeof(src));
@@ -984,7 +871,7 @@
 			       const void *src, size_t src_count)
 {
 	if (!ctx->cursor || count > src_count) {
-		return pldm_msgbuf_status(ctx, EINVAL);
+		return -EINVAL;
 	}
 
 	if (!count) {
@@ -993,17 +880,17 @@
 
 #if INTMAX_MAX < SIZE_MAX
 	if (count > INTMAX_MAX) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 #endif
 
 	if (ctx->remaining < INTMAX_MIN + (intmax_t)count) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 	ctx->remaining -= (intmax_t)count;
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	memcpy(ctx->cursor, src, count);
@@ -1062,22 +949,22 @@
 						       void **cursor)
 {
 	if (!ctx->cursor || (cursor && *cursor)) {
-		return pldm_msgbuf_status(ctx, EINVAL);
+		return -EINVAL;
 	}
 
 #if INTMAX_MAX < SIZE_MAX
 	if (required > INTMAX_MAX) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 #endif
 
 	if (ctx->remaining < INTMAX_MIN + (intmax_t)required) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 	ctx->remaining -= (intmax_t)required;
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	if (cursor) {
@@ -1096,12 +983,12 @@
 	intmax_t measured;
 
 	if (!ctx->cursor || (cursor && *cursor)) {
-		return pldm_msgbuf_status(ctx, EINVAL);
+		return -EINVAL;
 	}
 
 	if (ctx->remaining < 0) {
 		/* Tracking the amount of overflow gets disturbed here */
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	measured = (intmax_t)strnlen((const char *)ctx->cursor, ctx->remaining);
@@ -1113,20 +1000,20 @@
 		 * return an error.
 		 */
 		ctx->remaining = -1;
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	/* Include the NUL terminator in the span length, as spans are opaque */
 	measured++;
 
 	if (ctx->remaining < INTMAX_MIN + measured) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	ctx->remaining -= measured;
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	if (cursor) {
@@ -1152,12 +1039,12 @@
 	void *end;
 
 	if (!ctx->cursor || (cursor && *cursor)) {
-		return pldm_msgbuf_status(ctx, EINVAL);
+		return -EINVAL;
 	}
 
 	if (ctx->remaining < 0) {
 		/* Tracking the amount of overflow gets disturbed here */
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	/*
@@ -1186,7 +1073,7 @@
 		 * `pldm_msgbuf_destroy*()` APIs also return an error.
 		 */
 		ctx->remaining = -1;
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	end = (char *)end + sizeof(char16_t);
@@ -1200,13 +1087,13 @@
 
 	if (ctx->remaining < INTMAX_MIN + (intmax_t)measured) {
 		assert(ctx->remaining < 0);
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	ctx->remaining -= (intmax_t)measured;
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	if (cursor) {
@@ -1227,12 +1114,12 @@
 pldm_msgbuf_span_remaining(struct pldm_msgbuf *ctx, void **cursor, size_t *len)
 {
 	if (!ctx->cursor || *cursor) {
-		return pldm_msgbuf_status(ctx, EINVAL);
+		return -EINVAL;
 	}
 
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
-		return pldm_msgbuf_status(ctx, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	*cursor = ctx->cursor;
@@ -1263,36 +1150,34 @@
 pldm__msgbuf_copy(struct pldm_msgbuf *dst, struct pldm_msgbuf *src, size_t size,
 		  const char *description LIBPLDM_CC_UNUSED)
 {
-	assert(src->mode == dst->mode);
-
 	if (!src->cursor || !dst->cursor) {
-		return pldm_msgbuf_status(dst, EINVAL);
+		return -EINVAL;
 	}
 
 #if INTMAX_MAX < SIZE_MAX
 	if (size > INTMAX_MAX) {
-		return pldm_msgbuf_status(dst, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 #endif
 
 	if (src->remaining < INTMAX_MIN + (intmax_t)size) {
-		return pldm_msgbuf_status(dst, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	if (dst->remaining < INTMAX_MIN + (intmax_t)size) {
-		return pldm_msgbuf_status(dst, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	src->remaining -= (intmax_t)size;
 	assert(src->remaining >= 0);
 	if (src->remaining < 0) {
-		return pldm_msgbuf_status(dst, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	dst->remaining -= (intmax_t)size;
 	assert(dst->remaining >= 0);
 	if (dst->remaining < 0) {
-		return pldm_msgbuf_status(dst, EOVERFLOW);
+		return -EOVERFLOW;
 	}
 
 	memcpy(dst->cursor, src->cursor, size);