Branch data     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 */