michaelh/zephyr
1
0
Fork 0
Code Releases Activity

treewide: mgmt: mcumgr: Change "ret" to "err" for SMP version 2

Browse source 
This is a stable API treewide change changing the newly introduced
"ret" response to "err" as it was overlooked that the shell_mgmt
group already used "ret" to return the exit code of the command
and this created a collision. Since SMP version 2 was only recently
introduced, there should not be any public implementations of it
as of yet, but the original function has been kept and marked as
deprecated.

Signed-off-by: Jamie McCrae <jamie.mccrae@nordicsemi.no>
This commit is contained in:
Jamie McCrae 2023-07-31 11:14:59 +01:00 • committed by Carles Cufí
commit 5c88d45544
23 changed files with 425 additions and 426 deletions
Download patch file Download diff file Expand all files Collapse all files

12
doc/services/device_mgmt/mcumgr_callbacks.rst
View file

@ -193,7 +193,7 @@ Two types of errors can be returned, the ``rc`` parameter can be set to an
:c:enumerator:`mcumgr_err_t` error code and :c:enumerator:`MGMT_CB_ERROR_RC` :c:enumerator:`mcumgr_err_t` error code and :c:enumerator:`MGMT_CB_ERROR_RC`
can be returned, or a group error code (introduced with version 2 of the MCUmgr can be returned, or a group error code (introduced with version 2 of the MCUmgr
protocol) can be set by setting the ``group`` value to the group and ``rc`` protocol) can be set by setting the ``group`` value to the group and ``rc``
value to the group error code and returning :c:enumerator:`MGMT_CB_ERROR_RET`. value to the group error code and returning :c:enumerator:`MGMT_CB_ERROR_ERR`.
MCUmgr Command Callback Usage/Adding New Event Types MCUmgr Command Callback Usage/Adding New Event Types
==================================================== ====================================================
@ -234,8 +234,8 @@ An example MCUmgr command handler:
static int test_command(struct mgmt_ctxt *ctxt) static int test_command(struct mgmt_ctxt *ctxt)
{ {
int rc; int rc;
int ret_rc; int err_rc;
uint16_t ret_group; uint16_t err_group;
zcbor_state_t *zse = ctxt->cnbe->zs; zcbor_state_t *zse = ctxt->cnbe->zs;
bool ok; bool ok;
struct test_struct test_data = { struct test_struct test_data = {
@ -243,17 +243,17 @@ An example MCUmgr command handler:
}; };
rc = mgmt_callback_notify(MGMT_EVT_OP_USER_ONE_FIRST, &test_data, rc = mgmt_callback_notify(MGMT_EVT_OP_USER_ONE_FIRST, &test_data,
sizeof(test_data), &ret_rc, &ret_group); sizeof(test_data), &err_rc, &err_group);
if (rc != MGMT_CB_OK) { if (rc != MGMT_CB_OK) {
/* A handler returned a failure code */ /* A handler returned a failure code */
if (rc == MGMT_CB_ERROR_RC) { if (rc == MGMT_CB_ERROR_RC) {
/* The failure code is the RC value */ /* The failure code is the RC value */
return ret_rc; return err_rc;
} }
/* The failure is a group and ID error value */ /* The failure is a group and ID error value */
ok = smp_add_cmd_ret(zse, ret_group, (uint16_t)ret_rc); ok = smp_add_cmd_err(zse, err_group, (uint16_t)err_rc);
goto end; goto end;
} }

30
include/zephyr/mgmt/mcumgr/grp/fs_mgmt/fs_mgmt.h
View file

@ -25,39 +25,39 @@ extern "C" {
/** /**
* Command result codes for file system management group. * Command result codes for file system management group.
*/ */
enum fs_mgmt_ret_code_t { enum fs_mgmt_err_code_t {
/** No error, this is implied if there is no ret value in the response */ /** No error, this is implied if there is no ret value in the response */
FS_MGMT_RET_RC_OK = 0, FS_MGMT_ERR_OK = 0,
/** Unknown error occurred. */ /** Unknown error occurred. */
FS_MGMT_RET_RC_UNKNOWN, FS_MGMT_ERR_UNKNOWN,
/** The specified file name is not valid. */ /** The specified file name is not valid. */
FS_MGMT_RET_RC_FILE_INVALID_NAME, FS_MGMT_ERR_FILE_INVALID_NAME,
/** The specified file does not exist. */ /** The specified file does not exist. */
FS_MGMT_RET_RC_FILE_NOT_FOUND, FS_MGMT_ERR_FILE_NOT_FOUND,
/** The specified file is a directory, not a file. */ /** The specified file is a directory, not a file. */
FS_MGMT_RET_RC_FILE_IS_DIRECTORY, FS_MGMT_ERR_FILE_IS_DIRECTORY,
/** Error occurred whilst attempting to open a file. */ /** Error occurred whilst attempting to open a file. */
FS_MGMT_RET_RC_FILE_OPEN_FAILED, FS_MGMT_ERR_FILE_OPEN_FAILED,
/** Error occurred whilst attempting to seek to an offset in a file. */ /** Error occurred whilst attempting to seek to an offset in a file. */
FS_MGMT_RET_RC_FILE_SEEK_FAILED, FS_MGMT_ERR_FILE_SEEK_FAILED,
/** Error occurred whilst attempting to read data from a file. */ /** Error occurred whilst attempting to read data from a file. */
FS_MGMT_RET_RC_FILE_READ_FAILED, FS_MGMT_ERR_FILE_READ_FAILED,
/** Error occurred whilst trying to truncate file. */ /** Error occurred whilst trying to truncate file. */
FS_MGMT_RET_RC_FILE_TRUNCATE_FAILED, FS_MGMT_ERR_FILE_TRUNCATE_FAILED,
/** Error occurred whilst trying to delete file. */ /** Error occurred whilst trying to delete file. */
FS_MGMT_RET_RC_FILE_DELETE_FAILED, FS_MGMT_ERR_FILE_DELETE_FAILED,
/** Error occurred whilst attempting to write data to a file. */ /** Error occurred whilst attempting to write data to a file. */
FS_MGMT_RET_RC_FILE_WRITE_FAILED, FS_MGMT_ERR_FILE_WRITE_FAILED,
/** /**
* The specified data offset is not valid, this could indicate that the file on the device * The specified data offset is not valid, this could indicate that the file on the device
@ -66,13 +66,13 @@ enum fs_mgmt_ret_code_t {
* hash of the file could be requested and compared with the hash of the length of the * hash of the file could be requested and compared with the hash of the length of the
* file being uploaded to see if they match or not). * file being uploaded to see if they match or not).
*/ */
FS_MGMT_RET_RC_FILE_OFFSET_NOT_VALID, FS_MGMT_ERR_FILE_OFFSET_NOT_VALID,
/** The requested offset is larger than the size of the file on the device. */ /** The requested offset is larger than the size of the file on the device. */
FS_MGMT_RET_RC_FILE_OFFSET_LARGER_THAN_FILE, FS_MGMT_ERR_FILE_OFFSET_LARGER_THAN_FILE,
/** The requested checksum or hash type was not found or is not supported by this build. */ /** The requested checksum or hash type was not found or is not supported by this build. */
FS_MGMT_RET_RC_CHECKSUM_HASH_NOT_FOUND, FS_MGMT_ERR_CHECKSUM_HASH_NOT_FOUND,
}; };
#ifdef __cplusplus #ifdef __cplusplus

66
include/zephyr/mgmt/mcumgr/grp/img_mgmt/img_mgmt.h
View file

@ -60,102 +60,102 @@ extern "C" {
/** /**
* Command result codes for image management group. * Command result codes for image management group.
*/ */
enum img_mgmt_ret_code_t { enum img_mgmt_err_code_t {
/** No error, this is implied if there is no ret value in the response */ /** No error, this is implied if there is no ret value in the response */
IMG_MGMT_RET_RC_OK = 0, IMG_MGMT_ERR_OK = 0,
/** Unknown error occurred. */ /** Unknown error occurred. */
IMG_MGMT_RET_RC_UNKNOWN, IMG_MGMT_ERR_UNKNOWN,
/** Failed to query flash area configuration. */ /** Failed to query flash area configuration. */
IMG_MGMT_RET_RC_FLASH_CONFIG_QUERY_FAIL, IMG_MGMT_ERR_FLASH_CONFIG_QUERY_FAIL,
/** There is no image in the slot. */ /** There is no image in the slot. */
IMG_MGMT_RET_RC_NO_IMAGE, IMG_MGMT_ERR_NO_IMAGE,
/** The image in the slot has no TLVs (tag, length, value). */ /** The image in the slot has no TLVs (tag, length, value). */
IMG_MGMT_RET_RC_NO_TLVS, IMG_MGMT_ERR_NO_TLVS,
/** The image in the slot has an invalid TLV type and/or length. */ /** The image in the slot has an invalid TLV type and/or length. */
IMG_MGMT_RET_RC_INVALID_TLV, IMG_MGMT_ERR_INVALID_TLV,
/** The image in the slot has multiple hash TLVs, which is invalid. */ /** The image in the slot has multiple hash TLVs, which is invalid. */
IMG_MGMT_RET_RC_TLV_MULTIPLE_HASHES_FOUND, IMG_MGMT_ERR_TLV_MULTIPLE_HASHES_FOUND,
/** The image in the slot has an invalid TLV size. */ /** The image in the slot has an invalid TLV size. */
IMG_MGMT_RET_RC_TLV_INVALID_SIZE, IMG_MGMT_ERR_TLV_INVALID_SIZE,
/** The image in the slot does not have a hash TLV, which is required. */ /** The image in the slot does not have a hash TLV, which is required. */
IMG_MGMT_RET_RC_HASH_NOT_FOUND, IMG_MGMT_ERR_HASH_NOT_FOUND,
/** There is no free slot to place the image. */ /** There is no free slot to place the image. */
IMG_MGMT_RET_RC_NO_FREE_SLOT, IMG_MGMT_ERR_NO_FREE_SLOT,
/** Flash area opening failed. */ /** Flash area opening failed. */
IMG_MGMT_RET_RC_FLASH_OPEN_FAILED, IMG_MGMT_ERR_FLASH_OPEN_FAILED,
/** Flash area reading failed. */ /** Flash area reading failed. */
IMG_MGMT_RET_RC_FLASH_READ_FAILED, IMG_MGMT_ERR_FLASH_READ_FAILED,
/** Flash area writing failed. */ /** Flash area writing failed. */
IMG_MGMT_RET_RC_FLASH_WRITE_FAILED, IMG_MGMT_ERR_FLASH_WRITE_FAILED,
/** Flash area erase failed. */ /** Flash area erase failed. */
IMG_MGMT_RET_RC_FLASH_ERASE_FAILED, IMG_MGMT_ERR_FLASH_ERASE_FAILED,
/** The provided slot is not valid. */ /** The provided slot is not valid. */
IMG_MGMT_RET_RC_INVALID_SLOT, IMG_MGMT_ERR_INVALID_SLOT,
/** Insufficient heap memory (malloc failed). */ /** Insufficient heap memory (malloc failed). */
IMG_MGMT_RET_RC_NO_FREE_MEMORY, IMG_MGMT_ERR_NO_FREE_MEMORY,
/** The flash context is already set. */ /** The flash context is already set. */
IMG_MGMT_RET_RC_FLASH_CONTEXT_ALREADY_SET, IMG_MGMT_ERR_FLASH_CONTEXT_ALREADY_SET,
/** The flash context is not set. */ /** The flash context is not set. */
IMG_MGMT_RET_RC_FLASH_CONTEXT_NOT_SET, IMG_MGMT_ERR_FLASH_CONTEXT_NOT_SET,
/** The device for the flash area is NULL. */ /** The device for the flash area is NULL. */
IMG_MGMT_RET_RC_FLASH_AREA_DEVICE_NULL, IMG_MGMT_ERR_FLASH_AREA_DEVICE_NULL,
/** The offset for a page number is invalid. */ /** The offset for a page number is invalid. */
IMG_MGMT_RET_RC_INVALID_PAGE_OFFSET, IMG_MGMT_ERR_INVALID_PAGE_OFFSET,
/** The offset parameter was not provided and is required. */ /** The offset parameter was not provided and is required. */
IMG_MGMT_RET_RC_INVALID_OFFSET, IMG_MGMT_ERR_INVALID_OFFSET,
/** The length parameter was not provided and is required. */ /** The length parameter was not provided and is required. */
IMG_MGMT_RET_RC_INVALID_LENGTH, IMG_MGMT_ERR_INVALID_LENGTH,
/** The image length is smaller than the size of an image header. */ /** The image length is smaller than the size of an image header. */
IMG_MGMT_RET_RC_INVALID_IMAGE_HEADER, IMG_MGMT_ERR_INVALID_IMAGE_HEADER,
/** The image header magic value does not match the expected value. */ /** The image header magic value does not match the expected value. */
IMG_MGMT_RET_RC_INVALID_IMAGE_HEADER_MAGIC, IMG_MGMT_ERR_INVALID_IMAGE_HEADER_MAGIC,
/** The hash parameter provided is not valid. */ /** The hash parameter provided is not valid. */
IMG_MGMT_RET_RC_INVALID_HASH, IMG_MGMT_ERR_INVALID_HASH,
/** The image load address does not match the address of the flash area. */ /** The image load address does not match the address of the flash area. */
IMG_MGMT_RET_RC_INVALID_FLASH_ADDRESS, IMG_MGMT_ERR_INVALID_FLASH_ADDRESS,
/** Failed to get version of currently running application. */ /** Failed to get version of currently running application. */
IMG_MGMT_RET_RC_VERSION_GET_FAILED, IMG_MGMT_ERR_VERSION_GET_FAILED,
/** The currently running application is newer than the version being uploaded. */ /** The currently running application is newer than the version being uploaded. */
IMG_MGMT_RET_RC_CURRENT_VERSION_IS_NEWER, IMG_MGMT_ERR_CURRENT_VERSION_IS_NEWER,
/** There is already an image operating pending. */ /** There is already an image operating pending. */
IMG_MGMT_RET_RC_IMAGE_ALREADY_PENDING, IMG_MGMT_ERR_IMAGE_ALREADY_PENDING,
/** The image vector table is invalid. */ /** The image vector table is invalid. */
IMG_MGMT_RET_RC_INVALID_IMAGE_VECTOR_TABLE, IMG_MGMT_ERR_INVALID_IMAGE_VECTOR_TABLE,
/** The image it too large to fit. */ /** The image it too large to fit. */
IMG_MGMT_RET_RC_INVALID_IMAGE_TOO_LARGE, IMG_MGMT_ERR_INVALID_IMAGE_TOO_LARGE,
/** The amount of data sent is larger than the provided image size. */ /** The amount of data sent is larger than the provided image size. */
IMG_MGMT_RET_RC_INVALID_IMAGE_DATA_OVERRUN, IMG_MGMT_ERR_INVALID_IMAGE_DATA_OVERRUN,
}; };
/** /**

8
include/zephyr/mgmt/mcumgr/grp/os_mgmt/os_mgmt.h
View file

@ -28,15 +28,15 @@ extern "C" {
/** /**
* Command result codes for OS management group. * Command result codes for OS management group.
*/ */
enum os_mgmt_ret_code_t { enum os_mgmt_err_code_t {
/** No error, this is implied if there is no ret value in the response */ /** No error, this is implied if there is no ret value in the response */
OS_MGMT_RET_RC_OK = 0, OS_MGMT_ERR_OK = 0,
/** Unknown error occurred. */ /** Unknown error occurred. */
OS_MGMT_RET_RC_UNKNOWN, OS_MGMT_ERR_UNKNOWN,
/** The provided format value is not valid. */ /** The provided format value is not valid. */
OS_MGMT_RET_RC_INVALID_FORMAT, OS_MGMT_ERR_INVALID_FORMAT,
}; };
/* Bitmask values used by the os info command handler. Note that the width of this variable is /* Bitmask values used by the os info command handler. Note that the width of this variable is

10
include/zephyr/mgmt/mcumgr/grp/shell_mgmt/shell_mgmt.h
View file

@ -20,18 +20,18 @@ extern "C" {
/** /**
* Command result codes for shell management group. * Command result codes for shell management group.
*/ */
enum shell_mgmt_ret_code_t { enum shell_mgmt_err_code_t {
/** No error, this is implied if there is no ret value in the response */ /** No error, this is implied if there is no ret value in the response */
SHELL_MGMT_RET_RC_OK = 0, SHELL_MGMT_ERR_OK = 0,
/** Unknown error occurred. */ /** Unknown error occurred. */
SHELL_MGMT_RET_RC_UNKNOWN, SHELL_MGMT_ERR_UNKNOWN,
/** The provided command to execute is too long. */ /** The provided command to execute is too long. */
SHELL_MGMT_RET_RC_COMMAND_TOO_LONG, SHELL_MGMT_ERR_COMMAND_TOO_LONG,
/** No command to execute was provided. */ /** No command to execute was provided. */
SHELL_MGMT_RET_RC_EMPTY_COMMAND, SHELL_MGMT_ERR_EMPTY_COMMAND,
}; };
#ifdef __cplusplus #ifdef __cplusplus

14
include/zephyr/mgmt/mcumgr/grp/stat_mgmt/stat_mgmt.h
View file

@ -21,24 +21,24 @@ extern "C" {
/** /**
* Command result codes for statistics management group. * Command result codes for statistics management group.
*/ */
enum stat_mgmt_ret_code_t { enum stat_mgmt_err_code_t {
/** No error, this is implied if there is no ret value in the response */ /** No error, this is implied if there is no ret value in the response */
STAT_MGMT_RET_RC_OK = 0, STAT_MGMT_ERR_OK = 0,
/** Unknown error occurred. */ /** Unknown error occurred. */
STAT_MGMT_RET_RC_UNKNOWN, STAT_MGMT_ERR_UNKNOWN,
/** The provided statistic group name was not found. */ /** The provided statistic group name was not found. */
STAT_MGMT_RET_RC_INVALID_GROUP, STAT_MGMT_ERR_INVALID_GROUP,
/** The provided statistic name was not found. */ /** The provided statistic name was not found. */
STAT_MGMT_RET_RC_INVALID_STAT_NAME, STAT_MGMT_ERR_INVALID_STAT_NAME,
/** The size of the statistic cannot be handled. */ /** The size of the statistic cannot be handled. */
STAT_MGMT_RET_RC_INVALID_STAT_SIZE, STAT_MGMT_ERR_INVALID_STAT_SIZE,
/** Walk through of statistics was aborted. */ /** Walk through of statistics was aborted. */
STAT_MGMT_RET_RC_WALK_ABORTED, STAT_MGMT_ERR_WALK_ABORTED,
}; };
/** /**

12
include/zephyr/mgmt/mcumgr/grp/zephyr/zephyr_basic.h
View file

@ -18,21 +18,21 @@ extern "C" {
/** /**
* Command result codes for statistics management group. * Command result codes for statistics management group.
*/ */
enum zephyr_basic_group_ret_code_t { enum zephyr_basic_group_err_code_t {
/** No error, this is implied if there is no ret value in the response */ /** No error, this is implied if there is no ret value in the response */
ZEPHYR_MGMT_GRP_CMD_RC_OK = 0, ZEPHYRBASIC_MGMT_ERR_OK = 0,
/** Unknown error occurred. */ /** Unknown error occurred. */
ZEPHYR_MGMT_RET_RC_UNKNOWN, ZEPHYRBASIC_MGMT_ERR_UNKNOWN,
/** Opening of the flash area has failed. */ /** Opening of the flash area has failed. */
ZEPHYR_MGMT_GRP_CMD_RC_FLASH_OPEN_FAILED, ZEPHYRBASIC_MGMT_ERR_FLASH_OPEN_FAILED,
/** Querying the flash area parameters has failed. */ /** Querying the flash area parameters has failed. */
ZEPHYR_MGMT_GRP_CMD_RC_FLASH_CONFIG_QUERY_FAIL, ZEPHYRBASIC_MGMT_ERR_FLASH_CONFIG_QUERY_FAIL,
/** Erasing the flash area has failed. */ /** Erasing the flash area has failed. */
ZEPHYR_MGMT_GRP_CMD_RC_FLASH_ERASE_FAILED, ZEPHYRBASIC_MGMT_ERR_FLASH_ERASE_FAILED,
}; };
#ifdef __cplusplus #ifdef __cplusplus

33
include/zephyr/mgmt/mcumgr/mgmt/callbacks.h
View file

@ -58,16 +58,19 @@ enum mgmt_cb_return {
/** No error. */ /** No error. */
MGMT_CB_OK, MGMT_CB_OK,
/** SMP protocol error and ``ret_rc`` contains the #mcumgr_err_t error code. */ /** SMP protocol error and ``err_rc`` contains the #mcumgr_err_t error code. */
MGMT_CB_ERROR_RC, MGMT_CB_ERROR_RC,
/** /**
* Group (application-level) error and ``ret_group`` contains the group ID that caused * Group (application-level) error and ``err_group`` contains the group ID that caused
* the error and ``ret_rc`` contians the error code of that group to return. * the error and ``err_rc`` contians the error code of that group to return.
*/ */
MGMT_CB_ERROR_RET, MGMT_CB_ERROR_ERR,
}; };
/* Deprecated after Zephyr 3.4, use MGMT_CB_ERROR_ERR instead */
#define MGMT_CB_ERROR_RET __DEPRECATED_MACRO MGMT_CB_ERROR_ERR
/** /**
* @typedef mgmt_cb * @typedef mgmt_cb
* @brief Function to be called on MGMT notification/event. * @brief Function to be called on MGMT notification/event.
@ -80,16 +83,16 @@ enum mgmt_cb_return {
* is being called for a notification only, the return code will be ignored). * is being called for a notification only, the return code will be ignored).
* @param rc If ``prev_status`` is #MGMT_CB_ERROR_RC then this is the SMP error that * @param rc If ``prev_status`` is #MGMT_CB_ERROR_RC then this is the SMP error that
* was returned by the first handler that failed. If ``prev_status`` is * was returned by the first handler that failed. If ``prev_status`` is
* #MGMT_CB_ERROR_RET then this will be the group error rc code returned by * #MGMT_CB_ERROR_ERR then this will be the group error rc code returned by
* the first handler that failed. If the handler wishes to raise an SMP * the first handler that failed. If the handler wishes to raise an SMP
* error, this must be set to the #mcumgr_err_t status and #MGMT_CB_ERROR_RC * error, this must be set to the #mcumgr_err_t status and #MGMT_CB_ERROR_RC
* must be returned by the function, if the handler wishes to raise a ret * must be returned by the function, if the handler wishes to raise a ret
* error, this must be set to the group ret status and #MGMT_CB_ERROR_RET * error, this must be set to the group ret status and #MGMT_CB_ERROR_ERR
* must be returned by the function. * must be returned by the function.
* @param group If ``prev_status`` is #MGMT_CB_ERROR_RET then this is the group of the * @param group If ``prev_status`` is #MGMT_CB_ERROR_ERR then this is the group of the
* ret error that was returned by the first handler that failed. If the * ret error that was returned by the first handler that failed. If the
* handler wishes to raise a ret error, this must be set to the group ret * handler wishes to raise a ret error, this must be set to the group ret
* status and #MGMT_CB_ERROR_RET must be returned by the function. * status and #MGMT_CB_ERROR_ERR must be returned by the function.
* @param abort_more Set to true to abort further processing by additional handlers. * @param abort_more Set to true to abort further processing by additional handlers.
* @param data Optional event argument. * @param data Optional event argument.
* @param data_size Size of optional event argument (0 if no data is provided). * @param data_size Size of optional event argument (0 if no data is provided).
@ -249,18 +252,18 @@ uint8_t mgmt_evt_get_index(uint32_t event);
* @param event #mcumgr_op_t. * @param event #mcumgr_op_t.
* @param data Optional event argument. * @param data Optional event argument.
* @param data_size Size of optional event argument (0 if none). * @param data_size Size of optional event argument (0 if none).
* @param ret_rc Pointer to rc value. * @param err_rc Pointer to rc value.
* @param ret_group Pointer to group value. * @param err_group Pointer to group value.
* *
* @return #mgmt_cb_return either #MGMT_CB_OK if all handlers returned it, or * @return #mgmt_cb_return either #MGMT_CB_OK if all handlers returned it, or
* #MGMT_CB_ERROR_RC if the first failed handler returned an SMP error (in * #MGMT_CB_ERROR_RC if the first failed handler returned an SMP error (in
* which case ``ret_rc`` will be updated with the SMP error) or * which case ``err_rc`` will be updated with the SMP error) or
* #MGMT_CB_ERROR_RET if the first failed handler returned a ret group and * #MGMT_CB_ERROR_ERR if the first failed handler returned a ret group and
* error (in which case ``ret_group`` will be updated with the failed group * error (in which case ``err_group`` will be updated with the failed group
* ID and ``ret_rc`` will be updated with the group-specific error code). * ID and ``err_rc`` will be updated with the group-specific error code).
*/ */
enum mgmt_cb_return mgmt_callback_notify(uint32_t event, void *data, size_t data_size, enum mgmt_cb_return mgmt_callback_notify(uint32_t event, void *data, size_t data_size,
int32_t *ret_rc, uint16_t *ret_group); int32_t *err_rc, uint16_t *err_group);
/** /**
* @brief Register event callback function. * @brief Register event callback function.

16
include/zephyr/mgmt/mcumgr/smp/smp.h
View file

@ -107,9 +107,9 @@ struct smp_streamer {
int smp_process_request_packet(struct smp_streamer *streamer, void *req); int smp_process_request_packet(struct smp_streamer *streamer, void *req);
/** /**
* @brief Appends a "ret" response * @brief Appends an "err" response
* *
* This appends a ret response to a pending outgoing response which contains a * This appends an err response to a pending outgoing response which contains a
* result code for a specific group. Note that error codes are specific to the * result code for a specific group. Note that error codes are specific to the
* command group they are emitted from). * command group they are emitted from).
* *
@ -119,17 +119,23 @@ int smp_process_request_packet(struct smp_streamer *streamer, void *req);
* *
* @return true on success, false on failure (memory error). * @return true on success, false on failure (memory error).
*/ */
bool smp_add_cmd_ret(zcbor_state_t *zse, uint16_t group, uint16_t ret); bool smp_add_cmd_err(zcbor_state_t *zse, uint16_t group, uint16_t ret);
/** @deprecated Deprecated after Zephyr 3.4, use smp_add_cmd_err() instead */
__deprecated inline bool smp_add_cmd_ret(zcbor_state_t *zse, uint16_t group, uint16_t ret)
{
return smp_add_cmd_err(zse, group, ret);
}
#if IS_ENABLED(CONFIG_MCUMGR_SMP_SUPPORT_ORIGINAL_PROTOCOL) #if IS_ENABLED(CONFIG_MCUMGR_SMP_SUPPORT_ORIGINAL_PROTOCOL)
/** @typedef smp_translate_error_fn /** @typedef smp_translate_error_fn
* @brief Translates a SMP version 2 error response to a legacy SMP version 1 error code. * @brief Translates a SMP version 2 error response to a legacy SMP version 1 error code.
* *
* @param ret The SMP version 2 error ret/rc value. * @param ret The SMP version 2 group error value.
* *
* @return #enum mcumgr_err_t Legacy SMP version 1 error code to return to client. * @return #enum mcumgr_err_t Legacy SMP version 1 error code to return to client.
*/ */
typedef int (*smp_translate_error_fn)(uint16_t ret); typedef int (*smp_translate_error_fn)(uint16_t err);
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus

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

@ -152,20 +152,20 @@ static int fs_mgmt_filelen(const char *path, size_t *out_len)
rc = fs_stat(path, &dirent); rc = fs_stat(path, &dirent);
if (rc == -EINVAL) { if (rc == -EINVAL) {
return FS_MGMT_RET_RC_FILE_INVALID_NAME; return FS_MGMT_ERR_FILE_INVALID_NAME;
} else if (rc == -ENOENT) { } else if (rc == -ENOENT) {
return FS_MGMT_RET_RC_FILE_NOT_FOUND; return FS_MGMT_ERR_FILE_NOT_FOUND;
} else if (rc != 0) { } else if (rc != 0) {
return FS_MGMT_RET_RC_UNKNOWN; return FS_MGMT_ERR_UNKNOWN;
} }
if (dirent.type != FS_DIR_ENTRY_FILE) { if (dirent.type != FS_DIR_ENTRY_FILE) {
return FS_MGMT_RET_RC_FILE_IS_DIRECTORY; return FS_MGMT_ERR_FILE_IS_DIRECTORY;
} }
*out_len = dirent.size; *out_len = dirent.size;
return FS_MGMT_RET_RC_OK; return FS_MGMT_ERR_OK;
} }
/** /**
@ -226,8 +226,8 @@ static int fs_mgmt_file_download(struct smp_streamer *ctxt)
}; };
enum mgmt_cb_return status; enum mgmt_cb_return status;
int32_t ret_rc; int32_t err_rc;
uint16_t ret_group; uint16_t err_group;
#endif #endif
ok = zcbor_map_decode_bulk(zsd, fs_download_decode, ARRAY_SIZE(fs_download_decode), ok = zcbor_map_decode_bulk(zsd, fs_download_decode, ARRAY_SIZE(fs_download_decode),
@ -251,14 +251,14 @@ static int fs_mgmt_file_download(struct smp_streamer *ctxt)
#if defined(CONFIG_MCUMGR_GRP_FS_FILE_ACCESS_HOOK) #if defined(CONFIG_MCUMGR_GRP_FS_FILE_ACCESS_HOOK)
/* Send request to application to check if access should be allowed or not */ /* Send request to application to check if access should be allowed or not */
status = mgmt_callback_notify(MGMT_EVT_OP_FS_MGMT_FILE_ACCESS, &file_access_data, status = mgmt_callback_notify(MGMT_EVT_OP_FS_MGMT_FILE_ACCESS, &file_access_data,
sizeof(file_access_data), &ret_rc, &ret_group); sizeof(file_access_data), &err_rc, &err_group);
if (status != MGMT_CB_OK) { if (status != MGMT_CB_OK) {
if (status == MGMT_CB_ERROR_RC) { if (status == MGMT_CB_ERROR_RC) {
return ret_rc; return err_rc;
} }
ok = smp_add_cmd_ret(zse, ret_group, (uint16_t)ret_rc); ok = smp_add_cmd_err(zse, err_group, (uint16_t)err_rc);
goto end; goto end;
} }
#endif #endif
@ -270,8 +270,8 @@ static int fs_mgmt_file_download(struct smp_streamer *ctxt)
if (fs_mgmt_ctxt.state == STATE_NO_UPLOAD_OR_DOWNLOAD) { if (fs_mgmt_ctxt.state == STATE_NO_UPLOAD_OR_DOWNLOAD) {
rc = fs_mgmt_filelen(path, &fs_mgmt_ctxt.len); rc = fs_mgmt_filelen(path, &fs_mgmt_ctxt.len);
if (rc != FS_MGMT_RET_RC_OK) { if (rc != FS_MGMT_ERR_OK) {
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_FS, rc); ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_FS, rc);
goto end; goto end;
} }
@ -281,14 +281,14 @@ static int fs_mgmt_file_download(struct smp_streamer *ctxt)
if (rc != 0) { if (rc != 0) {
if (rc == -EINVAL) { if (rc == -EINVAL) {
rc = FS_MGMT_RET_RC_FILE_INVALID_NAME; rc = FS_MGMT_ERR_FILE_INVALID_NAME;
} else if (rc == -ENOENT) { } else if (rc == -ENOENT) {
rc = FS_MGMT_RET_RC_FILE_NOT_FOUND; rc = FS_MGMT_ERR_FILE_NOT_FOUND;
} else { } else {
rc = FS_MGMT_RET_RC_UNKNOWN; rc = FS_MGMT_ERR_UNKNOWN;
} }
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_FS, rc); ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_FS, rc);
goto end; goto end;
} }
@ -302,8 +302,8 @@ static int fs_mgmt_file_download(struct smp_streamer *ctxt)
rc = fs_seek(&fs_mgmt_ctxt.file, off, FS_SEEK_SET); rc = fs_seek(&fs_mgmt_ctxt.file, off, FS_SEEK_SET);
if (rc != 0) { if (rc != 0) {
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_FS, ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_FS,
FS_MGMT_RET_RC_FILE_SEEK_FAILED); FS_MGMT_ERR_FILE_SEEK_FAILED);
fs_mgmt_cleanup(); fs_mgmt_cleanup();
goto end; goto end;
} }
@ -319,7 +319,7 @@ static int fs_mgmt_file_download(struct smp_streamer *ctxt)
bytes_read = fs_read(&fs_mgmt_ctxt.file, file_data, MCUMGR_GRP_FS_DL_CHUNK_SIZE); bytes_read = fs_read(&fs_mgmt_ctxt.file, file_data, MCUMGR_GRP_FS_DL_CHUNK_SIZE);
if (bytes_read < 0) { if (bytes_read < 0) {
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_FS, FS_MGMT_RET_RC_FILE_READ_FAILED); ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_FS, FS_MGMT_ERR_FILE_READ_FAILED);
fs_mgmt_cleanup(); fs_mgmt_cleanup();
goto end; goto end;
} }
@ -374,8 +374,8 @@ static int fs_mgmt_file_upload(struct smp_streamer *ctxt)
}; };
enum mgmt_cb_return status; enum mgmt_cb_return status;
int32_t ret_rc; int32_t err_rc;
uint16_t ret_group; uint16_t err_group;
#endif #endif
ok = zcbor_map_decode_bulk(zsd, fs_upload_decode, ARRAY_SIZE(fs_upload_decode), ok = zcbor_map_decode_bulk(zsd, fs_upload_decode, ARRAY_SIZE(fs_upload_decode),
@ -400,14 +400,14 @@ static int fs_mgmt_file_upload(struct smp_streamer *ctxt)
#if defined(CONFIG_MCUMGR_GRP_FS_FILE_ACCESS_HOOK) #if defined(CONFIG_MCUMGR_GRP_FS_FILE_ACCESS_HOOK)
/* Send request to application to check if access should be allowed or not */ /* Send request to application to check if access should be allowed or not */
status = mgmt_callback_notify(MGMT_EVT_OP_FS_MGMT_FILE_ACCESS, &file_access_data, status = mgmt_callback_notify(MGMT_EVT_OP_FS_MGMT_FILE_ACCESS, &file_access_data,
sizeof(file_access_data), &ret_rc, &ret_group); sizeof(file_access_data), &err_rc, &err_group);
if (status != MGMT_CB_OK) { if (status != MGMT_CB_OK) {
if (status == MGMT_CB_ERROR_RC) { if (status == MGMT_CB_ERROR_RC) {
return ret_rc; return err_rc;
} }
ok = smp_add_cmd_ret(zse, ret_group, (uint16_t)ret_rc); ok = smp_add_cmd_err(zse, err_group, (uint16_t)err_rc);
goto end; goto end;
} }
#endif #endif
@ -423,14 +423,14 @@ static int fs_mgmt_file_upload(struct smp_streamer *ctxt)
if (rc != 0) { if (rc != 0) {
if (rc == -EINVAL) { if (rc == -EINVAL) {
rc = FS_MGMT_RET_RC_FILE_INVALID_NAME; rc = FS_MGMT_ERR_FILE_INVALID_NAME;
} else if (rc == -ENOENT) { } else if (rc == -ENOENT) {
rc = FS_MGMT_RET_RC_FILE_NOT_FOUND; rc = FS_MGMT_ERR_FILE_NOT_FOUND;
} else { } else {
rc = FS_MGMT_RET_RC_UNKNOWN; rc = FS_MGMT_ERR_UNKNOWN;
} }
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_FS, rc); ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_FS, rc);
goto end; goto end;
} }
@ -449,7 +449,7 @@ static int fs_mgmt_file_upload(struct smp_streamer *ctxt)
rc = fs_mgmt_filelen(file_name, &existing_file_size); rc = fs_mgmt_filelen(file_name, &existing_file_size);
if (rc != 0) { if (rc != 0) {
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_FS, rc); ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_FS, rc);
fs_mgmt_cleanup(); fs_mgmt_cleanup();
goto end; goto end;
} }
@ -457,7 +457,7 @@ static int fs_mgmt_file_upload(struct smp_streamer *ctxt)
rc = fs_mgmt_filelen(file_name, &fs_mgmt_ctxt.off); rc = fs_mgmt_filelen(file_name, &fs_mgmt_ctxt.off);
if (rc != 0) { if (rc != 0) {
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_FS, rc); ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_FS, rc);
fs_mgmt_cleanup(); fs_mgmt_cleanup();
goto end; goto end;
} }
@ -466,7 +466,7 @@ static int fs_mgmt_file_upload(struct smp_streamer *ctxt)
/* Verify that the data offset matches the expected offset (i.e. current size of file) */ /* Verify that the data offset matches the expected offset (i.e. current size of file) */
if (off > 0 && off != fs_mgmt_ctxt.off) { if (off > 0 && off != fs_mgmt_ctxt.off) {
/* Offset mismatch, send file length, client needs to handle this */ /* Offset mismatch, send file length, client needs to handle this */
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_FS, FS_MGMT_RET_RC_FILE_OFFSET_NOT_VALID); ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_FS, FS_MGMT_ERR_FILE_OFFSET_NOT_VALID);
ok = zcbor_tstr_put_lit(zse, "len") && ok = zcbor_tstr_put_lit(zse, "len") &&
zcbor_uint64_put(zse, fs_mgmt_ctxt.off); zcbor_uint64_put(zse, fs_mgmt_ctxt.off);
@ -487,8 +487,8 @@ static int fs_mgmt_file_upload(struct smp_streamer *ctxt)
rc = fs_seek(&fs_mgmt_ctxt.file, 0, FS_SEEK_SET); rc = fs_seek(&fs_mgmt_ctxt.file, 0, FS_SEEK_SET);
if (rc != 0) { if (rc != 0) {
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_FS, ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_FS,
FS_MGMT_RET_RC_FILE_SEEK_FAILED); FS_MGMT_ERR_FILE_SEEK_FAILED);
fs_mgmt_cleanup(); fs_mgmt_cleanup();
goto end; goto end;
} }
@ -503,8 +503,8 @@ static int fs_mgmt_file_upload(struct smp_streamer *ctxt)
rc = fs_unlink(file_name); rc = fs_unlink(file_name);
if (rc < 0 && rc != -ENOENT) { if (rc < 0 && rc != -ENOENT) {
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_FS, ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_FS,
FS_MGMT_RET_RC_FILE_DELETE_FAILED); FS_MGMT_ERR_FILE_DELETE_FAILED);
fs_mgmt_cleanup(); fs_mgmt_cleanup();
goto end; goto end;
} }
@ -515,8 +515,8 @@ static int fs_mgmt_file_upload(struct smp_streamer *ctxt)
if (rc < 0) { if (rc < 0) {
/* Failed to truncate file */ /* Failed to truncate file */
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_FS, ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_FS,
FS_MGMT_RET_RC_FILE_TRUNCATE_FAILED); FS_MGMT_ERR_FILE_TRUNCATE_FAILED);
fs_mgmt_cleanup(); fs_mgmt_cleanup();
goto end; goto end;
} }
@ -528,8 +528,8 @@ static int fs_mgmt_file_upload(struct smp_streamer *ctxt)
if (rc < 0) { if (rc < 0) {
/* Failed to seek in file */ /* Failed to seek in file */
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_FS, ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_FS,
FS_MGMT_RET_RC_FILE_SEEK_FAILED); FS_MGMT_ERR_FILE_SEEK_FAILED);
fs_mgmt_cleanup(); fs_mgmt_cleanup();
goto end; goto end;
} }
@ -538,8 +538,8 @@ static int fs_mgmt_file_upload(struct smp_streamer *ctxt)
rc = fs_write(&fs_mgmt_ctxt.file, file_data.value, file_data.len); rc = fs_write(&fs_mgmt_ctxt.file, file_data.value, file_data.len);
if (rc < 0) { if (rc < 0) {
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_FS, ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_FS,
FS_MGMT_RET_RC_FILE_WRITE_FAILED); FS_MGMT_ERR_FILE_WRITE_FAILED);
fs_mgmt_cleanup(); fs_mgmt_cleanup();
goto end; goto end;
} }
@ -584,8 +584,8 @@ static int fs_mgmt_file_status(struct smp_streamer *ctxt)
}; };
enum mgmt_cb_return status; enum mgmt_cb_return status;
int32_t ret_rc; int32_t err_rc;
uint16_t ret_group; uint16_t err_group;
#endif #endif
ok = zcbor_map_decode_bulk(zsd, fs_status_decode, ok = zcbor_map_decode_bulk(zsd, fs_status_decode,
@ -602,14 +602,14 @@ static int fs_mgmt_file_status(struct smp_streamer *ctxt)
#if defined(CONFIG_MCUMGR_GRP_FS_FILE_ACCESS_HOOK) #if defined(CONFIG_MCUMGR_GRP_FS_FILE_ACCESS_HOOK)
/* Send request to application to check if access should be allowed or not */ /* Send request to application to check if access should be allowed or not */
status = mgmt_callback_notify(MGMT_EVT_OP_FS_MGMT_FILE_ACCESS, &file_access_data, status = mgmt_callback_notify(MGMT_EVT_OP_FS_MGMT_FILE_ACCESS, &file_access_data,
sizeof(file_access_data), &ret_rc, &ret_group); sizeof(file_access_data), &err_rc, &err_group);
if (status != MGMT_CB_OK) { if (status != MGMT_CB_OK) {
if (status == MGMT_CB_ERROR_RC) { if (status == MGMT_CB_ERROR_RC) {
return ret_rc; return err_rc;
} }
ok = smp_add_cmd_ret(zse, ret_group, (uint16_t)ret_rc); ok = smp_add_cmd_err(zse, err_group, (uint16_t)err_rc);
return ok ? MGMT_ERR_EOK : MGMT_ERR_EMSGSIZE; return ok ? MGMT_ERR_EOK : MGMT_ERR_EMSGSIZE;
} }
#endif #endif
@ -618,7 +618,7 @@ static int fs_mgmt_file_status(struct smp_streamer *ctxt)
rc = fs_mgmt_filelen(path, &file_len); rc = fs_mgmt_filelen(path, &file_len);
if (rc != 0) { if (rc != 0) {
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_FS, rc); ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_FS, rc);
goto end; goto end;
} }
@ -676,8 +676,8 @@ static int fs_mgmt_file_hash_checksum(struct smp_streamer *ctxt)
}; };
enum mgmt_cb_return status; enum mgmt_cb_return status;
int32_t ret_rc; int32_t err_rc;
uint16_t ret_group; uint16_t err_group;
#endif #endif
ok = zcbor_map_decode_bulk(zsd, fs_hash_checksum_decode, ok = zcbor_map_decode_bulk(zsd, fs_hash_checksum_decode,
@ -701,22 +701,22 @@ static int fs_mgmt_file_hash_checksum(struct smp_streamer *ctxt)
group = fs_mgmt_hash_checksum_find_handler(type_arr); group = fs_mgmt_hash_checksum_find_handler(type_arr);
if (group == NULL) { if (group == NULL) {
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_FS, ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_FS,
FS_MGMT_RET_RC_CHECKSUM_HASH_NOT_FOUND); FS_MGMT_ERR_CHECKSUM_HASH_NOT_FOUND);
goto end; goto end;
} }
#if defined(CONFIG_MCUMGR_GRP_FS_FILE_ACCESS_HOOK) #if defined(CONFIG_MCUMGR_GRP_FS_FILE_ACCESS_HOOK)
/* Send request to application to check if access should be allowed or not */ /* Send request to application to check if access should be allowed or not */
status = mgmt_callback_notify(MGMT_EVT_OP_FS_MGMT_FILE_ACCESS, &file_access_data, status = mgmt_callback_notify(MGMT_EVT_OP_FS_MGMT_FILE_ACCESS, &file_access_data,
sizeof(file_access_data), &ret_rc, &ret_group); sizeof(file_access_data), &err_rc, &err_group);
if (status != MGMT_CB_OK) { if (status != MGMT_CB_OK) {
if (status == MGMT_CB_ERROR_RC) { if (status == MGMT_CB_ERROR_RC) {
return ret_rc; return err_rc;
} }
ok = smp_add_cmd_ret(zse, ret_group, (uint16_t)ret_rc); ok = smp_add_cmd_err(zse, err_group, (uint16_t)err_rc);
return ok ? MGMT_ERR_EOK : MGMT_ERR_EMSGSIZE; return ok ? MGMT_ERR_EOK : MGMT_ERR_EMSGSIZE;
} }
#endif #endif
@ -725,14 +725,14 @@ static int fs_mgmt_file_hash_checksum(struct smp_streamer *ctxt)
rc = fs_mgmt_filelen(path, &file_len); rc = fs_mgmt_filelen(path, &file_len);
if (rc != 0) { if (rc != 0) {
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_FS, rc); ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_FS, rc);
goto end; goto end;
} }
if (file_len <= off) { if (file_len <= off) {
/* Requested offset is larger than target file size */ /* Requested offset is larger than target file size */
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_FS, ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_FS,
FS_MGMT_RET_RC_FILE_OFFSET_LARGER_THAN_FILE); FS_MGMT_ERR_FILE_OFFSET_LARGER_THAN_FILE);
goto end; goto end;
} }
@ -742,14 +742,14 @@ static int fs_mgmt_file_hash_checksum(struct smp_streamer *ctxt)
if (rc != 0) { if (rc != 0) {
if (rc == -EINVAL) { if (rc == -EINVAL) {
rc = FS_MGMT_RET_RC_FILE_INVALID_NAME; rc = FS_MGMT_ERR_FILE_INVALID_NAME;
} else if (rc == -ENOENT) { } else if (rc == -ENOENT) {
rc = FS_MGMT_RET_RC_FILE_NOT_FOUND; rc = FS_MGMT_ERR_FILE_NOT_FOUND;
} else { } else {
rc = FS_MGMT_RET_RC_UNKNOWN; rc = FS_MGMT_ERR_UNKNOWN;
} }
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_FS, rc); ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_FS, rc);
goto end; goto end;
} }
@ -758,8 +758,8 @@ static int fs_mgmt_file_hash_checksum(struct smp_streamer *ctxt)
rc = fs_seek(&file, off, FS_SEEK_SET); rc = fs_seek(&file, off, FS_SEEK_SET);
if (rc != 0) { if (rc != 0) {
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_FS, ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_FS,
FS_MGMT_RET_RC_FILE_SEEK_FAILED); FS_MGMT_ERR_FILE_SEEK_FAILED);
fs_close(&file); fs_close(&file);
goto end; goto end;
} }
@ -773,7 +773,7 @@ static int fs_mgmt_file_hash_checksum(struct smp_streamer *ctxt)
/* Encode the response */ /* Encode the response */
if (rc != 0) { if (rc != 0) {
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_FS, rc); ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_FS, rc);
goto end; goto end;
} }
@ -900,35 +900,25 @@ static int fs_mgmt_close_opened_file(struct smp_streamer *ctxt)
/* /*
* @brief Translate FS mgmt group error code into MCUmgr error code * @brief Translate FS mgmt group error code into MCUmgr error code
* *
* @param ret #fs_mgmt_ret_code_t error code * @param ret #fs_mgmt_err_code_t error code
* *
* @return #mcumgr_err_t error code * @return #mcumgr_err_t error code
*/ */
static int fs_mgmt_translate_error_code(uint16_t ret) static int fs_mgmt_translate_error_code(uint16_t err)
{ {
int rc; int rc;
switch (ret) { switch (err) {
case FS_MGMT_RET_RC_FILE_INVALID_NAME: case FS_MGMT_ERR_UNKNOWN:
case FS_MGMT_RET_RC_CHECKSUM_HASH_NOT_FOUND: case FS_MGMT_ERR_FILE_OPEN_FAILED:
rc = MGMT_ERR_EINVAL; case FS_MGMT_ERR_FILE_SEEK_FAILED:
break; case FS_MGMT_ERR_FILE_READ_FAILED:
case FS_MGMT_ERR_FILE_TRUNCATE_FAILED:
case FS_MGMT_RET_RC_FILE_NOT_FOUND: case FS_MGMT_ERR_FILE_DELETE_FAILED:
case FS_MGMT_RET_RC_FILE_IS_DIRECTORY: case FS_MGMT_ERR_FILE_WRITE_FAILED:
rc = MGMT_ERR_ENOENT; case FS_MGMT_ERR_FILE_OFFSET_NOT_VALID:
break; case FS_MGMT_ERR_FILE_OFFSET_LARGER_THAN_FILE:
default:
case FS_MGMT_RET_RC_UNKNOWN:
case FS_MGMT_RET_RC_FILE_OPEN_FAILED:
case FS_MGMT_RET_RC_FILE_SEEK_FAILED:
case FS_MGMT_RET_RC_FILE_READ_FAILED:
case FS_MGMT_RET_RC_FILE_TRUNCATE_FAILED:
case FS_MGMT_RET_RC_FILE_DELETE_FAILED:
case FS_MGMT_RET_RC_FILE_WRITE_FAILED:
case FS_MGMT_RET_RC_FILE_OFFSET_NOT_VALID:
case FS_MGMT_RET_RC_FILE_OFFSET_LARGER_THAN_FILE:
default:
rc = MGMT_ERR_EUNKNOWN; rc = MGMT_ERR_EUNKNOWN;
} }

138
subsys/mgmt/mcumgr/grp/img_mgmt/src/img_mgmt.c
View file

@ -130,13 +130,13 @@ static int img_mgmt_find_tlvs(int slot, size_t *start_off, size_t *end_off, uint
if (tlv_info.it_magic != magic) { if (tlv_info.it_magic != magic) {
/* No TLVs. */ /* No TLVs. */
return IMG_MGMT_RET_RC_NO_TLVS; return IMG_MGMT_ERR_NO_TLVS;
} }
*start_off += sizeof(tlv_info); *start_off += sizeof(tlv_info);
*end_off = *start_off + tlv_info.it_tlv_tot; *end_off = *start_off + tlv_info.it_tlv_tot;
return IMG_MGMT_RET_RC_OK; return IMG_MGMT_ERR_OK;
} }
int img_mgmt_active_slot(int image) int img_mgmt_active_slot(int image)
@ -175,7 +175,7 @@ int img_mgmt_read_info(int image_slot, struct image_version *ver, uint8_t *hash,
rc = img_mgmt_erased_val(image_slot, &erased_val); rc = img_mgmt_erased_val(image_slot, &erased_val);
if (rc != 0) { if (rc != 0) {
return IMG_MGMT_RET_RC_FLASH_CONFIG_QUERY_FAIL; return IMG_MGMT_ERR_FLASH_CONFIG_QUERY_FAIL;
} }
rc = img_mgmt_read(image_slot, 0, &hdr, sizeof(hdr)); rc = img_mgmt_read(image_slot, 0, &hdr, sizeof(hdr));
@ -192,9 +192,9 @@ int img_mgmt_read_info(int image_slot, struct image_version *ver, uint8_t *hash,
memcpy(ver, &hdr.ih_ver, sizeof(*ver)); memcpy(ver, &hdr.ih_ver, sizeof(*ver));
} }
} else if (hdr.ih_magic == erased_val_32) { } else if (hdr.ih_magic == erased_val_32) {
return IMG_MGMT_RET_RC_NO_IMAGE; return IMG_MGMT_ERR_NO_IMAGE;
} else { } else {
return IMG_MGMT_RET_RC_INVALID_IMAGE_HEADER_MAGIC; return IMG_MGMT_ERR_INVALID_IMAGE_HEADER_MAGIC;
} }
if (flags != NULL) { if (flags != NULL) {
@ -218,7 +218,7 @@ int img_mgmt_read_info(int image_slot, struct image_version *ver, uint8_t *hash,
rc = img_mgmt_find_tlvs(image_slot, &data_off, &data_end, IMAGE_TLV_INFO_MAGIC); rc = img_mgmt_find_tlvs(image_slot, &data_off, &data_end, IMAGE_TLV_INFO_MAGIC);
if (rc != 0) { if (rc != 0) {
return IMG_MGMT_RET_RC_NO_TLVS; return IMG_MGMT_ERR_NO_TLVS;
} }
hash_found = false; hash_found = false;
@ -228,7 +228,7 @@ int img_mgmt_read_info(int image_slot, struct image_version *ver, uint8_t *hash,
return rc; return rc;
} }
if (tlv.it_type == 0xff && tlv.it_len == 0xffff) { if (tlv.it_type == 0xff && tlv.it_len == 0xffff) {
return IMG_MGMT_RET_RC_INVALID_TLV; return IMG_MGMT_ERR_INVALID_TLV;
} }
if (tlv.it_type != IMAGE_TLV_SHA256 || tlv.it_len != IMAGE_HASH_LEN) { if (tlv.it_type != IMAGE_TLV_SHA256 || tlv.it_len != IMAGE_HASH_LEN) {
/* Non-hash TLV. Skip it. */ /* Non-hash TLV. Skip it. */
@ -238,14 +238,14 @@ int img_mgmt_read_info(int image_slot, struct image_version *ver, uint8_t *hash,
if (hash_found) { if (hash_found) {
/* More than one hash. */ /* More than one hash. */
return IMG_MGMT_RET_RC_TLV_MULTIPLE_HASHES_FOUND; return IMG_MGMT_ERR_TLV_MULTIPLE_HASHES_FOUND;
} }
hash_found = true; hash_found = true;
data_off += sizeof(tlv); data_off += sizeof(tlv);
if (hash != NULL) { if (hash != NULL) {
if (data_off + IMAGE_HASH_LEN > data_end) { if (data_off + IMAGE_HASH_LEN > data_end) {
return IMG_MGMT_RET_RC_TLV_INVALID_SIZE; return IMG_MGMT_ERR_TLV_INVALID_SIZE;
} }
rc = img_mgmt_read(image_slot, data_off, hash, IMAGE_HASH_LEN); rc = img_mgmt_read(image_slot, data_off, hash, IMAGE_HASH_LEN);
if (rc != 0) { if (rc != 0) {
@ -255,7 +255,7 @@ int img_mgmt_read_info(int image_slot, struct image_version *ver, uint8_t *hash,
} }
if (!hash_found) { if (!hash_found) {
return IMG_MGMT_RET_RC_HASH_NOT_FOUND; return IMG_MGMT_ERR_HASH_NOT_FOUND;
} }
return 0; return 0;
@ -373,8 +373,8 @@ img_mgmt_erase(struct smp_streamer *ctxt)
/* Image info is valid. */ /* Image info is valid. */
if (img_mgmt_slot_in_use(slot)) { if (img_mgmt_slot_in_use(slot)) {
/* No free slot. */ /* No free slot. */
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_IMAGE, ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_IMAGE,
IMG_MGMT_RET_RC_NO_FREE_SLOT); IMG_MGMT_ERR_NO_FREE_SLOT);
goto end; goto end;
} }
} }
@ -384,13 +384,13 @@ img_mgmt_erase(struct smp_streamer *ctxt)
if (rc != 0) { if (rc != 0) {
#if defined(CONFIG_MCUMGR_GRP_IMG_STATUS_HOOKS) #if defined(CONFIG_MCUMGR_GRP_IMG_STATUS_HOOKS)
int32_t ret_rc; int32_t err_rc;
uint16_t ret_group; uint16_t err_group;
(void)mgmt_callback_notify(MGMT_EVT_OP_IMG_MGMT_DFU_STOPPED, NULL, 0, &ret_rc, (void)mgmt_callback_notify(MGMT_EVT_OP_IMG_MGMT_DFU_STOPPED, NULL, 0, &err_rc,
&ret_group); &err_group);
#endif #endif
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_IMAGE, rc); ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_IMAGE, rc);
goto end; goto end;
} }
@ -487,8 +487,8 @@ img_mgmt_upload(struct smp_streamer *ctxt)
#if defined(CONFIG_MCUMGR_GRP_IMG_UPLOAD_CHECK_HOOK) || \ #if defined(CONFIG_MCUMGR_GRP_IMG_UPLOAD_CHECK_HOOK) || \
defined(CONFIG_MCUMGR_GRP_IMG_STATUS_HOOKS) || \ defined(CONFIG_MCUMGR_GRP_IMG_STATUS_HOOKS) || \
defined(CONFIG_MCUMGR_SMP_COMMAND_STATUS_HOOKS) defined(CONFIG_MCUMGR_SMP_COMMAND_STATUS_HOOKS)
int32_t ret_rc; int32_t err_rc;
uint16_t ret_group; uint16_t err_group;
#endif #endif
struct zcbor_map_decode_key_val image_upload_decode[] = { struct zcbor_map_decode_key_val image_upload_decode[] = {
@ -529,13 +529,13 @@ defined(CONFIG_MCUMGR_SMP_COMMAND_STATUS_HOOKS)
rc = img_mgmt_upload_inspect(&req, &action); rc = img_mgmt_upload_inspect(&req, &action);
if (rc != 0) { if (rc != 0) {
#if defined(CONFIG_MCUMGR_GRP_IMG_STATUS_HOOKS) #if defined(CONFIG_MCUMGR_GRP_IMG_STATUS_HOOKS)
(void)mgmt_callback_notify(MGMT_EVT_OP_IMG_MGMT_DFU_STOPPED, NULL, 0, &ret_rc, (void)mgmt_callback_notify(MGMT_EVT_OP_IMG_MGMT_DFU_STOPPED, NULL, 0, &err_rc,
&ret_group); &err_group);
#endif #endif
MGMT_CTXT_SET_RC_RSN(ctxt, IMG_MGMT_UPLOAD_ACTION_RC_RSN(&action)); MGMT_CTXT_SET_RC_RSN(ctxt, IMG_MGMT_UPLOAD_ACTION_RC_RSN(&action));
LOG_ERR("Image upload inspect failed: %d", rc); LOG_ERR("Image upload inspect failed: %d", rc);
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_IMAGE, rc); ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_IMAGE, rc);
goto end; goto end;
} }
@ -553,17 +553,17 @@ defined(CONFIG_MCUMGR_SMP_COMMAND_STATUS_HOOKS)
* request. * request.
*/ */
status = mgmt_callback_notify(MGMT_EVT_OP_IMG_MGMT_DFU_CHUNK, &upload_check_data, status = mgmt_callback_notify(MGMT_EVT_OP_IMG_MGMT_DFU_CHUNK, &upload_check_data,
sizeof(upload_check_data), &ret_rc, &ret_group); sizeof(upload_check_data), &err_rc, &err_group);
if (status != MGMT_CB_OK) { if (status != MGMT_CB_OK) {
IMG_MGMT_UPLOAD_ACTION_SET_RC_RSN(&action, img_mgmt_err_str_app_reject); IMG_MGMT_UPLOAD_ACTION_SET_RC_RSN(&action, img_mgmt_err_str_app_reject);
if (status == MGMT_CB_ERROR_RC) { if (status == MGMT_CB_ERROR_RC) {
rc = ret_rc; rc = err_rc;
ok = zcbor_tstr_put_lit(zse, "rc") && ok = zcbor_tstr_put_lit(zse, "rc") &&
zcbor_int32_put(zse, rc); zcbor_int32_put(zse, rc);
} else { } else {
ok = smp_add_cmd_ret(zse, ret_group, (uint16_t)ret_rc); ok = smp_add_cmd_err(zse, err_group, (uint16_t)err_rc);
} }
goto end; goto end;
@ -586,8 +586,8 @@ defined(CONFIG_MCUMGR_SMP_COMMAND_STATUS_HOOKS)
g_img_mgmt_state.off = 0; g_img_mgmt_state.off = 0;
#if defined(CONFIG_MCUMGR_GRP_IMG_STATUS_HOOKS) #if defined(CONFIG_MCUMGR_GRP_IMG_STATUS_HOOKS)
(void)mgmt_callback_notify(MGMT_EVT_OP_IMG_MGMT_DFU_STARTED, NULL, 0, &ret_rc, (void)mgmt_callback_notify(MGMT_EVT_OP_IMG_MGMT_DFU_STARTED, NULL, 0, &err_rc,
&ret_group); &err_group);
#endif #endif
#if defined(CONFIG_MCUMGR_SMP_COMMAND_STATUS_HOOKS) #if defined(CONFIG_MCUMGR_SMP_COMMAND_STATUS_HOOKS)
@ -639,7 +639,7 @@ defined(CONFIG_MCUMGR_SMP_COMMAND_STATUS_HOOKS)
if (rc != 0) { if (rc != 0) {
IMG_MGMT_UPLOAD_ACTION_SET_RC_RSN(&action, IMG_MGMT_UPLOAD_ACTION_SET_RC_RSN(&action,
img_mgmt_err_str_flash_erase_failed); img_mgmt_err_str_flash_erase_failed);
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_IMAGE, rc); ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_IMAGE, rc);
goto end; goto end;
} }
} }
@ -675,7 +675,7 @@ defined(CONFIG_MCUMGR_SMP_COMMAND_STATUS_HOOKS)
LOG_ERR("Irrecoverable error: flash write failed: %d", rc); LOG_ERR("Irrecoverable error: flash write failed: %d", rc);
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_IMAGE, rc); ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_IMAGE, rc);
goto end; goto end;
} }
@ -704,11 +704,11 @@ defined(CONFIG_MCUMGR_SMP_COMMAND_STATUS_HOOKS)
#if defined(CONFIG_MCUMGR_GRP_IMG_STATUS_HOOKS) #if defined(CONFIG_MCUMGR_GRP_IMG_STATUS_HOOKS)
(void)mgmt_callback_notify(MGMT_EVT_OP_IMG_MGMT_DFU_PENDING, NULL, 0, (void)mgmt_callback_notify(MGMT_EVT_OP_IMG_MGMT_DFU_PENDING, NULL, 0,
&ret_rc, &ret_group); &err_rc, &err_group);
} else { } else {
/* Notify that the write has completed */ /* Notify that the write has completed */
(void)mgmt_callback_notify(MGMT_EVT_OP_IMG_MGMT_DFU_CHUNK_WRITE_COMPLETE, (void)mgmt_callback_notify(MGMT_EVT_OP_IMG_MGMT_DFU_CHUNK_WRITE_COMPLETE,
NULL, 0, &ret_rc, &ret_group); NULL, 0, &err_rc, &err_group);
#endif #endif
} }
} }
@ -718,13 +718,13 @@ end:
#if defined(CONFIG_MCUMGR_SMP_COMMAND_STATUS_HOOKS) #if defined(CONFIG_MCUMGR_SMP_COMMAND_STATUS_HOOKS)
(void)mgmt_callback_notify(MGMT_EVT_OP_CMD_STATUS, &cmd_status_arg, (void)mgmt_callback_notify(MGMT_EVT_OP_CMD_STATUS, &cmd_status_arg,
sizeof(cmd_status_arg), &ret_rc, &ret_group); sizeof(cmd_status_arg), &err_rc, &err_group);
#endif #endif
if (rc != 0) { if (rc != 0) {
#if defined(CONFIG_MCUMGR_GRP_IMG_STATUS_HOOKS) #if defined(CONFIG_MCUMGR_GRP_IMG_STATUS_HOOKS)
(void)mgmt_callback_notify(MGMT_EVT_OP_IMG_MGMT_DFU_STOPPED, NULL, 0, &ret_rc, (void)mgmt_callback_notify(MGMT_EVT_OP_IMG_MGMT_DFU_STOPPED, NULL, 0, &err_rc,
&ret_group); &err_group);
#endif #endif
img_mgmt_reset_upload(); img_mgmt_reset_upload();
@ -764,59 +764,59 @@ int img_mgmt_my_version(struct image_version *ver)
/* /*
* @brief Translate IMG mgmt group error code into MCUmgr error code * @brief Translate IMG mgmt group error code into MCUmgr error code
* *
* @param ret #img_mgmt_ret_code_t error code * @param ret #img_mgmt_err_code_t error code
* *
* @return #mcumgr_err_t error code * @return #mcumgr_err_t error code
*/ */
static int img_mgmt_translate_error_code(uint16_t ret) static int img_mgmt_translate_error_code(uint16_t err)
{ {
int rc; int rc;
switch (ret) { switch (err) {
case IMG_MGMT_RET_RC_NO_IMAGE: case IMG_MGMT_ERR_NO_IMAGE:
case IMG_MGMT_RET_RC_NO_TLVS: case IMG_MGMT_ERR_NO_TLVS:
rc = MGMT_ERR_ENOENT; rc = MGMT_ERR_ENOENT;
break; break;
case IMG_MGMT_RET_RC_NO_FREE_SLOT: case IMG_MGMT_ERR_NO_FREE_SLOT:
case IMG_MGMT_RET_RC_CURRENT_VERSION_IS_NEWER: case IMG_MGMT_ERR_CURRENT_VERSION_IS_NEWER:
case IMG_MGMT_RET_RC_IMAGE_ALREADY_PENDING: case IMG_MGMT_ERR_IMAGE_ALREADY_PENDING:
rc = MGMT_ERR_EBADSTATE; rc = MGMT_ERR_EBADSTATE;
break; break;
case IMG_MGMT_RET_RC_NO_FREE_MEMORY: case IMG_MGMT_ERR_NO_FREE_MEMORY:
rc = MGMT_ERR_ENOMEM; rc = MGMT_ERR_ENOMEM;
break; break;
case IMG_MGMT_RET_RC_INVALID_SLOT: case IMG_MGMT_ERR_INVALID_SLOT:
case IMG_MGMT_RET_RC_INVALID_PAGE_OFFSET: case IMG_MGMT_ERR_INVALID_PAGE_OFFSET:
case IMG_MGMT_RET_RC_INVALID_OFFSET: case IMG_MGMT_ERR_INVALID_OFFSET:
case IMG_MGMT_RET_RC_INVALID_LENGTH: case IMG_MGMT_ERR_INVALID_LENGTH:
case IMG_MGMT_RET_RC_INVALID_IMAGE_HEADER: case IMG_MGMT_ERR_INVALID_IMAGE_HEADER:
case IMG_MGMT_RET_RC_INVALID_HASH: case IMG_MGMT_ERR_INVALID_HASH:
case IMG_MGMT_RET_RC_INVALID_FLASH_ADDRESS: case IMG_MGMT_ERR_INVALID_FLASH_ADDRESS:
rc = MGMT_ERR_EINVAL; rc = MGMT_ERR_EINVAL;
break; break;
case IMG_MGMT_RET_RC_FLASH_CONFIG_QUERY_FAIL: case IMG_MGMT_ERR_FLASH_CONFIG_QUERY_FAIL:
case IMG_MGMT_RET_RC_VERSION_GET_FAILED: case IMG_MGMT_ERR_VERSION_GET_FAILED:
case IMG_MGMT_RET_RC_TLV_MULTIPLE_HASHES_FOUND: case IMG_MGMT_ERR_TLV_MULTIPLE_HASHES_FOUND:
case IMG_MGMT_RET_RC_TLV_INVALID_SIZE: case IMG_MGMT_ERR_TLV_INVALID_SIZE:
case IMG_MGMT_RET_RC_HASH_NOT_FOUND: case IMG_MGMT_ERR_HASH_NOT_FOUND:
case IMG_MGMT_RET_RC_INVALID_TLV: case IMG_MGMT_ERR_INVALID_TLV:
case IMG_MGMT_RET_RC_FLASH_OPEN_FAILED: case IMG_MGMT_ERR_FLASH_OPEN_FAILED:
case IMG_MGMT_RET_RC_FLASH_READ_FAILED: case IMG_MGMT_ERR_FLASH_READ_FAILED:
case IMG_MGMT_RET_RC_FLASH_WRITE_FAILED: case IMG_MGMT_ERR_FLASH_WRITE_FAILED:
case IMG_MGMT_RET_RC_FLASH_ERASE_FAILED: case IMG_MGMT_ERR_FLASH_ERASE_FAILED:
case IMG_MGMT_RET_RC_FLASH_CONTEXT_ALREADY_SET: case IMG_MGMT_ERR_FLASH_CONTEXT_ALREADY_SET:
case IMG_MGMT_RET_RC_FLASH_CONTEXT_NOT_SET: case IMG_MGMT_ERR_FLASH_CONTEXT_NOT_SET:
case IMG_MGMT_RET_RC_FLASH_AREA_DEVICE_NULL: case IMG_MGMT_ERR_FLASH_AREA_DEVICE_NULL:
case IMG_MGMT_RET_RC_INVALID_IMAGE_HEADER_MAGIC: case IMG_MGMT_ERR_INVALID_IMAGE_HEADER_MAGIC:
case IMG_MGMT_RET_RC_INVALID_IMAGE_VECTOR_TABLE: case IMG_MGMT_ERR_INVALID_IMAGE_VECTOR_TABLE:
case IMG_MGMT_RET_RC_INVALID_IMAGE_TOO_LARGE: case IMG_MGMT_ERR_INVALID_IMAGE_TOO_LARGE:
case IMG_MGMT_RET_RC_INVALID_IMAGE_DATA_OVERRUN: case IMG_MGMT_ERR_INVALID_IMAGE_DATA_OVERRUN:
case IMG_MGMT_RET_RC_UNKNOWN: case IMG_MGMT_ERR_UNKNOWN:
default: default:
rc = MGMT_ERR_EUNKNOWN; rc = MGMT_ERR_EUNKNOWN;
} }

44
subsys/mgmt/mcumgr/grp/img_mgmt/src/img_mgmt_state.c
View file

@ -183,7 +183,7 @@ img_mgmt_state_set_pending(int slot, int permanent)
* run if it is a loader in a split image setup. * run if it is a loader in a split image setup.
*/ */
if (state_flags & IMG_MGMT_STATE_F_CONFIRMED && slot != 0) { if (state_flags & IMG_MGMT_STATE_F_CONFIRMED && slot != 0) {
rc = IMG_MGMT_RET_RC_IMAGE_ALREADY_PENDING; rc = IMG_MGMT_ERR_IMAGE_ALREADY_PENDING;
goto done; goto done;
} }
@ -204,21 +204,21 @@ img_mgmt_state_confirm(void)
int rc; int rc;
#if defined(CONFIG_MCUMGR_GRP_IMG_STATUS_HOOKS) #if defined(CONFIG_MCUMGR_GRP_IMG_STATUS_HOOKS)
int32_t ret_rc; int32_t err_rc;
uint16_t ret_group; uint16_t err_group;
#endif #endif
/* Confirm disallowed if a test is pending. */ /* Confirm disallowed if a test is pending. */
if (img_mgmt_state_any_pending()) { if (img_mgmt_state_any_pending()) {
rc = IMG_MGMT_RET_RC_IMAGE_ALREADY_PENDING; rc = IMG_MGMT_ERR_IMAGE_ALREADY_PENDING;
goto err; goto err;
} }
rc = img_mgmt_write_confirmed(); rc = img_mgmt_write_confirmed();
#if defined(CONFIG_MCUMGR_GRP_IMG_STATUS_HOOKS) #if defined(CONFIG_MCUMGR_GRP_IMG_STATUS_HOOKS)
(void)mgmt_callback_notify(MGMT_EVT_OP_IMG_MGMT_DFU_CONFIRMED, NULL, 0, &ret_rc, (void)mgmt_callback_notify(MGMT_EVT_OP_IMG_MGMT_DFU_CONFIRMED, NULL, 0, &err_rc,
&ret_group); &err_group);
#endif #endif
err: err:
@ -305,8 +305,8 @@ int img_mgmt_set_next_boot_slot(int slot, bool confirm)
bool active = (slot == img_mgmt_active_slot(img_mgmt_active_image())); bool active = (slot == img_mgmt_active_slot(img_mgmt_active_image()));
#if defined(CONFIG_MCUMGR_GRP_IMG_STATUS_HOOKS) #if defined(CONFIG_MCUMGR_GRP_IMG_STATUS_HOOKS)
int32_t ret_rc; int32_t err_rc;
uint16_t ret_group; uint16_t err_group;
#endif #endif
if (active) { if (active) {
@ -320,11 +320,11 @@ int img_mgmt_set_next_boot_slot(int slot, bool confirm)
/* Confirm disallowed if a test is pending. */ /* Confirm disallowed if a test is pending. */
if (active && img_mgmt_state_any_pending()) { if (active && img_mgmt_state_any_pending()) {
return IMG_MGMT_RET_RC_IMAGE_ALREADY_PENDING; return IMG_MGMT_ERR_IMAGE_ALREADY_PENDING;
} }
if (flash_area_open(area_id, &fa) != 0) { if (flash_area_open(area_id, &fa) != 0) {
return IMG_MGMT_RET_RC_FLASH_OPEN_FAILED; return IMG_MGMT_ERR_FLASH_OPEN_FAILED;
} }
rc = boot_set_next(fa, active, confirm); rc = boot_set_next(fa, active, confirm);
@ -338,13 +338,13 @@ int img_mgmt_set_next_boot_slot(int slot, bool confirm)
/* Translate from boot util error code to IMG mgmt group error code */ /* Translate from boot util error code to IMG mgmt group error code */
if (rc == BOOT_EFLASH) { if (rc == BOOT_EFLASH) {
rc = IMG_MGMT_RET_RC_FLASH_WRITE_FAILED; rc = IMG_MGMT_ERR_FLASH_WRITE_FAILED;
} else if (rc == BOOT_EBADVECT) { } else if (rc == BOOT_EBADVECT) {
rc = IMG_MGMT_RET_RC_INVALID_IMAGE_VECTOR_TABLE; rc = IMG_MGMT_ERR_INVALID_IMAGE_VECTOR_TABLE;
} else if (rc == BOOT_EBADIMAGE) { } else if (rc == BOOT_EBADIMAGE) {
rc = IMG_MGMT_RET_RC_INVALID_IMAGE_HEADER_MAGIC; rc = IMG_MGMT_ERR_INVALID_IMAGE_HEADER_MAGIC;
} else { } else {
rc = IMG_MGMT_RET_RC_UNKNOWN; rc = IMG_MGMT_ERR_UNKNOWN;
} }
} }
flash_area_close(fa); flash_area_close(fa);
@ -352,8 +352,8 @@ int img_mgmt_set_next_boot_slot(int slot, bool confirm)
#if defined(CONFIG_MCUMGR_GRP_IMG_STATUS_HOOKS) #if defined(CONFIG_MCUMGR_GRP_IMG_STATUS_HOOKS)
if (active) { if (active) {
/* Confirm event is only sent for active slot */ /* Confirm event is only sent for active slot */
(void)mgmt_callback_notify(MGMT_EVT_OP_IMG_MGMT_DFU_CONFIRMED, NULL, 0, &ret_rc, (void)mgmt_callback_notify(MGMT_EVT_OP_IMG_MGMT_DFU_CONFIRMED, NULL, 0, &err_rc,
&ret_group); &err_group);
} }
#endif #endif
@ -396,15 +396,15 @@ img_mgmt_state_write(struct smp_streamer *ctxt)
slot = img_mgmt_active_slot(img_mgmt_active_image()); slot = img_mgmt_active_slot(img_mgmt_active_image());
} else { } else {
/* A 'test' without a hash is invalid. */ /* A 'test' without a hash is invalid. */
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_IMAGE, ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_IMAGE,
IMG_MGMT_RET_RC_INVALID_HASH); IMG_MGMT_ERR_INVALID_HASH);
goto end; goto end;
} }
} else if (zhash.len != IMAGE_HASH_LEN) { } else if (zhash.len != IMAGE_HASH_LEN) {
/* The img_mgmt_find_by_hash does exact length compare /* The img_mgmt_find_by_hash does exact length compare
* so just fail here. * so just fail here.
*/ */
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_IMAGE, IMG_MGMT_RET_RC_INVALID_HASH); ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_IMAGE, IMG_MGMT_ERR_INVALID_HASH);
goto end; goto end;
} else { } else {
uint8_t hash[IMAGE_HASH_LEN]; uint8_t hash[IMAGE_HASH_LEN];
@ -413,15 +413,15 @@ img_mgmt_state_write(struct smp_streamer *ctxt)
slot = img_mgmt_find_by_hash(hash, NULL); slot = img_mgmt_find_by_hash(hash, NULL);
if (slot < 0) { if (slot < 0) {
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_IMAGE, ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_IMAGE,
IMG_MGMT_RET_RC_HASH_NOT_FOUND); IMG_MGMT_ERR_HASH_NOT_FOUND);
goto end; goto end;
} }
} }
rc = img_mgmt_set_next_boot_slot(slot, confirm); rc = img_mgmt_set_next_boot_slot(slot, confirm);
if (rc != 0) { if (rc != 0) {
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_IMAGE, rc); ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_IMAGE, rc);
goto end; goto end;
} }

92
subsys/mgmt/mcumgr/grp/img_mgmt/src/zephyr_img_mgmt.c
View file

@ -106,7 +106,7 @@ static int img_mgmt_flash_check_empty_inner(const struct flash_area *fa)
rc = flash_area_read(fa, addr, data, bytes_to_read); rc = flash_area_read(fa, addr, data, bytes_to_read);
if (rc < 0) { if (rc < 0) {
LOG_ERR("Failed to read data from flash area: %d", rc); LOG_ERR("Failed to read data from flash area: %d", rc);
return IMG_MGMT_RET_RC_FLASH_READ_FAILED; return IMG_MGMT_ERR_FLASH_READ_FAILED;
} }
for (i = 0; i < bytes_to_read / 4; i++) { for (i = 0; i < bytes_to_read / 4; i++) {
@ -138,7 +138,7 @@ static int img_mgmt_flash_check_empty(uint8_t fa_id)
flash_area_close(fa); flash_area_close(fa);
} else { } else {
LOG_ERR("Failed to open flash area ID %u: %d", fa_id, rc); LOG_ERR("Failed to open flash area ID %u: %d", fa_id, rc);
rc = IMG_MGMT_RET_RC_FLASH_OPEN_FAILED; rc = IMG_MGMT_ERR_FLASH_OPEN_FAILED;
} }
return rc; return rc;
@ -291,14 +291,14 @@ int img_mgmt_erase_slot(int slot)
int area_id = img_mgmt_flash_area_id(slot); int area_id = img_mgmt_flash_area_id(slot);
if (area_id < 0) { if (area_id < 0) {
return IMG_MGMT_RET_RC_INVALID_SLOT; return IMG_MGMT_ERR_INVALID_SLOT;
} }
rc = flash_area_open(area_id, &fa); rc = flash_area_open(area_id, &fa);
if (rc < 0) { if (rc < 0) {
LOG_ERR("Failed to open flash area ID %u: %d", area_id, rc); LOG_ERR("Failed to open flash area ID %u: %d", area_id, rc);
return IMG_MGMT_RET_RC_FLASH_OPEN_FAILED; return IMG_MGMT_ERR_FLASH_OPEN_FAILED;
} }
rc = img_mgmt_flash_check_empty_inner(fa); rc = img_mgmt_flash_check_empty_inner(fa);
@ -308,7 +308,7 @@ int img_mgmt_erase_slot(int slot)
if (rc != 0) { if (rc != 0) {
LOG_ERR("Failed to erase flash area: %d", rc); LOG_ERR("Failed to erase flash area: %d", rc);
rc = IMG_MGMT_RET_RC_FLASH_ERASE_FAILED; rc = IMG_MGMT_ERR_FLASH_ERASE_FAILED;
} }
} }
@ -322,16 +322,16 @@ int img_mgmt_write_pending(int slot, bool permanent)
int rc; int rc;
if (slot != 1 && !(CONFIG_MCUMGR_GRP_IMG_UPDATABLE_IMAGE_NUMBER == 2 && slot == 3)) { if (slot != 1 && !(CONFIG_MCUMGR_GRP_IMG_UPDATABLE_IMAGE_NUMBER == 2 && slot == 3)) {
return IMG_MGMT_RET_RC_INVALID_SLOT; return IMG_MGMT_ERR_INVALID_SLOT;
} }
rc = boot_request_upgrade_multi(img_mgmt_slot_to_image(slot), permanent); rc = boot_request_upgrade_multi(img_mgmt_slot_to_image(slot), permanent);
if (rc != 0) { if (rc != 0) {
LOG_ERR("Failed to write pending flag for slot %d: %d", slot, rc); LOG_ERR("Failed to write pending flag for slot %d: %d", slot, rc);
return IMG_MGMT_RET_RC_FLASH_WRITE_FAILED; return IMG_MGMT_ERR_FLASH_WRITE_FAILED;
} }
return IMG_MGMT_RET_RC_OK; return IMG_MGMT_ERR_OK;
} }
int img_mgmt_write_confirmed(void) int img_mgmt_write_confirmed(void)
@ -341,10 +341,10 @@ int img_mgmt_write_confirmed(void)
rc = boot_write_img_confirmed(); rc = boot_write_img_confirmed();
if (rc != 0) { if (rc != 0) {
LOG_ERR("Failed to write confirmed flag: %d", rc); LOG_ERR("Failed to write confirmed flag: %d", rc);
return IMG_MGMT_RET_RC_FLASH_WRITE_FAILED; return IMG_MGMT_ERR_FLASH_WRITE_FAILED;
} }
return IMG_MGMT_RET_RC_OK; return IMG_MGMT_ERR_OK;
} }
int img_mgmt_read(int slot, unsigned int offset, void *dst, unsigned int num_bytes) int img_mgmt_read(int slot, unsigned int offset, void *dst, unsigned int num_bytes)
@ -354,13 +354,13 @@ int img_mgmt_read(int slot, unsigned int offset, void *dst, unsigned int num_byt
int area_id = img_mgmt_flash_area_id(slot); int area_id = img_mgmt_flash_area_id(slot);
if (area_id < 0) { if (area_id < 0) {
return IMG_MGMT_RET_RC_INVALID_SLOT; return IMG_MGMT_ERR_INVALID_SLOT;
} }
rc = flash_area_open(area_id, &fa); rc = flash_area_open(area_id, &fa);
if (rc != 0) { if (rc != 0) {
LOG_ERR("Failed to open flash area ID %u: %d", area_id, rc); LOG_ERR("Failed to open flash area ID %u: %d", area_id, rc);
return IMG_MGMT_RET_RC_FLASH_OPEN_FAILED; return IMG_MGMT_ERR_FLASH_OPEN_FAILED;
} }
rc = flash_area_read(fa, offset, dst, num_bytes); rc = flash_area_read(fa, offset, dst, num_bytes);
@ -368,7 +368,7 @@ int img_mgmt_read(int slot, unsigned int offset, void *dst, unsigned int num_byt
if (rc != 0) { if (rc != 0) {
LOG_ERR("Failed to read data from flash: %d", rc); LOG_ERR("Failed to read data from flash: %d", rc);
return IMG_MGMT_RET_RC_FLASH_READ_FAILED; return IMG_MGMT_ERR_FLASH_READ_FAILED;
} }
return 0; return 0;
@ -386,31 +386,31 @@ int img_mgmt_write_image_data(unsigned int offset, const void *data, unsigned in
BUILD_ASSERT(CONFIG_HEAP_MEM_POOL_SIZE >= (sizeof(struct flash_img_context)), BUILD_ASSERT(CONFIG_HEAP_MEM_POOL_SIZE >= (sizeof(struct flash_img_context)),
"Not enough heap mem for flash_img_context."); "Not enough heap mem for flash_img_context.");
int rc = IMG_MGMT_RET_RC_OK; int rc = IMG_MGMT_ERR_OK;
static struct flash_img_context *ctx; static struct flash_img_context *ctx;
if (offset != 0 && ctx == NULL) { if (offset != 0 && ctx == NULL) {
return IMG_MGMT_RET_RC_FLASH_CONTEXT_NOT_SET; return IMG_MGMT_ERR_FLASH_CONTEXT_NOT_SET;
} }
if (offset == 0) { if (offset == 0) {
if (ctx != NULL) { if (ctx != NULL) {
return IMG_MGMT_RET_RC_FLASH_CONTEXT_ALREADY_SET; return IMG_MGMT_ERR_FLASH_CONTEXT_ALREADY_SET;
} }
ctx = k_malloc(sizeof(struct flash_img_context)); ctx = k_malloc(sizeof(struct flash_img_context));
if (ctx == NULL) { if (ctx == NULL) {
return IMG_MGMT_RET_RC_NO_FREE_MEMORY; return IMG_MGMT_ERR_NO_FREE_MEMORY;
} }
if (flash_img_init_id(ctx, g_img_mgmt_state.area_id) != 0) { if (flash_img_init_id(ctx, g_img_mgmt_state.area_id) != 0) {
rc = IMG_MGMT_RET_RC_FLASH_OPEN_FAILED; rc = IMG_MGMT_ERR_FLASH_OPEN_FAILED;
goto out; goto out;
} }
} }
if (flash_img_buffered_write(ctx, data, num_bytes, last) != 0) { if (flash_img_buffered_write(ctx, data, num_bytes, last) != 0) {
rc = IMG_MGMT_RET_RC_FLASH_WRITE_FAILED; rc = IMG_MGMT_ERR_FLASH_WRITE_FAILED;
goto out; goto out;
} }
@ -430,15 +430,15 @@ int img_mgmt_write_image_data(unsigned int offset, const void *data, unsigned in
if (offset == 0) { if (offset == 0) {
if (flash_img_init_id(&ctx, g_img_mgmt_state.area_id) != 0) { if (flash_img_init_id(&ctx, g_img_mgmt_state.area_id) != 0) {
return IMG_MGMT_RET_RC_FLASH_OPEN_FAILED; return IMG_MGMT_ERR_FLASH_OPEN_FAILED;
} }
} }
if (flash_img_buffered_write(&ctx, data, num_bytes, last) != 0) { if (flash_img_buffered_write(&ctx, data, num_bytes, last) != 0) {
return IMG_MGMT_RET_RC_FLASH_WRITE_FAILED; return IMG_MGMT_ERR_FLASH_WRITE_FAILED;
} }
return IMG_MGMT_RET_RC_OK; return IMG_MGMT_ERR_OK;
} }
#endif #endif
@ -448,14 +448,14 @@ int img_mgmt_erase_image_data(unsigned int off, unsigned int num_bytes)
int rc; int rc;
if (off != 0) { if (off != 0) {
rc = IMG_MGMT_RET_RC_INVALID_OFFSET; rc = IMG_MGMT_ERR_INVALID_OFFSET;
goto end; goto end;
} }
rc = flash_area_open(g_img_mgmt_state.area_id, &fa); rc = flash_area_open(g_img_mgmt_state.area_id, &fa);
if (rc != 0) { if (rc != 0) {
LOG_ERR("Can't bind to the flash area (err %d)", rc); LOG_ERR("Can't bind to the flash area (err %d)", rc);
rc = IMG_MGMT_RET_RC_FLASH_OPEN_FAILED; rc = IMG_MGMT_ERR_FLASH_OPEN_FAILED;
goto end; goto end;
} }
@ -463,7 +463,7 @@ int img_mgmt_erase_image_data(unsigned int off, unsigned int num_bytes)
const struct device *dev = flash_area_get_device(fa); const struct device *dev = flash_area_get_device(fa);
if (dev == NULL) { if (dev == NULL) {
rc = IMG_MGMT_RET_RC_FLASH_AREA_DEVICE_NULL; rc = IMG_MGMT_ERR_FLASH_AREA_DEVICE_NULL;
goto end_fa; goto end_fa;
} }
struct flash_pages_info page; struct flash_pages_info page;
@ -472,7 +472,7 @@ int img_mgmt_erase_image_data(unsigned int off, unsigned int num_bytes)
rc = flash_get_page_info_by_offs(dev, page_offset, &page); rc = flash_get_page_info_by_offs(dev, page_offset, &page);
if (rc != 0) { if (rc != 0) {
LOG_ERR("bad offset (0x%lx)", (long)page_offset); LOG_ERR("bad offset (0x%lx)", (long)page_offset);
rc = IMG_MGMT_RET_RC_INVALID_PAGE_OFFSET; rc = IMG_MGMT_ERR_INVALID_PAGE_OFFSET;
goto end_fa; goto end_fa;
} }
@ -483,7 +483,7 @@ int img_mgmt_erase_image_data(unsigned int off, unsigned int num_bytes)
if (rc != 0) { if (rc != 0) {
LOG_ERR("image slot erase of 0x%zx bytes failed (err %d)", erase_size, LOG_ERR("image slot erase of 0x%zx bytes failed (err %d)", erase_size,
rc); rc);
rc = IMG_MGMT_RET_RC_FLASH_ERASE_FAILED; rc = IMG_MGMT_ERR_FLASH_ERASE_FAILED;
goto end_fa; goto end_fa;
} }
@ -507,14 +507,14 @@ int img_mgmt_erase_image_data(unsigned int off, unsigned int num_bytes)
if (rc != 0) { if (rc != 0) {
LOG_ERR("image slot trailer erase of 0x%zx bytes failed (err %d)", LOG_ERR("image slot trailer erase of 0x%zx bytes failed (err %d)",
erase_size, rc); erase_size, rc);
rc = IMG_MGMT_RET_RC_FLASH_ERASE_FAILED; rc = IMG_MGMT_ERR_FLASH_ERASE_FAILED;
goto end_fa; goto end_fa;
} }
LOG_INF("Erased 0x%zx bytes of image slot trailer", erase_size); LOG_INF("Erased 0x%zx bytes of image slot trailer", erase_size);
} }
#endif #endif
rc = IMG_MGMT_RET_RC_OK; rc = IMG_MGMT_ERR_OK;
end_fa: end_fa:
flash_area_close(fa); flash_area_close(fa);
@ -565,7 +565,7 @@ int img_mgmt_upload_inspect(const struct img_mgmt_upload_req *req,
if (req->off == SIZE_MAX) { if (req->off == SIZE_MAX) {
/* Request did not include an `off` field. */ /* Request did not include an `off` field. */
IMG_MGMT_UPLOAD_ACTION_SET_RC_RSN(action, img_mgmt_err_str_hdr_malformed); IMG_MGMT_UPLOAD_ACTION_SET_RC_RSN(action, img_mgmt_err_str_hdr_malformed);
return IMG_MGMT_RET_RC_INVALID_OFFSET; return IMG_MGMT_ERR_INVALID_OFFSET;
} }
if (req->off == 0) { if (req->off == 0) {
@ -575,24 +575,24 @@ int img_mgmt_upload_inspect(const struct img_mgmt_upload_req *req,
if (req->img_data.len < sizeof(struct image_header)) { if (req->img_data.len < sizeof(struct image_header)) {
/* Image header is the first thing in the image */ /* Image header is the first thing in the image */
IMG_MGMT_UPLOAD_ACTION_SET_RC_RSN(action, img_mgmt_err_str_hdr_malformed); IMG_MGMT_UPLOAD_ACTION_SET_RC_RSN(action, img_mgmt_err_str_hdr_malformed);
return IMG_MGMT_RET_RC_INVALID_IMAGE_HEADER; return IMG_MGMT_ERR_INVALID_IMAGE_HEADER;
} }
if (req->size == SIZE_MAX) { if (req->size == SIZE_MAX) {
/* Request did not include a `len` field. */ /* Request did not include a `len` field. */
IMG_MGMT_UPLOAD_ACTION_SET_RC_RSN(action, img_mgmt_err_str_hdr_malformed); IMG_MGMT_UPLOAD_ACTION_SET_RC_RSN(action, img_mgmt_err_str_hdr_malformed);
return IMG_MGMT_RET_RC_INVALID_LENGTH; return IMG_MGMT_ERR_INVALID_LENGTH;
} }
action->size = req->size; action->size = req->size;
hdr = (struct image_header *)req->img_data.value; hdr = (struct image_header *)req->img_data.value;
if (hdr->ih_magic != IMAGE_MAGIC) { if (hdr->ih_magic != IMAGE_MAGIC) {
IMG_MGMT_UPLOAD_ACTION_SET_RC_RSN(action, img_mgmt_err_str_magic_mismatch); IMG_MGMT_UPLOAD_ACTION_SET_RC_RSN(action, img_mgmt_err_str_magic_mismatch);
return IMG_MGMT_RET_RC_INVALID_IMAGE_HEADER_MAGIC; return IMG_MGMT_ERR_INVALID_IMAGE_HEADER_MAGIC;
} }
if (req->data_sha.len > IMG_MGMT_DATA_SHA_LEN) { if (req->data_sha.len > IMG_MGMT_DATA_SHA_LEN) {
return IMG_MGMT_RET_RC_INVALID_HASH; return IMG_MGMT_ERR_INVALID_HASH;
} }
/* /*
@ -605,7 +605,7 @@ int img_mgmt_upload_inspect(const struct img_mgmt_upload_req *req,
if ((g_img_mgmt_state.data_sha_len == req->data_sha.len) && if ((g_img_mgmt_state.data_sha_len == req->data_sha.len) &&
!memcmp(g_img_mgmt_state.data_sha, req->data_sha.value, !memcmp(g_img_mgmt_state.data_sha, req->data_sha.value,
req->data_sha.len)) { req->data_sha.len)) {
return IMG_MGMT_RET_RC_OK; return IMG_MGMT_ERR_OK;
} }
} }
@ -613,7 +613,7 @@ int img_mgmt_upload_inspect(const struct img_mgmt_upload_req *req,
if (action->area_id < 0) { if (action->area_id < 0) {
/* No slot where to upload! */ /* No slot where to upload! */
IMG_MGMT_UPLOAD_ACTION_SET_RC_RSN(action, img_mgmt_err_str_no_slot); IMG_MGMT_UPLOAD_ACTION_SET_RC_RSN(action, img_mgmt_err_str_no_slot);
return IMG_MGMT_RET_RC_NO_FREE_SLOT; return IMG_MGMT_ERR_NO_FREE_SLOT;
} }
rc = flash_area_open(action->area_id, &fa); rc = flash_area_open(action->area_id, &fa);
@ -621,7 +621,7 @@ int img_mgmt_upload_inspect(const struct img_mgmt_upload_req *req,
IMG_MGMT_UPLOAD_ACTION_SET_RC_RSN(action, IMG_MGMT_UPLOAD_ACTION_SET_RC_RSN(action,
img_mgmt_err_str_flash_open_failed); img_mgmt_err_str_flash_open_failed);
LOG_ERR("Failed to open flash area ID %u: %d", action->area_id, rc); LOG_ERR("Failed to open flash area ID %u: %d", action->area_id, rc);
return IMG_MGMT_RET_RC_FLASH_OPEN_FAILED; return IMG_MGMT_ERR_FLASH_OPEN_FAILED;
} }
/* Check that the area is of sufficient size to store the new image */ /* Check that the area is of sufficient size to store the new image */
@ -630,7 +630,7 @@ int img_mgmt_upload_inspect(const struct img_mgmt_upload_req *req,
img_mgmt_err_str_image_too_large); img_mgmt_err_str_image_too_large);
flash_area_close(fa); flash_area_close(fa);
LOG_ERR("Upload too large for slot: %u > %u", req->size, fa->fa_size); LOG_ERR("Upload too large for slot: %u > %u", req->size, fa->fa_size);
return IMG_MGMT_RET_RC_INVALID_IMAGE_TOO_LARGE; return IMG_MGMT_ERR_INVALID_IMAGE_TOO_LARGE;
} }
#if defined(CONFIG_MCUMGR_GRP_IMG_REJECT_DIRECT_XIP_MISMATCHED_SLOT) #if defined(CONFIG_MCUMGR_GRP_IMG_REJECT_DIRECT_XIP_MISMATCHED_SLOT)
@ -639,7 +639,7 @@ int img_mgmt_upload_inspect(const struct img_mgmt_upload_req *req,
IMG_MGMT_UPLOAD_ACTION_SET_RC_RSN(action, IMG_MGMT_UPLOAD_ACTION_SET_RC_RSN(action,
img_mgmt_err_str_image_bad_flash_addr); img_mgmt_err_str_image_bad_flash_addr);
flash_area_close(fa); flash_area_close(fa);
return IMG_MGMT_RET_RC_INVALID_FLASH_ADDRESS; return IMG_MGMT_ERR_INVALID_FLASH_ADDRESS;
} }
} }
#endif #endif
@ -652,13 +652,13 @@ int img_mgmt_upload_inspect(const struct img_mgmt_upload_req *req,
*/ */
rc = img_mgmt_my_version(&cur_ver); rc = img_mgmt_my_version(&cur_ver);
if (rc != 0) { if (rc != 0) {
return IMG_MGMT_RET_RC_VERSION_GET_FAILED; return IMG_MGMT_ERR_VERSION_GET_FAILED;
} }
if (img_mgmt_vercmp(&cur_ver, &hdr->ih_ver) >= 0) { if (img_mgmt_vercmp(&cur_ver, &hdr->ih_ver) >= 0) {
IMG_MGMT_UPLOAD_ACTION_SET_RC_RSN(action, IMG_MGMT_UPLOAD_ACTION_SET_RC_RSN(action,
img_mgmt_err_str_downgrade); img_mgmt_err_str_downgrade);
return IMG_MGMT_RET_RC_CURRENT_VERSION_IS_NEWER; return IMG_MGMT_ERR_CURRENT_VERSION_IS_NEWER;
} }
} }
@ -680,7 +680,7 @@ int img_mgmt_upload_inspect(const struct img_mgmt_upload_req *req,
* Invalid offset. Drop the data, and respond with the offset we're * Invalid offset. Drop the data, and respond with the offset we're
* expecting data for. * expecting data for.
*/ */
return IMG_MGMT_RET_RC_OK; return IMG_MGMT_ERR_OK;
} }
if ((req->off + req->img_data.len) > action->size) { if ((req->off + req->img_data.len) > action->size) {
@ -688,7 +688,7 @@ int img_mgmt_upload_inspect(const struct img_mgmt_upload_req *req,
* of the image that the client originally sent * of the image that the client originally sent
*/ */
IMG_MGMT_UPLOAD_ACTION_SET_RC_RSN(action, img_mgmt_err_str_data_overrun); IMG_MGMT_UPLOAD_ACTION_SET_RC_RSN(action, img_mgmt_err_str_data_overrun);
return IMG_MGMT_RET_RC_INVALID_IMAGE_DATA_OVERRUN; return IMG_MGMT_ERR_INVALID_IMAGE_DATA_OVERRUN;
} }
} }
@ -696,7 +696,7 @@ int img_mgmt_upload_inspect(const struct img_mgmt_upload_req *req,
action->proceed = true; action->proceed = true;
IMG_MGMT_UPLOAD_ACTION_SET_RC_RSN(action, NULL); IMG_MGMT_UPLOAD_ACTION_SET_RC_RSN(action, NULL);
return IMG_MGMT_RET_RC_OK; return IMG_MGMT_ERR_OK;
} }
int img_mgmt_erased_val(int slot, uint8_t *erased_val) int img_mgmt_erased_val(int slot, uint8_t *erased_val)
@ -706,13 +706,13 @@ int img_mgmt_erased_val(int slot, uint8_t *erased_val)
int area_id = img_mgmt_flash_area_id(slot); int area_id = img_mgmt_flash_area_id(slot);
if (area_id < 0) { if (area_id < 0) {
return IMG_MGMT_RET_RC_INVALID_SLOT; return IMG_MGMT_ERR_INVALID_SLOT;
} }
rc = flash_area_open(area_id, &fa); rc = flash_area_open(area_id, &fa);
if (rc != 0) { if (rc != 0) {
LOG_ERR("Failed to open flash area ID %u: %d", area_id, rc); LOG_ERR("Failed to open flash area ID %u: %d", area_id, rc);
return IMG_MGMT_RET_RC_FLASH_OPEN_FAILED; return IMG_MGMT_ERR_FLASH_OPEN_FAILED;
} }
*erased_val = flash_area_erased_val(fa); *erased_val = flash_area_erased_val(fa);

34
subsys/mgmt/mcumgr/grp/os_mgmt/src/os_mgmt.c
View file

@ -318,8 +318,8 @@ static int os_mgmt_reset(struct smp_streamer *ctxt)
zcbor_state_t *zse = ctxt->writer->zs; zcbor_state_t *zse = ctxt->writer->zs;
size_t decoded; size_t decoded;
enum mgmt_cb_return status; enum mgmt_cb_return status;
int32_t ret_rc; int32_t err_rc;
uint16_t ret_group; uint16_t err_group;
struct os_mgmt_reset_data reboot_data = { struct os_mgmt_reset_data reboot_data = {
.force = false .force = false
@ -334,16 +334,16 @@ static int os_mgmt_reset(struct smp_streamer *ctxt)
*/ */
(void)zcbor_map_decode_bulk(zsd, reset_decode, ARRAY_SIZE(reset_decode), &decoded); (void)zcbor_map_decode_bulk(zsd, reset_decode, ARRAY_SIZE(reset_decode), &decoded);
status = mgmt_callback_notify(MGMT_EVT_OP_OS_MGMT_RESET, &reboot_data, status = mgmt_callback_notify(MGMT_EVT_OP_OS_MGMT_RESET, &reboot_data,
sizeof(reboot_data), &ret_rc, &ret_group); sizeof(reboot_data), &err_rc, &err_group);
if (status != MGMT_CB_OK) { if (status != MGMT_CB_OK) {
bool ok; bool ok;
if (status == MGMT_CB_ERROR_RC) { if (status == MGMT_CB_ERROR_RC) {
return ret_rc; return err_rc;
} }
ok = smp_add_cmd_ret(zse, ret_group, (uint16_t)ret_rc); ok = smp_add_cmd_err(zse, err_group, (uint16_t)err_rc);
return ok ? MGMT_ERR_EOK : MGMT_ERR_EMSGSIZE; return ok ? MGMT_ERR_EOK : MGMT_ERR_EMSGSIZE;
} }
#endif #endif
@ -413,8 +413,8 @@ static int os_mgmt_info(struct smp_streamer *ctxt)
#ifdef CONFIG_MCUMGR_GRP_OS_INFO_CUSTOM_HOOKS #ifdef CONFIG_MCUMGR_GRP_OS_INFO_CUSTOM_HOOKS
enum mgmt_cb_return status; enum mgmt_cb_return status;
int32_t ret_rc; int32_t err_rc;
uint16_t ret_group; uint16_t err_group;
#endif #endif
if (zcbor_map_decode_bulk(zsd, fs_info_decode, ARRAY_SIZE(fs_info_decode), &decoded)) { if (zcbor_map_decode_bulk(zsd, fs_info_decode, ARRAY_SIZE(fs_info_decode), &decoded)) {
@ -491,12 +491,12 @@ static int os_mgmt_info(struct smp_streamer *ctxt)
#ifdef CONFIG_MCUMGR_GRP_OS_INFO_CUSTOM_HOOKS #ifdef CONFIG_MCUMGR_GRP_OS_INFO_CUSTOM_HOOKS
/* Run callbacks to see if any additional handlers will add options */ /* Run callbacks to see if any additional handlers will add options */
(void)mgmt_callback_notify(MGMT_EVT_OP_OS_MGMT_INFO_CHECK, &check_data, (void)mgmt_callback_notify(MGMT_EVT_OP_OS_MGMT_INFO_CHECK, &check_data,
sizeof(check_data), &ret_rc, &ret_group); sizeof(check_data), &err_rc, &err_group);
#endif #endif
if (valid_formats != format.len) { if (valid_formats != format.len) {
/* A provided format specifier is not valid */ /* A provided format specifier is not valid */
bool ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_OS, OS_MGMT_RET_RC_INVALID_FORMAT); bool ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_OS, OS_MGMT_ERR_INVALID_FORMAT);
return ok ? MGMT_ERR_EOK : MGMT_ERR_EMSGSIZE; return ok ? MGMT_ERR_EOK : MGMT_ERR_EMSGSIZE;
} else if (format_bitmask == 0) { } else if (format_bitmask == 0) {
@ -657,16 +657,16 @@ static int os_mgmt_info(struct smp_streamer *ctxt)
#ifdef CONFIG_MCUMGR_GRP_OS_INFO_CUSTOM_HOOKS #ifdef CONFIG_MCUMGR_GRP_OS_INFO_CUSTOM_HOOKS
/* Call custom handler command for additional output/processing */ /* Call custom handler command for additional output/processing */
status = mgmt_callback_notify(MGMT_EVT_OP_OS_MGMT_INFO_APPEND, &append_data, status = mgmt_callback_notify(MGMT_EVT_OP_OS_MGMT_INFO_APPEND, &append_data,
sizeof(append_data), &ret_rc, &ret_group); sizeof(append_data), &err_rc, &err_group);
if (status != MGMT_CB_OK) { if (status != MGMT_CB_OK) {
bool ok; bool ok;
if (status == MGMT_CB_ERROR_RC) { if (status == MGMT_CB_ERROR_RC) {
return ret_rc; return err_rc;
} }
ok = smp_add_cmd_ret(zse, ret_group, (uint16_t)ret_rc); ok = smp_add_cmd_err(zse, err_group, (uint16_t)err_rc);
return ok ? MGMT_ERR_EOK : MGMT_ERR_EMSGSIZE; return ok ? MGMT_ERR_EOK : MGMT_ERR_EMSGSIZE;
} }
#endif #endif
@ -685,20 +685,20 @@ fail:
/* /*
* @brief Translate OS mgmt group error code into MCUmgr error code * @brief Translate OS mgmt group error code into MCUmgr error code
* *
* @param ret #os_mgmt_ret_code_t error code * @param ret #os_mgmt_err_code_t error code
* *
* @return #mcumgr_err_t error code * @return #mcumgr_err_t error code
*/ */
static int os_mgmt_translate_error_code(uint16_t ret) static int os_mgmt_translate_error_code(uint16_t err)
{ {
int rc; int rc;
switch (ret) { switch (err) {
case OS_MGMT_RET_RC_INVALID_FORMAT: case OS_MGMT_ERR_INVALID_FORMAT:
rc = MGMT_ERR_EINVAL; rc = MGMT_ERR_EINVAL;
break; break;
case OS_MGMT_RET_RC_UNKNOWN: case OS_MGMT_ERR_UNKNOWN:
default: default:
rc = MGMT_ERR_EUNKNOWN; rc = MGMT_ERR_EUNKNOWN;
} }

16
subsys/mgmt/mcumgr/grp/shell_mgmt/src/shell_mgmt.c
View file

@ -84,8 +84,8 @@ shell_mgmt_exec(struct smp_streamer *ctxt)
ok = zcbor_tstr_decode(zsd, &value); ok = zcbor_tstr_decode(zsd, &value);
if (ok) { if (ok) {
if ((len + value.len) >= (ARRAY_SIZE(line) - 1)) { if ((len + value.len) >= (ARRAY_SIZE(line) - 1)) {
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_SHELL, ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_SHELL,
SHELL_MGMT_RET_RC_COMMAND_TOO_LONG); SHELL_MGMT_ERR_COMMAND_TOO_LONG);
goto end; goto end;
} }
@ -104,7 +104,7 @@ shell_mgmt_exec(struct smp_streamer *ctxt)
if (len == 0) { if (len == 0) {
/* We do not bother to close decoder */ /* We do not bother to close decoder */
LOG_ERR("Failed to compose command line"); LOG_ERR("Failed to compose command line");
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_SHELL, SHELL_MGMT_RET_RC_EMPTY_COMMAND); ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_SHELL, SHELL_MGMT_ERR_EMPTY_COMMAND);
goto end; goto end;
} }
@ -132,17 +132,17 @@ end:
/* /*
* @brief Translate shell mgmt group error code into MCUmgr error code * @brief Translate shell mgmt group error code into MCUmgr error code
* *
* @param ret #shell_mgmt_ret_code_t error code * @param ret #shell_mgmt_err_code_t error code
* *
* @return #mcumgr_err_t error code * @return #mcumgr_err_t error code
*/ */
static int shell_mgmt_translate_error_code(uint16_t ret) static int shell_mgmt_translate_error_code(uint16_t err)
{ {
int rc; int rc;
switch (ret) { switch (err) {
case SHELL_MGMT_RET_RC_COMMAND_TOO_LONG: case SHELL_MGMT_ERR_COMMAND_TOO_LONG:
case SHELL_MGMT_RET_RC_EMPTY_COMMAND: case SHELL_MGMT_ERR_EMPTY_COMMAND:
rc = MGMT_ERR_EINVAL; rc = MGMT_ERR_EINVAL;
break; break;

32
subsys/mgmt/mcumgr/grp/stat_mgmt/src/stat_mgmt.c
View file

@ -80,7 +80,7 @@ stat_mgmt_walk_cb(struct stats_hdr *hdr, void *arg, const char *name, uint16_t o
entry.value = *(uint64_t *) stat_val; entry.value = *(uint64_t *) stat_val;
break; break;
default: default:
return STAT_MGMT_RET_RC_INVALID_STAT_SIZE; return STAT_MGMT_ERR_INVALID_STAT_SIZE;
} }
entry.name = name; entry.name = name;
@ -96,7 +96,7 @@ stat_mgmt_foreach_entry(zcbor_state_t *zse, const char *group_name, stat_mgmt_fo
hdr = stats_group_find(group_name); hdr = stats_group_find(group_name);
if (hdr == NULL) { if (hdr == NULL) {
return STAT_MGMT_RET_RC_INVALID_GROUP; return STAT_MGMT_ERR_INVALID_GROUP;
} }
walk_arg = (struct stat_mgmt_walk_arg) { walk_arg = (struct stat_mgmt_walk_arg) {
@ -145,8 +145,8 @@ stat_mgmt_show(struct smp_streamer *ctxt)
if (stat_mgmt_count(stat_name, &counter) != 0) { if (stat_mgmt_count(stat_name, &counter) != 0) {
LOG_ERR("Invalid stat name: %s", stat_name); LOG_ERR("Invalid stat name: %s", stat_name);
ok = smp_add_cmd_ret(zse, ZEPHYR_MGMT_GRP_BASIC, ok = smp_add_cmd_err(zse, ZEPHYR_MGMT_GRP_BASIC,
STAT_MGMT_RET_RC_INVALID_STAT_NAME); STAT_MGMT_ERR_INVALID_STAT_NAME);
goto end; goto end;
} }
@ -166,13 +166,13 @@ stat_mgmt_show(struct smp_streamer *ctxt)
int rc = stat_mgmt_foreach_entry(zse, stat_name, int rc = stat_mgmt_foreach_entry(zse, stat_name,
stat_mgmt_cb_encode); stat_mgmt_cb_encode);
if (rc != STAT_MGMT_RET_RC_OK) { if (rc != STAT_MGMT_ERR_OK) {
if (rc != STAT_MGMT_RET_RC_INVALID_GROUP && if (rc != STAT_MGMT_ERR_INVALID_GROUP &&
rc != STAT_MGMT_RET_RC_INVALID_STAT_SIZE) { rc != STAT_MGMT_ERR_INVALID_STAT_SIZE) {
rc = STAT_MGMT_RET_RC_WALK_ABORTED; rc = STAT_MGMT_ERR_WALK_ABORTED;
} }
ok = smp_add_cmd_ret(zse, ZEPHYR_MGMT_GRP_BASIC, rc); ok = smp_add_cmd_err(zse, ZEPHYR_MGMT_GRP_BASIC, rc);
} }
} }
@ -230,25 +230,25 @@ stat_mgmt_list(struct smp_streamer *ctxt)
/* /*
* @brief Translate stat mgmt group error code into MCUmgr error code * @brief Translate stat mgmt group error code into MCUmgr error code
* *
* @param ret #stat_mgmt_ret_code_t error code * @param ret #stat_mgmt_err_code_t error code
* *
* @return #mcumgr_err_t error code * @return #mcumgr_err_t error code
*/ */
static int stat_mgmt_translate_error_code(uint16_t ret) static int stat_mgmt_translate_error_code(uint16_t err)
{ {
int rc; int rc;
switch (ret) { switch (err) {
case STAT_MGMT_RET_RC_INVALID_GROUP: case STAT_MGMT_ERR_INVALID_GROUP:
case STAT_MGMT_RET_RC_INVALID_STAT_NAME: case STAT_MGMT_ERR_INVALID_STAT_NAME:
rc = MGMT_ERR_ENOENT; rc = MGMT_ERR_ENOENT;
break; break;
case STAT_MGMT_RET_RC_INVALID_STAT_SIZE: case STAT_MGMT_ERR_INVALID_STAT_SIZE:
rc = MGMT_ERR_EINVAL; rc = MGMT_ERR_EINVAL;
break; break;
case STAT_MGMT_RET_RC_WALK_ABORTED: case STAT_MGMT_ERR_WALK_ABORTED:
default: default:
rc = MGMT_ERR_EUNKNOWN; rc = MGMT_ERR_EUNKNOWN;
} }

18
subsys/mgmt/mcumgr/grp/zephyr_basic/src/basic_mgmt.c
View file

@ -25,17 +25,17 @@ static int storage_erase(void)
if (rc < 0) { if (rc < 0) {
LOG_ERR("Failed to open flash area"); LOG_ERR("Failed to open flash area");
rc = ZEPHYR_MGMT_GRP_CMD_RC_FLASH_OPEN_FAILED; rc = ZEPHYRBASIC_MGMT_ERR_FLASH_OPEN_FAILED;
} else { } else {
if (flash_area_get_device(fa) == NULL) { if (flash_area_get_device(fa) == NULL) {
LOG_ERR("Failed to get flash area device"); LOG_ERR("Failed to get flash area device");
rc = ZEPHYR_MGMT_GRP_CMD_RC_FLASH_CONFIG_QUERY_FAIL; rc = ZEPHYRBASIC_MGMT_ERR_FLASH_CONFIG_QUERY_FAIL;
} else { } else {
rc = flash_area_erase(fa, 0, fa->fa_size); rc = flash_area_erase(fa, 0, fa->fa_size);
if (rc < 0) { if (rc < 0) {
LOG_ERR("Failed to erase flash area"); LOG_ERR("Failed to erase flash area");
rc = ZEPHYR_MGMT_GRP_CMD_RC_FLASH_ERASE_FAILED; rc = ZEPHYRBASIC_MGMT_ERR_FLASH_ERASE_FAILED;
} }
} }
@ -53,8 +53,8 @@ static int storage_erase_handler(struct smp_streamer *ctxt)
rc = storage_erase(); rc = storage_erase();
if (rc != ZEPHYR_MGMT_GRP_CMD_RC_OK) { if (rc != ZEPHYRBASIC_MGMT_ERR_OK) {
ok = smp_add_cmd_ret(zse, ZEPHYR_MGMT_GRP_BASIC, rc); ok = smp_add_cmd_err(zse, ZEPHYR_MGMT_GRP_BASIC, rc);
} }
if (!ok) { if (!ok) {
@ -68,7 +68,7 @@ static int storage_erase_handler(struct smp_streamer *ctxt)
/* /*
* @brief Translate zephyr basic group error code into MCUmgr error code * @brief Translate zephyr basic group error code into MCUmgr error code
* *
* @param ret #zephyr_basic_group_ret_code_t error code * @param ret #zephyr_basic_group_err_code_t error code
* *
* @return #mcumgr_err_t error code * @return #mcumgr_err_t error code
*/ */
@ -77,12 +77,12 @@ static int zephyr_basic_group_translate_error_code(uint16_t ret)
int rc; int rc;
switch (ret) { switch (ret) {
case ZEPHYR_MGMT_GRP_CMD_RC_FLASH_OPEN_FAILED: case ZEPHYRBASIC_MGMT_ERR_FLASH_OPEN_FAILED:
rc = MGMT_ERR_ENOENT; rc = MGMT_ERR_ENOENT;
break; break;
case ZEPHYR_MGMT_GRP_CMD_RC_FLASH_CONFIG_QUERY_FAIL: case ZEPHYRBASIC_MGMT_ERR_FLASH_CONFIG_QUERY_FAIL:
case ZEPHYR_MGMT_GRP_CMD_RC_FLASH_ERASE_FAILED: case ZEPHYRBASIC_MGMT_ERR_FLASH_ERASE_FAILED:
rc = MGMT_ERR_EOK; rc = MGMT_ERR_EOK;
break; break;

18
subsys/mgmt/mcumgr/mgmt/src/mgmt.c
View file

@ -111,7 +111,7 @@ void mgmt_callback_unregister(struct mgmt_callback *callback)
} }
enum mgmt_cb_return mgmt_callback_notify(uint32_t event, void *data, size_t data_size, enum mgmt_cb_return mgmt_callback_notify(uint32_t event, void *data, size_t data_size,
int32_t *ret_rc, uint16_t *ret_group) int32_t *err_rc, uint16_t *err_group)
{ {
sys_snode_t *snp, *sns; sys_snode_t *snp, *sns;
bool failed = false; bool failed = false;
@ -119,8 +119,8 @@ enum mgmt_cb_return mgmt_callback_notify(uint32_t event, void *data, size_t data
uint16_t group = MGMT_EVT_GET_GROUP(event); uint16_t group = MGMT_EVT_GET_GROUP(event);
enum mgmt_cb_return return_status = MGMT_CB_OK; enum mgmt_cb_return return_status = MGMT_CB_OK;
*ret_rc = MGMT_ERR_EOK; *err_rc = MGMT_ERR_EOK;
*ret_group = 0; *err_group = 0;
/* /*
* Search through the linked list for entries that have registered for this event and * Search through the linked list for entries that have registered for this event and
@ -139,24 +139,24 @@ enum mgmt_cb_return mgmt_callback_notify(uint32_t event, void *data, size_t data
(MGMT_EVT_GET_GROUP(loop_group->event_id) == group && (MGMT_EVT_GET_GROUP(loop_group->event_id) == group &&
(MGMT_EVT_GET_ID(event) & MGMT_EVT_GET_ID(loop_group->event_id)) == (MGMT_EVT_GET_ID(event) & MGMT_EVT_GET_ID(loop_group->event_id)) ==
MGMT_EVT_GET_ID(event))) { MGMT_EVT_GET_ID(event))) {
int32_t cached_rc = *ret_rc; int32_t cached_rc = *err_rc;
uint16_t cached_group = *ret_group; uint16_t cached_group = *err_group;
enum mgmt_cb_return status; enum mgmt_cb_return status;
status = loop_group->callback(event, return_status, &cached_rc, status = loop_group->callback(event, return_status, &cached_rc,
&cached_group, &abort_more, data, &cached_group, &abort_more, data,
data_size); data_size);
__ASSERT((status <= MGMT_CB_ERROR_RET), __ASSERT((status <= MGMT_CB_ERROR_ERR),
"Invalid status returned by MCUmgr handler: %d", status); "Invalid status returned by MCUmgr handler: %d", status);
if (status != MGMT_CB_OK && failed == false) { if (status != MGMT_CB_OK && failed == false) {
failed = true; failed = true;
return_status = status; return_status = status;
*ret_rc = cached_rc; *err_rc = cached_rc;
if (status == MGMT_CB_ERROR_RET) { if (status == MGMT_CB_ERROR_ERR) {
*ret_group = cached_group; *err_group = cached_group;
} }
} }

30
subsys/mgmt/mcumgr/smp/src/smp.c
View file

@ -31,11 +31,11 @@
* @brief Translate SMP version 2 error code to legacy SMP version 1 MCUmgr error code. * @brief Translate SMP version 2 error code to legacy SMP version 1 MCUmgr error code.
* *
* @param group #mcumgr_group_t group ID * @param group #mcumgr_group_t group ID
* @param ret Group-specific error code * @param err Group-specific error code
* *
* @return #mcumgr_err_t error code * @return #mcumgr_err_t error code
*/ */
static int smp_translate_error_code(uint16_t group, uint16_t ret) static int smp_translate_error_code(uint16_t group, uint16_t err)
{ {
smp_translate_error_fn translate_error_function = NULL; smp_translate_error_fn translate_error_function = NULL;
@ -45,7 +45,7 @@ static int smp_translate_error_code(uint16_t group, uint16_t ret)
return MGMT_ERR_EUNKNOWN; return MGMT_ERR_EUNKNOWN;
} }
return translate_error_function(ret); return translate_error_function(err);
} }
#endif #endif
@ -165,8 +165,8 @@ static int smp_handle_single_payload(struct smp_streamer *cbuf, const struct smp
#if defined(CONFIG_MCUMGR_SMP_COMMAND_STATUS_HOOKS) #if defined(CONFIG_MCUMGR_SMP_COMMAND_STATUS_HOOKS)
enum mgmt_cb_return status; enum mgmt_cb_return status;
struct mgmt_evt_op_cmd_arg cmd_recv; struct mgmt_evt_op_cmd_arg cmd_recv;
int32_t ret_rc; int32_t err_rc;
uint16_t ret_group; uint16_t err_group;
#endif #endif
handler = mgmt_find_handler(req_hdr->nh_group, req_hdr->nh_id); handler = mgmt_find_handler(req_hdr->nh_group, req_hdr->nh_id);
@ -207,17 +207,17 @@ static int smp_handle_single_payload(struct smp_streamer *cbuf, const struct smp
/* Send request to application to check if handler should run or not. */ /* Send request to application to check if handler should run or not. */
status = mgmt_callback_notify(MGMT_EVT_OP_CMD_RECV, &cmd_recv, sizeof(cmd_recv), status = mgmt_callback_notify(MGMT_EVT_OP_CMD_RECV, &cmd_recv, sizeof(cmd_recv),
&ret_rc, &ret_group); &err_rc, &err_group);
/* Skip running the command if a handler reported an error and return that /* Skip running the command if a handler reported an error and return that
* instead. * instead.
*/ */
if (status != MGMT_CB_OK) { if (status != MGMT_CB_OK) {
if (status == MGMT_CB_ERROR_RC) { if (status == MGMT_CB_ERROR_RC) {
rc = ret_rc; rc = err_rc;
} else { } else {
ok = smp_add_cmd_ret(cbuf->writer->zs, ret_group, ok = smp_add_cmd_err(cbuf->writer->zs, err_group,
(uint16_t)ret_rc); (uint16_t)err_rc);
rc = (ok ? MGMT_ERR_EOK : MGMT_ERR_EMSGSIZE); rc = (ok ? MGMT_ERR_EOK : MGMT_ERR_EMSGSIZE);
} }
@ -374,8 +374,8 @@ int smp_process_request_packet(struct smp_streamer *streamer, void *vreq)
#if defined(CONFIG_MCUMGR_SMP_COMMAND_STATUS_HOOKS) #if defined(CONFIG_MCUMGR_SMP_COMMAND_STATUS_HOOKS)
struct mgmt_evt_op_cmd_arg cmd_done_arg; struct mgmt_evt_op_cmd_arg cmd_done_arg;
int32_t ret_rc; int32_t err_rc;
uint16_t ret_group; uint16_t err_group;
#endif #endif
rsp = NULL; rsp = NULL;
@ -446,7 +446,7 @@ int smp_process_request_packet(struct smp_streamer *streamer, void *vreq)
cmd_done_arg.err = MGMT_ERR_EOK; cmd_done_arg.err = MGMT_ERR_EOK;
(void)mgmt_callback_notify(MGMT_EVT_OP_CMD_DONE, &cmd_done_arg, (void)mgmt_callback_notify(MGMT_EVT_OP_CMD_DONE, &cmd_done_arg,
sizeof(cmd_done_arg), &ret_rc, &ret_group); sizeof(cmd_done_arg), &err_rc, &err_group);
#endif #endif
} }
@ -460,7 +460,7 @@ int smp_process_request_packet(struct smp_streamer *streamer, void *vreq)
cmd_done_arg.err = rc; cmd_done_arg.err = rc;
(void)mgmt_callback_notify(MGMT_EVT_OP_CMD_DONE, &cmd_done_arg, (void)mgmt_callback_notify(MGMT_EVT_OP_CMD_DONE, &cmd_done_arg,
sizeof(cmd_done_arg), &ret_rc, &ret_group); sizeof(cmd_done_arg), &err_rc, &err_group);
#endif #endif
} }
@ -473,7 +473,7 @@ int smp_process_request_packet(struct smp_streamer *streamer, void *vreq)
return rc; return rc;
} }
bool smp_add_cmd_ret(zcbor_state_t *zse, uint16_t group, uint16_t ret) bool smp_add_cmd_err(zcbor_state_t *zse, uint16_t group, uint16_t ret)
{ {
bool ok = true; bool ok = true;
@ -485,7 +485,7 @@ bool smp_add_cmd_ret(zcbor_state_t *zse, uint16_t group, uint16_t ret)
container->error_ret = ret; container->error_ret = ret;
#endif #endif
ok = zcbor_tstr_put_lit(zse, "ret") && ok = zcbor_tstr_put_lit(zse, "err") &&
zcbor_map_start_encode(zse, 2) && zcbor_map_start_encode(zse, 2) &&
zcbor_tstr_put_lit(zse, "group") && zcbor_tstr_put_lit(zse, "group") &&
zcbor_uint32_put(zse, (uint32_t)group) && zcbor_uint32_put(zse, (uint32_t)group) &&

10
tests/subsys/mgmt/mcumgr/handler_demo/example_as_module/include/example_mgmt.h
View file

@ -24,18 +24,18 @@ extern "C" {
/** /**
* Command result codes for example management group. * Command result codes for example management group.
*/ */
enum example_mgmt_ret_code_t { enum example_mgmt_err_code_t {
/** No error, this is implied if there is no ret value in the response */ /** No error, this is implied if there is no ret value in the response */
EXAMPLE_MGMT_RET_RC_OK = 0, EXAMPLE_MGMT_ERR_OK = 0,
/** Unknown error occurred. */ /** Unknown error occurred. */
EXAMPLE_MGMT_RET_RC_UNKNOWN, EXAMPLE_MGMT_ERR_UNKNOWN,
/** The provided value is not wanted at this time. */ /** The provided value is not wanted at this time. */
EXAMPLE_MGMT_RET_RC_NOT_WANTED, EXAMPLE_MGMT_ERR_NOT_WANTED,
/** The provided value was rejected by a hook. */ /** The provided value was rejected by a hook. */
EXAMPLE_MGMT_RET_RC_REJECTED_BY_HOOK, EXAMPLE_MGMT_ERR_REJECTED_BY_HOOK,
}; };
#ifdef __cplusplus #ifdef __cplusplus

32
tests/subsys/mgmt/mcumgr/handler_demo/example_as_module/src/example_mgmt.c
View file

@ -56,7 +56,7 @@ static int example_mgmt_test(struct smp_streamer *ctxt)
/* If the value of "uint_key" is over 50, return an error of "not wanted" */ /* If the value of "uint_key" is over 50, return an error of "not wanted" */
if (uint_value > 50) { if (uint_value > 50) {
ok = smp_add_cmd_ret(zse, MGMT_GROUP_ID_EXAMPLE, EXAMPLE_MGMT_RET_RC_NOT_WANTED); ok = smp_add_cmd_err(zse, MGMT_GROUP_ID_EXAMPLE, EXAMPLE_MGMT_ERR_NOT_WANTED);
goto end; goto end;
} }
@ -86,8 +86,8 @@ static int example_mgmt_other(struct smp_streamer *ctxt)
#if defined(CONFIG_MCUMGR_GRP_EXAMPLE_OTHER_HOOK) #if defined(CONFIG_MCUMGR_GRP_EXAMPLE_OTHER_HOOK)
struct example_mgmt_other_data other_data; struct example_mgmt_other_data other_data;
enum mgmt_cb_return status; enum mgmt_cb_return status;
int32_t ret_rc; int32_t err_rc;
uint16_t ret_group; uint16_t err_group;
#endif #endif
LOG_DBG("Example other function called"); LOG_DBG("Example other function called");
@ -106,17 +106,17 @@ static int example_mgmt_other(struct smp_streamer *ctxt)
/* Send request to application to check what to do */ /* Send request to application to check what to do */
other_data.user_value = user_value; other_data.user_value = user_value;
status = mgmt_callback_notify(MGMT_EVT_OP_EXAMPLE_OTHER, &other_data, sizeof(other_data), status = mgmt_callback_notify(MGMT_EVT_OP_EXAMPLE_OTHER, &other_data, sizeof(other_data),
&ret_rc, &ret_group); &err_rc, &err_group);
if (status != MGMT_CB_OK) { if (status != MGMT_CB_OK) {
/* If a callback returned an RC error, exit out, if it returned a group error /* If a callback returned an RC error, exit out, if it returned a group error
* code, add the error code to the response and return to the calling function to * code, add the error code to the response and return to the calling function to
* have it sent back to the client * have it sent back to the client
*/ */
if (status == MGMT_CB_ERROR_RC) { if (status == MGMT_CB_ERROR_RC) {
return ret_rc; return err_rc;
} }
ok = smp_add_cmd_ret(zse, ret_group, (uint16_t)ret_rc); ok = smp_add_cmd_err(zse, err_group, (uint16_t)err_rc);
goto end; goto end;
} }
#endif #endif
@ -140,22 +140,22 @@ end:
* only for general SMP/MCUmgr errors. The success/OK error code is not used in translation * only for general SMP/MCUmgr errors. The success/OK error code is not used in translation
* functions as it is automatically handled by the base SMP code. * functions as it is automatically handled by the base SMP code.
*/ */
static int example_mgmt_translate_error_code(uint16_t ret) static int example_mgmt_translate_error_code(uint16_t err)
{ {
int rc; int rc;
switch (ret) { switch (err) {
case EXAMPLE_MGMT_RET_RC_NOT_WANTED: case EXAMPLE_MGMT_ERR_NOT_WANTED:
rc = MGMT_ERR_ENOENT; rc = MGMT_ERR_ENOENT;
break; break;
case EXAMPLE_MGMT_RET_RC_REJECTED_BY_HOOK: case EXAMPLE_MGMT_ERR_REJECTED_BY_HOOK:
rc = MGMT_ERR_EBADSTATE; rc = MGMT_ERR_EBADSTATE;
break; break;
case EXAMPLE_MGMT_RET_RC_UNKNOWN: case EXAMPLE_MGMT_ERR_UNKNOWN:
default: default:
rc = MGMT_ERR_EUNKNOWN; rc = MGMT_ERR_EUNKNOWN;
} }
return rc; return rc;

4
tests/subsys/mgmt/mcumgr/handler_demo/src/main.c
View file

@ -33,10 +33,10 @@ enum mgmt_cb_return test_function(uint32_t event, enum mgmt_cb_return prev_statu
if (last_run) { if (last_run) {
/* Return a dummy error for a demo */ /* Return a dummy error for a demo */
*group = MGMT_GROUP_ID_EXAMPLE; *group = MGMT_GROUP_ID_EXAMPLE;
*rc = EXAMPLE_MGMT_RET_RC_REJECTED_BY_HOOK; *rc = EXAMPLE_MGMT_ERR_REJECTED_BY_HOOK;
LOG_INF("Received hook, rejecting!"); LOG_INF("Received hook, rejecting!");
return MGMT_CB_ERROR_RET; return MGMT_CB_ERROR_ERR;
} }
LOG_INF("Received hook, allowing"); LOG_INF("Received hook, allowing");

18
tests/subsys/mgmt/mcumgr/smp_version/src/main.c
View file

@ -49,7 +49,7 @@ static const uint8_t response_old[] = {
/* Response to current packet */ /* Response to current packet */
static const uint8_t response_current[] = { static const uint8_t response_current[] = {
0x09, 0x00, 0x00, 0x13, 0x00, 0x00, 0x01, 0x07, 0x09, 0x00, 0x00, 0x13, 0x00, 0x00, 0x01, 0x07,
0xbf, 0x63, 0x72, 0x65, 0x74, 0xbf, 0x65, 0x67, 0xbf, 0x63, 0x65, 0x72, 0x72, 0xbf, 0x65, 0x67,
0x72, 0x6f, 0x75, 0x70, 0x00, 0x62, 0x72, 0x63, 0x72, 0x6f, 0x75, 0x70, 0x00, 0x62, 0x72, 0x63,
0x02, 0xff, 0xff 0x02, 0xff, 0xff
}; };
@ -115,7 +115,7 @@ ZTEST(smp_version, test_legacy_command)
struct zcbor_map_decode_key_val output_decode[] = { struct zcbor_map_decode_key_val output_decode[] = {
ZCBOR_MAP_DECODE_KEY_DECODER("output", zcbor_tstr_decode, &output), ZCBOR_MAP_DECODE_KEY_DECODER("output", zcbor_tstr_decode, &output),
ZCBOR_MAP_DECODE_KEY_DECODER("rc", zcbor_int32_decode, &rc), ZCBOR_MAP_DECODE_KEY_DECODER("rc", zcbor_int32_decode, &rc),
ZCBOR_MAP_DECODE_KEY_DECODER("ret", mcumgr_ret_decode, &group_error), ZCBOR_MAP_DECODE_KEY_DECODER("err", mcumgr_ret_decode, &group_error),
}; };
memset(buffer, 0, sizeof(buffer)); memset(buffer, 0, sizeof(buffer));
@ -173,7 +173,7 @@ ZTEST(smp_version, test_legacy_command)
zassert_equal( zassert_equal(
zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode),
"ret"), 0, "err"), 0,
"Did not expect to get ret in response"); "Did not expect to get ret in response");
#ifdef CONFIG_MCUMGR_SMP_SUPPORT_ORIGINAL_PROTOCOL #ifdef CONFIG_MCUMGR_SMP_SUPPORT_ORIGINAL_PROTOCOL
@ -202,7 +202,7 @@ ZTEST(smp_version, test_current_command)
struct zcbor_map_decode_key_val output_decode[] = { struct zcbor_map_decode_key_val output_decode[] = {
ZCBOR_MAP_DECODE_KEY_DECODER("output", zcbor_tstr_decode, &output), ZCBOR_MAP_DECODE_KEY_DECODER("output", zcbor_tstr_decode, &output),
ZCBOR_MAP_DECODE_KEY_DECODER("rc", zcbor_int32_decode, &rc), ZCBOR_MAP_DECODE_KEY_DECODER("rc", zcbor_int32_decode, &rc),
ZCBOR_MAP_DECODE_KEY_DECODER("ret", mcumgr_ret_decode, &group_error), ZCBOR_MAP_DECODE_KEY_DECODER("err", mcumgr_ret_decode, &group_error),
}; };
memset(buffer, 0, sizeof(buffer)); memset(buffer, 0, sizeof(buffer));
@ -260,14 +260,14 @@ ZTEST(smp_version, test_current_command)
zassert_equal( zassert_equal(
zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode),
"ret"), 1, "err"), 1,
"Expected to get ret in response"); "Expected to get ret in response");
zassert_true(group_error.found, "Expected both group and rc in ret to be found"); zassert_true(group_error.found, "Expected both group and rc in ret to be found");
zassert_equal(group_error.group, MGMT_GROUP_ID_OS, zassert_equal(group_error.group, MGMT_GROUP_ID_OS,
"Expected to get MGMT_GROUP_ID_OS for ret group"); "Expected to get MGMT_GROUP_ID_OS for ret group");
zassert_equal(group_error.rc, OS_MGMT_RET_RC_INVALID_FORMAT, zassert_equal(group_error.rc, OS_MGMT_ERR_INVALID_FORMAT,
"Expected to get OS_MGMT_RET_RC_INVALID_FORMAT for ret rc"); "Expected to get OS_MGMT_ERR_INVALID_FORMAT for ret rc");
} }
ZTEST(smp_version, test_new_command) ZTEST(smp_version, test_new_command)
@ -288,7 +288,7 @@ ZTEST(smp_version, test_new_command)
struct zcbor_map_decode_key_val output_decode[] = { struct zcbor_map_decode_key_val output_decode[] = {
ZCBOR_MAP_DECODE_KEY_DECODER("output", zcbor_tstr_decode, &output), ZCBOR_MAP_DECODE_KEY_DECODER("output", zcbor_tstr_decode, &output),
ZCBOR_MAP_DECODE_KEY_DECODER("rc", zcbor_int32_decode, &rc), ZCBOR_MAP_DECODE_KEY_DECODER("rc", zcbor_int32_decode, &rc),
ZCBOR_MAP_DECODE_KEY_DECODER("ret", mcumgr_ret_decode, &group_error), ZCBOR_MAP_DECODE_KEY_DECODER("err", mcumgr_ret_decode, &group_error),
}; };
memset(buffer, 0, sizeof(buffer)); memset(buffer, 0, sizeof(buffer));
@ -346,7 +346,7 @@ ZTEST(smp_version, test_new_command)
zassert_equal( zassert_equal(
zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode),
"ret"), 0, "err"), 0,
"Did not expect to get ret in response"); "Did not expect to get ret in response");
zassert_equal(rc, MGMT_ERR_UNSUPPORTED_TOO_NEW, zassert_equal(rc, MGMT_ERR_UNSUPPORTED_TOO_NEW,