bool cnc_daemon_encode_response(uint8_t * data, CNCWrapper * wrapper, CborEncoder * encoder, CborEncoder * container)
{
CborError err;
if(data == NULL || wrapper == NULL)
{
KLOG_ERR(&log_handle, LOG_COMPONENT_NAME, "%s called with a NULL pointer\n", __func__);
return false;
}
if (err = cbor_encode_text_stringz(container, "RETURN_CODE"))
{
KLOG_ERR(&log_handle, LOG_COMPONENT_NAME, "Unable to encode key \"RETURN_CODE\". Error code: %i\n", err);
return false;
}
if (err = cbor_encode_simple_value(container, wrapper->response_packet->return_code))
{
KLOG_ERR(&log_handle, LOG_COMPONENT_NAME, "Unable to encode value for key \"RETURN_CODE\". Error code:%i\n", err);
return false;
}
if (err = cbor_encode_text_stringz(container, "EXEC_TIME"))
{
KLOG_ERR(&log_handle, LOG_COMPONENT_NAME, "Unable to encode key \"EXEC_TIME\". Error code: %i\n", err);
return false;
}
if (err = cbor_encode_double(container, wrapper->response_packet->execution_time))
{
KLOG_ERR(&log_handle, LOG_COMPONENT_NAME, "Unable to encode value for key \"EXEC_TIME\". Error code:%i\n", err);
return false;
}
if (err = cbor_encode_text_stringz(container, "OUTPUT"))
{
KLOG_ERR(&log_handle, LOG_COMPONENT_NAME, "Unable to encode key \"OUTPUT\". Error code: %i\n", err);
return false;
}
if (err = cbor_encode_text_stringz(container, wrapper->response_packet->output))
{
KLOG_ERR(&log_handle, LOG_COMPONENT_NAME, "Unable to encode value for key \"OUTPUT\". Error code:%i\n", err);
return false;
}
return cnc_daemon_finish_encode_response_and_send(data, encoder, container);
}
/**
* Log encode entries
* @param log structure, the encoder, timestamp, index
* @return 0 on success; non-zero on failure
*/
static int
log_encode_entries(struct log *log, CborEncoder *cb,
int64_t ts, uint32_t index)
{
int rc;
struct encode_off encode_off;
int rsp_len = 0;
CborEncoder entries;
CborError g_err = CborNoError;
struct CborCntWriter cnt_writer;
CborEncoder cnt_encoder;
memset(&encode_off, 0, sizeof(encode_off));
/* this code counts how long the message would be if we encoded
* this outer structure using cbor. */
cbor_cnt_writer_init(&cnt_writer);
cbor_encoder_init(&cnt_encoder, &cnt_writer.enc, 0);
g_err |= cbor_encode_text_stringz(&cnt_encoder, "entries");
g_err |= cbor_encoder_create_array(&cnt_encoder, &entries,
CborIndefiniteLength);
g_err |= cbor_encoder_close_container(&cnt_encoder, &entries);
rsp_len = cbor_encode_bytes_written(cb) +
cbor_encode_bytes_written(&cnt_encoder);
if (rsp_len > 400) {
rc = OS_ENOMEM;
goto err;
}
g_err |= cbor_encode_text_stringz(cb, "entries");
g_err |= cbor_encoder_create_array(cb, &entries, CborIndefiniteLength);
encode_off.eo_encoder = &entries;
encode_off.eo_index = index;
encode_off.eo_ts = ts;
encode_off.rsp_len = rsp_len;
rc = log_walk(log, log_nmgr_encode_entry, &encode_off);
g_err |= cbor_encoder_close_container(cb, &entries);
err:
return rc;
}
/**
* Log encode function
* @param log structure, the encoder, json_value,
* timestamp, index
* @return 0 on success; non-zero on failure
*/
static int
log_encode(struct log *log, CborEncoder *cb,
int64_t ts, uint32_t index)
{
int rc;
CborEncoder logs;
CborError g_err = CborNoError;
g_err |= cbor_encoder_create_map(cb, &logs, CborIndefiniteLength);
g_err |= cbor_encode_text_stringz(&logs, "name");
g_err |= cbor_encode_text_stringz(&logs, log->l_name);
g_err |= cbor_encode_text_stringz(&logs, "type");
g_err |= cbor_encode_uint(&logs, log->l_log->log_type);
rc = log_encode_entries(log, &logs, ts, index);
g_err |= cbor_encoder_close_container(cb, &logs);
if (g_err) {
return MGMT_ERR_ENOMEM;
}
return rc;
}
void writeGeometry(CborEncoder *enc0, Geometry geometry)
{
if (geometry.selector == 0) {
CborEncoder enc1; CborEncoder* enc = &enc1; cbor_encoder_create_array(enc0, enc, 2);
cbor_encode_uint(enc, (uint64_t)geometry.selector);
writeShape(enc, geometry.data.ShapeGeometry.value0);
cbor_encoder_close_container_checked(enc0, enc);
};
if (geometry.selector == 1) {
CborEncoder enc1; CborEncoder* enc = &enc1; cbor_encoder_create_array(enc0, enc, 2);
cbor_encode_uint(enc, (uint64_t)geometry.selector);
cbor_encode_text_stringz(enc, geometry.data.ResourceGeometry.value0.c_str());
cbor_encoder_close_container_checked(enc0, enc);
};
}
bool cnc_daemon_encode_processing_error(uint8_t * data, CNCWrapper * result, CborEncoder * encoder, CborEncoder * container)
{
CborError err;
if (data == NULL || result == NULL)
{
KLOG_ERR(&log_handle, LOG_COMPONENT_NAME, "%s called with a NULL pointer\n", __func__);
return false;
}
if (err = cbor_encode_text_stringz(container, "ERROR_MSG"))
{
KLOG_ERR(&log_handle, LOG_COMPONENT_NAME, "Unable to encode key \"ERROR_MSG\" Error code: %i\n", err);
return false;
}
if (err = cbor_encode_text_stringz(container, result->output))
{
KLOG_ERR(&log_handle, LOG_COMPONENT_NAME, "Unable to encode value for key \"ERROR_MSG\" Error code: %i\n", err);
return false;
}
return cnc_daemon_finish_encode_response_and_send(data, encoder, container);
}
bool cnc_daemon_start_encode_response(int message_type, CNCWrapper * wrapper)
{
CborEncoder encoder, container;
CborError err;
uint8_t data[MTU] = {0};
if (wrapper == NULL)
{
KLOG_ERR(&log_handle, LOG_COMPONENT_NAME, "%s called with a NULL pointer\n", __func__);
return false;
}
cbor_encoder_init(&encoder, data, MTU, 0);
err = cbor_encoder_create_map(&encoder, &container, 4); //TODO: Dynamically assign map size
if (err)
{
KLOG_ERR(&log_handle, LOG_COMPONENT_NAME, "Unable to initialize cbor encoder, Error code: %i", err);
return false;
}
if (err = cbor_encode_text_stringz(&container, "MSG_TYPE"))
{
KLOG_ERR(&log_handle, LOG_COMPONENT_NAME, "Unable to encode key \"MSG_TYPE\". Error code: %i\n", err);
return false;
}
if (err = cbor_encode_int(&container, message_type))
{
KLOG_ERR(&log_handle, LOG_COMPONENT_NAME, "Unable to encode value for key \"MSG_TYPE\" Error code: %i\n", err);
return false;
}
switch (message_type)
{
case RESPONSE_TYPE_COMMAND_RESULT:
return cnc_daemon_encode_response(data, wrapper, &encoder, &container);
case RESPONSE_TYPE_PROCESSING_ERROR:
return cnc_daemon_encode_processing_error(data, wrapper, &encoder, &container);
}
}
CborError
sol_oic_encode_cbor_repr(struct sol_coap_packet *pkt,
const char *href, const struct sol_vector *repr_vec)
{
CborEncoder encoder, rep_map, array, map;
CborError err;
uint8_t *payload;
uint16_t size;
if (!repr_vec)
return CborNoError;
if (sol_coap_packet_get_payload(pkt, &payload, &size) < 0) {
SOL_WRN("Could not get CoAP payload");
return CborUnknownError;
}
cbor_encoder_init(&encoder, payload, size, 0);
err = cbor_encoder_create_array(&encoder, &array, CborIndefiniteLength);
err |= cbor_encode_uint(&array, SOL_OIC_PAYLOAD_REPRESENTATION);
err |= cbor_encoder_create_map(&array, &map, CborIndefiniteLength);
err |= cbor_encode_text_stringz(&map, SOL_OIC_KEY_HREF);
err |= cbor_encode_text_stringz(&map, href);
err |= cbor_encode_text_stringz(&map, SOL_OIC_KEY_REPRESENTATION);
err |= cbor_encoder_create_map(&map, &rep_map, CborIndefiniteLength);
if (repr_vec) {
struct sol_oic_repr_field *repr;
uint16_t idx;
SOL_VECTOR_FOREACH_IDX (repr_vec, repr, idx) {
if (err != CborNoError)
break;
err |= cbor_encode_text_stringz(&rep_map, repr->key);
switch (repr->type) {
case SOL_OIC_REPR_TYPE_UINT:
err |= cbor_encode_uint(&rep_map, repr->v_uint);
break;
case SOL_OIC_REPR_TYPE_INT:
err |= cbor_encode_int(&rep_map, repr->v_int);
break;
case SOL_OIC_REPR_TYPE_SIMPLE:
err |= cbor_encode_simple_value(&rep_map, repr->v_simple);
break;
case SOL_OIC_REPR_TYPE_TEXT_STRING: {
const char *p = repr->v_slice.data ? repr->v_slice.data : "";
err |= cbor_encode_text_string(&rep_map, p, repr->v_slice.len);
break;
}
case SOL_OIC_REPR_TYPE_BYTE_STRING: {
const uint8_t *empty = (const uint8_t *)"";
const uint8_t *p = repr->v_slice.data ? (const uint8_t *)repr->v_slice.data : empty;
err |= cbor_encode_byte_string(&rep_map, p, repr->v_slice.len);
break;
}
case SOL_OIC_REPR_TYPE_HALF_FLOAT:
err |= cbor_encode_half_float(&rep_map, repr->v_voidptr);
break;
case SOL_OIC_REPR_TYPE_FLOAT:
err |= cbor_encode_float(&rep_map, repr->v_float);
break;
case SOL_OIC_REPR_TYPE_DOUBLE:
err |= cbor_encode_double(&rep_map, repr->v_double);
break;
case SOL_OIC_REPR_TYPE_BOOLEAN:
err |= cbor_encode_boolean(&rep_map, repr->v_boolean);
break;
default:
if (err == CborNoError)
err = CborErrorUnknownType;
}
}
}
err |= cbor_encoder_close_container(&map, &rep_map);
err |= cbor_encoder_close_container(&array, &map);
err |= cbor_encoder_close_container(&encoder, &array);
if (err == CborNoError)
sol_coap_packet_set_payload_used(pkt, encoder.ptr - payload);
return err;
}
int
imgmgr_state_read(struct mgmt_cbuf *cb)
{
int i;
int rc;
uint32_t flags;
struct image_version ver;
uint8_t hash[IMGMGR_HASH_LEN]; /* SHA256 hash */
char vers_str[IMGMGR_NMGR_MAX_VER];
int any_non_bootable;
int split_status;
uint8_t state_flags;
CborError g_err = CborNoError;
CborEncoder *penc = &cb->encoder;
CborEncoder rsp, images, image;
any_non_bootable = 0;
g_err |= cbor_encoder_create_map(penc, &rsp, CborIndefiniteLength);
g_err |= cbor_encode_text_stringz(&rsp, "images");
g_err |= cbor_encoder_create_array(&rsp, &images, CborIndefiniteLength);
for (i = 0; i < 2; i++) {
rc = imgr_read_info(i, &ver, hash, &flags);
if (rc != 0) {
continue;
}
if (flags & IMAGE_F_NON_BOOTABLE) {
any_non_bootable = 1;
}
state_flags = imgmgr_state_flags(i);
g_err |= cbor_encoder_create_map(&images, &image, CborIndefiniteLength);
g_err |= cbor_encode_text_stringz(&image, "slot");
g_err |= cbor_encode_int(&image, i);
g_err |= cbor_encode_text_stringz(&image, "version");
imgr_ver_str(&ver, vers_str);
g_err |= cbor_encode_text_stringz(&image, vers_str);
g_err |= cbor_encode_text_stringz(&image, "hash");
g_err |= cbor_encode_byte_string(&image, hash, IMGMGR_HASH_LEN);
g_err |= cbor_encode_text_stringz(&image, "bootable");
g_err |= cbor_encode_boolean(&image, !(flags & IMAGE_F_NON_BOOTABLE));
g_err |= cbor_encode_text_stringz(&image, "pending");
g_err |= cbor_encode_boolean(&image,
state_flags & IMGMGR_STATE_F_PENDING);
g_err |= cbor_encode_text_stringz(&image, "confirmed");
g_err |= cbor_encode_boolean(&image,
state_flags & IMGMGR_STATE_F_CONFIRMED);
g_err |= cbor_encode_text_stringz(&image, "active");
g_err |= cbor_encode_boolean(&image,
state_flags & IMGMGR_STATE_F_ACTIVE);
g_err |= cbor_encoder_close_container(&images, &image);
}
g_err |= cbor_encoder_close_container(&rsp, &images);
if (any_non_bootable) {
split_status = split_check_status();
} else {
split_status = SPLIT_STATUS_INVALID;
}
g_err |= cbor_encode_text_stringz(&rsp, "splitStatus");
g_err |= cbor_encode_int(&rsp, split_status);
g_err |= cbor_encoder_close_container(penc, &rsp);
if (g_err) {
return MGMT_ERR_ENOMEM;
}
return 0;
}
/**
* Log encode entry
* @param log structure, arg:struct passed locally, dataptr, len
* @return 0 on success; non-zero on failure
*/
static int
log_nmgr_encode_entry(struct log *log, void *arg, void *dptr, uint16_t len)
{
struct encode_off *encode_off = (struct encode_off *)arg;
struct log_entry_hdr ueh;
char data[128];
int dlen;
int rc;
int rsp_len;
CborError g_err = CborNoError;
CborEncoder *penc = encode_off->eo_encoder;
CborEncoder rsp;
struct CborCntWriter cnt_writer;
CborEncoder cnt_encoder;
rc = log_read(log, dptr, &ueh, 0, sizeof(ueh));
if (rc != sizeof(ueh)) {
rc = OS_ENOENT;
goto err;
}
rc = OS_OK;
/* Matching timestamps and indices for sending a log entry */
if (ueh.ue_ts < encode_off->eo_ts ||
(ueh.ue_ts == encode_off->eo_ts &&
ueh.ue_index <= encode_off->eo_index)) {
goto err;
}
dlen = min(len-sizeof(ueh), 128);
rc = log_read(log, dptr, data, sizeof(ueh), dlen);
if (rc < 0) {
rc = OS_ENOENT;
goto err;
}
data[rc] = 0;
/*calculate whether this would fit */
/* create a counting encoder for cbor */
cbor_cnt_writer_init(&cnt_writer);
cbor_encoder_init(&cnt_encoder, &cnt_writer.enc, 0);
/* NOTE This code should exactly match what is below */
g_err |= cbor_encoder_create_map(&cnt_encoder, &rsp, CborIndefiniteLength);
g_err |= cbor_encode_text_stringz(&rsp, "msg");
g_err |= cbor_encode_text_stringz(&rsp, data);
g_err |= cbor_encode_text_stringz(&rsp, "ts");
g_err |= cbor_encode_int(&rsp, ueh.ue_ts);
g_err |= cbor_encode_text_stringz(&rsp, "level");
g_err |= cbor_encode_uint(&rsp, ueh.ue_level);
g_err |= cbor_encode_text_stringz(&rsp, "index");
g_err |= cbor_encode_uint(&rsp, ueh.ue_index);
g_err |= cbor_encode_text_stringz(&rsp, "module");
g_err |= cbor_encode_uint(&rsp, ueh.ue_module);
g_err |= cbor_encoder_close_container(&cnt_encoder, &rsp);
rsp_len = encode_off->rsp_len;
rsp_len += cbor_encode_bytes_written(&cnt_encoder);
if (rsp_len > 400) {
rc = OS_ENOMEM;
goto err;
}
encode_off->rsp_len = rsp_len;
g_err |= cbor_encoder_create_map(penc, &rsp, CborIndefiniteLength);
g_err |= cbor_encode_text_stringz(&rsp, "msg");
g_err |= cbor_encode_text_stringz(&rsp, data);
g_err |= cbor_encode_text_stringz(&rsp, "ts");
g_err |= cbor_encode_int(&rsp, ueh.ue_ts);
g_err |= cbor_encode_text_stringz(&rsp, "level");
g_err |= cbor_encode_uint(&rsp, ueh.ue_level);
g_err |= cbor_encode_text_stringz(&rsp, "index");
g_err |= cbor_encode_uint(&rsp, ueh.ue_index);
g_err |= cbor_encode_text_stringz(&rsp, "module");
g_err |= cbor_encode_uint(&rsp, ueh.ue_module);
g_err |= cbor_encoder_close_container(penc, &rsp);
if (g_err) {
return MGMT_ERR_ENOMEM;
}
return (0);
err:
return (rc);
}
