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            6 : 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            6 :     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            6 :     event_type_count = 0;
      54              : 
      55            6 :     if (inc_event_lost) {
      56            5 :         event_type_count++;
      57              :     }
      58            6 :     if (inc_meas_changed) {
      59            5 :         event_type_count++;
      60              :     }
      61            6 :     if (inc_meas_pre_update) {
      62            2 :         event_type_count++;
      63              :     }
      64            6 :     if (inc_cert_changed) {
      65            2 :         event_type_count++;
      66              :     }
      67              : 
      68            6 :     ptr = buffer;
      69            6 :     *total_bytes = 0;
      70              : 
      71            6 :     ((event_group_id_0byte_t *)ptr)->id = SPDM_REGISTRY_ID_DMTF;
      72            6 :     ((event_group_id_0byte_t *)ptr)->vendor_id_len = 0;
      73              : 
      74            6 :     ptr += sizeof(event_group_id_0byte_t);
      75            6 :     *total_bytes += (uint8_t)sizeof(event_group_id_0byte_t);
      76              : 
      77            6 :     ((event_group_t *)ptr)->event_type_count = event_type_count;
      78            6 :     ((event_group_t *)ptr)->event_group_ver = 1;
      79            6 :     ((event_group_t *)ptr)->attributes = attributes;
      80              : 
      81            6 :     ptr += sizeof(event_group_t);
      82            6 :     *total_bytes += (uint8_t)sizeof(event_group_t);
      83              : 
      84            6 :     if (inc_event_lost) {
      85            5 :         ((event_type_t *)ptr)->event_type_id = SPDM_DMTF_EVENT_TYPE_EVENT_LOST;
      86            5 :         ((event_type_t *)ptr)->reserved = 0;
      87            5 :         ptr += sizeof(event_type_t);
      88            5 :         *total_bytes += (uint8_t)sizeof(event_type_t);
      89              :     }
      90            6 :     if (inc_meas_changed) {
      91            5 :         ((event_type_t *)ptr)->event_type_id = SPDM_DMTF_EVENT_TYPE_MEASUREMENT_CHANGED;
      92            5 :         ((event_type_t *)ptr)->reserved = 0;
      93            5 :         ptr += sizeof(event_type_t);
      94            5 :         *total_bytes += (uint8_t)sizeof(event_type_t);
      95              :     }
      96            6 :     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            6 :     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            6 : }
     108              : 
     109           29 : 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           29 :     event_data = buffer;
     116              : 
     117           29 :     event_data->event_instance_id = event_instance_id;
     118           29 :     event_data->reserved[0] = 0;
     119           29 :     event_data->reserved[1] = 0;
     120           29 :     event_data->reserved[2] = 0;
     121           29 :     event_data->reserved[3] = 0;
     122           29 :     event_data->event_group_id.id = SPDM_REGISTRY_ID_DMTF;
     123           29 :     event_data->event_group_id.vendor_id_len = 0;
     124           29 :     event_data->event_type_id = event_type_id;
     125              : 
     126           29 :     switch (event_type_id) {
     127           17 :     case SPDM_DMTF_EVENT_TYPE_EVENT_LOST:
     128           17 :         event_detail_len = SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE;
     129           17 :         break;
     130            2 :     case SPDM_DMTF_EVENT_TYPE_MEASUREMENT_CHANGED:
     131            2 :         event_detail_len = SPDM_DMTF_EVENT_TYPE_MEASUREMENT_CHANGED_SIZE;
     132            2 :         break;
     133            2 :     case SPDM_DMTF_EVENT_TYPE_MEASUREMENT_PRE_UPDATE:
     134            2 :         event_detail_len = SPDM_DMTF_EVENT_TYPE_MEASUREMENT_PRE_UPDATE_SIZE;
     135            2 :         break;
     136            8 :     case SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED:
     137            8 :         event_detail_len = SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED_SIZE;
     138            8 :         break;
     139              :     }
     140              : 
     141           29 :     event_data->event_detail_len = event_detail_len;
     142              : 
     143           29 :     memcpy(event_data + 1, event_detail, (size_t)event_detail_len);
     144              : 
     145           29 :     *total_bytes = (uint8_t)sizeof(event_data_dmtf_t) + (uint8_t)event_detail_len;
     146           29 : }