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