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

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 <[email protected]>

Author: nordicjm

include/zephyr/mgmt/mcumgr/grp/fs_mgmt/fs_mgmt_chksum.h renamed to include/zephyr/mgmt/mcumgr/grp/fs_mgmt/fs_mgmt_hash_checksum.h

@@ -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,15 +80,15 @@ 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.
  *
  * @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
 }

subsys/mgmt/mcumgr/grp/fs_mgmt/CMakeLists.txt

@@ -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)

subsys/mgmt/mcumgr/grp/fs_mgmt/include/mgmt/mcumgr/grp/fs_mgmt/hash_checksum_crc32.h renamed to subsys/mgmt/mcumgr/grp/fs_mgmt/include/mgmt/mcumgr/grp/fs_mgmt/fs_mgmt_hash_checksum_crc32.h

@@ -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
 }

subsys/mgmt/mcumgr/grp/fs_mgmt/include/mgmt/mcumgr/grp/fs_mgmt/hash_checksum_sha256.h renamed to subsys/mgmt/mcumgr/grp/fs_mgmt/include/mgmt/mcumgr/grp/fs_mgmt/fs_mgmt_hash_checksum_sha256.h

@@ -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
 }

subsys/mgmt/mcumgr/grp/fs_mgmt/src/fs_mgmt.c

@@ -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,15 +618,15 @@ 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,
 	};
 
 	itr_ctx.ok = zcbor_tstr_put_lit(zse, "types");
 
 	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
 }

subsys/mgmt/mcumgr/grp/fs_mgmt/src/fs_mgmt_hash_checksum.c

@@ -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);
+	}
+}

subsys/mgmt/mcumgr/grp/fs_mgmt/src/hash_checksum_crc32.c renamed to subsys/mgmt/mcumgr/grp/fs_mgmt/src/fs_mgmt_hash_checksum_crc32.c

@@ -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);
 }

subsys/mgmt/mcumgr/grp/fs_mgmt/src/hash_checksum_sha256.c renamed to subsys/mgmt/mcumgr/grp/fs_mgmt/src/fs_mgmt_hash_checksum_sha256.c

@@ -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 @@ static int fs_hash_checksum_mgmt_sha256(struct fs_file_t *file, uint8_t *output,
 }
 #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);
 }