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; }