static void test_JSON(char * testBuf,
size_t testLen,
char * id)
{
lwm2m_data_t * tlvP;
int size;
int length;
uint8_t * buffer;
lwm2m_media_type_t format = LWM2M_CONTENT_JSON;
size = lwm2m_data_parse((uint8_t *)testBuf, testLen, format, &tlvP);
if (size <= 0)
{
printf("\n\nJSON buffer %s decoding failed !\n", id);
return;
}
else
printf("\n\nJSON buffer %s decoding:\n", id);
dump_tlv(stdout, size, tlvP, 0);
length = lwm2m_data_serialize(size, tlvP, &format, &buffer);
dump_json(buffer, length);
lwm2m_data_free(size, tlvP);
lwm2m_free(buffer);
}
static void prv_instance_dump(lwm2m_object_t * objectP,
uint16_t id)
{
int numData;
lwm2m_tlv_t * dataArray;
int size;
uint8_t * buffer;
int i;
uint16_t res;
numData = 0;
res = objectP->readFunc(id, &numData, &dataArray, objectP);
if (res != COAP_205_CONTENT)
{
printf("Error ");
print_status(stdout, res);
printf("\r\n");
return;
}
dump_tlv(stdout, numData, dataArray, 0);
size = lwm2m_tlv_serialize(numData, dataArray, &buffer);
printf("char objectTlv[%d] = {", size);
for (i = 0 ; i < size ; i++)
{
printf("0x%02X, ", buffer[i]);
}
printf("\b\b};\r\n");
lwm2m_tlv_free(numData, dataArray);
lwm2m_free(buffer);
}
void dump_tlv(int size,
lwm2m_tlv_t * tlvP,
int indent)
{
int i;
for(i= 0 ; i < size ; i++)
{
print_indent(indent);
printf("type: ");
switch (tlvP[i].type)
{
case LWM2M_TYPE_OBJECT_INSTANCE:
printf("LWM2M_TYPE_OBJECT_INSTANCE\r\n");
break;
case LWM2M_TYPE_RESOURCE_INSTANCE:
printf("LWM2M_TYPE_RESOURCE_INSTANCE\r\n");
break;
case LWM2M_TYPE_MULTIPLE_RESOURCE:
printf("LWM2M_TYPE_MULTIPLE_RESOURCE\r\n");
break;
case LWM2M_TYPE_RESOURCE:
printf("LWM2M_TYPE_RESOURCE\r\n");
break;
default:
printf("unknown (%d)\r\n", (int)tlvP[i].type);
break;
}
print_indent(indent);
printf("id: %d\r\n", tlvP[i].id);
print_indent(indent);
printf("data (%d bytes): ", tlvP[i].length);
prv_output_buffer(tlvP[i].value, tlvP[i].length);
if (tlvP[i].type == LWM2M_TYPE_OBJECT_INSTANCE
|| tlvP[i].type == LWM2M_TYPE_MULTIPLE_RESOURCE)
{
dump_tlv(tlvP[i].length, (lwm2m_tlv_t *)(tlvP[i].value), indent+1);
}
else if (tlvP[i].length <= 8)
{
int64_t value;
if (0 != lwm2m_opaqueToInt(tlvP[i].value, tlvP[i].length, &value))
{
print_indent(indent);
printf(" as int: %ld\r\n", value);
}
}
}
}
static void prv_instance_dump(lwm2m_object_t *objectP, uint16_t id)
{
int numData;
lwm2m_data_t *dataArray;
uint16_t res;
numData = 0;
res = objectP->readFunc(id, &numData, &dataArray, objectP);
if (res != COAP_205_CONTENT) {
printf("Error ");
print_status(stdout, res);
printf("\r\n");
return;
}
dump_tlv(stdout, numData, dataArray, 0);
}
static void test_TLV(char * testBuf,
size_t testLen,
char * id)
{
lwm2m_data_t * tlvP;
int size;
int length;
uint8_t * buffer;
lwm2m_media_type_t format = LWM2M_CONTENT_TLV;
printf("Buffer %s:\n", id);
decode(testBuf, testLen, 0);
printf("\n\nBuffer %s using lwm2m_data_t:\n", id);
size = lwm2m_data_parse((uint8_t *)testBuf, testLen, format, &tlvP);
dump_tlv(stdout, size, tlvP, 0);
length = lwm2m_data_serialize(size, tlvP, &format, &buffer);
if (length != testLen)
{
printf("\n\nSerialize Buffer %s to TLV failed: %d bytes instead of %d\n", id, length, testLen);
}
else if (memcmp(buffer, testBuf, length) != 0)
{
printf("\n\nSerialize Buffer %s to TLV failed:\n", id);
output_buffer(stdout, buffer, length, 0);
printf("\ninstead of:\n");
output_buffer(stdout, testBuf, length, 0);
}
else
{
printf("\n\nSerialize Buffer %s to TLV OK\n", id);
}
lwm2m_free(buffer);
format = LWM2M_CONTENT_JSON;
length = lwm2m_data_serialize(size, tlvP, &format, &buffer);
if (length <= 0)
{
printf("\n\nSerialize Buffer %s to JSON failed.\n", id);
}
else
{
dump_json(buffer, length);
lwm2m_free(buffer);
}
lwm2m_data_free(size, tlvP);
}
/* A big function to dump the ptp information */
static void dump_payload(char *prefix, void *pl, int len)
{
struct ptp_header *h = pl;
void *msg_specific = (void *)(h + 1);
int donelen = 34; /* packet length before tlv */
int version = h->versionPTP_and_reserved & 0xf;
int messageType = h->type_and_transport_specific & 0xf;
if (version != 2) {
printf("%sVERSION: unsupported (%i)\n", prefix, version);
return;
}
printf("%sVERSION: %i (type %i, len %i, domain %i)\n", prefix,
version, messageType,
ntohs(h->messageLength), h->domainNumber);
printf("%sFLAGS: 0x%04x (correction %08lu)\n", prefix, h->flagField,
(unsigned long)h->correctionField);
dump_1port(prefix, "PORT: ", h->sourcePortIdentity);
printf("%sREST: seq %i, ctrl %i, log-interval %i\n", prefix,
ntohs(h->sequenceId), h->controlField, h->logMessageInterval);
#define CASE(t, x) case PPM_ ##x: printf("%sMESSAGE: (" #t ") " #x "\n", prefix)
switch(messageType) {
CASE(E, SYNC);
dump_msg_sync_etc(prefix, "MSG-SYNC: ", msg_specific);
donelen = 44;
break;
CASE(E, DELAY_REQ);
dump_msg_sync_etc(prefix, "MSG-DELAY_REQ: ", msg_specific);
donelen = 44;
break;
CASE(G, FOLLOW_UP);
dump_msg_sync_etc(prefix, "MSG-FOLLOW_UP: ", msg_specific);
donelen = 44;
break;
CASE(G, DELAY_RESP);
dump_msg_resp_etc(prefix, "MSG-DELAY_RESP: ", msg_specific);
donelen = 54;
break;
CASE(G, ANNOUNCE);
dump_msg_announce(prefix, msg_specific);
donelen = 64;
break;
CASE(G, SIGNALING);
dump_1port(prefix, "MSG-SIGNALING: target-port ", msg_specific);
donelen = 44;
break;
#if __STDC_HOSTED__ /* Avoid pdelay dump withing ppsi, we don't use it */
CASE(E, PDELAY_REQ);
dump_msg_sync_etc(prefix, "MSG-PDELAY_REQ: ", msg_specific);
donelen = 54;
break;
CASE(E, PDELAY_RESP);
dump_msg_resp_etc(prefix, "MSG-PDELAY_RESP: ", msg_specific);
donelen = 54;
break;
CASE(G, PDELAY_RESP_FOLLOW_UP);
dump_msg_resp_etc(prefix, "MSG-PDELAY_RESP_FOLLOWUP: ",
msg_specific);
donelen = 54;
break;
CASE(G, MANAGEMENT);
/* FIXME */
break;
#endif
}
/*
* Dump any trailing TLV, but ignore a trailing 2-long data hunk.
* The trailing zeroes appear with less-than-minimum Eth messages.
*/
while (donelen < len && len - donelen > 2) {
int n = len - donelen;
if (n < sizeof(struct ptp_tlv)) {
printf("%sTLV: too short (%i - %i = %i)\n", prefix,
len, donelen, n);
break;
}
donelen += dump_tlv(prefix, pl + donelen, n);
}
/* Finally, binary dump of it all */
dumpstruct(prefix, "DUMP: ", "payload", pl, len);
}
void dump_tlv(FILE * stream,
int size,
lwm2m_data_t * dataP,
int indent)
{
int i;
for(i= 0 ; i < size ; i++)
{
print_indent(stream, indent);
fprintf(stream, "{\r\n");
print_indent(stream, indent+1);
fprintf(stream, "id: %d\r\n", dataP[i].id);
print_indent(stream, indent+1);
fprintf(stream, "type: ");
switch (dataP[i].type)
{
case LWM2M_TYPE_OBJECT:
fprintf(stream, "LWM2M_TYPE_OBJECT\r\n");
dump_tlv(stream, dataP[i].value.asChildren.count, dataP[i].value.asChildren.array, indent + 1);
break;
case LWM2M_TYPE_OBJECT_INSTANCE:
fprintf(stream, "LWM2M_TYPE_OBJECT_INSTANCE\r\n");
dump_tlv(stream, dataP[i].value.asChildren.count, dataP[i].value.asChildren.array, indent + 1);
break;
case LWM2M_TYPE_MULTIPLE_RESOURCE:
fprintf(stream, "LWM2M_TYPE_MULTIPLE_RESOURCE\r\n");
dump_tlv(stream, dataP[i].value.asChildren.count, dataP[i].value.asChildren.array, indent + 1);
break;
case LWM2M_TYPE_UNDEFINED:
fprintf(stream, "LWM2M_TYPE_UNDEFINED\r\n");
break;
case LWM2M_TYPE_STRING:
fprintf(stream, "LWM2M_TYPE_STRING\r\n");
print_indent(stream, indent + 1);
fprintf(stream, "\"%.*s\"\r\n", dataP[i].value.asBuffer.length, dataP[i].value.asBuffer.buffer);
break;
case LWM2M_TYPE_OPAQUE:
fprintf(stream, "LWM2M_TYPE_OPAQUE\r\n");
output_buffer(stream, dataP[i].value.asBuffer.buffer, dataP[i].value.asBuffer.length, indent + 1);
break;
case LWM2M_TYPE_INTEGER:
fprintf(stream, "LWM2M_TYPE_INTEGER: ");
print_indent(stream, indent + 1);
fprintf(stream, "%" PRId64, dataP[i].value.asInteger);
fprintf(stream, "\r\n");
break;
case LWM2M_TYPE_FLOAT:
fprintf(stream, "LWM2M_TYPE_FLOAT: ");
print_indent(stream, indent + 1);
fprintf(stream, "%f", dataP[i].value.asInteger);
fprintf(stream, "\r\n");
break;
case LWM2M_TYPE_BOOLEAN:
fprintf(stream, "LWM2M_TYPE_BOOLEAN: ");
fprintf(stream, "%s", dataP[i].value.asBoolean ? "true" : "false");
fprintf(stream, "\r\n");
break;
case LWM2M_TYPE_OBJECT_LINK:
fprintf(stream, "LWM2M_TYPE_OBJECT_LINK\r\n");
break;
default:
fprintf(stream, "unknown (%d)\r\n", (int)dataP[i].type);
break;
}
print_indent(stream, indent);
fprintf(stream, "}\r\n");
}
}
int main(int argc, char *argv[])
{
lwm2m_tlv_t * tlvP;
int size;
int length;
char * buffer;
char buffer1[] = {0x03, 0x0A, 0xC1, 0x01, 0x14, 0x03, 0x0B, 0xC1, 0x01, 0x15, 0x03, 0x0C, 0xC1, 0x01, 0x16};
char buffer2[] = {0xC8, 0x00, 0x14, 0x4F, 0x70, 0x65, 0x6E, 0x20, 0x4D, 0x6F, 0x62, 0x69, 0x6C, 0x65, 0x20,
0x41, 0x6C, 0x6C, 0x69, 0x61, 0x6E, 0x63, 0x65, 0xC8, 0x01, 0x16, 0x4C, 0x69, 0x67, 0x68,
0x74, 0x77 , 0x65, 0x69, 0x67, 0x68, 0x74, 0x20, 0x4D, 0x32, 0x4D, 0x20, 0x43, 0x6C, 0x69,
0x65, 0x6E, 0x74 , 0xC8, 0x02, 0x09, 0x33, 0x34, 0x35, 0x30, 0x30, 0x30, 0x31, 0x32, 0x33,
0xC3, 0x03, 0x31, 0x2E , 0x30, 0x86, 0x06, 0x41, 0x00, 0x01, 0x41, 0x01, 0x05, 0x88, 0x07,
0x08, 0x42, 0x00, 0x0E, 0xD8 , 0x42, 0x01, 0x13, 0x88, 0x87, 0x08, 0x41, 0x00, 0x7D, 0x42,
0x01, 0x03, 0x84, 0xC1, 0x09, 0x64 , 0xC1, 0x0A, 0x0F, 0x83, 0x0B, 0x41, 0x00, 0x00, 0xC4,
0x0D, 0x51, 0x82, 0x42, 0x8F, 0xC6, 0x0E, 0x2B, 0x30, 0x32, 0x3A, 0x30, 0x30, 0xC1, 0x0F, 0x55};
printf("Buffer 1:\n");
decode(buffer1, sizeof(buffer1), 0);
printf("\n\nBuffer 1 using lwm2m_tlv_t:\n");
size = lwm2m_tlv_parse(buffer1, sizeof(buffer1), &tlvP);
dump_tlv(size, tlvP, 0);
length = lwm2m_tlv_serialize(size, tlvP, &buffer);
if (length != sizeof(buffer1))
{
printf("\n\nSerialize Buffer 1 failed: %d bytes instead of %d\n", length, sizeof(buffer1));
}
else if (memcmp(buffer, buffer1, length) != 0)
{
printf("\n\nSerialize Buffer 1 failed:\n");
prv_output_buffer(buffer, length);
printf("\ninstead of:\n");
prv_output_buffer(buffer1, length);
}
else
{
printf("\n\nSerialize Buffer 1 OK\n");
}
lwm2m_tlv_free(size, tlvP);
printf("\n\n============\n\nBuffer 2: \r\r\n");
decode(buffer2, sizeof(buffer2), 0);
printf("\n\nBuffer 2 using lwm2m_tlv_t: \r\r\n");
size = lwm2m_tlv_parse(buffer2, sizeof(buffer2), &tlvP);
dump_tlv(size, tlvP, 0);
length = lwm2m_tlv_serialize(size, tlvP, &buffer);
if (length != sizeof(buffer2))
{
printf("\n\nSerialize Buffer 2 failed: %d bytes instead of %d\n", length, sizeof(buffer2));
}
else if (memcmp(buffer, buffer2, length) != 0)
{
printf("\n\nSerialize Buffer 2 failed:\n");
prv_output_buffer(buffer, length);
printf("\ninstead of:\n");
prv_output_buffer(buffer2, length);
}
else
{
printf("\n\nSerialize Buffer 2 OK\n\n");
}
lwm2m_tlv_free(size, tlvP);
}
void dump_tlv(FILE * stream,
int size,
lwm2m_tlv_t * tlvP,
int indent)
{
int i;
for(i= 0 ; i < size ; i++)
{
print_indent(stream, indent);
fprintf(stream, "{\r\n");
print_indent(stream, indent+1);
fprintf(stream, "id: %d\r\n", tlvP[i].id);
print_indent(stream, indent+1);
fprintf(stream, "type: ");
switch (tlvP[i].type)
{
case LWM2M_TYPE_OBJECT_INSTANCE:
fprintf(stream, "LWM2M_TYPE_OBJECT_INSTANCE\r\n");
break;
case LWM2M_TYPE_RESOURCE_INSTANCE:
fprintf(stream, "LWM2M_TYPE_RESOURCE_INSTANCE\r\n");
break;
case LWM2M_TYPE_MULTIPLE_RESOURCE:
fprintf(stream, "LWM2M_TYPE_MULTIPLE_RESOURCE\r\n");
break;
case LWM2M_TYPE_RESOURCE:
fprintf(stream, "LWM2M_TYPE_RESOURCE\r\n");
break;
default:
fprintf(stream, "unknown (%d)\r\n", (int)tlvP[i].type);
break;
}
print_indent(stream, indent+1);
fprintf(stream, "flags: ");
if (tlvP[i].flags & LWM2M_TLV_FLAG_STATIC_DATA)
{
fprintf(stream, "STATIC_DATA");
if (tlvP[i].flags & LWM2M_TLV_FLAG_TEXT_FORMAT)
{
fprintf(stream, " | TEXT_FORMAT");
}
}
else if (tlvP[i].flags & LWM2M_TLV_FLAG_TEXT_FORMAT)
{
fprintf(stream, "TEXT_FORMAT");
}
fprintf(stream, "\r\n");
print_indent(stream, indent+1);
fprintf(stream, "data length: %d\r\n", (int) tlvP[i].length);
if (tlvP[i].type == LWM2M_TYPE_OBJECT_INSTANCE
|| tlvP[i].type == LWM2M_TYPE_MULTIPLE_RESOURCE)
{
dump_tlv(stream, tlvP[i].length, (lwm2m_tlv_t *)(tlvP[i].value), indent+1);
}
else
{
print_indent(stream, indent+1);
fprintf(stream, "data type: ");
switch (tlvP[i].dataType)
{
case LWM2M_TYPE_INTEGER:
fprintf(stream, "Integer");
if ((tlvP[i].flags & LWM2M_TLV_FLAG_TEXT_FORMAT) == 0)
{
int64_t value;
if (1 == lwm2m_tlv_decode_int(tlvP + i, &value))
{
fprintf(stream, " (%" PRId64 ")", value);
}
}
break;
case LWM2M_TYPE_STRING:
fprintf(stream, "String");
break;
case LWM2M_TYPE_FLOAT:
fprintf(stream, "Float");
break;
case LWM2M_TYPE_BOOLEAN:
fprintf(stream, "Boolean");
if ((tlvP[i].flags & LWM2M_TLV_FLAG_TEXT_FORMAT) == 0)
{
bool value;
if (1 == lwm2m_tlv_decode_bool(tlvP + i, &value))
{
fprintf(stream, " (%s)", value?"true":"false");
}
}
break;
case LWM2M_TYPE_TIME:
fprintf(stream, "Time");
break;
case LWM2M_TYPE_OBJECT_LINK:
fprintf(stream, "Object Link");
break;
case LWM2M_TYPE_OPAQUE:
fprintf(stream, "Opaque");
break;
case LWM2M_TYPE_UNDEFINED:
fprintf(stream, "Undefined");
break;
}
fprintf(stream, "\r\n");
output_buffer(stream, tlvP[i].value, tlvP[i].length, indent+1);
}
print_indent(stream, indent);
fprintf(stream, "}\r\n");
}
}
