mirror
/
transmission
mirror of https://github.com/transmission/transmission
1
0
Fork 0
Code Issues Releases Wiki Activity
transmission/libtransmission/variant-json.cc

721 lines
18 KiB
C++
Raw Blame History

/*
* This file Copyright (C) 2008-2014 Mnemosyne LLC
*
* It may be used under the GNU GPL versions 2 or 3
* or any future license endorsed by Mnemosyne LLC.
*
*/
#include <ctype.h>
#include <math.h> /* fabs() */
#include <stdio.h>
#include <string.h>
#include <errno.h> /* EILSEQ, EINVAL */
#include <event2/buffer.h> /* evbuffer_add() */
#include <event2/util.h> /* evutil_strtoll() */
#define LIBTRANSMISSION_VARIANT_MODULE
#include "transmission.h"
#include "ConvertUTF.h"
#include "jsonsl.h"
#include "list.h"
#include "log.h"
#include "ptrarray.h"
#include "tr-assert.h"
#include "utils.h"
#include "variant.h"
#include "variant-common.h"
/* arbitrary value... this is much deeper than our code goes */
#define MAX_DEPTH 64
struct json_wrapper_data
{
int error;
bool has_content;
tr_variant* top;
char const* key;
size_t keylen;
struct evbuffer* keybuf;
struct evbuffer* strbuf;
char const* source;
tr_ptrArray stack;
/* A very common pattern is for a container's children to be similar,
* e.g. they may all be objects with the same set of keys. So when
* a container is popped off the stack, remember its size to use as
* a preallocation heuristic for the next container at that depth. */
size_t preallocGuess[MAX_DEPTH];
};
static tr_variant* get_node(struct jsonsl_st* jsn)
{
auto* data = static_cast<struct json_wrapper_data*>(jsn->data);
auto* parent = static_cast<tr_variant*>(tr_ptrArrayEmpty(&data->stack) ? nullptr : tr_ptrArrayBack(&data->stack));
tr_variant* node = nullptr;
if (parent == nullptr)
{
node = data->top;
}
else if (tr_variantIsList(parent))
{
node = tr_variantListAdd(parent);
}
else if (tr_variantIsDict(parent) && data->key != nullptr)
{
node = tr_variantDictAdd(parent, tr_quark_new(data->key, data->keylen));
data->key = nullptr;
data->keylen = 0;
}
return node;
}
static void error_handler(jsonsl_t jsn, jsonsl_error_t error, struct jsonsl_state_st* state, jsonsl_char_t const* buf)
{
TR_UNUSED(state);
auto* data = static_cast<struct json_wrapper_data*>(jsn->data);
if (data->source != nullptr)
{
tr_logAddError(
"JSON parse failed in %s at pos %zu: %s -- remaining text \"%.16s\"",
data->source,
jsn->pos,
jsonsl_strerror(error),
buf);
}
else
{
tr_logAddError("JSON parse failed at pos %zu: %s -- remaining text \"%.16s\"", jsn->pos, jsonsl_strerror(error), buf);
}
data->error = EILSEQ;
}
static int error_callback(jsonsl_t jsn, jsonsl_error_t error, struct jsonsl_state_st* state, jsonsl_char_t* at)
{
error_handler(jsn, error, state, at);
return 0; /* bail */
}
static void action_callback_PUSH(jsonsl_t jsn, jsonsl_action_t action, struct jsonsl_state_st* state, jsonsl_char_t const* buf)
{
TR_UNUSED(action);
TR_UNUSED(buf);
tr_variant* node;
auto* data = static_cast<struct json_wrapper_data*>(jsn->data);
if ((state->type == JSONSL_T_LIST) || (state->type == JSONSL_T_OBJECT))
{
data->has_content = true;
node = get_node(jsn);
tr_ptrArrayAppend(&data->stack, node);
int const depth = tr_ptrArraySize(&data->stack);
size_t const n = depth < MAX_DEPTH ? data->preallocGuess[depth] : 0;
if (state->type == JSONSL_T_LIST)
{
tr_variantInitList(node, n);
}
else
{
tr_variantInitDict(node, n);
}
}
}
/* like sscanf(in+2, "%4x", &val) but less slow */
static bool decode_hex_string(char const* in, unsigned int* setme)
{
TR_ASSERT(in != nullptr);
unsigned int val = 0;
char const* const end = in + 6;
TR_ASSERT(in[0] == '\\');
TR_ASSERT(in[1] == 'u');
in += 2;
do
{
val <<= 4;
if ('0' <= *in && *in <= '9')
{
val += *in - '0';
}
else if ('a' <= *in && *in <= 'f')
{
val += *in - 'a' + 10U;
}
else if ('A' <= *in && *in <= 'F')
{
val += *in - 'A' + 10U;
}
else
{
return false;
}
} while (++in != end);
*setme = val;
return true;
}
static char* extract_escaped_string(char const* in, size_t in_len, size_t* len, struct evbuffer* buf)
{
char const* const in_end = in + in_len;
evbuffer_drain(buf, evbuffer_get_length(buf));
while (in < in_end)
{
bool unescaped = false;
if (*in == '\\' && in_end - in >= 2)
{
switch (in[1])
{
case 'b':
evbuffer_add(buf, "\b", 1);
in += 2;
unescaped = true;
break;
case 'f':
evbuffer_add(buf, "\f", 1);
in += 2;
unescaped = true;
break;
case 'n':
evbuffer_add(buf, "\n", 1);
in += 2;
unescaped = true;
break;
case 'r':
evbuffer_add(buf, "\r", 1);
in += 2;
unescaped = true;
break;
case 't':
evbuffer_add(buf, "\t", 1);
in += 2;
unescaped = true;
break;
case '/':
evbuffer_add(buf, "/", 1);
in += 2;
unescaped = true;
break;
case '"':
evbuffer_add(buf, "\"", 1);
in += 2;
unescaped = true;
break;
case '\\':
evbuffer_add(buf, "\\", 1);
in += 2;
unescaped = true;
break;
case 'u':
{
if (in_end - in >= 6)
{
unsigned int val = 0;
if (decode_hex_string(in, &val))
{
UTF32 str32_buf[2] = { val, 0 };
UTF32 const* str32_walk = str32_buf;
UTF32 const* str32_end = str32_buf + 1;
UTF8 str8_buf[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
UTF8* str8_walk = str8_buf;
UTF8* str8_end = str8_buf + 8;
if (ConvertUTF32toUTF8(&str32_walk, str32_end, &str8_walk, str8_end, {}) == 0)
{
evbuffer_add(buf, str8_buf, str8_walk - str8_buf);
unescaped = true;
}
in += 6;
break;
}
}
}
}
}
if (!unescaped)
{
evbuffer_add(buf, in, 1);
++in;
}
}
*len = evbuffer_get_length(buf);
return (char*)evbuffer_pullup(buf, -1);
}
static char const* extract_string(jsonsl_t jsn, struct jsonsl_state_st* state, size_t* len, struct evbuffer* buf)
{
char const* ret;
char const* in_begin;
char const* in_end;
size_t in_len;
/* figure out where the string is */
in_begin = jsn->base + state->pos_begin;
if (*in_begin == '"')
{
in_begin++;
}
in_end = jsn->base + state->pos_cur;
in_len = in_end - in_begin;
if (memchr(in_begin, '\\', in_len) == nullptr)
{
/* it's not escaped */
ret = in_begin;
*len = in_len;
}
else
{
ret = extract_escaped_string(in_begin, in_len, len, buf);
}
return ret;
}
static void action_callback_POP(jsonsl_t jsn, jsonsl_action_t action, struct jsonsl_state_st* state, jsonsl_char_t const* buf)
{
TR_UNUSED(action);
TR_UNUSED(buf);
auto* data = static_cast<struct json_wrapper_data*>(jsn->data);
if (state->type == JSONSL_T_STRING)
{
size_t len;
char const* str = extract_string(jsn, state, &len, data->strbuf);
tr_variantInitStr(get_node(jsn), str, len);
data->has_content = true;
}
else if (state->type == JSONSL_T_HKEY)
{
data->has_content = true;
data->key = extract_string(jsn, state, &data->keylen, data->keybuf);
}
else if (state->type == JSONSL_T_LIST || state->type == JSONSL_T_OBJECT)
{
int const depth = tr_ptrArraySize(&data->stack);
auto* v = static_cast<tr_variant const*>(tr_ptrArrayPop(&data->stack));
if (depth < MAX_DEPTH)
{
data->preallocGuess[depth] = v->val.l.count;
}
}
else if (state->type == JSONSL_T_SPECIAL)
{
if ((state->special_flags & JSONSL_SPECIALf_NUMNOINT) != 0)
{
char const* begin = jsn->base + state->pos_begin;
data->has_content = true;
tr_variantInitReal(get_node(jsn), strtod(begin, nullptr));
}
else if ((state->special_flags & JSONSL_SPECIALf_NUMERIC) != 0)
{
char const* begin = jsn->base + state->pos_begin;
data->has_content = true;
tr_variantInitInt(get_node(jsn), evutil_strtoll(begin, nullptr, 10));
}
else if ((state->special_flags & JSONSL_SPECIALf_BOOLEAN) != 0)
{
bool const b = (state->special_flags & JSONSL_SPECIALf_TRUE) != 0;
data->has_content = true;
tr_variantInitBool(get_node(jsn), b);
}
else if ((state->special_flags & JSONSL_SPECIALf_NULL) != 0)
{
data->has_content = true;
tr_variantInitQuark(get_node(jsn), TR_KEY_NONE);
}
}
}
int tr_jsonParse(char const* source, void const* vbuf, size_t len, tr_variant* setme_variant, char const** setme_end)
{
int error;
jsonsl_t jsn;
struct json_wrapper_data data;
jsn = jsonsl_new(MAX_DEPTH);
jsn->action_callback_PUSH = action_callback_PUSH;
jsn->action_callback_POP = action_callback_POP;
jsn->error_callback = error_callback;
jsn->data = &data;
jsonsl_enable_all_callbacks(jsn);
data.error = 0;
data.has_content = false;
data.key = nullptr;
data.top = setme_variant;
data.stack = {};
data.source = source;
data.keybuf = evbuffer_new();
data.strbuf = evbuffer_new();
for (int i = 0; i < MAX_DEPTH; ++i)
{
data.preallocGuess[i] = 0;
}
/* parse it */
jsonsl_feed(jsn, static_cast<jsonsl_char_t const*>(vbuf), len);
/* EINVAL if there was no content */
if (data.error == 0 && !data.has_content)
{
data.error = EINVAL;
}
/* maybe set the end ptr */
if (setme_end != nullptr)
{
*setme_end = ((char const*)vbuf) + jsn->pos;
}
/* cleanup */
error = data.error;
evbuffer_free(data.keybuf);
evbuffer_free(data.strbuf);
tr_ptrArrayDestruct(&data.stack, nullptr);
jsonsl_destroy(jsn);
return error;
}
/****
*****
****/
struct ParentState
{
int variantType;
int childIndex;
int childCount;
};
struct jsonWalk
{
bool doIndent;
tr_list* parents;
struct evbuffer* out;
};
static void jsonIndent(struct jsonWalk* data)
{
static char buf[1024] = { '\0' };
if (*buf == '\0')
{
memset(buf, ' ', sizeof(buf));
buf[0] = '\n';
}
if (data->doIndent)
{
evbuffer_add(data->out, buf, tr_list_size(data->parents) * 4 + 1);
}
}
static void jsonChildFunc(struct jsonWalk* data)
{
if (data->parents != nullptr && data->parents->data != nullptr)
{
auto* pstate = static_cast<struct ParentState*>(data->parents->data);
switch (pstate->variantType)
{
case TR_VARIANT_TYPE_DICT:
{
int const i = pstate->childIndex;
++pstate->childIndex;
if (i % 2 == 0)
{
evbuffer_add(data->out, ": ", data->doIndent ? 2 : 1);
}
else
{
bool const isLast = pstate->childIndex == pstate->childCount;
if (!isLast)
{
evbuffer_add(data->out, ",", 1);
jsonIndent(data);
}
}
break;
}
case TR_VARIANT_TYPE_LIST:
{
++pstate->childIndex;
bool const isLast = pstate->childIndex == pstate->childCount;
if (!isLast)
{
evbuffer_add(data->out, ",", 1);
jsonIndent(data);
}
break;
}
default:
break;
}
}
}
static void jsonPushParent(struct jsonWalk* data, tr_variant const* v)
{
struct ParentState* pstate = tr_new(struct ParentState, 1);
pstate->variantType = v->type;
pstate->childIndex = 0;
pstate->childCount = v->val.l.count;
if (tr_variantIsDict(v))
{
pstate->childCount *= 2;
}
tr_list_prepend(&data->parents, pstate);
}
static void jsonPopParent(struct jsonWalk* data)
{
tr_free(tr_list_pop_front(&data->parents));
}
static void jsonIntFunc(tr_variant const* val, void* vdata)
{
auto* data = static_cast<struct jsonWalk*>(vdata);
evbuffer_add_printf(data->out, "%" PRId64, val->val.i);
jsonChildFunc(data);
}
static void jsonBoolFunc(tr_variant const* val, void* vdata)
{
auto* data = static_cast<struct jsonWalk*>(vdata);
if (val->val.b)
{
evbuffer_add(data->out, "true", 4);
}
else
{
evbuffer_add(data->out, "false", 5);
}
jsonChildFunc(data);
}
static void jsonRealFunc(tr_variant const* val, void* vdata)
{
auto* data = static_cast<struct jsonWalk*>(vdata);
if (fabs(val->val.d - (int)val->val.d) < 0.00001)
{
evbuffer_add_printf(data->out, "%d", (int)val->val.d);
}
else
{
evbuffer_add_printf(data->out, "%.4f", tr_truncd(val->val.d, 4));
}
jsonChildFunc(data);
}
static void jsonStringFunc(tr_variant const* val, void* vdata)
{
struct evbuffer_iovec vec[1];
auto* data = static_cast<struct jsonWalk*>(vdata);
char const* str = nullptr;
size_t len = 0;
(void)tr_variantGetStr(val, &str, &len);
auto const* it = reinterpret_cast<unsigned char const*>(str);
unsigned char const* const end = it + len;
evbuffer_reserve_space(data->out, len * 4, vec, 1);
auto* out = static_cast<char*>(vec[0].iov_base);
char const* const outend = out + vec[0].iov_len;
char* outwalk = out;
*outwalk++ = '"';
for (; it != end; ++it)
{
switch (*it)
{
case '\b':
*outwalk++ = '\\';
*outwalk++ = 'b';
break;
case '\f':
*outwalk++ = '\\';
*outwalk++ = 'f';
break;
case '\n':
*outwalk++ = '\\';
*outwalk++ = 'n';
break;
case '\r':
*outwalk++ = '\\';
*outwalk++ = 'r';
break;
case '\t':
*outwalk++ = '\\';
*outwalk++ = 't';
break;
case '"':
*outwalk++ = '\\';
*outwalk++ = '"';
break;
case '\\':
*outwalk++ = '\\';
*outwalk++ = '\\';
break;
default:
if (isprint(*it))
{
*outwalk++ = *it;
}
else
{
UTF8 const* tmp = it;
UTF32 buf[1] = { 0 };
UTF32* u32 = buf;
ConversionResult result = ConvertUTF8toUTF32(&tmp, end, &u32, buf + 1, {});
if ((result == conversionOK || result == targetExhausted) && tmp != it)
{
outwalk += tr_snprintf(outwalk, outend - outwalk, "\\u%04x", (unsigned int)buf[0]);
it = tmp - 1;
}
}
break;
}
}
*outwalk++ = '"';
vec[0].iov_len = outwalk - out;
evbuffer_commit_space(data->out, vec, 1);
jsonChildFunc(data);
}
static void jsonDictBeginFunc(tr_variant const* val, void* vdata)
{
auto* data = static_cast<struct jsonWalk*>(vdata);
jsonPushParent(data, val);
evbuffer_add(data->out, "{", 1);
if (val->val.l.count != 0)
{
jsonIndent(data);
}
}
static void jsonListBeginFunc(tr_variant const* val, void* vdata)
{
size_t const nChildren = tr_variantListSize(val);
auto* data = static_cast<struct jsonWalk*>(vdata);
jsonPushParent(data, val);
evbuffer_add(data->out, "[", 1);
if (nChildren != 0)
{
jsonIndent(data);
}
}
static void jsonContainerEndFunc(tr_variant const* val, void* vdata)
{
auto* data = static_cast<struct jsonWalk*>(vdata);
bool emptyContainer = false;
jsonPopParent(data);
if (!emptyContainer)
{
jsonIndent(data);
}
if (tr_variantIsDict(val))
{
evbuffer_add(data->out, "}", 1);
}
else /* list */
{
evbuffer_add(data->out, "]", 1);
}
jsonChildFunc(data);
}
static struct VariantWalkFuncs const walk_funcs = {
jsonIntFunc, //
jsonBoolFunc, //
jsonRealFunc, //
jsonStringFunc, //
jsonDictBeginFunc, //
jsonListBeginFunc, //
jsonContainerEndFunc, //
};
void tr_variantToBufJson(tr_variant const* top, struct evbuffer* buf, bool lean)
{
struct jsonWalk data;
data.doIndent = !lean;
data.out = buf;
data.parents = nullptr;
tr_variantWalk(top, &walk_funcs, &data, true);
if (evbuffer_get_length(buf) != 0)
{
evbuffer_add_printf(buf, "\n");
}
}
Reference in New Issue View Git Blame Copy Permalink