/*
* 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_config.h"
#define IMG_MGMT_DATA_SHA_LEN 32
static mgmt_handler_fn img_mgmt_upload;
static mgmt_handler_fn img_mgmt_erase;
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,
};
static struct {
/* Whether an upload is currently in progress. */
bool uploading;
/** Expected offset of next upload request. */
size_t off;
/** Total length of image currently being uploaded. */
size_t len;
/** Hash of image data; used for resume of a partial upload. */
uint8_t data_sha_len;
uint8_t data_sha[IMG_MGMT_DATA_SHA_LEN];
} img_mgmt_ctxt;
/**
* Finds the TLVs in the specified image slot, if any.
*/
static int
img_mgmt_find_tlvs(const struct image_header *hdr,
int slot, size_t *start_off, size_t *end_off)
{
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 != IMAGE_TLV_INFO_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)
{
struct image_header hdr;
struct image_tlv tlv;
size_t data_off;
size_t data_end;
bool hash_found;
int rc;
rc = img_mgmt_impl_read(image_slot, 0, &hdr, sizeof hdr);
if (rc != 0) {
return MGMT_ERR_EUNKNOWN;
}
if (ver != NULL) {
memset(ver, 0xff, sizeof(*ver));
}
if (hdr.ih_magic == IMAGE_MAGIC) {
if (ver != NULL) {
memcpy(ver, &hdr.ih_ver, sizeof(*ver));
}
} else if (hdr.ih_magic == 0xffffffff) {
return MGMT_ERR_ENOENT;
} else {
return MGMT_ERR_EUNKNOWN;
}
if (flags != NULL) {
*flags = hdr.ih_flags;
}
/* Read the image's TLVs. 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(&hdr, image_slot, &data_off, &data_end);
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; 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; i++) {
if (img_mgmt_read_info(i, ver, hash, NULL) != 0) {
continue;
}
if (!memcmp(hash, find, IMAGE_HASH_LEN)) {
return i;
}
}
return -1;
}
/**
* Command handler: image erase
*/
static int
img_mgmt_erase(struct mgmt_ctxt *ctxt)
{
CborError err;
int rc;
if (img_mgmt_slot_in_use(1)) {
/* No free slot. */
return MGMT_ERR_EBADSTATE;
}
rc = img_mgmt_impl_erase_slot();
err = 0;
err |= cbor_encode_text_stringz(&ctxt->encoder, "rc");
err |= cbor_encode_int(&ctxt->encoder, rc);
if (err != 0) {
return MGMT_ERR_ENOMEM;
}
/* reset uploading information on erase */
img_mgmt_ctxt.uploading = false;
return 0;
}
/**
* Encodes an image upload response.
*/
static int
img_mgmt_encode_upload_rsp(struct mgmt_ctxt *ctxt, int status)
{
CborError err;
err = 0;
err |= cbor_encode_text_stringz(&ctxt->encoder, "rc");
err |= cbor_encode_int(&ctxt->encoder, status);
err |= cbor_encode_text_stringz(&ctxt->encoder, "off");
err |= cbor_encode_int(&ctxt->encoder, img_mgmt_ctxt.off);
if (err != 0) {
return MGMT_ERR_ENOMEM;
}
return 0;
}
/* check if header for first packet is valid */
static int
img_mgmt_check_header(const uint8_t *req_data, size_t len)
{
struct image_header hdr;
if (len < sizeof(hdr)) {
return MGMT_ERR_EINVAL;
}
memcpy(&hdr, req_data, sizeof(hdr));
if (hdr.ih_magic != IMAGE_MAGIC) {
return MGMT_ERR_EINVAL;
}
return 0;
}
/**
* Processes an upload request specifying an offset of 0 (i.e., the first image
* chunk). The caller is responsible for encoding the response.
*/
static int
img_mgmt_upload_first_chunk(struct mgmt_ctxt *ctxt, const uint8_t *req_data,
size_t len, const uint8_t *data_sha,
size_t data_sha_len)
{
int rc;
if (img_mgmt_slot_in_use(1)) {
/* No free slot. */
return MGMT_ERR_ENOMEM;
}
rc = img_mgmt_impl_erase_slot();
if (rc != 0) {
return rc;
}
img_mgmt_ctxt.uploading = true;
img_mgmt_ctxt.off = 0;
img_mgmt_ctxt.len = 0;
/*
* 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.
*/
img_mgmt_ctxt.data_sha_len = data_sha_len;
memcpy(img_mgmt_ctxt.data_sha, data_sha, data_sha_len);
memset(&img_mgmt_ctxt.data_sha[data_sha_len], 0,
IMG_MGMT_DATA_SHA_LEN - data_sha_len);
return 0;
}
/**
* Command handler: image upload
*/
static int
img_mgmt_upload(struct mgmt_ctxt *ctxt)
{
uint8_t img_mgmt_data[IMG_MGMT_UL_CHUNK_SIZE];
uint8_t data_sha[IMG_MGMT_DATA_SHA_LEN];
size_t data_sha_len = 0;
unsigned long long len;
unsigned long long off;
size_t data_len;
size_t new_off;
bool last;
int rc;
const struct cbor_attr_t off_attr[] = {
[0] = {
.attribute = "data",
.type = CborAttrByteStringType,
.addr.bytestring.data = img_mgmt_data,
.addr.bytestring.len = &data_len,
.len = sizeof(img_mgmt_data)
},
[1] = {
.attribute = "len",
.type = CborAttrUnsignedIntegerType,
.addr.uinteger = &len,
.nodefault = true
},
[2] = {
.attribute = "off",
.type = CborAttrUnsignedIntegerType,
.addr.uinteger = &off,
.nodefault = true
},
[3] = {
.attribute = "sha",
.type = CborAttrByteStringType,
.addr.bytestring.data = data_sha,
.addr.bytestring.len = &data_sha_len,
.len = sizeof(data_sha)
},
[4] = { 0 },
};
len = ULLONG_MAX;
off = ULLONG_MAX;
data_len = 0;
rc = cbor_read_object(&ctxt->it, off_attr);
if (rc || off == ULLONG_MAX) {
return MGMT_ERR_EINVAL;
}
if (off == 0) {
/* Total image length is a required field in the first request. */
if (len == ULLONG_MAX) {
return MGMT_ERR_EINVAL;
}
rc = img_mgmt_check_header(img_mgmt_data, data_len);
if (rc) {
return rc;
}
/* Reject if SHA len is to big */
if (data_sha_len > IMG_MGMT_DATA_SHA_LEN) {
return MGMT_ERR_EINVAL;
}
/*
* If request includes proper data hash we can check whether there is
* upload in progress (interrupted due to e.g. link disconnection) with
* the same data hash so we can just resume it by simply including
* current upload offset in response.
*/
if ((data_sha_len > 0) && img_mgmt_ctxt.uploading) {
if ((img_mgmt_ctxt.data_sha_len == data_sha_len) &&
!memcmp(img_mgmt_ctxt.data_sha, data_sha, data_sha_len)) {
return img_mgmt_encode_upload_rsp(ctxt, 0);
}
}
rc = img_mgmt_upload_first_chunk(ctxt, img_mgmt_data, data_len,
data_sha, data_sha_len);
if (rc != 0) {
return rc;
}
img_mgmt_ctxt.len = len;
} else {
if (!img_mgmt_ctxt.uploading) {
return MGMT_ERR_EINVAL;
}
if (off != img_mgmt_ctxt.off) {
/* Invalid offset. Drop the data and send the expected offset. */
return img_mgmt_encode_upload_rsp(ctxt, 0);
}
}
new_off = img_mgmt_ctxt.off + data_len;
if (new_off > img_mgmt_ctxt.len) {
/* Data exceeds image length. */
return MGMT_ERR_EINVAL;
}
last = new_off == img_mgmt_ctxt.len;
if (data_len > 0) {
rc = img_mgmt_impl_write_image_data(off, img_mgmt_data, data_len,
last);
if (rc != 0) {
return rc;
}
}
img_mgmt_ctxt.off = new_off;
if (last) {
/* Upload complete. */
img_mgmt_ctxt.uploading = false;
}
return img_mgmt_encode_upload_rsp(ctxt, 0);
}
void
img_mgmt_register_group(void)
{
mgmt_register_group(&img_mgmt_group);
}