static int lyajl_gen_config (lua_State *L) {
const char *option;
luv_ref_t* ref;
luvit_generator_t *generator = generator_get(L, 1);
option = luaL_checkstring(L, 2);
if (strcmp(option, "beautify") == 0) {
yajl_gen_config(generator->gen, yajl_gen_beautify, lua_toboolean(L, 3));
} else if (strcmp(option, "indent_string") == 0) {
yajl_gen_config(generator->gen, yajl_gen_indent_string, luaL_checkstring(L, 3));
} else if (strcmp(option, "print_callback") == 0) {
if (lua_isfunction (L, 3) == 0) {
luaL_error(L, "Print callback config must be a function");
}
ref = (luv_ref_t*)malloc(sizeof(luv_ref_t));
ref->L = L;
lua_pushvalue(L, 3);
ref->r = luaL_ref(L, LUA_REGISTRYINDEX);
yajl_gen_config(generator->gen, yajl_gen_print_callback, lyajl_gen_on_print, (void*)ref);
} else if (strcmp(option, "validate_utf8") == 0) {
yajl_gen_config(generator->gen, yajl_gen_validate_utf8, lua_toboolean(L, 3));
} else if (strcmp(option, "escape_solidus") == 0) {
yajl_gen_config(generator->gen, yajl_gen_escape_solidus, lua_toboolean(L, 3));
} else {
luaL_error(L, "Invalid configuration option %s", option);
}
return 0;
}
json_writer::json_writer(boost::shared_ptr<output_buffer> &out, bool indent)
: pimpl(new pimpl_()) {
#ifdef HAVE_YAJL2
pimpl->gen = yajl_gen_alloc(NULL);
#else /* older version of YAJL */
// setup whether the generator should produce pretty output
if (indent) {
pimpl->config.beautify = 1;
pimpl->config.indentString = " ";
} else {
pimpl->config.beautify = 0;
pimpl->config.indentString = "";
}
pimpl->gen = yajl_gen_alloc2(&wrap_write, &pimpl->config, NULL, out.get());
#endif /* HAVE_YAJL2 */
if (pimpl->gen == 0) {
throw std::runtime_error("error creating json writer.");
}
#ifdef HAVE_YAJL2
if (indent) {
yajl_gen_config(pimpl->gen, yajl_gen_beautify, 1);
yajl_gen_config(pimpl->gen, yajl_gen_indent_string, " ");
} else {
yajl_gen_config(pimpl->gen, yajl_gen_beautify, 0);
yajl_gen_config(pimpl->gen, yajl_gen_indent_string, "");
}
yajl_gen_config(pimpl->gen, yajl_gen_print_callback, &wrap_write,
(void *)out.get());
#endif /* HAVE_YAJL2 */
}
static bool convert(options_t* options) {
FILE* in_file;
if (options->in_filename) {
in_file = fopen(options->in_filename, "rb");
if (in_file == NULL) {
fprintf(stderr, "%s: could not open \"%s\" for reading.\n", options->command, options->in_filename);
return false;
}
} else {
in_file = stdin;
}
if (options->out_filename) {
out_file = fopen(options->out_filename, "wb");
if (out_file == NULL) {
fprintf(stderr, "%s: could not open \"%s\" for writing.\n", options->command, options->out_filename);
if (in_file != stdin)
fclose(in_file);
return false;
}
} else {
out_file = stdout;
}
yajl_gen gen = yajl_gen_alloc(NULL);
if (options->pretty)
yajl_gen_config(gen, yajl_gen_beautify);
if (options->debug)
yajl_gen_config(gen, yajl_gen_allow_non_string_keys);
yajl_gen_config(gen, yajl_gen_print_callback, print, out_file);
mpack_reader_t reader;
mpack_reader_init_stack(&reader);
mpack_reader_set_fill(&reader, fill);
mpack_reader_set_context(&reader, in_file);
bool ret = element(&reader, gen, options, 0);
mpack_error_t error = mpack_reader_destroy(&reader);
yajl_gen_free(gen);
if (out_file != stdout)
fclose(out_file);
if (in_file != stdin)
fclose(in_file);
if (!ret || error != mpack_ok)
fprintf(stderr, "%s: parse error %i\n", options->command, (int)error);
return ret;
}
char *virJSONValueToString(virJSONValuePtr object,
bool pretty)
{
yajl_gen g;
const unsigned char *str;
char *ret = NULL;
yajl_size_t len;
# ifndef WITH_YAJL2
yajl_gen_config conf = { pretty ? 1 : 0, pretty ? " " : " "};
# endif
VIR_DEBUG("object=%p", object);
# ifdef WITH_YAJL2
g = yajl_gen_alloc(NULL);
if (g) {
yajl_gen_config(g, yajl_gen_beautify, pretty ? 1 : 0);
yajl_gen_config(g, yajl_gen_indent_string, pretty ? " " : " ");
yajl_gen_config(g, yajl_gen_validate_utf8, 1);
}
# else
g = yajl_gen_alloc(&conf, NULL);
# endif
if (!g) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Unable to create JSON formatter"));
goto cleanup;
}
if (virJSONValueToStringOne(object, g) < 0) {
virReportOOMError();
goto cleanup;
}
if (yajl_gen_get_buf(g, &str, &len) != yajl_gen_status_ok) {
virReportOOMError();
goto cleanup;
}
ignore_value(VIR_STRDUP(ret, (const char *)str));
cleanup:
yajl_gen_free(g);
VIR_DEBUG("result=%s", NULLSTR(ret));
return ret;
}
char *virJSONValueToString(virJSONValuePtr object)
{
yajl_gen g;
const unsigned char *str;
char *ret = NULL;
yajl_size_t len;
# ifndef HAVE_YAJL2
yajl_gen_config conf = { 0, " " }; /* Turns off pretty printing since QEMU can't cope */
# endif
VIR_DEBUG("object=%p", object);
# ifdef HAVE_YAJL2
g = yajl_gen_alloc(NULL);
if (g) {
yajl_gen_config(g, yajl_gen_beautify, 0);
yajl_gen_config(g, yajl_gen_indent_string, " ");
yajl_gen_config(g, yajl_gen_validate_utf8, 1);
}
# else
g = yajl_gen_alloc(&conf, NULL);
# endif
if (!g) {
virJSONError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Unable to create JSON formatter"));
goto cleanup;
}
if (virJSONValueToStringOne(object, g) < 0) {
virReportOOMError();
goto cleanup;
}
if (yajl_gen_get_buf(g, &str, &len) != yajl_gen_status_ok) {
virReportOOMError();
goto cleanup;
}
if (!(ret = strdup((const char *)str)))
virReportOOMError();
cleanup:
yajl_gen_free(g);
VIR_DEBUG("result=%s", NULLSTR(ret));
return ret;
}
ngx_http_tfs_json_gen_t *
ngx_http_tfs_json_init(ngx_log_t *log, ngx_pool_t *pool)
{
yajl_gen g;
ngx_http_tfs_json_gen_t *tj_gen;
g = yajl_gen_alloc(NULL);
if (g == NULL) {
ngx_log_error(NGX_LOG_ERR, log, errno, "alloc yajl_gen failed");
return NULL;
}
tj_gen = ngx_pcalloc(pool, sizeof(ngx_http_tfs_json_gen_t));
if (tj_gen == NULL) {
return NULL;
}
yajl_gen_config(g, yajl_gen_beautify, 1);
tj_gen->gen = g;
tj_gen->pool = pool;
tj_gen->log = log;
return tj_gen;
}
IoYajlGen *IoYajlGen_proto(void *state)
{
IoYajlGen *self = IoObject_new(state);
IoObject_tag_(self, IoYajlGen_newTag(state));
yajl_gen g = yajl_gen_alloc(NULL);
yajl_gen_config(g, yajl_gen_beautify, 0);
IoObject_setDataPointer_(self, g);
IoState_registerProtoWithFunc_(state, self, IoYajlGen_proto);
{
IoMethodTable methodTable[] =
{
{"pushNull", IoYajlGen_pushNull},
{"pushString", IoYajlGen_pushString},
{"pushInteger", IoYajlGen_pushInteger},
{"pushDouble", IoYajlGen_pushDouble},
{"pushNumberString", IoYajlGen_pushNumberString},
{"pushBool", IoYajlGen_pushBool},
{"openMap", IoYajlGen_openMap},
{"closeMap", IoYajlGen_closeMap},
{"openArray", IoYajlGen_openArray},
{"closeArray", IoYajlGen_closeArray},
{"generate", IoYajlGen_generate},
{NULL, NULL},
};
IoObject_addMethodTable_(self, methodTable);
}
return self;
}
/*
* Format (prometheus/alertmanager v1):
*
* [{
* "labels": {
* "alertname": "collectd_cpu",
* "instance": "host.example.com",
* "severity": "FAILURE",
* "service": "collectd",
* "cpu": "0",
* "type": "wait"
* },
* "annotations": {
* "summary": "...",
* // meta
* },
* "startsAt": <rfc3339 time>,
* "endsAt": <rfc3339 time>, // not used
* }]
*/
int format_json_notification(char *buffer, size_t buffer_size, /* {{{ */
notification_t const *n) {
yajl_gen g;
unsigned char const *out;
#if HAVE_YAJL_V2
size_t unused_out_len;
#else
unsigned int unused_out_len;
#endif
if ((buffer == NULL) || (n == NULL))
return EINVAL;
#if HAVE_YAJL_V2
g = yajl_gen_alloc(NULL);
if (g == NULL)
return -1;
#if COLLECT_DEBUG
yajl_gen_config(g, yajl_gen_beautify, 1);
yajl_gen_config(g, yajl_gen_validate_utf8, 1);
#endif
#else /* !HAVE_YAJL_V2 */
yajl_gen_config conf = {0};
#if COLLECT_DEBUG
conf.beautify = 1;
conf.indentString = " ";
#endif
g = yajl_gen_alloc(&conf, NULL);
if (g == NULL)
return -1;
#endif
if (format_alert(g, n) != 0) {
yajl_gen_clear(g);
yajl_gen_free(g);
return -1;
}
/* copy to output buffer */
yajl_gen_get_buf(g, &out, &unused_out_len);
sstrncpy(buffer, (void *)out, buffer_size);
yajl_gen_clear(g);
yajl_gen_free(g);
return 0;
} /* }}} format_json_notification */
static VALUE mEncoder_do_yajl_encode(VALUE self, VALUE obj, VALUE yajl_gen_opts, VALUE json_opts) {
ID sym_ffi_yajl = rb_intern("ffi_yajl");
VALUE sym_yajl_gen_beautify = ID2SYM(rb_intern("yajl_gen_beautify"));
VALUE sym_yajl_gen_validate_utf8 = ID2SYM(rb_intern("yajl_gen_validate_utf8"));
VALUE sym_yajl_gen_indent_string = ID2SYM(rb_intern("yajl_gen_indent_string"));
yajl_gen yajl_gen;
const unsigned char *buf;
size_t len;
VALUE state;
VALUE ret;
VALUE indent_string;
VALUE rb_yajl_gen;
yajl_gen = yajl_gen_alloc(NULL);
if ( rb_hash_aref(yajl_gen_opts, sym_yajl_gen_beautify) == Qtrue ) {
yajl_gen_config(yajl_gen, yajl_gen_beautify, 1);
}
if ( rb_hash_aref(yajl_gen_opts, sym_yajl_gen_validate_utf8) == Qtrue ) {
yajl_gen_config(yajl_gen, yajl_gen_validate_utf8, 1);
}
indent_string = rb_hash_aref(yajl_gen_opts, sym_yajl_gen_indent_string);
if (indent_string != Qnil) {
yajl_gen_config(yajl_gen, yajl_gen_indent_string, RSTRING_PTR(indent_string));
} else {
yajl_gen_config(yajl_gen, yajl_gen_indent_string, " ");
}
state = rb_hash_new();
rb_hash_aset(state, rb_str_new2("processing_key"), Qfalse);
rb_hash_aset(state, rb_str_new2("json_opts"), json_opts);
rb_yajl_gen = Data_Wrap_Struct(cYajl_Gen, NULL, NULL, yajl_gen);
rb_funcall(obj, sym_ffi_yajl, 2, rb_yajl_gen, state);
yajl_gen_get_buf(yajl_gen, &buf, &len);
ret = rb_str_new2((char *)buf);
yajl_gen_free(yajl_gen);
return ret;
}
IoYajlGen *IoYajlGen_rawClone(IoYajlGen *proto)
{
IoObject *self = IoObject_rawClonePrimitive(proto);
yajl_gen g = yajl_gen_alloc(NULL);
yajl_gen_config(g, yajl_gen_beautify, 0);
IoObject_setDataPointer_(self, g);
return self;
}
static int json_start(struct asfd *asfd)
{
if(!yajl)
{
if(!(yajl=yajl_gen_alloc(NULL)))
return -1;
yajl_gen_config(yajl, yajl_gen_beautify, pretty_print);
}
if(yajl_map_open_w()) return -1;
return 0;
}
TEST_F(Yajl, yajl_gen_beautify) {
for (size_t i = 0; i < kTrialCount; i++) {
yajl_gen g = yajl_gen_alloc(NULL);
yajl_gen_config(g, yajl_gen_beautify, 1);
yajl_gen_config(g, yajl_gen_indent_string, " ");
yajl_gen_status status = GenVal(g, root_);
if (status != yajl_gen_status_ok) {
std::cout << "gen error: " << status << std::endl;
FAIL();
}
const unsigned char * buf;
size_t len;
status = yajl_gen_get_buf(g, &buf, &len);
ASSERT_EQ(yajl_gen_status_ok, status);
//if (i == 0)
// std::cout << len << std::endl;
yajl_gen_free(g);
}
}
yajl_gen bson_to_yajl(bson *b)
{
bson_iterator it[1];
bson_iterator_init( it, b );
yajl_gen g = yajl_gen_alloc( NULL );
yajl_gen_config( g, yajl_gen_beautify, 1 );
json_from_bson_object( &g, it );
return g;
}
void writejson(FILE * out, char *stamp, char *line, size_t len, int fragment)
{
yajl_gen g;
const unsigned char *buf;
size_t buflen;
g = yajl_gen_alloc(NULL);
yajl_gen_config(g, yajl_gen_beautify, 0);
yajl_gen_config(g, yajl_gen_validate_utf8, 1);
chk(yajl_gen_map_open(g));
chk(yajl_gen_string(g, (const unsigned char *)"timestamp", 9));
chk(yajl_gen_string(g, (const unsigned char *)stamp, TIMESTAMP));
chk(yajl_gen_string(g, (const unsigned char *)"message", 7));
chk(yajl_gen_string(g, (const unsigned char *)line, len));
if (fragment >= 0) {
char fragmentStr[30];
snprintf(fragmentStr, 30, "%d", fragment);
chk(yajl_gen_string(g, (const unsigned char *)"fragmentId", 10));
chk(yajl_gen_number(g, fragmentStr, strlen(fragmentStr)));
}
chk(yajl_gen_map_close(g));
yajl_gen_get_buf(g, &buf, &buflen);
fwrite(buf, 1, buflen, out);
yajl_gen_clear(g);
yajl_gen_free(g);
putc('\n', out);
}
IoObject *IoYajlGen_generate(IoYajlGen *self, IoObject *locals, IoMessage *m)
{
const unsigned char *jsonBuffer;
size_t jsonBufferLength;
yajl_gen_get_buf(DATA(self), &jsonBuffer, &jsonBufferLength);
IoSeq *out = IOSEQ(jsonBuffer, jsonBufferLength);
yajl_gen_free(DATA(self));
yajl_gen g = yajl_gen_alloc(NULL);
yajl_gen_config(g, yajl_gen_beautify, 0);
IoObject_setDataPointer_(self, g);
return out;
}
/* Encode an IB list into JSON */
ib_status_t ib_json_encode(
ib_mpool_t *mpool,
const ib_list_t *list,
bool pretty,
char **obuf,
size_t *olen)
{
assert(mpool != NULL);
assert(list != NULL);
assert(obuf != NULL);
yajl_gen handle;
json_yajl_alloc_context_t alloc_ctx = { mpool, IB_OK };
ib_status_t rc;
yajl_gen_status status;
yajl_alloc_funcs alloc_fns = {
json_yajl_alloc,
json_yajl_realloc,
json_yajl_free,
&alloc_ctx
};
handle = yajl_gen_alloc(&alloc_fns);
/* Probably should validate the handle here, but it's not clear from the
* YAJL documentation how to do that */
/* Set pretty option */
if (pretty) {
int opt = yajl_gen_config(handle, yajl_gen_beautify);
if (opt == 0) {
return IB_EINVAL;
}
}
rc = encode_list(handle, NULL, 0, list);
if (rc != IB_OK) {
return rc;
}
status = yajl_gen_get_buf(handle, (const unsigned char **)obuf, olen);
if (status != yajl_gen_status_ok) {
return IB_EUNKNOWN;
}
return rc;
}
void
rb_journalist_socket_init() {
gen = yajl_gen_alloc(NULL);
yajl_gen_config(gen, yajl_gen_beautify, 0);
pid_t pid = getpid();
char path[1024];
snprintf(
path,
1024,
journalist_file_path_fmt,
pid
);
journalist_file = fopen(path, "w");
}
void yajl_gen_configure(yajl_gen g, VALUE options) {
if(rb_hash_aref(options, sym_beautify) == Qtrue) {
yajl_gen_config(g, yajl_gen_beautify, 1);
} else {
yajl_gen_config(g, yajl_gen_beautify, 0);
}
yajl_gen_config(g, yajl_gen_indent_string, RSTRING_PTR(rb_hash_aref(options, sym_indent_string)));
if(rb_hash_aref(options, sym_validate_utf8) == Qtrue) {
yajl_gen_config(g, yajl_gen_validate_utf8, 1);
} else {
yajl_gen_config(g, yajl_gen_validate_utf8, 0);
}
if(rb_hash_aref(options, sym_escape_solidus ) == Qtrue) {
yajl_gen_config(g, yajl_gen_escape_solidus, 1);
} else {
yajl_gen_config(g, yajl_gen_escape_solidus, 0);
}
}
static int convert(BlogRef const blog,
SLNSessionRef const session,
char const *const htmlpath,
SLNSubmissionRef *const outmeta,
strarg_t const URI,
SLNFileInfo const *const src,
BlogTypeCheck const types,
BlogConverter const converter)
{
int rc = types(src->type);
if(rc < 0) return UV_EINVAL;
str_t *tmp = NULL;
uv_file html = -1;
uv_file file = -1;
char const *buf = NULL;
SLNSubmissionRef meta = NULL;
yajl_gen json = NULL;
tmp = SLNRepoCopyTempPath(blog->repo);
if(!tmp) rc = UV_ENOMEM;
if(rc < 0) goto cleanup;
rc = async_fs_open_mkdirp(tmp, O_CREAT | O_EXCL | O_WRONLY, 0400);
if(rc < 0) goto cleanup;
html = rc;
rc = async_fs_open(src->path, O_RDONLY, 0000);
if(rc < 0) goto cleanup;
file = rc;
// We use size+1 to get nul-termination. Kind of a hack.
buf = mmap(NULL, src->size+1, PROT_READ, MAP_SHARED, file, 0);
if(MAP_FAILED == buf) rc = -errno;
if(rc < 0) goto cleanup;
if('\0' != buf[src->size]) rc = UV_EIO; // Slightly paranoid.
if(rc < 0) goto cleanup;
async_fs_close(file); file = -1;
if(outmeta) {
rc = SLNSubmissionCreate(session, NULL, URI, &meta);
if(rc < 0) goto cleanup;
rc = SLNSubmissionSetType(meta, SLN_META_TYPE);
if(rc < 0) goto cleanup;
}
SLNSubmissionWrite(meta, (byte_t const *)URI, strlen(URI));
SLNSubmissionWrite(meta, (byte_t const *)STR_LEN("\n\n"));
json = yajl_gen_alloc(NULL);
if(!json) rc = UV_ENOMEM;
if(rc < 0) goto cleanup;
yajl_gen_config(json, yajl_gen_print_callback, (void (*)())SLNSubmissionWrite, meta);
yajl_gen_config(json, yajl_gen_beautify, (int)true);
async_pool_enter(NULL);
yajl_gen_map_open(json);
rc = converter(html, json, buf, src->size, src->type);
yajl_gen_map_close(json);
async_pool_leave(NULL);
if(rc < 0) goto cleanup;
rc = async_fs_fdatasync(html);
if(rc < 0) goto cleanup;
rc = async_fs_link_mkdirp(tmp, htmlpath);
if(rc < 0) goto cleanup;
rc = SLNSubmissionEnd(meta);
if(rc < 0) goto cleanup;
if(outmeta) {
*outmeta = meta; meta = NULL;
}
cleanup:
async_fs_unlink(tmp); FREE(&tmp);
if(html >= 0) { async_fs_close(html); html = -1; }
if(file >= 0) { async_fs_close(file); file = -1; }
if(buf) { munmap((void *)buf, src->size+1); buf = NULL; }
if(json) { yajl_gen_free(json); json = NULL; }
SLNSubmissionFree(&meta);
assert(html < 0);
assert(file < 0);
return rc;
}
static int POST_post(BlogRef const blog,
SLNSessionRef const session,
HTTPConnectionRef const conn,
HTTPMethod const method,
strarg_t const URI,
HTTPHeadersRef const headers)
{
if(HTTP_POST != method) return -1;
if(0 != uripathcmp("/post", URI, NULL)) return -1;
// TODO: CSRF token
strarg_t const formtype = HTTPHeadersGet(headers, "content-type");
uv_buf_t boundary[1];
int rc = MultipartBoundaryFromType(formtype, boundary);
if(rc < 0) return 400;
MultipartFormRef form = NULL;
rc = MultipartFormCreate(conn, boundary, &form);
if(rc < 0) {
return 500;
}
SLNSubmissionRef sub = NULL;
SLNSubmissionRef meta = NULL;
str_t *title = NULL;
rc = parse_file(blog, session, form, &sub, &meta, &title);
if(UV_EACCES == rc) {
MultipartFormFree(&form);
return 403;
}
if(rc < 0) {
MultipartFormFree(&form);
return 500;
}
SLNSubmissionRef extra = NULL;
yajl_gen json = NULL;
str_t *target_QSEscaped = NULL;
str_t *location = NULL;
strarg_t const target = SLNSubmissionGetPrimaryURI(sub);
if(!target) rc = UV_ENOMEM;
if(rc < 0) goto cleanup;
target_QSEscaped = QSEscape(target, strlen(target), true);
if(!target_QSEscaped) rc = UV_ENOMEM;
if(rc < 0) goto cleanup;
rc = SLNSubmissionCreate(session, NULL, target, &extra);
if(rc < 0) goto cleanup;
rc = SLNSubmissionSetType(extra, SLN_META_TYPE);
if(rc < 0) goto cleanup;
SLNSubmissionWrite(extra, (byte_t const *)target, strlen(target));
SLNSubmissionWrite(extra, (byte_t const *)STR_LEN("\n\n"));
json = yajl_gen_alloc(NULL);
if(!json) rc = UV_ENOMEM;
if(rc < 0) goto cleanup;
yajl_gen_config(json, yajl_gen_print_callback, (void (*)())SLNSubmissionWrite, extra);
yajl_gen_config(json, yajl_gen_beautify, (int)true);
yajl_gen_map_open(json);
if(title) {
yajl_gen_string(json, (unsigned char const *)STR_LEN("title"));
yajl_gen_string(json, (unsigned char const *)title, strlen(title));
}
// TODO: Comment or description?
strarg_t const username = SLNSessionGetUsername(session);
if(username) {
yajl_gen_string(json, (unsigned char const *)STR_LEN("submitter-name"));
yajl_gen_string(json, (unsigned char const *)username, strlen(username));
}
strarg_t const reponame = SLNRepoGetName(blog->repo);
if(reponame) {
yajl_gen_string(json, (unsigned char const *)STR_LEN("submitter-repo"));
yajl_gen_string(json, (unsigned char const *)reponame, strlen(reponame));
}
time_t const now = time(NULL);
struct tm t[1];
gmtime_r(&now, t); // TODO: Error checking?
str_t tstr[31+1];
size_t const tlen = strftime(tstr, sizeof(tstr), "%FT%TZ", t); // ISO 8601
if(tlen) {
yajl_gen_string(json, (unsigned char const *)STR_LEN("submission-time"));
yajl_gen_string(json, (unsigned char const *)tstr, tlen);
}
yajl_gen_string(json, (unsigned char const *)STR_LEN("submission-software"));
yajl_gen_string(json, (unsigned char const *)STR_LEN("StrongLink Blog"));
str_t *fulltext = aasprintf("%s\n%s",
title ?: "",
NULL ?: ""); // TODO: Description, GNU-ism
if(fulltext) {
yajl_gen_string(json, (unsigned char const *)STR_LEN("fulltext"));
yajl_gen_string(json, (unsigned char const *)fulltext, strlen(fulltext));
}
FREE(&fulltext);
yajl_gen_map_close(json);
rc = SLNSubmissionEnd(extra);
if(rc < 0) goto cleanup;
SLNSubmissionRef subs[] = { sub, meta, extra };
rc = SLNSubmissionStoreBatch(subs, numberof(subs));
location = aasprintf("/?q=%s", target_QSEscaped);
if(!location) rc = UV_ENOMEM;
if(rc < 0) goto cleanup;
HTTPConnectionSendRedirect(conn, 303, location);
cleanup:
if(json) { yajl_gen_free(json); json = NULL; }
FREE(&title);
SLNSubmissionFree(&sub);
SLNSubmissionFree(&meta);
SLNSubmissionFree(&extra);
MultipartFormFree(&form);
FREE(&target_QSEscaped);
FREE(&location);
if(rc < 0) return 500;
return 0;
}
axa_json_res_t
axa_body_to_json(axa_emsg_t *emsg, nmsg_input_t nmsg_input, axa_p_hdr_t *hdr, axa_p_body_t *body, size_t body_len, char **out)
{
struct axa_strbuf *sb = NULL, *sb_tmp = NULL;
axa_json_res_t res;
yajl_gen g = NULL;
int yajl_rc;
char op_str[AXA_P_OP_STRLEN];
char addr_str[INET6_ADDRSTRLEN];
axa_p_direction_t dir;
uint8_t *p, *q;
uint16_t user_objs_cnt, an_objs_cnt;
_axa_p_stats_sys_t *sys;
char time_buf[30];
struct tm *tm_info;
time_t t;
runits_t ru;
_axa_p_stats_user_t *user_obj;
_axa_p_stats_user_rad_an_t *an_obj;
switch(AXA_P2H16(hdr->op)) {
case AXA_P_OP_MISSED_RAD:
case AXA_P_OP_AHIT:
case AXA_P_OP_ALIST:
dir = AXA_P_FROM_RAD;
break;
case AXA_P_OP_USER:
case AXA_P_OP_JOIN:
case AXA_P_OP_PAUSE:
case AXA_P_OP_GO:
case AXA_P_OP_WATCH:
case AXA_P_OP_WGET:
case AXA_P_OP_STOP:
case AXA_P_OP_ALL_STOP:
case AXA_P_OP_CHANNEL:
case AXA_P_OP_CGET:
case AXA_P_OP_ACCT:
case _AXA_P_OP_KILL_REQ:
case _AXA_P_OP_STATS_REQ:
dir = AXA_P_TO_SRA;
break;
case AXA_P_OP_ANOM:
case AXA_P_OP_AGET:
case AXA_P_OP_RADU:
dir = AXA_P_TO_RAD;
break;
default:
dir = AXA_P_FROM_SRA;
break;
} /* switch */
if (axa_ck_hdr(emsg, hdr, "json", dir) == false)
return (AXA_JSON_RES_FAILURE);
if (AXA_P2H32(hdr->len) - sizeof(axa_p_hdr_t) != body_len) {
axa_pemsg(emsg, "body length mismatch %zu != %zu",
AXA_P2H32(hdr->len) - sizeof(axa_p_hdr_t),
body_len);
return (AXA_JSON_RES_FAILURE);
}
if (axa_ck_body(emsg, hdr->op, body, body_len) == false)
return (AXA_JSON_RES_FAILURE);
sb = axa_strbuf_init();
if (sb == NULL) {
axa_pemsg(emsg, "could not allocate axa_strbuf");
return (AXA_JSON_RES_MEMFAIL);
}
sb_tmp = axa_strbuf_init();
if (sb_tmp == NULL) {
axa_pemsg(emsg, "could not allocate axa_strbuf");
axa_strbuf_destroy(&sb);
res = AXA_JSON_RES_MEMFAIL;
goto err;
}
g = yajl_gen_alloc(NULL);
AXA_ASSERT (g != NULL);
yajl_rc = yajl_gen_config(g,
yajl_gen_print_callback,
_callback_print_yajl_axa_strbuf,
sb);
AXA_ASSERT(yajl_rc != 0);
add_yajl_map(g);
add_yajl_string(g, "tag");
if (AXA_P2H16(hdr->tag) == AXA_TAG_NONE)
add_yajl_string(g, "*");
else
add_yajl_integer(g, AXA_P2H16(hdr->tag));
add_yajl_string(g, "op");
axa_op_to_str(op_str, sizeof(op_str), hdr->op);
add_yajl_string(g, op_str);
switch ((axa_p_op_t)hdr->op) {
case AXA_P_OP_NOP:
break;
case AXA_P_OP_HELLO:
add_yajl_string(g, "id");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->hello.id));
add_yajl_string(g, "pvers_min");
add_yajl_integer(g, body->hello.pvers_min);
add_yajl_string(g, "pvers_max");
add_yajl_integer(g, body->hello.pvers_max);
add_yajl_string(g, "str");
add_yajl_string(g, body->hello.str);
break;
case AXA_P_OP_OK:
case AXA_P_OP_ERROR:
add_yajl_string(g, "orig_op");
axa_op_to_str(op_str, sizeof(op_str), body->result.orig_op);
add_yajl_string(g, op_str);
add_yajl_string(g, "str");
add_yajl_string(g, body->result.str);
break;
case AXA_P_OP_MISSED:
add_yajl_string(g, "missed");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->missed.missed));
add_yajl_string(g, "dropped");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->missed.dropped));
add_yajl_string(g, "rlimit");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->missed.rlimit));
add_yajl_string(g, "filtered");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->missed.filtered));
add_yajl_string(g, "last_report");
add_yajl_integer(g, AXA_P2H32(body->missed.last_report));
break;
case AXA_P_OP_MISSED_RAD:
add_yajl_string(g, "sra_missed");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->missed_rad.sra_missed));
add_yajl_string(g, "sra_dropped");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->missed_rad.sra_dropped));
add_yajl_string(g, "sra_rlimit");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->missed_rad.sra_rlimit));
add_yajl_string(g, "sra_filtered");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->missed_rad.sra_filtered));
add_yajl_string(g, "dropped");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->missed_rad.dropped));
add_yajl_string(g, "rlimit");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->missed_rad.rlimit));
add_yajl_string(g, "filtered");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->missed_rad.filtered));
add_yajl_string(g, "last_report");
add_yajl_integer(g, AXA_P2H32(body->missed_rad.last_report));
break;
case AXA_P_OP_WHIT:
res = add_whit(emsg, g, sb, nmsg_input, &(body->whit), body_len);
if (res != AXA_JSON_RES_SUCCESS)
goto err;
break;
case AXA_P_OP_WATCH:
add_watch(g, &(body->watch), body_len);
break;
case AXA_P_OP_ANOM: {
bool print_parms;
print_parms = body_len > offsetof(axa_p_anom_t, parms) && body->anom.parms[0] != '\0';
add_anom(g, body->anom, print_parms);
break;
}
case AXA_P_OP_CHANNEL:
res = add_channel(emsg, g, body->channel.ch);
if (res != AXA_JSON_RES_SUCCESS)
goto err;
add_yajl_string(g, "on");
add_yajl_bool(g, body->channel.on != 0);
break;
case AXA_P_OP_WLIST:
add_yajl_string(g, "cur_tag");
add_yajl_integer(g, AXA_P2H16(body->wlist.cur_tag));
add_watch(g, &(body->wlist.w), body_len - offsetof(axa_p_wlist_t, w));
break;
case AXA_P_OP_AHIT:
add_yajl_string(g, "an");
add_yajl_string(g, body->ahit.an.c);
res = add_whit(emsg, g, sb, nmsg_input, &(body->ahit.whit), body_len - offsetof(axa_p_ahit_t, whit));
if (res != AXA_JSON_RES_SUCCESS)
goto err;
break;
case AXA_P_OP_ALIST: {
bool print_parms;
add_yajl_string(g, "cur_tag");
add_yajl_integer(g, AXA_P2H16(body->alist.cur_tag));
print_parms = body_len > offsetof(axa_p_alist_t, anom) + offsetof(axa_p_anom_t, parms) && body->alist.anom.parms[0] != '\0';
add_anom(g, body->alist.anom, print_parms);
break;
}
case AXA_P_OP_CLIST:
res = add_channel(emsg, g, body->clist.ch);
if (res != AXA_JSON_RES_SUCCESS)
goto err;
add_yajl_string(g, "on");
add_yajl_bool(g, body->clist.on != 0);
add_yajl_string(g, "spec");
add_yajl_string(g, body->clist.spec.c);
break;
case AXA_P_OP_USER:
add_yajl_string(g, "name");
add_yajl_string(g, body->user.name);
break;
case AXA_P_OP_OPT: {
char buf[AXA_P_OP_STRLEN];
add_yajl_string(g, "type");
add_yajl_string(g, axa_opt_to_str(buf, sizeof(buf), AXA_P2H64(body->opt.type)));
switch((axa_p_opt_type_t)body->opt.type) {
case AXA_P_OPT_TRACE: {
add_yajl_string(g, "trace");
if (AXA_P2H64(body->opt.u.trace) != AXA_P_OPT_TRACE_REQ) {
add_yajl_number(g, sb_tmp, AXA_P2H64(body->opt.u.trace));
} else {
add_yajl_string(g, "REQUEST TRACE VALUE");
}
break;
}
case AXA_P_OPT_RLIMIT:
add_yajl_string(g, "max_pkts_per_sec");
res = add_rlimit_count(emsg, g, body->opt.u.rlimit.max_pkts_per_sec);
if (res != AXA_JSON_RES_SUCCESS)
goto err;
add_yajl_string(g, "cur_pkts_per_sec");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->opt.u.rlimit.cur_pkts_per_sec));
add_yajl_string(g, "report_secs");
res = add_rlimit_count(emsg, g, body->opt.u.rlimit.report_secs);
if (res != AXA_JSON_RES_SUCCESS)
goto err;
break;
case AXA_P_OPT_SAMPLE:
add_yajl_string(g, "sample");
if (AXA_P2H64(body->opt.u.sample) == 0) {
add_yajl_string(g, "requested");
} else {
axa_strbuf_reset(sb_tmp);
axa_strbuf_append(sb_tmp, "%0.6f", ((double)AXA_P2H64(body->opt.u.sample)) / AXA_P_OPT_SAMPLE_MAX);
add_yajl_number_sb(g, sb_tmp);
}
break;
case AXA_P_OPT_SNDBUF:
add_yajl_string(g, "bufsize");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->opt.u.bufsize));
break;
} /* switch */
break;
}
case AXA_P_OP_JOIN:
add_yajl_string(g, "id");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->join.id));
break;
case _AXA_P_OP_STATS_REQ:
if (body->stats_req.version != _AXA_STATS_VERSION_ONE) {
res = AXA_JSON_RES_FAILURE;
goto err;
}
add_yajl_string(g, "version");
add_yajl_integer(g, body->stats_req.version);
add_yajl_string(g, "type");
switch (body->stats_req.type) {
case AXA_P_STATS_M_M_SUM:
add_yajl_string(g, "summary");
break;
case AXA_P_STATS_M_M_ALL:
add_yajl_string(g, "all");
break;
case AXA_P_STATS_M_M_SN:
add_yajl_string(g, "serial number");
break;
case AXA_P_STATS_M_M_U:
add_yajl_string(g, "user name");
break;
default:
add_yajl_string(g, "unknown");
}
if (body->stats_req.type == AXA_P_STATS_M_M_SN) {
add_yajl_string(g, "serial number");
add_yajl_integer(g, body->stats_req.sn);
}
if (body->stats_req.type == AXA_P_STATS_M_M_U) {
add_yajl_string(g, "user name");
add_yajl_string(g, body->stats_req.user.name);
}
break;
case _AXA_P_OP_STATS_RSP:
if (body->stats_rsp.version != _AXA_STATS_VERSION_ONE) {
res = AXA_JSON_RES_FAILURE;
goto err;
}
add_yajl_string(g, "version");
add_yajl_integer(g, body->stats_rsp.version);
if (body->stats_rsp.sys_objs_cnt > 1) {
res = AXA_JSON_RES_FAILURE;
goto err;
}
add_yajl_string(g, "result");
switch (body->stats_rsp.result) {
case AXA_P_STATS_R_SUCCESS:
add_yajl_string(g, "success");
break;
case AXA_P_STATS_R_FAIL_NF:
add_yajl_string(g, "failed: user not found");
break;
case AXA_P_STATS_R_FAIL_UNK:
default:
add_yajl_string(g, "failed: unknown reason");
}
if (body->stats_rsp.sys_objs_cnt == 1) {
p = (uint8_t *)&body->stats_rsp;
sys = (_axa_p_stats_sys_t *)(p +
sizeof (_axa_p_stats_rsp_t));
if (sys->type != _AXA_P_STATS_TYPE_SYS) {
res = AXA_JSON_RES_FAILURE;
goto err;
}
add_yajl_string(g, "load");
add_yajl_array(g);
add_yajl_integer(g, AXA_P2H32(sys->load[0]));
add_yajl_integer(g, AXA_P2H32(sys->load[1]));
add_yajl_integer(g, AXA_P2H32(sys->load[2]));
close_yajl_array(g);
add_yajl_string(g, "cpu_usage");
add_yajl_integer(g, AXA_P2H32(sys->cpu_usage));
add_yajl_string(g, "uptime");
add_yajl_integer(g, AXA_P2H32(sys->uptime));
add_yajl_string(g, "starttime");
add_yajl_integer(g, AXA_P2H32(sys->starttime));
add_yajl_string(g, "vmsize");
add_yajl_number(g, sb_tmp, AXA_P2H64(sys->vmsize));
add_yajl_string(g, "vmrss");
add_yajl_number(g, sb_tmp, AXA_P2H64(sys->vmrss));
add_yajl_string(g, "thread_cnt");
add_yajl_integer(g, AXA_P2H32(sys->thread_cnt));
add_yajl_string(g, "user_cnt");
add_yajl_integer(g, AXA_P2H32(sys->user_cnt));
switch (sys->server_type) {
case _AXA_STATS_SRVR_TYPE_SRA:
add_yajl_string(g, "server_type");
add_yajl_string(g, "sra");
add_yajl_string(g, "fd_sockets");
add_yajl_integer(g,
AXA_P2H32(sys->fd_sockets));
add_yajl_string(g, "fd_pipes");
add_yajl_integer(g,
AXA_P2H32(sys->fd_pipes));
add_yajl_string(g, "fd_anon_inodes");
add_yajl_integer(g,
AXA_P2H32(sys->fd_anon_inodes));
add_yajl_string(g, "fd_other");
add_yajl_integer(g,
AXA_P2H32(sys->fd_other));
add_yajl_string(g, "rchar");
add_yajl_number(g, sb_tmp,
AXA_P2H64(sys->rchar));
add_yajl_string(g, "wchar");
add_yajl_number(g, sb_tmp,
AXA_P2H64(sys->wchar));
add_yajl_string(g,
"sra_ipv4_watch_cnt");
add_yajl_integer(g,
AXA_P2H32(sys->srvr.sra.watches.ipv4_cnt));
add_yajl_string(g,
"sra_ipv6_watch_cnt");
add_yajl_integer(g,
AXA_P2H32(sys->srvr.sra.watches.ipv6_cnt));
add_yajl_string(g,
"sra_dns_watch_cnt");
add_yajl_integer(g,
AXA_P2H32(sys->srvr.sra.watches.dns_cnt));
add_yajl_string(g,
"sra_ch_watch_cnt");
add_yajl_integer(g,
AXA_P2H32(sys->srvr.sra.watches.ch_cnt));
add_yajl_string(g,
"sra_err_watch_cnt");
add_yajl_integer(g,
AXA_P2H32(sys->srvr.sra.watches.err_cnt));
add_yajl_string(g, "sra_channels");
add_yajl_array(g);
for (int j = 0; j <= AXA_NMSG_CH_MAX; j++) {
if (axa_get_bitwords(sys->srvr.sra.ch_mask.m, j)) {
axa_strbuf_reset(sb_tmp);
axa_strbuf_append(sb_tmp, "ch%d", (j));
add_yajl_string(g, (const char*)sb_tmp->data);
}
}
close_yajl_array(g);
break;
case _AXA_STATS_SRVR_TYPE_RAD:
add_yajl_string(g, "server_type");
add_yajl_string(g, "rad");
add_yajl_string(g, "rad_anomaly_cnt");
add_yajl_integer(g,
AXA_P2H32(sys->srvr.rad.an_cnt));
break;
default:
res = AXA_JSON_RES_FAILURE;
goto err;
}
}
user_objs_cnt = body->stats_rsp.user_objs_cnt;
p = (uint8_t *)&body->stats_rsp +
sizeof (_axa_p_stats_rsp_t) +
body->stats_rsp.sys_objs_cnt *
sizeof (_axa_p_stats_sys_t);
if (user_objs_cnt > 0) {
add_yajl_string(g, "users");
add_yajl_array(g);
user_obj = (_axa_p_stats_user_t *)p;
for (; user_objs_cnt; user_objs_cnt--, user_obj++) {
add_yajl_string(g, "user_obj");
add_yajl_map(g);
add_yajl_string(g, "server_type");
switch (user_obj->server_type) {
case _AXA_STATS_SRVR_TYPE_SRA:
add_yajl_string(g, "sra");
break;
case _AXA_STATS_SRVR_TYPE_RAD:
add_yajl_string(g, "rad");
break;
default:
add_yajl_string(g,
"unkwn");
break;
}
add_yajl_string(g, "user");
add_yajl_string(g, user_obj->user.name);
add_yajl_string(g, "is_admin");
add_yajl_bool(g, user_obj->is_admin == 1 ?
true : false);
add_yajl_string(g, "io_type");
switch (user_obj->io_type) {
case AXA_IO_TYPE_UNIX:
add_yajl_string(g,
AXA_IO_TYPE_UNIX_STR);
break;
case AXA_IO_TYPE_TCP:
add_yajl_string(g,
AXA_IO_TYPE_TCP_STR);
break;
case AXA_IO_TYPE_SSH:
add_yajl_string(g,
AXA_IO_TYPE_SSH_STR);
break;
case AXA_IO_TYPE_TLS:
add_yajl_string(g,
AXA_IO_TYPE_TLS_STR);
break;
case AXA_IO_TYPE_APIKEY:
add_yajl_string(g,
AXA_IO_TYPE_APIKEY_STR);
break;
case AXA_IO_TYPE_UNKN:
default:
add_yajl_string(g, "unknown");
break;
}
add_yajl_string(g, "address");
switch (user_obj->addr_type) {
case AXA_AF_INET:
inet_ntop(AF_INET, &user_obj->ip.ipv4,
addr_str, sizeof(addr_str));
break;
case AXA_AF_INET6:
inet_ntop(AF_INET6, &user_obj->ip.ipv6,
addr_str, sizeof(addr_str));
break;
case AXA_AF_UNKNOWN:
strlcpy(addr_str, "unknown",
sizeof(addr_str));
break;
}
add_yajl_string(g, addr_str);
add_yajl_string(g, "sn");
add_yajl_integer(g, user_obj->sn);
add_yajl_string(g, "connected_since");
t = AXA_P2H32(user_obj->connected_since.tv_sec);
tm_info = gmtime(&t);
strftime(time_buf, sizeof (time_buf),
"%Y-%m-%dT%H:%M:%SZ",
tm_info);
add_yajl_string(g, time_buf);
add_yajl_string(g, "ratelimit");
if (AXA_P2H64(user_obj->ratelimit) == AXA_RLIMIT_OFF) {
add_yajl_integer(g, 0);
}
else {
add_yajl_integer(g,
AXA_P2H64(user_obj->ratelimit));
}
add_yajl_string(g, "sample");
axa_strbuf_reset(sb_tmp);
axa_strbuf_append(sb_tmp, "%0.2f",
((double)AXA_P2H64(user_obj->sample)));
add_yajl_number_sb(g, sb_tmp);
add_yajl_string(g, "last_count_update");
t = AXA_P2H32(user_obj->last_cnt_update.tv_sec);
tm_info = gmtime(&t);
strftime(time_buf, sizeof (time_buf),
"%Y-%m-%dT%H:%M:%SZ",
tm_info);
add_yajl_string(g, time_buf);
add_yajl_string(g, "filtered");
add_yajl_integer(g, user_obj->filtered);
add_yajl_string(g, "missed");
add_yajl_integer(g, user_obj->missed);
add_yajl_string(g, "collected");
add_yajl_integer(g, user_obj->collected);
add_yajl_string(g, "sent");
add_yajl_integer(g, user_obj->sent);
add_yajl_string(g, "rlimit");
add_yajl_integer(g, user_obj->rlimit);
add_yajl_string(g, "congested");
add_yajl_integer(g, user_obj->congested);
switch (user_obj->server_type) {
case _AXA_STATS_SRVR_TYPE_SRA:
add_yajl_string(g,
"ipv4_watch_cnt");
add_yajl_integer(g,
AXA_P2H32(user_obj->srvr.sra.watches.ipv4_cnt));
add_yajl_string(g,
"ipv6_watch_cnt");
add_yajl_integer(g,
AXA_P2H32(user_obj->srvr.sra.watches.ipv6_cnt));
add_yajl_string(g,
"dns_watch_cnt");
add_yajl_integer(g,
AXA_P2H32(user_obj->srvr.sra.watches.dns_cnt));
add_yajl_string(g,
"ch_watch_cnt");
add_yajl_integer(g,
AXA_P2H32(user_obj->srvr.sra.watches.ch_cnt));
add_yajl_string(g,
"err_watch_cnt");
add_yajl_integer(g,
AXA_P2H32(user_obj->srvr.sra.watches.err_cnt));
add_yajl_string(g, "channels");
add_yajl_array(g);
for (int j = 0; j <= AXA_NMSG_CH_MAX; j++) {
if (axa_get_bitwords(user_obj->srvr.sra.ch_mask.m, j)) {
axa_strbuf_reset(sb_tmp);
axa_strbuf_append(sb_tmp, "ch%d", (j));
add_yajl_string(g, (const char*)sb_tmp->data);
}
}
close_yajl_array(g);
break;
case _AXA_STATS_SRVR_TYPE_RAD:
add_yajl_string(g, "anomaly_count_in_flight");
add_yajl_integer(g,
AXA_P2H32(user_obj->srvr.rad.an_obj_cnt));
add_yajl_string(g, "anomaly_count_total");
add_yajl_integer(g,
AXA_P2H32(user_obj->srvr.rad.an_obj_cnt_total));
an_objs_cnt = user_obj->srvr.rad.an_obj_cnt;
q = (uint8_t *)&body->stats_rsp +
sizeof (_axa_p_stats_rsp_t) +
body->stats_rsp.sys_objs_cnt *
sizeof (_axa_p_stats_sys_t) +
sizeof (_axa_p_stats_user_t);
if (an_objs_cnt > 0) {
add_yajl_string(g,
"anomalies");
add_yajl_array(g);
an_obj = (_axa_p_stats_user_rad_an_t *)q;
for ( ; an_objs_cnt; an_objs_cnt--, an_obj++) {
add_yajl_string(g, "an_obj");
add_yajl_map(g);
add_yajl_string(g, "name");
add_yajl_string(g,
an_obj->name);
add_yajl_string(g, "options");
add_yajl_string(g,
an_obj->opt);
add_yajl_string(g,
"ru_original");
ru = AXA_P2H32(an_obj->ru_original);
if (ru == INT_MAX)
add_yajl_string(g,
"unlimited");
else
add_yajl_integer(g,
AXA_P2H32(an_obj->ru_original));
add_yajl_string(g,
"ru_current");
ru = AXA_P2H32(an_obj->ru_current);
if (ru == INT_MAX)
add_yajl_string(g,
"unlimited");
else
add_yajl_integer(g,
AXA_P2H32(an_obj->ru_current));
add_yajl_string(g, "ru_cost");
add_yajl_integer(g,
AXA_P2H32(an_obj->ru_cost));
add_yajl_string(g,
"channels");
add_yajl_array(g);
for (int j = 0; j <= AXA_NMSG_CH_MAX; j++) {
if (axa_get_bitwords(an_obj->ch_mask.m, j)) {
axa_strbuf_reset(sb_tmp);
axa_strbuf_append(sb_tmp, "ch%d", (j));
add_yajl_string(g, (const char*)sb_tmp->data);
}
}
close_yajl_array(g);
close_yajl_map(g);
}
close_yajl_array(g);
}
break;
default:
res = AXA_JSON_RES_FAILURE;
goto err;
} /* switch (user_obj->server_type) */
close_yajl_map(g);
} /* for (; user_objs_cnt; user_objs_cnt--, ... */
close_yajl_array(g);
} /* if (user_objs_cnt > 0) */
break;
case _AXA_P_OP_KILL_REQ:
case _AXA_P_OP_KILL_RSP:
add_yajl_string(g, "mode");
add_yajl_integer(g, body->kill.mode);
add_yajl_string(g, "user");
add_yajl_string(g, body->kill.user.name);
add_yajl_string(g, "sn");
add_yajl_integer(g, AXA_P2H32(body->kill.sn));
add_yajl_string(g, "result");
add_yajl_integer(g, body->kill.result);
break;
case AXA_P_OP_PAUSE:
case AXA_P_OP_GO:
case AXA_P_OP_WGET:
case AXA_P_OP_AGET:
case AXA_P_OP_STOP:
case AXA_P_OP_ALL_STOP:
case AXA_P_OP_CGET:
case AXA_P_OP_ACCT:
case AXA_P_OP_RADU:
break;
case AXA_P_OP_MGMT_GETRSP:
case AXA_P_OP_MGMT_GET:
add_yajl_string(g, "mgmt is deprecated; please upgrade and use \"stats\"");
break;
} /* switch */
close_yajl_map(g);
yajl_gen_reset(g, "");
yajl_gen_free(g);
*out = sb->data;
free(sb);
axa_strbuf_destroy(&sb_tmp);
return (AXA_JSON_RES_SUCCESS);
err:
if (g != NULL)
yajl_gen_free(g);
axa_strbuf_destroy(&sb);
axa_strbuf_destroy(&sb_tmp);
return (res);
}
CCObject* CCJSONParser::load(const char* json, size_t length) {
// use memory input stream
CCMemoryInputStream* mis = CCMemoryInputStream::create((char*)json, length);
// status of yajl
yajl_status stat;
// get gen instance
yajl_gen g = yajl_gen_alloc(NULL);
// register callback
ccJSONContext ctx;
ctx.g = g;
ctx.root = NULL;
ctx.objStack = new vector<CCObject*>();
ctx.flagStack = new vector<bool>();
yajl_handle hand = yajl_alloc(&callbacks, NULL, (void*)&ctx);
// config yajl
yajl_gen_config(g, yajl_gen_beautify, 1);
yajl_gen_config(g, yajl_gen_validate_utf8, 1);
yajl_config(hand, yajl_allow_comments, 1);
// parse
char buf[4096];
while(true) {
// read data
int rd = mis->read(buf, 4096);
if (rd == 0)
break;
// parese data
stat = yajl_parse(hand, (const unsigned char*)buf, rd);
// if parse error, break
if (stat != yajl_status_ok)
break;
}
// complete parse
stat = yajl_complete_parse(hand);
// check error
if (stat != yajl_status_ok) {
unsigned char* str = yajl_get_error(hand, 1, (const unsigned char*)json, length);
CCLOGWARN("parse json error: %s", str);
yajl_free_error(hand, str);
// when error, doesn't return anything
ctx.root = NULL;
}
// free
yajl_gen_free(g);
yajl_free(hand);
delete ctx.objStack;
delete ctx.flagStack;
// return
return ctx.root;
}
int
main(int argc, char ** argv)
{
yajl_handle hand;
static unsigned char fileData[65536];
/* generator config */
yajl_gen g;
yajl_status stat;
size_t rd;
int retval = 0;
int a = 1;
g = yajl_gen_alloc(NULL);
yajl_gen_config(g, yajl_gen_beautify, 1);
yajl_gen_config(g, yajl_gen_validate_utf8, 1);
/* ok. open file. let's read and parse */
hand = yajl_alloc(&callbacks, NULL, (void *) g);
/* and let's allow comments by default */
yajl_config(hand, yajl_allow_comments, 1);
/* check arguments.*/
while ((a < argc) && (argv[a][0] == '-') && (strlen(argv[a]) > 1)) {
unsigned int i;
for ( i=1; i < strlen(argv[a]); i++) {
switch (argv[a][i]) {
case 'm':
yajl_gen_config(g, yajl_gen_beautify, 0);
break;
case 'u':
yajl_config(hand, yajl_dont_validate_strings, 1);
break;
default:
fprintf(stderr, "unrecognized option: '%c'\n\n",
argv[a][i]);
usage(argv[0]);
}
}
++a;
}
if (a < argc) {
usage(argv[0]);
}
for (;;) {
rd = fread((void *) fileData, 1, sizeof(fileData) - 1, stdin);
if (rd == 0) {
if (!feof(stdin)) {
fprintf(stderr, "error on file read.\n");
retval = 1;
}
break;
}
fileData[rd] = 0;
stat = yajl_parse(hand, fileData, rd);
if (stat != yajl_status_ok) break;
{
const unsigned char * buf;
size_t len;
yajl_gen_get_buf(g, &buf, &len);
//fwrite(buf, 1, len, stdout);
std::cout << "Buf => " << buf << std::endl;
yajl_gen_clear(g);
}
}
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);
retval = 1;
}
yajl_gen_free(g);
yajl_free(hand);
return retval;
}
static int js_generator(lua_State *L) {
yajl_print_t print = NULL;
void * ctx = NULL;
yajl_gen* handle;
luaL_checktype(L, 1, LUA_TTABLE);
/* {args}, ?, tbl */
lua_newtable(L);
/* Validate and save in fenv so it isn't gc'ed: */
lua_getfield(L, 1, "printer");
if ( ! lua_isnil(L, -1) ) {
js_printer_ctx* print_ctx;
luaL_checktype(L, -1, LUA_TFUNCTION);
lua_pushvalue(L, -1);
/* {args}, ?, tbl, printer, printer */
lua_setfield(L, -3, "printer");
print_ctx = (js_printer_ctx*)
lua_newuserdata(L, sizeof(js_printer_ctx));
/* {args}, ?, tbl, printer, printer_ctx */
lua_setfield(L, -3, "printer_ctx");
/* {args}, ?, tbl, printer */
lua_getfield(L, LUA_REGISTRYINDEX, "yajl.refs");
/* {args}, ?, tbl, printer, refs */
lua_insert(L, -2);
/* {args}, ?, tbl, refs, printer */
print_ctx->printer_ref = luaL_ref(L, -2);
print_ctx->L = L;
print = &js_printer;
ctx = print_ctx;
}
lua_pop(L, 1);
/* {args}, ?, tbl */
/* Sucks that yajl's generator doesn't keep track of this for me
(this is a stack of strings "array" and "object" so I can keep
track of what to "close"): */
lua_newtable(L);
lua_setfield(L, -2, "stack");
/* {args}, ?, tbl */
handle = (yajl_gen*)lua_newuserdata(L, sizeof(yajl_gen));
*handle = yajl_gen_alloc(NULL);
/* {args}, ?, tbl, ud */
if ( print ) {
yajl_gen_config(*handle, yajl_gen_print_callback, print, ctx);
}
/* Get the indent and save so it isn't gc'ed: */
lua_getfield(L, 1, "indent");
if ( ! lua_isnil(L, -1) ) {
yajl_gen_config(*handle, yajl_gen_beautify, 1);
yajl_gen_config(*handle, yajl_gen_indent_string, lua_tostring(L, -1));
lua_setfield(L, -3, "indent");
} else {
lua_pop(L, 1);
}
/* {args}, ?, tbl, ud */
/* {args}, ?, tbl, ud, meta */
luaL_getmetatable(L, "yajl.generator.meta");
lua_setmetatable(L, -2);
/* {args}, ?, tbl, ud */
lua_insert(L, -2);
/* {args}, ?, ud, tbl */
lua_setfenv(L, -2);
return 1;
}
int dump_audit_log(struct audit_log_entry_t *a)
{
yajl_gen g;
const unsigned char * buf;
size_t len;
g = yajl_gen_alloc(NULL);
yajl_gen_config(g, yajl_gen_beautify, 1);
yajl_gen_array_open(g);
yajl_gen_map_open(g);
yajl_gen_string(g, "id", strlen("id"));
yajl_gen_string(g, a->id, strlen(a->id));
yajl_gen_string(g, "date", strlen("date"));
yajl_gen_string(g, a->date, strlen(a->date));
yajl_gen_string(g, "origin", strlen("origin"));
yajl_gen_map_open(g);
yajl_gen_string(g, "ip", strlen("ip"));
yajl_gen_string(g, a->origin, strlen(a->origin));
yajl_gen_string(g, "port", strlen("port"));
yajl_gen_number(g, a->origin_port, strlen(a->origin_port));
yajl_gen_map_close(g);
yajl_gen_string(g, "dest", strlen("dest"));
yajl_gen_map_open(g);
yajl_gen_string(g, "ip", strlen("ip"));
yajl_gen_string(g, a->dest, strlen(a->dest));
yajl_gen_string(g, "port", strlen("port"));
yajl_gen_number(g, a->dest_port, strlen(a->dest_port));
yajl_gen_map_close(g);
if (a->section_a != NULL)
{
yajl_gen_string(g, "Section A", strlen("Section A"));
yajl_gen_string(g, a->section_a, strlen(a->section_a));
}
if (a->section_b != NULL)
{
yajl_gen_string(g, "Section B", strlen("Section B"));
yajl_gen_string(g, a->section_b, strlen(a->section_b));
}
if (a->section_f != NULL)
{
yajl_gen_string(g, "Section F", strlen("Section F"));
yajl_gen_string(g, a->section_f, strlen(a->section_f));
}
if (a->section_e != NULL)
{
yajl_gen_string(g, "Section E", strlen("Section E"));
yajl_gen_string(g, a->section_e, strlen(a->section_e));
}
if (a->section_h != NULL)
{
yajl_gen_string(g, "Section H", strlen("Section H"));
yajl_gen_string(g, a->section_h, strlen(a->section_h));
}
yajl_gen_map_close(g);
yajl_gen_array_close(g);
yajl_gen_get_buf(g, &buf, &len);
fwrite(buf, 1, len, stdout);
yajl_gen_free(g);
#if 0
fprintf(stdout, "Section A: %s\n", a->section_a);
fprintf(stdout, "Section B: %s\n", a->section_b);
fprintf(stdout, "Section F: %s\n", a->section_f);
fprintf(stdout, "Section E: %s\n", a->section_e);
fprintf(stdout, "Section H: %s\n", a->section_h);
#endif
}
SEXP R_reformat(SEXP x, SEXP pretty, SEXP indent_string) {
yajl_status stat;
yajl_handle hand;
yajl_gen g;
SEXP output;
/* init generator */
g = yajl_gen_alloc(NULL);
yajl_gen_config(g, yajl_gen_beautify, asInteger(pretty));
yajl_gen_config(g, yajl_gen_indent_string, translateCharUTF8(asChar(indent_string)));
yajl_gen_config(g, yajl_gen_validate_utf8, 0);
yajl_gen_config(g, yajl_gen_escape_solidus, 1); //modified to only escape for "</"
/* init parser */
hand = yajl_alloc(&callbacks, NULL, (void *) g);
/* get data from R */
const char* json = translateCharUTF8(asChar(x));
/* ignore BOM */
if(json[0] == '\xEF' && json[1] == '\xBB' && json[2] == '\xBF'){
json = json + 3;
}
/* Get length (after removing bom) */
const size_t rd = strlen(json);
/* parse */
stat = yajl_parse(hand, (const unsigned char*) json, rd);
if(stat == yajl_status_ok) {
stat = yajl_complete_parse(hand);
}
//error message
if (stat != yajl_status_ok) {
unsigned char* str = yajl_get_error(hand, 1, (const unsigned char*) json, rd);
output = PROTECT(mkString((const char*) str));
yajl_free_error(hand, str);
} else {
//create R object
const unsigned char* buf;
size_t len;
yajl_gen_get_buf(g, &buf, &len);
//force as UTF8 string
output = PROTECT(allocVector(STRSXP, 1));
SET_STRING_ELT(output, 0, mkCharCE((const char*) buf, CE_UTF8));
setAttrib(output, R_ClassSymbol, mkString("json"));
}
/* clean up */
yajl_gen_clear(g);
yajl_gen_free(g);
yajl_free(hand);
/* return boolean vec (0 means no errors, means is valid) */
SEXP vec = PROTECT(allocVector(VECSXP, 2));
SET_VECTOR_ELT(vec, 0, ScalarInteger(stat));
SET_VECTOR_ELT(vec, 1, output);
UNPROTECT(2);
return vec;
}
int main(int argc, char **argv) {
bstring info_page;
info_t info;
yajl_gen yajl;
const unsigned char *json;
size_t json_len;
curl_global_init(CURL_GLOBAL_NOTHING);
for (size_t i = 0; argv[i]; i += 1) {
if (strcmp(argv[i], "-r") == 0) {
modem_touch(MODEM_RESTART_URL);
return EXIT_SUCCESS;
}
}
info_page = modem_fetch(MODEM_INFO_URL);
if (!info_page) {
fprintf(stderr, "hektor: Couldn't fetch '%s'\n", MODEM_INFO_URL);
return EXIT_FAILURE;
}
info_init(&info, info_page);
yajl = yajl_gen_alloc(NULL);
assert(yajl);
yajl_gen_config(yajl, yajl_gen_beautify, true);
#define yajl_gen_strst(y, s) yajl_gen_string((y), (s), sizeof(s) - 1)
yajl_gen_map_open(yajl);
yajl_gen_strst(yajl, "connection");
yajl_gen_integer(yajl, info.conn);
yajl_gen_strst(yajl, "fapped");
yajl_gen_bool(yajl, info.fap == FAP_ACTIVE);
yajl_gen_strst(yajl, "refill_secs");
yajl_gen_integer(yajl, info.refill_secs);
yajl_gen_strst(yajl, "refill_ts");
yajl_gen_integer(yajl, info.refill_ts);
yajl_gen_strst(yajl, "usage_allowed");
yajl_gen_integer(yajl, info.usage_allowed);
yajl_gen_strst(yajl, "usage_remain");
yajl_gen_integer(yajl, info.usage_remain);
yajl_gen_map_close(yajl);
#undef yajl_gen_strst
yajl_gen_get_buf(yajl, &json, &json_len);
printf("%s", json);
bdestroy(info_page);
yajl_gen_free(yajl);
curl_global_cleanup();
return EXIT_SUCCESS;
}
