LCOV - code coverage report
Current view: top level - library/spdm_requester_lib - libspdm_req_encap_request.c (source / functions) Coverage Total Hit
Test: coverage.info Lines: 66.5 % 221 147
Test Date: 2025-10-12 08:10:56 Functions: 80.0 % 5 4

            Line data    Source code
       1              : /**
       2              :  *  Copyright Notice:
       3              :  *  Copyright 2021-2025 DMTF. All rights reserved.
       4              :  *  License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
       5              :  **/
       6              : 
       7              : #include "internal/libspdm_requester_lib.h"
       8              : 
       9              : #if LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP
      10              : 
      11           13 : void libspdm_register_get_encap_response_func(void *spdm_context,
      12              :                                               const libspdm_get_encap_response_func
      13              :                                               get_encap_response_func)
      14              : {
      15              :     libspdm_context_t *context;
      16              : 
      17           13 :     context = spdm_context;
      18           13 :     context->get_encap_response_func = (void *)get_encap_response_func;
      19           13 : }
      20              : 
      21              : /**
      22              :  * Return the GET_ENCAP_RESPONSE function via request code.
      23              :  *
      24              :  * @param  request_code                  The SPDM request code.
      25              :  *
      26              :  * @return GET_ENCAP_RESPONSE function according to the request code.
      27              :  **/
      28              : static libspdm_get_encap_response_func
      29            8 : libspdm_get_encap_response_func_via_request_code(uint8_t request_response_code)
      30              : {
      31              :     typedef struct {
      32              :         uint8_t request_response_code;
      33              :         libspdm_get_encap_response_func get_encap_response_func;
      34              :     } libspdm_get_encap_response_struct_t;
      35              : 
      36              :     size_t index;
      37              : 
      38            8 :     const libspdm_get_encap_response_struct_t get_encap_response_struct[] = {
      39              :         #if LIBSPDM_ENABLE_CAPABILITY_CERT_CAP
      40              :         { SPDM_GET_DIGESTS, libspdm_get_encap_response_digest },
      41              :         { SPDM_GET_CERTIFICATE, libspdm_get_encap_response_certificate },
      42              :         #endif /* LIBSPDM_ENABLE_CAPABILITY_CERT_CAP */
      43              : 
      44              :         #if LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP
      45              :         #if LIBSPDM_ENABLE_CAPABILITY_CHAL_CAP
      46              :         { SPDM_CHALLENGE, libspdm_get_encap_response_challenge_auth },
      47              :         #endif /* LIBSPDM_ENABLE_CAPABILITY_CHAL_CAP */
      48              :         #endif /* LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP */
      49              : 
      50              :         #if ((LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP) || (LIBSPDM_ENABLE_CAPABILITY_PSK_CAP))
      51              :         { SPDM_KEY_UPDATE, libspdm_get_encap_response_key_update },
      52              :         #endif /* ((LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP) || (LIBSPDM_ENABLE_CAPABILITY_PSK_CAP)) */
      53              : 
      54              :         #if LIBSPDM_EVENT_RECIPIENT_SUPPORT
      55              :         { SPDM_SEND_EVENT, libspdm_get_encap_response_event_ack },
      56              :         #endif /* LIBSPDM_EVENT_RECIPIENT_SUPPORT */
      57              : 
      58              :         #if LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP
      59              :         { SPDM_GET_SUPPORTED_EVENT_TYPES, libspdm_get_encap_supported_event_types },
      60              :         { SPDM_SUBSCRIBE_EVENT_TYPES, libspdm_get_encap_subscribe_event_types_ack },
      61              :         #endif /* LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP */
      62              : 
      63              :         #if LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP
      64              :         { SPDM_GET_ENDPOINT_INFO, libspdm_get_encap_response_endpoint_info },
      65              :         #endif /* LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP */
      66              :     };
      67              : 
      68           27 :     for (index = 0; index < LIBSPDM_ARRAY_SIZE(get_encap_response_struct); index++) {
      69           26 :         if (request_response_code == get_encap_response_struct[index].request_response_code) {
      70            7 :             return get_encap_response_struct[index].get_encap_response_func;
      71              :         }
      72              :     }
      73            1 :     return NULL;
      74              : }
      75              : 
      76              : /**
      77              :  * This function processes encapsulated request.
      78              :  *
      79              :  * @param  spdm_context         A pointer to the SPDM context.
      80              :  * @param  encap_request_size   Size, in bytes, of the request data buffer.
      81              :  * @param  encap_request        A pointer to a destination buffer to store the request.
      82              :  * @param  encap_response_size  Size, in bytes, of the response data buffer.
      83              :  * @param  encap_response       A pointer to a destination buffer to store the response.
      84              :  **/
      85            8 : static libspdm_return_t libspdm_process_encapsulated_request(libspdm_context_t *spdm_context,
      86              :                                                              size_t encap_request_size,
      87              :                                                              void *encap_request,
      88              :                                                              size_t *encap_response_size,
      89              :                                                              void *encap_response)
      90              : {
      91              :     libspdm_get_encap_response_func get_encap_response_func;
      92              :     spdm_message_header_t *spdm_requester;
      93              : 
      94            8 :     spdm_requester = encap_request;
      95            8 :     if (encap_request_size < sizeof(spdm_message_header_t)) {
      96            0 :         return libspdm_generate_encap_error_response(
      97              :             spdm_context, SPDM_ERROR_CODE_UNSUPPORTED_REQUEST,
      98            0 :             spdm_requester->request_response_code,
      99              :             encap_response_size, encap_response);
     100              :     }
     101              : 
     102            8 :     get_encap_response_func = libspdm_get_encap_response_func_via_request_code(
     103            8 :         spdm_requester->request_response_code);
     104            8 :     if (get_encap_response_func == NULL) {
     105            1 :         get_encap_response_func =
     106            1 :             (libspdm_get_encap_response_func)spdm_context->get_encap_response_func;
     107              :     }
     108            8 :     if (get_encap_response_func != NULL) {
     109            7 :         return get_encap_response_func(
     110              :             spdm_context, encap_request_size, encap_request,
     111              :             encap_response_size, encap_response);
     112              :     } else {
     113            1 :         return libspdm_generate_encap_error_response(
     114              :             spdm_context, SPDM_ERROR_CODE_UNEXPECTED_REQUEST,
     115              :             0, encap_response_size, encap_response);
     116              :     }
     117              : }
     118              : 
     119           13 : libspdm_return_t libspdm_encapsulated_request(libspdm_context_t *spdm_context,
     120              :                                               const uint32_t *session_id,
     121              :                                               uint8_t mut_auth_requested,
     122              :                                               uint8_t *req_slot_id_param)
     123              : {
     124              :     libspdm_return_t status;
     125              :     uint8_t *spdm_request;
     126              :     size_t spdm_request_size;
     127              :     spdm_get_encapsulated_request_request_t
     128              :     *spdm_get_encapsulated_request_request;
     129              :     spdm_deliver_encapsulated_response_request_t
     130              :     *spdm_deliver_encapsulated_response_request;
     131              :     uint8_t *spdm_response;
     132              :     size_t spdm_response_size;
     133              :     spdm_encapsulated_request_response_t *libspdm_encapsulated_request_response;
     134              :     spdm_encapsulated_response_ack_response_t
     135              :     *spdm_encapsulated_response_ack_response;
     136              :     libspdm_session_info_t *session_info;
     137              :     uint8_t request_id;
     138              :     void *encapsulated_request;
     139              :     size_t encapsulated_request_size;
     140              :     void *encapsulated_response;
     141              :     size_t encapsulated_response_size;
     142              :     size_t ack_header_size;
     143              : 
     144              :     uint8_t *message;
     145              :     size_t message_size;
     146              :     size_t transport_header_size;
     147              : 
     148              :     #if LIBSPDM_ENABLE_CAPABILITY_CERT_CAP
     149              :     spdm_get_digest_request_t *get_digests;
     150              :     #endif /* LIBSPDM_ENABLE_CAPABILITY_CERT_CAP */
     151              : 
     152           13 :     if (!libspdm_is_encap_supported(spdm_context)) {
     153            0 :         return LIBSPDM_STATUS_UNSUPPORTED_CAP;
     154              :     }
     155              : 
     156           13 :     if (session_id != NULL) {
     157            0 :         session_info = libspdm_get_session_info_via_session_id(spdm_context, *session_id);
     158            0 :         if (session_info == NULL) {
     159            0 :             LIBSPDM_ASSERT(false);
     160            0 :             return LIBSPDM_STATUS_INVALID_STATE_LOCAL;
     161              :         }
     162            0 :         LIBSPDM_ASSERT((mut_auth_requested == 0) ||
     163              :                        (mut_auth_requested ==
     164              :                         SPDM_KEY_EXCHANGE_RESPONSE_MUT_AUTH_REQUESTED_WITH_ENCAP_REQUEST) ||
     165              :                        (mut_auth_requested ==
     166              :                         SPDM_KEY_EXCHANGE_RESPONSE_MUT_AUTH_REQUESTED_WITH_GET_DIGESTS));
     167              :     } else {
     168           13 :         LIBSPDM_ASSERT(mut_auth_requested == 0);
     169              :     }
     170              : 
     171              : 
     172              :     /* Cache */
     173           13 :     libspdm_reset_message_mut_b(spdm_context);
     174           13 :     libspdm_reset_message_mut_c(spdm_context);
     175              : 
     176           13 :     if (session_id == NULL) {
     177           13 :         spdm_context->last_spdm_request_session_id_valid = false;
     178           13 :         spdm_context->last_spdm_request_session_id = 0;
     179              :     } else {
     180            0 :         spdm_context->last_spdm_request_session_id_valid = true;
     181            0 :         spdm_context->last_spdm_request_session_id = *session_id;
     182              :     }
     183              : 
     184           13 :     if (mut_auth_requested == SPDM_KEY_EXCHANGE_RESPONSE_MUT_AUTH_REQUESTED_WITH_GET_DIGESTS) {
     185              : #if LIBSPDM_ENABLE_CAPABILITY_CERT_CAP
     186            0 :         get_digests = (void *)spdm_context->last_spdm_request;
     187            0 :         get_digests->header.spdm_version = libspdm_get_connection_version (spdm_context);
     188            0 :         get_digests->header.request_response_code = SPDM_GET_DIGESTS;
     189            0 :         get_digests->header.param1 = 0;
     190            0 :         get_digests->header.param2 = 0;
     191            0 :         spdm_context->last_spdm_request_size = sizeof(spdm_get_digest_request_t);
     192            0 :         encapsulated_request = (void *)spdm_context->last_spdm_request;
     193            0 :         encapsulated_request_size = spdm_context->last_spdm_request_size;
     194            0 :         request_id = 0;
     195              : #else /* LIBSPDM_ENABLE_CAPABILITY_CERT_CAP */
     196              :         return LIBSPDM_STATUS_UNSUPPORTED_CAP;
     197              : #endif /* LIBSPDM_ENABLE_CAPABILITY_CERT_CAP */
     198              :     } else {
     199           13 :         transport_header_size = spdm_context->local_context.capability.transport_header_size;
     200           13 :         status = libspdm_acquire_sender_buffer (spdm_context, &message_size, (void **)&message);
     201           13 :         if (LIBSPDM_STATUS_IS_ERROR(status)) {
     202            0 :             return status;
     203              :         }
     204           13 :         LIBSPDM_ASSERT (message_size >= transport_header_size +
     205              :                         spdm_context->local_context.capability.transport_tail_size);
     206           13 :         spdm_request = (void *)(message + transport_header_size);
     207           13 :         spdm_request_size = message_size - transport_header_size -
     208           13 :                             spdm_context->local_context.capability.transport_tail_size;
     209              : 
     210           13 :         spdm_context->crypto_request = true;
     211           13 :         spdm_get_encapsulated_request_request = (void *)spdm_request;
     212           13 :         spdm_get_encapsulated_request_request->header.spdm_version =
     213           13 :             libspdm_get_connection_version (spdm_context);
     214              :         spdm_get_encapsulated_request_request->header
     215           13 :         .request_response_code = SPDM_GET_ENCAPSULATED_REQUEST;
     216           13 :         spdm_get_encapsulated_request_request->header.param1 = 0;
     217           13 :         spdm_get_encapsulated_request_request->header.param2 = 0;
     218           13 :         spdm_request_size = sizeof(spdm_get_encapsulated_request_request_t);
     219           13 :         libspdm_reset_message_buffer_via_request_code
     220              :             (spdm_context, NULL,
     221           13 :             spdm_get_encapsulated_request_request->header.request_response_code);
     222           13 :         status = libspdm_send_spdm_request(spdm_context, session_id, spdm_request_size,
     223              :                                            spdm_request);
     224           13 :         if (LIBSPDM_STATUS_IS_ERROR(status)) {
     225            1 :             libspdm_release_sender_buffer (spdm_context);
     226            1 :             return status;
     227              :         }
     228           12 :         libspdm_release_sender_buffer (spdm_context);
     229           12 :         spdm_get_encapsulated_request_request = (void *)spdm_context->last_spdm_request;
     230              : 
     231              :         /* receive */
     232              : 
     233           12 :         status = libspdm_acquire_receiver_buffer (spdm_context, &message_size, (void **)&message);
     234           12 :         if (LIBSPDM_STATUS_IS_ERROR(status)) {
     235            0 :             return status;
     236              :         }
     237           12 :         LIBSPDM_ASSERT (message_size >= transport_header_size);
     238           12 :         spdm_response = (void *)(message);
     239           12 :         spdm_response_size = message_size;
     240              : 
     241           12 :         status = libspdm_receive_spdm_response(
     242              :             spdm_context, session_id, &spdm_response_size,
     243              :             (void **)&spdm_response);
     244           12 :         libspdm_encapsulated_request_response = (void *)spdm_response;
     245           12 :         if (LIBSPDM_STATUS_IS_ERROR(status)) {
     246            0 :             libspdm_release_receiver_buffer (spdm_context);
     247            0 :             return status;
     248              :         }
     249           12 :         if (libspdm_encapsulated_request_response->header.request_response_code == SPDM_ERROR) {
     250            3 :             const uint8_t error_code = libspdm_encapsulated_request_response->header.param1;
     251              : 
     252            3 :             libspdm_release_receiver_buffer(spdm_context);
     253              : 
     254            3 :             if (spdm_response_size < sizeof(spdm_error_response_t)) {
     255            0 :                 libspdm_release_receiver_buffer (spdm_context);
     256            0 :                 return LIBSPDM_STATUS_INVALID_MSG_SIZE;
     257              :             }
     258              : 
     259            3 :             if (mut_auth_requested == 0) {
     260              :                 /* Responder can send NoPendingRequests or UnexpectedRequest if it has no
     261              :                  * encapsulated request for the Requester. */
     262            3 :                 if ((libspdm_get_connection_version(spdm_context) >= SPDM_MESSAGE_VERSION_13) &&
     263              :                     (error_code == SPDM_ERROR_CODE_NO_PENDING_REQUESTS)) {
     264              : 
     265            1 :                     return LIBSPDM_STATUS_SUCCESS;
     266              :                 }
     267            2 :                 if ((libspdm_get_connection_version(spdm_context) < SPDM_MESSAGE_VERSION_13) &&
     268              :                     (error_code == SPDM_ERROR_CODE_UNEXPECTED_REQUEST)) {
     269            1 :                     return LIBSPDM_STATUS_SUCCESS;
     270              :                 }
     271              :             }
     272            1 :             status = libspdm_handle_error_response_main(
     273              :                 spdm_context, session_id,
     274              :                 &spdm_response_size, (void **)&spdm_response,
     275              :                 SPDM_GET_ENCAPSULATED_REQUEST, SPDM_ENCAPSULATED_REQUEST);
     276            1 :             return status;
     277              :         }
     278            9 :         if (libspdm_encapsulated_request_response->header.spdm_version !=
     279            9 :             spdm_get_encapsulated_request_request->header.spdm_version) {
     280            0 :             libspdm_release_receiver_buffer (spdm_context);
     281            0 :             return LIBSPDM_STATUS_INVALID_MSG_FIELD;
     282              :         }
     283              : 
     284            9 :         if (libspdm_encapsulated_request_response->header.request_response_code !=
     285              :             SPDM_ENCAPSULATED_REQUEST) {
     286            0 :             libspdm_release_receiver_buffer (spdm_context);
     287            0 :             return LIBSPDM_STATUS_INVALID_MSG_FIELD;
     288              :         }
     289            9 :         if (spdm_response_size <= sizeof(spdm_encapsulated_request_response_t)) {
     290            1 :             libspdm_release_receiver_buffer (spdm_context);
     291            1 :             return LIBSPDM_STATUS_INVALID_MSG_SIZE;
     292              :         }
     293              : 
     294            8 :         request_id = libspdm_encapsulated_request_response->header.param1;
     295              : 
     296            8 :         encapsulated_request = (void *)(libspdm_encapsulated_request_response + 1);
     297            8 :         encapsulated_request_size =
     298            8 :             spdm_response_size - sizeof(spdm_encapsulated_request_response_t);
     299              : 
     300            8 :         libspdm_copy_mem (spdm_context->last_spdm_request,
     301            8 :                           libspdm_get_scratch_buffer_last_spdm_request_capacity(spdm_context),
     302              :                           encapsulated_request,
     303              :                           encapsulated_request_size);
     304            8 :         spdm_context->last_spdm_request_size = encapsulated_request_size;
     305            8 :         encapsulated_request = (void *)spdm_context->last_spdm_request;
     306              : 
     307            8 :         libspdm_release_receiver_buffer (spdm_context);
     308              :     }
     309              : 
     310              :     while (true) {
     311              :         /* Process request. */
     312            8 :         transport_header_size = spdm_context->local_context.capability.transport_header_size;
     313            8 :         status = libspdm_acquire_sender_buffer (spdm_context, &message_size, (void **)&message);
     314            8 :         if (LIBSPDM_STATUS_IS_ERROR(status)) {
     315            0 :             return status;
     316              :         }
     317            8 :         LIBSPDM_ASSERT (message_size >= transport_header_size +
     318              :                         spdm_context->local_context.capability.transport_tail_size);
     319            8 :         spdm_request = (void *)(message + transport_header_size);
     320            8 :         spdm_request_size = message_size - transport_header_size -
     321            8 :                             spdm_context->local_context.capability.transport_tail_size;
     322              : 
     323            8 :         spdm_context->crypto_request = true;
     324            8 :         spdm_deliver_encapsulated_response_request = (void *)spdm_request;
     325            8 :         spdm_deliver_encapsulated_response_request->header.spdm_version =
     326            8 :             libspdm_get_connection_version (spdm_context);
     327            8 :         spdm_deliver_encapsulated_response_request->header.request_response_code =
     328              :             SPDM_DELIVER_ENCAPSULATED_RESPONSE;
     329            8 :         spdm_deliver_encapsulated_response_request->header.param1 = request_id;
     330            8 :         spdm_deliver_encapsulated_response_request->header.param2 = 0;
     331            8 :         encapsulated_response = (void *)(spdm_deliver_encapsulated_response_request + 1);
     332            8 :         encapsulated_response_size =
     333            8 :             spdm_request_size - sizeof(spdm_deliver_encapsulated_response_request_t);
     334              : 
     335            8 :         status = libspdm_process_encapsulated_request(
     336              :             spdm_context, encapsulated_request_size,
     337              :             encapsulated_request, &encapsulated_response_size,
     338              :             encapsulated_response);
     339            8 :         if (LIBSPDM_STATUS_IS_ERROR(status)) {
     340            0 :             libspdm_release_sender_buffer (spdm_context);
     341            0 :             return status;
     342              :         }
     343              : 
     344            8 :         spdm_request_size =
     345            8 :             sizeof(spdm_deliver_encapsulated_response_request_t) + encapsulated_response_size;
     346            8 :         status = libspdm_send_spdm_request(
     347              :             spdm_context, session_id, spdm_request_size,
     348              :             spdm_request);
     349            8 :         if (LIBSPDM_STATUS_IS_ERROR(status)) {
     350            0 :             libspdm_release_sender_buffer (spdm_context);
     351            0 :             return status;
     352              :         }
     353            8 :         libspdm_release_sender_buffer (spdm_context);
     354            8 :         spdm_deliver_encapsulated_response_request = (void *)spdm_context->last_spdm_request;
     355              : 
     356              :         /* Receive. */
     357            8 :         status = libspdm_acquire_receiver_buffer (spdm_context, &message_size, (void **)&message);
     358            8 :         if (LIBSPDM_STATUS_IS_ERROR(status)) {
     359            0 :             return status;
     360              :         }
     361            8 :         LIBSPDM_ASSERT (message_size >= transport_header_size);
     362            8 :         spdm_response = (void *)(message);
     363            8 :         spdm_response_size = message_size;
     364              : 
     365            8 :         status = libspdm_receive_spdm_response(
     366              :             spdm_context, session_id, &spdm_response_size,
     367              :             (void **)&spdm_response);
     368            8 :         spdm_encapsulated_response_ack_response = (void *)spdm_response;
     369            8 :         if (LIBSPDM_STATUS_IS_ERROR(status)) {
     370            0 :             libspdm_release_receiver_buffer (spdm_context);
     371            0 :             return status;
     372              :         }
     373            8 :         if (spdm_encapsulated_response_ack_response->header.request_response_code == SPDM_ERROR) {
     374            1 :             libspdm_release_receiver_buffer(spdm_context);
     375              : 
     376            1 :             if (spdm_response_size < sizeof(spdm_error_response_t)) {
     377            0 :                 libspdm_release_receiver_buffer (spdm_context);
     378            0 :                 return LIBSPDM_STATUS_INVALID_MSG_SIZE;
     379              :             }
     380              : 
     381            1 :             status = libspdm_handle_error_response_main(
     382              :                 spdm_context, session_id,
     383              :                 &spdm_response_size, (void **)&spdm_response,
     384              :                 SPDM_DELIVER_ENCAPSULATED_RESPONSE,
     385              :                 SPDM_ENCAPSULATED_RESPONSE_ACK);
     386            1 :             return status;
     387            7 :         } else if (spdm_encapsulated_response_ack_response->header.request_response_code !=
     388              :                    SPDM_ENCAPSULATED_RESPONSE_ACK) {
     389            1 :             libspdm_release_receiver_buffer (spdm_context);
     390            1 :             return LIBSPDM_STATUS_INVALID_MSG_FIELD;
     391              :         }
     392            6 :         if (spdm_encapsulated_response_ack_response->header.spdm_version !=
     393            6 :             spdm_deliver_encapsulated_response_request->header.spdm_version) {
     394            0 :             libspdm_release_receiver_buffer (spdm_context);
     395            0 :             return LIBSPDM_STATUS_INVALID_MSG_FIELD;
     396              :         }
     397            6 :         if (spdm_encapsulated_response_ack_response->header.spdm_version >=
     398              :             SPDM_MESSAGE_VERSION_12) {
     399            1 :             ack_header_size = sizeof(spdm_encapsulated_response_ack_response_t);
     400              :         } else {
     401            5 :             ack_header_size = sizeof(spdm_message_header_t);
     402              :         }
     403            6 :         if (spdm_response_size < ack_header_size) {
     404            0 :             libspdm_release_receiver_buffer (spdm_context);
     405            0 :             return LIBSPDM_STATUS_INVALID_MSG_SIZE;
     406              :         }
     407              : 
     408            6 :         if (spdm_encapsulated_response_ack_response->header.spdm_version >=
     409              :             SPDM_MESSAGE_VERSION_12) {
     410            1 :             if (spdm_encapsulated_response_ack_response->ack_request_id !=
     411            1 :                 spdm_deliver_encapsulated_response_request->header.param1) {
     412            0 :                 libspdm_release_receiver_buffer (spdm_context);
     413            0 :                 return LIBSPDM_STATUS_INVALID_MSG_FIELD;
     414              :             }
     415              :         }
     416              : 
     417            6 :         switch (spdm_encapsulated_response_ack_response->header.param2) {
     418            5 :         case SPDM_ENCAPSULATED_RESPONSE_ACK_RESPONSE_PAYLOAD_TYPE_ABSENT:
     419            5 :             libspdm_release_receiver_buffer (spdm_context);
     420            5 :             return LIBSPDM_STATUS_SUCCESS;
     421            0 :         case SPDM_ENCAPSULATED_RESPONSE_ACK_RESPONSE_PAYLOAD_TYPE_PRESENT:
     422            0 :             break;
     423            1 :         case SPDM_ENCAPSULATED_RESPONSE_ACK_RESPONSE_PAYLOAD_TYPE_REQ_SLOT_NUMBER:
     424            1 :             if (spdm_response_size >= ack_header_size + sizeof(uint8_t)) {
     425            1 :                 if ((req_slot_id_param != NULL) && (*req_slot_id_param == 0)) {
     426            0 :                     *req_slot_id_param =
     427            0 :                         *((uint8_t *)spdm_encapsulated_response_ack_response + ack_header_size);
     428              :                     /* 0xFF or 0xF slot is not allowed. */
     429            0 :                     if (*req_slot_id_param >= SPDM_MAX_SLOT_COUNT) {
     430            0 :                         libspdm_release_receiver_buffer (spdm_context);
     431            0 :                         return LIBSPDM_STATUS_INVALID_MSG_FIELD;
     432              :                     }
     433              : 
     434            0 :                     if ((spdm_encapsulated_response_ack_response->header.spdm_version >=
     435            0 :                          SPDM_MESSAGE_VERSION_13) &&
     436            0 :                         spdm_context->connection_info.multi_key_conn_req) {
     437            0 :                         if ((spdm_context->local_context.local_key_usage_bit_mask[*req_slot_id_param
     438            0 :                              ] & SPDM_KEY_USAGE_BIT_MASK_KEY_EX_USE) == 0) {
     439            0 :                             libspdm_release_receiver_buffer (spdm_context);
     440            0 :                             return LIBSPDM_STATUS_INVALID_MSG_FIELD;
     441              :                         }
     442              :                     }
     443              :                 }
     444            1 :                 libspdm_release_receiver_buffer (spdm_context);
     445            1 :                 return LIBSPDM_STATUS_SUCCESS;
     446              :             } else {
     447            0 :                 libspdm_release_receiver_buffer (spdm_context);
     448            0 :                 return LIBSPDM_STATUS_INVALID_MSG_SIZE;
     449              :             }
     450              :             break;
     451            0 :         default:
     452            0 :             libspdm_release_receiver_buffer (spdm_context);
     453            0 :             return LIBSPDM_STATUS_INVALID_MSG_FIELD;
     454              :         }
     455            0 :         request_id = spdm_encapsulated_response_ack_response->header.param1;
     456              : 
     457            0 :         encapsulated_request =
     458              :             ((uint8_t *)spdm_encapsulated_response_ack_response + ack_header_size);
     459            0 :         encapsulated_request_size = spdm_response_size - ack_header_size;
     460              : 
     461            0 :         libspdm_copy_mem (spdm_context->last_spdm_request,
     462            0 :                           libspdm_get_scratch_buffer_last_spdm_request_capacity(spdm_context),
     463              :                           encapsulated_request,
     464              :                           encapsulated_request_size);
     465            0 :         spdm_context->last_spdm_request_size = encapsulated_request_size;
     466            0 :         encapsulated_request = (void *)spdm_context->last_spdm_request;
     467              : 
     468            0 :         libspdm_release_receiver_buffer (spdm_context);
     469              :     }
     470              : 
     471              :     return LIBSPDM_STATUS_SUCCESS;
     472              : }
     473              : 
     474            0 : libspdm_return_t libspdm_send_receive_encap_request(void *spdm_context, const uint32_t *session_id)
     475              : {
     476            0 :     return libspdm_encapsulated_request(spdm_context, session_id, 0, NULL);
     477              : }
     478              : 
     479              : #endif /* LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP */
        

Generated by: LCOV version 2.0-1