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 "internal/libspdm_common_lib.h"
       8              : 
       9              : #if LIBSPDM_EVENT_RECIPIENT_SUPPORT
      10              : 
      11           27 : bool libspdm_validate_dmtf_event_type(uint16_t event_type_id, uint16_t event_detail_len)
      12              : {
      13           27 :     switch (event_type_id) {
      14           15 :     case SPDM_DMTF_EVENT_TYPE_EVENT_LOST:
      15           15 :         return (event_detail_len == SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE);
      16            2 :     case SPDM_DMTF_EVENT_TYPE_MEASUREMENT_CHANGED:
      17            2 :         return (event_detail_len == SPDM_DMTF_EVENT_TYPE_MEASUREMENT_CHANGED_SIZE);
      18            2 :     case SPDM_DMTF_EVENT_TYPE_MEASUREMENT_PRE_UPDATE:
      19            2 :         return (event_detail_len == SPDM_DMTF_EVENT_TYPE_MEASUREMENT_PRE_UPDATE_SIZE);
      20            8 :     case SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED:
      21            8 :         return (event_detail_len == SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED_SIZE);
      22            0 :     default:
      23            0 :         return false;
      24              :     }
      25              : }
      26              : 
      27           19 : bool libspdm_parse_and_send_event(libspdm_context_t *context, uint32_t session_id,
      28              :                                   const void *event_data, const void **next_event_data)
      29              : {
      30              :     libspdm_return_t status;
      31              :     const uint8_t *ptr;
      32              :     uint32_t event_instance_id;
      33              :     uint8_t svh_id;
      34              :     uint8_t svh_vendor_id_len;
      35              :     const void *svh_vendor_id;
      36              :     uint16_t event_type_id;
      37              :     uint16_t event_detail_len;
      38              : 
      39           19 :     LIBSPDM_ASSERT(context->process_event != NULL);
      40              : 
      41           19 :     ptr = event_data;
      42           19 :     event_instance_id = libspdm_read_uint32(ptr);
      43              : 
      44           19 :     ptr += sizeof(uint32_t);
      45           19 :     ptr += sizeof(uint32_t);
      46           19 :     svh_id = *ptr;
      47           19 :     ptr++;
      48           19 :     svh_vendor_id_len = *ptr;
      49           19 :     ptr++;
      50              : 
      51           19 :     if (svh_vendor_id_len == 0) {
      52           19 :         svh_vendor_id = NULL;
      53              :     } else {
      54            0 :         svh_vendor_id = ptr;
      55              :     }
      56           19 :     ptr += svh_vendor_id_len;
      57              : 
      58           19 :     event_type_id = libspdm_read_uint16(ptr);
      59           19 :     ptr += sizeof(uint16_t);
      60           19 :     event_detail_len = libspdm_read_uint16(ptr);
      61           19 :     ptr += sizeof(uint16_t);
      62              : 
      63           19 :     status = context->process_event(context, session_id, event_instance_id, svh_id,
      64              :                                     svh_vendor_id_len, svh_vendor_id, event_type_id,
      65              :                                     event_detail_len, ptr);
      66              : 
      67           19 :     if (next_event_data != NULL) {
      68           15 :         ptr += event_detail_len;
      69           15 :         *next_event_data = ptr;
      70              :     }
      71              : 
      72           19 :     return (status == LIBSPDM_STATUS_SUCCESS);
      73              : }
      74              : 
      75            8 : const void *libspdm_find_event_instance_id(const void *events_list_start, uint32_t event_count,
      76              :                                            uint32_t target_event_instance_id)
      77              : {
      78              :     uint32_t index;
      79              :     const uint8_t *ptr;
      80              : 
      81            8 :     ptr = events_list_start;
      82              : 
      83           12 :     for (index = 0; index < event_count; index++) {
      84              :         uint32_t event_instance_id;
      85              : 
      86           12 :         event_instance_id = libspdm_read_uint32(ptr);
      87              : 
      88           12 :         if (event_instance_id == target_event_instance_id) {
      89            8 :             return ptr;
      90              :         } else {
      91              :             uint8_t vendor_id_len;
      92              :             uint16_t event_detail_len;
      93              : 
      94            4 :             ptr += sizeof(uint32_t) +  sizeof(uint32_t) + sizeof(uint8_t);
      95            4 :             vendor_id_len = *ptr;
      96            4 :             ptr += sizeof(uint8_t);
      97            4 :             ptr += vendor_id_len;
      98            4 :             ptr += sizeof(uint16_t);
      99            4 :             event_detail_len = libspdm_read_uint16(ptr);
     100            4 :             ptr += sizeof(uint16_t);
     101            4 :             ptr += event_detail_len;
     102              :         }
     103              :     }
     104              : 
     105            0 :     return NULL;
     106              : }
     107              : 
     108              : #endif /* LIBSPDM_EVENT_RECIPIENT_SUPPORT */