| /** |
| * @brief This file will be depricated soon. Currently it exists as a patch. |
| * This code is to be upstreamed in C, however to build it within this repo, |
| * this code is extracted as a cpp file here. |
| * There were some functionalities that were not working as a C file hence |
| * extracted to a cpp file |
| */ |
| #include "pldm_rde.hpp" |
| |
| #include "libpldm/base.h" |
| |
| #include <endian.h> |
| |
| #include <stdplus/print.hpp> |
| |
| #include <cstdlib> |
| #include <cstring> |
| |
| int encode_negotiate_redfish_parameters_req(uint8_t instance_id, |
| uint8_t concurrency_support, |
| bitfield16_t* feature_support, |
| struct pldm_msg* msg) |
| { |
| if ((msg == NULL) || (feature_support == NULL) || |
| (concurrency_support == 0)) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| struct pldm_header_info header; |
| header.instance = instance_id; |
| header.pldm_type = PLDM_RDE; |
| header.msg_type = PLDM_REQUEST; |
| header.command = PLDM_NEGOTIATE_REDFISH_PARAMETERS; |
| uint8_t rc = pack_pldm_header(&header, &(msg->hdr)); |
| if (rc != PLDM_SUCCESS) |
| { |
| return rc; |
| } |
| struct pldm_rde_negotiate_redfish_parameters_req* req = |
| (struct pldm_rde_negotiate_redfish_parameters_req*)msg->payload; |
| req->mc_concurrency_support = concurrency_support; |
| req->mc_feature_support.value = htole16(feature_support->value); |
| return PLDM_SUCCESS; |
| } |
| |
| int encode_negotiate_redfish_parameters_resp( |
| uint8_t instance_id, uint8_t completion_code, |
| uint8_t device_concurrency_support, bitfield8_t device_capabilities_flags, |
| bitfield16_t device_feature_support, |
| uint32_t device_configuration_signature, const char* device_provider_name, |
| enum pldm_rde_varstring_format name_format, struct pldm_msg* msg) |
| { |
| if ((NULL == msg) || (NULL == device_provider_name)) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| struct pldm_header_info header; |
| header.msg_type = PLDM_RESPONSE; |
| header.instance = instance_id; |
| header.pldm_type = PLDM_RDE; |
| header.command = PLDM_NEGOTIATE_REDFISH_PARAMETERS; |
| uint8_t rc = pack_pldm_header(&header, &(msg->hdr)); |
| if (rc != PLDM_SUCCESS) |
| { |
| return rc; |
| } |
| struct pldm_rde_negotiate_redfish_parameters_resp* response = |
| (struct pldm_rde_negotiate_redfish_parameters_resp*)msg->payload; |
| response->completion_code = completion_code; |
| if (response->completion_code != PLDM_SUCCESS) |
| { |
| return PLDM_SUCCESS; |
| } |
| response->device_concurrency_support = device_concurrency_support; |
| response->device_capabilities_flags.byte = device_capabilities_flags.byte; |
| response->device_feature_support.value = |
| htole16(device_feature_support.value); |
| response->device_configuration_signature = |
| htole32(device_configuration_signature); |
| response->device_provider_name.string_format = name_format; |
| // length should include NULL terminator. |
| response->device_provider_name.string_length_bytes = |
| strlen(device_provider_name) + 1; |
| // Copy including NULL terminator. |
| memcpy(response->device_provider_name.string_data, device_provider_name, |
| response->device_provider_name.string_length_bytes); |
| return PLDM_SUCCESS; |
| } |
| |
| int decode_negotiate_redfish_parameters_req(const struct pldm_msg* msg, |
| size_t payload_length, |
| uint8_t* mc_concurrency_support, |
| bitfield16_t* mc_feature_support) |
| { |
| if ((msg == NULL) || (mc_concurrency_support == NULL) || |
| (mc_feature_support == NULL)) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| if (payload_length != |
| sizeof(struct pldm_rde_negotiate_redfish_parameters_req)) |
| { |
| return PLDM_ERROR_INVALID_LENGTH; |
| } |
| struct pldm_rde_negotiate_redfish_parameters_req* request = |
| (struct pldm_rde_negotiate_redfish_parameters_req*)msg->payload; |
| if (request->mc_concurrency_support == 0) |
| { |
| stdplus::print(stderr, "Concurrency support is 0\n"); |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| *mc_concurrency_support = request->mc_concurrency_support; |
| mc_feature_support->value = le16toh(request->mc_feature_support.value); |
| return PLDM_SUCCESS; |
| } |
| |
| int encode_negotiate_medium_parameters_resp( |
| uint8_t instance_id, uint8_t completion_code, |
| uint32_t device_maximum_transfer_bytes, struct pldm_msg* msg) |
| { |
| if (NULL == msg) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| struct pldm_header_info header; |
| header.msg_type = PLDM_RESPONSE; |
| header.instance = instance_id; |
| header.pldm_type = PLDM_RDE; |
| header.command = PLDM_NEGOTIATE_MEDIUM_PARAMETERS; |
| uint8_t rc = pack_pldm_header(&header, &(msg->hdr)); |
| if (rc != PLDM_SUCCESS) |
| { |
| return rc; |
| } |
| struct pldm_rde_negotiate_medium_parameters_resp* response = |
| (struct pldm_rde_negotiate_medium_parameters_resp*)msg->payload; |
| response->completion_code = completion_code; |
| if (response->completion_code != PLDM_SUCCESS) |
| { |
| return PLDM_SUCCESS; |
| } |
| response->device_maximum_transfer_chunk_size_bytes = |
| htole32(device_maximum_transfer_bytes); |
| return PLDM_SUCCESS; |
| } |
| |
| int decode_negotiate_redfish_parameters_resp( |
| const struct pldm_msg* msg, size_t payload_length, uint8_t* completion_code, |
| struct pldm_rde_device_info* device) |
| { |
| if ((msg == NULL) || (device == NULL) || (completion_code == NULL)) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| |
| *completion_code = msg->payload[0]; |
| |
| if (PLDM_SUCCESS != *completion_code) |
| { |
| stdplus::print( |
| stderr, |
| "Unsuccessful completion code received in neg. params: {}\n", |
| static_cast<uint8_t>(*completion_code)); |
| return PLDM_SUCCESS; |
| } |
| |
| if (payload_length < RDE_NEGOTIATE_REDFISH_PARAMETERS_RESP_BYTES) |
| { |
| return PLDM_ERROR_INVALID_LENGTH; |
| } |
| |
| struct pldm_rde_negotiate_redfish_parameters_resp* response = |
| (struct pldm_rde_negotiate_redfish_parameters_resp*)msg->payload; |
| |
| device->device_concurrency = response->device_concurrency_support; |
| device->device_capabilities_flag = response->device_capabilities_flags; |
| device->device_configuration_signature = |
| le32toh(response->device_configuration_signature); |
| device->device_feature_support.value = |
| le16toh(response->device_feature_support.value); |
| device->device_provider_name = response->device_provider_name; |
| return PLDM_SUCCESS; |
| } |
| |
| int decode_negotiate_medium_parameters_resp( |
| const struct pldm_msg* msg, size_t payload_length, uint8_t* completion_code, |
| uint32_t* device_maximum_transfer_bytes) |
| { |
| if ((msg == NULL) || (device_maximum_transfer_bytes == NULL) || |
| (completion_code == NULL)) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| |
| *completion_code = msg->payload[0]; |
| |
| if (PLDM_SUCCESS != *completion_code) |
| { |
| stdplus::print( |
| stderr, |
| "Unsuccessful completion code received in neg med params: {}\n", |
| static_cast<uint8_t>(*completion_code)); |
| return PLDM_SUCCESS; |
| } |
| |
| if (payload_length < RDE_NEGOTIATE_MEDIUM_PARAMETERS_RESP_BYTES) |
| { |
| return PLDM_ERROR_INVALID_LENGTH; |
| } |
| |
| struct pldm_rde_negotiate_medium_parameters_resp* response = |
| (struct pldm_rde_negotiate_medium_parameters_resp*)msg->payload; |
| |
| *device_maximum_transfer_bytes = |
| le32toh(response->device_maximum_transfer_chunk_size_bytes); |
| |
| return PLDM_SUCCESS; |
| } |
| |
| int encode_negotiate_medium_parameters_req(uint8_t instance_id, |
| uint32_t maximum_transfer_size, |
| struct pldm_msg* msg) |
| { |
| if (msg == NULL) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| struct pldm_header_info header; |
| header.instance = instance_id; |
| header.pldm_type = PLDM_RDE; |
| header.msg_type = PLDM_REQUEST; |
| header.command = PLDM_NEGOTIATE_MEDIUM_PARAMETERS; |
| uint8_t rc = pack_pldm_header(&header, &(msg->hdr)); |
| if (rc != PLDM_SUCCESS) |
| { |
| return rc; |
| } |
| struct pldm_rde_negotiate_medium_parameters_req* req = |
| (struct pldm_rde_negotiate_medium_parameters_req*)msg->payload; |
| req->mc_maximum_transfer_chunk_size_bytes = htole32(maximum_transfer_size); |
| return PLDM_SUCCESS; |
| } |
| |
| int decode_negotiate_medium_parameters_req(const struct pldm_msg* msg, |
| size_t payload_length, |
| uint32_t* mc_maximum_transfer_size) |
| { |
| if ((msg == NULL) || (mc_maximum_transfer_size == NULL)) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| if (payload_length != |
| sizeof(struct pldm_rde_negotiate_medium_parameters_req)) |
| { |
| return PLDM_ERROR_INVALID_LENGTH; |
| } |
| struct pldm_rde_negotiate_medium_parameters_req* request = |
| (struct pldm_rde_negotiate_medium_parameters_req*)msg->payload; |
| *mc_maximum_transfer_size = |
| le32toh(request->mc_maximum_transfer_chunk_size_bytes); |
| if (*mc_maximum_transfer_size < PLDM_RDE_MIN_TRANSFER_SIZE_BYTES) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| return PLDM_SUCCESS; |
| } |
| |
| int encode_get_schema_dictionary_req(uint8_t instance_id, uint32_t resource_id, |
| uint8_t schema_class, struct pldm_msg* msg) |
| { |
| if (msg == NULL) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| struct pldm_header_info header; |
| header.instance = instance_id; |
| header.pldm_type = PLDM_RDE; |
| header.msg_type = PLDM_REQUEST; |
| header.command = PLDM_GET_SCHEMA_DICTIONARY; |
| uint8_t rc = pack_pldm_header(&header, &(msg->hdr)); |
| if (rc != PLDM_SUCCESS) |
| { |
| return rc; |
| } |
| struct pldm_rde_get_schema_dictionary_req* req = |
| (struct pldm_rde_get_schema_dictionary_req*)msg->payload; |
| req->resource_id = htole32(resource_id); |
| req->requested_schema_class = schema_class; |
| return PLDM_SUCCESS; |
| } |
| |
| int decode_get_schema_dictionary_req(const struct pldm_msg* msg, |
| size_t payload_length, |
| uint32_t* resource_id, |
| uint8_t* requested_schema_class) |
| { |
| if ((msg == NULL) || (resource_id == NULL) || |
| (requested_schema_class == NULL)) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| if (payload_length != sizeof(struct pldm_rde_get_schema_dictionary_req)) |
| { |
| return PLDM_ERROR_INVALID_LENGTH; |
| } |
| struct pldm_rde_get_schema_dictionary_req* request = |
| (struct pldm_rde_get_schema_dictionary_req*)msg->payload; |
| *resource_id = le32toh(request->resource_id); |
| *requested_schema_class = request->requested_schema_class; |
| if (*requested_schema_class > PLDM_RDE_SCHEMA_REGISTRY) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| return PLDM_SUCCESS; |
| } |
| |
| int encode_get_schema_dictionary_resp(uint8_t instance_id, |
| uint8_t completion_code, |
| uint8_t dictionary_format, |
| uint32_t transfer_handle, |
| struct pldm_msg* msg) |
| { |
| if (NULL == msg) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| struct pldm_header_info header; |
| header.msg_type = PLDM_RESPONSE; |
| header.instance = instance_id; |
| header.pldm_type = PLDM_RDE; |
| header.command = PLDM_GET_SCHEMA_DICTIONARY; |
| uint8_t rc = pack_pldm_header(&header, &(msg->hdr)); |
| if (rc != PLDM_SUCCESS) |
| { |
| return rc; |
| } |
| struct pldm_rde_get_schema_dictionary_resp* response = |
| (struct pldm_rde_get_schema_dictionary_resp*)msg->payload; |
| response->completion_code = completion_code; |
| if (response->completion_code != PLDM_SUCCESS) |
| { |
| return PLDM_SUCCESS; |
| } |
| response->dictionary_format = dictionary_format; |
| response->transfer_handle = htole32(transfer_handle); |
| return PLDM_SUCCESS; |
| } |
| |
| int decode_get_schema_dictionary_resp(const struct pldm_msg* msg, |
| size_t payload_length, |
| uint8_t* completion_code, |
| uint8_t* dictionary_format, |
| uint32_t* transfer_handle) |
| { |
| if ((msg == NULL) || (dictionary_format == NULL) || |
| (completion_code == NULL) || (transfer_handle == NULL)) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| |
| *completion_code = msg->payload[0]; |
| |
| if (PLDM_SUCCESS != *completion_code) |
| { |
| stdplus::print(stderr, |
| "Unsuccessful completion code received in schema: {}\n", |
| static_cast<uint8_t>(*completion_code)); |
| return PLDM_SUCCESS; |
| } |
| |
| if (payload_length < RDE_GET_DICTIONARY_SCHEMA_RESP_BYTES) |
| { |
| fprintf(stderr, "Unsuccessful completion code received %x", |
| (uint8_t)(*completion_code)); |
| return PLDM_ERROR_INVALID_LENGTH; |
| } |
| |
| struct pldm_rde_get_schema_dictionary_resp* response = |
| (struct pldm_rde_get_schema_dictionary_resp*)msg->payload; |
| *dictionary_format = response->dictionary_format; |
| *transfer_handle = le32toh(response->transfer_handle); |
| return PLDM_SUCCESS; |
| } |
| |
| int encode_rde_multipart_receive_req(uint8_t instance_id, |
| uint32_t data_transfer_handle, |
| uint16_t operation_id, |
| uint8_t transfer_operation, |
| struct pldm_msg* msg) |
| { |
| if (msg == NULL) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| struct pldm_header_info header; |
| header.instance = instance_id; |
| header.pldm_type = PLDM_RDE; |
| header.msg_type = PLDM_REQUEST; |
| header.command = PLDM_RDE_MULTIPART_RECEIVE; |
| uint8_t rc = pack_pldm_header(&header, &(msg->hdr)); |
| if (rc != PLDM_SUCCESS) |
| { |
| return rc; |
| } |
| struct pldm_rde_multipart_receive_req* req = |
| (struct pldm_rde_multipart_receive_req*)msg->payload; |
| req->data_transfer_handle = htole32(data_transfer_handle); |
| req->operation_id = htole16(operation_id); |
| req->transfer_operation = transfer_operation; |
| return PLDM_SUCCESS; |
| } |
| |
| int decode_rde_multipart_receive_req(const struct pldm_msg* msg, |
| size_t payload_length, |
| uint32_t* data_transfer_handle, |
| uint16_t* operation_id, |
| uint8_t* transfer_operation) |
| { |
| if ((msg == NULL) || (data_transfer_handle == NULL) || |
| (operation_id == NULL) || (transfer_operation == NULL)) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| if (payload_length != sizeof(struct pldm_rde_multipart_receive_req)) |
| { |
| return PLDM_ERROR_INVALID_LENGTH; |
| } |
| struct pldm_rde_multipart_receive_req* request = |
| (struct pldm_rde_multipart_receive_req*)msg->payload; |
| *data_transfer_handle = le32toh(request->data_transfer_handle); |
| *operation_id = le16toh(request->operation_id); |
| *transfer_operation = request->transfer_operation; |
| if (*transfer_operation > PLDM_RDE_XFER_ABORT) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| return PLDM_SUCCESS; |
| } |
| |
| int encode_rde_multipart_receive_resp( |
| uint8_t instance_id, uint8_t completion_code, uint8_t transfer_flag, |
| uint32_t next_data_transfer_handle, uint32_t data_length_bytes, |
| bool add_checksum, uint32_t checksum, const uint8_t* payload, |
| struct pldm_msg* msg) |
| { |
| if (NULL == msg) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| struct pldm_header_info header; |
| header.msg_type = PLDM_RESPONSE; |
| header.instance = instance_id; |
| header.pldm_type = PLDM_RDE; |
| header.command = PLDM_RDE_MULTIPART_RECEIVE; |
| uint8_t rc = pack_pldm_header(&header, &(msg->hdr)); |
| if (rc != PLDM_SUCCESS) |
| { |
| return rc; |
| } |
| struct pldm_rde_multipart_receive_resp* response = |
| (struct pldm_rde_multipart_receive_resp*)msg->payload; |
| response->completion_code = completion_code; |
| if (response->completion_code != PLDM_SUCCESS) |
| { |
| return PLDM_SUCCESS; |
| } |
| response->transfer_flag = transfer_flag; |
| response->next_data_transfer_handle = htole32(next_data_transfer_handle); |
| memcpy(response->payload, (uint8_t*)payload, data_length_bytes); |
| uint32_t tot_length = data_length_bytes; |
| if (add_checksum) |
| { |
| tot_length += 4; |
| checksum = htole32(checksum); |
| memcpy(response->payload + data_length_bytes, &checksum, |
| sizeof(uint32_t)); |
| } |
| response->data_length_bytes = htole32(tot_length); |
| return PLDM_SUCCESS; |
| } |
| |
| int decode_rde_multipart_receive_resp( |
| const struct pldm_msg* msg, size_t payload_length, uint8_t* completion_code, |
| uint8_t* ret_transfer_flag, uint32_t* ret_data_transfer_handle, |
| uint32_t* data_length_bytes, uint8_t** payload) |
| { |
| if ((msg == NULL) || (completion_code == NULL) || |
| (ret_transfer_flag == NULL) || (ret_data_transfer_handle == NULL) || |
| (data_length_bytes == NULL) || (payload == NULL)) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| |
| *completion_code = msg->payload[0]; |
| |
| if (PLDM_SUCCESS != *completion_code) |
| { |
| stdplus::print( |
| stderr, "Unsuccessful completion code received in multipart: {}\n", |
| static_cast<uint8_t>(*completion_code)); |
| return PLDM_ERROR; |
| } |
| |
| if (payload_length < RDE_MULTIPART_RECV_MINIMUM_RESP_BYTES) |
| { |
| stdplus::print( |
| stderr, |
| "Decoded successfully with failed payload length in multipart" |
| " with payload length: {} and expected: {}\n", |
| payload_length, RDE_MULTIPART_RECV_MINIMUM_RESP_BYTES); |
| return PLDM_ERROR_INVALID_LENGTH; |
| } |
| |
| struct pldm_rde_multipart_receive_resp* response = |
| (struct pldm_rde_multipart_receive_resp*)msg->payload; |
| *ret_transfer_flag = response->transfer_flag; |
| *ret_data_transfer_handle = le32toh(response->next_data_transfer_handle); |
| *data_length_bytes = le32toh(response->data_length_bytes); |
| *payload = &response->payload[0]; |
| return PLDM_SUCCESS; |
| } |
| |
| int encode_rde_operation_init_req( |
| uint8_t instance_id, uint32_t resource_id, uint16_t operation_id, |
| uint8_t operation_type, |
| const union pldm_rde_operation_flags* operation_flags, |
| uint32_t send_data_transfer_handle, uint8_t operation_locator_length, |
| uint32_t request_payload_length, const uint8_t* operation_locator, |
| uint8_t* request_payload, struct pldm_msg* msg) |
| { |
| if ((msg == NULL) || (operation_flags == NULL)) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| if ((operation_locator_length > 0) && (operation_locator == NULL)) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| if ((request_payload_length > 0) && (request_payload == NULL)) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| struct pldm_header_info header; |
| header.instance = instance_id; |
| header.pldm_type = PLDM_RDE; |
| header.msg_type = PLDM_REQUEST; |
| header.command = PLDM_RDE_OPERATION_INIT; |
| uint8_t rc = pack_pldm_header(&header, &(msg->hdr)); |
| if (rc != PLDM_SUCCESS) |
| { |
| return rc; |
| } |
| struct pldm_rde_operation_init_req* req = |
| (struct pldm_rde_operation_init_req*)msg->payload; |
| req->resource_id = htole32(resource_id); |
| req->operation_id = htole16(operation_id); |
| req->operation_type = operation_type; |
| req->operation_flags.byte = operation_flags->byte; |
| req->send_data_transfer_handle = htole32(send_data_transfer_handle); |
| req->operation_locator_length = operation_locator_length; |
| req->request_payload_length = htole32(request_payload_length); |
| if (operation_locator_length > 0) |
| { |
| memcpy(req->var_data, (uint8_t*)operation_locator, |
| operation_locator_length); |
| } |
| if (request_payload_length > 0) |
| { |
| memcpy(req->var_data + operation_locator_length, |
| (uint8_t*)request_payload, request_payload_length); |
| request_payload = NULL; |
| } |
| return PLDM_SUCCESS; |
| } |
| |
| static bool pldm_rde_is_valid_mc_op_id(uint16_t operation_id) |
| { |
| // Operation identifiers with the MSBit set are reserved for use by the |
| // MC. Operation identifiers with the MSBit clear are reserved for use |
| // by the RDE Device. The value 0x0000 is reserved to indicate no |
| // Operation. |
| if ((operation_id == 0) || ((operation_id >> 15) == 0)) |
| { |
| return false; |
| } |
| return true; |
| } |
| |
| int decode_rde_operation_init_req( |
| const struct pldm_msg* msg, size_t payload_length, uint32_t* resource_id, |
| uint16_t* operation_id, uint8_t* operation_type, |
| union pldm_rde_operation_flags* operation_flags, |
| uint32_t* send_data_transfer_handle, uint8_t* operation_locator_length, |
| uint32_t* request_payload_length, uint8_t** operation_locator, |
| uint8_t** request_payload) |
| { |
| if ((msg == NULL) || (resource_id == NULL) || (operation_id == NULL) || |
| (operation_type == NULL) || (operation_flags == NULL) || |
| (send_data_transfer_handle == NULL) || |
| (operation_locator_length == NULL) || (request_payload_length == NULL)) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| if (payload_length < PLDM_RDE_OPERATION_INIT_REQ_HDR_SIZE) |
| { |
| return PLDM_ERROR_INVALID_LENGTH; |
| } |
| struct pldm_rde_operation_init_req* request = |
| (struct pldm_rde_operation_init_req*)msg->payload; |
| *operation_id = le16toh(request->operation_id); |
| if (!pldm_rde_is_valid_mc_op_id(*operation_id)) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| *resource_id = le32toh(request->resource_id); |
| *operation_type = request->operation_type; |
| operation_flags->byte = request->operation_flags.byte; |
| *send_data_transfer_handle = le32toh(request->send_data_transfer_handle); |
| *operation_locator_length = request->operation_locator_length; |
| *request_payload_length = le32toh(request->request_payload_length); |
| if (*operation_locator_length > 0) |
| { |
| *operation_locator = request->var_data; |
| } |
| else |
| { |
| *operation_locator = NULL; |
| } |
| if (*request_payload_length > 0) |
| { |
| *request_payload = request->var_data + *operation_locator_length; |
| } |
| else |
| { |
| *request_payload = NULL; |
| } |
| return PLDM_SUCCESS; |
| } |
| |
| int encode_rde_operation_init_resp( |
| uint8_t instance_id, uint8_t completion_code, uint8_t operation_status, |
| uint8_t completion_percentage, uint32_t completion_time_seconds, |
| const union pldm_rde_op_execution_flags* operation_execution_flags, |
| uint32_t result_transfer_handle, |
| const union pldm_rde_permission_flags* permission_flags, |
| uint32_t response_payload_length, |
| enum pldm_rde_varstring_format etag_format, const char* etag, |
| const uint8_t* response_payload, struct pldm_msg* msg) |
| { |
| if ((msg == NULL) || (operation_execution_flags == NULL) || |
| (permission_flags == NULL)) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| if ((response_payload_length > 0) && (response_payload == NULL)) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| struct pldm_header_info header; |
| header.msg_type = PLDM_RESPONSE; |
| header.instance = instance_id; |
| header.pldm_type = PLDM_RDE; |
| header.command = PLDM_RDE_OPERATION_INIT; |
| uint8_t rc = pack_pldm_header(&header, &(msg->hdr)); |
| if (rc != PLDM_SUCCESS) |
| { |
| return rc; |
| } |
| struct pldm_rde_operation_init_resp* response = |
| (struct pldm_rde_operation_init_resp*)msg->payload; |
| response->completion_code = completion_code; |
| if (response->completion_code != PLDM_SUCCESS) |
| { |
| return PLDM_SUCCESS; |
| } |
| response->operation_status = operation_status; |
| response->completion_percentage = completion_percentage; |
| response->completion_time_seconds = htole32(completion_time_seconds); |
| response->operation_execution_flags.byte = operation_execution_flags->byte; |
| response->result_transfer_handle = htole32(result_transfer_handle); |
| response->permission_flags.byte = permission_flags->byte; |
| response->response_payload_length = htole32(response_payload_length); |
| struct pldm_rde_varstring* resp_etag = |
| (struct pldm_rde_varstring*)response->var_data; |
| resp_etag->string_format = etag_format; |
| // length should include NULL terminator. |
| size_t etag_len_wo_null = strlen(etag); |
| resp_etag->string_length_bytes = etag_len_wo_null + 1; |
| // Copy including NULL terminator. |
| memcpy(resp_etag->string_data, etag, resp_etag->string_length_bytes); |
| // Copy the payload. |
| if (response_payload_length > 0) |
| { |
| memcpy(response->var_data + sizeof(struct pldm_rde_varstring) + |
| etag_len_wo_null, |
| (uint8_t*)response_payload, response_payload_length); |
| } |
| return PLDM_SUCCESS; |
| } |
| |
| int decode_rde_operation_init_resp( |
| const struct pldm_msg* msg, size_t payload_length, uint8_t* completion_code, |
| uint8_t* completion_percentage, uint8_t* operation_status, |
| uint32_t* completion_time_seconds, uint32_t* result_transfer_handle, |
| uint32_t* response_payload_length, |
| union pldm_rde_permission_flags** permission_flags, |
| union pldm_rde_op_execution_flags** operation_execution_flags, |
| struct pldm_rde_varstring** resp_etag, uint8_t** response_payload) |
| { |
| if (msg == NULL) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| *completion_code = msg->payload[0]; |
| if (PLDM_SUCCESS != *completion_code) |
| { |
| fprintf(stderr, |
| "Unsuccessful completion code received in op init: %x\n", |
| (uint8_t)(*completion_code)); |
| return PLDM_ERROR; |
| } |
| |
| if (payload_length < RDE_READ_OPERATION_INIT_MIN_BYTES) |
| { |
| fprintf(stderr, |
| "Decoded successfully with failed payload length with payload " |
| "length: %zu and expected: %d\n", |
| payload_length, RDE_READ_OPERATION_INIT_MIN_BYTES); |
| return PLDM_ERROR_INVALID_LENGTH; |
| } |
| |
| struct pldm_rde_operation_init_resp* response = |
| (struct pldm_rde_operation_init_resp*)msg->payload; |
| |
| *operation_status = response->operation_status; |
| *completion_percentage = response->completion_percentage; |
| *completion_time_seconds = le32toh(response->completion_time_seconds); |
| (*operation_execution_flags)->byte = |
| response->operation_execution_flags.byte; |
| *result_transfer_handle = le32toh(response->result_transfer_handle); |
| (*permission_flags)->byte = response->permission_flags.byte; |
| *response_payload_length = le32toh(response->response_payload_length); |
| |
| *resp_etag = (struct pldm_rde_varstring*)response->var_data; |
| |
| if (*operation_status == PLDM_RDE_OPERATION_COMPLETED) |
| { |
| *response_payload = |
| &(*resp_etag)->string_data[0] + (*resp_etag)->string_length_bytes; |
| } |
| return 0; |
| } |
| |
| int encode_rde_operation_complete_req(uint8_t instance_id, uint32_t resource_id, |
| uint16_t operation_id, |
| struct pldm_msg* msg) |
| { |
| if (msg == NULL) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| struct pldm_header_info header; |
| header.instance = instance_id; |
| header.pldm_type = PLDM_RDE; |
| header.msg_type = PLDM_REQUEST; |
| header.command = PLDM_RDE_OPERATION_COMPLETE; |
| uint8_t rc = pack_pldm_header(&header, &(msg->hdr)); |
| if (rc != PLDM_SUCCESS) |
| { |
| return rc; |
| } |
| struct pldm_rde_operation_complete_req* req = |
| (struct pldm_rde_operation_complete_req*)msg->payload; |
| req->resource_id = htole32(resource_id); |
| req->operation_id = htole16(operation_id); |
| return PLDM_SUCCESS; |
| } |
| |
| int decode_rde_operation_complete_req(const struct pldm_msg* msg, |
| size_t payload_length, |
| uint32_t* resource_id, |
| uint16_t* operation_id) |
| { |
| if ((msg == NULL) || (resource_id == NULL) || (operation_id == NULL)) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| if (payload_length < sizeof(struct pldm_rde_operation_complete_req)) |
| { |
| return PLDM_ERROR_INVALID_LENGTH; |
| } |
| struct pldm_rde_operation_complete_req* request = |
| (struct pldm_rde_operation_complete_req*)msg->payload; |
| *resource_id = le32toh(request->resource_id); |
| *operation_id = le16toh(request->operation_id); |
| return PLDM_SUCCESS; |
| } |
| |
| int encode_rde_operation_complete_resp(uint8_t instance_id, |
| uint8_t completion_code, |
| struct pldm_msg* msg) |
| { |
| if (msg == NULL) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| struct pldm_header_info header; |
| header.msg_type = PLDM_RESPONSE; |
| header.instance = instance_id; |
| header.pldm_type = PLDM_RDE; |
| header.command = PLDM_RDE_OPERATION_COMPLETE; |
| uint8_t rc = pack_pldm_header(&header, &(msg->hdr)); |
| if (rc != PLDM_SUCCESS) |
| { |
| return rc; |
| } |
| struct pldm_rde_operation_complete_resp* response = |
| (struct pldm_rde_operation_complete_resp*)msg->payload; |
| response->completion_code = completion_code; |
| return PLDM_SUCCESS; |
| } |
| |
| int decode_rde_operation_complete_resp(const struct pldm_msg* msg, |
| size_t payload_length, |
| uint8_t* completion_code) |
| { |
| if (msg == NULL) |
| { |
| fprintf(stderr, "Invalid message object\n"); |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| if (payload_length < 1) |
| { |
| fprintf(stderr, "Invalid payload length\n"); |
| return PLDM_ERROR_INVALID_LENGTH; |
| } |
| |
| *completion_code = msg->payload[0]; |
| |
| if (PLDM_SUCCESS != *completion_code) |
| { |
| fprintf(stderr, |
| "Unsuccessful completion code received in op complete: %x\n", |
| (uint8_t)(*completion_code)); |
| return PLDM_SUCCESS; |
| } |
| return PLDM_SUCCESS; |
| } |
| |
| int encode_rde_operation_status_req(uint8_t instance_id, uint32_t resource_id, |
| uint16_t operation_id, struct pldm_msg* msg) |
| { |
| if (msg == NULL) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| struct pldm_header_info header; |
| header.instance = instance_id; |
| header.pldm_type = PLDM_RDE; |
| header.msg_type = PLDM_REQUEST; |
| header.command = PLDM_RDE_OPERATION_STATUS; |
| uint8_t rc = pack_pldm_header(&header, &(msg->hdr)); |
| if (rc != PLDM_SUCCESS) |
| { |
| return rc; |
| } |
| struct pldm_rde_operation_status_req* req = |
| (struct pldm_rde_operation_status_req*)msg->payload; |
| req->resource_id = htole32(resource_id); |
| req->operation_id = htole16(operation_id); |
| return PLDM_SUCCESS; |
| } |
| |
| int decode_rde_operation_status_req(const struct pldm_msg* msg, |
| size_t payload_length, |
| uint32_t* resource_id, |
| uint16_t* operation_id) |
| { |
| if ((msg == NULL) || (resource_id == NULL) || (operation_id == NULL)) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| if (payload_length < sizeof(struct pldm_rde_operation_status_req)) |
| { |
| return PLDM_ERROR_INVALID_LENGTH; |
| } |
| struct pldm_rde_operation_status_req* request = |
| (struct pldm_rde_operation_status_req*)msg->payload; |
| *resource_id = le32toh(request->resource_id); |
| *operation_id = le16toh(request->operation_id); |
| return PLDM_SUCCESS; |
| } |
| |
| int encode_rde_operation_status_resp( |
| uint8_t instance_id, uint8_t completion_code, uint8_t operation_status, |
| uint8_t completion_percentage, uint32_t completion_time_seconds, |
| const union pldm_rde_op_execution_flags* operation_execution_flags, |
| uint32_t result_transfer_handle, |
| const union pldm_rde_permission_flags* permission_flags, |
| uint32_t response_payload_length, |
| enum pldm_rde_varstring_format etag_format, const char* etag, |
| const uint8_t* response_payload, struct pldm_msg* msg) |
| { |
| if ((msg == NULL) || (operation_execution_flags == NULL) || |
| (permission_flags == NULL)) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| if ((response_payload_length > 0) && (response_payload == NULL)) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| struct pldm_header_info header; |
| header.msg_type = PLDM_RESPONSE; |
| header.instance = instance_id; |
| header.pldm_type = PLDM_RDE; |
| header.command = PLDM_RDE_OPERATION_STATUS; |
| uint8_t rc = pack_pldm_header(&header, &(msg->hdr)); |
| if (rc != PLDM_SUCCESS) |
| { |
| return rc; |
| } |
| struct pldm_rde_operation_status_resp* response = |
| (struct pldm_rde_operation_status_resp*)msg->payload; |
| response->completion_code = completion_code; |
| if (response->completion_code != PLDM_SUCCESS) |
| { |
| return PLDM_SUCCESS; |
| } |
| response->operation_status = operation_status; |
| response->completion_percentage = completion_percentage; |
| response->completion_time_seconds = htole32(completion_time_seconds); |
| response->operation_execution_flags.byte = operation_execution_flags->byte; |
| response->result_transfer_handle = htole32(result_transfer_handle); |
| response->permission_flags.byte = permission_flags->byte; |
| response->response_payload_length = htole32(response_payload_length); |
| struct pldm_rde_varstring* resp_etag = |
| (struct pldm_rde_varstring*)response->var_data; |
| resp_etag->string_format = etag_format; |
| // length should include NULL terminator. |
| size_t etag_len_wo_null = strlen(etag); |
| resp_etag->string_length_bytes = etag_len_wo_null + 1; |
| // Copy including NULL terminator. |
| memcpy(resp_etag->string_data, etag, resp_etag->string_length_bytes); |
| // Copy the payload. |
| if (response_payload_length > 0) |
| { |
| memcpy(response->var_data + sizeof(struct pldm_rde_varstring) + |
| etag_len_wo_null, |
| (uint8_t*)response_payload, response_payload_length); |
| } |
| return PLDM_SUCCESS; |
| } |
| |
| int decode_rde_operation_status_resp( |
| const struct pldm_msg* msg, size_t payload_length, uint8_t* completion_code, |
| uint8_t* completion_percentage, uint8_t* operation_status, |
| uint32_t* completion_time_seconds, uint32_t* result_transfer_handle, |
| uint32_t* response_payload_length, |
| union pldm_rde_permission_flags** permission_flags, |
| union pldm_rde_op_execution_flags** operation_execution_flags, |
| struct pldm_rde_varstring** resp_etag, uint8_t** response_payload) |
| { |
| if (msg == NULL) |
| { |
| stdplus::print(stderr, "Invalid msg object\n"); |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| |
| *completion_code = msg->payload[0]; |
| if (PLDM_SUCCESS != *completion_code) |
| { |
| stdplus::print( |
| stderr, "Unsuccessful completion code received in op status: {}\n", |
| static_cast<uint8_t>(*completion_code)); |
| return PLDM_SUCCESS; |
| } |
| |
| if (payload_length < RDE_READ_OPERATION_INIT_MIN_BYTES) |
| { |
| stdplus::print(stderr, |
| "Decoded sucessfully with failed payload length\n"); |
| return PLDM_ERROR_INVALID_LENGTH; |
| } |
| |
| struct pldm_rde_operation_init_resp* response = |
| (struct pldm_rde_operation_init_resp*)msg->payload; |
| |
| *operation_status = response->operation_status; |
| *completion_percentage = response->completion_percentage; |
| *completion_time_seconds = le32toh(response->completion_time_seconds); |
| (*operation_execution_flags)->byte = |
| response->operation_execution_flags.byte; |
| *result_transfer_handle = le32toh(response->result_transfer_handle); |
| (*permission_flags)->byte = response->permission_flags.byte; |
| *response_payload_length = le32toh(response->response_payload_length); |
| |
| *resp_etag = (struct pldm_rde_varstring*)response->var_data; |
| if (*operation_status == PLDM_RDE_OPERATION_COMPLETED) |
| { |
| *response_payload = |
| &(*resp_etag)->string_data[0] + (*resp_etag)->string_length_bytes; |
| } |
| return 0; |
| } |
| |
| int encode_rde_operation_kill_req(uint8_t instance_id, uint32_t resource_id, |
| uint16_t operation_id, struct pldm_msg* msg) |
| { |
| if (msg == NULL) |
| { |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| struct pldm_header_info header; |
| header.instance = instance_id; |
| header.pldm_type = PLDM_RDE; |
| header.msg_type = PLDM_REQUEST; |
| header.command = PLDM_RDE_OPERATION_KILL; |
| uint8_t rc = pack_pldm_header(&header, &(msg->hdr)); |
| if (rc != PLDM_SUCCESS) |
| { |
| return rc; |
| } |
| struct pldm_rde_operation_kill_req* req = |
| (struct pldm_rde_operation_kill_req*)msg->payload; |
| req->resource_id = htole32(resource_id); |
| req->operation_id = htole16(operation_id); |
| req->killflags.byte = 4; |
| return PLDM_SUCCESS; |
| } |
