inline bool __JSONParseWithString(__JSONRef json, CFStringRef string, CFErrorRef *error) { bool success = 1; json->yajlParser = yajl_alloc(&json->yajlParserCallbacks, &json->yajlAllocFuncs, (void *)json); if (json->yajlParser) { // yajl_config(json->yajlParser, yajl_allow_comments, kJSONReadOptionAllowComments | options ? 1 : 0); // yajl_config(json->yajlParser, yajl_dont_validate_strings, kJSONReadOptionCheckUTF8 | options ? 1 : 0); CFDataRef data = CFStringCreateExternalRepresentation(json->allocator, string, kCFStringEncodingUTF8, 0); if (data) { if ((json->yajlParserStatus = yajl_parse(json->yajlParser, CFDataGetBytePtr(data), CFDataGetLength(data))) != yajl_status_ok) { if (error) { success = 0; unsigned char * str = yajl_get_error(json->yajlParser, 1, CFDataGetBytePtr(data), CFDataGetLength(data)); fprintf(stderr, "%s", (const char *) str); yajl_free_error(json->yajlParser, str); *error = CFErrorCreateWithUserInfoKeysAndValues(json->allocator, CFSTR("com.github.mirek.CoreJSON"), (CFIndex)json->yajlParserStatus, (const void *) { kCFErrorDescriptionKey }, (const void *) { CFSTR("Test") }, 1); } // TODO: Error stuff //printf("ERROR: %s\n", yajl_get_error(json->yajlParser, 1, __JSONUTF8StringGetBuffer(utf8), __JSONUTF8StringGetMaximumSize(utf8))); } json->yajlParserStatus = yajl_complete_parse(json->yajlParser); CFRelease(data); } else {
static int js_parser_parse(lua_State *L) { yajl_handle* handle = (yajl_handle*) lua_touserdata(L, lua_upvalueindex(1)); if ( lua_isnil(L, 1) ) { js_parser_assert(L, yajl_complete_parse(*handle), handle, NULL, 0, __FILE__, __LINE__); } else { size_t len; const unsigned char* buff = (const unsigned char*) luaL_checklstring(L, 1, &len); if ( NULL == buff ) return 0; js_parser_assert(L, yajl_parse(*handle, buff, len), handle, buff, len, __FILE__, __LINE__); } return 0; }
/* if this method throw an exception then the object is invalid */ bool JsonShredder::Shred(uint64_t docseq, const std::string& json, std::string* idout, std::string* errout) { YajlHandle hand(&ctx_); yajl_status stat; bool success = true; ctx_.docseq = docseq; stat = yajl_parse(hand, (unsigned char*)json.c_str(), json.length()); if (stat == yajl_status_ok) stat = yajl_complete_parse(hand); if (stat == yajl_status_client_canceled) { if (ctx_.exception_ptr) { // some sorta exception occurred. rethrow. std::rethrow_exception(ctx_.exception_ptr); } else { // error message must be in tempbuff *errout = ctx_.tempbuff; success = false; } } else if (stat != yajl_status_ok) { hand.GetError(json, errout); success = false; } if (ctx_.docid.length() == 0) { *errout = "missing _id field"; success = false; } *idout = ctx_.docid; return success; }
yajl_val yajl_tree_parse_options (const char *input, char *error_buffer, size_t error_buffer_size, yajl_tree_option options) { static const yajl_callbacks callbacks = { /* null = */ handle_null, /* boolean = */ handle_boolean, /* integer = */ NULL, /* double = */ NULL, /* number = */ handle_number, /* string = */ handle_string, /* start map = */ handle_start_map, /* map key = */ handle_string, /* end map = */ handle_end_map, /* start array = */ handle_start_array, /* end array = */ handle_end_array }; yajl_handle handle; yajl_status status; char * internal_err_str; context_t ctx = { NULL, NULL, NULL, 0 }; ctx.errbuf = error_buffer; ctx.errbuf_size = error_buffer_size; if (error_buffer != NULL) memset (error_buffer, 0, error_buffer_size); handle = yajl_alloc (&callbacks, NULL, &ctx); yajl_config(handle, yajl_allow_comments, (options & yajl_tree_option_dont_allow_comments) ? 0 : 1); yajl_config(handle, yajl_allow_trailing_separator, (options & yajl_tree_option_allow_trailing_separator) ? 1 : 0); status = yajl_parse(handle, (unsigned char *) input, strlen (input)); status = yajl_complete_parse (handle); if (status != yajl_status_ok) { if (error_buffer != NULL && error_buffer_size > 0) { internal_err_str = (char *) yajl_get_error(handle, 1, (const unsigned char *) input, strlen(input)); snprintf(error_buffer, error_buffer_size, "%s", internal_err_str); YA_FREE(&(handle->alloc), internal_err_str); } while (ctx.stack) { yajl_tree_free(context_pop(&ctx)); } yajl_free (handle); return NULL; } yajl_free (handle); return (ctx.root); }
CJSONVariantParser::~CJSONVariantParser() { #if YAJL_MAJOR == 2 yajl_complete_parse(m_handler); #else yajl_parse_complete(m_handler); #endif yajl_free(m_handler); }
static struct rest_json_payload * rest_get_json_upload(mtev_http_rest_closure_t *restc, int *mask, int *complete) { struct rest_json_payload *rxc; mtev_http_request *req = mtev_http_session_request(restc->http_ctx); httptrap_closure_t *ccl = NULL; int content_length; char buffer[32768]; content_length = mtev_http_request_content_length(req); rxc = restc->call_closure; rxc->check = noit_poller_lookup(rxc->check_id); if (!rxc->check) { *complete = 1; return NULL; } if(!strcmp(rxc->check->module, "httptrap")) ccl = rxc->check->closure; rxc->immediate = noit_httptrap_check_asynch(ccl ? ccl->self : NULL, rxc->check); while(!rxc->complete) { int len; len = mtev_http_session_req_consume( restc->http_ctx, buffer, MIN(content_length - rxc->len, sizeof(buffer)), sizeof(buffer), mask); if(len > 0) { yajl_status status; _YD("inbound payload chunk (%d bytes) continuing YAJL parse\n", len); status = yajl_parse(rxc->parser, (unsigned char *)buffer, len); if(status != yajl_status_ok) { unsigned char *err; *complete = 1; err = yajl_get_error(rxc->parser, 0, (unsigned char *)buffer, len); rxc->error = strdup((char *)err); yajl_free_error(rxc->parser, err); return rxc; } rxc->len += len; } if(len < 0 && errno == EAGAIN) return NULL; else if(len < 0) { *complete = 1; return NULL; } content_length = mtev_http_request_content_length(req); if((mtev_http_request_payload_chunked(req) && len == 0) || (rxc->len == content_length)) { rxc->complete = 1; _YD("no more data, finishing YAJL parse\n"); yajl_complete_parse(rxc->parser); } } *complete = 1; return rxc; }
SLNFilterRef SLNJSONFilterParserEnd(SLNJSONFilterParserRef const parser) { if(!parser) return NULL; assertf(parser->JSONParser, "Parser in invalid state"); yajl_status const err = yajl_complete_parse(parser->JSONParser); yajl_free(parser->JSONParser); parser->JSONParser = NULL; assertf(-1 == parser->depth, "Parser ended at invalid depth %d", parser->depth); SLNFilterRef const filter = parser->stack[0]; parser->stack[0] = NULL; return yajl_status_ok == err ? filter : NULL; }
bool jsaxparser_end(jsaxparser_ref parser) { #if YAJL_VERSION < 20000 parser->status = yajl_parse_complete(parser->handle); #else parser->status = yajl_complete_parse(parser->handle); #endif return jsaxparser_process_error(parser, "", 0, true); }
bool hkvJsonStreamReader::Parse(const char* pszFileName, unsigned int uiChunkSize) { yajl_status stat; void* pFile; size_t rd; // Allocate read buffer unsigned char* pFileData = (unsigned char*)(YA_MALLOC(&(m_pHandle->alloc), uiChunkSize)); assert(pFileData); // Open file pFile = m_pFileHandler->Open(pszFileName, hkvJsonFileHandler::JFM_READ); if (pFile == NULL) return false; for (;;) { rd = m_pFileHandler->Read((void*)pFileData, uiChunkSize - 1, pFile); if (rd == 0) { if (!m_pFileHandler->IsEOF(pFile)) fprintf(stderr, "Error encountered on file read.\n"); break; } pFileData[rd] = 0; // Pass to parser stat = yajl_parse(m_pHandle, pFileData, rd); if (stat != yajl_status_ok) break; } // Parse any remaining buffered data stat = yajl_complete_parse(m_pHandle); if (stat != yajl_status_ok) { unsigned char * str = yajl_get_error(m_pHandle, 1, pFileData, rd); fprintf(stderr, "%s", (const char *) str); yajl_free_error(m_pHandle, str); assert(false); return false; } // Close the file m_pFileHandler->Close(pFile); // Free read buffer YA_FREE(&(m_pHandle->alloc), pFileData); return true; }
static int cj_perform (cj_t *db) /* {{{ */ { int status; yajl_handle yprev = db->yajl; db->yajl = yajl_alloc (&ycallbacks, #if HAVE_YAJL_V2 /* alloc funcs = */ NULL, #else /* alloc funcs = */ NULL, NULL, #endif /* context = */ (void *)db); if (db->yajl == NULL) { ERROR ("curl_json plugin: yajl_alloc failed."); db->yajl = yprev; return (-1); } if (db->url) status = cj_curl_perform (db); else status = cj_sock_perform (db); if (status < 0) { yajl_free (db->yajl); db->yajl = yprev; return (-1); } #if HAVE_YAJL_V2 status = yajl_complete_parse(db->yajl); #else status = yajl_parse_complete(db->yajl); #endif if (status != yajl_status_ok) { unsigned char *errmsg; errmsg = yajl_get_error (db->yajl, /* verbose = */ 0, /* jsonText = */ NULL, /* jsonTextLen = */ 0); ERROR ("curl_json plugin: yajl_parse_complete failed: %s", (char *) errmsg); yajl_free_error (db->yajl, errmsg); yajl_free (db->yajl); db->yajl = yprev; return (-1); } yajl_free (db->yajl); db->yajl = yprev; return (0); } /* }}} int cj_perform */
/* * Public functions */ yajl_val yajl_tree_parse (const char *input, char *error_buffer, size_t error_buffer_size) { static const yajl_callbacks callbacks = { /* null = */ handle_null, /* boolean = */ handle_boolean, /* integer = */ NULL, /* double = */ NULL, /* number = */ handle_number, /* string = */ handle_string, /* start map = */ handle_start_map, /* map key = */ handle_string, /* end map = */ handle_end_map, /* start array = */ handle_start_array, /* end array = */ handle_end_array }; yajl_handle handle; yajl_status status; context_t ctx = { NULL, NULL, NULL, 0 }; ctx.errbuf = error_buffer; ctx.errbuf_size = error_buffer_size; if (error_buffer != NULL) memset (error_buffer, 0, error_buffer_size); handle = yajl_alloc (&callbacks, NULL, &ctx); yajl_config(handle, yajl_allow_comments, 1); status = yajl_parse(handle, (unsigned char *) input, strlen (input)); status = yajl_complete_parse (handle); if (status != yajl_status_ok) { if (error_buffer != NULL && error_buffer_size > 0) { snprintf( error_buffer, error_buffer_size, "%s", (char *) yajl_get_error(handle, 1, (const unsigned char *) input, strlen(input))); } yajl_free (handle); return NULL; } yajl_free (handle); return (ctx.root); }
TEST_F(Yajl, yajl_parse_nullcallbacks) { for (size_t i = 0; i < kTrialCount; i++) { yajl_handle hand = yajl_alloc(&nullcallbacks, NULL, NULL); yajl_status stat = yajl_parse(hand, (unsigned char*)json_, length_ - 1); //ASSERT_EQ(yajl_status_ok, stat); if (stat != yajl_status_ok) { unsigned char * str = yajl_get_error(hand, 1, (unsigned char*)json_, length_ + 1); fprintf(stderr, "%s", (const char *) str); } stat = yajl_complete_parse(hand); ASSERT_EQ(yajl_status_ok, stat); yajl_free(hand); } }
static struct rest_json_payload * rest_get_json_upload(mtev_http_rest_closure_t *restc, int *mask, int *complete) { struct rest_json_payload *rxc; mtev_http_request *req = mtev_http_session_request(restc->http_ctx); httptrap_closure_t *ccl; int content_length; char buffer[32768]; content_length = mtev_http_request_content_length(req); rxc = restc->call_closure; ccl = rxc->check->closure; rxc->immediate = mtev_httptrap_check_aynsch(ccl->self, rxc->check); while(!rxc->complete) { int len; len = mtev_http_session_req_consume( restc->http_ctx, buffer, MIN(content_length - rxc->len, sizeof(buffer)), sizeof(buffer), mask); if(len > 0) { yajl_status status; status = yajl_parse(rxc->parser, (unsigned char *)buffer, len); if(status != yajl_status_ok) { unsigned char *err; *complete = 1; err = yajl_get_error(rxc->parser, 0, (unsigned char *)buffer, len); rxc->error = strdup((char *)err); yajl_free_error(rxc->parser, err); return rxc; } rxc->len += len; } if(len < 0 && errno == EAGAIN) return NULL; else if(len < 0) { *complete = 1; return NULL; } content_length = mtev_http_request_content_length(req); if((mtev_http_request_payload_chunked(req) && len == 0) || (rxc->len == content_length)) { rxc->complete = 1; yajl_complete_parse(rxc->parser); } } *complete = 1; return rxc; }
static VALUE mParser_do_yajl_parse(VALUE self, VALUE str, VALUE yajl_opts) { yajl_handle hand; yajl_status stat; unsigned char *err; volatile CTX ctx; rb_ivar_set(self, rb_intern("key"), Qnil); rb_ivar_set(self, rb_intern("stack"), rb_ary_new()); rb_ivar_set(self, rb_intern("key_stack"), rb_ary_new()); ctx.self = self; ctx.symbolizeKeys = get_opts_key(self, "symbolize_keys"); ctx.uniqueKeyChecking = get_opts_key(self, "unique_key_checking"); hand = yajl_alloc(&callbacks, NULL, (void *)&ctx); if (rb_hash_aref(yajl_opts, ID2SYM(rb_intern("yajl_allow_comments"))) == Qtrue) { yajl_config(hand, yajl_allow_comments, 1); } if (rb_hash_aref(yajl_opts, ID2SYM(rb_intern("yajl_dont_validate_strings"))) == Qtrue) { yajl_config(hand, yajl_dont_validate_strings, 1); } if (rb_hash_aref(yajl_opts, ID2SYM(rb_intern("yajl_allow_trailing_garbage"))) == Qtrue) { yajl_config(hand, yajl_allow_trailing_garbage, 1); } if (rb_hash_aref(yajl_opts, ID2SYM(rb_intern("yajl_allow_multiple_values"))) == Qtrue) { yajl_config(hand, yajl_allow_multiple_values, 1); } if (rb_hash_aref(yajl_opts, ID2SYM(rb_intern("yajl_allow_partial_values"))) == Qtrue) { yajl_config(hand, yajl_allow_partial_values, 1); } if ((stat = yajl_parse(hand, (unsigned char *)RSTRING_PTR(str), RSTRING_LEN(str))) != yajl_status_ok) { err = yajl_get_error(hand, 1, (unsigned char *)RSTRING_PTR(str), RSTRING_LEN(str)); goto raise; } if ((stat = yajl_complete_parse(hand)) != yajl_status_ok) { err = yajl_get_error(hand, 1, (unsigned char *)RSTRING_PTR(str), RSTRING_LEN(str)); goto raise; } yajl_free(hand); return rb_ary_pop(rb_ivar_get(self, rb_intern("stack"))); raise: if (hand) { yajl_free(hand); } rb_raise(cParseError, "%s", err); }
/** * Finalise JSON parsing. */ int json_complete(modsec_rec *msr, char **error_msg) { char *json_data = (char *) NULL; if (error_msg == NULL) return -1; *error_msg = NULL; /* Wrap up the parsing process */ msr->json->status = yajl_complete_parse(msr->json->handle); if (msr->json->status != yajl_status_ok) { /* We need to free the yajl error message later, how to do this? */ *error_msg = yajl_get_error(msr->json->handle, 0, NULL, 0); return -1; } return 1; }
struct aws_dynamo_put_item_response * aws_dynamo_parse_put_item_response(const char *response, int response_len, struct aws_dynamo_attribute *attributes, int num_attributes) { yajl_handle hand; yajl_status stat; struct put_item_ctx _ctx = { 0 }; _ctx.r = calloc(sizeof(*(_ctx.r)), 1); if (_ctx.r == NULL) { Warnx("aws_dynamo_parse_put_item_response: response alloc failed."); return NULL; } if (num_attributes > 0) { _ctx.r->attributes = malloc(sizeof(*(_ctx.r->attributes)) * num_attributes); if (_ctx.r->attributes == NULL) { Warnx("aws_dynamo_parse_put_item_response: attribute alloc failed."); free(_ctx.r); return NULL; } memcpy(_ctx.r->attributes, attributes, sizeof(*(attributes)) * num_attributes); _ctx.r->num_attributes = num_attributes; } #if YAJL_MAJOR == 2 hand = yajl_alloc(&put_item_callbacks, NULL, &_ctx); yajl_parse(hand, response, response_len); stat = yajl_complete_parse(hand); #else hand = yajl_alloc(&put_item_callbacks, NULL, NULL, &_ctx); yajl_parse(hand, response, response_len); stat = yajl_parse_complete(hand); #endif if (stat != yajl_status_ok) { unsigned char *str = yajl_get_error(hand, 1, response, response_len); Warnx("aws_dynamo_parse_put_item_response: json parse failed, '%s'", (const char *)str); yajl_free_error(hand, str); yajl_free(hand); aws_dynamo_free_put_item_response(_ctx.r); return NULL; } yajl_free(hand); return _ctx.r; }
static int lyajl_complete_parse (lua_State *L) { yajl_status stat; luvit_parser_t *parser = parser_get(L, 1); /* Process the args */ stat = yajl_complete_parse(parser->handle); /* Unreference the callback */ luaL_unref(L, LUA_REGISTRYINDEX, parser->ref->r); if (stat != yajl_status_ok) { unsigned char * str = yajl_get_error(parser->handle, 1, (const unsigned char*)0, 0); luaL_error(L, (const char *) str); yajl_free_error(parser->handle, str); /* This doesn't actually happen */ } return 0; }
bool run_test(uint32_t* hash_out) { char* data = benchmark_in_situ_copy(file_data, file_size); if (!data) return false; parser_t parser; parser_init(&parser, *hash_out); yajl_handle handle = yajl_alloc(&callbacks, NULL, &parser); yajl_status status = yajl_parse(handle, (const unsigned char*)file_data, file_size); if (status == yajl_status_ok) status = yajl_complete_parse(handle); yajl_free(handle); *hash_out = parser.hash; benchmark_in_situ_free(data); return status == yajl_status_ok; }
SEXP R_validate(SEXP x) { /* get data from R */ const char* json = translateCharUTF8(asChar(x)); /* test for BOM */ if(json[0] == '\xEF' && json[1] == '\xBB' && json[2] == '\xBF'){ SEXP output = PROTECT(duplicate(ScalarLogical(0))); SEXP msg = PROTECT(Rf_mkString("JSON string contains UTF8 byte-order-mark.")); setAttrib(output, install("err"), msg); UNPROTECT(2); return(output); } /* allocate a parser */ yajl_handle hand = yajl_alloc(NULL, NULL, NULL); /* parser options */ //yajl_config(hand, yajl_dont_validate_strings, 1); /* go parse */ const size_t rd = strlen(json); yajl_status stat = yajl_parse(hand, (const unsigned char*) json, rd); if(stat == yajl_status_ok) { stat = yajl_complete_parse(hand); } SEXP output = PROTECT(duplicate(ScalarLogical(!stat))); //error message if (stat != yajl_status_ok) { unsigned char* str = yajl_get_error(hand, 1, (const unsigned char*) json, rd); SEXP errstr = PROTECT(mkString((const char *) str)); SEXP offset = PROTECT(ScalarInteger(yajl_get_bytes_consumed(hand))); yajl_free_error(hand, str); setAttrib(output, install("offset"), offset); setAttrib(output, install("err"), errstr); UNPROTECT(2); } /* return boolean vec (0 means no errors, means is valid) */ yajl_free(hand); UNPROTECT(1); return output; }
/* STRATEGY: * * Each of the js_to_value_callbacks perform these actions: * * [1] Push a new value onto the top of the Lua stack. * * [2] Call the function that was at the top of the Lua stack before * step [1] occurred. * * The purpose of the function call in [2] is to take the value at the * top of the stack and store it in the appropriate location. * Initially, the function is the noop (no operation) function which * does nothing. Therefore we know that the final result is on the * top of the Lua stack. * * The to_value_start_map and to_value_start_array callbacks are * different since they need to use a bit of the Lua stack to store * some state information. When these callbacks are ran, they perform * these actions: * * [a] Push a new table which will represent the final "array" or * "object" onto the top of the Lua stack. * * [b] Allocate space for the "key" (in the case of arrays, this is * the index into the array to use as part of the next insertion) * * [c] Push the got_array_value or got_map_key function. * * The got_array_value function will take the value at the top of the * stack and insert it into the table created in step [a]. It will * then increment the index created in step [b]. As a final step, it * removes the value at the top of the stack. * * The got_map_key function simply takes the value at the top of the * stack and stores it in the space allocated by step [b] above. It * then replaces the function pushed onto the stack by step [c] with * the got_map_value function. As a final step, it removes the value * at the top of the stack. * * The got_map_value function takes the value at the top of the stack * and inserts it into the table created in step [a] with the key * whose space was allocated in step [b]. The function pushed onto * the stack by step [c] is then restored back to the got_map_key * function. As a final step, it removes the value at the top of the * stack. */ static int js_to_value(lua_State *L) { yajl_handle handle; size_t len; const unsigned char* buff = (const unsigned char*) luaL_checklstring(L, 1, &len); if ( NULL == buff ) return 0; handle = yajl_alloc(&js_to_value_callbacks, NULL, (void*)L); lua_pushcfunction(L, noop); if ( lua_istable(L, 2) ) { lua_getfield(L, 2, "allow_comments"); if ( ! lua_isnil(L, -1) ) { yajl_config(handle, yajl_allow_comments, lua_toboolean(L, -1)); } lua_pop(L, 1); lua_getfield(L, 2, "check_utf8"); if ( ! lua_isnil(L, -1) ) { yajl_config(handle, yajl_dont_validate_strings, !lua_toboolean(L, -1)); } lua_pop(L, 1); } js_parser_assert(L, yajl_parse(handle, buff, len), &handle, buff, len, __FILE__, __LINE__); js_parser_assert(L, yajl_complete_parse(handle), &handle, buff, len, __FILE__, __LINE__); yajl_free(handle); return 1; }
bool readJson (const std::string& str) { yajl_handle hand = yajl_alloc(&callbacks, nullptr, nullptr); yajl_status stat = yajl_parse(hand, reinterpret_cast<const unsigned char*>(str.c_str()), str.length()); if (stat != yajl_status_ok && stat != yajl_status_client_canceled) { printError(hand, str); return false; } stat = yajl_complete_parse(hand); if (stat != yajl_status_ok && stat != yajl_status_client_canceled) { printError(hand, str); return false; } yajl_free(hand); return true; }
static void yajl_init(struct json_streamer *json, json_streamer_frame_cb_t fcb, void *userdata, bool reinit) { struct json_streamer_state_ctx *ctx = json->ctx; if (!ctx) ctx = ec_malloc(sizeof(struct json_streamer_state_ctx)); ctx->cur_state = waiting; ctx->frame_callback = fcb; ctx->userdata = userdata; /* Save pointer so that we can free it later in json_streamer_destroy() */ json->ctx = ctx; if (reinit) { yajl_complete_parse(json->yajl); yajl_free(json->yajl); } json->yajl = yajl_alloc(&yajl_cbs, NULL, ctx); }
// Client records will be coming through in alphabetical order. // FIX THIS: If a client is deleted on the server, it is not deleted from // clist. int json_input(struct asfd *asfd, struct sel *sel) { static yajl_handle yajl=NULL; cslist=&sel->clist; sselbu=&sel->backup; sllines=&sel->llines; if(!yajl) { if(!(yajl=yajl_alloc(&callbacks, NULL, NULL))) goto error; yajl_config(yajl, yajl_dont_validate_strings, 1); } if(yajl_parse(yajl, (const unsigned char *)asfd->rbuf->buf, asfd->rbuf->len)!=yajl_status_ok) { do_yajl_error(yajl, asfd); goto error; } if(!map_depth) { // Got to the end of the JSON object. if(!sel->gotfirstresponse) sel->gotfirstresponse=1; if(yajl_complete_parse(yajl)!=yajl_status_ok) { do_yajl_error(yajl, asfd); goto error; } yajl_free(yajl); yajl=NULL; } return 0; error: yajl_free(yajl); yajl=NULL; return -1; }
void nx_json_parse(nx_json_parser_ctx_t *ctx, const char *json, size_t len) { yajl_handle hand; yajl_gen g; g = yajl_gen_alloc(NULL); //yajl_gen_config(g, yajl_gen_validate_utf8, 1); hand = yajl_alloc(&callbacks, NULL, (void *) ctx); yajl_config(hand, yajl_allow_comments, 1); if ( (yajl_parse(hand, (const unsigned char *) json, len) != yajl_status_ok) || (yajl_complete_parse(hand) != yajl_status_ok) ) { unsigned char *errstr = yajl_get_error(hand, 1, (const unsigned char *) json, len); log_error("failed to parse json string, %s [%s]", errstr, json); yajl_free_error(hand, errstr); } yajl_gen_free(g); yajl_free(hand); }
/** * Initiate JSON parsing and print error if one occurs */ static int cconn_process_json(struct cconn *io) { if((io->request_type != ASOK_REQ_DATA) && (io->request_type != ASOK_REQ_SCHEMA)) { return -EDOM; } int result = 1; yajl_handle hand; yajl_status status; hand = yajl_alloc(&callbacks, #if HAVE_YAJL_V2 /* alloc funcs = */ NULL, #else /* alloc funcs = */ NULL, NULL, #endif /* context = */ (void *)(&io->yajl)); if(!hand) { ERROR ("ceph plugin: yajl_alloc failed."); return ENOMEM; } io->yajl.depth = 0; switch(io->request_type) { case ASOK_REQ_DATA: io->yajl.handler = node_handler_fetch_data; result = cconn_process_data(io, &io->yajl, hand); break; case ASOK_REQ_SCHEMA: //init daemon specific variables io->d->ds_num = 0; io->d->last_idx = 0; io->d->last_poll_data = NULL; io->yajl.handler = node_handler_define_schema; io->yajl.handler_arg = io->d; result = traverse_json(io->json, io->json_len, hand); break; } if(result) { goto done; } #if HAVE_YAJL_V2 status = yajl_complete_parse(hand); #else status = yajl_parse_complete(hand); #endif if (status != yajl_status_ok) { unsigned char *errmsg = yajl_get_error (hand, /* verbose = */ 0, /* jsonText = */ NULL, /* jsonTextLen = */ 0); ERROR ("ceph plugin: yajl_parse_complete failed: %s", (char *) errmsg); yajl_free_error (hand, errmsg); yajl_free (hand); return 1; } done: yajl_free (hand); return result; }
int enron_messages_init_fread(FILE *stream, size_t maxrecip, double **time, size_t **from, size_t ***to, size_t **nto, intptr_t **attr, size_t *nmsg) { unsigned char fileData[65536]; size_t rd; yajl_status stat; int parse_ok = 1; struct message_parse parse; message_parse_init(&parse, maxrecip); yajl_handle hand = yajl_alloc(&parse_callbacks, NULL, (void *) &parse); yajl_config(hand, yajl_allow_comments, 1); yajl_config(hand, yajl_dont_validate_strings, 1); for (;;) { rd = fread((void *)fileData, 1, sizeof(fileData) - 1, stream); if (rd == 0) { if (!feof(stream)) { fprintf(stderr, "error on file read.\n"); parse_ok = 0; } break; } fileData[rd] = 0; stat = yajl_parse(hand, fileData, rd); if (stat != yajl_status_ok) break; } stat = yajl_complete_parse(hand); if (stat != yajl_status_ok) { unsigned char * str = yajl_get_error(hand, 1, fileData, rd); fprintf(stderr, "%s", (const char *) str); yajl_free_error(hand, str); parse_ok = 0; } yajl_free(hand); message_parse_deinit(&parse); if (!parse_ok) { size_t i, n = parse.nmsg; for (i = 0; i < n; i++) { free(parse.to[i]); } free(parse.attr); free(parse.nto); free(parse.to); free(parse.from); free(parse.time); } *time = parse.time; *from = parse.from; *to = parse.to; *nto = parse.nto; *attr = parse.attr; *nmsg = parse.nmsg; return parse_ok ? 0 : -1; }
static int run(int validate_utf8) { long long times = 0; double starttime; unsigned long long sumsize = 0; starttime = mygettime(); /* allocate a parser */ for (;;) { int i; { double now = mygettime(); if (now - starttime >= PARSE_TIME_SECS) break; } for (i = 0; i < 100; i++) { yajl_handle hand = yajl_alloc(NULL, NULL, NULL); yajl_status stat; const char ** d; yajl_config(hand, yajl_dont_validate_strings, validate_utf8 ? 0 : 1); for (d = get_doc(times % num_docs()); *d; d++) { size_t size = strlen(*d); sumsize += size; stat = yajl_parse(hand, (unsigned char *) *d, size); if (stat != yajl_status_ok) break; } stat = yajl_complete_parse(hand); if (stat != yajl_status_ok) { unsigned char * str = yajl_get_error(hand, 1, (unsigned char *) *d, (*d ? strlen(*d) : 0)); fprintf(stderr, "%s", (const char *) str); yajl_free_error(hand, str); return 1; } yajl_free(hand); times++; } } /* parsed doc 'times' times */ { double throughput; double now; const char * all_units[] = { "B/s", "KB/s", "MB/s", (char *) 0 }; const char ** units = all_units; now = mygettime(); throughput = sumsize / (now - starttime); while (*(units + 1) && throughput > 1024) { throughput /= 1024; units++; } printf("Parsing speed: %g %s\n", throughput, *units); } return 0; }
Validator* parse_schema_n(char const *str, size_t len, UriResolver *uri_resolver, char const *root_scope, JschemaErrorFunc error_func, void *error_ctxt) { //JsonSchemaParserTrace(stdout, ">>> "); void *parser = JsonSchemaParserAlloc(malloc); YajlContext yajl_context = { .parser = parser, .parser_ctxt = { .validator = NULL, .error = SEC_OK, }, }; const bool allow_comments = true; #if YAJL_VERSION < 20000 yajl_parser_config yajl_opts = { allow_comments, 0, }; yajl_handle yh = yajl_alloc(&callbacks, &yajl_opts, NULL, &yajl_context); #else yajl_handle yh = yajl_alloc(&callbacks, NULL, &yajl_context); yajl_config(yh, yajl_allow_comments, allow_comments ? 1 : 0); yajl_config(yh, yajl_dont_validate_strings, 1); #endif // YAJL_VERSION if (!yh) { JsonSchemaParserFree(parser, free); return NULL; } if (yajl_status_ok != yajl_parse(yh, (const unsigned char *)str, len)) { if (yajl_context.parser_ctxt.error == SEC_OK) { unsigned char *err = yajl_get_error(yh, 0/*verbose*/, (const unsigned char *)str, len); if (error_func) error_func(yajl_get_bytes_consumed(yh), SEC_SYNTAX, (const char *) err, error_ctxt); yajl_free_error(yh, err); } else { if (error_func) error_func(yajl_get_bytes_consumed(yh), yajl_context.parser_ctxt.error, SchemaGetErrorMessage(yajl_context.parser_ctxt.error), error_ctxt); } yajl_free(yh); JsonSchemaParserFree(parser, free); return NULL; } #if YAJL_VERSION < 20000 if (yajl_status_ok != yajl_parse_complete(yh)) #else if (yajl_status_ok != yajl_complete_parse(yh)) #endif { if (yajl_context.parser_ctxt.error == SEC_OK) { unsigned char *err = yajl_get_error(yh, 0, (const unsigned char *)str, len); if (error_func) error_func(yajl_get_bytes_consumed(yh), SEC_SYNTAX, (const char *) err, error_ctxt); yajl_free_error(yh, err); } else { if (error_func) error_func(yajl_get_bytes_consumed(yh), yajl_context.parser_ctxt.error, SchemaGetErrorMessage(yajl_context.parser_ctxt.error), error_ctxt); } yajl_free(yh); JsonSchemaParserFree(parser, free); return NULL; } // Let the parser finish its job. static TokenParam token_param; JsonSchemaParser(parser, 0, token_param, &yajl_context.parser_ctxt); // Even if parsing was completed there can be an error if (!yajl_context.parser_ctxt.error == SEC_OK) { if (error_func) error_func(yajl_get_bytes_consumed(yh), yajl_context.parser_ctxt.error, SchemaGetErrorMessage(yajl_context.parser_ctxt.error), error_ctxt); validator_unref(yajl_context.parser_ctxt.validator); yajl_free(yh); JsonSchemaParserFree(parser, free); return NULL; } yajl_free(yh); JsonSchemaParserFree(parser, free); // Post-parse processing Validator *v = yajl_context.parser_ctxt.validator; // Move parsed features to the validators validator_apply_features(v); // Combine type validator and other validators contaiters (allOf, anyOf, etc.) validator_combine(v); if (uri_resolver) validator_collect_uri(v, root_scope, uri_resolver); // Substitute every SchemaParsing by its type validator for every node // in the AST. Validator *result = validator_finalize_parse(v); // Forget about SchemaParsing then. validator_unref(v); return result; }
struct aws_dynamo_create_table_response *aws_dynamo_parse_create_table_response(const char *response, int response_len) { yajl_handle hand; yajl_status stat; struct ctx _ctx = { 0 }; _ctx.r = calloc(sizeof(*(_ctx.r)), 1); if (_ctx.r == NULL) { Warnx("aws_dynamo_parse_create_table_response: response alloc failed."); return NULL; } #if YAJL_MAJOR == 2 hand = yajl_alloc(&handle_callbacks, NULL, &_ctx); yajl_parse(hand, response, response_len); stat = yajl_complete_parse(hand); #else hand = yajl_alloc(&handle_callbacks, NULL, NULL, &_ctx); yajl_parse(hand, response, response_len); stat = yajl_parse_complete(hand); #endif if (stat != yajl_status_ok) { unsigned char *str = yajl_get_error(hand, 1, response, response_len); Warnx("aws_dynamo_parse_create_table_response: json parse failed, '%s'", (const char *)str); yajl_free_error(hand, str); yajl_free(hand); aws_dynamo_free_create_table_response(_ctx.r); return NULL; } yajl_free(hand); return _ctx.r; }
static SLVAL sl_json_parse(sl_vm_t* vm, SLVAL self, size_t argc, SLVAL* argv) { sl_string_t* str = sl_get_string(vm, argv[0]); json_parse_t json; yajl_alloc_funcs alloc_funcs = { sl_yajl_alloc, sl_yajl_realloc, sl_yajl_free, NULL }; alloc_funcs.ctx = vm->arena; json.vm = vm; json.max_depth = 32; json.stack_len = 0; json.stack_cap = 32; json.stack = sl_alloc(vm->arena, sizeof(SLVAL) * json.stack_cap); json.type_stack = sl_alloc(vm->arena, json.stack_cap); if(argc > 1) { json.max_depth = sl_get_int(sl_expect(vm, argv[1], vm->lib.Int)); } json.yajl = yajl_alloc(&callbacks, &alloc_funcs, &json); sl_json_parse_check_error(vm, str, &json, yajl_parse(json.yajl, str->buff, str->buff_len)); sl_json_parse_check_error(vm, str, &json, yajl_complete_parse(json.yajl)); yajl_free(json.yajl); /* must've been OK! */ return json.stack[0]; (void)self; }