diff --git a/include/internal/libspdm_requester_lib.h b/include/internal/libspdm_requester_lib.h index a9f2b9877c1..4eb67c0d100 100644 --- a/include/internal/libspdm_requester_lib.h +++ b/include/internal/libspdm_requester_lib.h @@ -498,6 +498,13 @@ libspdm_return_t libspdm_get_encap_response_event_ack(void *spdm_context, size_t *response_size, void *response); #endif /* LIBSPDM_EVENT_RECIPIENT_SUPPORT */ +#if LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP +libspdm_return_t libspdm_get_encap_supported_event_types(void *spdm_context, + size_t request_size, + void *request, + size_t *response_size, + void *response); +#endif /* LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP */ #if LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP libspdm_return_t libspdm_get_encap_response_endpoint_info(void *spdm_context, size_t request_size, diff --git a/library/spdm_requester_lib/CMakeLists.txt b/library/spdm_requester_lib/CMakeLists.txt index b0131ccb966..8fe227a07b1 100644 --- a/library/spdm_requester_lib/CMakeLists.txt +++ b/library/spdm_requester_lib/CMakeLists.txt @@ -20,6 +20,7 @@ target_sources(spdm_requester_lib libspdm_req_encap_event_ack.c libspdm_req_encap_endpoint_info.c libspdm_req_encap_request.c + libspdm_req_encap_supported_event_types.c libspdm_req_end_session.c libspdm_req_finish.c libspdm_req_get_capabilities.c @@ -44,4 +45,4 @@ target_sources(spdm_requester_lib libspdm_req_get_measurement_extension_log.c libspdm_req_get_key_pair_info.c libspdm_req_set_key_pair_info.c -) \ No newline at end of file +) diff --git a/library/spdm_requester_lib/libspdm_req_encap_request.c b/library/spdm_requester_lib/libspdm_req_encap_request.c index 6e3a1207e30..170200ba4cd 100644 --- a/library/spdm_requester_lib/libspdm_req_encap_request.c +++ b/library/spdm_requester_lib/libspdm_req_encap_request.c @@ -35,7 +35,7 @@ libspdm_get_encap_response_func_via_request_code(uint8_t request_response_code) size_t index; - libspdm_get_encap_response_struct_t get_encap_response_struct[] = { + const libspdm_get_encap_response_struct_t get_encap_response_struct[] = { #if LIBSPDM_ENABLE_CAPABILITY_CERT_CAP { SPDM_GET_DIGESTS, libspdm_get_encap_response_digest }, { SPDM_GET_CERTIFICATE, libspdm_get_encap_response_certificate }, @@ -53,6 +53,10 @@ libspdm_get_encap_response_func_via_request_code(uint8_t request_response_code) { SPDM_SEND_EVENT, libspdm_get_encap_response_event_ack }, #endif /* LIBSPDM_EVENT_RECIPIENT_SUPPORT */ + #if LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP + { SPDM_GET_SUPPORTED_EVENT_TYPES, libspdm_get_encap_supported_event_types }, + #endif /* LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP */ + #if LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP { SPDM_GET_ENDPOINT_INFO, libspdm_get_encap_response_endpoint_info }, #endif /* LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP */ diff --git a/library/spdm_requester_lib/libspdm_req_encap_supported_event_types.c b/library/spdm_requester_lib/libspdm_req_encap_supported_event_types.c new file mode 100644 index 00000000000..323c91d02ce --- /dev/null +++ b/library/spdm_requester_lib/libspdm_req_encap_supported_event_types.c @@ -0,0 +1,107 @@ +/** + * Copyright Notice: + * Copyright 2025 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#include "internal/libspdm_requester_lib.h" +#include "internal/libspdm_secured_message_lib.h" + +#if (LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP) && (LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP) + +libspdm_return_t libspdm_get_encap_supported_event_types(void *spdm_context, + size_t request_size, + void *request, + size_t *response_size, + void *response) +{ + uint32_t session_id; + spdm_supported_event_types_response_t *spdm_response; + spdm_get_supported_event_types_request_t *spdm_request; + const size_t response_buffer_size = *response_size; + libspdm_context_t *context; + libspdm_session_info_t *session_info; + libspdm_session_state_t session_state; + uint32_t supported_event_groups_list_len; + uint8_t event_group_count; + + context = spdm_context; + spdm_request = request; + + if (libspdm_get_connection_version(context) < SPDM_MESSAGE_VERSION_13) { + return libspdm_generate_encap_error_response( + context, SPDM_ERROR_CODE_UNSUPPORTED_REQUEST, SPDM_GET_SUPPORTED_EVENT_TYPES, + response_size, response); + } + if (spdm_request->header.spdm_version != libspdm_get_connection_version(context)) { + return libspdm_generate_encap_error_response( + context, SPDM_ERROR_CODE_VERSION_MISMATCH, 0, response_size, response); + } + if (!libspdm_is_capabilities_flag_supported( + context, true, SPDM_GET_CAPABILITIES_REQUEST_FLAGS_EVENT_CAP, 0)) { + return libspdm_generate_encap_error_response( + context, SPDM_ERROR_CODE_UNSUPPORTED_REQUEST, SPDM_GET_SUPPORTED_EVENT_TYPES, + response_size, response); + } + if (!context->last_spdm_request_session_id_valid) { + return libspdm_generate_encap_error_response( + context, SPDM_ERROR_CODE_SESSION_REQUIRED, 0, response_size, response); + } + + session_id = context->last_spdm_request_session_id; + session_info = libspdm_get_session_info_via_session_id(context, session_id); + if (session_info == NULL) { + return libspdm_generate_encap_error_response( + context, SPDM_ERROR_CODE_INVALID_REQUEST, 0, response_size, response); + } + + session_state = libspdm_secured_message_get_session_state( + session_info->secured_message_context); + if (session_state != LIBSPDM_SESSION_STATE_ESTABLISHED) { + return libspdm_generate_encap_error_response( + context, SPDM_ERROR_CODE_INVALID_REQUEST, 0, response_size, response); + } + + libspdm_reset_message_buffer_via_request_code(context, session_info, + spdm_request->header.request_response_code); + + /* This message can only be in secured session. + * Thus don't need to consider transport layer padding, just check its exact size. */ + if (request_size != sizeof(spdm_get_supported_event_types_request_t)) { + return libspdm_generate_encap_error_response( + context, SPDM_ERROR_CODE_INVALID_REQUEST, 0, + response_size, response); + } + + spdm_response = response; + + spdm_response->header.spdm_version = libspdm_get_connection_version(context); + spdm_response->header.request_response_code = SPDM_SUPPORTED_EVENT_TYPES; + spdm_response->header.param2 = 0; + + supported_event_groups_list_len = (uint32_t)(response_buffer_size - + sizeof(spdm_supported_event_types_response_t)); + + if (!libspdm_event_get_types(context, context->connection_info.version, session_id, + (void *)(spdm_response + 1), &supported_event_groups_list_len, + &event_group_count)) { + return libspdm_generate_encap_error_response(context, + SPDM_ERROR_CODE_UNSPECIFIED, 0, + response_size, response); + } + + LIBSPDM_ASSERT(supported_event_groups_list_len > 0); + LIBSPDM_ASSERT(supported_event_groups_list_len <= + (response_buffer_size - sizeof(spdm_supported_event_types_response_t))); + LIBSPDM_ASSERT(event_group_count > 0); + + spdm_response->header.param1 = event_group_count; + spdm_response->supported_event_groups_list_len = supported_event_groups_list_len; + + *response_size = sizeof(spdm_supported_event_types_response_t) + + supported_event_groups_list_len; + + return LIBSPDM_STATUS_SUCCESS; +} + +#endif /* (LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP) && (LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP) */ diff --git a/unit_test/test_spdm_requester/CMakeLists.txt b/unit_test/test_spdm_requester/CMakeLists.txt index 248bcdfb10f..d3ec5da1a18 100644 --- a/unit_test/test_spdm_requester/CMakeLists.txt +++ b/unit_test/test_spdm_requester/CMakeLists.txt @@ -41,6 +41,7 @@ target_sources(test_spdm_requester encap_endpoint_info.c encap_key_update.c encap_request.c + encap_supported_event_types.c set_certificate.c get_csr.c chunk_get.c @@ -63,6 +64,7 @@ target_sources(test_spdm_requester error_test/encap_event_ack_err.c error_test/get_endpoint_info_err.c error_test/encap_endpoint_info_err.c + error_test/encap_supported_event_types_err.c ${LIBSPDM_DIR}/unit_test/spdm_unit_test_common/common.c ${LIBSPDM_DIR}/unit_test/spdm_unit_test_common/algo.c ${LIBSPDM_DIR}/unit_test/spdm_unit_test_common/support.c diff --git a/unit_test/test_spdm_requester/encap_supported_event_types.c b/unit_test/test_spdm_requester/encap_supported_event_types.c new file mode 100644 index 00000000000..5cc7c1d59f9 --- /dev/null +++ b/unit_test/test_spdm_requester/encap_supported_event_types.c @@ -0,0 +1,131 @@ +/** + * Copyright Notice: + * Copyright 2025 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#include "spdm_unit_test.h" +#include "internal/libspdm_requester_lib.h" + +#if (LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP) && (LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP) + +static uint8_t m_spdm_request_buffer[0x1000]; +static uint8_t m_spdm_response_buffer[0x1000]; + +static const uint32_t m_session_id = 0xffffffff; + +extern uint32_t g_supported_event_groups_list_len; +extern uint8_t g_event_group_count; + +static void set_standard_state(libspdm_context_t *spdm_context) +{ + libspdm_session_info_t *session_info; + + spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 << + SPDM_VERSION_NUMBER_SHIFT_BIT; + spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED; + + spdm_context->connection_info.capability.flags |= + SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP; + spdm_context->connection_info.capability.flags |= + SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP; + spdm_context->connection_info.capability.flags |= + SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP; + spdm_context->connection_info.capability.flags |= + SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP; + + spdm_context->local_context.capability.flags |= + SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP; + spdm_context->local_context.capability.flags |= + SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP; + spdm_context->local_context.capability.flags |= + SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP; + spdm_context->local_context.capability.flags |= + SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP; + spdm_context->local_context.capability.flags |= + SPDM_GET_CAPABILITIES_REQUEST_FLAGS_EVENT_CAP; + + spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo; + spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo; + spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo; + spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo; + + spdm_context->latest_session_id = m_session_id; + spdm_context->last_spdm_request_session_id_valid = true; + spdm_context->last_spdm_request_session_id = m_session_id; + session_info = &spdm_context->session_info[0]; + libspdm_session_info_init(spdm_context, session_info, m_session_id, true); + libspdm_secured_message_set_session_state( + session_info->secured_message_context, + LIBSPDM_SESSION_STATE_ESTABLISHED); +} + +static void test_supported_event_types_case1(void **state) +{ + libspdm_return_t status; + libspdm_test_context_t *spdm_test_context; + libspdm_context_t *spdm_context; + spdm_get_supported_event_types_request_t *get_supported_event_types; + size_t request_size; + spdm_supported_event_types_response_t *supported_event_types; + size_t response_size = sizeof(m_spdm_response_buffer); + + spdm_test_context = *state; + spdm_context = spdm_test_context->spdm_context; + spdm_test_context->case_id = 0x01; + + set_standard_state(spdm_context); + + get_supported_event_types = (spdm_get_supported_event_types_request_t *)m_spdm_request_buffer; + + get_supported_event_types->header.spdm_version = SPDM_MESSAGE_VERSION_13; + get_supported_event_types->header.request_response_code = SPDM_GET_SUPPORTED_EVENT_TYPES; + get_supported_event_types->header.param1 = 0; + get_supported_event_types->header.param2 = 0; + + request_size = sizeof(spdm_get_supported_event_types_request_t); + + status = libspdm_get_encap_supported_event_types(spdm_context, + request_size, + m_spdm_request_buffer, + &response_size, + m_spdm_response_buffer); + + supported_event_types = (spdm_supported_event_types_response_t *)m_spdm_response_buffer; + + assert_int_equal(status, LIBSPDM_STATUS_SUCCESS); + assert_int_equal(supported_event_types->header.spdm_version, SPDM_MESSAGE_VERSION_13); + assert_int_equal(supported_event_types->header.request_response_code, SPDM_SUPPORTED_EVENT_TYPES); + assert_int_equal(supported_event_types->header.param1, g_event_group_count); + assert_int_equal(supported_event_types->header.param2, 0); + assert_int_equal(supported_event_types->supported_event_groups_list_len, + g_supported_event_groups_list_len); + + for (uint32_t index = 0; index < supported_event_types->supported_event_groups_list_len; index++) + { + assert_int_equal(((char *)(supported_event_types + 1))[index], (char)index); + } + + libspdm_dump_data(m_spdm_response_buffer, response_size); + LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n")); +} + +int libspdm_requester_encap_supported_event_types_test_main(void) +{ + const struct CMUnitTest spdm_requester_supported_event_types_tests[] = { + cmocka_unit_test(test_supported_event_types_case1), + }; + + libspdm_test_context_t test_context = { + LIBSPDM_TEST_CONTEXT_VERSION, + false, + }; + + libspdm_setup_test_context(&test_context); + + return cmocka_run_group_tests(spdm_requester_supported_event_types_tests, + libspdm_unit_test_group_setup, + libspdm_unit_test_group_teardown); +} + +#endif /* (LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP) && (LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP) */ diff --git a/unit_test/test_spdm_requester/error_test/encap_supported_event_types_err.c b/unit_test/test_spdm_requester/error_test/encap_supported_event_types_err.c new file mode 100644 index 00000000000..4ff18badbdc --- /dev/null +++ b/unit_test/test_spdm_requester/error_test/encap_supported_event_types_err.c @@ -0,0 +1,174 @@ +/** + * Copyright Notice: + * Copyright 2025 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#include "spdm_unit_test.h" +#include "internal/libspdm_requester_lib.h" + +#if (LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP) && (LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP) + +static uint8_t m_spdm_request_buffer[0x1000]; +static uint8_t m_spdm_response_buffer[0x1000]; + +static const uint32_t m_session_id = 0xffffffff; + +extern uint32_t g_supported_event_groups_list_len; +extern uint8_t g_event_group_count; + +static void set_standard_state(libspdm_context_t *spdm_context) +{ + libspdm_session_info_t *session_info; + + spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 << + SPDM_VERSION_NUMBER_SHIFT_BIT; + spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED; + + spdm_context->connection_info.capability.flags |= + SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP; + spdm_context->connection_info.capability.flags |= + SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP; + spdm_context->connection_info.capability.flags |= + SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP; + spdm_context->connection_info.capability.flags |= + SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP; + + spdm_context->local_context.capability.flags |= + SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP; + spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP; + spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP; + spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP; + spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_EVENT_CAP; + + spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo; + spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo; + spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo; + spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo; + + spdm_context->latest_session_id = m_session_id; + spdm_context->last_spdm_request_session_id_valid = true; + spdm_context->last_spdm_request_session_id = m_session_id; + session_info = &spdm_context->session_info[0]; + libspdm_session_info_init(spdm_context, session_info, m_session_id, true); + libspdm_secured_message_set_session_state( + session_info->secured_message_context, + LIBSPDM_SESSION_STATE_ESTABLISHED); +} + +/** + * Test 1: Requester has not set EVENT_CAP. + * Expected Behavior: Requester returns SPDM_ERROR_CODE_UNSUPPORTED_REQUEST. + **/ +static void test_encap_supported_event_types_err_case1(void **state) +{ + libspdm_return_t status; + libspdm_test_context_t *spdm_test_context; + libspdm_context_t *spdm_context; + spdm_get_supported_event_types_request_t *get_supported_event_types; + size_t request_size; + spdm_error_response_t *error_response; + size_t response_size = sizeof(m_spdm_response_buffer); + + spdm_test_context = *state; + spdm_context = spdm_test_context->spdm_context; + spdm_test_context->case_id = 0x01; + + set_standard_state(spdm_context); + + /* Clear Requester's EVENT_CAP. */ + spdm_context->local_context.capability.flags &= ~SPDM_GET_CAPABILITIES_REQUEST_FLAGS_EVENT_CAP; + + get_supported_event_types = (spdm_get_supported_event_types_request_t *)m_spdm_request_buffer; + + get_supported_event_types->header.spdm_version = SPDM_MESSAGE_VERSION_13; + get_supported_event_types->header.request_response_code = SPDM_GET_SUPPORTED_EVENT_TYPES; + get_supported_event_types->header.param1 = 0; + get_supported_event_types->header.param2 = 0; + + request_size = sizeof(spdm_get_supported_event_types_request_t); + + status = libspdm_get_encap_supported_event_types(spdm_context, + request_size, + m_spdm_request_buffer, + &response_size, + m_spdm_response_buffer); + + error_response = (spdm_error_response_t *)m_spdm_response_buffer; + + assert_int_equal(status, LIBSPDM_STATUS_SUCCESS); + + assert_int_equal(response_size, sizeof(spdm_error_response_t)); + assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_13); + assert_int_equal(error_response->header.request_response_code, SPDM_ERROR); + assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_UNSUPPORTED_REQUEST); + assert_int_equal(error_response->header.param2, SPDM_GET_SUPPORTED_EVENT_TYPES); +} + +/** + * Test 2: Size of GET_SUPPORTED_EVENT_TYPES is not the correct size. + * Expected Behavior: Requester returns SPDM_ERROR_CODE_INVALID_REQUEST. + **/ +static void test_encap_supported_event_types_err_case2(void **state) +{ + libspdm_return_t status; + libspdm_test_context_t *spdm_test_context; + libspdm_context_t *spdm_context; + spdm_get_supported_event_types_request_t *get_supported_event_types; + size_t request_size; + spdm_error_response_t *error_response; + size_t response_size = sizeof(m_spdm_response_buffer); + + spdm_test_context = *state; + spdm_context = spdm_test_context->spdm_context; + spdm_test_context->case_id = 0x01; + + set_standard_state(spdm_context); + + get_supported_event_types = (spdm_get_supported_event_types_request_t *)m_spdm_request_buffer; + + get_supported_event_types->header.spdm_version = SPDM_MESSAGE_VERSION_13; + get_supported_event_types->header.request_response_code = SPDM_GET_SUPPORTED_EVENT_TYPES; + get_supported_event_types->header.param1 = 0; + get_supported_event_types->header.param2 = 0; + + /* Incorrect request size. */ + request_size = sizeof(spdm_get_supported_event_types_request_t) + 1; + + status = libspdm_get_encap_supported_event_types(spdm_context, + request_size, + m_spdm_request_buffer, + &response_size, + m_spdm_response_buffer); + + error_response = (spdm_error_response_t *)m_spdm_response_buffer; + + assert_int_equal(status, LIBSPDM_STATUS_SUCCESS); + + assert_int_equal(response_size, sizeof(spdm_error_response_t)); + assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_13); + assert_int_equal(error_response->header.request_response_code, SPDM_ERROR); + assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST); + assert_int_equal(error_response->header.param2, 0); +} + +int libspdm_requester_encap_supported_event_types_error_test_main(void) +{ + const struct CMUnitTest spdm_requester_encap_supported_event_types_err_tests[] = { + cmocka_unit_test(test_encap_supported_event_types_err_case1), + cmocka_unit_test(test_encap_supported_event_types_err_case2), + }; + + libspdm_test_context_t test_context = { + LIBSPDM_TEST_CONTEXT_VERSION, + false, + }; + + libspdm_setup_test_context(&test_context); + + return cmocka_run_group_tests(spdm_requester_encap_supported_event_types_err_tests, + libspdm_unit_test_group_setup, + libspdm_unit_test_group_teardown); +} + +#endif /* (LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP) && (LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP) */ diff --git a/unit_test/test_spdm_requester/test_spdm_requester.c b/unit_test/test_spdm_requester/test_spdm_requester.c index 0854e3201fe..60b8d72bd2a 100644 --- a/unit_test/test_spdm_requester/test_spdm_requester.c +++ b/unit_test/test_spdm_requester/test_spdm_requester.c @@ -64,7 +64,11 @@ int libspdm_requester_encap_challenge_auth_test_main(void); #if LIBSPDM_EVENT_RECIPIENT_SUPPORT int libspdm_requester_encap_event_ack_test_main(void); int libspdm_requester_encap_event_ack_error_test_main(void); -#endif /* #if LIBSPDM_EVENT_RECIPIENT_SUPPORT */ +#endif /* LIBSPDM_EVENT_RECIPIENT_SUPPORT */ +#if LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP +int libspdm_requester_encap_supported_event_types_test_main(void); +int libspdm_requester_encap_supported_event_types_error_test_main(void); +#endif /* LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP */ int libspdm_requester_encap_key_update_test_main(void); #if LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP int libspdm_requester_encap_endpoint_info_test_main(void); @@ -243,6 +247,14 @@ int main(void) return_value = 1; } #endif /* LIBSPDM_EVENT_RECIPIENT_SUPPORT */ + #if LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP + if (libspdm_requester_encap_supported_event_types_test_main() != 0) { + return_value = 1; + } + if (libspdm_requester_encap_supported_event_types_error_test_main() != 0) { + return_value = 1; + } + #endif /* LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP */ #if LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP if (libspdm_requester_encap_endpoint_info_test_main() != 0) { return_value = 1;