Line data    Source code

       1              : /**
       2              :  *  Copyright Notice:
       3              :  *  Copyright 2025-2026 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_responder_lib.h"
       8              : 
       9              : #if (LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP) && (LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP)
      10              : 
      11            3 : libspdm_return_t libspdm_get_encap_request_send_event(
      12              :     libspdm_context_t *spdm_context,
      13              :     size_t *encap_request_size,
      14              :     void *encap_request)
      15              : {
      16              :     spdm_send_event_request_t *spdm_request;
      17              :     uint32_t session_id;
      18              :     uint32_t event_count;
      19              :     size_t events_list_size;
      20              : 
      21            3 :     spdm_request = encap_request;
      22              : 
      23            3 :     if (spdm_context->last_spdm_request_session_id_valid) {
      24              :         libspdm_session_info_t *session_info;
      25              :         libspdm_session_state_t session_state;
      26              : 
      27            3 :         session_id = spdm_context->last_spdm_request_session_id;
      28            3 :         session_info = libspdm_get_session_info_via_session_id(spdm_context, session_id);
      29              : 
      30            3 :         if (session_info == NULL) {
      31            0 :             return LIBSPDM_STATUS_INVALID_STATE_LOCAL;
      32              :         }
      33              : 
      34            3 :         session_state = libspdm_secured_message_get_session_state(
      35              :             session_info->secured_message_context);
      36              : 
      37            3 :         if (session_state != LIBSPDM_SESSION_STATE_ESTABLISHED) {
      38            0 :             return LIBSPDM_STATUS_INVALID_STATE_LOCAL;
      39              :         }
      40              :     } else {
      41            0 :         return LIBSPDM_STATUS_ERROR_PEER;
      42              :     }
      43              : 
      44            3 :     spdm_request->header.spdm_version = libspdm_get_connection_version(spdm_context);
      45            3 :     spdm_request->header.request_response_code = SPDM_SEND_EVENT;
      46            3 :     spdm_request->header.param1 = 0;
      47            3 :     spdm_request->header.param2 = 0;
      48              : 
      49            3 :     events_list_size = *encap_request_size - sizeof(spdm_send_event_request_t);
      50              : 
      51            3 :     if (!libspdm_generate_event_list(spdm_context, libspdm_get_connection_version(spdm_context),
      52              :                                      session_id, &event_count, &events_list_size,
      53            3 :                                      (uint8_t *)(spdm_request + 1))) {
      54            1 :         return LIBSPDM_STATUS_INVALID_STATE_LOCAL;
      55              :     }
      56              : 
      57            2 :     LIBSPDM_ASSERT(event_count != 0);
      58            2 :     LIBSPDM_ASSERT(events_list_size != 0);
      59              : 
      60            2 :     spdm_request->event_count = event_count;
      61              : 
      62            2 :     *encap_request_size = sizeof(spdm_send_event_request_t) + events_list_size;
      63              : 
      64            2 :     return LIBSPDM_STATUS_SUCCESS;
      65              : }
      66              : 
      67            2 : libspdm_return_t libspdm_process_encap_response_event_ack(
      68              :     libspdm_context_t *spdm_context, size_t encap_response_size,
      69              :     const void *encap_response, bool *need_continue)
      70              : {
      71              :     libspdm_return_t status;
      72              :     const spdm_event_ack_response_t *spdm_response;
      73              :     size_t spdm_response_size;
      74              :     uint32_t session_id;
      75              : 
      76            2 :     if (spdm_context->last_spdm_request_session_id_valid) {
      77              :         libspdm_session_info_t *session_info;
      78              :         libspdm_session_state_t session_state;
      79              : 
      80            2 :         session_id = spdm_context->last_spdm_request_session_id;
      81            2 :         session_info = libspdm_get_session_info_via_session_id(spdm_context, session_id);
      82              : 
      83            2 :         if (session_info == NULL) {
      84            0 :             return LIBSPDM_STATUS_INVALID_STATE_LOCAL;
      85              :         }
      86              : 
      87            2 :         session_state = libspdm_secured_message_get_session_state(
      88              :             session_info->secured_message_context);
      89              : 
      90            2 :         if (session_state != LIBSPDM_SESSION_STATE_ESTABLISHED) {
      91            0 :             return LIBSPDM_STATUS_INVALID_STATE_LOCAL;
      92              :         }
      93              :     } else {
      94            0 :         return LIBSPDM_STATUS_ERROR_PEER;
      95              :     }
      96              : 
      97            2 :     spdm_response = encap_response;
      98            2 :     spdm_response_size = encap_response_size;
      99              : 
     100            2 :     if (spdm_response->header.spdm_version != libspdm_get_connection_version(spdm_context)) {
     101            1 :         return LIBSPDM_STATUS_INVALID_MSG_FIELD;
     102              :     }
     103              : 
     104            1 :     if (spdm_response->header.request_response_code == SPDM_ERROR) {
     105            0 :         status = libspdm_handle_encap_error_response_main(spdm_response->header.param1);
     106            0 :         if (LIBSPDM_STATUS_IS_ERROR(status)) {
     107            0 :             return status;
     108              :         }
     109            1 :     } else if (spdm_response->header.request_response_code != SPDM_EVENT_ACK) {
     110            0 :         return LIBSPDM_STATUS_INVALID_MSG_FIELD;
     111              :     }
     112              : 
     113            1 :     if (spdm_response_size != sizeof(spdm_event_ack_response_t)) {
     114            0 :         return LIBSPDM_STATUS_INVALID_MSG_SIZE;
     115              :     }
     116              : 
     117            1 :     *need_continue = false;
     118              : 
     119            1 :     return LIBSPDM_STATUS_SUCCESS;
     120              : }
     121              : 
     122              : #endif /* (LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP) && (LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP) */