LCOV - code coverage report
Current view: top level - unit_test/test_spdm_responder/error_test - event_ack_err.c (source / functions) Coverage Total Hit
Test: coverage.info Lines: 92.4 % 275 254
Test Date: 2025-10-12 08:10:56 Functions: 100.0 % 11 11

            Line data    Source code
       1              : /**
       2              :  *  Copyright Notice:
       3              :  *  Copyright 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 "spdm_unit_test.h"
       8              : #include "internal/libspdm_responder_lib.h"
       9              : #include "internal/libspdm_secured_message_lib.h"
      10              : 
      11              : #if LIBSPDM_EVENT_RECIPIENT_SUPPORT
      12              : 
      13              : static uint8_t m_spdm_request_buffer[0x1000];
      14              : static uint8_t m_spdm_response_buffer[0x1000];
      15              : 
      16              : static const uint32_t m_session_id = 0xffffffff;
      17              : 
      18              : typedef struct {
      19              :     uint32_t event_instance_id;
      20              :     uint8_t svh_id;
      21              :     uint8_t svh_vendor_id_len;
      22              :     uint8_t svh_vendor_id[4];
      23              :     uint16_t event_type_id;
      24              :     uint16_t event_detail_len;
      25              :     uint8_t event_detail[100];
      26              : } expected_event_t;
      27              : 
      28              : static expected_event_t m_expected_event[4];
      29              : static uint32_t m_event_counter;
      30              : static bool m_process_event_error = false;
      31              : 
      32            1 : static libspdm_return_t process_event(void *spdm_context,
      33              :                                       uint32_t session_id,
      34              :                                       uint32_t event_instance_id,
      35              :                                       uint8_t svh_id,
      36              :                                       uint8_t svh_vendor_id_len,
      37              :                                       const void *svh_vendor_id,
      38              :                                       uint16_t event_type_id,
      39              :                                       uint16_t event_detail_len,
      40              :                                       const void *event_detail)
      41              : {
      42            1 :     if (m_process_event_error) {
      43            1 :         return LIBSPDM_STATUS_INVALID_MSG_FIELD;
      44              :     }
      45              : 
      46            0 :     printf("Event Received\n");
      47            0 :     printf("Event Instance ID = [0x%x]\n", event_instance_id);
      48            0 :     printf("SVH ID = [0x%x], SVH VendorIDLen = [0x%x]\n", svh_id, svh_vendor_id_len);
      49            0 :     if (svh_vendor_id_len != 0) {
      50            0 :         printf("SVH VendorID\n");
      51            0 :         libspdm_dump_hex(svh_vendor_id, svh_vendor_id_len);
      52            0 :         printf("\n");
      53              :     }
      54            0 :     printf("EventTypeID = [0x%x], EventDetailLen = [0x%x]\n", event_type_id, event_detail_len);
      55            0 :     printf("Event Detail\n");
      56            0 :     libspdm_dump_hex(event_detail, event_detail_len);
      57              : 
      58            0 :     assert_int_equal(session_id, m_session_id);
      59            0 :     assert_int_equal(event_instance_id, m_expected_event[m_event_counter].event_instance_id);
      60            0 :     assert_int_equal(event_type_id, m_expected_event[m_event_counter].event_type_id);
      61            0 :     assert_int_equal(svh_id, m_expected_event[m_event_counter].svh_id);
      62            0 :     assert_int_equal(svh_vendor_id_len, m_expected_event[m_event_counter].svh_vendor_id_len);
      63            0 :     if (svh_vendor_id_len == 0) {
      64            0 :         assert_ptr_equal(svh_vendor_id, NULL);
      65              :     }
      66            0 :     assert_int_equal(event_detail_len, m_expected_event[m_event_counter].event_detail_len);
      67            0 :     assert_memory_equal(m_expected_event[m_event_counter].event_detail, event_detail,
      68              :                         event_detail_len);
      69            0 :     m_event_counter++;
      70              : 
      71            0 :     return LIBSPDM_STATUS_SUCCESS;
      72              : }
      73              : 
      74            8 : static void set_standard_state(libspdm_context_t *spdm_context)
      75              : {
      76              :     libspdm_session_info_t *session_info;
      77              : 
      78            8 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
      79              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
      80            8 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
      81              : 
      82            8 :     spdm_context->connection_info.capability.flags |=
      83              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_EVENT_CAP;
      84            8 :     spdm_context->connection_info.capability.flags |=
      85              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
      86            8 :     spdm_context->connection_info.capability.flags |=
      87              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
      88            8 :     spdm_context->connection_info.capability.flags |=
      89              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
      90            8 :     spdm_context->connection_info.capability.flags |=
      91              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
      92              : 
      93            8 :     spdm_context->local_context.capability.flags |=
      94              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
      95            8 :     spdm_context->local_context.capability.flags |=
      96              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
      97            8 :     spdm_context->local_context.capability.flags |=
      98              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
      99            8 :     spdm_context->local_context.capability.flags |=
     100              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
     101              : 
     102            8 :     spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
     103            8 :     spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
     104            8 :     spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
     105            8 :     spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
     106              : 
     107            8 :     spdm_context->latest_session_id = m_session_id;
     108            8 :     spdm_context->last_spdm_request_session_id_valid = true;
     109            8 :     spdm_context->last_spdm_request_session_id = m_session_id;
     110            8 :     session_info = &spdm_context->session_info[0];
     111            8 :     libspdm_session_info_init(spdm_context, session_info, m_session_id,
     112              :                               SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
     113            8 :     libspdm_secured_message_set_session_state(
     114              :         session_info->secured_message_context,
     115              :         LIBSPDM_SESSION_STATE_ESTABLISHED);
     116              : 
     117            8 :     libspdm_register_event_callback(spdm_context, process_event);
     118            8 : }
     119              : 
     120              : /**
     121              :  * Test 1: Illegal EventCount is set to 0.
     122              :  * Expected behavior: InvalidRequest error response.
     123              :  **/
     124            1 : static void rsp_event_ack_err_case1(void **state)
     125              : {
     126              :     libspdm_return_t status;
     127              :     libspdm_test_context_t *spdm_test_context;
     128              :     libspdm_context_t *spdm_context;
     129              :     spdm_send_event_request_t *send_event;
     130              :     size_t request_size;
     131              :     spdm_error_response_t *spdm_response;
     132            1 :     size_t response_size =  sizeof(m_spdm_response_buffer);
     133              :     uint8_t event_data_size;
     134              :     spdm_dmtf_event_type_event_lost_t event_lost;
     135              : 
     136            1 :     spdm_test_context = *state;
     137            1 :     spdm_context = spdm_test_context->spdm_context;
     138            1 :     spdm_test_context->case_id = 0x01;
     139              : 
     140            1 :     set_standard_state(spdm_context);
     141              : 
     142            1 :     send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
     143              : 
     144            1 :     send_event->header.spdm_version = SPDM_MESSAGE_VERSION_13;
     145            1 :     send_event->header.request_response_code = SPDM_SEND_EVENT;
     146            1 :     send_event->header.param1 = 0;
     147            1 :     send_event->header.param2 = 0;
     148              :     /* Illegal value for EventCount. */
     149            1 :     send_event->event_count = 0;
     150              : 
     151            1 :     event_lost.last_acked_event_inst_id = 0xffeeddcc;
     152            1 :     event_lost.last_lost_event_inst_id = 0x55667788;
     153              : 
     154            1 :     generate_dmtf_event_data(send_event + 1, &event_data_size, 0x11223344,
     155              :                              SPDM_DMTF_EVENT_TYPE_EVENT_LOST, &event_lost);
     156              : 
     157            1 :     m_event_counter = 0;
     158              : 
     159            1 :     request_size = sizeof(spdm_send_event_request_t) + event_data_size;
     160              : 
     161            1 :     status = libspdm_get_response_send_event(
     162              :         spdm_context, request_size, m_spdm_request_buffer,
     163              :         &response_size, m_spdm_response_buffer);
     164              : 
     165            1 :     spdm_response = (spdm_error_response_t *)m_spdm_response_buffer;
     166              : 
     167            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     168              : 
     169            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     170            1 :     assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_13);
     171            1 :     assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
     172            1 :     assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
     173            1 :     assert_int_equal(spdm_response->header.param2, 0);
     174              : 
     175            1 :     assert_int_equal(m_event_counter, 0);
     176            1 : }
     177              : 
     178              : /**
     179              :  * Test 2: Send two events with gap in event instance IDs.
     180              :  * Expected behavior: InvalidRequest error response.
     181              :  **/
     182            1 : static void rsp_event_ack_err_case2(void **state)
     183              : {
     184              :     libspdm_return_t status;
     185              :     libspdm_test_context_t *spdm_test_context;
     186              :     libspdm_context_t *spdm_context;
     187              :     spdm_send_event_request_t *send_event;
     188              :     size_t request_size;
     189              :     spdm_error_response_t *spdm_response;
     190            1 :     size_t response_size =  sizeof(m_spdm_response_buffer);
     191              :     uint8_t event_data_size[2];
     192              :     spdm_dmtf_event_type_event_lost_t event_lost;
     193              :     spdm_dmtf_event_type_certificate_changed_t certificate_changed;
     194              :     uint8_t *ptr;
     195              : 
     196            1 :     spdm_test_context = *state;
     197            1 :     spdm_context = spdm_test_context->spdm_context;
     198            1 :     spdm_test_context->case_id = 0x02;
     199              : 
     200            1 :     set_standard_state(spdm_context);
     201              : 
     202            1 :     send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
     203              : 
     204            1 :     send_event->header.spdm_version = SPDM_MESSAGE_VERSION_13;
     205            1 :     send_event->header.request_response_code = SPDM_SEND_EVENT;
     206            1 :     send_event->header.param1 = 0;
     207            1 :     send_event->header.param2 = 0;
     208            1 :     send_event->event_count = 2;
     209              : 
     210            1 :     certificate_changed.certificate_changed = 5;
     211              : 
     212            1 :     event_lost.last_acked_event_inst_id = 0xffeeddcc;
     213            1 :     event_lost.last_lost_event_inst_id = 0x55667788;
     214              : 
     215            1 :     ptr = (uint8_t *)(send_event + 1);
     216              : 
     217            1 :     generate_dmtf_event_data(ptr, &event_data_size[0], 0x11223343,
     218              :                              SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED, &certificate_changed);
     219            1 :     ptr += event_data_size[0];
     220              : 
     221            1 :     generate_dmtf_event_data(ptr, &event_data_size[1], 0x11223345,
     222              :                              SPDM_DMTF_EVENT_TYPE_EVENT_LOST, &event_lost);
     223            1 :     ptr += event_data_size[1];
     224              : 
     225            1 :     m_event_counter = 0;
     226              : 
     227            1 :     m_expected_event[0].event_instance_id = 0x11223343;
     228            1 :     m_expected_event[0].svh_id = SPDM_REGISTRY_ID_DMTF;
     229            1 :     m_expected_event[0].svh_vendor_id_len = 0;
     230            1 :     m_expected_event[0].event_type_id = SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED;
     231              : 
     232            1 :     m_expected_event[1].event_instance_id = 0x11223344;
     233            1 :     m_expected_event[1].svh_id = SPDM_REGISTRY_ID_DMTF;
     234            1 :     m_expected_event[1].svh_vendor_id_len = 0;
     235            1 :     m_expected_event[1].event_type_id = SPDM_DMTF_EVENT_TYPE_EVENT_LOST;
     236              : 
     237            1 :     request_size = sizeof(spdm_send_event_request_t) + event_data_size[0] + event_data_size[1];
     238              : 
     239            1 :     status = libspdm_get_response_send_event(
     240              :         spdm_context, request_size, m_spdm_request_buffer,
     241              :         &response_size, m_spdm_response_buffer);
     242              : 
     243            1 :     spdm_response = (spdm_error_response_t *)m_spdm_response_buffer;
     244              : 
     245            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     246              : 
     247            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     248            1 :     assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_13);
     249            1 :     assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
     250            1 :     assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
     251            1 :     assert_int_equal(spdm_response->header.param2, 0);
     252              : 
     253            1 :     assert_int_equal(m_event_counter, 0);
     254            1 : }
     255              : 
     256              : /**
     257              :  * Test 3: Send one event but the value of EventCount is two.
     258              :  * Expected behavior: InvalidRequest error response.
     259              :  **/
     260            1 : static void rsp_event_ack_err_case3(void **state)
     261              : {
     262              :     libspdm_return_t status;
     263              :     libspdm_test_context_t *spdm_test_context;
     264              :     libspdm_context_t *spdm_context;
     265              :     spdm_send_event_request_t *send_event;
     266              :     size_t request_size;
     267              :     spdm_error_response_t *spdm_response;
     268            1 :     size_t response_size =  sizeof(m_spdm_response_buffer);
     269              :     uint8_t event_data_size;
     270              :     spdm_dmtf_event_type_event_lost_t event_lost;
     271              : 
     272            1 :     spdm_test_context = *state;
     273            1 :     spdm_context = spdm_test_context->spdm_context;
     274            1 :     spdm_test_context->case_id = 0x03;
     275              : 
     276            1 :     set_standard_state(spdm_context);
     277              : 
     278            1 :     send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
     279              : 
     280            1 :     send_event->header.spdm_version = SPDM_MESSAGE_VERSION_13;
     281            1 :     send_event->header.request_response_code = SPDM_SEND_EVENT;
     282            1 :     send_event->header.param1 = 0;
     283            1 :     send_event->header.param2 = 0;
     284              :     /* Only one event but event_count is two. */
     285            1 :     send_event->event_count = 2;
     286              : 
     287            1 :     event_lost.last_acked_event_inst_id = 0xffeeddcc;
     288            1 :     event_lost.last_lost_event_inst_id = 0x55667788;
     289              : 
     290            1 :     generate_dmtf_event_data(send_event + 1, &event_data_size, 0x11223344,
     291              :                              SPDM_DMTF_EVENT_TYPE_EVENT_LOST, &event_lost);
     292              : 
     293            1 :     m_event_counter = 0;
     294              : 
     295            1 :     request_size = sizeof(spdm_send_event_request_t) + event_data_size;
     296              : 
     297            1 :     status = libspdm_get_response_send_event(
     298              :         spdm_context, request_size, m_spdm_request_buffer,
     299              :         &response_size, m_spdm_response_buffer);
     300              : 
     301            1 :     spdm_response = (spdm_error_response_t *)m_spdm_response_buffer;
     302              : 
     303            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     304              : 
     305            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     306            1 :     assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_13);
     307            1 :     assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
     308            1 :     assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
     309            1 :     assert_int_equal(spdm_response->header.param2, 0);
     310              : 
     311            1 :     assert_int_equal(m_event_counter, 0);
     312            1 : }
     313              : 
     314              : /**
     315              :  * Test 4: Send one event but request_size is not exact.
     316              :  * Expected behavior: InvalidRequest error response.
     317              :  **/
     318            1 : static void rsp_event_ack_err_case4(void **state)
     319              : {
     320              :     libspdm_return_t status;
     321              :     libspdm_test_context_t *spdm_test_context;
     322              :     libspdm_context_t *spdm_context;
     323              :     spdm_send_event_request_t *send_event;
     324              :     size_t request_size;
     325              :     spdm_error_response_t *spdm_response;
     326            1 :     size_t response_size =  sizeof(m_spdm_response_buffer);
     327              :     uint8_t event_data_size;
     328              :     spdm_dmtf_event_type_event_lost_t event_lost;
     329              : 
     330            1 :     spdm_test_context = *state;
     331            1 :     spdm_context = spdm_test_context->spdm_context;
     332            1 :     spdm_test_context->case_id = 0x04;
     333              : 
     334            1 :     set_standard_state(spdm_context);
     335              : 
     336            1 :     send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
     337              : 
     338            1 :     send_event->header.spdm_version = SPDM_MESSAGE_VERSION_13;
     339            1 :     send_event->header.request_response_code = SPDM_SEND_EVENT;
     340            1 :     send_event->header.param1 = 0;
     341            1 :     send_event->header.param2 = 0;
     342            1 :     send_event->event_count = 1;
     343              : 
     344            1 :     event_lost.last_acked_event_inst_id = 0xffeeddcc;
     345            1 :     event_lost.last_lost_event_inst_id = 0x55667788;
     346              : 
     347            1 :     generate_dmtf_event_data(send_event + 1, &event_data_size, 0x11223344,
     348              :                              SPDM_DMTF_EVENT_TYPE_EVENT_LOST, &event_lost);
     349              : 
     350            1 :     m_event_counter = 0;
     351              : 
     352              :     /* request_size is not exact (+ 1). */
     353            1 :     request_size = sizeof(spdm_send_event_request_t) + event_data_size + 1;
     354              : 
     355            1 :     status = libspdm_get_response_send_event(
     356              :         spdm_context, request_size, m_spdm_request_buffer,
     357              :         &response_size, m_spdm_response_buffer);
     358              : 
     359            1 :     spdm_response = (spdm_error_response_t *)m_spdm_response_buffer;
     360              : 
     361            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     362              : 
     363            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     364            1 :     assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_13);
     365            1 :     assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
     366            1 :     assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
     367            1 :     assert_int_equal(spdm_response->header.param2, 0);
     368              : 
     369            1 :     assert_int_equal(m_event_counter, 0);
     370            1 : }
     371              : 
     372              : /**
     373              :  * Test 5: Negotiated SPDM version does not support SEND_EVENT request message.
     374              :  * Expected Behavior: Responder returns SPDM_ERROR_CODE_UNSUPPORTED_REQUEST.
     375              :  **/
     376            1 : static void rsp_event_ack_err_case5(void **state)
     377              : {
     378              :     libspdm_return_t status;
     379              :     libspdm_test_context_t *spdm_test_context;
     380              :     libspdm_context_t *spdm_context;
     381              :     spdm_send_event_request_t *send_event;
     382              :     size_t request_size;
     383              :     spdm_error_response_t *spdm_response;
     384            1 :     size_t response_size =  sizeof(m_spdm_response_buffer);
     385              : 
     386            1 :     spdm_test_context = *state;
     387            1 :     spdm_context = spdm_test_context->spdm_context;
     388            1 :     spdm_test_context->case_id = 0x05;
     389              : 
     390            1 :     set_standard_state(spdm_context);
     391              : 
     392              :     /* SPDM 1.2 does not support SEND_EVENT request message. */
     393            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
     394              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     395              : 
     396            1 :     send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
     397              : 
     398            1 :     send_event->header.spdm_version = SPDM_MESSAGE_VERSION_12;
     399            1 :     send_event->header.request_response_code = SPDM_SEND_EVENT;
     400            1 :     send_event->header.param1 = 0;
     401            1 :     send_event->header.param2 = 0;
     402              : 
     403            1 :     m_event_counter = 0;
     404              : 
     405            1 :     request_size = sizeof(spdm_send_event_request_t);
     406              : 
     407            1 :     status = libspdm_get_response_send_event(
     408              :         spdm_context, request_size, m_spdm_request_buffer,
     409              :         &response_size, m_spdm_response_buffer);
     410              : 
     411            1 :     spdm_response = (spdm_error_response_t *)m_spdm_response_buffer;
     412              : 
     413            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     414              : 
     415            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     416            1 :     assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
     417            1 :     assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
     418            1 :     assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_UNSUPPORTED_REQUEST);
     419            1 :     assert_int_equal(spdm_response->header.param2, SPDM_SEND_EVENT);
     420              : 
     421            1 :     assert_int_equal(m_event_counter, 0);
     422            1 : }
     423              : 
     424              : /**
     425              :  * Test 6: SPDM version field in SEND_EVENT request message does not match the
     426              :  *         connection's negotiated version.
     427              :  * Expected Behavior: Responder returns SPDM_ERROR_CODE_VERSION_MISMATCH.
     428              :  **/
     429            1 : static void rsp_event_ack_err_case6(void **state)
     430              : {
     431              :     libspdm_return_t status;
     432              :     libspdm_test_context_t *spdm_test_context;
     433              :     libspdm_context_t *spdm_context;
     434              :     spdm_send_event_request_t *send_event;
     435              :     size_t request_size;
     436              :     spdm_error_response_t *spdm_response;
     437            1 :     size_t response_size =  sizeof(m_spdm_response_buffer);
     438              : 
     439            1 :     spdm_test_context = *state;
     440            1 :     spdm_context = spdm_test_context->spdm_context;
     441            1 :     spdm_test_context->case_id = 0x06;
     442              : 
     443            1 :     set_standard_state(spdm_context);
     444              : 
     445            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_14 <<
     446              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     447              : 
     448            1 :     send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
     449              : 
     450              :     /* Value is not equal to the negotiated SPDM version (1.4). */
     451            1 :     send_event->header.spdm_version = SPDM_MESSAGE_VERSION_13;
     452            1 :     send_event->header.request_response_code = SPDM_SEND_EVENT;
     453            1 :     send_event->header.param1 = 0;
     454            1 :     send_event->header.param2 = 0;
     455              : 
     456            1 :     m_event_counter = 0;
     457              : 
     458            1 :     request_size = sizeof(spdm_send_event_request_t);
     459              : 
     460            1 :     status = libspdm_get_response_send_event(
     461              :         spdm_context, request_size, m_spdm_request_buffer,
     462              :         &response_size, m_spdm_response_buffer);
     463              : 
     464            1 :     spdm_response = (spdm_error_response_t *)m_spdm_response_buffer;
     465              : 
     466            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     467              : 
     468            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     469            1 :     assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_14);
     470            1 :     assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
     471            1 :     assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_VERSION_MISMATCH);
     472            1 :     assert_int_equal(spdm_response->header.param2, 0);
     473              : 
     474            1 :     assert_int_equal(m_event_counter, 0);
     475            1 : }
     476              : 
     477              : /**
     478              :  * Test 7: Requester does not support EVENT_CAP.
     479              :  * Expected Behavior: Responder returns SPDM_ERROR_CODE_UNSUPPORTED_REQUEST.
     480              :  **/
     481            1 : static void rsp_event_ack_err_case7(void **state)
     482              : {
     483              :     libspdm_return_t status;
     484              :     libspdm_test_context_t *spdm_test_context;
     485              :     libspdm_context_t *spdm_context;
     486              :     spdm_send_event_request_t *send_event;
     487              :     size_t request_size;
     488              :     spdm_error_response_t *spdm_response;
     489            1 :     size_t response_size =  sizeof(m_spdm_response_buffer);
     490              : 
     491            1 :     spdm_test_context = *state;
     492            1 :     spdm_context = spdm_test_context->spdm_context;
     493            1 :     spdm_test_context->case_id = 0x07;
     494              : 
     495            1 :     set_standard_state(spdm_context);
     496              : 
     497            1 :     send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
     498              : 
     499            1 :     send_event->header.spdm_version = SPDM_MESSAGE_VERSION_13;
     500            1 :     send_event->header.request_response_code = SPDM_SEND_EVENT;
     501            1 :     send_event->header.param1 = 0;
     502            1 :     send_event->header.param2 = 0;
     503              : 
     504              :     /* Requester sends SEND_EVENT but does not support EVENT_CAP. */
     505            1 :     spdm_context->connection_info.capability.flags &=
     506              :         ~SPDM_GET_CAPABILITIES_REQUEST_FLAGS_EVENT_CAP;
     507              : 
     508            1 :     m_event_counter = 0;
     509              : 
     510            1 :     request_size = sizeof(spdm_send_event_request_t);
     511              : 
     512            1 :     status = libspdm_get_response_send_event(
     513              :         spdm_context, request_size, m_spdm_request_buffer,
     514              :         &response_size, m_spdm_response_buffer);
     515              : 
     516            1 :     spdm_response = (spdm_error_response_t *)m_spdm_response_buffer;
     517              : 
     518            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     519              : 
     520            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     521            1 :     assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_13);
     522            1 :     assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
     523            1 :     assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_UNSUPPORTED_REQUEST);
     524            1 :     assert_int_equal(spdm_response->header.param2, SPDM_SEND_EVENT);
     525              : 
     526            1 :     assert_int_equal(m_event_counter, 0);
     527            1 : }
     528              : 
     529              : /**
     530              :  * Test 8: Call to process_event returns an error.
     531              :  * Expected Behavior: Responder returns SPDM_ERROR_CODE_INVALID_REQUEST.
     532              :  **/
     533            1 : static void rsp_event_ack_err_case8(void **state)
     534              : {
     535              :     libspdm_return_t status;
     536              :     libspdm_test_context_t *spdm_test_context;
     537              :     libspdm_context_t *spdm_context;
     538              :     spdm_send_event_request_t *send_event;
     539              :     size_t request_size;
     540              :     spdm_error_response_t *spdm_response;
     541            1 :     size_t response_size =  sizeof(m_spdm_response_buffer);
     542              :     uint8_t event_data_size;
     543              :     spdm_dmtf_event_type_event_lost_t event_lost;
     544              : 
     545            1 :     spdm_test_context = *state;
     546            1 :     spdm_context = spdm_test_context->spdm_context;
     547            1 :     spdm_test_context->case_id = 0x8;
     548              : 
     549            1 :     set_standard_state(spdm_context);
     550              : 
     551            1 :     send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
     552              : 
     553            1 :     send_event->header.spdm_version = SPDM_MESSAGE_VERSION_13;
     554            1 :     send_event->header.request_response_code = SPDM_SEND_EVENT;
     555            1 :     send_event->header.param1 = 0;
     556            1 :     send_event->header.param2 = 0;
     557            1 :     send_event->event_count = 1;
     558              : 
     559            1 :     event_lost.last_acked_event_inst_id = 0xffeeddcc;
     560            1 :     event_lost.last_lost_event_inst_id = 0x55667788;
     561              : 
     562            1 :     generate_dmtf_event_data(send_event + 1, &event_data_size, 0x11223344,
     563              :                              SPDM_DMTF_EVENT_TYPE_EVENT_LOST, &event_lost);
     564              : 
     565            1 :     m_event_counter = 0;
     566              : 
     567            1 :     request_size = sizeof(spdm_send_event_request_t) + event_data_size;
     568              : 
     569              :     /* Induce error in process_request. */
     570            1 :     m_process_event_error = true;
     571              : 
     572            1 :     status = libspdm_get_response_send_event(
     573              :         spdm_context, request_size, m_spdm_request_buffer,
     574              :         &response_size, m_spdm_response_buffer);
     575              : 
     576            1 :     m_process_event_error = false;
     577              : 
     578            1 :     spdm_response = (spdm_error_response_t *)m_spdm_response_buffer;
     579              : 
     580            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     581              : 
     582            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     583            1 :     assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_13);
     584            1 :     assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
     585            1 :     assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
     586            1 :     assert_int_equal(spdm_response->header.param2, 0);
     587              : 
     588            1 :     assert_int_equal(m_event_counter, 0);
     589            1 : }
     590              : 
     591            1 : int libspdm_rsp_event_ack_error_test(void)
     592              : {
     593            1 :     const struct CMUnitTest test_cases[] = {
     594              :         cmocka_unit_test(rsp_event_ack_err_case1),
     595              :         cmocka_unit_test(rsp_event_ack_err_case2),
     596              :         cmocka_unit_test(rsp_event_ack_err_case3),
     597              :         cmocka_unit_test(rsp_event_ack_err_case4),
     598              :         cmocka_unit_test(rsp_event_ack_err_case5),
     599              :         cmocka_unit_test(rsp_event_ack_err_case6),
     600              :         cmocka_unit_test(rsp_event_ack_err_case7),
     601              :         cmocka_unit_test(rsp_event_ack_err_case8),
     602              :     };
     603              : 
     604            1 :     libspdm_test_context_t test_context = {
     605              :         LIBSPDM_TEST_CONTEXT_VERSION,
     606              :         false,
     607              :     };
     608              : 
     609            1 :     libspdm_setup_test_context(&test_context);
     610              : 
     611            1 :     return cmocka_run_group_tests(test_cases,
     612              :                                   libspdm_unit_test_group_setup,
     613              :                                   libspdm_unit_test_group_teardown);
     614              : }
     615              : 
     616              : #endif /* LIBSPDM_EVENT_RECIPIENT_SUPPORT */
        

Generated by: LCOV version 2.0-1