forked from dukelec/msgpackel
-
Notifications
You must be signed in to change notification settings - Fork 0
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
0 parents
commit 16663a5
Showing
5 changed files
with
492 additions
and
0 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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. |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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 | ||
|
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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 | ||
|
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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; | ||
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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 |