eclipse/wakaama
1
0
Fork 0
mirror of https://github.com/eclipse/wakaama.git synced 2025-05-08 23:31:37 +08:00
Code Issues Packages Projects Releases Wiki Activity

Modifiy the SenML-CBOR contribution to comply with project formatting

Browse Source 
This change only contains cosmetic changes to comply with the current
code format style for the SenML-CBOR contribution enforced by
clang-format and cmake-format.
This commit is contained in:
Marc Lasch 2023-05-31 10:18:29 +02:00 committed by mlasch
parent d962a1c919
commit 38fe6868aa
12 changed files with 1354 additions and 2509 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
core/internals.h
View File

@ -89,6 +89,7 @@
else if (!LWM2M_URI_IS_SET_RESOURCE_INSTANCE(URI)) lwm2m_printf("[%s:%d] /%d/%d/%d\r\n", __func__ , __LINE__, (URI)->objectId, (URI)->instanceId, (URI)->resourceId); \
else lwm2m_printf("[%s:%d] /%d/%d/%d/%d\r\n", __func__ , __LINE__, (URI)->objectId, (URI)->instanceId, (URI)->resourceId, (URI)->resourceInstanceId)
#endif
/* clang-format off */
#define STR_STATUS(S) \
((S) == STATE_DEREGISTERED ? "STATE_DEREGISTERED" : \
((S) == STATE_REG_HOLD_OFF ? "STATE_REG_HOLD_OFF" : \
@ -107,6 +108,7 @@
((S) == STATE_BS_FAILING ? "STATE_BS_FAILING" : \
((S) == STATE_BS_FAILED ? "STATE_BS_FAILED" : \
"Unknown"))))))))))))))))
#define STR_MEDIA_TYPE(M) \
((M) == LWM2M_CONTENT_TEXT ? "LWM2M_CONTENT_TEXT" : \
((M) == LWM2M_CONTENT_LINK ? "LWM2M_CONTENT_LINK" : \
@ -114,9 +116,10 @@
((M) == LWM2M_CONTENT_TLV ? "LWM2M_CONTENT_TLV" : \
((M) == LWM2M_CONTENT_JSON ? "LWM2M_CONTENT_JSON" : \
((M) == LWM2M_CONTENT_SENML_JSON ? "LWM2M_CONTENT_SENML_JSON" : \
((M) == LWM2M_CONTENT_CBOR ? "LWM2M_CONTENT_CBOR" : \
((M) == LWM2M_CONTENT_CBOR ? "LWM2M_CONTENT_CBOR" : \
((M) == LWM2M_CONTENT_SENML_CBOR ? "LWM2M_CONTENT_SENML_CBOR" : \
"Unknown"))))))))
#define STR_STATE(S) \
((S) == STATE_INITIAL ? "STATE_INITIAL" : \
((S) == STATE_BOOTSTRAP_REQUIRED ? "STATE_BOOTSTRAP_REQUIRED" : \
@ -125,6 +128,7 @@
((S) == STATE_REGISTERING ? "STATE_REGISTERING" : \
((S) == STATE_READY ? "STATE_READY" : \
"Unknown"))))))
/* clang-format on */
#define STR_NULL2EMPTY(S) ((const char *)(S) ? (const char *)(S) : "")
#else
#define LOG_ARG(FMT, ...)
@ -135,7 +139,7 @@
#define LWM2M_DEFAULT_LIFETIME 86400
#ifdef LWM2M_SUPPORT_SENML_CBOR
#define REG_LWM2M_RESOURCE_TYPE ">;rt=\"oma.lwm2m\";ct=112,"
#define REG_LWM2M_RESOURCE_TYPE ">;rt=\"oma.lwm2m\";ct=112,"
#define REG_LWM2M_RESOURCE_TYPE_LEN 23
#elif defined(LWM2M_SUPPORT_SENML_JSON)
#define REG_LWM2M_RESOURCE_TYPE ">;rt=\"oma.lwm2m\";ct=110,"
@ -213,8 +217,8 @@
#define REG_ATTR_CONTENT_JSON_OLD_LEN 4
#define REG_ATTR_CONTENT_SENML_JSON "110"
#define REG_ATTR_CONTENT_SENML_JSON_LEN 3
#define REG_ATTR_CONTENT_SENML_CBOR "112"
#define REG_ATTR_CONTENT_SENML_CBOR_LEN 3
#define REG_ATTR_CONTENT_SENML_CBOR "112"
#define REG_ATTR_CONTENT_SENML_CBOR_LEN 3
#define ATTR_SERVER_ID_STR "ep="
#define ATTR_SERVER_ID_LEN 3
@ -296,8 +300,7 @@ typedef enum
} lwm2m_request_type_t;
#ifdef LWM2M_SUPPORT_SENML_CBOR
typedef enum
{
typedef enum {
CBOR_TYPE_UNKNOWN,
CBOR_TYPE_UNSIGNED_INTEGER,
CBOR_TYPE_NEGATIVE_INTEGER,
@ -313,14 +316,13 @@ typedef enum
#endif
#if defined(LWM2M_SUPPORT_JSON) || defined(LWM2M_SUPPORT_SENML_JSON) || defined(LWM2M_SUPPORT_SENML_CBOR)
typedef struct
{
uint16_t ids[4];
lwm2m_data_t value; /* Any buffer will be within the parsed data */
time_t time;
typedef struct {
uint16_t ids[4];
lwm2m_data_t value; /* Any buffer will be within the parsed data */
time_t time;
} senml_record_t;
typedef bool (*senml_convertValue)(const senml_record_t * recordP, lwm2m_data_t * targetP);
typedef bool (*senml_convertValue)(const senml_record_t *recordP, lwm2m_data_t *targetP);
#endif
// defined in uri.c
@ -415,28 +417,30 @@ int senml_json_serialize(const lwm2m_uri_t * uriP, int size, const lwm2m_data_t
#ifdef LWM2M_SUPPORT_SENML_CBOR
// defined in cbor.c
int cbor_get_type_and_value(const uint8_t * buffer, size_t bufferLen, cbor_type_t * type, uint64_t * value);
int cbor_get_singular(const uint8_t * buffer, size_t bufferLen, lwm2m_data_t *dataP);
int cbor_get_type_and_value(const uint8_t *buffer, size_t bufferLen, cbor_type_t *type, uint64_t *value);
int cbor_get_singular(const uint8_t *buffer, size_t bufferLen, lwm2m_data_t *dataP);
int cbor_put_type_and_value(uint8_t *buffer, size_t bufferLen, cbor_type_t type, uint64_t val);
int cbor_put_singular(uint8_t *buffer, size_t bufferLen, const lwm2m_data_t * dataP);
int cbor_put_singular(uint8_t *buffer, size_t bufferLen, const lwm2m_data_t *dataP);
#if !defined(LWM2M_VERSION_1_0) && !defined(LWM2M_VERSION_1_1)
int cbor_parse(const lwm2m_uri_t * uriP, const uint8_t * buffer, size_t bufferLen, lwm2m_data_t ** dataP);
int cbor_serialize(const lwm2m_uri_t * uriP, int size, const lwm2m_data_t * dataP, uint8_t ** bufferP);
int cbor_parse(const lwm2m_uri_t *uriP, const uint8_t *buffer, size_t bufferLen, lwm2m_data_t **dataP);
int cbor_serialize(const lwm2m_uri_t *uriP, int size, const lwm2m_data_t *dataP, uint8_t **bufferP);
#endif
// defined in senml_cbor.c
int senml_cbor_parse(const lwm2m_uri_t * uriP, const uint8_t * buffer, size_t bufferLen, lwm2m_data_t ** dataP);
int senml_cbor_serialize(const lwm2m_uri_t * uriP, int size, const lwm2m_data_t * tlvP, uint8_t ** bufferP);
int senml_cbor_parse(const lwm2m_uri_t *uriP, const uint8_t *buffer, size_t bufferLen, lwm2m_data_t **dataP);
int senml_cbor_serialize(const lwm2m_uri_t *uriP, int size, const lwm2m_data_t *tlvP, uint8_t **bufferP);
#endif
// defined in senml_common.c
#if defined(LWM2M_SUPPORT_JSON) || defined(LWM2M_SUPPORT_SENML_JSON) || defined(LWM2M_SUPPORT_SENML_CBOR)
int senml_convert_records(const lwm2m_uri_t * uriP, senml_record_t * recordArray, int numRecords, senml_convertValue convertValue, lwm2m_data_t ** dataP);
lwm2m_data_t * senml_extendData(lwm2m_data_t * parentP, lwm2m_data_type_t type, uint16_t id);
int senml_dataStrip(int size, lwm2m_data_t * dataP, lwm2m_data_t ** resultP);
lwm2m_data_t * senml_findDataItem(lwm2m_data_t * listP, size_t count, uint16_t id);
int senml_convert_records(const lwm2m_uri_t *uriP, senml_record_t *recordArray, int numRecords,
senml_convertValue convertValue, lwm2m_data_t **dataP);
lwm2m_data_t *senml_extendData(lwm2m_data_t *parentP, lwm2m_data_type_t type, uint16_t id);
int senml_dataStrip(int size, lwm2m_data_t *dataP, lwm2m_data_t **resultP);
lwm2m_data_t *senml_findDataItem(lwm2m_data_t *listP, size_t count, uint16_t id);
uri_depth_t senml_decreaseLevel(uri_depth_t level);
int senml_findAndCheckData(const lwm2m_uri_t * uriP, uri_depth_t baseLevel, size_t size, const lwm2m_data_t * tlvP, lwm2m_data_t ** targetP, uri_depth_t *targetLevelP);
int senml_findAndCheckData(const lwm2m_uri_t *uriP, uri_depth_t baseLevel, size_t size, const lwm2m_data_t *tlvP,
lwm2m_data_t **targetP, uri_depth_t *targetLevelP);
#endif
// defined in json_common.c

11
core/registration.c
View File

@ -1433,14 +1433,11 @@ static int prv_parseLinkAttributes(uint8_t * data,
&& 0 == lwm2m_strncmp(REG_ATTR_CONTENT_SENML_JSON, (char*)data + index + valueStart, valueLength))
{
*format = LWM2M_CONTENT_SENML_JSON;
}
else if (valueLength == REG_ATTR_CONTENT_SENML_CBOR_LEN
&& 0 == lwm2m_strncmp(REG_ATTR_CONTENT_SENML_CBOR, (char*)data + index + valueStart, valueLength))
{
} else if (valueLength == REG_ATTR_CONTENT_SENML_CBOR_LEN &&
0 ==
lwm2m_strncmp(REG_ATTR_CONTENT_SENML_CBOR, (char *)data + index + valueStart, valueLength)) {
*format = LWM2M_CONTENT_SENML_CBOR;
}
else
{
} else {
return 0;
}
}

11
core/utils.c
View File

@ -812,8 +812,7 @@ uint8_t utils_getResponseFormat(uint8_t accept_num,
#ifdef LWM2M_SUPPORT_SENML_CBOR
#ifndef LWM2M_VERSION_1_1
case LWM2M_CONTENT_CBOR:
if (singular)
{
if (singular) {
*format = LWM2M_CONTENT_CBOR;
found = true;
}
@ -830,13 +829,9 @@ uint8_t utils_getResponseFormat(uint8_t accept_num,
}
}
if (!found) result = COAP_406_NOT_ACCEPTABLE;
}
else if (singular)
{
} else if (singular) {
*format = LWM2M_CONTENT_TEXT;
}
else
{
} else {
#if defined(LWM2M_SUPPORT_SENML_CBOR)
*format = LWM2M_CONTENT_SENML_CBOR;
#elif defined(LWM2M_SUPPORT_SENML_JSON)

403
data/cbor.c
View File

@ -26,75 +26,67 @@
#error CBOR not supported with LWM2M 1.0
#endif
#define CBOR_UNSIGNED_INTEGER 0
#define CBOR_NEGATIVE_INTEGER 1
#define CBOR_BYTE_STRING 2
#define CBOR_TEXT_STRING 3
#define CBOR_ARRAY 4
#define CBOR_MAP 5
#define CBOR_SEMANTIC_TAG 6
#define CBOR_UNSIGNED_INTEGER 0
#define CBOR_NEGATIVE_INTEGER 1
#define CBOR_BYTE_STRING 2
#define CBOR_TEXT_STRING 3
#define CBOR_ARRAY 4
#define CBOR_MAP 5
#define CBOR_SEMANTIC_TAG 6
#define CBOR_FLOATING_OR_SIMPLE 7
#define CBOR_AI_ONE_BYTE_VALUE 24
#define CBOR_AI_TWO_BYTE_VALUE 25
#define CBOR_AI_FOUR_BYTE_VALUE 26
#define CBOR_AI_EIGHT_BYTE_VALUE 27
#define CBOR_AI_ONE_BYTE_VALUE 24
#define CBOR_AI_TWO_BYTE_VALUE 25
#define CBOR_AI_FOUR_BYTE_VALUE 26
#define CBOR_AI_EIGHT_BYTE_VALUE 27
#define CBOR_AI_INDEFINITE_OR_BREAK 31
#define CBOR_SIMPLE_FALSE 20
#define CBOR_SIMPLE_TRUE 21
#define CBOR_SIMPLE_NULL 22
#define CBOR_SIMPLE_UNDEFINED 23
#define CBOR_SIMPLE_FALSE 20
#define CBOR_SIMPLE_TRUE 21
#define CBOR_SIMPLE_NULL 22
#define CBOR_SIMPLE_UNDEFINED 23
int cbor_get_type_and_value(const uint8_t * buffer,
size_t bufferLen,
cbor_type_t * type,
uint64_t * value)
{
int cbor_get_type_and_value(const uint8_t *buffer, size_t bufferLen, cbor_type_t *type, uint64_t *value) {
uint8_t mt;
uint8_t ai;
uint64_t val;
double dval;
int result = 1;
if (bufferLen < 1) return -1;
if (bufferLen < 1)
return -1;
mt = buffer[0] >> 5;
ai = buffer[0] & 0x1f;
switch (ai)
{
switch (ai) {
default:
val = ai;
break;
case CBOR_AI_ONE_BYTE_VALUE:
if (bufferLen < 2) return -1;
if (bufferLen < 2)
return -1;
val = buffer[1];
result += 1;
break;
case CBOR_AI_TWO_BYTE_VALUE:
if (bufferLen < 3) return -1;
if (bufferLen < 3)
return -1;
val = (((uint16_t)buffer[1]) << 8) + buffer[2];
result += 2;
break;
case CBOR_AI_FOUR_BYTE_VALUE:
if (bufferLen < 5) return -1;
val = (((uint32_t)buffer[1]) << 24) +
(((uint32_t)buffer[2]) << 16) +
(((uint32_t)buffer[3]) << 8) +
buffer[4];
if (bufferLen < 5)
return -1;
val = (((uint32_t)buffer[1]) << 24) + (((uint32_t)buffer[2]) << 16) + (((uint32_t)buffer[3]) << 8) + buffer[4];
result += 4;
break;
case CBOR_AI_EIGHT_BYTE_VALUE:
if (bufferLen < 9) return -1;
val = (((uint64_t)buffer[1]) << 56) +
(((uint64_t)buffer[2]) << 48) +
(((uint64_t)buffer[3]) << 40) +
(((uint64_t)buffer[4]) << 32) +
(((uint64_t)buffer[5]) << 24) +
(((uint64_t)buffer[6]) << 16) +
(((uint64_t)buffer[7]) << 8) +
buffer[8];
if (bufferLen < 9)
return -1;
val = (((uint64_t)buffer[1]) << 56) + (((uint64_t)buffer[2]) << 48) + (((uint64_t)buffer[3]) << 40) +
(((uint64_t)buffer[4]) << 32) + (((uint64_t)buffer[5]) << 24) + (((uint64_t)buffer[6]) << 16) +
(((uint64_t)buffer[7]) << 8) + buffer[8];
result += 8;
break;
case 28:
@ -104,14 +96,14 @@ int cbor_get_type_and_value(const uint8_t * buffer,
return -1;
}
switch (mt)
{
switch (mt) {
case CBOR_UNSIGNED_INTEGER:
*type = CBOR_TYPE_UNSIGNED_INTEGER;
*value = val;
break;
case CBOR_NEGATIVE_INTEGER:
if (val >> 63 != 0) return -1; // Can't convert properly
if (val >> 63 != 0)
return -1; // Can't convert properly
*type = CBOR_TYPE_NEGATIVE_INTEGER;
*value = ~val;
break;
@ -136,48 +128,37 @@ int cbor_get_type_and_value(const uint8_t * buffer,
*value = val;
break;
case CBOR_FLOATING_OR_SIMPLE:
switch (ai)
{
switch (ai) {
default:
*type = CBOR_TYPE_SIMPLE_VALUE;
*value = val;
break;
case CBOR_AI_TWO_BYTE_VALUE:
{
uint16_t half = val;
int exp = (half >> 10) & 0x1f;
int mant = half & 0x3ff;
if (exp == 0)
{
dval = ldexp(mant, -24);
}
else if (exp != 31)
{
dval = ldexp(mant + 1024, exp - 25);
}
else if (mant == 0)
{
dval = INFINITY;
}
else
{
dval = NAN;
}
if ((half & 0x8000) != 0)
{
dval = -dval;
}
case CBOR_AI_TWO_BYTE_VALUE: {
uint16_t half = val;
int exp = (half >> 10) & 0x1f;
int mant = half & 0x3ff;
if (exp == 0) {
dval = ldexp(mant, -24);
} else if (exp != 31) {
dval = ldexp(mant + 1024, exp - 25);
} else if (mant == 0) {
dval = INFINITY;
} else {
dval = NAN;
}
if ((half & 0x8000) != 0) {
dval = -dval;
}
}
*type = CBOR_TYPE_FLOAT;
*value = *(uint64_t*)&dval;
*value = *(uint64_t *)&dval;
break;
case CBOR_AI_FOUR_BYTE_VALUE:
{
int32_t val32 = val;
dval = *(float*)&val32;
}
case CBOR_AI_FOUR_BYTE_VALUE: {
int32_t val32 = val;
dval = *(float *)&val32;
}
*type = CBOR_TYPE_FLOAT;
*value = *(uint64_t*)&dval;
*value = *(uint64_t *)&dval;
break;
case CBOR_AI_EIGHT_BYTE_VALUE:
*type = CBOR_TYPE_FLOAT;
@ -197,8 +178,7 @@ int cbor_get_type_and_value(const uint8_t * buffer,
return result;
}
int cbor_get_singular(const uint8_t * buffer, size_t bufferLen, lwm2m_data_t *dataP)
{
int cbor_get_singular(const uint8_t *buffer, size_t bufferLen, lwm2m_data_t *dataP) {
cbor_type_t mt;
uint64_t val;
int result = 0;
@ -210,11 +190,11 @@ int cbor_get_singular(const uint8_t * buffer, size_t bufferLen, lwm2m_data_t *da
skipTag = false;
dataP->type = LWM2M_TYPE_UNDEFINED;
res = cbor_get_type_and_value(buffer + result, bufferLen - result, &mt, &val);
if (res < 1) return -1;
if (res < 1)
return -1;
result += res;
switch (mt)
{
switch (mt) {
case CBOR_TYPE_UNSIGNED_INTEGER:
dataP->type = LWM2M_TYPE_UNSIGNED_INTEGER;
dataP->value.asUnsigned = val;
@ -229,14 +209,14 @@ int cbor_get_singular(const uint8_t * buffer, size_t bufferLen, lwm2m_data_t *da
break;
case CBOR_TYPE_SEMANTIC_TAG:
// Only 1 tag allowed.
if (tagSeen) return -1;
if (tagSeen)
return -1;
tagSeen = true;
// Ignore the tag and get the tagged value.
skipTag = true;
break;
case CBOR_TYPE_SIMPLE_VALUE:
switch (val)
{
switch (val) {
case CBOR_SIMPLE_FALSE:
dataP->type = LWM2M_TYPE_BOOLEAN;
dataP->value.asBoolean = false;
@ -254,29 +234,25 @@ int cbor_get_singular(const uint8_t * buffer, size_t bufferLen, lwm2m_data_t *da
// Indefinite lengths not supported.
return -1;
case CBOR_TYPE_BYTE_STRING:
if (val > bufferLen - result) return -1;
if (val > bufferLen - result)
return -1;
dataP->type = LWM2M_TYPE_OPAQUE;
dataP->value.asBuffer.length = val;
if (val > 0)
{
if (val > 0) {
dataP->value.asBuffer.buffer = (uint8_t *)buffer + result;
}
else
{
} else {
dataP->value.asBuffer.buffer = NULL;
}
result += val;
break;
case CBOR_TYPE_TEXT_STRING:
if (val > bufferLen - result) return -1;
if (val > bufferLen - result)
return -1;
dataP->type = LWM2M_TYPE_STRING;
dataP->value.asBuffer.length = val;
if (val > 0)
{
if (val > 0) {
dataP->value.asBuffer.buffer = (uint8_t *)buffer + result;
}
else
{
} else {
dataP->value.asBuffer.buffer = NULL;
}
result += val;
@ -294,42 +270,36 @@ int cbor_get_singular(const uint8_t * buffer, size_t bufferLen, lwm2m_data_t *da
return result;
}
int prv_put_value(uint8_t * buffer, int bufferLen, uint8_t mt, uint64_t val)
{
int prv_put_value(uint8_t *buffer, int bufferLen, uint8_t mt, uint64_t val) {
int result = 0;
uint8_t val8 = (uint8_t)val;
uint16_t val16 = (uint16_t)val;
uint32_t val32 = (uint32_t)val;
uint8_t ai = CBOR_AI_EIGHT_BYTE_VALUE;
if (val8 == val)
{
if (val8 < 24)
{
if (bufferLen < 1) return 0;
if (val8 == val) {
if (val8 < 24) {
if (bufferLen < 1)
return 0;
ai = val8;
}
else
{
if (bufferLen < 2) return 0;
} else {
if (bufferLen < 2)
return 0;
ai = CBOR_AI_ONE_BYTE_VALUE;
}
}
else if (val16 == val)
{
if (bufferLen < 3) return 0;
} else if (val16 == val) {
if (bufferLen < 3)
return 0;
ai = CBOR_AI_TWO_BYTE_VALUE;
}
else if (val32 == val)
{
if (bufferLen < 5) return 0;
} else if (val32 == val) {
if (bufferLen < 5)
return 0;
ai = CBOR_AI_FOUR_BYTE_VALUE;
}
else if (bufferLen < 9) return 0;
} else if (bufferLen < 9)
return 0;
buffer[result++] = (mt << 5) | ai;
switch (ai)
{
switch (ai) {
case CBOR_AI_EIGHT_BYTE_VALUE:
buffer[result++] = (uint8_t)(val >> 56);
buffer[result++] = (uint8_t)(val >> 48);
@ -353,46 +323,38 @@ int prv_put_value(uint8_t * buffer, int bufferLen, uint8_t mt, uint64_t val)
return result;
}
int prv_put_float(uint8_t *buffer, size_t bufferLen, double val)
{
int prv_put_float(uint8_t *buffer, size_t bufferLen, double val) {
int result = 0;
float fval = val;
if (bufferLen < 3) return 0;
if (bufferLen < 3)
return 0;
if (val != val)
{
if (val != val) {
// NaN
buffer[0] = (CBOR_FLOATING_OR_SIMPLE << 5) | CBOR_AI_TWO_BYTE_VALUE;
buffer[1] = 0x7e;
buffer[2] = 0;
result = 3;
}
else if (fval == val)
{
} else if (fval == val) {
// Single or half precision
uint32_t uval = *(uint32_t*)&fval;
uint32_t uval = *(uint32_t *)&fval;
uint32_t mant = uval & 0x7FFFFF;
int32_t exp = ((uval >> 23) & 0xFF) - 127;
uint8_t sign = (uint8_t)((uval & 0x80000000u) >> 24);
if (exp == 0xFF - 127)
{
if (exp == 0xFF - 127) {
// Infinity
buffer[0] = (CBOR_FLOATING_OR_SIMPLE << 5) | CBOR_AI_TWO_BYTE_VALUE;
buffer[1] = sign | 0x7c;
buffer[2] = 0;
result = 3;
}
else if (mant == 0 && exp == -127)
{
} else if (mant == 0 && exp == -127) {
// Positive or negative 0
buffer[0] = (CBOR_FLOATING_OR_SIMPLE << 5) | CBOR_AI_TWO_BYTE_VALUE;
buffer[1] = sign;
buffer[2] = 0;
result = 3;
}
else if ((mant & 0x7FF) == 0 && exp >= -14 && exp <= 15)
{
} else if ((mant & 0x7FF) == 0 && exp >= -14 && exp <= 15) {
// Normalized half precision
exp = exp + 15;
mant >>= 13;
@ -400,20 +362,17 @@ int prv_put_float(uint8_t *buffer, size_t bufferLen, double val)
buffer[1] = sign | ((exp << 2) & 0x7C) | ((mant >> 8) & 0x3);
buffer[2] = mant & 0xFF;
result = 3;
}
else if (exp >= -24 && exp <= -14 && (mant & ((1 << (1 - exp)) - 1)) == 0 )
{
} else if (exp >= -24 && exp <= -14 && (mant & ((1 << (1 - exp)) - 1)) == 0) {
// Denormalized half precision
mant = (mant + 0x800000) >> (-1 - exp);
buffer[0] = (CBOR_FLOATING_OR_SIMPLE << 5) | CBOR_AI_TWO_BYTE_VALUE;
buffer[1] = sign | ((mant >> 8) & 0x3);
buffer[2] = mant & 0xFF;
result = 3;
}
else
{
} else {
// Single precision
if (bufferLen < 5) return 0;
if (bufferLen < 5)
return 0;
buffer[0] = (CBOR_FLOATING_OR_SIMPLE << 5) | CBOR_AI_FOUR_BYTE_VALUE;
buffer[1] = (uint8_t)(uval >> 24);
buffer[2] = (uint8_t)(uval >> 16);
@ -421,13 +380,12 @@ int prv_put_float(uint8_t *buffer, size_t bufferLen, double val)
buffer[4] = (uint8_t)uval;
result = 5;
}
}
else
{
} else {
// Double precision
uint64_t uval;
if (bufferLen < 9) return 0;
uval = *(uint64_t*)&val;
if (bufferLen < 9)
return 0;
uval = *(uint64_t *)&val;
buffer[0] = (CBOR_FLOATING_OR_SIMPLE << 5) | CBOR_AI_EIGHT_BYTE_VALUE;
buffer[1] = (uint8_t)(uval >> 56);
buffer[2] = (uint8_t)(uval >> 48);
@ -443,20 +401,18 @@ int prv_put_float(uint8_t *buffer, size_t bufferLen, double val)
return result;
}
int cbor_put_type_and_value(uint8_t *buffer,
size_t bufferLen,
cbor_type_t type,
uint64_t val)
{
int cbor_put_type_and_value(uint8_t *buffer, size_t bufferLen, cbor_type_t type, uint64_t val) {
uint8_t mt;
if (bufferLen < 1) return 0;
if (bufferLen < 1)
return 0;
if (type == CBOR_TYPE_NEGATIVE_INTEGER) val = ~val;
if (type == CBOR_TYPE_FLOAT) return prv_put_float(buffer, bufferLen, *(double*)&val);
if (type == CBOR_TYPE_NEGATIVE_INTEGER)
val = ~val;
if (type == CBOR_TYPE_FLOAT)
return prv_put_float(buffer, bufferLen, *(double *)&val);
switch (type)
{
switch (type) {
default:
return 0;
case CBOR_TYPE_UNSIGNED_INTEGER:
@ -469,7 +425,8 @@ int cbor_put_type_and_value(uint8_t *buffer,
mt = CBOR_SEMANTIC_TAG;
break;
case CBOR_TYPE_SIMPLE_VALUE:
if (val > 255) return 0;
if (val > 255)
return 0;
mt = CBOR_FLOATING_OR_SIMPLE;
break;
case CBOR_TYPE_BREAK:
@ -492,13 +449,11 @@ int cbor_put_type_and_value(uint8_t *buffer,
return prv_put_value(buffer, bufferLen, mt, val);
}
int cbor_put_singular(uint8_t *buffer, size_t bufferLen, const lwm2m_data_t * dataP)
{
int cbor_put_singular(uint8_t *buffer, size_t bufferLen, const lwm2m_data_t *dataP) {
int result = 0;
int res = 0;
switch (dataP->type)
{
switch (dataP->type) {
case LWM2M_TYPE_UNDEFINED:
case LWM2M_TYPE_OBJECT:
case LWM2M_TYPE_OBJECT_INSTANCE:
@ -510,87 +465,59 @@ int cbor_put_singular(uint8_t *buffer, size_t bufferLen, const lwm2m_data_t * da
case LWM2M_TYPE_STRING:
case LWM2M_TYPE_CORE_LINK:
case LWM2M_TYPE_OPAQUE:
res = prv_put_value(buffer + result,
bufferLen - result,
(LWM2M_TYPE_OPAQUE == dataP->type ? CBOR_BYTE_STRING
: CBOR_TEXT_STRING),
res = prv_put_value(buffer + result, bufferLen - result,
(LWM2M_TYPE_OPAQUE == dataP->type ? CBOR_BYTE_STRING : CBOR_TEXT_STRING),
dataP->value.asBuffer.length);
if (dataP->value.asBuffer.length > 0)
{
if (res <= 0) return 0;
if (dataP->value.asBuffer.length > 0) {
if (res <= 0)
return 0;
result += res;
memcpy(buffer + result,
dataP->value.asBuffer.buffer,
dataP->value.asBuffer.length);
memcpy(buffer + result, dataP->value.asBuffer.buffer, dataP->value.asBuffer.length);
res = dataP->value.asBuffer.length;
}
break;
case LWM2M_TYPE_INTEGER:
if (dataP->value.asInteger < 0)
{
res = prv_put_value(buffer + result,
bufferLen - result,
CBOR_NEGATIVE_INTEGER,
~dataP->value.asInteger);
if (dataP->value.asInteger < 0) {
res = prv_put_value(buffer + result, bufferLen - result, CBOR_NEGATIVE_INTEGER, ~dataP->value.asInteger);
break;
}
// fall through
case LWM2M_TYPE_UNSIGNED_INTEGER:
res = prv_put_value(buffer + result,
bufferLen - result,
CBOR_UNSIGNED_INTEGER,
dataP->value.asUnsigned);
res = prv_put_value(buffer + result, bufferLen - result, CBOR_UNSIGNED_INTEGER, dataP->value.asUnsigned);
break;
case LWM2M_TYPE_FLOAT:
res = prv_put_float(buffer + result,
bufferLen - result,
dataP->value.asFloat);
res = prv_put_float(buffer + result, bufferLen - result, dataP->value.asFloat);
break;
case LWM2M_TYPE_BOOLEAN:
res = prv_put_value(buffer + result,
bufferLen - result,
CBOR_FLOATING_OR_SIMPLE,
dataP->value.asBoolean ? CBOR_SIMPLE_TRUE
: CBOR_SIMPLE_FALSE);
res = prv_put_value(buffer + result, bufferLen - result, CBOR_FLOATING_OR_SIMPLE,
dataP->value.asBoolean ? CBOR_SIMPLE_TRUE : CBOR_SIMPLE_FALSE);
break;
case LWM2M_TYPE_OBJECT_LINK:
res = snprintf((char *)buffer + result + 1,
bufferLen - result - 1,
"%u:%u",
dataP->value.asObjLink.objectId,
res = snprintf((char *)buffer + result + 1, bufferLen - result - 1, "%u:%u", dataP->value.asObjLink.objectId,
dataP->value.asObjLink.objectInstanceId);
if ((int)(bufferLen - result - 1) > res)
{
if (prv_put_value(buffer + result,
bufferLen - result,
CBOR_TEXT_STRING,
res) == 1)
{
if ((int)(bufferLen - result - 1) > res) {
if (prv_put_value(buffer + result, bufferLen - result, CBOR_TEXT_STRING, res) == 1) {
res += 1;
}
else
{
} else {
res = 0;
}
}
else
{
} else {
res = 0;
}
break;
}
if (res <= 0) return 0;
if (res <= 0)
return 0;
result += res;
return result;
}
#if !defined(LWM2M_VERSION_1_1)
int cbor_parse(const lwm2m_uri_t * uriP, const uint8_t * buffer, size_t bufferLen, lwm2m_data_t ** dataP)
{
int cbor_parse(const lwm2m_uri_t *uriP, const uint8_t *buffer, size_t bufferLen, lwm2m_data_t **dataP) {
int result = 0;
uint8_t * tmp;
uint8_t *tmp;
LOG_ARG("bufferLen: %d", bufferLen);
LOG_URI(uriP);
@ -599,21 +526,17 @@ int cbor_parse(const lwm2m_uri_t * uriP, const uint8_t * buffer, size_t bufferLe
return 0;
*dataP = lwm2m_data_new(1);
if (*dataP == NULL) return 0;
if (*dataP == NULL)
return 0;
if (LWM2M_URI_IS_SET_RESOURCE_INSTANCE(uriP))
{
if (LWM2M_URI_IS_SET_RESOURCE_INSTANCE(uriP)) {
(*dataP)->id = uriP->resourceInstanceId;
}
else
{
} else {
(*dataP)->id = uriP->resourceId;
}
if (cbor_get_singular(buffer, bufferLen, *dataP) == (int)bufferLen)
{
switch ((*dataP)->type)
{
if (cbor_get_singular(buffer, bufferLen, *dataP) == (int)bufferLen) {
switch ((*dataP)->type) {
case LWM2M_TYPE_UNDEFINED:
case LWM2M_TYPE_OBJECT:
case LWM2M_TYPE_OBJECT_INSTANCE:
@ -630,8 +553,7 @@ int cbor_parse(const lwm2m_uri_t * uriP, const uint8_t * buffer, size_t bufferLe
// Buffer is within the input buffer. Need to duplicate it.
tmp = (*dataP)->value.asBuffer.buffer;
(*dataP)->value.asBuffer.buffer = lwm2m_malloc((*dataP)->value.asBuffer.length);
if ((*dataP)->value.asBuffer.buffer != NULL)
{
if ((*dataP)->value.asBuffer.buffer != NULL) {
if (tmp != NULL) {
memcpy((*dataP)->value.asBuffer.buffer, tmp, (*dataP)->value.asBuffer.length);
}
@ -640,8 +562,7 @@ int cbor_parse(const lwm2m_uri_t * uriP, const uint8_t * buffer, size_t bufferLe
break;
}
}
if (result == 0)
{
if (result == 0) {
lwm2m_data_free(1, *dataP);
*dataP = NULL;
}
@ -649,8 +570,7 @@ int cbor_parse(const lwm2m_uri_t * uriP, const uint8_t * buffer, size_t bufferLe
return result;
}
int cbor_serialize(const lwm2m_uri_t * uriP, int size, const lwm2m_data_t * dataP, uint8_t ** bufferP)
{
int cbor_serialize(const lwm2m_uri_t *uriP, int size, const lwm2m_data_t *dataP, uint8_t **bufferP) {
int result = 0;
int res;
uint8_t tmp[13];
@ -660,38 +580,29 @@ int cbor_serialize(const lwm2m_uri_t * uriP, int size, const lwm2m_data_t * data
*bufferP = NULL;
if (size != 1) return 0;
if (size != 1)
return 0;
switch (dataP->type)
{
switch (dataP->type) {
case LWM2M_TYPE_STRING:
case LWM2M_TYPE_CORE_LINK:
case LWM2M_TYPE_OPAQUE:
res = prv_put_value(tmp,
sizeof(tmp),
(LWM2M_TYPE_OPAQUE == dataP->type ? CBOR_BYTE_STRING
: CBOR_TEXT_STRING),
res = prv_put_value(tmp, sizeof(tmp), (LWM2M_TYPE_OPAQUE == dataP->type ? CBOR_BYTE_STRING : CBOR_TEXT_STRING),
dataP->value.asBuffer.length);
if (res > 0)
{
if (res > 0) {
*bufferP = lwm2m_malloc(res + dataP->value.asBuffer.length);
if (*bufferP != NULL)
{
if (*bufferP != NULL) {
result = res + dataP->value.asBuffer.length;
memcpy(*bufferP, tmp, res);
memcpy((*bufferP) + res,
dataP->value.asBuffer.buffer,
dataP->value.asBuffer.length);
memcpy((*bufferP) + res, dataP->value.asBuffer.buffer, dataP->value.asBuffer.length);
}
}
break;
default:
res = cbor_put_singular(tmp, sizeof(tmp), dataP);
if (res > 0)
{
if (res > 0) {
*bufferP = lwm2m_malloc(res);
if (*bufferP != NULL)
{
if (*bufferP != NULL) {
result = res;
memcpy(*bufferP, tmp, res);
}

39
data/data.c
View File

@ -735,10 +735,7 @@ int lwm2m_data_serialize(lwm2m_uri_t * uriP,
LOG_ARG("size: %d, formatP: %s", size, STR_MEDIA_TYPE(*formatP));
// Check format
if (*formatP == LWM2M_CONTENT_TEXT
|| *formatP == LWM2M_CONTENT_OPAQUE
|| *formatP == LWM2M_CONTENT_CBOR)
{
if (*formatP == LWM2M_CONTENT_TEXT || *formatP == LWM2M_CONTENT_OPAQUE || *formatP == LWM2M_CONTENT_CBOR) {
if (size != 1
|| (uriP != NULL && !LWM2M_URI_IS_SET_RESOURCE(uriP))
|| dataP->type == LWM2M_TYPE_OBJECT
@ -839,31 +836,23 @@ int lwm2m_data_serialize(lwm2m_uri_t * uriP,
}
}
int lwm2m_data_append(int *sizeP,
lwm2m_data_t **dataP,
int addDataSize,
lwm2m_data_t *addDataP)
{
int lwm2m_data_append(int *sizeP, lwm2m_data_t **dataP, int addDataSize, lwm2m_data_t *addDataP) {
int result = 0;
int tmpSize = (*sizeP) + addDataSize;
if (addDataSize == 0)
{
if (addDataSize == 0) {
// Nothing to do.
result = 1;
}
if (*sizeP == 0)
{
if (*sizeP == 0) {
*dataP = addDataP;
*sizeP = addDataSize;
result = 1;
}
// Guard against overflow
else if (tmpSize > *sizeP && tmpSize > addDataSize)
{
lwm2m_data_t * tmpDataP = lwm2m_data_new(tmpSize);
if (tmpDataP != NULL)
{
else if (tmpSize > *sizeP && tmpSize > addDataSize) {
lwm2m_data_t *tmpDataP = lwm2m_data_new(tmpSize);
if (tmpDataP != NULL) {
// Shallow copy into new array
memcpy(tmpDataP, *dataP, (*sizeP) * sizeof(lwm2m_data_t));
memcpy(tmpDataP + *sizeP, addDataP, addDataSize * sizeof(lwm2m_data_t));
@ -882,20 +871,14 @@ int lwm2m_data_append(int *sizeP,
return result;
}
int lwm2m_data_append_one(int *sizeP,
lwm2m_data_t **dataP,
lwm2m_data_type_t type,
uint16_t id)
{
int lwm2m_data_append_one(int *sizeP, lwm2m_data_t **dataP, lwm2m_data_type_t type, uint16_t id) {
int result = 0;
int tmpSize = *sizeP + 1;
// Guard against overflow
if (tmpSize > *sizeP)
{
lwm2m_data_t * tmpDataP = lwm2m_data_new(tmpSize);
if (tmpDataP != NULL)
{
if (tmpSize > *sizeP) {
lwm2m_data_t *tmpDataP = lwm2m_data_new(tmpSize);
if (tmpDataP != NULL) {
// Shallow copy into new array
memcpy(tmpDataP, *dataP, (*sizeP) * sizeof(lwm2m_data_t));
// Shallow free old data

656
data/senml_cbor.c
View File

File diff suppressed because it is too large Load Diff

398
data/senml_common.c
View File

@ -16,93 +16,76 @@
*
*******************************************************************************/
#include "internals.h"
#if defined(LWM2M_SUPPORT_JSON) || defined(LWM2M_SUPPORT_SENML_JSON) || defined(LWM2M_SUPPORT_SENML_CBOR)
static int prv_convertRecord(const senml_record_t * recordArray,
int count,
lwm2m_data_t ** dataP,
senml_convertValue convertValue)
{
static int prv_convertRecord(const senml_record_t *recordArray, int count, lwm2m_data_t **dataP,
senml_convertValue convertValue) {
int index;
int freeIndex;
lwm2m_data_t * rootP;
lwm2m_data_t *rootP;
rootP = lwm2m_data_new(count);
if (NULL == rootP)
{
if (NULL == rootP) {
*dataP = NULL;
return -1;
}
freeIndex = 0;
for (index = 0 ; index < count ; index++)
{
lwm2m_data_t * targetP;
for (index = 0; index < count; index++) {
lwm2m_data_t *targetP;
int i;
targetP = senml_findDataItem(rootP, count, recordArray[index].ids[0]);
if (targetP == NULL)
{
if (targetP == NULL) {
targetP = rootP + freeIndex;
freeIndex++;
targetP->id = recordArray[index].ids[0];
if (targetP->id != LWM2M_MAX_ID)
{
if (targetP->id != LWM2M_MAX_ID) {
targetP->type = LWM2M_TYPE_OBJECT;
}
else
{
} else {
targetP->type = LWM2M_TYPE_UNDEFINED;
}
}
if (recordArray[index].ids[1] != LWM2M_MAX_ID)
{
lwm2m_data_t * parentP;
if (recordArray[index].ids[1] != LWM2M_MAX_ID) {
lwm2m_data_t *parentP;
uri_depth_t level;
parentP = targetP;
level = URI_DEPTH_OBJECT_INSTANCE;
for (i = 1 ; i <= 2 ; i++)
{
if (recordArray[index].ids[i] == LWM2M_MAX_ID) break;
targetP = senml_findDataItem(parentP->value.asChildren.array,
parentP->value.asChildren.count,
recordArray[index].ids[i]);
if (targetP == NULL)
{
targetP = senml_extendData(parentP,
utils_depthToDatatype(level),
recordArray[index].ids[i]);
if (targetP == NULL) goto error;
for (i = 1; i <= 2; i++) {
if (recordArray[index].ids[i] == LWM2M_MAX_ID)
break;
targetP = senml_findDataItem(parentP->value.asChildren.array, parentP->value.asChildren.count,
recordArray[index].ids[i]);
if (targetP == NULL) {
targetP = senml_extendData(parentP, utils_depthToDatatype(level), recordArray[index].ids[i]);
if (targetP == NULL)
goto error;
}
level = senml_decreaseLevel(level);
parentP = targetP;
}
if (recordArray[index].ids[3] != LWM2M_MAX_ID)
{
if (recordArray[index].ids[3] != LWM2M_MAX_ID) {
targetP->type = LWM2M_TYPE_MULTIPLE_RESOURCE;
targetP = senml_extendData(targetP,
LWM2M_TYPE_UNDEFINED,
recordArray[index].ids[3]);
if (targetP == NULL) goto error;
targetP = senml_extendData(targetP, LWM2M_TYPE_UNDEFINED, recordArray[index].ids[3]);
if (targetP == NULL)
goto error;
}
}
if (!convertValue(recordArray + index, targetP)) goto error;
if (!convertValue(recordArray + index, targetP))
goto error;
}
if (freeIndex < count)
{
if (freeIndex < count) {
*dataP = lwm2m_data_new(freeIndex);
if (*dataP == NULL) goto error;
if (*dataP == NULL)
goto error;
memcpy(*dataP, rootP, freeIndex * sizeof(lwm2m_data_t));
lwm2m_free(rootP); /* do not use lwm2m_data_free() to keep pointed values */
}
else
{
lwm2m_free(rootP); /* do not use lwm2m_data_free() to keep pointed values */
} else {
*dataP = rootP;
}
@ -115,43 +98,33 @@ error:
return -1;
}
int senml_convert_records(const lwm2m_uri_t* uriP,
senml_record_t * recordArray,
int numRecords,
senml_convertValue convertValue,
lwm2m_data_t ** dataP)
{
lwm2m_data_t * resultP;
lwm2m_data_t * parsedP = NULL;
int senml_convert_records(const lwm2m_uri_t *uriP, senml_record_t *recordArray, int numRecords,
senml_convertValue convertValue, lwm2m_data_t **dataP) {
lwm2m_data_t *resultP;
lwm2m_data_t *parsedP = NULL;
int size;
int count;
count = prv_convertRecord(recordArray, numRecords, &parsedP, convertValue);
lwm2m_free(recordArray);
if (count > 0 && uriP != NULL && LWM2M_URI_IS_SET_OBJECT(uriP))
{
if (parsedP->type != LWM2M_TYPE_OBJECT) goto error;
if (parsedP->id != uriP->objectId) goto error;
if (count > 0 && uriP != NULL && LWM2M_URI_IS_SET_OBJECT(uriP)) {
if (parsedP->type != LWM2M_TYPE_OBJECT)
goto error;
if (parsedP->id != uriP->objectId)
goto error;
if (!LWM2M_URI_IS_SET_INSTANCE(uriP))
{
if (!LWM2M_URI_IS_SET_INSTANCE(uriP)) {
size = parsedP->value.asChildren.count;
resultP = parsedP->value.asChildren.array;
}
else
{
} else {
int i;
resultP = NULL;
/* be permissive and allow full object when requesting for a single instance */
for (i = 0;
i < (int)parsedP->value.asChildren.count && resultP == NULL;
i++)
{
lwm2m_data_t* targetP;
for (i = 0; i < (int)parsedP->value.asChildren.count && resultP == NULL; i++) {
lwm2m_data_t *targetP;
targetP = parsedP->value.asChildren.array + i;
if (targetP->id == uriP->instanceId)
{
if (targetP->id == uriP->instanceId) {
resultP = targetP->value.asChildren.array;
size = targetP->value.asChildren.count;
}
@ -159,73 +132,66 @@ int senml_convert_records(const lwm2m_uri_t* uriP,
if (resultP == NULL)
goto error;
if (LWM2M_URI_IS_SET_RESOURCE(uriP))
{
lwm2m_data_t* resP;
if (LWM2M_URI_IS_SET_RESOURCE(uriP)) {
lwm2m_data_t *resP;
resP = NULL;
for (i = 0; i < size && resP == NULL; i++)
{
lwm2m_data_t* targetP;
for (i = 0; i < size && resP == NULL; i++) {
lwm2m_data_t *targetP;
targetP = resultP + i;
if (targetP->id == uriP->resourceId)
{
if (targetP->id == uriP->resourceId) {
#ifndef LWM2M_VERSION_1_0
if (targetP->type == LWM2M_TYPE_MULTIPLE_RESOURCE
&& LWM2M_URI_IS_SET_RESOURCE_INSTANCE(uriP))
{
if (targetP->type == LWM2M_TYPE_MULTIPLE_RESOURCE && LWM2M_URI_IS_SET_RESOURCE_INSTANCE(uriP)) {
resP = targetP->value.asChildren.array;
size = targetP->value.asChildren.count;
}
else
} else
#endif
{
size = senml_dataStrip(1, targetP, &resP);
if (size <= 0) goto error;
if (size <= 0)
goto error;
lwm2m_data_free(count, parsedP);
parsedP = NULL;
}
}
}
if (resP == NULL) goto error;
if (resP == NULL)
goto error;
resultP = resP;
}
#ifndef LWM2M_VERSION_1_0
if (LWM2M_URI_IS_SET_RESOURCE_INSTANCE(uriP))
{
lwm2m_data_t* resP;
if (LWM2M_URI_IS_SET_RESOURCE_INSTANCE(uriP)) {
lwm2m_data_t *resP;
resP = NULL;
for (i = 0; i < size && resP == NULL; i++)
{
lwm2m_data_t* targetP;
for (i = 0; i < size && resP == NULL; i++) {
lwm2m_data_t *targetP;
targetP = resultP + i;
if (targetP->id == uriP->resourceInstanceId)
{
if (targetP->id == uriP->resourceInstanceId) {
size = senml_dataStrip(1, targetP, &resP);
if (size <= 0) goto error;
if (size <= 0)
goto error;
lwm2m_data_free(count, parsedP);
parsedP = NULL;
}
}
if (resP == NULL) goto error;
if (resP == NULL)
goto error;
resultP = resP;
}
#endif
}
}
else
{
} else {
resultP = parsedP;
size = count;
}
if (parsedP != NULL)
{
lwm2m_data_t* tempP;
if (parsedP != NULL) {
lwm2m_data_t *tempP;
size = senml_dataStrip(size, resultP, &tempP);
if (size <= 0) goto error;
if (size <= 0)
goto error;
lwm2m_data_free(count, parsedP);
resultP = tempP;
@ -235,63 +201,47 @@ int senml_convert_records(const lwm2m_uri_t* uriP,
return count;
error:
if (parsedP != NULL)
{
if (parsedP != NULL) {
lwm2m_data_free(count, parsedP);
parsedP = NULL;
}
return -1;
}
lwm2m_data_t * senml_extendData(lwm2m_data_t * parentP,
lwm2m_data_type_t type,
uint16_t id)
{
lwm2m_data_t *senml_extendData(lwm2m_data_t *parentP, lwm2m_data_type_t type, uint16_t id) {
int count = parentP->value.asChildren.count;
if (lwm2m_data_append_one(&count,
&parentP->value.asChildren.array,
type,
id) != 0)
{
if (lwm2m_data_append_one(&count, &parentP->value.asChildren.array, type, id) != 0) {
parentP->value.asChildren.count = count;
return parentP->value.asChildren.array + count - 1;
}
return NULL;
}
int senml_dataStrip(int size, lwm2m_data_t * dataP, lwm2m_data_t ** resultP)
{
int senml_dataStrip(int size, lwm2m_data_t *dataP, lwm2m_data_t **resultP) {
int i;
int j;
*resultP = lwm2m_data_new(size);
if (*resultP == NULL) return -1;
if (*resultP == NULL)
return -1;
j = 0;
for (i = 0 ; i < size ; i++)
{
for (i = 0; i < size; i++) {
memcpy((*resultP) + j, dataP + i, sizeof(lwm2m_data_t));
switch (dataP[i].type)
{
switch (dataP[i].type) {
case LWM2M_TYPE_OBJECT:
case LWM2M_TYPE_OBJECT_INSTANCE:
case LWM2M_TYPE_MULTIPLE_RESOURCE:
{
if (dataP[i].value.asChildren.count != 0)
{
case LWM2M_TYPE_MULTIPLE_RESOURCE: {
if (dataP[i].value.asChildren.count != 0) {
int childLen;
childLen = senml_dataStrip(dataP[i].value.asChildren.count,
dataP[i].value.asChildren.array,
&((*resultP)[j].value.asChildren.array));
if (childLen <= 0)
{
childLen = senml_dataStrip(dataP[i].value.asChildren.count, dataP[i].value.asChildren.array,
&((*resultP)[j].value.asChildren.array));
if (childLen <= 0) {
/* skip this one */
j--;
}
else
{
} else {
(*resultP)[j].value.asChildren.count = childLen;
}
}
@ -314,17 +264,14 @@ int senml_dataStrip(int size, lwm2m_data_t * dataP, lwm2m_data_t ** resultP)
return size;
}
lwm2m_data_t * senml_findDataItem(lwm2m_data_t * listP, size_t count, uint16_t id)
{
lwm2m_data_t *senml_findDataItem(lwm2m_data_t *listP, size_t count, uint16_t id) {
size_t i;
// TODO: handle times
i = 0;
while (i < count)
{
if (listP[i].type != LWM2M_TYPE_UNDEFINED && listP[i].id == id)
{
while (i < count) {
if (listP[i].type != LWM2M_TYPE_UNDEFINED && listP[i].id == id) {
return listP + i;
}
i++;
@ -333,10 +280,8 @@ lwm2m_data_t * senml_findDataItem(lwm2m_data_t * listP, size_t count, uint16_t i
return NULL;
}
uri_depth_t senml_decreaseLevel(uri_depth_t level)
{
switch(level)
{
uri_depth_t senml_decreaseLevel(uri_depth_t level) {
switch (level) {
case URI_DEPTH_NONE:
return URI_DEPTH_OBJECT;
case URI_DEPTH_OBJECT:
@ -352,39 +297,25 @@ uri_depth_t senml_decreaseLevel(uri_depth_t level)
}
}
static int prv_findAndCheckData(const lwm2m_uri_t * uriP,
uri_depth_t desiredLevel,
size_t size,
const lwm2m_data_t * tlvP,
lwm2m_data_t ** targetP,
uri_depth_t *targetLevelP)
{
static int prv_findAndCheckData(const lwm2m_uri_t *uriP, uri_depth_t desiredLevel, size_t size,
const lwm2m_data_t *tlvP, lwm2m_data_t **targetP, uri_depth_t *targetLevelP) {
size_t index;
int result;
if (size == 0) return 0;
if (size == 0)
return 0;
if (size > 1)
{
if (tlvP[0].type == LWM2M_TYPE_OBJECT
|| tlvP[0].type == LWM2M_TYPE_OBJECT_INSTANCE)
{
for (index = 0; index < size; index++)
{
if (tlvP[index].type != tlvP[0].type)
{
if (size > 1) {
if (tlvP[0].type == LWM2M_TYPE_OBJECT || tlvP[0].type == LWM2M_TYPE_OBJECT_INSTANCE) {
for (index = 0; index < size; index++) {
if (tlvP[index].type != tlvP[0].type) {
*targetP = NULL;
return -1;
}
}
}
else
{
for (index = 0; index < size; index++)
{
if (tlvP[index].type == LWM2M_TYPE_OBJECT
|| tlvP[index].type == LWM2M_TYPE_OBJECT_INSTANCE)
{
} else {
for (index = 0; index < size; index++) {
if (tlvP[index].type == LWM2M_TYPE_OBJECT || tlvP[index].type == LWM2M_TYPE_OBJECT_INSTANCE) {
*targetP = NULL;
return -1;
}
@ -394,37 +325,28 @@ static int prv_findAndCheckData(const lwm2m_uri_t * uriP,
*targetP = NULL;
result = -1;
switch (desiredLevel)
{
switch (desiredLevel) {
case URI_DEPTH_OBJECT:
if (tlvP[0].type == LWM2M_TYPE_OBJECT)
{
*targetP = (lwm2m_data_t*)tlvP;
if (tlvP[0].type == LWM2M_TYPE_OBJECT) {
*targetP = (lwm2m_data_t *)tlvP;
*targetLevelP = URI_DEPTH_OBJECT;
result = (int)size;
}
break;
case URI_DEPTH_OBJECT_INSTANCE:
switch (tlvP[0].type)
{
switch (tlvP[0].type) {
case LWM2M_TYPE_OBJECT:
for (index = 0; index < size; index++)
{
if (tlvP[index].id == uriP->objectId)
{
for (index = 0; index < size; index++) {
if (tlvP[index].id == uriP->objectId) {
*targetLevelP = URI_DEPTH_OBJECT_INSTANCE;
return prv_findAndCheckData(uriP,
desiredLevel,
tlvP[index].value.asChildren.count,
tlvP[index].value.asChildren.array,
targetP,
targetLevelP);
return prv_findAndCheckData(uriP, desiredLevel, tlvP[index].value.asChildren.count,
tlvP[index].value.asChildren.array, targetP, targetLevelP);
}
}
break;
case LWM2M_TYPE_OBJECT_INSTANCE:
*targetP = (lwm2m_data_t*)tlvP;
*targetP = (lwm2m_data_t *)tlvP;
result = (int)size;
break;
default:
@ -433,94 +355,63 @@ static int prv_findAndCheckData(const lwm2m_uri_t * uriP,
break;
case URI_DEPTH_RESOURCE:
switch (tlvP[0].type)
{
switch (tlvP[0].type) {
case LWM2M_TYPE_OBJECT:
for (index = 0; index < size; index++)
{
if (tlvP[index].id == uriP->objectId)
{
for (index = 0; index < size; index++) {
if (tlvP[index].id == uriP->objectId) {
*targetLevelP = URI_DEPTH_OBJECT_INSTANCE;
return prv_findAndCheckData(uriP,
desiredLevel,
tlvP[index].value.asChildren.count,
tlvP[index].value.asChildren.array,
targetP,
targetLevelP);
return prv_findAndCheckData(uriP, desiredLevel, tlvP[index].value.asChildren.count,
tlvP[index].value.asChildren.array, targetP, targetLevelP);
}
}
break;
case LWM2M_TYPE_OBJECT_INSTANCE:
for (index = 0; index < size; index++)
{
if (tlvP[index].id == uriP->instanceId)
{
for (index = 0; index < size; index++) {
if (tlvP[index].id == uriP->instanceId) {
*targetLevelP = URI_DEPTH_RESOURCE;
return prv_findAndCheckData(uriP,
desiredLevel,
tlvP[index].value.asChildren.count,
tlvP[index].value.asChildren.array,
targetP, targetLevelP);
return prv_findAndCheckData(uriP, desiredLevel, tlvP[index].value.asChildren.count,
tlvP[index].value.asChildren.array, targetP, targetLevelP);
}
}
break;
default:
*targetP = (lwm2m_data_t*)tlvP;
*targetP = (lwm2m_data_t *)tlvP;
result = (int)size;
break;
}
break;
case URI_DEPTH_RESOURCE_INSTANCE:
switch (tlvP[0].type)
{
switch (tlvP[0].type) {
case LWM2M_TYPE_OBJECT:
for (index = 0; index < size; index++)
{
if (tlvP[index].id == uriP->objectId)
{
for (index = 0; index < size; index++) {
if (tlvP[index].id == uriP->objectId) {
*targetLevelP = URI_DEPTH_OBJECT_INSTANCE;
return prv_findAndCheckData(uriP,
desiredLevel,
tlvP[index].value.asChildren.count,
tlvP[index].value.asChildren.array,
targetP,
targetLevelP);
return prv_findAndCheckData(uriP, desiredLevel, tlvP[index].value.asChildren.count,
tlvP[index].value.asChildren.array, targetP, targetLevelP);
}
}
break;
case LWM2M_TYPE_OBJECT_INSTANCE:
for (index = 0; index < size; index++)
{
if (tlvP[index].id == uriP->instanceId)
{
for (index = 0; index < size; index++) {
if (tlvP[index].id == uriP->instanceId) {
*targetLevelP = URI_DEPTH_RESOURCE;
return prv_findAndCheckData(uriP,
desiredLevel,
tlvP[index].value.asChildren.count,
tlvP[index].value.asChildren.array,
targetP,
targetLevelP);
return prv_findAndCheckData(uriP, desiredLevel, tlvP[index].value.asChildren.count,
tlvP[index].value.asChildren.array, targetP, targetLevelP);
}
}
break;
case LWM2M_TYPE_MULTIPLE_RESOURCE:
for (index = 0; index < size; index++)
{
if (tlvP[index].id == uriP->resourceId)
{
for (index = 0; index < size; index++) {
if (tlvP[index].id == uriP->resourceId) {
*targetLevelP = URI_DEPTH_RESOURCE_INSTANCE;
return prv_findAndCheckData(uriP,
desiredLevel,
tlvP[index].value.asChildren.count,
tlvP[index].value.asChildren.array,
targetP,
targetLevelP);
return prv_findAndCheckData(uriP, desiredLevel, tlvP[index].value.asChildren.count,
tlvP[index].value.asChildren.array, targetP, targetLevelP);
}
}
break;
default:
*targetP = (lwm2m_data_t*)tlvP;
*targetP = (lwm2m_data_t *)tlvP;
result = (int)size;
break;
}
@ -533,28 +424,15 @@ static int prv_findAndCheckData(const lwm2m_uri_t * uriP,
return result;
}
int senml_findAndCheckData(const lwm2m_uri_t * uriP,
uri_depth_t baseLevel,
size_t size,
const lwm2m_data_t * tlvP,
lwm2m_data_t ** targetP,
uri_depth_t *targetLevelP)
{
int senml_findAndCheckData(const lwm2m_uri_t *uriP, uri_depth_t baseLevel, size_t size, const lwm2m_data_t *tlvP,
lwm2m_data_t **targetP, uri_depth_t *targetLevelP) {
uri_depth_t desiredLevel = senml_decreaseLevel(baseLevel);
if (baseLevel < URI_DEPTH_RESOURCE)
{
if (baseLevel < URI_DEPTH_RESOURCE) {
*targetLevelP = desiredLevel;
}
else
{
} else {
*targetLevelP = baseLevel;
}
return prv_findAndCheckData(uriP,
desiredLevel,
size,
tlvP,
targetP,
targetLevelP);
return prv_findAndCheckData(uriP, desiredLevel, size, tlvP, targetP, targetLevelP);
}
#endif

281
examples/shared/commandline.c
View File

@ -17,14 +17,14 @@
*
*******************************************************************************/
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <math.h>
#include <unistd.h>
#include <inttypes.h>
#include "liblwm2m.h"
#include <ctype.h>
#include <inttypes.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "commandline.h"
@ -302,86 +302,60 @@ void output_tlv(FILE * stream,
}
#ifdef LWM2M_SUPPORT_SENML_CBOR
#define CBOR_UNSIGNED_INTEGER 0
#define CBOR_NEGATIVE_INTEGER 1
#define CBOR_BYTE_STRING 2
#define CBOR_TEXT_STRING 3
#define CBOR_ARRAY 4
#define CBOR_MAP 5
#define CBOR_SEMANTIC_TAG 6
#define CBOR_UNSIGNED_INTEGER 0
#define CBOR_NEGATIVE_INTEGER 1
#define CBOR_BYTE_STRING 2
#define CBOR_TEXT_STRING 3
#define CBOR_ARRAY 4
#define CBOR_MAP 5
#define CBOR_SEMANTIC_TAG 6
#define CBOR_FLOATING_OR_SIMPLE 7
#define CBOR_AI_ONE_BYTE_VALUE 24
#define CBOR_AI_TWO_BYTE_VALUE 25
#define CBOR_AI_FOUR_BYTE_VALUE 26
#define CBOR_AI_EIGHT_BYTE_VALUE 27
#define CBOR_AI_ONE_BYTE_VALUE 24
#define CBOR_AI_TWO_BYTE_VALUE 25
#define CBOR_AI_FOUR_BYTE_VALUE 26
#define CBOR_AI_EIGHT_BYTE_VALUE 27
#define CBOR_AI_INDEFINITE_OR_BREAK 31
#define CBOR_SIMPLE_FALSE 20
#define CBOR_SIMPLE_TRUE 21
#define CBOR_SIMPLE_NULL 22
#define CBOR_SIMPLE_UNDEFINED 23
#define CBOR_SIMPLE_FALSE 20
#define CBOR_SIMPLE_TRUE 21
#define CBOR_SIMPLE_NULL 22
#define CBOR_SIMPLE_UNDEFINED 23
static int prv_output_cbor_indefinite(FILE * stream,
uint8_t * buffer,
size_t buffer_len,
bool breakable,
uint8_t * mt);
static int prv_output_cbor_indefinite(FILE *stream, uint8_t *buffer, size_t buffer_len, bool breakable, uint8_t *mt);
static double prv_convert_half(uint16_t half)
{
static double prv_convert_half(uint16_t half) {
double result;
int exp = (half >> 10) & 0x1f;
int mant = half & 0x3ff;
if (exp == 0)
{
if (exp == 0) {
result = ldexp(mant, -24);
}
else if (exp != 31)
{
} else if (exp != 31) {
result = ldexp(mant + 1024, exp - 25);
}
else if (mant == 0)
{
} else if (mant == 0) {
result = INFINITY;
}
else
{
} else {
result = NAN;
}
if ((half & 0x8000) != 0)
{
if ((half & 0x8000) != 0) {
result = -result;
}
return result;
}
static void prv_output_cbor_float(FILE * stream, double val)
{
if (val != val)
{
static void prv_output_cbor_float(FILE *stream, double val) {
if (val != val) {
fprintf(stream, "NaN");
}
else if (val == INFINITY)
{
} else if (val == INFINITY) {
fprintf(stream, "Infinity");
}
else if (val == -INFINITY)
{
} else if (val == -INFINITY) {
fprintf(stream, "-Infinity");
}
else
{
} else {
fprintf(stream, "%g", val);
}
}
static int prv_output_cbor_definite(FILE * stream,
uint8_t * buffer,
size_t buffer_len,
bool breakable,
uint8_t *mt)
{
static int prv_output_cbor_definite(FILE *stream, uint8_t *buffer, size_t buffer_len, bool breakable, uint8_t *mt) {
int head;
int res;
uint8_t ai;
@ -402,8 +376,7 @@ static int prv_output_cbor_definite(FILE * stream,
ai = buffer[0] & 0x1f;
head = 1;
switch (ai)
{
switch (ai) {
default:
valbits = 8;
val.u8 = ai;
@ -441,17 +414,13 @@ static int prv_output_cbor_definite(FILE * stream,
// Invalid
return -1;
case CBOR_AI_INDEFINITE_OR_BREAK:
res = prv_output_cbor_indefinite(stream,
buffer + head,
buffer_len - head,
breakable,
mt);
if (res < 0) return res;
res = prv_output_cbor_indefinite(stream, buffer + head, buffer_len - head, breakable, mt);
if (res < 0)
return res;
return head + res;
}
switch (valbits)
{
switch (valbits) {
case 8:
u64 = val.u8;
i64 = ~(int64_t)val.u8;
@ -473,92 +442,75 @@ static int prv_output_cbor_definite(FILE * stream,
return -1;
}
switch (*mt)
{
switch (*mt) {
case CBOR_UNSIGNED_INTEGER:
fprintf(stream, "%"PRIu64, u64);
fprintf(stream, "%" PRIu64, u64);
break;
case CBOR_NEGATIVE_INTEGER:
if ((u64 >> 63) != 0)
{
if ((u64 >> 63) != 0) {
// Unrepresentable
return -1;
}
else
{
fprintf(stream, "%"PRId64, i64);
} else {
fprintf(stream, "%" PRId64, i64);
}
break;
case CBOR_BYTE_STRING:
fprintf(stream, "h'");
if (buffer_len - head < u64) return -1;
for (i = 0; i < u64; i++)
{
if (buffer_len - head < u64)
return -1;
for (i = 0; i < u64; i++) {
fprintf(stream, "%02x", buffer[head++]);
}
fprintf(stream, "'");
break;
case CBOR_TEXT_STRING:
fprintf(stream, "\"");
if (buffer_len - head < u64) return -1;
for (i = 0; i < u64; i++)
{
if (buffer_len - head < u64)
return -1;
for (i = 0; i < u64; i++) {
fprintf(stream, "%c", buffer[head++]);
}
fprintf(stream, "\"");
break;
case CBOR_ARRAY:
fprintf(stream, "[");
for (i = 0; i < u64; i++)
{
if (i != 0) fprintf(stream, ", ");
res = prv_output_cbor_definite(stream,
buffer + head,
buffer_len - head,
false,
mt);
if (res <= 0) return -1;
for (i = 0; i < u64; i++) {
if (i != 0)
fprintf(stream, ", ");
res = prv_output_cbor_definite(stream, buffer + head, buffer_len - head, false, mt);
if (res <= 0)
return -1;
head += res;
}
fprintf(stream, "]");
break;
case CBOR_MAP:
fprintf(stream, "{");
for (i = 0; i < u64; i++)
{
if (i != 0) fprintf(stream, ", ");
res = prv_output_cbor_definite(stream,
buffer + head,
buffer_len - head,
false,
mt);
if (res <= 0) return -1;
for (i = 0; i < u64; i++) {
if (i != 0)
fprintf(stream, ", ");
res = prv_output_cbor_definite(stream, buffer + head, buffer_len - head, false, mt);
if (res <= 0)
return -1;
head += res;
fprintf(stream, ": ");
res = prv_output_cbor_definite(stream,
buffer + head,
buffer_len - head,
false,
mt);
if (res <= 0) return -1;
res = prv_output_cbor_definite(stream, buffer + head, buffer_len - head, false, mt);
if (res <= 0)
return -1;
head += res;
}
fprintf(stream, "}");
break;
case CBOR_SEMANTIC_TAG:
fprintf(stream, "%"PRIu64"(", u64);
res = prv_output_cbor_definite(stream,
buffer + head,
buffer_len - head,
false,
mt);
if (res <= 0) return -1;
fprintf(stream, "%" PRIu64 "(", u64);
res = prv_output_cbor_definite(stream, buffer + head, buffer_len - head, false, mt);
if (res <= 0)
return -1;
head += res;
fprintf(stream, ")");
break;
case CBOR_FLOATING_OR_SIMPLE:
switch (ai)
{
switch (ai) {
default:
fprintf(stream, "simple(%u)", val.u8);
break;
@ -598,78 +550,62 @@ static int prv_output_cbor_definite(FILE * stream,
return head;
}
static int prv_output_cbor_indefinite(FILE * stream,
uint8_t * buffer,
size_t buffer_len,
bool breakable,
uint8_t * mt)
{
static int prv_output_cbor_indefinite(FILE *stream, uint8_t *buffer, size_t buffer_len, bool breakable, uint8_t *mt) {
uint8_t it;
int head = 0;
int res;
switch (*mt)
{
switch (*mt) {
case CBOR_BYTE_STRING:
case CBOR_TEXT_STRING:
fprintf(stream, "(_ ");
while (1)
{
res = prv_output_cbor_definite(stream,
buffer + head,
buffer_len - head,
true,
&it);
if (res <= 0) return -1;
while (1) {
res = prv_output_cbor_definite(stream, buffer + head, buffer_len - head, true, &it);
if (res <= 0)
return -1;
head += res;
if (it == UINT8_MAX) break;
if (it != *mt) return -1;
if (it == UINT8_MAX)
break;
if (it != *mt)
return -1;
fprintf(stream, ", ");
}
fprintf(stream, ")");
break;
case CBOR_ARRAY:
fprintf(stream, "[_ ");
while (1)
{
res = prv_output_cbor_definite(stream,
buffer + head,
buffer_len - head,
true,
&it);
if (res <= 0) return -1;
while (1) {
res = prv_output_cbor_definite(stream, buffer + head, buffer_len - head, true, &it);
if (res <= 0)
return -1;
head += res;
if (it == UINT8_MAX) break;
if (it == UINT8_MAX)
break;
fprintf(stream, ", ");
}
fprintf(stream, "]");
break;
case CBOR_MAP:
fprintf(stream, "{_ ");
while (1)
{
res = prv_output_cbor_definite(stream,
buffer + head,
buffer_len - head,
true,
&it);
if (res <= 0) return -1;
while (1) {
res = prv_output_cbor_definite(stream, buffer + head, buffer_len - head, true, &it);
if (res <= 0)
return -1;
head += res;
if (it == UINT8_MAX) break;
if (it == UINT8_MAX)
break;
fprintf(stream, ": ");
res = prv_output_cbor_definite(stream,
buffer + head,
buffer_len - head,
false,
&it);
if (res <= 0) return -1;
res = prv_output_cbor_definite(stream, buffer + head, buffer_len - head, false, &it);
if (res <= 0)
return -1;
head += res;
fprintf(stream, ", ");
}
fprintf(stream, "}");
break;
case CBOR_AI_INDEFINITE_OR_BREAK:
if (!breakable) return -1;
if (!breakable)
return -1;
*mt = UINT8_MAX;
break;
default:
@ -679,26 +615,17 @@ static int prv_output_cbor_indefinite(FILE * stream,
}
#endif
void output_cbor(FILE * stream,
uint8_t * buffer,
size_t buffer_len,
int indent)
{
void output_cbor(FILE *stream, uint8_t *buffer, size_t buffer_len, int indent) {
#ifdef LWM2M_SUPPORT_SENML_CBOR
size_t head = 0;
int res;
uint8_t mt;
print_indent(stream, indent);
while (head < buffer_len)
{
if (head != 0) fprintf(stream, ", ");
res = prv_output_cbor_definite(stream,
buffer + head,
buffer_len - head,
false,
&mt);
if (res <= 0)
{
while (head < buffer_len) {
if (head != 0)
fprintf(stream, ", ");
res = prv_output_cbor_definite(stream, buffer + head, buffer_len - head, false, &mt);
if (res <= 0) {
fprintf(stream, "Error.\r\n");
break;
}

19
include/liblwm2m.h
View File

@ -390,17 +390,16 @@ struct _lwm2m_data_t
} value;
};
typedef enum
{
LWM2M_CONTENT_TEXT = 0, // Also used as undefined
LWM2M_CONTENT_LINK = 40,
LWM2M_CONTENT_OPAQUE = 42,
LWM2M_CONTENT_TLV_OLD = 1542, // Keep old value for backward-compatibility
LWM2M_CONTENT_TLV = 11542,
LWM2M_CONTENT_JSON_OLD = 1543, // Keep old value for backward-compatibility
LWM2M_CONTENT_JSON = 11543,
typedef enum {
LWM2M_CONTENT_TEXT = 0, // Also used as undefined
LWM2M_CONTENT_LINK = 40,
LWM2M_CONTENT_OPAQUE = 42,
LWM2M_CONTENT_TLV_OLD = 1542, // Keep old value for backward-compatibility
LWM2M_CONTENT_TLV = 11542,
LWM2M_CONTENT_JSON_OLD = 1543, // Keep old value for backward-compatibility
LWM2M_CONTENT_JSON = 11543,
LWM2M_CONTENT_SENML_JSON = 110,
LWM2M_CONTENT_CBOR = 60,
LWM2M_CONTENT_CBOR = 60,
LWM2M_CONTENT_SENML_CBOR = 112,
} lwm2m_media_type_t;

785
tests/cbor_tests.c
View File

File diff suppressed because it is too large Load Diff

1199
tests/senml_cbor_tests.c
View File

File diff suppressed because it is too large Load Diff

9
wakaama.cmake
View File

@ -8,10 +8,13 @@ set(WAKAAMA_EXAMPLE_SHARED_DIRECTORY "${WAKAAMA_EXAMPLE_DIRECTORY}/shared")
function(target_sources_data target)
target_sources(
${target}
PRIVATE ${WAKAAMA_TOP_LEVEL_DIRECTORY}/data/data.c ${WAKAAMA_TOP_LEVEL_DIRECTORY}/data/json.c
${WAKAAMA_TOP_LEVEL_DIRECTORY}/data/json_common.c ${WAKAAMA_TOP_LEVEL_DIRECTORY}/data/senml_json.c
PRIVATE ${WAKAAMA_TOP_LEVEL_DIRECTORY}/data/data.c
${WAKAAMA_TOP_LEVEL_DIRECTORY}/data/json.c
${WAKAAMA_TOP_LEVEL_DIRECTORY}/data/json_common.c
${WAKAAMA_TOP_LEVEL_DIRECTORY}/data/senml_json.c
${WAKAAMA_TOP_LEVEL_DIRECTORY}/data/tlv.c
${WAKAAMA_TOP_LEVEL_DIRECTORY}/data/cbor.c ${WAKAAMA_TOP_LEVEL_DIRECTORY}/data/senml_common.c
${WAKAAMA_TOP_LEVEL_DIRECTORY}/data/cbor.c
${WAKAAMA_TOP_LEVEL_DIRECTORY}/data/senml_common.c
${WAKAAMA_TOP_LEVEL_DIRECTORY}/data/senml_cbor.c
)
endfunction()