summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--wrap-json.c210
-rw-r--r--wrap-json.md19
2 files changed, 225 insertions, 4 deletions
diff --git a/wrap-json.c b/wrap-json.c
index d3fb333..e87035e 100644
--- a/wrap-json.c
+++ b/wrap-json.c
@@ -1,5 +1,5 @@
/*
- Copyright (C) 2016, 2017 "IoT.bzh"
+ Copyright (C) 2016, 2017, 2018 "IoT.bzh"
author: José Bollo <jose.bollo@iot.bzh>
@@ -39,15 +39,16 @@ enum {
wrap_json_error_incomplete,
wrap_json_error_missfit_type,
wrap_json_error_key_not_found,
+ wrap_json_error_bad_base64,
_wrap_json_error_count_
};
static const char ignore_all[] = " \t\n\r,:";
-static const char pack_accept_arr[] = "][{snbiIfoO";
+static const char pack_accept_arr[] = "][{snbiIfoOyY";
static const char pack_accept_key[] = "s}";
#define pack_accept_any (&pack_accept_arr[1])
-static const char unpack_accept_arr[] = "*!][{snbiIfFoO";
+static const char unpack_accept_arr[] = "*!][{snbiIfFoOyY";
static const char unpack_accept_key[] = "*!s}";
#define unpack_accept_any (&unpack_accept_arr[3])
@@ -67,7 +68,8 @@ static const char *pack_errors[_wrap_json_error_count_] =
[wrap_json_error_out_of_range] = "array too small",
[wrap_json_error_incomplete] = "incomplete container",
[wrap_json_error_missfit_type] = "missfit of type",
- [wrap_json_error_key_not_found] = "key not found"
+ [wrap_json_error_key_not_found] = "key not found",
+ [wrap_json_error_bad_base64] = "bad base64 encoding"
};
int wrap_json_get_error_position(int rc)
@@ -92,7 +94,160 @@ const char *wrap_json_get_error_string(int rc)
return pack_errors[rc];
}
+static int encode_base64(
+ const uint8_t *data,
+ size_t datalen,
+ char **encoded,
+ size_t *encodedlen,
+ int width,
+ int pad,
+ int url)
+{
+ uint16_t u16;
+ uint8_t u8;
+ size_t in, out, rlen, n3, r3, iout, nout;
+ int iw;
+ char *result, c;
+
+ /* compute unformatted output length */
+ n3 = datalen / 3;
+ r3 = datalen % 3;
+ nout = 4 * n3 + r3 + !!r3;
+
+ /* deduce formatted output length */
+ rlen = nout;
+ if (pad)
+ rlen += ((~rlen) + 1) & 3;
+ if (width)
+ rlen += rlen / width;
+
+ /* allocate the output */
+ result = malloc(rlen + 1);
+ if (result == NULL)
+ return wrap_json_error_out_of_memory;
+
+ /* compute the formatted output */
+ iw = width;
+ for (in = out = iout = 0 ; iout < nout ; iout++) {
+ /* get in 'u8' the 6 bits value to add */
+ switch (iout & 3) {
+ case 0:
+ u16 = (uint16_t)data[in++];
+ u8 = (uint8_t)(u16 >> 2);
+ break;
+ case 1:
+ u16 = (uint16_t)(u16 << 8);
+ if (in < datalen)
+ u16 = (uint16_t)(u16 | data[in++]);
+ u8 = (uint8_t)(u16 >> 4);
+ break;
+ case 2:
+ u16 = (uint16_t)(u16 << 8);
+ if (in < datalen)
+ u16 = (uint16_t)(u16 | data[in++]);
+ u8 = (uint8_t)(u16 >> 6);
+ break;
+ case 3:
+ u8 = (uint8_t)u16;
+ break;
+ }
+ u8 &= 63;
+
+ /* encode 'u8' to the char 'c' */
+ if (u8 < 52) {
+ if (u8 < 26)
+ c = (char)('A' + u8);
+ else
+ c = (char)('a' + u8 - 26);
+ } else {
+ if (u8 < 62)
+ c = (char)('0' + u8 - 52);
+ else if (u8 == 62)
+ c = url ? '-' : '+';
+ else
+ c = url ? '_' : '/';
+ }
+
+ /* put to output with format */
+ result[out++] = c;
+ if (iw && !--iw) {
+ result[out++] = '\n';
+ iw = width;
+ }
+ }
+
+ /* pad the output */
+ while (out < rlen) {
+ result[out++] = '=';
+ if (iw && !--iw) {
+ result[out++] = '\n';
+ iw = width;
+ }
+ }
+
+ /* terminate */
+ result[out] = 0;
+ *encoded = result;
+ *encodedlen = rlen;
+ return 0;
+}
+
+static int decode_base64(
+ const char *data,
+ size_t datalen,
+ uint8_t **decoded,
+ size_t *decodedlen,
+ int url)
+{
+ uint16_t u16;
+ uint8_t u8, *result;
+ size_t in, out, iin;
+ char c;
+ /* allocate enougth output */
+ result = malloc(datalen);
+ if (result == NULL)
+ return wrap_json_error_out_of_memory;
+
+ /* decode the input */
+ for (iin = in = out = 0 ; in < datalen ; in++) {
+ c = data[in];
+ if (c != '\n' && c != '\r' && c != '=') {
+ if ('A' <= c && c <= 'Z')
+ u8 = (uint8_t)(c - 'A');
+ else if ('a' <= c && c <= 'z')
+ u8 = (uint8_t)(c - 'a' + 26);
+ else if ('0' <= c && c <= '9')
+ u8 = (uint8_t)(c - '0' + 52);
+ else if (c == '+' || c == '-')
+ u8 = (uint8_t)62;
+ else if (c == '/' || c == '_')
+ u8 = (uint8_t)63;
+ else {
+ free(result);
+ return wrap_json_error_bad_base64;
+ }
+ if (!iin) {
+ u16 = (uint16_t)u8;
+ iin = 6;
+ } else {
+ u16 = (uint16_t)((u16 << 6) | u8);
+ iin -= 2;
+ u8 = (uint8_t)(u16 >> iin);
+ result[out++] = u8;
+ }
+ }
+ }
+
+ /* terminate */
+ *decoded = realloc(result, out);
+ if (*decoded == NULL) {
+ free(result);
+ return wrap_json_error_out_of_memory;
+ }
+ *decodedlen = out;
+ return 0;
+}
static inline const char *skip(const char *d)
{
@@ -110,6 +265,7 @@ int wrap_json_vpack(struct json_object **result, const char *desc, va_list args)
char c;
const char *d;
char buffer[256];
+ struct { const uint8_t *in; size_t insz; char *out; size_t outsz; } bytes;
struct { const char *str; size_t sz; } strs[STRCOUNT];
struct { struct json_object *cont, *key; const char *acc; char type; } stack[STACKCOUNT], *top;
struct json_object *obj;
@@ -218,6 +374,19 @@ int wrap_json_vpack(struct json_object **result, const char *desc, va_list args)
if (c == 'O')
json_object_get(obj);
break;
+ case 'y':
+ case 'Y':
+ bytes.in = va_arg(args, const uint8_t*);
+ bytes.insz = va_arg(args, size_t);
+ rc = encode_base64(bytes.in, bytes.insz,
+ &bytes.out, &bytes.outsz, 0, 0, c == 'y');
+ if (rc)
+ goto error;
+ obj = json_object_new_string_len(bytes.out, (int)bytes.outsz);
+ free(bytes.out);
+ if (!obj)
+ goto out_of_memory;
+ break;
case '[':
case '{':
if (++top >= &stack[STACKCOUNT])
@@ -347,6 +516,7 @@ static int vunpack(struct json_object *object, const char *desc, va_list args, i
int *pi = NULL;
int64_t *pI = NULL;
size_t *pz = NULL;
+ uint8_t **py = NULL;
struct { struct json_object *parent; const char *acc; int index; size_t count; char type; } stack[STACKCOUNT], *top;
struct json_object *obj;
struct json_object **po;
@@ -477,6 +647,25 @@ static int vunpack(struct json_object *object, const char *desc, va_list args, i
}
}
break;
+ case 'y':
+ case 'Y':
+ if (store) {
+ py = va_arg(args, uint8_t **);
+ pz = va_arg(args, size_t *);
+ }
+ if (!ignore) {
+ if (!json_object_is_type(obj, json_type_string))
+ goto missfit;
+ if (store && py && pz) {
+ rc = decode_base64(
+ json_object_get_string(obj),
+ (size_t)json_object_get_string_len(obj),
+ py, pz, c == 'y');
+ if (rc)
+ goto error;
+ }
+ }
+ break;
case '[':
case '{':
@@ -731,6 +920,7 @@ int64_t *xI[10];
double *xf[10];
struct json_object *xo[10];
size_t xz[10];
+uint8_t *xy[10];
void u(const char *value, const char *desc, ...)
{
@@ -772,6 +962,14 @@ void u(const char *value, const char *desc, ...)
case 'F': printf(" F:%f", *va_arg(args, double*)); k = m&1; break;
case 'o': printf(" o:%s", json_object_to_json_string(*va_arg(args, struct json_object**))); k = m&1; break;
case 'O': o = *va_arg(args, struct json_object**); printf(" O:%s", json_object_to_json_string(o)); json_object_put(o); k = m&1; break;
+ case 'y':
+ case 'Y': {
+ uint8_t *p = *va_arg(args, uint8_t**);
+ size_t s = *va_arg(args, size_t*);
+ printf(" y/%d:%.*s", (int)s, (int)s, (char*)p);
+ k ^= m&1;
+ break;
+ }
default: break;
}
desc++;
@@ -839,6 +1037,8 @@ int main()
P("{ {}: s }", "foo");
P("{ s: {}, s:[ii{} }", "foo", "bar", 12, 13);
P("[[[[[ [[[[[ [[[[ }]]]] ]]]] ]]]]]");
+ P("y", "???????hello>>>>>>>", (size_t)19);
+ P("Y", "???????hello>>>>>>>", (size_t)19);
U("true", "b", &xi[0]);
U("false", "b", &xi[0]);
@@ -915,6 +1115,8 @@ int main()
U("{}", "{s?{s?i}}", "foo", "bar", &xi[0]);
U("{\"foo\":42,\"baz\":45}", "{s?isi!}", "baz", &xi[0], "foo", &xi[1]);
U("{\"foo\":42}", "{s?isi!}", "baz", &xi[0], "foo", &xi[1]);
+
+ U("\"Pz8_Pz8_P2hlbGxvPj4-Pj4-Pg\"", "y", &xy[0], &xz[0]);
return 0;
}
diff --git a/wrap-json.md b/wrap-json.md
index 131b7aa..a86d2a5 100644
--- a/wrap-json.md
+++ b/wrap-json.md
@@ -66,6 +66,15 @@ arguments.
: Like `+#` but the length argument is of type size\_t.
+`y` (byte array) \[const uint8_t \*, size\_t\]
+
+: Convert the byte array whose length is given to
+ its base64url string representation.
+
+`Y` (byte array) \[const uint8_t \*, size\_t\]
+
+: Like 'y' but output is base64.
+
`n` (null)
: Output a JSON null value. No argument is consumed.
@@ -183,6 +192,16 @@ type whose address should be passed.
: Convert a JSON string to a pointer to a null terminated UTF-8 string
and its length.
+`y` (byte array) \[uint8_t \*\*, size\_t \*\]
+
+: Convert an input string base64url encoded to its
+ byte array representation. The result and its length
+ are stored. The returned buffer must be freed by the caller.
+
+`Y` (byte array) \[uint8_t \*\*, size\_t \*\]
+
+: Like 'y' but input is base64.
+
`n` (null)
: Expect a JSON null value. Nothing is extracted.