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