Line data    Source code

       1              : /**
       2              :  *  Copyright Notice:
       3              :  *  Copyright 2021-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 "internal/libspdm_requester_lib.h"
       8              : 
       9          168 : uint16_t libspdm_allocate_req_session_id(libspdm_context_t *spdm_context, bool use_psk)
      10              : {
      11              :     uint16_t req_session_id;
      12              :     libspdm_session_info_t *session_info;
      13              :     size_t index;
      14              : 
      15          168 :     if (use_psk) {
      16           60 :         if ((spdm_context->max_psk_session_count != 0) &&
      17           16 :             (spdm_context->current_psk_session_count >= spdm_context->max_psk_session_count)) {
      18            5 :             LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR,
      19              :                            "libspdm_allocate_req_session_id - MAX PSK session\n"));
      20            5 :             return (INVALID_SESSION_ID & 0xFFFF);
      21              :         }
      22              :     } else {
      23          108 :         if ((spdm_context->max_dhe_session_count != 0) &&
      24           16 :             (spdm_context->current_dhe_session_count >= spdm_context->max_dhe_session_count)) {
      25            5 :             LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR,
      26              :                            "libspdm_allocate_req_session_id - MAX DHE session\n"));
      27            5 :             return (INVALID_SESSION_ID & 0xFFFF);
      28              :         }
      29              :     }
      30              : 
      31          158 :     session_info = spdm_context->session_info;
      32          350 :     for (index = 0; index < LIBSPDM_MAX_SESSION_COUNT; index++) {
      33          350 :         if ((session_info[index].session_id & 0xFFFF) == (INVALID_SESSION_ID & 0xFFFF)) {
      34          158 :             req_session_id = (uint16_t)(0xFFFF - index);
      35          158 :             return req_session_id;
      36              :         }
      37              :     }
      38              : 
      39            0 :     LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR, "libspdm_allocate_req_session_id - MAX session_id\n"));
      40            0 :     return (INVALID_SESSION_ID & 0xFFFF);
      41              : }
      42              : 
      43          174 : void libspdm_build_opaque_data_supported_version_data(libspdm_context_t *spdm_context,
      44              :                                                       size_t *data_out_size,
      45              :                                                       void *data_out)
      46              : {
      47              :     size_t final_data_size;
      48              :     secured_message_general_opaque_data_table_header_t *general_opaque_data_table_header;
      49              :     spdm_general_opaque_data_table_header_t *spdm_general_opaque_data_table_header;
      50              :     secured_message_opaque_element_table_header_t *opaque_element_table_header;
      51              :     secured_message_opaque_element_supported_version_t *opaque_element_support_version;
      52              :     spdm_version_number_t *versions_list;
      53              :     void *end;
      54              : 
      55          174 :     if (spdm_context->local_context.secured_message_version.secured_message_version_count == 0) {
      56            0 :         *data_out_size = 0;
      57            0 :         return;
      58              :     }
      59              : 
      60          174 :     final_data_size = libspdm_get_opaque_data_supported_version_data_size(spdm_context);
      61          174 :     LIBSPDM_ASSERT(*data_out_size >= final_data_size);
      62              : 
      63          174 :     if (libspdm_get_connection_version (spdm_context) >= SPDM_MESSAGE_VERSION_12) {
      64           14 :         spdm_general_opaque_data_table_header = data_out;
      65           14 :         spdm_general_opaque_data_table_header->total_elements = 1;
      66           14 :         libspdm_write_uint24(spdm_general_opaque_data_table_header->reserved, 0);
      67           14 :         opaque_element_table_header = (void *)(spdm_general_opaque_data_table_header + 1);
      68              :     } else {
      69          160 :         general_opaque_data_table_header = data_out;
      70          160 :         general_opaque_data_table_header->spec_id = SECURED_MESSAGE_OPAQUE_DATA_SPEC_ID;
      71          160 :         general_opaque_data_table_header->opaque_version = SECURED_MESSAGE_OPAQUE_VERSION;
      72          160 :         general_opaque_data_table_header->total_elements = 1;
      73          160 :         general_opaque_data_table_header->reserved = 0;
      74          160 :         opaque_element_table_header = (void *)(general_opaque_data_table_header + 1);
      75              :     }
      76              : 
      77          174 :     opaque_element_table_header->id = SPDM_REGISTRY_ID_DMTF;
      78          174 :     opaque_element_table_header->vendor_len = 0;
      79          174 :     opaque_element_table_header->opaque_element_data_len =
      80          174 :         sizeof(secured_message_opaque_element_supported_version_t) +
      81          174 :         sizeof(spdm_version_number_t) *
      82          174 :         spdm_context->local_context.secured_message_version.secured_message_version_count;
      83              : 
      84          174 :     opaque_element_support_version = (void *)(opaque_element_table_header + 1);
      85          174 :     opaque_element_support_version->sm_data_version =
      86              :         SECURED_MESSAGE_OPAQUE_ELEMENT_SMDATA_DATA_VERSION;
      87          174 :     opaque_element_support_version->sm_data_id =
      88              :         SECURED_MESSAGE_OPAQUE_ELEMENT_SMDATA_ID_SUPPORTED_VERSION;
      89          174 :     opaque_element_support_version->version_count =
      90          174 :         spdm_context->local_context.secured_message_version.secured_message_version_count;
      91              : 
      92          174 :     versions_list = (void *)(opaque_element_support_version + 1);
      93          174 :     libspdm_copy_mem(versions_list,
      94          174 :                      *data_out_size - ((uint8_t*)versions_list - (uint8_t*)data_out),
      95          174 :                      spdm_context->local_context.secured_message_version.secured_message_version,
      96          174 :                      spdm_context->local_context.secured_message_version.secured_message_version_count *
      97              :                      sizeof(spdm_version_number_t));
      98              : 
      99              :     /* Zero Padding. *data_out_size does not need to be changed, because data is 0 padded */
     100          174 :     end = versions_list + spdm_context->local_context.secured_message_version.secured_message_version_count;
     101          174 :     libspdm_zero_mem(end, (size_t)data_out + final_data_size - (size_t)end);
     102              : }