Line data    Source code

       1              : /**
       2              :  *  Copyright Notice:
       3              :  *  Copyright 2023-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 "spdm_unit_test.h"
       8              : 
       9              : #pragma pack(1)
      10              : typedef struct {
      11              :     uint8_t id;
      12              :     uint8_t vendor_id_len;
      13              : } event_group_id_0byte_t;
      14              : 
      15              : typedef struct {
      16              :     uint8_t id;
      17              :     uint8_t vendor_id_len;
      18              :     uint16_t vendor_id;
      19              : } event_group_id_2byte_t;
      20              : 
      21              : typedef struct {
      22              :     uint16_t event_type_count;
      23              :     uint16_t event_group_ver;
      24              :     uint32_t attributes;
      25              :     /* uint8_t event_type_list[] */
      26              : } event_group_t;
      27              : 
      28              : typedef struct {
      29              :     uint16_t event_type_id;
      30              :     uint16_t reserved;
      31              : } event_type_t;
      32              : 
      33              : typedef struct {
      34              :     uint32_t event_instance_id;
      35              :     uint8_t reserved[4];
      36              :     event_group_id_0byte_t event_group_id;
      37              :     uint16_t event_type_id;
      38              :     uint16_t event_detail_len;
      39              : } event_data_dmtf_t;
      40              : #pragma pack()
      41              : 
      42            5 : void generate_dmtf_event_group(void *buffer, uint8_t *total_bytes, uint32_t attributes,
      43              :                                bool inc_event_lost, bool inc_meas_changed,
      44              :                                bool inc_meas_pre_update, bool inc_cert_changed)
      45              : {
      46              :     uint8_t *ptr;
      47              :     uint16_t event_type_count;
      48              : 
      49            5 :     LIBSPDM_ASSERT(!(attributes & SPDM_SUBSCRIBE_EVENT_TYPES_REQUEST_ATTRIBUTE_ALL) ||
      50              :                    (!inc_event_lost && !inc_meas_changed &&
      51              :                     !inc_meas_pre_update && !inc_cert_changed));
      52              : 
      53            5 :     event_type_count = 0;
      54              : 
      55            5 :     if (inc_event_lost) {
      56            4 :         event_type_count++;
      57              :     }
      58            5 :     if (inc_meas_changed) {
      59            4 :         event_type_count++;
      60              :     }
      61            5 :     if (inc_meas_pre_update) {
      62            2 :         event_type_count++;
      63              :     }
      64            5 :     if (inc_cert_changed) {
      65            2 :         event_type_count++;
      66              :     }
      67              : 
      68            5 :     ptr = buffer;
      69            5 :     *total_bytes = 0;
      70              : 
      71            5 :     ((event_group_id_0byte_t *)ptr)->id = SPDM_REGISTRY_ID_DMTF;
      72            5 :     ((event_group_id_0byte_t *)ptr)->vendor_id_len = 0;
      73              : 
      74            5 :     ptr += sizeof(event_group_id_0byte_t);
      75            5 :     *total_bytes += (uint8_t)sizeof(event_group_id_0byte_t);
      76              : 
      77            5 :     ((event_group_t *)ptr)->event_type_count = event_type_count;
      78            5 :     ((event_group_t *)ptr)->event_group_ver = 1;
      79            5 :     ((event_group_t *)ptr)->attributes = attributes;
      80              : 
      81            5 :     ptr += sizeof(event_group_t);
      82            5 :     *total_bytes += (uint8_t)sizeof(event_group_t);
      83              : 
      84            5 :     if (inc_event_lost) {
      85            4 :         ((event_type_t *)ptr)->event_type_id = SPDM_DMTF_EVENT_TYPE_EVENT_LOST;
      86            4 :         ((event_type_t *)ptr)->reserved = 0;
      87            4 :         ptr += sizeof(event_type_t);
      88            4 :         *total_bytes += (uint8_t)sizeof(event_type_t);
      89              :     }
      90            5 :     if (inc_meas_changed) {
      91            4 :         ((event_type_t *)ptr)->event_type_id = SPDM_DMTF_EVENT_TYPE_MEASUREMENT_CHANGED;
      92            4 :         ((event_type_t *)ptr)->reserved = 0;
      93            4 :         ptr += sizeof(event_type_t);
      94            4 :         *total_bytes += (uint8_t)sizeof(event_type_t);
      95              :     }
      96            5 :     if (inc_meas_pre_update) {
      97            2 :         ((event_type_t *)ptr)->event_type_id = SPDM_DMTF_EVENT_TYPE_MEASUREMENT_PRE_UPDATE;
      98            2 :         ((event_type_t *)ptr)->reserved = 0;
      99            2 :         ptr += sizeof(event_type_t);
     100            2 :         *total_bytes += (uint8_t)sizeof(event_type_t);
     101              :     }
     102            5 :     if (inc_cert_changed) {
     103            2 :         ((event_type_t *)ptr)->event_type_id = SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED;
     104            2 :         ((event_type_t *)ptr)->reserved = 0;
     105            2 :         *total_bytes += (uint8_t)sizeof(event_type_t);
     106              :     }
     107            5 : }
     108              : 
     109           14 : void generate_dmtf_event_data(void *buffer, uint8_t *total_bytes, uint32_t event_instance_id,
     110              :                               uint16_t event_type_id, void *event_detail)
     111              : {
     112              :     event_data_dmtf_t *event_data;
     113              :     uint16_t event_detail_len;
     114              : 
     115           14 :     event_data = buffer;
     116              : 
     117           14 :     event_data->event_instance_id = event_instance_id;
     118           14 :     event_data->reserved[0] = 0;
     119           14 :     event_data->reserved[1] = 0;
     120           14 :     event_data->reserved[2] = 0;
     121           14 :     event_data->reserved[3] = 0;
     122           14 :     event_data->event_group_id.id = SPDM_REGISTRY_ID_DMTF;
     123           14 :     event_data->event_group_id.vendor_id_len = 0;
     124           14 :     event_data->event_type_id = event_type_id;
     125              : 
     126           14 :     switch (event_type_id) {
     127            8 :     case SPDM_DMTF_EVENT_TYPE_EVENT_LOST:
     128            8 :         event_detail_len = SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE;
     129            8 :         break;
     130            1 :     case SPDM_DMTF_EVENT_TYPE_MEASUREMENT_CHANGED:
     131            1 :         event_detail_len = SPDM_DMTF_EVENT_TYPE_MEASUREMENT_CHANGED_SIZE;
     132            1 :         break;
     133            1 :     case SPDM_DMTF_EVENT_TYPE_MEASUREMENT_PRE_UPDATE:
     134            1 :         event_detail_len = SPDM_DMTF_EVENT_TYPE_MEASUREMENT_PRE_UPDATE_SIZE;
     135            1 :         break;
     136            4 :     case SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED:
     137            4 :         event_detail_len = SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED_SIZE;
     138            4 :         break;
     139              :     }
     140              : 
     141           14 :     event_data->event_detail_len = event_detail_len;
     142              : 
     143           14 :     memcpy(event_data + 1, event_detail, (size_t)event_detail_len);
     144              : 
     145           14 :     *total_bytes = (uint8_t)sizeof(event_data_dmtf_t) + (uint8_t)event_detail_len;
     146           14 : }