Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2021-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 "internal/libspdm_requester_lib.h"
8 :
9 : #if LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP
10 :
11 13 : void libspdm_register_get_encap_response_func(void *spdm_context,
12 : const libspdm_get_encap_response_func
13 : get_encap_response_func)
14 : {
15 : libspdm_context_t *context;
16 :
17 13 : context = spdm_context;
18 13 : context->get_encap_response_func = (void *)get_encap_response_func;
19 13 : }
20 :
21 : /**
22 : * Return the GET_ENCAP_RESPONSE function via request code.
23 : *
24 : * @param request_code The SPDM request code.
25 : *
26 : * @return GET_ENCAP_RESPONSE function according to the request code.
27 : **/
28 : static libspdm_get_encap_response_func
29 8 : libspdm_get_encap_response_func_via_request_code(uint8_t request_response_code)
30 : {
31 : typedef struct {
32 : uint8_t request_response_code;
33 : libspdm_get_encap_response_func get_encap_response_func;
34 : } libspdm_get_encap_response_struct_t;
35 :
36 : size_t index;
37 :
38 8 : const libspdm_get_encap_response_struct_t get_encap_response_struct[] = {
39 : #if LIBSPDM_ENABLE_CAPABILITY_CERT_CAP
40 : { SPDM_GET_DIGESTS, libspdm_get_encap_response_digest },
41 : { SPDM_GET_CERTIFICATE, libspdm_get_encap_response_certificate },
42 : #endif /* LIBSPDM_ENABLE_CAPABILITY_CERT_CAP */
43 :
44 : #if LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP
45 : #if LIBSPDM_ENABLE_CAPABILITY_CHAL_CAP
46 : { SPDM_CHALLENGE, libspdm_get_encap_response_challenge_auth },
47 : #endif /* LIBSPDM_ENABLE_CAPABILITY_CHAL_CAP */
48 : #endif /* LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP */
49 :
50 : { SPDM_KEY_UPDATE, libspdm_get_encap_response_key_update },
51 :
52 : #if LIBSPDM_EVENT_RECIPIENT_SUPPORT
53 : { SPDM_SEND_EVENT, libspdm_get_encap_response_event_ack },
54 : #endif /* LIBSPDM_EVENT_RECIPIENT_SUPPORT */
55 :
56 : #if LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP
57 : { SPDM_GET_SUPPORTED_EVENT_TYPES, libspdm_get_encap_supported_event_types },
58 : #endif /* LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP */
59 :
60 : #if LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP
61 : { SPDM_GET_ENDPOINT_INFO, libspdm_get_encap_response_endpoint_info },
62 : #endif /* LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP */
63 : };
64 :
65 25 : for (index = 0; index < LIBSPDM_ARRAY_SIZE(get_encap_response_struct); index++) {
66 24 : if (request_response_code == get_encap_response_struct[index].request_response_code) {
67 7 : return get_encap_response_struct[index].get_encap_response_func;
68 : }
69 : }
70 1 : return NULL;
71 : }
72 :
73 : /**
74 : * This function processes encapsulated request.
75 : *
76 : * @param spdm_context A pointer to the SPDM context.
77 : * @param encap_request_size Size, in bytes, of the request data buffer.
78 : * @param encap_request A pointer to a destination buffer to store the request.
79 : * @param encap_response_size Size, in bytes, of the response data buffer.
80 : * @param encap_response A pointer to a destination buffer to store the response.
81 : **/
82 8 : static libspdm_return_t libspdm_process_encapsulated_request(libspdm_context_t *spdm_context,
83 : size_t encap_request_size,
84 : void *encap_request,
85 : size_t *encap_response_size,
86 : void *encap_response)
87 : {
88 : libspdm_get_encap_response_func get_encap_response_func;
89 : spdm_message_header_t *spdm_requester;
90 :
91 8 : spdm_requester = encap_request;
92 8 : if (encap_request_size < sizeof(spdm_message_header_t)) {
93 0 : return libspdm_generate_encap_error_response(
94 : spdm_context, SPDM_ERROR_CODE_UNSUPPORTED_REQUEST,
95 0 : spdm_requester->request_response_code,
96 : encap_response_size, encap_response);
97 : }
98 :
99 8 : get_encap_response_func = libspdm_get_encap_response_func_via_request_code(
100 8 : spdm_requester->request_response_code);
101 8 : if (get_encap_response_func == NULL) {
102 1 : get_encap_response_func =
103 1 : (libspdm_get_encap_response_func)spdm_context->get_encap_response_func;
104 : }
105 8 : if (get_encap_response_func != NULL) {
106 7 : return get_encap_response_func(
107 : spdm_context, encap_request_size, encap_request,
108 : encap_response_size, encap_response);
109 : } else {
110 1 : return libspdm_generate_encap_error_response(
111 : spdm_context, SPDM_ERROR_CODE_UNEXPECTED_REQUEST,
112 : 0, encap_response_size, encap_response);
113 : }
114 : }
115 :
116 13 : libspdm_return_t libspdm_encapsulated_request(libspdm_context_t *spdm_context,
117 : const uint32_t *session_id,
118 : uint8_t mut_auth_requested,
119 : uint8_t *req_slot_id_param)
120 : {
121 : libspdm_return_t status;
122 : uint8_t *spdm_request;
123 : size_t spdm_request_size;
124 : spdm_get_encapsulated_request_request_t
125 : *spdm_get_encapsulated_request_request;
126 : spdm_deliver_encapsulated_response_request_t
127 : *spdm_deliver_encapsulated_response_request;
128 : uint8_t *spdm_response;
129 : size_t spdm_response_size;
130 : spdm_encapsulated_request_response_t *libspdm_encapsulated_request_response;
131 : spdm_encapsulated_response_ack_response_t
132 : *spdm_encapsulated_response_ack_response;
133 : libspdm_session_info_t *session_info;
134 : uint8_t request_id;
135 : void *encapsulated_request;
136 : size_t encapsulated_request_size;
137 : void *encapsulated_response;
138 : size_t encapsulated_response_size;
139 : size_t ack_header_size;
140 :
141 : uint8_t *message;
142 : size_t message_size;
143 : size_t transport_header_size;
144 :
145 : #if LIBSPDM_ENABLE_CAPABILITY_CERT_CAP
146 : spdm_get_digest_request_t *get_digests;
147 : #endif /* LIBSPDM_ENABLE_CAPABILITY_CERT_CAP */
148 :
149 13 : if (!libspdm_is_encap_supported(spdm_context)) {
150 0 : return LIBSPDM_STATUS_UNSUPPORTED_CAP;
151 : }
152 :
153 13 : if (session_id != NULL) {
154 0 : session_info = libspdm_get_session_info_via_session_id(spdm_context, *session_id);
155 0 : if (session_info == NULL) {
156 0 : LIBSPDM_ASSERT(false);
157 0 : return LIBSPDM_STATUS_INVALID_STATE_LOCAL;
158 : }
159 0 : LIBSPDM_ASSERT((mut_auth_requested == 0) ||
160 : (mut_auth_requested ==
161 : SPDM_KEY_EXCHANGE_RESPONSE_MUT_AUTH_REQUESTED_WITH_ENCAP_REQUEST) ||
162 : (mut_auth_requested ==
163 : SPDM_KEY_EXCHANGE_RESPONSE_MUT_AUTH_REQUESTED_WITH_GET_DIGESTS));
164 : } else {
165 13 : LIBSPDM_ASSERT(mut_auth_requested == 0);
166 : }
167 :
168 :
169 : /* Cache */
170 13 : libspdm_reset_message_mut_b(spdm_context);
171 13 : libspdm_reset_message_mut_c(spdm_context);
172 :
173 13 : if (session_id == NULL) {
174 13 : spdm_context->last_spdm_request_session_id_valid = false;
175 13 : spdm_context->last_spdm_request_session_id = 0;
176 : } else {
177 0 : spdm_context->last_spdm_request_session_id_valid = true;
178 0 : spdm_context->last_spdm_request_session_id = *session_id;
179 : }
180 :
181 13 : if (mut_auth_requested == SPDM_KEY_EXCHANGE_RESPONSE_MUT_AUTH_REQUESTED_WITH_GET_DIGESTS) {
182 : #if LIBSPDM_ENABLE_CAPABILITY_CERT_CAP
183 0 : get_digests = (void *)spdm_context->last_spdm_request;
184 0 : get_digests->header.spdm_version = libspdm_get_connection_version (spdm_context);
185 0 : get_digests->header.request_response_code = SPDM_GET_DIGESTS;
186 0 : get_digests->header.param1 = 0;
187 0 : get_digests->header.param2 = 0;
188 0 : spdm_context->last_spdm_request_size = sizeof(spdm_get_digest_request_t);
189 0 : encapsulated_request = (void *)spdm_context->last_spdm_request;
190 0 : encapsulated_request_size = spdm_context->last_spdm_request_size;
191 0 : request_id = 0;
192 : #else /* LIBSPDM_ENABLE_CAPABILITY_CERT_CAP */
193 : return LIBSPDM_STATUS_UNSUPPORTED_CAP;
194 : #endif /* LIBSPDM_ENABLE_CAPABILITY_CERT_CAP */
195 : } else {
196 13 : transport_header_size = spdm_context->local_context.capability.transport_header_size;
197 13 : status = libspdm_acquire_sender_buffer (spdm_context, &message_size, (void **)&message);
198 13 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
199 0 : return status;
200 : }
201 13 : LIBSPDM_ASSERT (message_size >= transport_header_size +
202 : spdm_context->local_context.capability.transport_tail_size);
203 13 : spdm_request = (void *)(message + transport_header_size);
204 13 : spdm_request_size = message_size - transport_header_size -
205 13 : spdm_context->local_context.capability.transport_tail_size;
206 :
207 13 : spdm_context->crypto_request = true;
208 13 : spdm_get_encapsulated_request_request = (void *)spdm_request;
209 13 : spdm_get_encapsulated_request_request->header.spdm_version =
210 13 : libspdm_get_connection_version (spdm_context);
211 : spdm_get_encapsulated_request_request->header
212 13 : .request_response_code = SPDM_GET_ENCAPSULATED_REQUEST;
213 13 : spdm_get_encapsulated_request_request->header.param1 = 0;
214 13 : spdm_get_encapsulated_request_request->header.param2 = 0;
215 13 : spdm_request_size = sizeof(spdm_get_encapsulated_request_request_t);
216 13 : libspdm_reset_message_buffer_via_request_code
217 : (spdm_context, NULL,
218 13 : spdm_get_encapsulated_request_request->header.request_response_code);
219 13 : status = libspdm_send_spdm_request(spdm_context, session_id, spdm_request_size,
220 : spdm_request);
221 13 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
222 1 : libspdm_release_sender_buffer (spdm_context);
223 1 : return status;
224 : }
225 12 : libspdm_release_sender_buffer (spdm_context);
226 12 : spdm_get_encapsulated_request_request = (void *)spdm_context->last_spdm_request;
227 :
228 : /* receive */
229 :
230 12 : status = libspdm_acquire_receiver_buffer (spdm_context, &message_size, (void **)&message);
231 12 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
232 0 : return status;
233 : }
234 12 : LIBSPDM_ASSERT (message_size >= transport_header_size);
235 12 : spdm_response = (void *)(message);
236 12 : spdm_response_size = message_size;
237 :
238 12 : status = libspdm_receive_spdm_response(
239 : spdm_context, session_id, &spdm_response_size,
240 : (void **)&spdm_response);
241 12 : libspdm_encapsulated_request_response = (void *)spdm_response;
242 12 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
243 0 : libspdm_release_receiver_buffer (spdm_context);
244 0 : return status;
245 : }
246 12 : if (libspdm_encapsulated_request_response->header.request_response_code == SPDM_ERROR) {
247 3 : const uint8_t error_code = libspdm_encapsulated_request_response->header.param1;
248 :
249 3 : libspdm_release_receiver_buffer(spdm_context);
250 :
251 3 : if (spdm_response_size < sizeof(spdm_error_response_t)) {
252 0 : libspdm_release_receiver_buffer (spdm_context);
253 0 : return LIBSPDM_STATUS_INVALID_MSG_SIZE;
254 : }
255 :
256 3 : if (mut_auth_requested == 0) {
257 : /* Responder can send NoPendingRequests or UnexpectedRequest if it has no
258 : * encapsulated request for the Requester. */
259 3 : if ((libspdm_get_connection_version(spdm_context) >= SPDM_MESSAGE_VERSION_13) &&
260 : (error_code == SPDM_ERROR_CODE_NO_PENDING_REQUESTS)) {
261 :
262 1 : return LIBSPDM_STATUS_SUCCESS;
263 : }
264 2 : if ((libspdm_get_connection_version(spdm_context) < SPDM_MESSAGE_VERSION_13) &&
265 : (error_code == SPDM_ERROR_CODE_UNEXPECTED_REQUEST)) {
266 1 : return LIBSPDM_STATUS_SUCCESS;
267 : }
268 : }
269 1 : status = libspdm_handle_error_response_main(
270 : spdm_context, session_id,
271 : &spdm_response_size, (void **)&spdm_response,
272 : SPDM_GET_ENCAPSULATED_REQUEST, SPDM_ENCAPSULATED_REQUEST);
273 1 : return status;
274 : }
275 9 : if (libspdm_encapsulated_request_response->header.spdm_version !=
276 9 : spdm_get_encapsulated_request_request->header.spdm_version) {
277 0 : libspdm_release_receiver_buffer (spdm_context);
278 0 : return LIBSPDM_STATUS_INVALID_MSG_FIELD;
279 : }
280 :
281 9 : if (libspdm_encapsulated_request_response->header.request_response_code !=
282 : SPDM_ENCAPSULATED_REQUEST) {
283 0 : libspdm_release_receiver_buffer (spdm_context);
284 0 : return LIBSPDM_STATUS_INVALID_MSG_FIELD;
285 : }
286 9 : if (spdm_response_size <= sizeof(spdm_encapsulated_request_response_t)) {
287 1 : libspdm_release_receiver_buffer (spdm_context);
288 1 : return LIBSPDM_STATUS_INVALID_MSG_SIZE;
289 : }
290 :
291 8 : request_id = libspdm_encapsulated_request_response->header.param1;
292 :
293 8 : encapsulated_request = (void *)(libspdm_encapsulated_request_response + 1);
294 8 : encapsulated_request_size =
295 8 : spdm_response_size - sizeof(spdm_encapsulated_request_response_t);
296 :
297 8 : libspdm_copy_mem (spdm_context->last_spdm_request,
298 8 : libspdm_get_scratch_buffer_last_spdm_request_capacity(spdm_context),
299 : encapsulated_request,
300 : encapsulated_request_size);
301 8 : spdm_context->last_spdm_request_size = encapsulated_request_size;
302 8 : encapsulated_request = (void *)spdm_context->last_spdm_request;
303 :
304 8 : libspdm_release_receiver_buffer (spdm_context);
305 : }
306 :
307 : while (true) {
308 : /* Process request. */
309 8 : transport_header_size = spdm_context->local_context.capability.transport_header_size;
310 8 : status = libspdm_acquire_sender_buffer (spdm_context, &message_size, (void **)&message);
311 8 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
312 0 : return status;
313 : }
314 8 : LIBSPDM_ASSERT (message_size >= transport_header_size +
315 : spdm_context->local_context.capability.transport_tail_size);
316 8 : spdm_request = (void *)(message + transport_header_size);
317 8 : spdm_request_size = message_size - transport_header_size -
318 8 : spdm_context->local_context.capability.transport_tail_size;
319 :
320 8 : spdm_context->crypto_request = true;
321 8 : spdm_deliver_encapsulated_response_request = (void *)spdm_request;
322 8 : spdm_deliver_encapsulated_response_request->header.spdm_version =
323 8 : libspdm_get_connection_version (spdm_context);
324 8 : spdm_deliver_encapsulated_response_request->header.request_response_code =
325 : SPDM_DELIVER_ENCAPSULATED_RESPONSE;
326 8 : spdm_deliver_encapsulated_response_request->header.param1 = request_id;
327 8 : spdm_deliver_encapsulated_response_request->header.param2 = 0;
328 8 : encapsulated_response = (void *)(spdm_deliver_encapsulated_response_request + 1);
329 8 : encapsulated_response_size =
330 8 : spdm_request_size - sizeof(spdm_deliver_encapsulated_response_request_t);
331 :
332 8 : status = libspdm_process_encapsulated_request(
333 : spdm_context, encapsulated_request_size,
334 : encapsulated_request, &encapsulated_response_size,
335 : encapsulated_response);
336 8 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
337 0 : libspdm_release_sender_buffer (spdm_context);
338 0 : return status;
339 : }
340 :
341 8 : spdm_request_size =
342 8 : sizeof(spdm_deliver_encapsulated_response_request_t) + encapsulated_response_size;
343 8 : status = libspdm_send_spdm_request(
344 : spdm_context, session_id, spdm_request_size,
345 : spdm_request);
346 8 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
347 0 : libspdm_release_sender_buffer (spdm_context);
348 0 : return status;
349 : }
350 8 : libspdm_release_sender_buffer (spdm_context);
351 8 : spdm_deliver_encapsulated_response_request = (void *)spdm_context->last_spdm_request;
352 :
353 : /* Receive. */
354 8 : status = libspdm_acquire_receiver_buffer (spdm_context, &message_size, (void **)&message);
355 8 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
356 0 : return status;
357 : }
358 8 : LIBSPDM_ASSERT (message_size >= transport_header_size);
359 8 : spdm_response = (void *)(message);
360 8 : spdm_response_size = message_size;
361 :
362 8 : status = libspdm_receive_spdm_response(
363 : spdm_context, session_id, &spdm_response_size,
364 : (void **)&spdm_response);
365 8 : spdm_encapsulated_response_ack_response = (void *)spdm_response;
366 8 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
367 0 : libspdm_release_receiver_buffer (spdm_context);
368 0 : return status;
369 : }
370 8 : if (spdm_encapsulated_response_ack_response->header.request_response_code == SPDM_ERROR) {
371 1 : libspdm_release_receiver_buffer(spdm_context);
372 :
373 1 : if (spdm_response_size < sizeof(spdm_error_response_t)) {
374 0 : libspdm_release_receiver_buffer (spdm_context);
375 0 : return LIBSPDM_STATUS_INVALID_MSG_SIZE;
376 : }
377 :
378 1 : status = libspdm_handle_error_response_main(
379 : spdm_context, session_id,
380 : &spdm_response_size, (void **)&spdm_response,
381 : SPDM_DELIVER_ENCAPSULATED_RESPONSE,
382 : SPDM_ENCAPSULATED_RESPONSE_ACK);
383 1 : return status;
384 7 : } else if (spdm_encapsulated_response_ack_response->header.request_response_code !=
385 : SPDM_ENCAPSULATED_RESPONSE_ACK) {
386 1 : libspdm_release_receiver_buffer (spdm_context);
387 1 : return LIBSPDM_STATUS_INVALID_MSG_FIELD;
388 : }
389 6 : if (spdm_encapsulated_response_ack_response->header.spdm_version !=
390 6 : spdm_deliver_encapsulated_response_request->header.spdm_version) {
391 0 : libspdm_release_receiver_buffer (spdm_context);
392 0 : return LIBSPDM_STATUS_INVALID_MSG_FIELD;
393 : }
394 6 : if (spdm_encapsulated_response_ack_response->header.spdm_version >=
395 : SPDM_MESSAGE_VERSION_12) {
396 1 : ack_header_size = sizeof(spdm_encapsulated_response_ack_response_t);
397 : } else {
398 5 : ack_header_size = sizeof(spdm_message_header_t);
399 : }
400 6 : if (spdm_response_size < ack_header_size) {
401 0 : libspdm_release_receiver_buffer (spdm_context);
402 0 : return LIBSPDM_STATUS_INVALID_MSG_SIZE;
403 : }
404 :
405 6 : if (spdm_encapsulated_response_ack_response->header.spdm_version >=
406 : SPDM_MESSAGE_VERSION_12) {
407 1 : if (spdm_encapsulated_response_ack_response->ack_request_id !=
408 1 : spdm_deliver_encapsulated_response_request->header.param1) {
409 0 : libspdm_release_receiver_buffer (spdm_context);
410 0 : return LIBSPDM_STATUS_INVALID_MSG_FIELD;
411 : }
412 : }
413 :
414 6 : switch (spdm_encapsulated_response_ack_response->header.param2) {
415 5 : case SPDM_ENCAPSULATED_RESPONSE_ACK_RESPONSE_PAYLOAD_TYPE_ABSENT:
416 5 : libspdm_release_receiver_buffer (spdm_context);
417 5 : return LIBSPDM_STATUS_SUCCESS;
418 0 : case SPDM_ENCAPSULATED_RESPONSE_ACK_RESPONSE_PAYLOAD_TYPE_PRESENT:
419 0 : break;
420 1 : case SPDM_ENCAPSULATED_RESPONSE_ACK_RESPONSE_PAYLOAD_TYPE_REQ_SLOT_NUMBER:
421 1 : if (spdm_response_size >= ack_header_size + sizeof(uint8_t)) {
422 1 : if ((req_slot_id_param != NULL) && (*req_slot_id_param == 0)) {
423 0 : *req_slot_id_param =
424 0 : *((uint8_t *)spdm_encapsulated_response_ack_response + ack_header_size);
425 : /* 0xFF or 0xF slot is not allowed. */
426 0 : if (*req_slot_id_param >= SPDM_MAX_SLOT_COUNT) {
427 0 : libspdm_release_receiver_buffer (spdm_context);
428 0 : return LIBSPDM_STATUS_INVALID_MSG_FIELD;
429 : }
430 :
431 0 : if ((spdm_encapsulated_response_ack_response->header.spdm_version >=
432 0 : SPDM_MESSAGE_VERSION_13) &&
433 0 : spdm_context->connection_info.multi_key_conn_req) {
434 0 : if ((spdm_context->local_context.local_key_usage_bit_mask[*req_slot_id_param
435 0 : ] & SPDM_KEY_USAGE_BIT_MASK_KEY_EX_USE) == 0) {
436 0 : libspdm_release_receiver_buffer (spdm_context);
437 0 : return LIBSPDM_STATUS_INVALID_MSG_FIELD;
438 : }
439 : }
440 : }
441 1 : libspdm_release_receiver_buffer (spdm_context);
442 1 : return LIBSPDM_STATUS_SUCCESS;
443 : } else {
444 0 : libspdm_release_receiver_buffer (spdm_context);
445 0 : return LIBSPDM_STATUS_INVALID_MSG_SIZE;
446 : }
447 : break;
448 0 : default:
449 0 : libspdm_release_receiver_buffer (spdm_context);
450 0 : return LIBSPDM_STATUS_INVALID_MSG_FIELD;
451 : }
452 0 : request_id = spdm_encapsulated_response_ack_response->header.param1;
453 :
454 0 : encapsulated_request =
455 : ((uint8_t *)spdm_encapsulated_response_ack_response + ack_header_size);
456 0 : encapsulated_request_size = spdm_response_size - ack_header_size;
457 :
458 0 : libspdm_copy_mem (spdm_context->last_spdm_request,
459 0 : libspdm_get_scratch_buffer_last_spdm_request_capacity(spdm_context),
460 : encapsulated_request,
461 : encapsulated_request_size);
462 0 : spdm_context->last_spdm_request_size = encapsulated_request_size;
463 0 : encapsulated_request = (void *)spdm_context->last_spdm_request;
464 :
465 0 : libspdm_release_receiver_buffer (spdm_context);
466 : }
467 :
468 : return LIBSPDM_STATUS_SUCCESS;
469 : }
470 :
471 0 : libspdm_return_t libspdm_send_receive_encap_request(void *spdm_context, const uint32_t *session_id)
472 : {
473 0 : return libspdm_encapsulated_request(spdm_context, session_id, 0, NULL);
474 : }
475 :
476 : #endif /* LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP */
|
