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_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 : void *svh_vendor_id,
36 : uint16_t event_type_id,
37 : uint16_t event_detail_len,
38 : 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 |=
81 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
82 4 : spdm_context->connection_info.capability.flags |=
83 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
84 4 : spdm_context->connection_info.capability.flags |=
85 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
86 :
87 4 : spdm_context->local_context.capability.flags |=
88 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
89 4 : spdm_context->local_context.capability.flags |=
90 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
91 4 : spdm_context->local_context.capability.flags |=
92 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
93 4 : spdm_context->local_context.capability.flags |=
94 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
95 :
96 4 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
97 4 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
98 4 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
99 4 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
100 :
101 4 : spdm_context->latest_session_id = m_session_id;
102 4 : spdm_context->last_spdm_request_session_id_valid = true;
103 4 : spdm_context->last_spdm_request_session_id = m_session_id;
104 4 : session_info = &spdm_context->session_info[0];
105 4 : libspdm_session_info_init(spdm_context, session_info, m_session_id, true);
106 4 : libspdm_secured_message_set_session_state(
107 : session_info->secured_message_context,
108 : LIBSPDM_SESSION_STATE_ESTABLISHED);
109 :
110 4 : libspdm_register_event_callback(spdm_context, process_event);
111 4 : }
112 :
113 : /* Send exactly one event. */
114 1 : static void test_libspdm_requester_encap_event_ack_case1(void **state)
115 : {
116 : libspdm_return_t status;
117 : libspdm_test_context_t *spdm_test_context;
118 : libspdm_context_t *spdm_context;
119 : spdm_send_event_request_t *send_event;
120 : size_t request_size;
121 : spdm_event_ack_response_t *event_ack;
122 1 : size_t response_size = sizeof(m_spdm_response_buffer);
123 : uint8_t event_data_size;
124 : spdm_dmtf_event_type_event_lost_t event_lost;
125 :
126 1 : spdm_test_context = *state;
127 1 : spdm_context = spdm_test_context->spdm_context;
128 1 : spdm_test_context->case_id = 0x01;
129 :
130 1 : set_standard_state(spdm_context);
131 :
132 1 : send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
133 :
134 1 : send_event->header.spdm_version = SPDM_MESSAGE_VERSION_13;
135 1 : send_event->header.request_response_code = SPDM_SEND_EVENT;
136 1 : send_event->header.param1 = 0;
137 1 : send_event->header.param2 = 0;
138 1 : send_event->event_count = 1;
139 :
140 1 : event_lost.last_acked_event_inst_id = 0xffeeddcc;
141 1 : event_lost.last_lost_event_inst_id = 0x55667788;
142 :
143 1 : generate_dmtf_event_data(send_event + 1, &event_data_size, 0x11223344,
144 : SPDM_DMTF_EVENT_TYPE_EVENT_LOST, &event_lost);
145 :
146 1 : m_event_counter = 0;
147 1 : m_expected_event[0].event_instance_id = 0x11223344;
148 1 : m_expected_event[0].svh_id = SPDM_REGISTRY_ID_DMTF;
149 1 : m_expected_event[0].svh_vendor_id_len = 0;
150 1 : m_expected_event[0].event_type_id = SPDM_DMTF_EVENT_TYPE_EVENT_LOST;
151 1 : m_expected_event[0].event_detail_len = SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE;
152 1 : memcpy(m_expected_event[0].event_detail, &event_lost, SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE);
153 :
154 1 : request_size = sizeof(spdm_send_event_request_t) + event_data_size;
155 :
156 1 : status = libspdm_get_encap_response_event_ack(spdm_context,
157 : request_size,
158 : m_spdm_request_buffer,
159 : &response_size,
160 : m_spdm_response_buffer);
161 :
162 1 : event_ack = (spdm_event_ack_response_t *)m_spdm_response_buffer;
163 :
164 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
165 :
166 1 : assert_int_equal(response_size, sizeof(spdm_event_ack_response_t));
167 1 : assert_int_equal(event_ack->header.spdm_version, SPDM_MESSAGE_VERSION_13);
168 1 : assert_int_equal(event_ack->header.request_response_code, SPDM_EVENT_ACK);
169 1 : assert_int_equal(event_ack->header.param1, 0);
170 1 : assert_int_equal(event_ack->header.param2, 0);
171 :
172 1 : assert_int_equal(m_event_counter, 1);
173 1 : }
174 :
175 : /* Send two events with in-order event instance IDs. */
176 1 : static void test_libspdm_requester_encap_event_ack_case2(void **state)
177 : {
178 : libspdm_return_t status;
179 : libspdm_test_context_t *spdm_test_context;
180 : libspdm_context_t *spdm_context;
181 : spdm_send_event_request_t *send_event;
182 : size_t request_size;
183 : spdm_event_ack_response_t *event_ack;
184 1 : size_t response_size = sizeof(m_spdm_response_buffer);
185 : uint8_t event_data_size[2];
186 : spdm_dmtf_event_type_event_lost_t event_lost;
187 : spdm_dmtf_event_type_certificate_changed_t certificate_changed;
188 : uint8_t *ptr;
189 :
190 1 : spdm_test_context = *state;
191 1 : spdm_context = spdm_test_context->spdm_context;
192 1 : spdm_test_context->case_id = 0x02;
193 :
194 1 : set_standard_state(spdm_context);
195 :
196 1 : send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
197 :
198 1 : send_event->header.spdm_version = SPDM_MESSAGE_VERSION_13;
199 1 : send_event->header.request_response_code = SPDM_SEND_EVENT;
200 1 : send_event->header.param1 = 0;
201 1 : send_event->header.param2 = 0;
202 1 : send_event->event_count = 2;
203 :
204 1 : certificate_changed.certificate_changed = 5;
205 :
206 1 : event_lost.last_acked_event_inst_id = 0xffeeddcc;
207 1 : event_lost.last_lost_event_inst_id = 0x55667788;
208 :
209 1 : ptr = (uint8_t *)(send_event + 1);
210 :
211 1 : generate_dmtf_event_data(ptr, &event_data_size[0], 0x11223343,
212 : SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED, &certificate_changed);
213 1 : ptr += event_data_size[0];
214 :
215 1 : generate_dmtf_event_data(ptr, &event_data_size[1], 0x11223344,
216 : SPDM_DMTF_EVENT_TYPE_EVENT_LOST, &event_lost);
217 1 : ptr += event_data_size[1];
218 :
219 1 : m_event_counter = 0;
220 :
221 1 : m_expected_event[0].event_instance_id = 0x11223343;
222 1 : m_expected_event[0].svh_id = SPDM_REGISTRY_ID_DMTF;
223 1 : m_expected_event[0].svh_vendor_id_len = 0;
224 1 : m_expected_event[0].event_type_id = SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED;
225 1 : m_expected_event[0].event_detail_len = SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED_SIZE;
226 1 : memcpy(m_expected_event[0].event_detail, &certificate_changed,
227 : SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED_SIZE);
228 :
229 1 : m_expected_event[1].event_instance_id = 0x11223344;
230 1 : m_expected_event[1].svh_id = SPDM_REGISTRY_ID_DMTF;
231 1 : m_expected_event[1].svh_vendor_id_len = 0;
232 1 : m_expected_event[1].event_type_id = SPDM_DMTF_EVENT_TYPE_EVENT_LOST;
233 1 : m_expected_event[1].event_detail_len = SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE;
234 1 : memcpy(m_expected_event[1].event_detail, &event_lost, SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE);
235 :
236 1 : request_size = sizeof(spdm_send_event_request_t) + event_data_size[0] + event_data_size[1];
237 :
238 1 : status = libspdm_get_encap_response_event_ack(spdm_context,
239 : request_size,
240 : m_spdm_request_buffer,
241 : &response_size,
242 : m_spdm_response_buffer);
243 :
244 1 : event_ack = (spdm_event_ack_response_t *)m_spdm_response_buffer;
245 :
246 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
247 :
248 1 : assert_int_equal(response_size, sizeof(spdm_event_ack_response_t));
249 1 : assert_int_equal(event_ack->header.spdm_version, SPDM_MESSAGE_VERSION_13);
250 1 : assert_int_equal(event_ack->header.request_response_code, SPDM_EVENT_ACK);
251 1 : assert_int_equal(event_ack->header.param1, 0);
252 1 : assert_int_equal(event_ack->header.param2, 0);
253 :
254 1 : assert_int_equal(m_event_counter, 2);
255 1 : }
256 :
257 : /* Send two events with out-of-order event instance IDs. */
258 1 : static void test_libspdm_requester_encap_event_ack_case3(void **state)
259 : {
260 : libspdm_return_t status;
261 : libspdm_test_context_t *spdm_test_context;
262 : libspdm_context_t *spdm_context;
263 : spdm_send_event_request_t *send_event;
264 : size_t request_size;
265 : spdm_event_ack_response_t *event_ack;
266 1 : size_t response_size = sizeof(m_spdm_response_buffer);
267 : uint8_t event_data_size[2];
268 : spdm_dmtf_event_type_event_lost_t event_lost;
269 : spdm_dmtf_event_type_certificate_changed_t certificate_changed;
270 : uint8_t *ptr;
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 1 : send_event->event_count = 2;
285 :
286 1 : certificate_changed.certificate_changed = 5;
287 :
288 1 : event_lost.last_acked_event_inst_id = 0xffeeddcc;
289 1 : event_lost.last_lost_event_inst_id = 0x55667788;
290 :
291 1 : ptr = (uint8_t *)(send_event + 1);
292 :
293 1 : generate_dmtf_event_data(ptr, &event_data_size[0], 0x11223344,
294 : SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED, &certificate_changed);
295 1 : ptr += event_data_size[0];
296 :
297 1 : generate_dmtf_event_data(ptr, &event_data_size[1], 0x11223343,
298 : SPDM_DMTF_EVENT_TYPE_EVENT_LOST, &event_lost);
299 1 : ptr += event_data_size[1];
300 :
301 1 : m_event_counter = 0;
302 :
303 1 : m_expected_event[0].event_instance_id = 0x11223343;
304 1 : m_expected_event[0].svh_id = SPDM_REGISTRY_ID_DMTF;
305 1 : m_expected_event[0].svh_vendor_id_len = 0;
306 1 : m_expected_event[0].event_type_id = SPDM_DMTF_EVENT_TYPE_EVENT_LOST;
307 1 : m_expected_event[0].event_detail_len = SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE;
308 1 : memcpy(m_expected_event[0].event_detail, &event_lost, SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE);
309 :
310 1 : m_expected_event[1].event_instance_id = 0x11223344;
311 1 : m_expected_event[1].svh_id = SPDM_REGISTRY_ID_DMTF;
312 1 : m_expected_event[1].svh_vendor_id_len = 0;
313 1 : m_expected_event[1].event_type_id = SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED;
314 1 : m_expected_event[1].event_detail_len = SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED_SIZE;
315 1 : memcpy(m_expected_event[1].event_detail, &certificate_changed,
316 : SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED_SIZE);
317 :
318 1 : request_size = sizeof(spdm_send_event_request_t) + event_data_size[0] + event_data_size[1];
319 :
320 1 : status = libspdm_get_encap_response_event_ack(spdm_context,
321 : request_size,
322 : m_spdm_request_buffer,
323 : &response_size,
324 : m_spdm_response_buffer);
325 :
326 1 : event_ack = (spdm_event_ack_response_t *)m_spdm_response_buffer;
327 :
328 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
329 :
330 1 : assert_int_equal(response_size, sizeof(spdm_event_ack_response_t));
331 1 : assert_int_equal(event_ack->header.spdm_version, SPDM_MESSAGE_VERSION_13);
332 1 : assert_int_equal(event_ack->header.request_response_code, SPDM_EVENT_ACK);
333 1 : assert_int_equal(event_ack->header.param1, 0);
334 1 : assert_int_equal(event_ack->header.param2, 0);
335 :
336 1 : assert_int_equal(m_event_counter, 2);
337 1 : }
338 :
339 : /* Send four events with in-order event instance IDs. */
340 1 : static void test_libspdm_requester_encap_event_ack_case4(void **state)
341 : {
342 : libspdm_return_t status;
343 : libspdm_test_context_t *spdm_test_context;
344 : libspdm_context_t *spdm_context;
345 : spdm_send_event_request_t *send_event;
346 : size_t request_size;
347 : spdm_event_ack_response_t *event_ack;
348 1 : size_t response_size = sizeof(m_spdm_response_buffer);
349 : uint8_t event_data_size[4];
350 : spdm_dmtf_event_type_event_lost_t event_lost;
351 : spdm_dmtf_event_type_certificate_changed_t certificate_changed;
352 : spdm_dmtf_event_type_measurement_changed_t measurement_changed;
353 : spdm_dmtf_event_type_measurement_pre_update_t measurement_pre_update;
354 : uint8_t *ptr;
355 : uint32_t index;
356 :
357 1 : spdm_test_context = *state;
358 1 : spdm_context = spdm_test_context->spdm_context;
359 1 : spdm_test_context->case_id = 0x04;
360 :
361 1 : set_standard_state(spdm_context);
362 :
363 1 : send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
364 :
365 1 : send_event->header.spdm_version = SPDM_MESSAGE_VERSION_13;
366 1 : send_event->header.request_response_code = SPDM_SEND_EVENT;
367 1 : send_event->header.param1 = 0;
368 1 : send_event->header.param2 = 0;
369 1 : send_event->event_count = 4;
370 :
371 1 : ptr = (uint8_t *)(send_event + 1);
372 :
373 1 : certificate_changed.certificate_changed = 5;
374 1 : generate_dmtf_event_data(ptr, &event_data_size[0], 0x11223343,
375 : SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED, &certificate_changed);
376 1 : ptr += event_data_size[0];
377 :
378 1 : event_lost.last_acked_event_inst_id = 0xffeeddcc;
379 1 : event_lost.last_lost_event_inst_id = 0x55667788;
380 1 : generate_dmtf_event_data(ptr, &event_data_size[1], 0x11223344,
381 : SPDM_DMTF_EVENT_TYPE_EVENT_LOST, &event_lost);
382 1 : ptr += event_data_size[1];
383 :
384 33 : for (index = 0; index < SPDM_DMTF_EVENT_TYPE_MEASUREMENT_CHANGED_SIZE; index++) {
385 32 : measurement_changed.changed_measurements[index] = (uint8_t)index;
386 : }
387 1 : generate_dmtf_event_data(ptr, &event_data_size[2], 0x11223345,
388 : SPDM_DMTF_EVENT_TYPE_MEASUREMENT_CHANGED, &measurement_changed);
389 1 : ptr += event_data_size[2];
390 :
391 33 : for (index = 0; index < SPDM_DMTF_EVENT_TYPE_MEASUREMENT_PRE_UPDATE_SIZE; index++) {
392 32 : measurement_pre_update.pre_update_measurement_changes[index] = (uint8_t)(2 * index);
393 : }
394 1 : generate_dmtf_event_data(ptr, &event_data_size[3], 0x11223346,
395 : SPDM_DMTF_EVENT_TYPE_MEASUREMENT_PRE_UPDATE, &measurement_pre_update);
396 1 : ptr += event_data_size[3];
397 :
398 1 : m_event_counter = 0;
399 :
400 1 : m_expected_event[0].event_instance_id = 0x11223343;
401 1 : m_expected_event[0].svh_id = SPDM_REGISTRY_ID_DMTF;
402 1 : m_expected_event[0].svh_vendor_id_len = 0;
403 1 : m_expected_event[0].event_type_id = SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED;
404 1 : m_expected_event[0].event_detail_len = SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED_SIZE;
405 1 : memcpy(m_expected_event[0].event_detail, &certificate_changed,
406 : SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED_SIZE);
407 :
408 1 : m_expected_event[1].event_instance_id = 0x11223344;
409 1 : m_expected_event[1].svh_id = SPDM_REGISTRY_ID_DMTF;
410 1 : m_expected_event[1].svh_vendor_id_len = 0;
411 1 : m_expected_event[1].event_type_id = SPDM_DMTF_EVENT_TYPE_EVENT_LOST;
412 1 : m_expected_event[1].event_detail_len = SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE;
413 1 : memcpy(m_expected_event[1].event_detail, &event_lost, SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE);
414 :
415 1 : m_expected_event[2].event_instance_id = 0x11223345;
416 1 : m_expected_event[2].svh_id = SPDM_REGISTRY_ID_DMTF;
417 1 : m_expected_event[2].svh_vendor_id_len = 0;
418 1 : m_expected_event[2].event_type_id = SPDM_DMTF_EVENT_TYPE_MEASUREMENT_CHANGED;
419 1 : m_expected_event[2].event_detail_len = SPDM_DMTF_EVENT_TYPE_MEASUREMENT_CHANGED_SIZE;
420 1 : memcpy(m_expected_event[2].event_detail, &measurement_changed,
421 : SPDM_DMTF_EVENT_TYPE_MEASUREMENT_CHANGED_SIZE);
422 :
423 1 : m_expected_event[3].event_instance_id = 0x11223346;
424 1 : m_expected_event[3].svh_id = SPDM_REGISTRY_ID_DMTF;
425 1 : m_expected_event[3].svh_vendor_id_len = 0;
426 1 : m_expected_event[3].event_type_id = SPDM_DMTF_EVENT_TYPE_MEASUREMENT_PRE_UPDATE;
427 1 : m_expected_event[3].event_detail_len = SPDM_DMTF_EVENT_TYPE_MEASUREMENT_PRE_UPDATE_SIZE;
428 1 : memcpy(m_expected_event[3].event_detail, &measurement_pre_update,
429 : SPDM_DMTF_EVENT_TYPE_MEASUREMENT_PRE_UPDATE_SIZE);
430 :
431 1 : request_size = sizeof(spdm_send_event_request_t) + event_data_size[0] + event_data_size[1] +
432 1 : event_data_size[2] + event_data_size[3];
433 :
434 1 : status = libspdm_get_encap_response_event_ack(spdm_context,
435 : request_size,
436 : m_spdm_request_buffer,
437 : &response_size,
438 : m_spdm_response_buffer);
439 :
440 1 : event_ack = (spdm_event_ack_response_t *)m_spdm_response_buffer;
441 :
442 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
443 :
444 1 : assert_int_equal(response_size, sizeof(spdm_event_ack_response_t));
445 1 : assert_int_equal(event_ack->header.spdm_version, SPDM_MESSAGE_VERSION_13);
446 1 : assert_int_equal(event_ack->header.request_response_code, SPDM_EVENT_ACK);
447 1 : assert_int_equal(event_ack->header.param1, 0);
448 1 : assert_int_equal(event_ack->header.param2, 0);
449 :
450 1 : assert_int_equal(m_event_counter, 4);
451 1 : }
452 :
453 1 : int libspdm_requester_encap_event_ack_test_main(void)
454 : {
455 1 : const struct CMUnitTest spdm_requester_event_ack_tests[] = {
456 : cmocka_unit_test(test_libspdm_requester_encap_event_ack_case1),
457 : cmocka_unit_test(test_libspdm_requester_encap_event_ack_case2),
458 : cmocka_unit_test(test_libspdm_requester_encap_event_ack_case3),
459 : cmocka_unit_test(test_libspdm_requester_encap_event_ack_case4)
460 : };
461 :
462 1 : libspdm_test_context_t test_context = {
463 : LIBSPDM_TEST_CONTEXT_VERSION,
464 : false,
465 : };
466 :
467 1 : libspdm_setup_test_context(&test_context);
468 :
469 1 : return cmocka_run_group_tests(spdm_requester_event_ack_tests,
470 : libspdm_unit_test_group_setup,
471 : libspdm_unit_test_group_teardown);
472 : }
473 :
474 : #endif /* (LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP) && (LIBSPDM_EVENT_RECIPIENT_SUPPORT) */
|
