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 "spdm_unit_test.h"
8 : #include "internal/libspdm_requester_lib.h"
9 :
10 : #if (LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP) && (LIBSPDM_EVENT_RECIPIENT_SUPPORT)
11 :
12 : static uint8_t m_spdm_request_buffer[0x1000];
13 : static uint8_t m_spdm_response_buffer[0x1000];
14 :
15 : static const uint32_t m_session_id = 0xffffffff;
16 :
17 : typedef struct {
18 : uint32_t event_instance_id;
19 : uint8_t svh_id;
20 : uint8_t svh_vendor_id_len;
21 : uint8_t svh_vendor_id[4];
22 : uint16_t event_type_id;
23 : uint16_t event_detail_len;
24 : uint8_t event_detail[100];
25 : } expected_event_t;
26 :
27 : static expected_event_t m_expected_event[4];
28 : static uint32_t m_event_counter;
29 :
30 9 : static libspdm_return_t process_event(void *spdm_context,
31 : uint32_t session_id,
32 : uint32_t event_instance_id,
33 : uint8_t svh_id,
34 : uint8_t svh_vendor_id_len,
35 : const void *svh_vendor_id,
36 : uint16_t event_type_id,
37 : uint16_t event_detail_len,
38 : const void *event_detail)
39 : {
40 9 : printf("Event Received\n");
41 9 : printf("Event Instance ID = [0x%x]\n", event_instance_id);
42 9 : printf("SVH ID = [0x%x], SVH VendorIDLen = [0x%x]\n", svh_id, svh_vendor_id_len);
43 9 : if (svh_vendor_id_len != 0) {
44 0 : printf("SVH VendorID\n");
45 0 : libspdm_dump_hex(svh_vendor_id, svh_vendor_id_len);
46 0 : printf("\n");
47 : }
48 9 : printf("EventTypeID = [0x%x], EventDetailLen = [0x%x]\n", event_type_id, event_detail_len);
49 9 : printf("Event Detail\n");
50 9 : libspdm_dump_hex(event_detail, event_detail_len);
51 :
52 9 : assert_int_equal(session_id, m_session_id);
53 9 : assert_int_equal(event_instance_id, m_expected_event[m_event_counter].event_instance_id);
54 9 : assert_int_equal(event_type_id, m_expected_event[m_event_counter].event_type_id);
55 9 : assert_int_equal(svh_id, m_expected_event[m_event_counter].svh_id);
56 9 : assert_int_equal(svh_vendor_id_len, m_expected_event[m_event_counter].svh_vendor_id_len);
57 9 : if (svh_vendor_id_len == 0) {
58 9 : assert_ptr_equal(svh_vendor_id, NULL);
59 : }
60 9 : assert_int_equal(event_detail_len, m_expected_event[m_event_counter].event_detail_len);
61 9 : assert_memory_equal(m_expected_event[m_event_counter].event_detail, event_detail,
62 : event_detail_len);
63 9 : m_event_counter++;
64 :
65 9 : return LIBSPDM_STATUS_SUCCESS;
66 : }
67 :
68 4 : static void set_standard_state(libspdm_context_t *spdm_context)
69 : {
70 : libspdm_session_info_t *session_info;
71 :
72 4 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
73 : SPDM_VERSION_NUMBER_SHIFT_BIT;
74 4 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
75 :
76 4 : spdm_context->connection_info.capability.flags |=
77 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_EVENT_CAP;
78 4 : spdm_context->connection_info.capability.flags |=
79 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
80 4 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
81 4 : spdm_context->connection_info.capability.flags |=
82 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
83 4 : spdm_context->connection_info.capability.flags |=
84 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
85 :
86 4 : spdm_context->local_context.capability.flags |=
87 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
88 4 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
89 4 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
90 4 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
91 :
92 4 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
93 4 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
94 4 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
95 4 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
96 :
97 4 : spdm_context->latest_session_id = m_session_id;
98 4 : spdm_context->last_spdm_request_session_id_valid = true;
99 4 : spdm_context->last_spdm_request_session_id = m_session_id;
100 4 : session_info = &spdm_context->session_info[0];
101 4 : libspdm_session_info_init(spdm_context, session_info, m_session_id,
102 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
103 4 : libspdm_secured_message_set_session_state(
104 : session_info->secured_message_context,
105 : LIBSPDM_SESSION_STATE_ESTABLISHED);
106 :
107 4 : libspdm_register_event_callback(spdm_context, process_event);
108 4 : }
109 :
110 : /* Send exactly one event. */
111 1 : static void req_encap_event_ack_case1(void **state)
112 : {
113 : libspdm_return_t status;
114 : libspdm_test_context_t *spdm_test_context;
115 : libspdm_context_t *spdm_context;
116 : spdm_send_event_request_t *send_event;
117 : size_t request_size;
118 : spdm_event_ack_response_t *event_ack;
119 1 : size_t response_size = sizeof(m_spdm_response_buffer);
120 : uint8_t event_data_size;
121 : spdm_dmtf_event_type_event_lost_t event_lost;
122 :
123 1 : spdm_test_context = *state;
124 1 : spdm_context = spdm_test_context->spdm_context;
125 1 : spdm_test_context->case_id = 0x01;
126 :
127 1 : set_standard_state(spdm_context);
128 :
129 1 : send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
130 :
131 1 : send_event->header.spdm_version = SPDM_MESSAGE_VERSION_13;
132 1 : send_event->header.request_response_code = SPDM_SEND_EVENT;
133 1 : send_event->header.param1 = 0;
134 1 : send_event->header.param2 = 0;
135 1 : send_event->event_count = 1;
136 :
137 1 : event_lost.last_acked_event_inst_id = 0xffeeddcc;
138 1 : event_lost.last_lost_event_inst_id = 0x55667788;
139 :
140 1 : generate_dmtf_event_data(send_event + 1, &event_data_size, 0x11223344,
141 : SPDM_DMTF_EVENT_TYPE_EVENT_LOST, &event_lost);
142 :
143 1 : m_event_counter = 0;
144 1 : m_expected_event[0].event_instance_id = 0x11223344;
145 1 : m_expected_event[0].svh_id = SPDM_REGISTRY_ID_DMTF;
146 1 : m_expected_event[0].svh_vendor_id_len = 0;
147 1 : m_expected_event[0].event_type_id = SPDM_DMTF_EVENT_TYPE_EVENT_LOST;
148 1 : m_expected_event[0].event_detail_len = SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE;
149 1 : memcpy(m_expected_event[0].event_detail, &event_lost, SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE);
150 :
151 1 : request_size = sizeof(spdm_send_event_request_t) + event_data_size;
152 :
153 1 : status = libspdm_get_encap_response_event_ack(spdm_context,
154 : request_size,
155 : m_spdm_request_buffer,
156 : &response_size,
157 : m_spdm_response_buffer);
158 :
159 1 : event_ack = (spdm_event_ack_response_t *)m_spdm_response_buffer;
160 :
161 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
162 :
163 1 : assert_int_equal(response_size, sizeof(spdm_event_ack_response_t));
164 1 : assert_int_equal(event_ack->header.spdm_version, SPDM_MESSAGE_VERSION_13);
165 1 : assert_int_equal(event_ack->header.request_response_code, SPDM_EVENT_ACK);
166 1 : assert_int_equal(event_ack->header.param1, 0);
167 1 : assert_int_equal(event_ack->header.param2, 0);
168 :
169 1 : assert_int_equal(m_event_counter, 1);
170 1 : }
171 :
172 : /* Send two events with in-order event instance IDs. */
173 1 : static void req_encap_event_ack_case2(void **state)
174 : {
175 : libspdm_return_t status;
176 : libspdm_test_context_t *spdm_test_context;
177 : libspdm_context_t *spdm_context;
178 : spdm_send_event_request_t *send_event;
179 : size_t request_size;
180 : spdm_event_ack_response_t *event_ack;
181 1 : size_t response_size = sizeof(m_spdm_response_buffer);
182 : uint8_t event_data_size[2];
183 : spdm_dmtf_event_type_event_lost_t event_lost;
184 : spdm_dmtf_event_type_certificate_changed_t certificate_changed;
185 : uint8_t *ptr;
186 :
187 1 : spdm_test_context = *state;
188 1 : spdm_context = spdm_test_context->spdm_context;
189 1 : spdm_test_context->case_id = 0x02;
190 :
191 1 : set_standard_state(spdm_context);
192 :
193 1 : send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
194 :
195 1 : send_event->header.spdm_version = SPDM_MESSAGE_VERSION_13;
196 1 : send_event->header.request_response_code = SPDM_SEND_EVENT;
197 1 : send_event->header.param1 = 0;
198 1 : send_event->header.param2 = 0;
199 1 : send_event->event_count = 2;
200 :
201 1 : certificate_changed.certificate_changed = 5;
202 :
203 1 : event_lost.last_acked_event_inst_id = 0xffeeddcc;
204 1 : event_lost.last_lost_event_inst_id = 0x55667788;
205 :
206 1 : ptr = (uint8_t *)(send_event + 1);
207 :
208 1 : generate_dmtf_event_data(ptr, &event_data_size[0], 0x11223343,
209 : SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED, &certificate_changed);
210 1 : ptr += event_data_size[0];
211 :
212 1 : generate_dmtf_event_data(ptr, &event_data_size[1], 0x11223344,
213 : SPDM_DMTF_EVENT_TYPE_EVENT_LOST, &event_lost);
214 1 : ptr += event_data_size[1];
215 :
216 1 : m_event_counter = 0;
217 :
218 1 : m_expected_event[0].event_instance_id = 0x11223343;
219 1 : m_expected_event[0].svh_id = SPDM_REGISTRY_ID_DMTF;
220 1 : m_expected_event[0].svh_vendor_id_len = 0;
221 1 : m_expected_event[0].event_type_id = SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED;
222 1 : m_expected_event[0].event_detail_len = SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED_SIZE;
223 1 : memcpy(m_expected_event[0].event_detail, &certificate_changed,
224 : SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED_SIZE);
225 :
226 1 : m_expected_event[1].event_instance_id = 0x11223344;
227 1 : m_expected_event[1].svh_id = SPDM_REGISTRY_ID_DMTF;
228 1 : m_expected_event[1].svh_vendor_id_len = 0;
229 1 : m_expected_event[1].event_type_id = SPDM_DMTF_EVENT_TYPE_EVENT_LOST;
230 1 : m_expected_event[1].event_detail_len = SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE;
231 1 : memcpy(m_expected_event[1].event_detail, &event_lost, SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE);
232 :
233 1 : request_size = sizeof(spdm_send_event_request_t) + event_data_size[0] + event_data_size[1];
234 :
235 1 : status = libspdm_get_encap_response_event_ack(spdm_context,
236 : request_size,
237 : m_spdm_request_buffer,
238 : &response_size,
239 : m_spdm_response_buffer);
240 :
241 1 : event_ack = (spdm_event_ack_response_t *)m_spdm_response_buffer;
242 :
243 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
244 :
245 1 : assert_int_equal(response_size, sizeof(spdm_event_ack_response_t));
246 1 : assert_int_equal(event_ack->header.spdm_version, SPDM_MESSAGE_VERSION_13);
247 1 : assert_int_equal(event_ack->header.request_response_code, SPDM_EVENT_ACK);
248 1 : assert_int_equal(event_ack->header.param1, 0);
249 1 : assert_int_equal(event_ack->header.param2, 0);
250 :
251 1 : assert_int_equal(m_event_counter, 2);
252 1 : }
253 :
254 : /* Send two events with out-of-order event instance IDs. */
255 1 : static void req_encap_event_ack_case3(void **state)
256 : {
257 : libspdm_return_t status;
258 : libspdm_test_context_t *spdm_test_context;
259 : libspdm_context_t *spdm_context;
260 : spdm_send_event_request_t *send_event;
261 : size_t request_size;
262 : spdm_event_ack_response_t *event_ack;
263 1 : size_t response_size = sizeof(m_spdm_response_buffer);
264 : uint8_t event_data_size[2];
265 : spdm_dmtf_event_type_event_lost_t event_lost;
266 : spdm_dmtf_event_type_certificate_changed_t certificate_changed;
267 : uint8_t *ptr;
268 :
269 1 : spdm_test_context = *state;
270 1 : spdm_context = spdm_test_context->spdm_context;
271 1 : spdm_test_context->case_id = 0x03;
272 :
273 1 : set_standard_state(spdm_context);
274 :
275 1 : send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
276 :
277 1 : send_event->header.spdm_version = SPDM_MESSAGE_VERSION_13;
278 1 : send_event->header.request_response_code = SPDM_SEND_EVENT;
279 1 : send_event->header.param1 = 0;
280 1 : send_event->header.param2 = 0;
281 1 : send_event->event_count = 2;
282 :
283 1 : certificate_changed.certificate_changed = 5;
284 :
285 1 : event_lost.last_acked_event_inst_id = 0xffeeddcc;
286 1 : event_lost.last_lost_event_inst_id = 0x55667788;
287 :
288 1 : ptr = (uint8_t *)(send_event + 1);
289 :
290 1 : generate_dmtf_event_data(ptr, &event_data_size[0], 0x11223344,
291 : SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED, &certificate_changed);
292 1 : ptr += event_data_size[0];
293 :
294 1 : generate_dmtf_event_data(ptr, &event_data_size[1], 0x11223343,
295 : SPDM_DMTF_EVENT_TYPE_EVENT_LOST, &event_lost);
296 1 : ptr += event_data_size[1];
297 :
298 1 : m_event_counter = 0;
299 :
300 1 : m_expected_event[0].event_instance_id = 0x11223343;
301 1 : m_expected_event[0].svh_id = SPDM_REGISTRY_ID_DMTF;
302 1 : m_expected_event[0].svh_vendor_id_len = 0;
303 1 : m_expected_event[0].event_type_id = SPDM_DMTF_EVENT_TYPE_EVENT_LOST;
304 1 : m_expected_event[0].event_detail_len = SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE;
305 1 : memcpy(m_expected_event[0].event_detail, &event_lost, SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE);
306 :
307 1 : m_expected_event[1].event_instance_id = 0x11223344;
308 1 : m_expected_event[1].svh_id = SPDM_REGISTRY_ID_DMTF;
309 1 : m_expected_event[1].svh_vendor_id_len = 0;
310 1 : m_expected_event[1].event_type_id = SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED;
311 1 : m_expected_event[1].event_detail_len = SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED_SIZE;
312 1 : memcpy(m_expected_event[1].event_detail, &certificate_changed,
313 : SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED_SIZE);
314 :
315 1 : request_size = sizeof(spdm_send_event_request_t) + event_data_size[0] + event_data_size[1];
316 :
317 1 : status = libspdm_get_encap_response_event_ack(spdm_context,
318 : request_size,
319 : m_spdm_request_buffer,
320 : &response_size,
321 : m_spdm_response_buffer);
322 :
323 1 : event_ack = (spdm_event_ack_response_t *)m_spdm_response_buffer;
324 :
325 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
326 :
327 1 : assert_int_equal(response_size, sizeof(spdm_event_ack_response_t));
328 1 : assert_int_equal(event_ack->header.spdm_version, SPDM_MESSAGE_VERSION_13);
329 1 : assert_int_equal(event_ack->header.request_response_code, SPDM_EVENT_ACK);
330 1 : assert_int_equal(event_ack->header.param1, 0);
331 1 : assert_int_equal(event_ack->header.param2, 0);
332 :
333 1 : assert_int_equal(m_event_counter, 2);
334 1 : }
335 :
336 : /* Send four events with in-order event instance IDs. */
337 1 : static void req_encap_event_ack_case4(void **state)
338 : {
339 : libspdm_return_t status;
340 : libspdm_test_context_t *spdm_test_context;
341 : libspdm_context_t *spdm_context;
342 : spdm_send_event_request_t *send_event;
343 : size_t request_size;
344 : spdm_event_ack_response_t *event_ack;
345 1 : size_t response_size = sizeof(m_spdm_response_buffer);
346 : uint8_t event_data_size[4];
347 : spdm_dmtf_event_type_event_lost_t event_lost;
348 : spdm_dmtf_event_type_certificate_changed_t certificate_changed;
349 : spdm_dmtf_event_type_measurement_changed_t measurement_changed;
350 : spdm_dmtf_event_type_measurement_pre_update_t measurement_pre_update;
351 : uint8_t *ptr;
352 : uint32_t index;
353 :
354 1 : spdm_test_context = *state;
355 1 : spdm_context = spdm_test_context->spdm_context;
356 1 : spdm_test_context->case_id = 0x04;
357 :
358 1 : set_standard_state(spdm_context);
359 :
360 1 : send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
361 :
362 1 : send_event->header.spdm_version = SPDM_MESSAGE_VERSION_13;
363 1 : send_event->header.request_response_code = SPDM_SEND_EVENT;
364 1 : send_event->header.param1 = 0;
365 1 : send_event->header.param2 = 0;
366 1 : send_event->event_count = 4;
367 :
368 1 : ptr = (uint8_t *)(send_event + 1);
369 :
370 1 : certificate_changed.certificate_changed = 5;
371 1 : generate_dmtf_event_data(ptr, &event_data_size[0], 0x11223343,
372 : SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED, &certificate_changed);
373 1 : ptr += event_data_size[0];
374 :
375 1 : event_lost.last_acked_event_inst_id = 0xffeeddcc;
376 1 : event_lost.last_lost_event_inst_id = 0x55667788;
377 1 : generate_dmtf_event_data(ptr, &event_data_size[1], 0x11223344,
378 : SPDM_DMTF_EVENT_TYPE_EVENT_LOST, &event_lost);
379 1 : ptr += event_data_size[1];
380 :
381 33 : for (index = 0; index < SPDM_DMTF_EVENT_TYPE_MEASUREMENT_CHANGED_SIZE; index++) {
382 32 : measurement_changed.changed_measurements[index] = (uint8_t)index;
383 : }
384 1 : generate_dmtf_event_data(ptr, &event_data_size[2], 0x11223345,
385 : SPDM_DMTF_EVENT_TYPE_MEASUREMENT_CHANGED, &measurement_changed);
386 1 : ptr += event_data_size[2];
387 :
388 33 : for (index = 0; index < SPDM_DMTF_EVENT_TYPE_MEASUREMENT_PRE_UPDATE_SIZE; index++) {
389 32 : measurement_pre_update.pre_update_measurement_changes[index] = (uint8_t)(2 * index);
390 : }
391 1 : generate_dmtf_event_data(ptr, &event_data_size[3], 0x11223346,
392 : SPDM_DMTF_EVENT_TYPE_MEASUREMENT_PRE_UPDATE, &measurement_pre_update);
393 1 : ptr += event_data_size[3];
394 :
395 1 : m_event_counter = 0;
396 :
397 1 : m_expected_event[0].event_instance_id = 0x11223343;
398 1 : m_expected_event[0].svh_id = SPDM_REGISTRY_ID_DMTF;
399 1 : m_expected_event[0].svh_vendor_id_len = 0;
400 1 : m_expected_event[0].event_type_id = SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED;
401 1 : m_expected_event[0].event_detail_len = SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED_SIZE;
402 1 : memcpy(m_expected_event[0].event_detail, &certificate_changed,
403 : SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED_SIZE);
404 :
405 1 : m_expected_event[1].event_instance_id = 0x11223344;
406 1 : m_expected_event[1].svh_id = SPDM_REGISTRY_ID_DMTF;
407 1 : m_expected_event[1].svh_vendor_id_len = 0;
408 1 : m_expected_event[1].event_type_id = SPDM_DMTF_EVENT_TYPE_EVENT_LOST;
409 1 : m_expected_event[1].event_detail_len = SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE;
410 1 : memcpy(m_expected_event[1].event_detail, &event_lost, SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE);
411 :
412 1 : m_expected_event[2].event_instance_id = 0x11223345;
413 1 : m_expected_event[2].svh_id = SPDM_REGISTRY_ID_DMTF;
414 1 : m_expected_event[2].svh_vendor_id_len = 0;
415 1 : m_expected_event[2].event_type_id = SPDM_DMTF_EVENT_TYPE_MEASUREMENT_CHANGED;
416 1 : m_expected_event[2].event_detail_len = SPDM_DMTF_EVENT_TYPE_MEASUREMENT_CHANGED_SIZE;
417 1 : memcpy(m_expected_event[2].event_detail, &measurement_changed,
418 : SPDM_DMTF_EVENT_TYPE_MEASUREMENT_CHANGED_SIZE);
419 :
420 1 : m_expected_event[3].event_instance_id = 0x11223346;
421 1 : m_expected_event[3].svh_id = SPDM_REGISTRY_ID_DMTF;
422 1 : m_expected_event[3].svh_vendor_id_len = 0;
423 1 : m_expected_event[3].event_type_id = SPDM_DMTF_EVENT_TYPE_MEASUREMENT_PRE_UPDATE;
424 1 : m_expected_event[3].event_detail_len = SPDM_DMTF_EVENT_TYPE_MEASUREMENT_PRE_UPDATE_SIZE;
425 1 : memcpy(m_expected_event[3].event_detail, &measurement_pre_update,
426 : SPDM_DMTF_EVENT_TYPE_MEASUREMENT_PRE_UPDATE_SIZE);
427 :
428 1 : request_size = sizeof(spdm_send_event_request_t) + event_data_size[0] + event_data_size[1] +
429 1 : event_data_size[2] + event_data_size[3];
430 :
431 1 : status = libspdm_get_encap_response_event_ack(spdm_context,
432 : request_size,
433 : m_spdm_request_buffer,
434 : &response_size,
435 : m_spdm_response_buffer);
436 :
437 1 : event_ack = (spdm_event_ack_response_t *)m_spdm_response_buffer;
438 :
439 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
440 :
441 1 : assert_int_equal(response_size, sizeof(spdm_event_ack_response_t));
442 1 : assert_int_equal(event_ack->header.spdm_version, SPDM_MESSAGE_VERSION_13);
443 1 : assert_int_equal(event_ack->header.request_response_code, SPDM_EVENT_ACK);
444 1 : assert_int_equal(event_ack->header.param1, 0);
445 1 : assert_int_equal(event_ack->header.param2, 0);
446 :
447 1 : assert_int_equal(m_event_counter, 4);
448 1 : }
449 :
450 1 : int libspdm_req_encap_event_ack_test(void)
451 : {
452 1 : const struct CMUnitTest test_cases[] = {
453 : cmocka_unit_test(req_encap_event_ack_case1),
454 : cmocka_unit_test(req_encap_event_ack_case2),
455 : cmocka_unit_test(req_encap_event_ack_case3),
456 : cmocka_unit_test(req_encap_event_ack_case4)
457 : };
458 :
459 1 : libspdm_test_context_t test_context = {
460 : LIBSPDM_TEST_CONTEXT_VERSION,
461 : false,
462 : };
463 :
464 1 : libspdm_setup_test_context(&test_context);
465 :
466 1 : return cmocka_run_group_tests(test_cases,
467 : libspdm_unit_test_group_setup,
468 : libspdm_unit_test_group_teardown);
469 : }
470 :
471 : #endif /* (LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP) && (LIBSPDM_EVENT_RECIPIENT_SUPPORT) */
|
