Skip to content

Commit

Permalink
init
Browse files Browse the repository at this point in the history
dukelec committed Oct 25, 2021
0 parents commit 16663a5
Showing 5 changed files with 492 additions and 0 deletions.
21 changes: 21 additions & 0 deletions License
Original file line number Diff line number Diff line change
@@ -0,0 +1,21 @@
MIT License

Copyright (c) 2021 DUKELEC

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
19 changes: 19 additions & 0 deletions Readme.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,19 @@
MessagePackEL
====================================

This is the little-endian version of MessagePack, except the endianness is different,
the rest is exactly the same as MessagePack.



C library: [msgpackel-c](msgpackel-c)


MIME type for original msgpack: `application/msgpack`
MIME type for msgpackel: `application/msgpackel`

By convention, `el` is the initials of "little-endian" read in little-endian order.


Why create the little-endian version: https://github.com/msgpack/msgpack/issues/313

96 changes: 96 additions & 0 deletions msgpackel-c/Readme.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,96 @@
Little-endian version of the msgpack C library
==============================================

This library does not require malloc.

### Usage

Data structure demo:
```
{
"dev": "abc123",
"data": {
"voltage": 3.6,
"angle": [45, 90]
}
}
```

Serialization:

```
uint8_t msg_buf[256];
size_t prepare_data(void)
{
uint8_t *pos = msg_buf;
pos = mpk_w_map_hdr(pos, 2); // create top map
pos = mpk_w_str(pos, "dev"); // create first item
pos = mpk_w_str(pos, "abc123");
pos = mpk_w_str(pos, "data"); // create second item
pos = mpk_w_map_hdr(pos, 2); // create sub map
pos = mpk_w_str(pos, "voltage");
pos = mpk_w_float(pos, 3.6f);
pos = mpk_w_str(pos, "angle");
pos = mpk_w_array_hdr(pos, 2);
pos = mpk_w_int(pos, 45);
pos = mpk_w_int(pos, 90);
return pos - msg_buf; // return length
}
```

Deserialization:

```
void check_data(void)
{
mpk_t st;
uint8_t *payload, *end;
size_t num;
float voltage;
st = mpk_map_search(msg_buf, NULL, NULL, (uint8_t *)&voltage, NULL,
"data", "voltage", NULL); // must end with NULL
if (st == MPK_FLOAT)
printf("found data.voltage: %f\n", voltage);
else
printf("parse data.voltage error: %d\n", st);
st = mpk_map_search(msg_buf, &payload, &end, NULL, NULL,
"dev", NULL);
if (st == MPK_STR) {
int str_len = end - payload;
printf("found dev: %.*s\n", str_len, payload); // print non-null terminated string
} else {
printf("parse dev error: %d\n", st);
}
st = mpk_map_search(msg_buf, &payload, NULL, NULL, &num,
"data", "angle", NULL);
if (st == MPK_ARRAY) {
uint8_t *pos = payload;
printf("data.angle[] length: %d\n", num);
for (int i = 0; i < num; i++) {
int32_t val; // val must be at least 4 bytes
st = mpk_parse(pos, NULL, &end, (uint8_t *)&val, NULL);
if (st != MPK_INT && st != MPK_UINT) {
printf(" parse data.angle error\n");
break;
}
printf(" data.angle[%d]: %ld\n", i, val);
pos = end;
}
} else {
printf("parse data.angle error: %d\n", st);
}
}
```

The header file `cd_utils.h` please refer to: https://github.com/dukelec/cdnet/blob/master/utils/cd_utils.h

314 changes: 314 additions & 0 deletions msgpackel-c/msgpackel.c
Original file line number Diff line number Diff line change
@@ -0,0 +1,314 @@
/*
* Software License Agreement (MIT License)
*
* Copyright (c) 2021, DUKELEC, Inc.
* All rights reserved.
*
* Author: Duke Fong <d@d-l.io>
*/

#include "msgpackel.h"


uint8_t *mpk_w_int(uint8_t *buf, int32_t val)
{
if (val >= -32 && val <= 127) { // fix-int
*(int8_t *)buf = val;
return buf + 1;
}
if (val >= -128 && val <= 127) { // int8
*buf = 0xd0;
*(int8_t *)(buf + 1) = val;
return buf + 1 + 1;
}
if (val >= -32768 && val <= 32767) { // int16
*buf = 0xd1;
put_unaligned16(val, buf + 1);
return buf + 1 + 2;
}
if (val >= INT32_MIN && val <= INT32_MAX) { // int32
*buf = 0xd2;
put_unaligned32(val, buf + 1);
return buf + 1 + 4;
}
return NULL;
}

uint8_t *mpk_w_uint(uint8_t *buf, uint32_t val)
{
if (val <= 255) { // uint8
*buf = 0xcc;
*(buf + 1) = val;
return buf + 1 + 1;
}
if (val <= 65535) { // uint16
*buf = 0xcd;
put_unaligned16(val, buf + 1);
return buf + 1 + 2;
}
if (val <= UINT32_MAX) { // uint32
*buf = 0xce;
put_unaligned32(val, buf + 1);
return buf + 1 + 4;
}
return NULL;
}

uint8_t *mpk_w_nil(uint8_t *buf)
{
*buf = 0xc0;
return buf + 1;
}

uint8_t *mpk_w_bool(uint8_t *buf, bool val)
{
*buf = val ? 0xc3 : 0xc2;
return buf + 1;
}

uint8_t *mpk_w_float(uint8_t *buf, float val)
{
*buf = 0xca;
memcpy(buf + 1, &val, 4);
return buf + 1 + 4;
}

uint8_t *mpk_w_str(uint8_t *buf, char *str)
{
size_t len = strlen(str);
if (len <= 31) {
*buf = 0xa0 | len; // fix-str
memcpy(buf + 1, str, len);
return buf + 1 + len;
}
if (len <= 255) {
*buf = 0xd9; // str8
*(buf + 1) = len;
memcpy(buf + 1 + 1, str, len);
return buf + 1 + 1 + len;
}
if (len <= 65535) {
*buf = 0xda; // str16
put_unaligned16(len, buf + 1);
memcpy(buf + 1 + 2, str, len);
return buf + 1 + 2 + len;
}
return NULL;
}

uint8_t *mpk_w_bin(uint8_t *buf, uint8_t *dat, size_t len)
{
if (len <= 255) {
*buf = 0xc4; // bin8
*(buf + 1) = len;
memcpy(buf + 1 + 1, dat, len);
return buf + 1 + 1 + len;
}
if (len <= 65535) {
*buf = 0xc5; // bin16
put_unaligned16(len, buf + 1);
memcpy(buf + 1 + 2, dat, len);
return buf + 1 + 2 + len;
}

*buf = 0xc6; // bin32
put_unaligned32(len, buf + 1);
memcpy(buf + 1 + 4, dat, len);
return buf + 1 + 4 + len;
}

uint8_t *mpk_w_array_hdr(uint8_t *buf, size_t num)
{
if (num <= 15) {
*buf = 0x90 | num; // fix-array
return buf + 1;
}

if (num <= 65535) {
*buf = 0xdc; // array16
put_unaligned16(num, buf + 1);
return buf + 1 + 2;
}

return NULL;
}

uint8_t *mpk_w_map_hdr(uint8_t *buf, size_t num)
{
if (num <= 15) {
*buf = 0x80 | num; // fix-map
return buf + 1;
}

if (num <= 65535) {
*buf = 0xde; // map16
put_unaligned16(num, buf + 1);
return buf + 1 + 2;
}

return NULL;
}


mpk_t mpk_parse(uint8_t *buf, uint8_t **payload, uint8_t **end, uint8_t *val, size_t *num)
{
mpk_t type = MPK_ERR;
uint8_t *_payload = buf + 1;
uint8_t *_end = buf + 1;
uint8_t _val[4] = {0};
size_t _num = 0;

if (*buf <= 0x7f || *buf >= 0xe0) { // fix-int
_payload = buf;
*(int32_t *)_val = *(int8_t *)buf;
type = MPK_INT;
} else if (*buf == 0xd0) { // int8
_end = buf + 1 + 1;
*(int32_t *)_val = *(int8_t *)(buf + 1);
type = MPK_INT;
} else if (*buf == 0xd1) { // int16
_end = buf + 1 + 2;
*(int32_t *)_val = (int16_t)get_unaligned16(buf + 1);
type = MPK_INT;
} else if (*buf == 0xd2) { // int32
_end = buf + 1 + 4;
*(int32_t *)_val = get_unaligned32(buf + 1);
type = MPK_INT;

} else if (*buf == 0xcc) { // uint8
_end = buf + 1 + 1;
*(uint32_t *)_val = *(buf + 1);
type = MPK_UINT;
} else if (*buf == 0xcd) { // uint16
_end = buf + 1 + 2;
*(uint32_t *)_val = get_unaligned16(buf + 1);
type = MPK_UINT;
} else if (*buf == 0xce) { // uint32
_end = buf + 1 + 4;
*(uint32_t *)_val = get_unaligned32(buf + 1);
type = MPK_UINT;

} else if (*buf == 0xc0) { // nil
_payload = buf;
type = MPK_NIL;
} else if (*buf == 0xc2 || *buf == 0xc3) { // bool
_payload = buf;
*(uint32_t *)_val = *_payload & 1;
type = MPK_BOOL;

} else if (*buf == 0xca) { // float
_end = buf + 1 + 4;
memcpy(_val, buf + 1, 4);
type = MPK_FLOAT;

} else if ((*buf & 0xe0) == 0xa0) { // fix-str
_end = buf + 1 + (*buf & 0x1f);
type = MPK_STR;
} else if (*buf == 0xd9) { // str8
_payload = buf + 1 + 1;
_end = _payload + *(buf + 1);
type = MPK_STR;
} else if (*buf == 0xda) { // str16
_payload = buf + 1 + 2;
_end = _payload + get_unaligned16(buf + 1);
type = MPK_STR;

} else if (*buf == 0xc4) { // bin8
_payload = buf + 1 + 1;
_end = _payload + *(buf + 1);
type = MPK_BIN;
} else if (*buf == 0xc5) { // bin16
_payload = buf + 1 + 2;
_end = _payload + get_unaligned16(buf + 1);
type = MPK_BIN;
} else if (*buf == 0xc6) { // bin32
_payload = buf + 1 + 4;
_end = _payload + get_unaligned32(buf + 1);
type = MPK_BIN;

} else if ((*buf & 0xf0) == 0x90 || *buf == 0xdc) { // fix-arr, arr16
if (*buf != 0xdc) {
_num = *buf & 0xf;
} else {
_num = get_unaligned16(buf + 1);
_payload = buf + 1 + 2;
}
uint8_t *sub_buf = _payload, *sub_end = _payload;
for (int i = 0; i < _num; i++) {
if (mpk_parse(sub_buf, NULL, &sub_end, NULL, NULL) == MPK_ERR)
return MPK_ERR;
sub_buf = sub_end;
}
_end = sub_end;
type = MPK_ARRAY;
}

else if ((*buf & 0xf0) == 0x80 || *buf == 0xde) { // fix-map, map16
if (*buf != 0xde) {
_num = *buf & 0xf;
} else {
_num = get_unaligned16(buf + 1);
_payload = buf + 1 + 2;
}
uint8_t *sub_buf = _payload, *sub_end = _payload;
for (int i = 0; i < _num * 2; i++) {
if (mpk_parse(sub_buf, NULL, &sub_end, NULL, NULL) == MPK_ERR)
return MPK_ERR;
sub_buf = sub_end;
}
_end = sub_end;
type = MPK_MAP;
}

if (payload) *payload = _payload;
if (end) *end = _end;
if (val) memcpy(val, _val, 4);
if (num) *num = _num;
return type;
}

mpk_t mpk_map_search(uint8_t *buf, uint8_t **payload, uint8_t **end, uint8_t *val, size_t *num, ...)
{
va_list va;
char *key;
uint8_t *map_payload;
size_t map_num = 0;
mpk_t ret = MPK_ERR;
uint8_t *sub_payload;
uint8_t *sub_end;
bool is_found = false;

va_start(va, num);
while ((key = va_arg(va, char *))) {
ret = mpk_parse(buf, &map_payload, NULL, NULL, &map_num);
if (ret != MPK_MAP)
return MPK_ERR;

is_found = false;
buf = map_payload;
for (int i = 0; i < map_num; i++) {
// compare key
ret = mpk_parse(buf, &sub_payload, &sub_end, NULL, NULL);
if (ret == MPK_ERR)
return MPK_ERR;
if (ret == MPK_STR && strlen(key) == sub_end - sub_payload
&& memcmp(key, sub_payload, sub_end - sub_payload) == 0) {
is_found = true;
buf = sub_end;
break; // found
}
// skip value
buf = sub_end;
ret = mpk_parse(buf, NULL, &sub_end, NULL, NULL);
if (ret == MPK_ERR)
return MPK_ERR;
buf = sub_end;
}
}
va_end(va);

if (is_found)
return mpk_parse(buf, payload, end, val, num);
else
return MPK_ERR;
}
42 changes: 42 additions & 0 deletions msgpackel-c/msgpackel.h
Original file line number Diff line number Diff line change
@@ -0,0 +1,42 @@
/*
* Software License Agreement (MIT License)
*
* Copyright (c) 2021, DUKELEC, Inc.
* All rights reserved.
*
* Author: Duke Fong <d@d-l.io>
*/

#ifndef __MSGPACKEL_H__
#define __MSGPACKEL_H__

#include "cd_utils.h"

uint8_t *mpk_w_int(uint8_t *buf, int32_t val);
uint8_t *mpk_w_uint(uint8_t *buf, uint32_t val);
uint8_t *mpk_w_nil(uint8_t *buf);
uint8_t *mpk_w_bool(uint8_t *buf, bool val);
uint8_t *mpk_w_float(uint8_t *buf, float val);
uint8_t *mpk_w_str(uint8_t *buf, char *str);
uint8_t *mpk_w_bin(uint8_t *buf, uint8_t *dat, size_t len);
uint8_t *mpk_w_array_hdr(uint8_t *buf, size_t num);
uint8_t *mpk_w_map_hdr(uint8_t *buf, size_t num);


typedef enum {
MPK_ERR,
MPK_INT,
MPK_UINT,
MPK_NIL,
MPK_BOOL,
MPK_FLOAT,
MPK_STR,
MPK_BIN,
MPK_ARRAY,
MPK_MAP
} mpk_t;

mpk_t mpk_parse(uint8_t *buf, uint8_t **payload, uint8_t **end, uint8_t *val, size_t *num);
mpk_t mpk_map_search(uint8_t *buf, uint8_t **payload, uint8_t **end, uint8_t *val, size_t *num, ...);

#endif

0 comments on commit 16663a5

Please sign in to comment.