/*
|
* Licensed to the Apache Software Foundation (ASF) under one
|
* or more contributor license agreements. See the NOTICE file
|
* distributed with this work for additional information
|
* regarding copyright ownership. The ASF licenses this file
|
* to you under the Apache License, Version 2.0 (the
|
* "License"); you may not use this file except in compliance
|
* with the License. You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing,
|
* software distributed under the License is distributed on an
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
* KIND, either express or implied. See the License for the
|
* specific language governing permissions and limitations
|
* under the License.
|
*/
|
|
#include <limits.h>
|
#include <assert.h>
|
#include <string.h>
|
|
#include "cborattr/cborattr.h"
|
#include "mgmt/mgmt.h"
|
|
#include "img_mgmt/image.h"
|
#include "img_mgmt/img_mgmt.h"
|
#include "img_mgmt/img_mgmt_impl.h"
|
#include "img_mgmt_priv.h"
|
#include "img_mgmt/img_mgmt_config.h"
|
|
static mgmt_handler_fn img_mgmt_upload;
|
static mgmt_handler_fn img_mgmt_erase;
|
static img_mgmt_upload_fn *img_mgmt_upload_cb;
|
static void *img_mgmt_upload_arg;
|
|
const img_mgmt_dfu_callbacks_t *img_mgmt_dfu_callbacks_fn;
|
|
struct img_mgmt_state g_img_mgmt_state;
|
|
static const struct mgmt_handler img_mgmt_handlers[] = {
|
[IMG_MGMT_ID_STATE] = {
|
.mh_read = img_mgmt_state_read,
|
.mh_write = img_mgmt_state_write,
|
},
|
[IMG_MGMT_ID_UPLOAD] = {
|
.mh_read = NULL,
|
.mh_write = img_mgmt_upload
|
},
|
[IMG_MGMT_ID_ERASE] = {
|
.mh_read = NULL,
|
.mh_write = img_mgmt_erase
|
},
|
};
|
|
#define IMG_MGMT_HANDLER_CNT \
|
sizeof(img_mgmt_handlers) / sizeof(img_mgmt_handlers[0])
|
|
static struct mgmt_group img_mgmt_group = {
|
.mg_handlers = (struct mgmt_handler *)img_mgmt_handlers,
|
.mg_handlers_count = IMG_MGMT_HANDLER_CNT,
|
.mg_group_id = MGMT_GROUP_ID_IMAGE,
|
};
|
|
#if IMG_MGMT_VERBOSE_ERR
|
const char *img_mgmt_err_str_app_reject = "app reject";
|
const char *img_mgmt_err_str_hdr_malformed = "header malformed";
|
const char *img_mgmt_err_str_magic_mismatch = "magic mismatch";
|
const char *img_mgmt_err_str_no_slot = "no slot";
|
const char *img_mgmt_err_str_flash_open_failed = "fa open fail";
|
const char *img_mgmt_err_str_flash_erase_failed = "fa erase fail";
|
const char *img_mgmt_err_str_flash_write_failed = "fa write fail";
|
const char *img_mgmt_err_str_downgrade = "downgrade";
|
const char *img_mgmt_err_str_image_bad_flash_addr = "img addr mismatch";
|
#endif
|
|
/**
|
* Finds the TLVs in the specified image slot, if any.
|
*/
|
static int
|
img_mgmt_find_tlvs(int slot, size_t *start_off, size_t *end_off,
|
uint16_t magic)
|
{
|
struct image_tlv_info tlv_info;
|
int rc;
|
|
rc = img_mgmt_impl_read(slot, *start_off, &tlv_info, sizeof tlv_info);
|
if (rc != 0) {
|
/* Read error. */
|
return MGMT_ERR_EUNKNOWN;
|
}
|
|
if (tlv_info.it_magic != magic) {
|
/* No TLVs. */
|
return MGMT_ERR_ENOENT;
|
}
|
|
*start_off += sizeof tlv_info;
|
*end_off = *start_off + tlv_info.it_tlv_tot;
|
|
return 0;
|
}
|
|
/*
|
* Reads the version and build hash from the specified image slot.
|
*/
|
int
|
img_mgmt_read_info(int image_slot, struct image_version *ver, uint8_t *hash,
|
uint32_t *flags)
|
{
|
|
#if IMG_MGMT_DUMMY_HDR
|
uint8_t dummy_hash[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
|
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
|
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
|
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77};
|
|
if (!hash && !ver && !flags) {
|
return 0;
|
}
|
|
if (hash) {
|
memcpy(hash, dummy_hash, IMG_MGMT_HASH_LEN);
|
}
|
|
if (ver) {
|
memset(ver, 0xff, sizeof *ver);
|
}
|
|
if (flags) {
|
*flags = 0;
|
}
|
|
return 0;
|
#endif
|
struct image_header hdr;
|
struct image_tlv tlv;
|
size_t data_off;
|
size_t data_end;
|
bool hash_found;
|
uint8_t erased_val;
|
uint32_t erased_val_32;
|
int rc;
|
|
rc = img_mgmt_impl_erased_val(image_slot, &erased_val);
|
if (rc != 0) {
|
return MGMT_ERR_EUNKNOWN;
|
}
|
|
rc = img_mgmt_impl_read(image_slot, 0, &hdr, sizeof hdr);
|
if (rc != 0) {
|
return MGMT_ERR_EUNKNOWN;
|
}
|
|
if (ver != NULL) {
|
memset(ver, erased_val, sizeof(*ver));
|
}
|
erased_val_32 = ERASED_VAL_32(erased_val);
|
if (hdr.ih_magic == IMAGE_MAGIC) {
|
if (ver != NULL) {
|
memcpy(ver, &hdr.ih_ver, sizeof(*ver));
|
}
|
} else if (hdr.ih_magic == erased_val_32) {
|
return MGMT_ERR_ENOENT;
|
} else {
|
return MGMT_ERR_EUNKNOWN;
|
}
|
|
if (flags != NULL) {
|
*flags = hdr.ih_flags;
|
}
|
|
/* Read the image's TLVs. We first try to find the protected TLVs, if the protected
|
* TLV does not exist, we try to find non-protected TLV which also contains the hash
|
* TLV. All images are required to have a hash TLV. If the hash is missing, the image
|
* is considered invalid.
|
*/
|
data_off = hdr.ih_hdr_size + hdr.ih_img_size;
|
|
rc = img_mgmt_find_tlvs(image_slot, &data_off, &data_end, IMAGE_TLV_PROT_INFO_MAGIC);
|
if (!rc) {
|
/* The data offset should start after the header bytes after the end of the protected TLV,
|
* if one exists.
|
*/
|
data_off = data_end - sizeof(struct image_tlv_info);
|
}
|
|
rc = img_mgmt_find_tlvs(image_slot, &data_off, &data_end, IMAGE_TLV_INFO_MAGIC);
|
if (rc != 0) {
|
return MGMT_ERR_EUNKNOWN;
|
}
|
|
hash_found = false;
|
while (data_off + sizeof tlv <= data_end) {
|
rc = img_mgmt_impl_read(image_slot, data_off, &tlv, sizeof tlv);
|
if (rc != 0) {
|
return MGMT_ERR_EUNKNOWN;
|
}
|
if (tlv.it_type == 0xff && tlv.it_len == 0xffff) {
|
return MGMT_ERR_EUNKNOWN;
|
}
|
if (tlv.it_type != IMAGE_TLV_SHA256 || tlv.it_len != IMAGE_HASH_LEN) {
|
/* Non-hash TLV. Skip it. */
|
data_off += sizeof tlv + tlv.it_len;
|
continue;
|
}
|
|
if (hash_found) {
|
/* More than one hash. */
|
return MGMT_ERR_EUNKNOWN;
|
}
|
hash_found = true;
|
|
data_off += sizeof tlv;
|
if (hash != NULL) {
|
if (data_off + IMAGE_HASH_LEN > data_end) {
|
return MGMT_ERR_EUNKNOWN;
|
}
|
rc = img_mgmt_impl_read(image_slot, data_off, hash,
|
IMAGE_HASH_LEN);
|
if (rc != 0) {
|
return MGMT_ERR_EUNKNOWN;
|
}
|
}
|
}
|
|
if (!hash_found) {
|
return MGMT_ERR_EUNKNOWN;
|
}
|
|
return 0;
|
}
|
|
/*
|
* Finds image given version number. Returns the slot number image is in,
|
* or -1 if not found.
|
*/
|
int
|
img_mgmt_find_by_ver(struct image_version *find, uint8_t *hash)
|
{
|
int i;
|
struct image_version ver;
|
|
for (i = 0; i < 2 * IMG_MGMT_UPDATABLE_IMAGE_NUMBER; i++) {
|
if (img_mgmt_read_info(i, &ver, hash, NULL) != 0) {
|
continue;
|
}
|
if (!memcmp(find, &ver, sizeof(ver))) {
|
return i;
|
}
|
}
|
return -1;
|
}
|
|
/*
|
* Finds image given hash of the image. Returns the slot number image is in,
|
* or -1 if not found.
|
*/
|
int
|
img_mgmt_find_by_hash(uint8_t *find, struct image_version *ver)
|
{
|
int i;
|
uint8_t hash[IMAGE_HASH_LEN];
|
|
for (i = 0; i < 2 * IMG_MGMT_UPDATABLE_IMAGE_NUMBER; i++) {
|
if (img_mgmt_read_info(i, ver, hash, NULL) != 0) {
|
continue;
|
}
|
if (!memcmp(hash, find, IMAGE_HASH_LEN)) {
|
return i;
|
}
|
}
|
return -1;
|
}
|
|
#if IMG_MGMT_VERBOSE_ERR
|
int
|
img_mgmt_error_rsp(struct mgmt_ctxt *ctxt, int rc, const char *rsn)
|
{
|
/*
|
* This is an error response so returning a different error when failed to
|
* encode other error probably does not make much sense - just ignore errors
|
* here.
|
*/
|
cbor_encode_text_stringz(&ctxt->encoder, "rsn");
|
cbor_encode_text_stringz(&ctxt->encoder, rsn);
|
return rc;
|
}
|
#endif
|
|
/**
|
* Command handler: image erase
|
*/
|
static int
|
img_mgmt_erase(struct mgmt_ctxt *ctxt)
|
{
|
struct image_version ver;
|
CborError err;
|
int rc;
|
|
/*
|
* First check if image info is valid.
|
* This check is done incase the flash area has a corrupted image.
|
*/
|
rc = img_mgmt_read_info(1, &ver, NULL, NULL);
|
|
if (rc == 0) {
|
/* Image info is valid. */
|
if (img_mgmt_slot_in_use(1)) {
|
/* No free slot. */
|
return MGMT_ERR_EBADSTATE;
|
}
|
}
|
|
rc = img_mgmt_impl_erase_slot();
|
|
if (!rc) {
|
img_mgmt_dfu_stopped();
|
}
|
|
err = 0;
|
err |= cbor_encode_text_stringz(&ctxt->encoder, "rc");
|
err |= cbor_encode_int(&ctxt->encoder, rc);
|
|
if (err != 0) {
|
return MGMT_ERR_ENOMEM;
|
}
|
|
return 0;
|
}
|
|
static int
|
img_mgmt_upload_good_rsp(struct mgmt_ctxt *ctxt)
|
{
|
CborError err = CborNoError;
|
|
err |= cbor_encode_text_stringz(&ctxt->encoder, "rc");
|
err |= cbor_encode_int(&ctxt->encoder, MGMT_ERR_EOK);
|
err |= cbor_encode_text_stringz(&ctxt->encoder, "off");
|
err |= cbor_encode_int(&ctxt->encoder, g_img_mgmt_state.off);
|
|
if (err != 0) {
|
return MGMT_ERR_ENOMEM;
|
}
|
|
return 0;
|
}
|
|
/**
|
* Logs an upload request if necessary.
|
*
|
* @param is_first Whether the request includes the first chunk of
|
* the image.
|
* @param is_last Whether the request includes the last chunk of
|
* the image.
|
* @param status The result of processing the upload request
|
* (MGMT_ERR code).
|
*
|
* @return 0 on success; nonzero on failure.
|
*/
|
static int
|
img_mgmt_upload_log(bool is_first, bool is_last, int status)
|
{
|
uint8_t hash[IMAGE_HASH_LEN];
|
const uint8_t *hashp;
|
int rc;
|
|
if (is_first) {
|
return img_mgmt_impl_log_upload_start(status);
|
}
|
|
if (is_last || status != 0) {
|
/* Log the image hash if we know it. */
|
rc = img_mgmt_read_info(1, NULL, hash, NULL);
|
if (rc != 0) {
|
hashp = NULL;
|
} else {
|
hashp = hash;
|
}
|
|
return img_mgmt_impl_log_upload_done(status, hashp);
|
}
|
|
/* Nothing to log. */
|
return 0;
|
}
|
|
/**
|
* Command handler: image upload
|
*/
|
static int
|
img_mgmt_upload(struct mgmt_ctxt *ctxt)
|
{
|
struct mgmt_evt_op_cmd_status_arg cmd_status_arg;
|
struct img_mgmt_upload_req req = {
|
.off = -1,
|
.size = -1,
|
.data_len = 0,
|
.data_sha_len = 0,
|
.upgrade = false,
|
.image = 0,
|
};
|
|
const struct cbor_attr_t off_attr[] = {
|
[0] = {
|
.attribute = "image",
|
.type = CborAttrUnsignedIntegerType,
|
.addr.uinteger = &req.image,
|
.nodefault = true
|
},
|
[1] = {
|
.attribute = "data",
|
.type = CborAttrByteStringType,
|
.addr.bytestring.data = req.img_data,
|
.addr.bytestring.len = &req.data_len,
|
.len = sizeof(req.img_data)
|
},
|
[2] = {
|
.attribute = "len",
|
.type = CborAttrUnsignedIntegerType,
|
.addr.uinteger = &req.size,
|
.nodefault = true
|
},
|
[3] = {
|
.attribute = "off",
|
.type = CborAttrUnsignedIntegerType,
|
.addr.uinteger = &req.off,
|
.nodefault = true
|
},
|
[4] = {
|
.attribute = "sha",
|
.type = CborAttrByteStringType,
|
.addr.bytestring.data = req.data_sha,
|
.addr.bytestring.len = &req.data_sha_len,
|
.len = sizeof(req.data_sha)
|
},
|
[5] = {
|
.attribute = "upgrade",
|
.type = CborAttrBooleanType,
|
.addr.boolean = &req.upgrade,
|
.dflt.boolean = false,
|
},
|
[6] = { 0 },
|
};
|
int rc;
|
const char *errstr = NULL;
|
struct img_mgmt_upload_action action;
|
bool last = false;
|
|
rc = cbor_read_object(&ctxt->it, off_attr);
|
if (rc != 0) {
|
return MGMT_ERR_EINVAL;
|
}
|
|
/* Determine what actions to take as a result of this request. */
|
rc = img_mgmt_impl_upload_inspect(&req, &action, &errstr);
|
if (rc != 0) {
|
img_mgmt_dfu_stopped();
|
return rc;
|
}
|
|
if (!action.proceed) {
|
/* Request specifies incorrect offset. Respond with a success code and
|
* the correct offset.
|
*/
|
return img_mgmt_upload_good_rsp(ctxt);
|
}
|
|
/* Request is valid. Give the application a chance to reject this upload
|
* request.
|
*/
|
if (img_mgmt_upload_cb != NULL) {
|
rc = img_mgmt_upload_cb(req.off, action.size, img_mgmt_upload_arg);
|
if (rc != 0) {
|
errstr = img_mgmt_err_str_app_reject;
|
goto end;
|
}
|
}
|
|
/* Remember flash area ID and image size for subsequent upload requests. */
|
g_img_mgmt_state.area_id = action.area_id;
|
g_img_mgmt_state.size = action.size;
|
|
if (req.off == 0) {
|
/*
|
* New upload.
|
*/
|
g_img_mgmt_state.off = 0;
|
|
img_mgmt_dfu_started();
|
cmd_status_arg.status = IMG_MGMT_ID_UPLOAD_STATUS_START;
|
|
/*
|
* We accept SHA trimmed to any length by client since it's up to client
|
* to make sure provided data are good enough to avoid collisions when
|
* resuming upload.
|
*/
|
g_img_mgmt_state.data_sha_len = req.data_sha_len;
|
memcpy(g_img_mgmt_state.data_sha, req.data_sha, req.data_sha_len);
|
memset(&g_img_mgmt_state.data_sha[req.data_sha_len], 0,
|
IMG_MGMT_DATA_SHA_LEN - req.data_sha_len);
|
|
#if IMG_MGMT_LAZY_ERASE
|
/* setup for lazy sector by sector erase */
|
g_img_mgmt_state.sector_id = -1;
|
g_img_mgmt_state.sector_end = 0;
|
#else
|
/* erase the entire req.size all at once */
|
if (action.erase) {
|
rc = img_mgmt_impl_erase_image_data(0, req.size);
|
if (rc != 0) {
|
rc = MGMT_ERR_EUNKNOWN;
|
errstr = img_mgmt_err_str_flash_erase_failed;
|
goto end;
|
}
|
}
|
#endif
|
} else {
|
cmd_status_arg.status = IMG_MGMT_ID_UPLOAD_STATUS_ONGOING;
|
}
|
|
/* Write the image data to flash. */
|
if (req.data_len != 0) {
|
#if IMG_MGMT_LAZY_ERASE
|
/* erase as we cross sector boundaries */
|
if (img_mgmt_impl_erase_if_needed(req.off, action.write_bytes) != 0) {
|
rc = MGMT_ERR_EUNKNOWN;
|
errstr = img_mgmt_err_str_flash_erase_failed;
|
goto end;
|
}
|
#endif
|
/* If this is the last chunk */
|
if (g_img_mgmt_state.off + req.data_len == g_img_mgmt_state.size) {
|
last = true;
|
}
|
|
rc = img_mgmt_impl_write_image_data(req.off, req.img_data, action.write_bytes, last);
|
|
if (rc != 0) {
|
rc = MGMT_ERR_EUNKNOWN;
|
errstr = img_mgmt_err_str_flash_write_failed;
|
goto end;
|
} else {
|
g_img_mgmt_state.off += action.write_bytes;
|
if (g_img_mgmt_state.off == g_img_mgmt_state.size) {
|
/* Done */
|
img_mgmt_dfu_pending();
|
cmd_status_arg.status = IMG_MGMT_ID_UPLOAD_STATUS_COMPLETE;
|
g_img_mgmt_state.area_id = -1;
|
}
|
}
|
}
|
|
end:
|
|
img_mgmt_upload_log(req.off == 0, g_img_mgmt_state.off == g_img_mgmt_state.size, rc);
|
mgmt_evt(MGMT_EVT_OP_CMD_STATUS, MGMT_GROUP_ID_IMAGE, IMG_MGMT_ID_UPLOAD,
|
&cmd_status_arg);
|
|
if (rc != 0) {
|
img_mgmt_dfu_stopped();
|
return img_mgmt_error_rsp(ctxt, rc, errstr);
|
}
|
|
return img_mgmt_upload_good_rsp(ctxt);
|
}
|
|
void
|
img_mgmt_dfu_stopped(void)
|
{
|
if (img_mgmt_dfu_callbacks_fn && img_mgmt_dfu_callbacks_fn->dfu_stopped_cb) {
|
img_mgmt_dfu_callbacks_fn->dfu_stopped_cb();
|
}
|
}
|
|
void
|
img_mgmt_dfu_started(void)
|
{
|
if (img_mgmt_dfu_callbacks_fn && img_mgmt_dfu_callbacks_fn->dfu_started_cb) {
|
img_mgmt_dfu_callbacks_fn->dfu_started_cb();
|
}
|
}
|
|
void
|
img_mgmt_dfu_pending(void)
|
{
|
if (img_mgmt_dfu_callbacks_fn && img_mgmt_dfu_callbacks_fn->dfu_pending_cb) {
|
img_mgmt_dfu_callbacks_fn->dfu_pending_cb();
|
}
|
}
|
|
void
|
img_mgmt_dfu_confirmed(void)
|
{
|
if (img_mgmt_dfu_callbacks_fn && img_mgmt_dfu_callbacks_fn->dfu_confirmed_cb) {
|
img_mgmt_dfu_callbacks_fn->dfu_confirmed_cb();
|
}
|
}
|
|
void
|
img_mgmt_set_upload_cb(img_mgmt_upload_fn *cb, void *arg)
|
{
|
img_mgmt_upload_cb = cb;
|
img_mgmt_upload_arg = arg;
|
}
|
|
void
|
img_mgmt_register_callbacks(const img_mgmt_dfu_callbacks_t *cb_struct)
|
{
|
img_mgmt_dfu_callbacks_fn = cb_struct;
|
}
|
|
|
int
|
img_mgmt_my_version(struct image_version *ver)
|
{
|
return img_mgmt_read_info(IMG_MGMT_BOOT_CURR_SLOT, ver, NULL, NULL);
|
}
|
|
void
|
img_mgmt_register_group(void)
|
{
|
mgmt_register_group(&img_mgmt_group);
|
}
|
|
void
|
img_mgmt_unregister_group(void)
|
{
|
mgmt_unregister_group(&img_mgmt_group);
|
}
|
