Line data    Source code

       1              : /**
       2              :  *  Copyright Notice:
       3              :  *  Copyright 2024-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 <stdarg.h>
       8              : #include <stddef.h>
       9              : #include <setjmp.h>
      10              : #include <stdint.h>
      11              : #include <stdlib.h>
      12              : #include <stdio.h>
      13              : #include <assert.h>
      14              : #include <string.h>
      15              : 
      16              : #include <base.h>
      17              : #include "library/memlib.h"
      18              : #include "spdm_device_secret_lib_internal.h"
      19              : #include "internal/libspdm_common_lib.h"
      20              : 
      21              : uint32_t g_supported_event_groups_list_len = 8;
      22              : uint8_t g_event_group_count = 1;
      23              : bool g_event_all_subscribe = false;
      24              : bool g_event_all_unsubscribe = false;
      25              : uint32_t g_event_count = 1;
      26              : bool g_generate_event_list_error = false;
      27              : size_t g_events_list_size = 0;
      28              : bool g_event_get_types_error = false;
      29              : bool g_event_subscribe_error = false;
      30              : 
      31              : #if LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP
      32            4 : bool libspdm_event_get_types(
      33              :     void *spdm_context,
      34              :     spdm_version_number_t spdm_version,
      35              :     uint32_t session_id,
      36              :     void *supported_event_groups_list,
      37              :     uint32_t *supported_event_groups_list_len,
      38              :     uint8_t *event_group_count)
      39              : {
      40            4 :     if (g_event_get_types_error) {
      41            2 :         return false;
      42              :     }
      43              : 
      44            2 :     *supported_event_groups_list_len = g_supported_event_groups_list_len;
      45              : 
      46           18 :     for (uint32_t index = 0; index < *supported_event_groups_list_len; index++)
      47              :     {
      48           16 :         ((char *)supported_event_groups_list)[index] = (char)index;
      49              :     }
      50              : 
      51            2 :     *event_group_count = g_event_group_count;
      52              : 
      53            2 :     return true;
      54              : }
      55              : 
      56            7 : bool libspdm_event_subscribe(
      57              :     void *spdm_context,
      58              :     spdm_version_number_t spdm_version,
      59              :     uint32_t session_id,
      60              :     uint8_t subscribe_type,
      61              :     uint8_t subscribe_event_group_count,
      62              :     uint32_t subscribe_list_len,
      63              :     const void *subscribe_list)
      64              : {
      65            7 :     if (g_event_subscribe_error) {
      66            2 :         return false;
      67              :     }
      68              : 
      69            5 :     switch (subscribe_type) {
      70            1 :     case LIBSPDM_EVENT_SUBSCRIBE_ALL:
      71            1 :         if ((subscribe_list_len != 0) || (subscribe_list != NULL)) {
      72            0 :             return false;
      73              :         }
      74            1 :         LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO,
      75              :                        "Subscribing to all events for session ID 0x%x.\n", session_id));
      76            1 :         g_event_all_subscribe = true;
      77            1 :         g_event_all_unsubscribe = false;
      78            1 :         return true;
      79            2 :     case LIBSPDM_EVENT_SUBSCRIBE_NONE:
      80            2 :         if ((subscribe_list_len != 0) || (subscribe_list != NULL)) {
      81            0 :             return false;
      82              :         }
      83            2 :         LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO,
      84              :                        "Unsubscribing from all events for session ID 0x%x.\n", session_id));
      85            2 :         g_event_all_subscribe = false;
      86            2 :         g_event_all_unsubscribe = true;
      87            2 :         return true;
      88            2 :     case LIBSPDM_EVENT_SUBSCRIBE_LIST:
      89            2 :         if ((subscribe_list_len == 0) || (subscribe_list == NULL)) {
      90            0 :             return false;
      91              :         }
      92            2 :         break;
      93            0 :     default:
      94            0 :         return false;
      95              :     }
      96              : 
      97            2 :     g_event_all_subscribe = false;
      98            2 :     g_event_all_unsubscribe = false;
      99              : 
     100            2 :     LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO,
     101              :                    "subscribe_event_group_count == %d, subscribe_list_len = %d\n",
     102              :                    subscribe_event_group_count, subscribe_list_len));
     103              : 
     104           38 :     for (uint32_t index = 0; index < subscribe_list_len; index++) {
     105           36 :         printf("%02x ", ((const char *)subscribe_list)[index]);
     106              :     }
     107            2 :     printf("\n");
     108              : 
     109            2 :     return true;
     110              : }
     111              : 
     112            3 : bool libspdm_generate_event_list(
     113              :     void *spdm_context,
     114              :     spdm_version_number_t spdm_version,
     115              :     uint32_t session_id,
     116              :     uint32_t *event_count,
     117              :     size_t *events_list_size,
     118              :     void *events_list)
     119              : {
     120            3 :     if (g_generate_event_list_error) {
     121            1 :         return false;
     122              :     }
     123              : 
     124            2 :     *event_count = g_event_count;
     125              : 
     126            2 :     if ((g_events_list_size != 0) && (g_events_list_size < *events_list_size)) {
     127            1 :         *events_list_size = g_events_list_size;
     128              :     }
     129              : 
     130         4634 :     for (uint32_t index = 0; index < *events_list_size; index++)
     131              :     {
     132         4632 :         ((char *)events_list)[index] = (char)index;
     133              :     }
     134              : 
     135            2 :     return true;
     136              : }
     137              : #endif /* LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP */