static int json_tokenise(char *js, size_t len,
struct flb_pack_state *state)
{
int ret;
int n;
void *tmp;
ret = jsmn_parse(&state->parser, js, len,
state->tokens, state->tokens_size);
while (ret == JSMN_ERROR_NOMEM) {
n = state->tokens_size += 256;
tmp = realloc(state->tokens, sizeof(jsmntok_t) * n);
if (!tmp) {
perror("realloc");
return -1;
}
state->tokens = tmp;
state->tokens_size = n;
ret = jsmn_parse(&state->parser, js, len,
state->tokens, state->tokens_size);
}
if (ret == JSMN_ERROR_INVAL) {
return FLB_ERR_JSON_INVAL;
}
if (ret == JSMN_ERROR_PART) {
/* This is a partial JSON message, just stop */
flb_debug("[json tokenise] incomplete");
return FLB_ERR_JSON_PART;
}
state->tokens_count += ret;
return 0;
}
int test_string() {
int r;
jsmn_parser p;
jsmntok_t tok[10];
const char *js;
js = "\"strVar\" : \"hello world\"";
jsmn_init(&p);
r = jsmn_parse(&p, js, tok, 10);
check(r == JSMN_SUCCESS && tok[0].type == JSMN_STRING
&& tok[1].type == JSMN_STRING);
check(TOKEN_STRING(js, tok[0], "strVar"));
check(TOKEN_STRING(js, tok[1], "hello world"));
js = "\"strVar\" : \"escapes: \\/\\r\\n\\t\\b\\f\\\"\\\\\"";
jsmn_init(&p);
r = jsmn_parse(&p, js, tok, 10);
check(r == JSMN_SUCCESS && tok[0].type == JSMN_STRING
&& tok[1].type == JSMN_STRING);
check(TOKEN_STRING(js, tok[0], "strVar"));
check(TOKEN_STRING(js, tok[1], "escapes: \\/\\r\\n\\t\\b\\f\\\"\\\\"));
js = "\"strVar\" : \"\"";
jsmn_init(&p);
r = jsmn_parse(&p, js, tok, 10);
check(r == JSMN_SUCCESS && tok[0].type == JSMN_STRING
&& tok[1].type == JSMN_STRING);
check(TOKEN_STRING(js, tok[0], "strVar"));
check(TOKEN_STRING(js, tok[1], ""));
return 0;
}
int test_array_nomem() {
int i;
int r;
jsmn_parser p;
jsmntok_t toksmall[10], toklarge[10];
const char *js;
js = " [ 1, true, [123, \"hello\"]]";
for (i = 0; i < 6; i++) {
jsmn_init(&p);
memset(toksmall, 0, sizeof(toksmall));
memset(toklarge, 0, sizeof(toklarge));
r = jsmn_parse(&p, js, toksmall, i);
check(r == JSMN_ERROR_NOMEM);
memcpy(toklarge, toksmall, sizeof(toksmall));
r = jsmn_parse(&p, js, toklarge, 10);
check(r == JSMN_SUCCESS);
check(toklarge[0].type == JSMN_ARRAY && toklarge[0].size == 3);
check(toklarge[3].type == JSMN_ARRAY && toklarge[3].size == 2);
}
return 0;
}
int test_objects_arrays() {
int i;
int r;
jsmn_parser p;
jsmntok_t tokens[10];
const char *js;
js = "[10}";
jsmn_init(&p);
r = jsmn_parse(&p, js, tokens, 10);
check(r == JSMN_ERROR_INVAL);
js = "[10]";
jsmn_init(&p);
r = jsmn_parse(&p, js, tokens, 10);
check(r == JSMN_SUCCESS);
js = "{\"a\": 1]";
jsmn_init(&p);
r = jsmn_parse(&p, js, tokens, 10);
check(r == JSMN_ERROR_INVAL);
js = "{\"a\": 1}";
jsmn_init(&p);
r = jsmn_parse(&p, js, tokens, 10);
check(r == JSMN_SUCCESS);
return 0;
}
jsmntok_t * json_tokenise(char *js)
{
jsmn_parser parser;
jsmn_init(&parser);
unsigned int n = JSON_TOKENS;
jsmntok_t *tokens = malloc(sizeof(jsmntok_t) * n);
log_null(tokens);
int ret = jsmn_parse(&parser, js, tokens, n);
while (ret == JSMN_ERROR_NOMEM)
{
n = n * 2 + 1;
tokens = realloc(tokens, sizeof(jsmntok_t) * n);
log_null(tokens);
ret = jsmn_parse(&parser, js, tokens, n);
}
if (ret == JSMN_ERROR_INVAL)
log_die("jsmn_parse: invalid JSON string");
if (ret == JSMN_ERROR_PART)
log_die("jsmn_parse: truncated JSON string");
return tokens;
}
int test_array_nomem(void) {
int i;
int r;
jsmn_parser p;
jsmntok_t toksmall[10], toklarge[10];
const char *js;
js = " [ 1, true, [123, \"hello\"]]";
for (i = 0; i < 6; i++) {
jsmn_init(&p);
memset(toksmall, 0, sizeof(toksmall));
memset(toklarge, 0, sizeof(toklarge));
r = jsmn_parse(&p, js, strlen(js), toksmall, i);
check(r == JSMN_ERROR_NOMEM);
memcpy(toklarge, toksmall, sizeof(toksmall));
r = jsmn_parse(&p, js, strlen(js), toklarge, 10);
check(r >= 0);
check(tokeq(js, toklarge, 4,
JSMN_ARRAY, -1, -1, 3,
JSMN_PRIMITIVE, "1",
JSMN_PRIMITIVE, "true",
JSMN_ARRAY, -1, -1, 2,
JSMN_PRIMITIVE, "123",
JSMN_STRING, "hello", 0));
}
return 0;
}
int test_simple() {
const char *js;
int r;
jsmn_parser p;
jsmntok_t tokens[10];
js = "{\"a\": 0}";
jsmn_init(&p);
r = jsmn_parse(&p, js, tokens, 10);
check(r == JSMN_SUCCESS);
check(TOKEN_EQ(tokens[0], 0, 8, JSMN_OBJECT));
check(TOKEN_EQ(tokens[1], 2, 3, JSMN_STRING));
check(TOKEN_EQ(tokens[2], 6, 7, JSMN_PRIMITIVE));
check(TOKEN_STRING(js, tokens[0], js));
check(TOKEN_STRING(js, tokens[1], "a"));
check(TOKEN_STRING(js, tokens[2], "0"));
jsmn_init(&p);
js = "[\"a\":{},\"b\":{}]";
r = jsmn_parse(&p, js, tokens, 10);
check(r == JSMN_SUCCESS);
jsmn_init(&p);
js = "{\n \"Day\": 26,\n \"Month\": 9,\n \"Year\": 12\n }";
r = jsmn_parse(&p, js, tokens, 10);
check(r == JSMN_SUCCESS);
return 0;
}
jsmntok_t *jsmn_tokenize(char *json) {
jsmn_parser parser;
jsmntok_t *tokens;
unsigned maxToks;
int status;
jsmn_init(&parser);
maxToks = 256;
tokens = (jsmntok_t*)calloc(sizeof(jsmntok_t), maxToks);
assert(tokens);
if (json == NULL)
{
assert(0);
return NULL;
}
status = jsmn_parse(&parser, json, tokens, maxToks);
while (status == JSMN_ERROR_NOMEM)
{
maxToks = maxToks * 2 + 1;
tokens = (jsmntok_t*)realloc(tokens, sizeof(jsmntok_t) * maxToks);
assert(tokens);
status = jsmn_parse(&parser, json, tokens, maxToks);
}
return tokens;
}
int main(int argc, char *argv[])
{
int opt, ret;
char *tempdir;
struct stat st;
/* argument parsing */
while ((opt = getopt_long(argc, argv, optstring, long_opts, NULL)) != -1)
switch (opt) {
case 'V':
fprintf(stderr, "%s %s\n", NAME, VERSION);
return 0;
default:
fprintf(stderr, "unknown option '%c'", opt);
case '?':
fputs(help_msg, stderr);
exit(1);
break;
}
openlog(NAME, LOG_PERROR, LOG_DAEMON);
tempdir = argv[optind];
if (!tempdir)
asprintf(&tempdir, "/tmp/%s-%i", NAME, getppid());
/* setup input */
if (fstat(STDIN_FILENO, &st))
mylog(LOG_ERR, "fstat(0): %s", ESTR(errno));
char *dat;
dat = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE | MAP_POPULATE, STDIN_FILENO, 0);
if (dat == MAP_FAILED)
mylog(LOG_ERR, "mmap(0): %s", ESTR(errno));
/* start parsing */
jsmn_parser prs;
jsmntok_t *tok;
size_t tokcnt;
jsmn_init(&prs);
ret = jsmn_parse(&prs, dat, st.st_size, NULL, 0);
if (ret < 0)
mylog(LOG_ERR, "jsmn_parse returned %i", ret);
jsmn_init(&prs);
tokcnt = ret;
tok = malloc(sizeof(*tok)*tokcnt);
ret = jsmn_parse(&prs, dat, st.st_size, tok, tokcnt);
if (ret < 0)
mylog(LOG_ERR, "jsmn_parse returned %i", ret);
tokdump(dat, tok, tempdir);
return 0;
}
int parseTokens(char *json, jsmntok_t **tokens){
jsmn_parser parser;
jsmn_init(&parser);
log("[JSON] counting elements\n");
unsigned int tokensCnt = jsmn_parse(&parser, json, strlen(json), NULL, 0);
*tokens = (jsmntok_t*)malloc(sizeof(jsmntok_t) * tokensCnt);
jsmn_init(&parser);
log("[JSON] parsing elements\n");
return jsmn_parse(&parser, json, strlen(json), *tokens, tokensCnt);
}
int test_primitive() {
#ifndef JSMN_STRICT
int r;
jsmn_parser p;
jsmntok_t tok[10];
const char *js;
js = "\"boolVar\" : true";
jsmn_init(&p);
r = jsmn_parse(&p, js, tok, 10);
check(r == JSMN_SUCCESS && tok[0].type == JSMN_STRING
&& tok[1].type == JSMN_PRIMITIVE);
check(TOKEN_STRING(js, tok[0], "boolVar"));
check(TOKEN_STRING(js, tok[1], "true"));
js = "\"boolVar\" : false";
jsmn_init(&p);
r = jsmn_parse(&p, js, tok, 10);
check(r == JSMN_SUCCESS && tok[0].type == JSMN_STRING
&& tok[1].type == JSMN_PRIMITIVE);
check(TOKEN_STRING(js, tok[0], "boolVar"));
check(TOKEN_STRING(js, tok[1], "false"));
js = "\"intVar\" : 12345";
jsmn_init(&p);
r = jsmn_parse(&p, js, tok, 10);
check(r == JSMN_SUCCESS && tok[0].type == JSMN_STRING
&& tok[1].type == JSMN_PRIMITIVE);
check(TOKEN_STRING(js, tok[0], "intVar"));
check(TOKEN_STRING(js, tok[1], "12345"));
js = "\"floatVar\" : 12.345";
jsmn_init(&p);
r = jsmn_parse(&p, js, tok, 10);
check(r == JSMN_SUCCESS && tok[0].type == JSMN_STRING
&& tok[1].type == JSMN_PRIMITIVE);
check(TOKEN_STRING(js, tok[0], "floatVar"));
check(TOKEN_STRING(js, tok[1], "12.345"));
js = "\"nullVar\" : null";
jsmn_init(&p);
r = jsmn_parse(&p, js, tok, 10);
check(r == JSMN_SUCCESS && tok[0].type == JSMN_STRING
&& tok[1].type == JSMN_PRIMITIVE);
check(TOKEN_STRING(js, tok[0], "nullVar"));
check(TOKEN_STRING(js, tok[1], "null"));
#endif
return 0;
}
bool json_parse(const char *json_buffer, TokenVector *tokens) {
int jsmn_ret;
jsmn_parser p;
jsmn_init(&p);
jsmn_ret = jsmn_parse(&p, json_buffer, tokens);
return (JSMN_SUCCESS == jsmn_ret);
}
static int parse_json(struct cdb_make *cdbm, char *filename)
{
FILE *fp = fopen(filename, "r");
fseek(fp, 0, SEEK_END);
uint32_t size = ftell(fp);
char *str = malloc(size + 1);
fseek(fp, 0, SEEK_SET);
fread(str, 1, size, fp);
str[size] = 0;
int i;
int r;
jsmn_parser p;
jsmntok_t t[128];
jsmn_init(&p);
r = jsmn_parse(&p, str, size, t, sizeof(t)/sizeof(t[0]));
if (r < 0) {
printf("Failed to parse JSON: %d\n", r);
return 1;
}
for(i = 1; i < r; i+=2) {
if(!strncmp((str + t[i].start), "0x", 2)) {
char filename[256];
memset(filename, 0, 256);
char *tmp;
strncpy(filename,
&str[t[i + 1].start],
t[i + 1].end - t[i + 1].start);
FILE *data = fopen(filename, "rb+");
if(data == NULL) {
printf("Couldn't open file %s\n", filename);
}
fseek(data, 0, SEEK_END);
size_t size = ftell(data);
tmp = malloc(size * sizeof(char));
fseek(data, 0, SEEK_SET);
fread(tmp, sizeof(char), size, data);
cdb_make_add(cdbm,
&str[t[i].start + 2],
(t[i].end - t[i].start) - 2,
tmp, size);
fclose(data);
free(tmp);
} else {
cdb_make_add(cdbm,
&str[t[i].start],
t[i].end - t[i].start,
&str[t[i + 1].start],
t[i + 1].end - t[i + 1].start);
}
}
free(str);
fclose(fp);
return 0;
}
FIO_status load_JSON(char* path, char *js_buff, jsmntok_t *tokens, json_attr_t *json_attr){
FIL fff; // File handler
jsmn_parser parser;
UINT size;
SDFS_status_type res = SDFS_open(&fff, path, F_RD);
if (res != SDFS_OK) //Calibration not file exist
return FIO_FILE_NOT_FOUND;
FRESULT f_res=f_read(&fff, js_buff, JSON_BUFF_SIZE, &size);
if (f_res!=FR_OK){
if (SDFS_close(&fff)!= SDFS_OK)
return FIO_FILE_CLOSE_ERROR;
return FIO_READ_ERROR;
}
js_buff[size] = 0;
jsmn_init(&parser);
jsmnerr_t result = jsmn_parse(&parser, js_buff, size, tokens, TOKENS_NUM);
if (result<0){
SDFS_close(&fff);
return FIO_JSON_FORMAT_ERR;
}
parse_result_t parse_result = tokens_parse(js_buff, tokens, json_attr, 0);
if (parse_result != parse_ok){
if (SDFS_close(&fff)!= SDFS_OK)
return FIO_FILE_CLOSE_ERROR;
return FIO_JSON_DATA_ERR;
}
if (SDFS_close(&fff)!= SDFS_OK)
return FIO_FILE_CLOSE_ERROR;
return FIO_OK;
}
int parse_json (char *js, int len, jsmntok_t *tok, int num_tok)
{
jsmn_parser p;
int r, i, s, e;
char saved;
debug (4, "==> parse_json");
jsmn_init(&p);
r = jsmn_parse(&p, js, len, tok, num_tok);
if (r <= 0) {
error ("jsmn_parse returned error(%d)", r);
return r;
}
if (sp_config.debug || sp_config.debug_stderr) {
for (i = 0; i < r; i++) {
s = tok[i].start;
e = tok[i].end;
saved = js[e];
js[e] = 0;
debug (4, "tok.type = %s", types[tok[i].type]);
debug (4, "value = %s", js + s);
js[e] = saved;
}
}
return r;
}
static void process_frame(const char * const body)
{
jsmn_parser parser;
qword elapsed = time_ms();
jsmn_init(&parser);
int r = jsmn_parse(&parser, body, tokens, NUM_TOKENS);
if(r != 0)
{
_log(MAJOR, "Parser result %d. Message discarded.", r);
stats[NotRecog]++;
}
else
{
size_t messages, i, index;
// Is it an array?
if(tokens[0].type == JSMN_ARRAY)
{
messages = tokens[0].size;
index = 1;
_log(DEBUG, "STOMP message is array of %d TD messages.", messages);
}
else
{
messages = 1;
index = 0;
_log(DEBUG, "STOMP message contains a single TD message.");
}
for(i=0; i < messages && run; i++)
{
char area_id[4];
word describer;
jsmn_find_extract_token(body, tokens, index, "area_id", area_id, sizeof(area_id));
stats[GoodMessage]++;
message_count++;
for(describer = 0; describer < DESCRIBERS; describer++)
{
if(!strcasecmp(area_id, describers[describer]))
{
process_message(describer, body, index);
stats[RelMessage]++;
message_count_rel++;
describer = DESCRIBERS;
}
}
size_t message_ends = tokens[index].end;
do index++;
while ( tokens[index].start < message_ends && tokens[index].start >= 0 && index < NUM_TOKENS);
}
}
elapsed = time_ms() - elapsed;
if(debug || elapsed > 2500)
{
_log(MINOR, "Frame took %s ms to process.", commas_q(elapsed));
}
}
bool ExtractKeysFromJWKSet(const std::string& jwk_set,
KeyIdAndKeyPairs* keys,
int session_type) {
/*We expect max 128 tokens
* FIXME: We need a different and safe JSON parser.
*/
jsmntok_t t[MAX_JSON_TOKENS];
jsmn_parser parser;
int result;
const char* jchr = &(jwk_set.c_str()[0]);
std::string algorithm;
std::string key;
std::string keyId;
jsmn_init(&parser);
result = jsmn_parse(&parser, jchr, jwk_set.size(), t, sizeof(t)/sizeof(t[0]));
if(result<0) {
std::cout << "Failed to parse JSON" << jwk_set << std::endl;
return false;
}
if(jsoneq(jchr, &t[1], kKeysTag)!=0) {
std::cout << "Unable to parse JSON. Expected kKeyTag : " << kKeysTag << std::endl;
return false;
}
KeyIdAndKeyPairs local_keys;
/* Ignore the first 2 tokens */
for(int i = 2; i < result; i++) {
if(jsoneq(jchr, &t[i], kAlgTag) == 0 && (i+1) < MAX_JSON_TOKENS) {
algorithm = std::string(jchr + t[i+1].start, t[i+1].end - t[i+1].start);
continue;
}
if(jsoneq(jchr, &t[i], kKeyTag) == 0 && (i+1) < MAX_JSON_TOKENS) {
if(key.size() != 0) {
std::cout << "CDMI supports only one key in JSON message. Got multiple keys." << std::endl;
return false;
}
key = std::string(jchr + t[i+1].start, t[i+1].end - t[i+1].start);
continue;
}
if(jsoneq(jchr, &t[i], kKeyIdTag) == 0 && (i+1) < MAX_JSON_TOKENS) {
if(keyId.size() != 0) {
std::cout << "CDMI supports only one keyID in JSON message. Got multiple keys." << std::endl;
return false;
}
keyId = std::string(jchr + t[i+1].start, t[i+1].end - t[i+1].start);
continue;
}
}
KeyIdAndKeyPair keyPair;
convertStringsToKeyPair(&keyPair, key, keyId);
local_keys.push_back(keyPair);
keys->swap(local_keys);
return true;
}
int test_issue_22() {
int r;
jsmn_parser p;
jsmntok_t tokens[128];
const char *js;
js = "{ \"height\":10, \"layers\":[ { \"data\":[6,6], \"height\":10, "
"\"name\":\"Calque de Tile 1\", \"opacity\":1, \"type\":\"tilelayer\", "
"\"visible\":true, \"width\":10, \"x\":0, \"y\":0 }], "
"\"orientation\":\"orthogonal\", \"properties\": { }, \"tileheight\":32, "
"\"tilesets\":[ { \"firstgid\":1, \"image\":\"..\\/images\\/tiles.png\", "
"\"imageheight\":64, \"imagewidth\":160, \"margin\":0, \"name\":\"Tiles\", "
"\"properties\":{}, \"spacing\":0, \"tileheight\":32, \"tilewidth\":32 }], "
"\"tilewidth\":32, \"version\":1, \"width\":10 }";
jsmn_init(&p);
r = jsmn_parse(&p, js, strlen(js), tokens, 128);
check(r >= 0);
#if 0
for (i = 1; tokens[i].end < tokens[0].end; i++) {
if (tokens[i].type == JSMN_STRING || tokens[i].type == JSMN_PRIMITIVE) {
printf("%.*s\n", tokens[i].end - tokens[i].start, js + tokens[i].start);
} else if (tokens[i].type == JSMN_ARRAY) {
printf("[%d elems]\n", tokens[i].size);
} else if (tokens[i].type == JSMN_OBJECT) {
printf("{%d elems}\n", tokens[i].size);
} else {
TOKEN_PRINT(tokens[i]);
}
}
#endif
return 0;
}
static int ov_json_parse(void *ov_msg_handle, char *data, void *jd_cookie)
{
ov_json_data_t *jd = jd_cookie;
jsmn_parser parser;
jsmnerr_t rc;
jsmntok_t tokens[NO_OF_TOKENS] = {};
if (!jd->json_cb)
{
printf("No JSON Callback - Unparsed data:\n\n%s\n", data);
return 0;
}
printf("\nRaw Unparsed data:\n\n%s\n", data);
jsmn_init(&parser);
rc = jsmn_parse(&parser, data, tokens, NO_OF_TOKENS);
if (rc == 0) {
jsmntok_t *t = tokens;
/* null-terminate text to make printing easier */
while (t->end) {
if (t->end > 0) {
data[t->end] = '\0';
}
t++;
}
if (jd->json_cb) {
jd->json_cb(ov_msg_handle, tokens, data, jd->json_data);
}
}
return rc;
}
int test_partial_array(void) {
#ifdef JSMN_STRICT
int r;
int i;
jsmn_parser p;
jsmntok_t tok[10];
const char *js = "[ 1, true, [123, \"hello\"]]";
jsmn_init(&p);
for (i = 1; i <= strlen(js); i++) {
r = jsmn_parse(&p, js, i, tok, sizeof(tok)/sizeof(tok[0]));
if (i == strlen(js)) {
check(r == 6);
check(tokeq(js, tok, 6,
JSMN_ARRAY, -1, -1, 3,
JSMN_PRIMITIVE, "1",
JSMN_PRIMITIVE, "true",
JSMN_ARRAY, -1, -1, 2,
JSMN_PRIMITIVE, "123",
JSMN_STRING, "hello", 0));
} else {
check(r == JSMN_ERROR_PART);
}
}
#endif
return 0;
}
int cfg_from_json(struct conn *conn)
{
size_t size;
char *jstr = cw_load_file("cfg.json", &size);
if (!jstr) {
fprintf(stderr, "Can't load cfg %s: %s\n", "cfg.json", strerror(errno));
return 0;
}
jsmn_parser p;
jsmntok_t t[1200];
jsmn_init(&p);
int rc = jsmn_parse(&p, jstr, size, t, sizeof(t) / sizeof(t[0]));
if (rc < 0) {
printf("Parser failed\n");
return 1;
}
printf("Number of items %d\n",conn->actions->items->count);
scn_obj(jstr, t, conn->config, conn->actions->items,NULL);
return 1;
}
bool extractClientToken(const char *pJsonDocument, char *pExtractedClientToken) {
bool ret_val = false;
jsmn_init(&shadowJsonParser);
int32_t tokenCount, i;
jsmntok_t ClientJsonToken;
tokenCount = jsmn_parse(&shadowJsonParser, pJsonDocument, strlen(pJsonDocument), jsonTokenStruct,
sizeof(jsonTokenStruct) / sizeof(jsonTokenStruct[0]));
if (tokenCount < 0) {
WARN("Failed to parse JSON: %d\n", tokenCount);
return false;
}
/* Assume the top-level element is an object */
if (tokenCount < 1 || jsonTokenStruct[0].type != JSMN_OBJECT) {
return false;
}
for (i = 1; i < tokenCount; i++) {
if (jsoneq(pJsonDocument, &jsonTokenStruct[i], SHADOW_CLIENT_TOKEN_STRING) == 0) {
ClientJsonToken = jsonTokenStruct[i + 1];
uint8_t length = ClientJsonToken.end - ClientJsonToken.start;
strncpy(pExtractedClientToken, pJsonDocument + ClientJsonToken.start, length);
pExtractedClientToken[length] = '\0';
return true;
}
}
return false;
}
int kr_mixer_path_type_fr_json(char *json, void *st) {
int res;
jsmn_parser parser;
jsmntok_t tokens[512];
jsmnerr_t err;
int ntokens;
int k;
res = 0;
if ((json == NULL) || (st == NULL)) {
return -1;
}
jsmn_init(&parser);
err = jsmn_parse(&parser,json,tokens,512);
ntokens = parser.toknext;
k = 0;
if (err != JSMN_SUCCESS || ntokens < 3) {
return -1;
}
if (tokens[k].type != JSMN_OBJECT) {
return -1;
}
k++;
return res;
}
jsmntok_t *json_parse_input(const char *input, int len, bool *valid)
{
jsmn_parser parser;
jsmntok_t *toks;
jsmnerr_t ret;
toks = tal_arr(input, jsmntok_t, 10);
again:
jsmn_init(&parser);
ret = jsmn_parse(&parser, input, len, toks, tal_count(toks) - 1);
switch (ret) {
case JSMN_ERROR_INVAL:
*valid = false;
return tal_free(toks);
case JSMN_ERROR_PART:
*valid = true;
return tal_free(toks);
case JSMN_ERROR_NOMEM:
tal_resize(&toks, tal_count(toks) * 2);
goto again;
}
/* Cut to length and return. */
*valid = true;
tal_resize(&toks, ret + 1);
/* Make sure last one is always referencable. */
toks[ret].type = -1;
toks[ret].start = toks[ret].end = toks[ret].size = 0;
return toks;
}
static BOOL
json_parse_record(
json_ctx * ctx,
char * buf)
{
jsmn_parser jsm;
int idx, rc;
jsmn_init(&jsm);
rc = jsmn_parse(&jsm, buf, ctx->tok, JSMN_MAXTOK);
ctx->buf = buf;
ctx->ntok = jsm.toknext;
/* Make all tokens NUL terminated by overwriting the
* terminator symbol
*/
for (idx = 0; idx < jsm.toknext; ++idx)
if (ctx->tok[idx].end > ctx->tok[idx].start)
ctx->buf[ctx->tok[idx].end] = '\0';
if (JSMN_ERROR_PART != rc &&
JSMN_ERROR_NOMEM != rc &&
JSMN_SUCCESS != rc )
return FALSE; /* not parseable - bail out */
if (0 >= jsm.toknext || JSMN_OBJECT != ctx->tok[0].type)
return FALSE; /* not object or no data!?! */
return TRUE;
}
// Parses a JSON document into an array of tokens.
//
// importer - The importer.
// source - The import file contents.
// tokens - A pointer to where the tokens should be returned.
//
// Returns 0 if successful, otherwise returns -1.
int sky_importer_tokenize(sky_importer *importer, bstring source,
jsmntok_t **tokens)
{
assert(importer != NULL);
assert(source != NULL);
assert(tokens != NULL);
// Initialize return values.
*tokens = NULL;
// Create JSON parser.
jsmn_parser parser;
jsmn_init(&parser);
// Parse tokens until we're done.
uint32_t token_count = 1024;
jsmnerr_t ret;
do {
*tokens = realloc(*tokens, token_count * sizeof(jsmntok_t));
ret = jsmn_parse(&parser, bdata(source), *tokens, token_count);
check(ret != JSMN_ERROR_INVAL, "Invalid json token");
check(ret != JSMN_ERROR_PART, "Unexpected end in json data");
// If we didn't have enough tokens then reallocate and try again.
if(ret == JSMN_ERROR_NOMEM) token_count *= 2;
} while(ret != JSMN_SUCCESS);
return 0;
error:
free(*tokens);
*tokens = NULL;
return -1;
}
static void process_frame(const char * body)
{
jsmn_parser parser;
time_t elapsed = time(NULL);
jsmn_init(&parser);
int r = jsmn_parse(&parser, body, tokens, NUM_TOKENS);
if(r != 0)
{
_log(MAJOR, "Parser result %d. Message discarded.", r);
stats[NotVSTP]++;
}
else
{
// Good message
char message_name[128];
jsmn_extract_token(body, tokens, 1, message_name, sizeof(message_name));
if(!strcmp(message_name, "VSTPCIFMsgV1"))
{
process_vstp(body, tokens);
}
else
{
_log(MINOR, "Unrecognised message name \"%s\".", message_name);
jsmn_dump_tokens(body, tokens, 0);
stats[NotVSTP]++;
}
}
elapsed = time(NULL) - elapsed;
if(elapsed > 1 || debug)
{
_log(MINOR, "Transaction took %ld seconds.", elapsed);
}
}
int main(void)
{
int i;
int r;
jsmn_parser p;
jsmntok_t t[16]; /* We expect no more than 16 tokens */
jsmn_init(&p);
r = jsmn_parse(&p, JSON_STRING, strlen(JSON_STRING), t, sizeof(t) / sizeof(t[0]));
if (r < 0) {
printf("Failed to parse JSON: %d\n", r);
return 1;
}
/* Assume the top-level element is an object */
if (r < 1 || t[0].type != JSMN_OBJECT) {
printf("Object expected\n");
return 1;
}
/* Loop over all keys of the root object */
for (i = 1; i < r; i++) {
if (jsoneq(JSON_STRING, &t[i], "user") == 0) {
/* We may use strndup() to fetch string value */
printf("- User: %.*s\n", t[i + 1].end - t[i + 1].start,
JSON_STRING + t[i + 1].start);
i++;
}
else if (jsoneq(JSON_STRING, &t[i], "admin") == 0) {
/* We may additionally check if the value is either "true" or "false" */
printf("- Admin: %.*s\n", t[i + 1].end - t[i + 1].start,
JSON_STRING + t[i + 1].start);
i++;
}
else if (jsoneq(JSON_STRING, &t[i], "uid") == 0) {
/* We may want to do strtol() here to get numeric value */
printf("- UID: %.*s\n", t[i + 1].end - t[i + 1].start,
JSON_STRING + t[i + 1].start);
i++;
}
else if (jsoneq(JSON_STRING, &t[i], "groups") == 0) {
int j;
printf("- Groups:\n");
if (t[i + 1].type != JSMN_ARRAY) {
continue; /* We expect groups to be an array of strings */
}
for (j = 0; j < t[i + 1].size; j++) {
jsmntok_t *g = &t[i + j + 2];
printf(" * %.*s\n", g->end - g->start, JSON_STRING + g->start);
}
i += t[i + 1].size + 1;
}
else {
printf("Unexpected key: %.*s\n", t[i].end - t[i].start,
JSON_STRING + t[i].start);
}
}
return 0;
}
jsmntok_t * json_tokenise(char *js)
{
jsmn_parser parser;
parser.size = sizeof(parser);
jsmn_init(&parser, NULL);
unsigned int n = 64;
jsmntok_t* tokens = (jsmntok_t*)malloc(sizeof(jsmntok_t) * n);
int ret = jsmn_parse(&parser, js, strlen(js), tokens, n, NULL);
while (ret==JSMN_ERROR_NOMEM)
{
n = n * 2 + 1;
tokens = (jsmntok_t*)realloc(tokens, sizeof(jsmntok_t) * n);
ret = jsmn_parse(&parser, js, strlen(js), tokens, n, NULL);
}
return tokens;
}
int test_count() {
jsmn_parser p;
const char *js;
js = "{}";
jsmn_init(&p);
check(jsmn_parse(&p, js, strlen(js), NULL, 0) == 1);
js = "[]";
jsmn_init(&p);
check(jsmn_parse(&p, js, strlen(js), NULL, 0) == 1);
js = "[[]]";
jsmn_init(&p);
check(jsmn_parse(&p, js, strlen(js), NULL, 0) == 2);
js = "[[], []]";
jsmn_init(&p);
check(jsmn_parse(&p, js, strlen(js), NULL, 0) == 3);
js = "[[], []]";
jsmn_init(&p);
check(jsmn_parse(&p, js, strlen(js), NULL, 0) == 3);
js = "[[], [[]], [[], []]]";
jsmn_init(&p);
check(jsmn_parse(&p, js, strlen(js), NULL, 0) == 7);
js = "[\"a\", [[], []]]";
jsmn_init(&p);
check(jsmn_parse(&p, js, strlen(js), NULL, 0) == 5);
js = "[[], \"[], [[]]\", [[]]]";
jsmn_init(&p);
check(jsmn_parse(&p, js, strlen(js), NULL, 0) == 5);
js = "[1, 2, 3]";
jsmn_init(&p);
check(jsmn_parse(&p, js, strlen(js), NULL, 0) == 4);
js = "[1, 2, [3, \"a\"], null]";
jsmn_init(&p);
check(jsmn_parse(&p, js, strlen(js), NULL, 0) == 7);
return 0;
}
