Line data    Source code

       1            0 : /*
       2              :  * Copyright (c) 2018-2022 mcumgr authors
       3              :  * Copyright (c) 2022 Laird Connectivity
       4              :  * Copyright (c) 2022 Nordic Semiconductor ASA
       5              :  *
       6              :  * SPDX-License-Identifier: Apache-2.0
       7              :  */
       8              : 
       9              : #ifndef H_MGMT_MCUMGR_GRP_FS_MGMT_CHKSUM_
      10              : #define H_MGMT_MCUMGR_GRP_FS_MGMT_CHKSUM_
      11              : 
      12              : #include <zephyr/kernel.h>
      13              : #include <zephyr/fs/fs.h>
      14              : 
      15              : #ifdef __cplusplus
      16              : extern "C" {
      17              : #endif
      18              : 
      19              : /** @typedef fs_mgmt_hash_checksum_handler_fn
      20              :  * @brief Function that gets called to generate a hash or checksum.
      21              :  *
      22              :  * @param file          Opened file context
      23              :  * @param output        Output buffer for hash/checksum
      24              :  * @param out_len       Updated with size of input data
      25              :  * @param len           Maximum length of data to perform hash/checksum on
      26              :  *
      27              :  * @return 0 on success, negative error code on failure.
      28              :  */
      29            1 : typedef int (*fs_mgmt_hash_checksum_handler_fn)(struct fs_file_t *file, uint8_t *output,
      30              :                                                 size_t *out_len, size_t len);
      31              : 
      32              : /**
      33              :  * @brief A collection of handlers for an entire hash/checksum group.
      34              :  */
      35            1 : struct fs_mgmt_hash_checksum_group {
      36              :         /** Entry list node. */
      37            1 :         sys_snode_t node;
      38              : 
      39              :         /** Array of handlers; one entry per name. */
      40            1 :         const char *group_name;
      41              : 
      42              :         /** Byte string or numerical output. */
      43            1 :         bool byte_string;
      44              : 
      45              :         /** Size (in bytes) of output. */
      46            1 :         uint8_t output_size;
      47              : 
      48              :         /** Hash/checksum function pointer. */
      49            1 :         fs_mgmt_hash_checksum_handler_fn function;
      50              : };
      51              : 
      52              : /** @typedef fs_mgmt_hash_checksum_list_cb
      53              :  * @brief Function that gets called with hash/checksum details
      54              :  *
      55              :  * @param group         Details about a supported hash/checksum
      56              :  * @param user_data     User-supplied value to calling function
      57              :  */
      58            1 : typedef void (*fs_mgmt_hash_checksum_list_cb)(const struct fs_mgmt_hash_checksum_group *group,
      59              :                                               void *user_data);
      60              : 
      61              : /**
      62              :  * @brief Registers a full hash/checksum group.
      63              :  *
      64              :  * @param group The group to register.
      65              :  */
      66            1 : void fs_mgmt_hash_checksum_register_group(struct fs_mgmt_hash_checksum_group *group);
      67              : 
      68              : /**
      69              :  * @brief Unregisters a full hash/checksum group.
      70              :  *
      71              :  * @param group The group to register.
      72              :  */
      73            1 : void fs_mgmt_hash_checksum_unregister_group(struct fs_mgmt_hash_checksum_group *group);
      74              : 
      75              : /**
      76              :  * @brief Finds a registered hash/checksum handler.
      77              :  *
      78              :  * @param name  The name of the hash/checksum group to find.
      79              :  *
      80              :  * @return      The requested hash/checksum handler on success;
      81              :  *              NULL on failure.
      82              :  */
      83            1 : const struct fs_mgmt_hash_checksum_group *fs_mgmt_hash_checksum_find_handler(const char *name);
      84              : 
      85              : /**
      86              :  * @brief Runs a callback with all supported hash/checksum types.
      87              :  *
      88              :  * @param cb            The callback function to call with each hash/checksum type.
      89              :  * @param user_data     Data to pass back with the callback function.
      90              :  */
      91            1 : void fs_mgmt_hash_checksum_find_handlers(fs_mgmt_hash_checksum_list_cb cb, void *user_data);
      92              : 
      93              : #ifdef __cplusplus
      94              : }
      95              : #endif
      96              : 
      97              : #endif /* ifndef H_MGMT_MCUMGR_GRP_FS_MGMT_CHKSUM_ */