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);
}
static void js_parser_assert(lua_State* L,
yajl_status status,
yajl_handle* handle,
const unsigned char* json_text,
size_t json_text_len,
const char* file,
int line)
{
int verbose = 1;
unsigned char* msg;
switch ( status ) {
case yajl_status_ok:
return;
case yajl_status_client_canceled:
lua_pushfstring(L, "Unreachable: yajl_status_client_canceled should never be returned since all callbacks return true at %s line %d",
file, line);
break;
case yajl_status_error:
msg = yajl_get_error(*handle, verbose, json_text, json_text_len);
lua_pushfstring(L, "InvalidJSONInput: %s at %s line %d", msg, file, line);
yajl_free_error(*handle, msg);
break;
}
lua_error(L);
}
unsigned char *json_get_error(const unsigned char *data_utf8, size_t len)
{
if (*my_error != '\0')
return (unsigned char *)my_error;
return yajl_get_error(parser, 1, data_utf8, len);
}
static size_t cj_curl_callback (void *buf, /* {{{ */
size_t size, size_t nmemb, void *user_data)
{
cj_t *db;
size_t len;
yajl_status status;
len = size * nmemb;
if (len <= 0)
return (len);
db = user_data;
if (db == NULL)
return (0);
status = yajl_parse(db->yajl, (unsigned char *)buf, len);
if (status == yajl_status_ok)
return (len);
#if !HAVE_YAJL_V2
else if (status == yajl_status_insufficient_data)
return (len);
#endif
unsigned char *msg = yajl_get_error(db->yajl, /* verbose = */ 1,
/* jsonText = */ (unsigned char *) buf, (unsigned int) len);
ERROR ("curl_json plugin: yajl_parse failed: %s", msg);
yajl_free_error(db->yajl, msg);
return (0); /* abort write callback */
} /* }}} size_t cj_curl_callback */
static void
_j4status_i3bar_ouput_action(J4statusPluginContext *context, gchar *line)
{
gsize length = strlen(line);
yajl_status json_state;
json_state = yajl_parse(context->json_handle, (const unsigned char *) line, length);
if ( json_state == yajl_status_ok )
return;
g_free(context->parse_context.name);
g_free(context->parse_context.instance);
if ( json_state == yajl_status_error )
{
unsigned char *str_error;
str_error = yajl_get_error(context->json_handle, 0, (const unsigned char *) line, length);
g_warning("Couldn't parse section from i3bar: %s", str_error);
yajl_free_error(context->json_handle, str_error);
}
else if ( json_state == yajl_status_client_canceled )
{
g_warning("i3bar JSON protocol error: %s", context->parse_context.error);
g_free(context->parse_context.error);
}
}
// Yajl Helpers ==============================================================
void yajl_helper_check_status(yajl_handle handle, yajl_status status, int verbose, const unsigned char * jsonText, size_t jsonTextLength) {
if(status != yajl_status_ok) {
unsigned char * str = yajl_get_error(handle, verbose, jsonText, jsonTextLength);
yajl_free_error(handle, str);
rb_raise(rb_const_get(rb_const_get(rb_cObject, rb_intern("Wankel")), rb_intern("ParseError")), "%s", (const char*) str);
}
}
static const char *parse_json(state_t *st, unsigned char *buf, size_t len)
{
yajl_parser_config cfg = {
1, /* allow comments */
0 /* don't check UTF-8 */
};
yajl_handle yh;
yajl_status ys;
const char *err=NULL;
alloc_funcs.ctx = st->env; /* will be passed to alloc funcs */
yh = yajl_alloc(&callbacks, &cfg, &alloc_funcs, st);
ys = yajl_parse(yh, buf, len);
if (ys == yajl_status_insufficient_data) {
ys = yajl_parse_complete(yh);
}
if (ys == yajl_status_insufficient_data) {
err = "unexpected end of document";
} else if (ys != yajl_status_ok) {
unsigned char *msg = yajl_get_error(yh, 0, NULL, 0);
strncpy(st->errmsg, (char *)msg, sizeof(st->errmsg)-1);
yajl_free_error(yh, msg);
st->errmsg[sizeof(st->errmsg)] = 0;
err = st->errmsg;
}
yajl_free(yh);
return err;
}
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 {
std::vector<char> LKStreamTranslator::process(const std::vector<char> &chunk)
{
std::vector<char> retval;
// We work with C strings here, because YAJL
const char *str = chunk.data();
size_t len = chunk.size();
// Abort if the string is empty anyways
if(len == 0)
return retval;
// Skip any BOM if there is one
const unsigned char bom[] = {0xEF, 0xBB, 0xBF};
if(len >= 3 && memcmp(bom, str, 3) == 0)
{
str += 3;
len -= 3;
}
// Abort if it had nothing but a BOM
if(len == 0)
return retval;
// KanColle specific: most datablobs are prefixed with "svdata=", that's
// needed for the game to work, but we can't parse with it left in
const char *svdata = "svdata=";
if(memcmp(svdata, str, (size_t)std::min(strlen(svdata), len)) == 0)
{
str += strlen(svdata);
len -= strlen(svdata);
retval.insert(retval.end(), svdata, svdata + strlen(svdata));
}
if(len > 0)
{
if(yajl_parse(ctx.parser, (const unsigned char *)str, len) != yajl_status_ok)
{
unsigned char *error = yajl_get_error(ctx.parser, true, (const unsigned char *)str, len);
std::string error_string((const char *)error);
yajl_free_error(ctx.parser, error);
throw std::runtime_error("JSON Parsing Error: " + error_string);
}
const unsigned char *buf;
size_t buf_len;
yajl_gen_get_buf(ctx.gen, &buf, &buf_len);
if(buf_len > 0)
{
retval.insert(retval.end(), buf, buf + buf_len);
yajl_gen_clear(ctx.gen);
}
}
return retval;
}
static int cj_curl_perform (cj_t *db, CURL *curl) /* {{{ */
{
int status;
long rc;
char *url;
yajl_handle yprev = db->yajl;
db->yajl = yajl_alloc (&ycallbacks, NULL, NULL, (void *)db);
if (db->yajl == NULL)
{
ERROR ("curl_json plugin: yajl_alloc failed.");
db->yajl = yprev;
return (-1);
}
url = NULL;
curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &url);
status = curl_easy_perform (curl);
if (status != 0)
{
ERROR ("curl_json plugin: curl_easy_perform failed with status %i: %s (%s)",
status, db->curl_errbuf, (url != NULL) ? url : "<null>");
yajl_free (db->yajl);
db->yajl = yprev;
return (-1);
}
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &rc);
/* The response code is zero if a non-HTTP transport was used. */
if ((rc != 0) && (rc != 200))
{
ERROR ("curl_json plugin: curl_easy_perform failed with "
"response code %ld (%s)", rc, url);
yajl_free (db->yajl);
db->yajl = yprev;
return (-1);
}
status = yajl_parse_complete (db->yajl);
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_curl_perform */
static void do_yajl_error(yajl_handle yajl, struct asfd *asfd)
{
unsigned char *str;
str=yajl_get_error(yajl, 1,
(const unsigned char *)asfd->rbuf->buf, asfd->rbuf->len);
logp("yajl error: %s\n", (const char *)str);
yajl_free_error(yajl, str);
}
/* this method can only be called once */
void GetError(const std::string& json, std::string* errout) {
assert(errstring == nullptr);
errstring = yajl_get_error(hand, 1,
(unsigned char*)json.c_str(),
json.length());
*errout = std::string((char*)errstring);
}
/* XXX add an incremental streaming parser - yajl trivially supports it */
virJSONValuePtr virJSONValueFromString(const char *jsonstring)
{
yajl_handle hand;
virJSONParser parser = { NULL, NULL, 0 };
virJSONValuePtr ret = NULL;
# ifndef WITH_YAJL2
yajl_parser_config cfg = { 1, 1 };
# endif
VIR_DEBUG("string=%s", jsonstring);
# ifdef WITH_YAJL2
hand = yajl_alloc(&parserCallbacks, NULL, &parser);
if (hand) {
yajl_config(hand, yajl_allow_comments, 1);
yajl_config(hand, yajl_dont_validate_strings, 0);
}
# else
hand = yajl_alloc(&parserCallbacks, &cfg, NULL, &parser);
# endif
if (!hand) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Unable to create JSON parser"));
goto cleanup;
}
if (yajl_parse(hand,
(const unsigned char *)jsonstring,
strlen(jsonstring)) != yajl_status_ok) {
unsigned char *errstr = yajl_get_error(hand, 1,
(const unsigned char*)jsonstring,
strlen(jsonstring));
virReportError(VIR_ERR_INTERNAL_ERROR,
_("cannot parse json %s: %s"),
jsonstring, (const char*) errstr);
VIR_FREE(errstr);
virJSONValueFree(parser.head);
goto cleanup;
}
ret = parser.head;
cleanup:
yajl_free(hand);
if (parser.nstate) {
size_t i;
for (i = 0; i < parser.nstate; i++) {
VIR_FREE(parser.state[i].key);
}
VIR_FREE(parser.state);
}
VIR_DEBUG("result=%p", parser.head);
return ret;
}
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);
}
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;
}
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;
}
void yajl_parse_chunk(const unsigned char * chunk, unsigned int len, yajl_handle parser) {
yajl_status stat;
stat = yajl_parse(parser, chunk, len);
if (stat != yajl_status_ok && stat != yajl_status_insufficient_data) {
unsigned char * str = yajl_get_error(parser, 1, chunk, len);
rb_raise(cParseError, "%s", (const char *) str);
yajl_free_error(parser, str);
}
}
unsigned char *json_streamer_get_last_error(struct json_streamer *json,
unsigned char *data, size_t size)
{
if (!json || !json->yajl || !data || !size)
return false;
return yajl_get_error(json->yajl,
1,
data,
size);
}
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 */
int parseSampleFromFile(Sample *sample, FILE *inputFile) {
yajl_handle hand;
static unsigned char fileData[READ_BUFFER_SIZE];
ParseContext g;
g.sample = sample;
yajl_status stat;
size_t rd;
/* allow comments */
yajl_parser_config cfg = { 1, 1 };
int retval = 1, done = 0;
/* ok. open file. let's read and parse */
hand = yajl_alloc(&callbacks, &cfg, NULL, (void *) &g);
while (!done) {
rd = fread((void *) fileData, 1, sizeof(fileData) - 1, inputFile);
if (rd == 0) {
if (!feof(inputFile)) {
fprintf(stderr, "error on file read.\n");
retval = 0;
break;
}
done = 1;
}
fileData[rd] = 0;
if (done)
/* parse any remaining buffered data */
stat = yajl_parse_complete(hand);
else
/* read file data, pass to parser */
stat = yajl_parse(hand, fileData, rd);
if (stat != yajl_status_ok &&
stat != yajl_status_insufficient_data)
{
unsigned char * str = yajl_get_error(hand, 1, fileData, rd);
fprintf(stderr, "%s", (const char *) str);
yajl_free_error(hand, str);
retval = 0;
if( stat == yajl_status_client_canceled) {
fprintf(stderr, "%s\n", g.lastError);
}
break;
}
}
yajl_free(hand);
return retval;
}
void reformat(ErlDrvPort port, char* buf, int len)
{
yajl_handle hand;
/* generator config */
yajl_gen_config conf = { 1, " " };
yajl_gen g;
yajl_status stat;
/* allow comments */
yajl_parser_config cfg = { 1, 1 };
g = yajl_gen_alloc(&conf, NULL);
/* ok. open file. let's read and parse */
hand = yajl_alloc(&callbacks, &cfg, NULL, (void *) g);
/* read file data, pass to parser */
stat = yajl_parse(hand, (unsigned char*) buf, len);
if (stat != yajl_status_ok &&
stat != yajl_status_insufficient_data)
{
char* err = (char*) yajl_get_error(hand, 1, (unsigned char*) buf, len);
int len = strlen(err);
ErlDrvTermData msg[] = {
ERL_DRV_ATOM, driver_mk_atom("error"),
ERL_DRV_BUF2BINARY, (ErlDrvTermData) err, (ErlDrvUInt) len,
ERL_DRV_TUPLE, 2
};
driver_send_term(port, driver_caller(port), msg, sizeof(msg) / sizeof(msg[0]));
} else {
const unsigned char* json;
unsigned int len;
yajl_gen_get_buf(g, &json, &len);
ErlDrvTermData msg[] = {
ERL_DRV_ATOM, driver_mk_atom("ok"),
ERL_DRV_BUF2BINARY, (ErlDrvTermData) json, (ErlDrvUInt) len,
ERL_DRV_TUPLE, 2
};
driver_send_term(port, driver_caller(port), msg, sizeof(msg) / sizeof(msg[0]));
yajl_gen_clear(g);
}
yajl_gen_free(g);
yajl_free(hand);
}
/**
* Feed one chunk of data to the JSON parser.
*/
int json_process_chunk(modsec_rec *msr, const char *buf, unsigned int size, char **error_msg) {
if (error_msg == NULL) return -1;
*error_msg = NULL;
/* Feed our parser and catch any errors */
msr->json->status = yajl_parse(msr->json->handle, buf, size);
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, buf, size);
return -1;
}
return 1;
}
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);
}
}
/*
* 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);
}
int main(int argc, char ** argv)
{
yajl_handle hand;
yajl_status stat;
yajl_parser_config cfg = { 1, 1 };
int done = 0;
hand = yajl_alloc(&callbacks, &cfg, NULL, (void *) g);
while (!done) {
rd = fread((void *) fileData, 1, sizeof(fileData) - 1, stdin);
if (rd == 0) {
if (!feof(stdin)) {
fprintf(stderr, "error on file read.\n");
break;
}
done = 1;
}
fileData[rd] = 0;
if (done)
/* parse any remaining buffered data */
stat = yajl_parse_complete(hand);
else
/* read file data, pass to parser */
stat = yajl_parse(hand, fileData, rd);
if (stat != yajl_status_ok &&
stat != yajl_status_insufficient_data)
{
unsigned char * str = yajl_get_error(hand, 1, fileData, rd);
fprintf(stderr, (const char *) str);
yajl_free_error(hand, str);
} else {
const unsigned char * buf;
unsigned int len;
yajl_gen_get_buf(g, &buf, &len);
fwrite(buf, 1, len, stdout);
yajl_gen_clear(g);
}
}
yajl_gen_free(g);
yajl_free(hand);
return 0;
}
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;
}
/**
* 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;
}
/**
* Read JSON data and parse it using the given YAJL parser.
* @param url URL of the JSON data.
* @param hand YAJL parser handle.
* @return -1 on error, 0 on success.
*/
static int
soundcloud_parse_json(const char *url, yajl_handle hand, GMutex* mutex, GCond* cond)
{
struct input_stream *input_stream;
GError *error = NULL;
char buffer[4096];
unsigned char *ubuffer = (unsigned char *)buffer;
size_t nbytes;
input_stream = input_stream_open(url, mutex, cond, &error);
if (input_stream == NULL) {
if (error != NULL) {
g_warning("%s", error->message);
g_error_free(error);
}
return -1;
}
g_mutex_lock(mutex);
input_stream_wait_ready(input_stream);
yajl_status stat;
int done = 0;
while (!done) {
nbytes = input_stream_read(input_stream, buffer, sizeof(buffer), &error);
if (nbytes == 0) {
if (error != NULL) {
g_warning("%s", error->message);
g_error_free(error);
}
if (input_stream_eof(input_stream)) {
done = true;
} else {
g_mutex_unlock(mutex);
input_stream_close(input_stream);
return -1;
}
}
if (done)
stat = yajl_parse_complete(hand);
else
stat = yajl_parse(hand, ubuffer, nbytes);
if (stat != yajl_status_ok &&
stat != yajl_status_insufficient_data)
{
unsigned char *str = yajl_get_error(hand, 1, ubuffer, nbytes);
g_warning("%s", str);
yajl_free_error(hand, str);
break;
}
}
g_mutex_unlock(mutex);
input_stream_close(input_stream);
return 0;
}
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;
}
void json_parse_to_ei(ErlDrvData session, const unsigned char* s, int len, int opts) {
int parseValue = opts & EEP0018_PARSE_VALUE;
unsigned char* yajl_msg = 0;
unsigned char* msg = 0;
ErlDrvPort port = (ErlDrvPort) session;
/*
* initialize yajl parser
*/
State state;
init(&state, opts);
yajl_parser_config conf = { YAJL_ALLOW_COMMENTS }; // , YAJL_CHECK_UTF8 };
yajl_handle handle = yajl_alloc(&callbacks, &conf, &state);
/* start parser */
yajl_status stat;
if(parseValue) stat = yajl_parse(handle, (const unsigned char*) "[ ", 2);
stat = yajl_parse(handle, s, len);
if(parseValue) stat = yajl_parse(handle, (const unsigned char*) " ]", 2);
/*
* sometimes the parser is still stuck inside a JSON token. This finishs
* the token no matter what.
*/
if(stat == yajl_status_insufficient_data)
stat = yajl_parse(handle, (const unsigned char*) " ", 1);
/*
* get an error message on errors
*/
switch(stat) {
case yajl_status_ok: break;
case yajl_status_insufficient_data:
msg = (unsigned char*)"Insufficient data";
break;
default:
msg = yajl_msg = yajl_get_error(handle, 0, s, len);
break;
}
/*
* if result is not ok: we write {error, "reason"} instead. This is
* something that will never be encoded from any JSON data.
*/
if(msg) {
ei_x_free(&state.ei_buf);
ei_x_new_with_version(&state.ei_buf);
ei_x_encode_tuple_header(&state.ei_buf, 2);
ei_x_encode_atom_len(&state.ei_buf, "error", 5);
ei_x_encode_string_len(&state.ei_buf, (const char*) msg, strlen((const char*) msg));
if(yajl_msg) yajl_free_error(yajl_msg);
}
send_data(port, EEP0018_EI, state.ei_buf.buff, state.ei_buf.index);
deinit(&state);
}