michaelh/zephyr
1
0
Fork 0
Code Releases Activity

mgmt: mcumgr: Add fs_mgmt prefix to hash/checksum functions/files

Browse source 
This aligns the naming of files in fs_mgmt so that files and
functions relating to hash/checksum are prefixed with fs_mgmt.

Signed-off-by: Jamie McCrae <jamie.mccrae@nordicsemi.no>
This commit is contained in:
Jamie McCrae 2022-11-21 08:20:07 +00:00 • committed by Stephanos Ioannidis
commit cbd0d2d55a
9 changed files with 107 additions and 106 deletions
Download patch file Download diff file Expand all files Collapse all files

25
include/zephyr/mgmt/mcumgr/grp/fs_mgmt/fs_mgmt_chksum.h → include/zephyr/mgmt/mcumgr/grp/fs_mgmt/fs_mgmt_hash_checksum.h
View file

@ -16,7 +16,7 @@
extern "C" {
#endif
/** @typedef hash_checksum_mgmt_handler_fn
/** @typedef fs_mgmt_hash_checksum_handler_fn
* @brief Function that gets called to generate a hash or checksum.
*
* @param file Opened file context
@ -26,14 +26,13 @@ extern "C" {
*
* @return 0 on success, negative error code on failure.
*/
typedef int (*hash_checksum_mgmt_handler_fn)(struct fs_file_t *file,
uint8_t *output, size_t *out_len,
size_t len);
typedef int (*fs_mgmt_hash_checksum_handler_fn)(struct fs_file_t *file, uint8_t *output,
size_t *out_len, size_t len);
/**
* @brief A collection of handlers for an entire hash/checksum group.
*/
struct hash_checksum_mgmt_group {
struct fs_mgmt_hash_checksum_group {
/** Entry list node. */
sys_snode_t node;
@ -47,31 +46,31 @@ struct hash_checksum_mgmt_group {
uint8_t output_size;
/** Hash/checksum function pointer. */
hash_checksum_mgmt_handler_fn function;
fs_mgmt_hash_checksum_handler_fn function;
};
/** @typedef hash_checksum_mgmt_list_cb
/** @typedef fs_mgmt_hash_checksum_list_cb
* @brief Function that gets called with hash/checksum details
*
* @param group Details about a supported hash/checksum
* @param user_data User-supplied value to calling function
*/
typedef void (*hash_checksum_mgmt_list_cb)(const struct hash_checksum_mgmt_group *group,
void *user_data);
typedef void (*fs_mgmt_hash_checksum_list_cb)(const struct fs_mgmt_hash_checksum_group *group,
void *user_data);
/**
* @brief Registers a full hash/checksum group.
*
* @param group The group to register.
*/
void hash_checksum_mgmt_register_group(struct hash_checksum_mgmt_group *group);
void fs_mgmt_hash_checksum_register_group(struct fs_mgmt_hash_checksum_group *group);
/**
* @brief Unregisters a full hash/checksum group.
*
* @param group The group to register.
*/
void hash_checksum_mgmt_unregister_group(struct hash_checksum_mgmt_group *group);
void fs_mgmt_hash_checksum_unregister_group(struct fs_mgmt_hash_checksum_group *group);
/**
* @brief Finds a registered hash/checksum handler.
@ -81,7 +80,7 @@ void hash_checksum_mgmt_unregister_group(struct hash_checksum_mgmt_group *group)
* @return The requested hash/checksum handler on success;
* NULL on failure.
*/
const struct hash_checksum_mgmt_group *hash_checksum_mgmt_find_handler(const char *name);
const struct fs_mgmt_hash_checksum_group *fs_mgmt_hash_checksum_find_handler(const char *name);
/**
* @brief Runs a callback with all supported hash/checksum types.
@ -89,7 +88,7 @@ const struct hash_checksum_mgmt_group *hash_checksum_mgmt_find_handler(const cha
* @param cb The callback function to call with each hash/checksum type.
* @param user_data Data to pass back with the callback function.
*/
void hash_checksum_mgmt_find_handlers(hash_checksum_mgmt_list_cb cb, void *user_data);
void fs_mgmt_hash_checksum_find_handlers(fs_mgmt_hash_checksum_list_cb cb, void *user_data);
#ifdef __cplusplus
}

6
subsys/mgmt/mcumgr/grp/fs_mgmt/CMakeLists.txt
View file

@ -11,13 +11,13 @@
add_library(mgmt_mcumgr_grp_fs src/fs_mgmt.c)
target_sources_ifdef(CONFIG_FS_MGMT_CHECKSUM_HASH
mgmt_mcumgr_grp_fs PRIVATE src/hash_checksum_mgmt.c
mgmt_mcumgr_grp_fs PRIVATE src/fs_mgmt_hash_checksum.c
)
target_sources_ifdef(CONFIG_FS_MGMT_CHECKSUM_IEEE_CRC32
mgmt_mcumgr_grp_fs PRIVATE src/hash_checksum_crc32.c
mgmt_mcumgr_grp_fs PRIVATE src/fs_mgmt_hash_checksum_crc32.c
)
target_sources_ifdef(CONFIG_FS_MGMT_HASH_SHA256
mgmt_mcumgr_grp_fs PRIVATE src/hash_checksum_sha256.c)
mgmt_mcumgr_grp_fs PRIVATE src/fs_mgmt_hash_checksum_sha256.c)
if (CONFIG_FS_MGMT_CHECKSUM_HASH AND CONFIG_FS_MGMT_HASH_SHA256)
if (NOT CONFIG_TINYCRYPT)

4
subsys/mgmt/mcumgr/grp/fs_mgmt/include/mgmt/mcumgr/grp/fs_mgmt/hash_checksum_crc32.h → subsys/mgmt/mcumgr/grp/fs_mgmt/include/mgmt/mcumgr/grp/fs_mgmt/fs_mgmt_hash_checksum_crc32.h
View file

@ -16,12 +16,12 @@ extern "C" {
/**
* @brief Registers the IEEE CRC32 checksum mcumgr handler.
*/
void fs_hash_checksum_mgmt_register_crc32(void);
void fs_mgmt_hash_checksum_register_crc32(void);
/**
* @brief Un-registers the IEEE CRC32 checksum mcumgr handler.
*/
void fs_hash_checksum_mgmt_unregister_crc32(void);
void fs_mgmt_hash_checksum_unregister_crc32(void);
#ifdef __cplusplus
}

4
subsys/mgmt/mcumgr/grp/fs_mgmt/include/mgmt/mcumgr/grp/fs_mgmt/hash_checksum_sha256.h → subsys/mgmt/mcumgr/grp/fs_mgmt/include/mgmt/mcumgr/grp/fs_mgmt/fs_mgmt_hash_checksum_sha256.h
View file

@ -16,12 +16,12 @@ extern "C" {
/**
* @brief Registers the SHA256 hash mcumgr handler.
*/
void fs_hash_checksum_mgmt_register_sha256(void);
void fs_mgmt_hash_checksum_register_sha256(void);
/**
* @brief Un-registers the SHA256 hash mcumgr handler.
*/
void fs_hash_checksum_mgmt_unregister_sha256(void);
void fs_mgmt_hash_checksum_unregister_sha256(void);
#ifdef __cplusplus
}

28
subsys/mgmt/mcumgr/grp/fs_mgmt/src/fs_mgmt.c
View file

@ -12,7 +12,7 @@
#include <zephyr/mgmt/mcumgr/mgmt/mgmt.h>
#include <zephyr/mgmt/mcumgr/smp/smp.h>
#include <zephyr/mgmt/mcumgr/grp/fs_mgmt/fs_mgmt.h>
#include <zephyr/mgmt/mcumgr/grp/fs_mgmt/fs_mgmt_chksum.h>
#include <zephyr/mgmt/mcumgr/grp/fs_mgmt/fs_mgmt_hash_checksum.h>
#include <assert.h>
#include <limits.h>
#include <string.h>
@ -25,11 +25,11 @@
#include <mgmt/mcumgr/grp/fs_mgmt/fs_mgmt_config.h>
#if defined(CONFIG_FS_MGMT_CHECKSUM_IEEE_CRC32)
#include <mgmt/mcumgr/grp/fs_mgmt/hash_checksum_crc32.h>
#include <mgmt/mcumgr/grp/fs_mgmt/fs_mgmt_hash_checksum_crc32.h>
#endif
#if defined(CONFIG_FS_MGMT_HASH_SHA256)
#include <mgmt/mcumgr/grp/fs_mgmt/hash_checksum_sha256.h>
#include <mgmt/mcumgr/grp/fs_mgmt/fs_mgmt_hash_checksum_sha256.h>
#endif
#if defined(CONFIG_MCUMGR_MGMT_NOTIFICATION_HOOKS)
@ -77,7 +77,7 @@ static const struct mgmt_handler fs_mgmt_handlers[];
#if defined(CONFIG_FS_MGMT_CHECKSUM_HASH)
/* Hash/checksum iterator information passing structure */
struct hash_checksum_iterator_info {
struct fs_mgmt_hash_checksum_iterator_info {
zcbor_state_t *zse;
bool ok;
};
@ -464,7 +464,7 @@ static int fs_mgmt_file_hash_checksum(struct smp_streamer *ctxt)
struct zcbor_string name = { 0 };
size_t decoded;
struct fs_file_t file;
const struct hash_checksum_mgmt_group *group = NULL;
const struct fs_mgmt_hash_checksum_group *group = NULL;
struct zcbor_map_decode_key_val fs_hash_checksum_decode[] = {
ZCBOR_MAP_DECODE_KEY_VAL(type, zcbor_tstr_decode, &type),
@ -491,7 +491,7 @@ static int fs_mgmt_file_hash_checksum(struct smp_streamer *ctxt)
}
/* Search for supported hash/checksum */
group = hash_checksum_mgmt_find_handler(type_arr);
group = fs_mgmt_hash_checksum_find_handler(type_arr);
if (group == NULL) {
return MGMT_ERR_EINVAL;
@ -591,10 +591,12 @@ static int fs_mgmt_file_hash_checksum(struct smp_streamer *ctxt)
#if defined(CONFIG_MCUMGR_GRP_FS_CHECKSUM_HASH_SUPPORTED_CMD)
/* Callback for supported hash/checksum types to encode details on one type into CBOR map */
static void supported_hash_checksum_callback(const struct hash_checksum_mgmt_group *group,
void *user_data)
static void fs_mgmt_supported_hash_checksum_callback(
const struct fs_mgmt_hash_checksum_group *group,
void *user_data)
{
struct hash_checksum_iterator_info *ctx = (struct hash_checksum_iterator_info *)user_data;
struct fs_mgmt_hash_checksum_iterator_info *ctx =
(struct fs_mgmt_hash_checksum_iterator_info *)user_data;
if (!ctx->ok) {
return;
@ -616,7 +618,7 @@ static int
fs_mgmt_supported_hash_checksum(struct smp_streamer *ctxt)
{
zcbor_state_t *zse = ctxt->writer->zs;
struct hash_checksum_iterator_info itr_ctx = {
struct fs_mgmt_hash_checksum_iterator_info itr_ctx = {
.zse = zse,
};
@ -624,7 +626,7 @@ fs_mgmt_supported_hash_checksum(struct smp_streamer *ctxt)
zcbor_map_start_encode(zse, CONFIG_MCUMGR_GRP_FS_CHECKSUM_HASH_SUPPORTED_MAX_TYPES);
hash_checksum_mgmt_find_handlers(supported_hash_checksum_callback, &itr_ctx);
fs_mgmt_hash_checksum_find_handlers(fs_mgmt_supported_hash_checksum_callback, &itr_ctx);
if (!itr_ctx.ok ||
!zcbor_map_end_encode(zse, CONFIG_MCUMGR_GRP_FS_CHECKSUM_HASH_SUPPORTED_MAX_TYPES)) {
@ -676,11 +678,11 @@ void fs_mgmt_register_group(void)
#if defined(CONFIG_FS_MGMT_CHECKSUM_HASH)
/* Register any supported hash or checksum functions */
#if defined(CONFIG_FS_MGMT_CHECKSUM_IEEE_CRC32)
fs_hash_checksum_mgmt_register_crc32();
fs_mgmt_hash_checksum_register_crc32();
#endif
#if defined(CONFIG_FS_MGMT_HASH_SHA256)
fs_hash_checksum_mgmt_register_sha256();
fs_mgmt_hash_checksum_register_sha256();
#endif
#endif
}

54
subsys/mgmt/mcumgr/grp/fs_mgmt/src/fs_mgmt_hash_checksum.c Normal file
View file

@ -0,0 +1,54 @@
/*
* Copyright (c) 2022 Laird Connectivity
* Copyright (c) 2022 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr/kernel.h>
#include <string.h>
#include <zephyr/mgmt/mcumgr/grp/fs_mgmt/fs_mgmt_hash_checksum.h>
static sys_slist_t fs_mgmt_hash_checksum_group_list =
SYS_SLIST_STATIC_INIT(&fs_mgmt_hash_checksum_group_list);
void fs_mgmt_hash_checksum_unregister_group(struct fs_mgmt_hash_checksum_group *group)
{
(void)sys_slist_find_and_remove(&fs_mgmt_hash_checksum_group_list, &group->node);
}
void fs_mgmt_hash_checksum_register_group(struct fs_mgmt_hash_checksum_group *group)
{
sys_slist_append(&fs_mgmt_hash_checksum_group_list, &group->node);
}
const struct fs_mgmt_hash_checksum_group *fs_mgmt_hash_checksum_find_handler(const char *name)
{
/* Find the group with the specified group name */
struct fs_mgmt_hash_checksum_group *group = NULL;
sys_snode_t *snp, *sns;
SYS_SLIST_FOR_EACH_NODE_SAFE(&fs_mgmt_hash_checksum_group_list, snp, sns) {
struct fs_mgmt_hash_checksum_group *loop_group =
CONTAINER_OF(snp, struct fs_mgmt_hash_checksum_group, node);
if (strcmp(loop_group->group_name, name) == 0) {
group = loop_group;
break;
}
}
return group;
}
void fs_mgmt_hash_checksum_find_handlers(fs_mgmt_hash_checksum_list_cb cb, void *user_data)
{
/* Run a callback with all supported hash/checksums */
sys_snode_t *snp, *sns;
SYS_SLIST_FOR_EACH_NODE_SAFE(&fs_mgmt_hash_checksum_group_list, snp, sns) {
struct fs_mgmt_hash_checksum_group *group =
CONTAINER_OF(snp, struct fs_mgmt_hash_checksum_group, node);
cb(group, user_data);
}
}

18
subsys/mgmt/mcumgr/grp/fs_mgmt/src/hash_checksum_crc32.c → subsys/mgmt/mcumgr/grp/fs_mgmt/src/fs_mgmt_hash_checksum_crc32.c
View file

@ -8,15 +8,15 @@
#include <zephyr/sys/crc.h>
#include <zephyr/fs/fs.h>
#include <zephyr/mgmt/mcumgr/mgmt/mgmt.h>
#include <zephyr/mgmt/mcumgr/grp/fs_mgmt/fs_mgmt_chksum.h>
#include <zephyr/mgmt/mcumgr/grp/fs_mgmt/fs_mgmt_hash_checksum.h>
#include <string.h>
#include <mgmt/mcumgr/grp/fs_mgmt/fs_mgmt_config.h>
#include <mgmt/mcumgr/grp/fs_mgmt/hash_checksum_crc32.h>
#include <mgmt/mcumgr/grp/fs_mgmt/fs_mgmt_hash_checksum_crc32.h>
#define CRC32_SIZE 4
static int fs_hash_checksum_mgmt_crc32(struct fs_file_t *file, uint8_t *output,
static int fs_mgmt_hash_checksum_crc32(struct fs_file_t *file, uint8_t *output,
size_t *out_len, size_t len)
{
/* Calculate IEEE CRC32 checksum of target file */
@ -50,19 +50,19 @@ static int fs_hash_checksum_mgmt_crc32(struct fs_file_t *file, uint8_t *output,
return 0;
}
struct hash_checksum_mgmt_group crc32 = {
static struct fs_mgmt_hash_checksum_group crc32 = {
.group_name = "crc32",
.byte_string = false,
.output_size = CRC32_SIZE,
.function = fs_hash_checksum_mgmt_crc32,
.function = fs_mgmt_hash_checksum_crc32,
};
void fs_hash_checksum_mgmt_register_crc32(void)
void fs_mgmt_hash_checksum_register_crc32(void)
{
hash_checksum_mgmt_register_group(&crc32);
fs_mgmt_hash_checksum_register_group(&crc32);
}
void fs_hash_checksum_mgmt_unregister_crc32(void)
void fs_mgmt_hash_checksum_unregister_crc32(void)
{
hash_checksum_mgmt_unregister_group(&crc32);
fs_mgmt_hash_checksum_unregister_group(&crc32);
}

20
subsys/mgmt/mcumgr/grp/fs_mgmt/src/hash_checksum_sha256.c → subsys/mgmt/mcumgr/grp/fs_mgmt/src/fs_mgmt_hash_checksum_sha256.c
View file

@ -7,11 +7,11 @@
#include <zephyr/kernel.h>
#include <zephyr/fs/fs.h>
#include <zephyr/mgmt/mcumgr/mgmt/mgmt.h>
#include <zephyr/mgmt/mcumgr/grp/fs_mgmt/fs_mgmt_chksum.h>
#include <zephyr/mgmt/mcumgr/grp/fs_mgmt/fs_mgmt_hash_checksum.h>
#include <string.h>
#include <mgmt/mcumgr/grp/fs_mgmt/fs_mgmt_config.h>
#include <mgmt/mcumgr/grp/fs_mgmt/hash_checksum_sha256.h>
#include <mgmt/mcumgr/grp/fs_mgmt/fs_mgmt_hash_checksum_sha256.h>
#if defined(CONFIG_TINYCRYPT_SHA256)
#include <tinycrypt/constants.h>
@ -25,7 +25,7 @@
#if defined(CONFIG_TINYCRYPT_SHA256)
/* Tinycrypt SHA256 implementation */
static int fs_hash_checksum_mgmt_sha256(struct fs_file_t *file, uint8_t *output,
static int fs_mgmt_hash_checksum_sha256(struct fs_file_t *file, uint8_t *output,
size_t *out_len, size_t len)
{
int rc = 0;
@ -72,7 +72,7 @@ static int fs_hash_checksum_mgmt_sha256(struct fs_file_t *file, uint8_t *output,
}
#else
/* mbedtls SHA256 implementation */
static int fs_hash_checksum_mgmt_sha256(struct fs_file_t *file, uint8_t *output,
static int fs_mgmt_hash_checksum_sha256(struct fs_file_t *file, uint8_t *output,
size_t *out_len, size_t len)
{
int rc = 0;
@ -133,19 +133,19 @@ error:
}
#endif
struct hash_checksum_mgmt_group sha256 = {
static struct fs_mgmt_hash_checksum_group sha256 = {
.group_name = "sha256",
.byte_string = true,
.output_size = SHA256_DIGEST_SIZE,
.function = fs_hash_checksum_mgmt_sha256,
.function = fs_mgmt_hash_checksum_sha256,
};
void fs_hash_checksum_mgmt_register_sha256(void)
void fs_mgmt_hash_checksum_register_sha256(void)
{
hash_checksum_mgmt_register_group(&sha256);
fs_mgmt_hash_checksum_register_group(&sha256);
}
void fs_hash_checksum_mgmt_unregister_sha256(void)
void fs_mgmt_hash_checksum_unregister_sha256(void)
{
hash_checksum_mgmt_unregister_group(&sha256);
fs_mgmt_hash_checksum_unregister_group(&sha256);
}

54
subsys/mgmt/mcumgr/grp/fs_mgmt/src/hash_checksum_mgmt.c
View file

@ -1,54 +0,0 @@
/*
* Copyright (c) 2022 Laird Connectivity
* Copyright (c) 2022 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr/kernel.h>
#include <string.h>
#include <zephyr/mgmt/mcumgr/grp/fs_mgmt/fs_mgmt_chksum.h>
static sys_slist_t hash_checksum_mgmt_group_list =
SYS_SLIST_STATIC_INIT(&hash_checksum_mgmt_group_list);
void hash_checksum_mgmt_unregister_group(struct hash_checksum_mgmt_group *group)
{
(void)sys_slist_find_and_remove(&hash_checksum_mgmt_group_list, &group->node);
}
void hash_checksum_mgmt_register_group(struct hash_checksum_mgmt_group *group)
{
sys_slist_append(&hash_checksum_mgmt_group_list, &group->node);
}
const struct hash_checksum_mgmt_group *hash_checksum_mgmt_find_handler(const char *name)
{
/* Find the group with the specified group name */
struct hash_checksum_mgmt_group *group = NULL;
sys_snode_t *snp, *sns;
SYS_SLIST_FOR_EACH_NODE_SAFE(&hash_checksum_mgmt_group_list, snp, sns) {
struct hash_checksum_mgmt_group *loop_group =
CONTAINER_OF(snp, struct hash_checksum_mgmt_group, node);
if (strcmp(loop_group->group_name, name) == 0) {
group = loop_group;
break;
}
}
return group;
}
void hash_checksum_mgmt_find_handlers(hash_checksum_mgmt_list_cb cb, void *user_data)
{
/* Run a callback with all supported hash/checksums */
sys_snode_t *snp, *sns;
SYS_SLIST_FOR_EACH_NODE_SAFE(&hash_checksum_mgmt_group_list, snp, sns) {
struct hash_checksum_mgmt_group *group =
CONTAINER_OF(snp, struct hash_checksum_mgmt_group, node);
cb(group, user_data);
}
}