static gchar *
_j4status_i3bar_output_generate_header(J4statusPluginContext *context)
{
yajl_gen json_gen;
json_gen = yajl_gen_alloc(NULL);
yajl_gen_map_open(json_gen);
yajl_gen_string(json_gen, (const unsigned char *)"version", strlen("version"));
yajl_gen_integer(json_gen, 1);
yajl_gen_string(json_gen, (const unsigned char *)"stop_signal", strlen("stop_signal"));
yajl_gen_integer(json_gen, SIGUSR2);
yajl_gen_string(json_gen, (const unsigned char *)"cont_signal", strlen("cont_signal"));
yajl_gen_integer(json_gen, SIGUSR1);
if ( ! context->no_click_events )
{
yajl_gen_string(json_gen, (const unsigned char *)"click_events", strlen("click_events"));
yajl_gen_bool(json_gen, 1);
}
yajl_gen_map_close(json_gen);
const unsigned char *buffer;
size_t length;
yajl_gen_get_buf(json_gen, &buffer, &length);
gchar *header;
header = g_strdup_printf("%s\n[[]\n", buffer);
yajl_gen_free(json_gen);
return header;
}
int PNode_op_rm(PNode *self, Datum *d)
{
PQuery *q = PNode_startQuery(self);
Datum *k;
long size = PNode_size(self);
long removeCount = 0;
if(!q) PNode_first(self);
while (k = PQuery_key(q))
{
PDB_willWrite(self->pdb);
if(!StoreCursor_remove(self->storeCursor)) break;
// HACK to avoid skipping a step by backing up in the reverse enum direction before calling PQuery_enumerate
if(PQuery_stepDirection(q) == 1)
{
StoreCursor_previous(self->storeCursor);
}
removeCount ++;
//count += PNode_removeAt_(self, k);
PQuery_enumerate(q);
}
PNode_setSize_(self, size - removeCount);
yajl_gen_integer(self->yajl, removeCount);
Datum_appendYajl_(d, self->yajl);
//Datum_appendLong_(d, removeCount);
return 0;
}
static int js_generator_integer(lua_State *L) {
js_generator_assert(L,
yajl_gen_integer(*js_check_generator(L, 1),
luaL_checkinteger(L, 2)),
__FILE__, __LINE__);
return 0;
}
int PNode_op_sizes(PNode *self, Datum *d)
{
PNode *tmpNode = PDB_allocNode(self->pdb);
Datum *k;
PQuery *q = PNode_startQuery(self);
yajl_gen_map_open(self->yajl);
while (k = PQuery_key(q))
{
if(!Datum_beginsWithCString_(k, "_"))
{
yajl_gen_datum(self->yajl, PNode_key(self));
PNode_setPid_(tmpNode, PNode_value(self));
yajl_gen_integer(self->yajl, PNode_size(tmpNode));
}
if (q) { PQuery_enumerate(q); } else { PNode_next(self); }
}
yajl_gen_map_close(self->yajl);
Datum_appendYajl_(d, self->yajl);
return 0;
}
void write(T i)
{
status = yajl_gen_integer(g, i);
THROW_EXC_IF_FAILED(status == yajl_gen_status_ok,
"YAJL generator failed, error code: %u, data: %lli",
status, static_cast<long long int>(i));
}
void galleryd::response::generate(galleryd::request &req, galleryd::queue &q)
{
yajl_gen_clear(handle_);
yajl_gen_map_open(handle_);
try
{
if(req.method == "status")
{
constexpr const unsigned char key_states[] = {'s', 't', 'a', 't', 'e'};
yajl_gen_string(handle_, key_states, sizeof(key_states));
yajl_gen_array_open(handle_);
for(auto state : q.status(req.items, req.category))
yajl_gen_integer(handle_, state);
yajl_gen_array_close(handle_);
}
else if(req.method == "add")
{
q.add(req.items, req.category);
}
else if(req.method == "open")
{
auto path = q.open(req.items, req.category);
if(not path.empty())
{
path += '/';
path += req.items[0];
if(fork() == 0)
{
int fd = open("/dev/null", O_WRONLY);
dup2(fd, 2); // redirect stderr
execl("/usr/bin/geeqie", "/usr/bin/geeqie", "-r", path.c_str(), nullptr);
exit(1); // in case execl returns with an error
}
}
else
{
// TODO error handling
}
}
}
catch(const std::exception &e)
{
constexpr const unsigned char key_error[] = {'e', 'r', 'r', 'o', 'r'};
const char *err = e.what();
const size_t len = strlen(err);
yajl_gen_string(handle_, key_error, sizeof(key_error));
yajl_gen_string(handle_, reinterpret_cast<const unsigned char *>(err), len);
}
yajl_gen_map_close(handle_);
}
static yajl_gen_status
generate(yajl_gen g, Var v, void *ctx)
{
struct generate_context *gctx = (struct generate_context *)ctx;
switch (v.type) {
case TYPE_INT:
return yajl_gen_integer(g, v.v.num);
case TYPE_FLOAT:
return yajl_gen_double(g, *v.v.fnum);
case TYPE_OBJ:
case TYPE_ERR:
{
const char *tmp = value_to_literal(v);
if (MODE_EMBEDDED_TYPES == gctx->mode)
tmp = append_type(tmp, v.type);
return yajl_gen_string(g, (const unsigned char *)tmp, strlen(tmp));
}
case TYPE_STR:
{
const char *tmp = v.v.str;
size_t len = strlen(tmp);
if (MODE_EMBEDDED_TYPES == gctx->mode)
if (TYPE_NONE != valid_type(&tmp, &len))
tmp = append_type(tmp, v.type);
return yajl_gen_string(g, (const unsigned char *)tmp, strlen(tmp));
}
case TYPE_MAP:
{
struct do_map_closure dmc;
dmc.g = g;
dmc.gctx = gctx;
dmc.status = yajl_gen_status_ok;
yajl_gen_map_open(g);
if (mapforeach(v, do_map, &dmc))
return dmc.status;
yajl_gen_map_close(g);
return yajl_gen_status_ok;
}
case TYPE_LIST:
{
int i;
yajl_gen_status status;
yajl_gen_array_open(g);
for (i = 1; i <= v.v.list[0].v.num; i++) {
status = generate(g, v.v.list[i], ctx);
if (yajl_gen_status_ok != status)
return status;
}
yajl_gen_array_close(g);
return yajl_gen_status_ok;
}
default:
panic("Unsupported type in generate()");
}
return -1;
}
int VertexServer_api_collectGarbage(VertexServer *self)
{
time_t t1 = time(NULL);
long savedCount = PDB_collectGarbage(self->pdb);
double dt = difftime(time(NULL), t1);
yajl_gen_map_open(self->yajl);
yajl_gen_cstring(self->yajl, "saved");
yajl_gen_integer(self->yajl, savedCount);
yajl_gen_cstring(self->yajl, "seconds");
yajl_gen_integer(self->yajl, (int)dt);
yajl_gen_map_close(self->yajl);
Datum_appendYajl_(self->result, self->yajl);
Log_Printf_("gc: %s\n", Datum_data(self->result));
return 0;
}
static int json_format(struct formatter *fmt, struct recordset *rset)
{
struct record *r;
struct json_formatter_data *priv = fmt->priv;
yajl_gen_map_open(priv->yajl);
int repeat = 0;
for_each_record(r, rset) {
if(r->type != RECORD_TYPE_RSET || !repeat)
yajl_gen_string(priv->yajl, (unsigned char*)r->name, r->len_n-1);
if(r->type != RECORD_TYPE_RSET) {
if(repeat) yajl_gen_array_close(priv->yajl);
repeat = 0;
}
switch(r->type) {
case RECORD_TYPE_STRING:
yajl_gen_string(priv->yajl, (unsigned char*)r->value_str, r->len_v-1);
break;
case RECORD_TYPE_INT:
yajl_gen_integer(priv->yajl, r->value_int);
break;
case RECORD_TYPE_UINT:
case RECORD_TYPE_HEX:
yajl_gen_integer(priv->yajl, r->value_uint);
break;
case RECORD_TYPE_DOUBLE:
yajl_gen_double(priv->yajl, r->value_double);
break;
case RECORD_TYPE_RSET:
if(!repeat) yajl_gen_array_open(priv->yajl);
json_format(fmt, r->value_rset);
repeat = 1;
break;
default:
break;
}
}
if(repeat) yajl_gen_array_close(priv->yajl);
yajl_gen_map_close(priv->yajl);
json_print(fmt->f, priv->yajl);
return 0;
}
yajl_gen_status
yajl_gen_value(yajl_gen gen, VALUE obj)
{
if (FIXNUM_P(obj))
return yajl_gen_integer(gen, NUM2LONG(obj));
else if (NIL_P(obj) || obj == Qundef)
return yajl_gen_null(gen);
else if (obj == Qtrue)
return yajl_gen_bool(gen, 1);
else if (obj == Qfalse)
return yajl_gen_bool(gen, 0);
else if (SYMBOL_P(obj))
return yajl_gen_format(gen, ":%s", rb_id2name(SYM2ID(obj)));
else
return yajl_gen_format(gen, "0x%x", obj);
}
int PNode_op_count(PNode *self, Datum *d)
{
PQuery *q = PNode_startQuery(self);
Datum *k;
long count = 0;
while (k = PQuery_key(q))
{
count ++;
PQuery_enumerate(q);
}
yajl_gen_integer(self->yajl, count);
Datum_appendYajl_(d, self->yajl);
return 0;
}
int orderly_write_json2(yajl_gen g, const orderly_json * j)
{
yajl_gen_status s;
int rv = 1;
if (j) {
if (j->k) yajl_gen_string(g, (const unsigned char *) j->k, strlen(j->k));
switch (j->t) {
case orderly_json_none:
return 0;
case orderly_json_null:
s = yajl_gen_null(g);
break;
case orderly_json_string:
s = yajl_gen_string(g, (const unsigned char *) j->v.s, strlen(j->v.s));
break;
case orderly_json_boolean:
s = yajl_gen_bool(g, j->v.b);
break;
case orderly_json_integer:
s = yajl_gen_integer(g, j->v.i);
break;
case orderly_json_number:
s = yajl_gen_double(g, j->v.n);
break;
case orderly_json_object:
s = yajl_gen_map_open(g);
rv = orderly_write_json2(g, j->v.children.first);
s = yajl_gen_map_close(g);
break;
case orderly_json_array:
s = yajl_gen_array_open(g);
rv = orderly_write_json2(g, j->v.children.first);
s = yajl_gen_array_close(g);
break;
}
if (rv && j->next) rv = orderly_write_json2(g, j->next);
}
return rv;
}
void message_bus_write_json(yajl_gen g, void *context) {
state *state = context;
yajl_val output_values = state_get_json(state, STATE_OUTPUT_VALUES);
assert(YAJL_IS_ARRAY(output_values));
yajl_gen_map_open(g);
int len = YAJL_GET_ARRAY(output_values)->len;
for (int i = 0; i < len; i++) {
char *k = YAJL_GET_STRING(YAJL_GET_ARRAY(output_values)->values[i]);
state_value_type type = state_get_value_type(state, k);
yajl_gen_string(g, (unsigned char *)k, strlen(k));
float float_value;
int int_value;
yajl_val json_value;
switch (type) {
case state_value_type_float:
float_value = state_get_float(state, k);
yajl_gen_double(g, (double)float_value);
break;
case state_value_type_int:
int_value = state_get_int(state, k);
yajl_gen_integer(g, int_value);
break;
case state_value_type_json:
json_value = state_get_json(state, k);
json_write_value(g, json_value);
break;
default:
assert(0);
break;
}
}
yajl_gen_map_close(g);
}
static
ngx_int_t ngx_http_metrics_gen_status_counters(yajl_gen g)
{
YAJL_CHECK(yajl_gen_cstring(g, "status_codes"));
YAJL_CHECK(yajl_gen_map_open(g));
ngx_int_t i = 0;
char buf[4];
for (i = 0; i < NGX_HTTP_NUM_STATUS_CODES; i++) {
if (ngx_http_metrics_status_codes[i] > 0) {
snprintf(buf, 4, "%ld", NGX_HTTP_OK + i);
YAJL_CHECK(yajl_gen_cstring(g, buf));
YAJL_CHECK(yajl_gen_integer(g, ngx_http_metrics_status_codes[i]));
}
}
YAJL_CHECK(yajl_gen_map_close(g));
return NGX_OK;
}
static
ngx_int_t ngx_http_metrics_gen_stub_status(yajl_gen g)
{
YAJL_CHECK(yajl_gen_cstring(g, "requests"));
YAJL_CHECK(yajl_gen_integer(g, *ngx_stat_requests));
YAJL_CHECK(yajl_gen_cstring(g, "accepted"));
YAJL_CHECK(yajl_gen_integer(g, *ngx_stat_accepted));
YAJL_CHECK(yajl_gen_cstring(g, "handled"));
YAJL_CHECK(yajl_gen_integer(g, *ngx_stat_handled));
YAJL_CHECK(yajl_gen_cstring(g, "connections"));
YAJL_CHECK(yajl_gen_integer(g, *ngx_stat_active));
YAJL_CHECK(yajl_gen_cstring(g, "reading"));
YAJL_CHECK(yajl_gen_integer(g, *ngx_stat_reading));
YAJL_CHECK(yajl_gen_cstring(g, "writing"));
YAJL_CHECK(yajl_gen_integer(g, *ngx_stat_writing));
return NGX_OK;
}
int VertexServer_api_queueExpireTo(VertexServer *self)
{
PNode *fromNode = PDB_allocNode(self->pdb);
PNode *toNode = PDB_allocNode(self->pdb);
PNode *itemNode = PDB_allocNode(self->pdb);
Datum *toPath = HttpRequest_queryValue_(self->httpRequest, "toPath");
unsigned int itemsExpired = 0;
if (PNode_moveToPathIfExists_(fromNode, HttpRequest_uriPath(self->httpRequest)) != 0)
{
VertexServer_setErrorCString_(self, "from path does not exist: ");
VertexServer_appendError_(self, HttpRequest_uriPath(self->httpRequest));
return -1;
}
//PNode_moveToPath_(toNode, toPath);
if (PNode_moveToPathIfExists_(toNode, toPath) != 0)
{
VertexServer_setErrorCString_(self, "to path does not exist: ");
VertexServer_appendError_(self, toPath);
return -1;
}
PNode_first(fromNode);
{
Datum *qTimeKey = Datum_newWithCString_("_qtime");
Datum *k;
Datum *qExpireKey = Datum_newWithCString_("_qexpire");
long now = time(NULL);
while (k = PNode_key(fromNode))
{
Datum *pid = PNode_value(fromNode);
Datum *qExpireValue;
PNode_setPid_(itemNode, pid);
qExpireValue = PNode_at_(itemNode, qExpireKey);
if(!qExpireValue)
{
Log_Printf("WARNING: attempt to expire a node with no _qexpire value\n");
if(PNode_at_(itemNode, qTimeKey) == 0x0)
{
Log_Printf("WARNING: node also missing _qtime value\n");
}
break;
}
if(qExpireValue == 0x0 || Datum_asLong(qExpireValue) < now)
{
PNode_removeAtCursor(fromNode); // the remove will go to the next item
PNode_key(fromNode);
PNode_removeAt_(itemNode, qTimeKey);
PNode_removeAt_(itemNode, qExpireKey);
PNode_atPut_(toNode, k, pid);
PNode_jumpToCurrentKey(fromNode);
itemsExpired ++;
}
else
{
PNode_next(fromNode);
}
}
Datum_free(qTimeKey);
Datum_free(qExpireKey);
}
yajl_gen_integer(self->yajl, (long)itemsExpired);
Datum_appendYajl_(self->result, self->yajl);
return 0;
}
static void
_j4status_i3bar_output_process_section(J4statusPluginContext *context, J4statusSection *section)
{
const gchar *value;
gchar *labelled_value = NULL;
value = j4status_section_get_value(section);
if ( value == NULL )
{
j4status_section_set_cache(section, NULL);
return;
}
yajl_gen json_gen;
json_gen = yajl_gen_alloc(NULL);
const gchar *label;
label = j4status_section_get_label(section);
const gchar *label_colour;
label_colour = j4status_colour_to_hex(j4status_section_get_label_colour(section));
if ( ( label != NULL ) && ( label_colour != NULL ) )
{
gchar *label_with_sep;
label_with_sep = g_strdup_printf("%s: ", label);
/*
* We create a fake section with just the label
* so we open an array to have yajl generate a
* comma between the two sections
*/
yajl_gen_array_open(json_gen);
yajl_gen_clear(json_gen); /* We need the comma alone */
yajl_gen_map_open(json_gen);
yajl_gen_string(json_gen, (const unsigned char *)"color", strlen("color"));
yajl_gen_string(json_gen, (const unsigned char *)label_colour, strlen("#000000"));
yajl_gen_string(json_gen, (const unsigned char *)"full_text", strlen("full_text"));
yajl_gen_string(json_gen, (const unsigned char *)label_with_sep, strlen(label_with_sep));
yajl_gen_string(json_gen, (const unsigned char *)"separator", strlen("separator"));
yajl_gen_bool(json_gen, FALSE);
yajl_gen_string(json_gen, (const unsigned char *)"separator_block_width", strlen("separator_block_width"));
yajl_gen_integer(json_gen, 0);
yajl_gen_map_close(json_gen);
g_free(label_with_sep);
}
else if ( label != NULL )
value = labelled_value = g_strdup_printf("%s: %s", label, value);
yajl_gen_map_open(json_gen);
const gchar *name;
name = j4status_section_get_name(section);
if ( name != NULL )
{
yajl_gen_string(json_gen, (const unsigned char *)"name", strlen("name"));
yajl_gen_string(json_gen, (const unsigned char *)name, strlen(name));
}
const gchar *instance;
instance = j4status_section_get_instance(section);
if ( instance != NULL )
{
yajl_gen_string(json_gen, (const unsigned char *)"instance", strlen("instance"));
yajl_gen_string(json_gen, (const unsigned char *)instance, strlen(instance));
}
gint64 max_width;
max_width = j4status_section_get_max_width(section);
if ( context->align && ( max_width != 0 ) )
{
yajl_gen_string(json_gen, (const unsigned char *)"min_width", strlen("min_width"));
if ( max_width < 0 )
{
gsize l = - max_width + 1;
if ( ( label != NULL ) && ( label_colour == NULL ) )
l += strlen(label);
gchar max_value[l];
memset(max_value, 'm', l);
max_value[l] ='\0';
yajl_gen_string(json_gen, (const unsigned char *)max_value, l);
}
else
yajl_gen_integer(json_gen, max_width);
const gchar *align = NULL;
switch ( j4status_section_get_align(section) )
{
case J4STATUS_ALIGN_LEFT:
align = "left";
break;
case J4STATUS_ALIGN_RIGHT:
align = "right";
break;
case J4STATUS_ALIGN_CENTER:
break;
}
if ( align != NULL )
{
yajl_gen_string(json_gen, (const unsigned char *)"align", strlen("align"));
yajl_gen_string(json_gen, (const unsigned char *)align, strlen(align));
}
}
J4statusState state = j4status_section_get_state(section);
const gchar *colour = NULL;
switch ( state & ~J4STATUS_STATE_FLAGS )
{
case J4STATUS_STATE_NO_STATE:
colour = context->colours.no_state;
break;
case J4STATUS_STATE_UNAVAILABLE:
colour = context->colours.unavailable;
break;
case J4STATUS_STATE_BAD:
colour = context->colours.bad;
break;
case J4STATUS_STATE_AVERAGE:
colour = context->colours.average;
break;
case J4STATUS_STATE_GOOD:
colour = context->colours.good;
break;
case J4STATUS_STATE_URGENT:
break;
}
if ( state & J4STATUS_STATE_URGENT )
{
yajl_gen_string(json_gen, (const unsigned char *)"urgent", strlen("urgent"));
yajl_gen_bool(json_gen, TRUE);
}
const gchar *forced_colour;
forced_colour = j4status_colour_to_hex(j4status_section_get_colour(section));
if ( forced_colour != NULL )
colour = forced_colour;
if ( colour != NULL )
{
yajl_gen_string(json_gen, (const unsigned char *)"color", strlen("color"));
yajl_gen_string(json_gen, (const unsigned char *)colour, strlen("#000000"));
}
const gchar *short_value;
short_value = j4status_section_get_short_value(section);
if ( short_value != NULL )
{
yajl_gen_string(json_gen, (const unsigned char *)"short_text", strlen("short_text"));
yajl_gen_string(json_gen, (const unsigned char *)short_value, strlen(short_value));
}
yajl_gen_string(json_gen, (const unsigned char *)"full_text", strlen("full_text"));
yajl_gen_string(json_gen, (const unsigned char *)value, strlen(value));
g_free(labelled_value);
yajl_gen_map_close(json_gen);
const unsigned char *buffer;
size_t length;
yajl_gen_get_buf(json_gen, &buffer, &length);
j4status_section_set_cache(section, g_strdup((const gchar *)buffer));
yajl_gen_free(json_gen);
}
void
obj_dump(VALUE obj, yajl_gen gen)
{
int type;
yajl_gen_map_open(gen);
yajl_gen_cstr(gen, "_id");
yajl_gen_value(gen, obj);
struct obj_track *tracker = NULL;
if (st_lookup(objs, (st_data_t)obj, (st_data_t *)&tracker) && BUILTIN_TYPE(obj) != T_NODE) {
yajl_gen_cstr(gen, "file");
yajl_gen_cstr(gen, tracker->source);
yajl_gen_cstr(gen, "line");
yajl_gen_integer(gen, tracker->line);
}
yajl_gen_cstr(gen, "type");
switch (type=BUILTIN_TYPE(obj)) {
case T_DATA:
yajl_gen_cstr(gen, "data");
if (RBASIC(obj)->klass) {
yajl_gen_cstr(gen, "class");
yajl_gen_value(gen, RBASIC(obj)->klass);
yajl_gen_cstr(gen, "class_name");
VALUE name = rb_classname(RBASIC(obj)->klass);
if (RTEST(name))
yajl_gen_cstr(gen, RSTRING(name)->ptr);
else
yajl_gen_cstr(gen, 0);
}
break;
case T_FILE:
yajl_gen_cstr(gen, "file");
break;
case T_FLOAT:
yajl_gen_cstr(gen, "float");
yajl_gen_cstr(gen, "data");
yajl_gen_double(gen, RFLOAT(obj)->value);
break;
case T_BIGNUM:
yajl_gen_cstr(gen, "bignum");
yajl_gen_cstr(gen, "negative");
yajl_gen_bool(gen, RBIGNUM(obj)->sign == 0);
yajl_gen_cstr(gen, "length");
yajl_gen_integer(gen, RBIGNUM(obj)->len);
yajl_gen_cstr(gen, "data");
yajl_gen_string(gen, RBIGNUM(obj)->digits, RBIGNUM(obj)->len);
break;
case T_MATCH:
yajl_gen_cstr(gen, "match");
yajl_gen_cstr(gen, "data");
yajl_gen_value(gen, RMATCH(obj)->str);
break;
case T_REGEXP:
yajl_gen_cstr(gen, "regexp");
yajl_gen_cstr(gen, "length");
yajl_gen_integer(gen, RREGEXP(obj)->len);
yajl_gen_cstr(gen, "data");
yajl_gen_cstr(gen, RREGEXP(obj)->str);
break;
case T_SCOPE:
yajl_gen_cstr(gen, "scope");
struct SCOPE *scope = (struct SCOPE *)obj;
if (scope->local_tbl) {
int i = 1;
int n = scope->local_tbl[0];
VALUE *list = &scope->local_vars[-1];
VALUE cur = *list++;
yajl_gen_cstr(gen, "node");
yajl_gen_value(gen, cur);
if (n) {
yajl_gen_cstr(gen, "variables");
yajl_gen_map_open(gen);
while (n--) {
cur = *list++;
yajl_gen_cstr(gen, scope->local_tbl[i] == 95 ? "_" : rb_id2name(scope->local_tbl[i]));
yajl_gen_value(gen, cur);
i++;
}
yajl_gen_map_close(gen);
}
}
break;
case T_NODE:
yajl_gen_cstr(gen, "node");
yajl_gen_cstr(gen, "node_type");
yajl_gen_cstr(gen, nd_type_str(obj));
yajl_gen_cstr(gen, "file");
yajl_gen_cstr(gen, RNODE(obj)->nd_file);
yajl_gen_cstr(gen, "line");
yajl_gen_integer(gen, nd_line(obj));
yajl_gen_cstr(gen, "node_code");
yajl_gen_integer(gen, nd_type(obj));
switch (nd_type(obj)) {
case NODE_SCOPE:
break;
}
break;
case T_STRING:
yajl_gen_cstr(gen, "string");
yajl_gen_cstr(gen, "length");
yajl_gen_integer(gen, RSTRING(obj)->len);
if (FL_TEST(obj, ELTS_SHARED|FL_USER3)) {
yajl_gen_cstr(gen, "shared");
yajl_gen_value(gen, RSTRING(obj)->aux.shared);
yajl_gen_cstr(gen, "flags");
yajl_gen_array_open(gen);
if (FL_TEST(obj, ELTS_SHARED))
yajl_gen_cstr(gen, "elts_shared");
if (FL_TEST(obj, FL_USER3))
yajl_gen_cstr(gen, "str_assoc");
yajl_gen_array_close(gen);
} else {
yajl_gen_cstr(gen, "data");
yajl_gen_string(gen, (unsigned char *)RSTRING(obj)->ptr, RSTRING(obj)->len);
}
break;
case T_VARMAP:
yajl_gen_cstr(gen, "varmap");
struct RVarmap *vars = (struct RVarmap *)obj;
if (vars->next) {
yajl_gen_cstr(gen, "next");
yajl_gen_value(gen, (VALUE)vars->next);
}
if (vars->id) {
yajl_gen_cstr(gen, "data");
yajl_gen_map_open(gen);
yajl_gen_cstr(gen, rb_id2name(vars->id));
yajl_gen_value(gen, vars->val);
yajl_gen_map_close(gen);
}
break;
case T_CLASS:
case T_MODULE:
case T_ICLASS:
yajl_gen_cstr(gen, type==T_CLASS ? "class" : type==T_MODULE ? "module" : "iclass");
yajl_gen_cstr(gen, "name");
VALUE name = rb_classname(obj);
if (RTEST(name))
yajl_gen_cstr(gen, RSTRING(name)->ptr);
else
yajl_gen_cstr(gen, 0);
yajl_gen_cstr(gen, "super");
yajl_gen_value(gen, RCLASS(obj)->super);
yajl_gen_cstr(gen, "super_name");
VALUE super_name = rb_classname(RCLASS(obj)->super);
if (RTEST(super_name))
yajl_gen_cstr(gen, RSTRING(super_name)->ptr);
else
yajl_gen_cstr(gen, 0);
if (FL_TEST(obj, FL_SINGLETON)) {
yajl_gen_cstr(gen, "singleton");
yajl_gen_bool(gen, 1);
}
if (RCLASS(obj)->iv_tbl && RCLASS(obj)->iv_tbl->num_entries) {
yajl_gen_cstr(gen, "ivars");
yajl_gen_map_open(gen);
st_foreach(RCLASS(obj)->iv_tbl, each_ivar, (st_data_t)gen);
yajl_gen_map_close(gen);
}
if (type != T_ICLASS && RCLASS(obj)->m_tbl && RCLASS(obj)->m_tbl->num_entries) {
yajl_gen_cstr(gen, "methods");
yajl_gen_map_open(gen);
st_foreach(RCLASS(obj)->m_tbl, each_ivar, (st_data_t)gen);
yajl_gen_map_close(gen);
}
break;
case T_OBJECT:
yajl_gen_cstr(gen, "object");
yajl_gen_cstr(gen, "class");
yajl_gen_value(gen, RBASIC(obj)->klass);
yajl_gen_cstr(gen, "class_name");
yajl_gen_cstr(gen, rb_obj_classname(obj));
struct RClass *klass = RCLASS(obj);
if (klass->iv_tbl && klass->iv_tbl->num_entries) {
yajl_gen_cstr(gen, "ivars");
yajl_gen_map_open(gen);
st_foreach(klass->iv_tbl, each_ivar, (st_data_t)gen);
yajl_gen_map_close(gen);
}
break;
case T_ARRAY:
yajl_gen_cstr(gen, "array");
struct RArray *ary = RARRAY(obj);
yajl_gen_cstr(gen, "length");
yajl_gen_integer(gen, ary->len);
if (FL_TEST(obj, ELTS_SHARED)) {
yajl_gen_cstr(gen, "shared");
yajl_gen_value(gen, ary->aux.shared);
} else if (ary->len) {
yajl_gen_cstr(gen, "data");
yajl_gen_array_open(gen);
int i;
for(i=0; i < ary->len; i++)
yajl_gen_value(gen, ary->ptr[i]);
yajl_gen_array_close(gen);
}
break;
case T_HASH:
yajl_gen_cstr(gen, "hash");
struct RHash *hash = RHASH(obj);
yajl_gen_cstr(gen, "length");
if (hash->tbl)
yajl_gen_integer(gen, hash->tbl->num_entries);
else
yajl_gen_integer(gen, 0);
yajl_gen_cstr(gen, "default");
yajl_gen_value(gen, hash->ifnone);
if (hash->tbl && hash->tbl->num_entries) {
yajl_gen_cstr(gen, "data");
//yajl_gen_map_open(gen);
yajl_gen_array_open(gen);
st_foreach(hash->tbl, each_hash_entry, (st_data_t)gen);
yajl_gen_array_close(gen);
//yajl_gen_map_close(gen);
}
break;
default:
yajl_gen_cstr(gen, "unknown");
}
yajl_gen_cstr(gen, "code");
yajl_gen_integer(gen, BUILTIN_TYPE(obj));
yajl_gen_map_close(gen);
}
static gboolean
log_save_foreach(GtkTreeModel *store,
GtkTreePath *path,
GtkTreeIter *iter,
gpointer data)
{
yajl_gen gen = (yajl_gen)data;
network_t net;
signals_node_t *sample;
const gchar *buffer;
gtk_tree_model_get(GTK_TREE_MODEL(ui.model->store), iter,
COL_ADDRESS, &net.address,
COL_FREQUENCY, &net.frequency,
COL_CHANNEL, &net.channel,
COL_MODE, &net.mode,
COL_SSID, &net.ssid,
COL_RADIONAME, &net.radioname,
COL_MAXRSSI, &net.rssi,
COL_PRIVACY, &net.flags.privacy,
COL_ROUTEROS, &net.flags.routeros,
COL_NSTREME, &net.flags.nstreme,
COL_TDMA, &net.flags.tdma,
COL_WDS, &net.flags.wds,
COL_BRIDGE, &net.flags.bridge,
COL_ROUTEROS_VER, &net.routeros_ver,
COL_FIRSTSEEN, &net.firstseen,
COL_LASTSEEN, &net.lastseen,
COL_LATITUDE, &net.latitude,
COL_LONGITUDE, &net.longitude,
COL_SIGNALS, &net.signals,
-1);
yajl_gen_string(gen, (guchar*)net.address, strlen(net.address));
yajl_gen_map_open(gen);
buffer = model_format_frequency(net.frequency);
yajl_gen_string(gen, (guchar*)keys[KEY_FREQUENCY], strlen(keys[KEY_FREQUENCY]));
yajl_gen_number(gen, buffer, strlen(buffer));
yajl_gen_string(gen, (guchar*)keys[KEY_CHANNEL], strlen(keys[KEY_CHANNEL]));
yajl_gen_string(gen, (guchar*)net.channel, strlen(net.channel));
yajl_gen_string(gen, (guchar*)keys[KEY_MODE], strlen(keys[KEY_MODE]));
yajl_gen_string(gen, (guchar*)net.mode, strlen(net.mode));
yajl_gen_string(gen, (guchar*)keys[KEY_SSID], strlen(keys[KEY_SSID]));
yajl_gen_string(gen, (guchar*)net.ssid, strlen(net.ssid));
yajl_gen_string(gen, (guchar*)keys[KEY_RADIONAME], strlen(keys[KEY_RADIONAME]));
yajl_gen_string(gen, (guchar*)net.radioname, strlen(net.radioname));
yajl_gen_string(gen, (guchar*)keys[KEY_RSSI], strlen(keys[KEY_RSSI]));
yajl_gen_integer(gen, net.rssi);
yajl_gen_string(gen, (guchar*)keys[KEY_PRIVACY], strlen(keys[KEY_PRIVACY]));
yajl_gen_integer(gen, net.flags.privacy);
yajl_gen_string(gen, (guchar*)keys[KEY_ROUTEROS], strlen(keys[KEY_ROUTEROS]));
if(net.routeros_ver && strlen(net.routeros_ver))
yajl_gen_string(gen, (guchar*)net.routeros_ver, strlen(net.routeros_ver));
else
yajl_gen_integer(gen, net.flags.routeros);
yajl_gen_string(gen, (guchar*)keys[KEY_NSTREME], strlen(keys[KEY_NSTREME]));
yajl_gen_integer(gen, net.flags.nstreme);
yajl_gen_string(gen, (guchar*)keys[KEY_TDMA], strlen(keys[KEY_TDMA]));
yajl_gen_integer(gen, net.flags.tdma);
yajl_gen_string(gen, (guchar*)keys[KEY_WDS], strlen(keys[KEY_WDS]));
yajl_gen_integer(gen, net.flags.wds);
yajl_gen_string(gen, (guchar*)keys[KEY_BRIDGE], strlen(keys[KEY_BRIDGE]));
yajl_gen_integer(gen, net.flags.bridge);
yajl_gen_string(gen, (guchar*)keys[KEY_FIRSTSEEN], strlen(keys[KEY_FIRSTSEEN]));
yajl_gen_integer(gen, net.firstseen);
yajl_gen_string(gen, (guchar*)keys[KEY_LASTSEEN], strlen(keys[KEY_LASTSEEN]));
yajl_gen_integer(gen, net.lastseen);
if(!isnan(net.latitude) && !isnan(net.longitude))
{
buffer = model_format_gps(net.latitude);
yajl_gen_string(gen, (guchar*)keys[KEY_LATITUDE], strlen(keys[KEY_LATITUDE]));
yajl_gen_number(gen, buffer, strlen(buffer));
buffer = model_format_gps(net.longitude);
yajl_gen_string(gen, (guchar*)keys[KEY_LONGITUDE], strlen(keys[KEY_LONGITUDE]));
yajl_gen_number(gen, buffer, strlen(buffer));
}
if(net.signals->head)
{
yajl_gen_string(gen, (guchar*)keys[KEY_SIGNALS], strlen(keys[KEY_SIGNALS]));
yajl_gen_array_open(gen);
sample = net.signals->head;
while(sample)
{
yajl_gen_map_open(gen);
yajl_gen_string(gen, (guchar*)keys_signals[KEY_SIGNALS_TIMESTAMP], strlen(keys_signals[KEY_SIGNALS_TIMESTAMP]));
yajl_gen_integer(gen, sample->timestamp);
yajl_gen_string(gen, (guchar*)keys_signals[KEY_SIGNALS_RSSI], strlen(keys_signals[KEY_SIGNALS_RSSI]));
yajl_gen_integer(gen, sample->rssi);
if(!isnan(sample->latitude) && !isnan(sample->longitude))
{
buffer = model_format_gps(sample->latitude);
yajl_gen_string(gen, (guchar*)keys_signals[KEY_SIGNALS_LATITUDE], strlen(keys_signals[KEY_SIGNALS_LATITUDE]));
yajl_gen_number(gen, buffer, strlen(buffer));
buffer = model_format_gps(sample->longitude);
yajl_gen_string(gen, (guchar*)keys_signals[KEY_SIGNALS_LONGITUDE], strlen(keys_signals[KEY_SIGNALS_LONGITUDE]));
yajl_gen_number(gen, buffer, strlen(buffer));
}
yajl_gen_map_close(gen);
sample = sample->next;
}
yajl_gen_array_close(gen);
}
yajl_gen_map_close(gen);
/* Signals are stored in GtkListStore just as pointer,
so set it to NULL before freeing the struct */
net.signals = NULL;
network_free(&net);
return FALSE;
}
static bool element(mpack_reader_t* reader, yajl_gen gen, options_t* options, int depth) {
const mpack_tag_t tag = mpack_read_tag(reader);
if (mpack_reader_error(reader) != mpack_ok)
return false;
if (!options->debug && depth == 0 && (tag.type != mpack_type_map && tag.type != mpack_type_array)) {
fprintf(stderr, "%s: Top-level object must be a map or array. Try debug viewing mode (-d)\n", options->command);
return false;
}
// TODO check not depth zero
switch (tag.type) {
case mpack_type_bool: return yajl_gen_bool(gen, tag.v.b) == yajl_gen_status_ok;
case mpack_type_nil: return yajl_gen_null(gen) == yajl_gen_status_ok;
case mpack_type_int: return yajl_gen_integer(gen, tag.v.i) == yajl_gen_status_ok;
case mpack_type_float: return yajl_gen_double(gen, tag.v.f) == yajl_gen_status_ok;
case mpack_type_double: return yajl_gen_double(gen, tag.v.d) == yajl_gen_status_ok;
case mpack_type_uint:
if (tag.v.u > (uint64_t)INT64_MAX) {
char buf[32];
snprintf(buf, sizeof(buf), "%" PRIu64, tag.v.u);
return yajl_gen_string(gen, (const unsigned char*)buf, strlen(buf)) == yajl_gen_status_ok;
}
return yajl_gen_integer(gen, (int64_t)tag.v.u) == yajl_gen_status_ok;
case mpack_type_str:
return string(reader, gen, options, tag.v.l);
case mpack_type_bin:
if (options->base64) {
return base64_bin(reader, gen, options, tag.v.l, options->base64_prefix);
} else if (options->debug) {
mpack_skip_bytes(reader, tag.v.l);
mpack_done_bin(reader);
// output nothing to allow us to print our debug string
skip_quotes = true;
if (yajl_gen_string(gen, (const unsigned char*)"", 0) != yajl_gen_status_ok)
return false;
skip_quotes = false;
char buf[64];
snprintf(buf, sizeof(buf), "<bin of size %u>", tag.v.l);
print(out_file, buf, strlen(buf));
return true;
} else {
fprintf(stderr, "%s: bin unencodable in JSON. Try debug viewing mode (-d)\n", options->command);
return false;
}
case mpack_type_ext:
if (options->base64) {
return base64_ext(reader, gen, options, tag.exttype, tag.v.l);
} else if (options->debug) {
mpack_skip_bytes(reader, tag.v.l);
mpack_done_ext(reader);
// output nothing to allow us to print our debug string
skip_quotes = true;
if (yajl_gen_string(gen, (const unsigned char*)"", 0) != yajl_gen_status_ok)
return false;
skip_quotes = false;
char buf[64];
snprintf(buf, sizeof(buf), "<ext of type %i size %u>", tag.exttype, tag.v.l);
print(out_file, buf, strlen(buf));
return true;
} else {
fprintf(stderr, "%s: ext type %i unencodable in JSON. Try debug viewing mode (-d)\n", options->command, tag.exttype);
return false;
}
case mpack_type_array:
if (yajl_gen_array_open(gen) != yajl_gen_status_ok)
return false;
for (size_t i = 0; i < tag.v.l; ++i)
if (!element(reader, gen, options, depth + 1))
return false;
mpack_done_array(reader);
return yajl_gen_array_close(gen) == yajl_gen_status_ok;
case mpack_type_map:
if (yajl_gen_map_open(gen) != yajl_gen_status_ok)
return false;
for (size_t i = 0; i < tag.v.l; ++i) {
if (options->debug) {
element(reader, gen, options, depth + 1);
} else {
uint32_t len = mpack_expect_str(reader);
if (mpack_reader_error(reader) != mpack_ok) {
fprintf(stderr, "%s: map key is not a string. Try debug viewing mode (-d)\n", options->command);
return false;
}
if (!string(reader, gen, options, len))
return false;
}
if (!element(reader, gen, options, depth + 1))
return false;
}
mpack_done_map(reader);
return yajl_gen_map_close(gen) == yajl_gen_status_ok;
}
return true;
}
ngx_chain_t *
ngx_http_tfs_json_custom_file_info(ngx_http_tfs_json_gen_t *tj_gen,
ngx_http_tfs_custom_meta_info_t *meta_info, uint8_t file_type)
{
size_t size;
u_char time_buf[NGX_HTTP_TFS_GMT_TIME_SIZE];
yajl_gen g;
uint32_t count;
ngx_buf_t *b;
ngx_int_t is_file;
ngx_uint_t i;
ngx_chain_t *cl;
ngx_http_tfs_custom_file_t *file;
g = tj_gen->gen;
size = 0;
if (file_type == NGX_HTTP_TFS_CUSTOM_FT_DIR) {
yajl_gen_array_open(g);
}
for(; meta_info; meta_info = meta_info->next) {
count = meta_info->file_count;
file = meta_info->files;
for (i = 0; i < count; i++) {
yajl_gen_map_open(g);
yajl_gen_string(g, (const unsigned char *) "NAME", 4);
yajl_gen_string(g, (const unsigned char *) file[i].file_name.data,
file[i].file_name.len);
yajl_gen_string(g, (const unsigned char *) "PID", 3);
yajl_gen_integer(g, file[i].file_info.pid);
yajl_gen_string(g, (const unsigned char *) "ID", 2);
yajl_gen_integer(g, file[i].file_info.id);
yajl_gen_string(g, (const unsigned char *) "SIZE", 4);
yajl_gen_integer(g, file[i].file_info.size);
yajl_gen_string(g, (const unsigned char *) "IS_FILE", 7);
if (file_type == NGX_HTTP_TFS_CUSTOM_FT_DIR) {
is_file = (file[i].file_info.pid >> 63) & 0x01;
} else {
is_file = 1;
}
yajl_gen_bool(g, is_file);
ngx_http_tfs_time(time_buf, file[i].file_info.create_time);
yajl_gen_string(g, (const unsigned char *) "CREATE_TIME", 11);
yajl_gen_string(g, time_buf, NGX_HTTP_TFS_GMT_TIME_SIZE);
ngx_http_tfs_time(time_buf, file[i].file_info.modify_time);
yajl_gen_string(g, (const unsigned char *) "MODIFY_TIME", 11);
yajl_gen_string(g, time_buf, NGX_HTTP_TFS_GMT_TIME_SIZE);
yajl_gen_string(g, (const unsigned char *) "VER_NO", 6);
yajl_gen_integer(g, file[i].file_info.ver_no);
yajl_gen_map_close(g);
}
int
enc_json(Encoder* enc, ERL_NIF_TERM term)
{
int ival;
unsigned int uival;
long lval;
unsigned long ulval;
double dval;
ERL_NIF_TERM head;
ERL_NIF_TERM tail;
int arity;
const ERL_NIF_TERM* tuple;
if(enif_is_atom(enc->env, term))
{
return enc_atom(enc, term);
}
if(enif_is_binary(enc->env, term))
{
return enc_binary(enc, term);
}
if(enif_get_int(enc->env, term, &ival))
{
if(yajl_gen_integer(enc->handle, ival) != yajl_gen_status_ok)
{
enc->error = enif_make_atom(enc->env, "bad_integer");
return ERROR;
}
return OK;
}
if(enif_get_uint(enc->env, term, &uival))
{
if(yajl_gen_integer(enc->handle, uival) != yajl_gen_status_ok)
{
enc->error = enif_make_atom(enc->env, "bad_unsigned_integer");
return ERROR;
}
return OK;
}
if(enif_get_long(enc->env, term, &lval))
{
if(yajl_gen_integer(enc->handle, lval) != yajl_gen_status_ok)
{
enc->error = enif_make_atom(enc->env, "bad_long");
return ERROR;
}
return OK;
}
if(enif_get_ulong(enc->env, term, &ulval))
{
if(yajl_gen_integer(enc->handle, ulval) != yajl_gen_status_ok)
{
enc->error = enif_make_atom(enc->env, "bad_unsigned_long");
return ERROR;
}
return OK;
}
if(enif_get_double(enc->env, term, &dval))
{
if(yajl_gen_double(enc->handle, dval) != yajl_gen_status_ok)
{
enc->error = enif_make_atom(enc->env, "bad_double");
return ERROR;
}
return OK;
}
if(enif_is_empty_list(enc->env, term))
{
if(yajl_gen_array_open(enc->handle) != yajl_gen_status_ok)
{
enc->error = enif_make_atom(enc->env, "failed_to_open_empty_list");
return ERROR;
}
if(yajl_gen_array_close(enc->handle) != yajl_gen_status_ok)
{
enc->error = enif_make_atom(enc->env, "failed_to_close_empty_list");
return ERROR;
}
return OK;
}
if(enif_get_list_cell(enc->env, term, &head, &tail))
{
return enc_array(enc, head, tail);
}
if(enif_get_tuple(enc->env, term, &arity, &tuple))
{
if(arity == 1)
{
if(enif_is_empty_list(enc->env, tuple[0]))
{
if(yajl_gen_map_open(enc->handle) != yajl_gen_status_ok)
{
enc->error = enif_make_atom(enc->env,
"failed_to_open_empty_map");
return ERROR;
}
if(yajl_gen_map_close(enc->handle) != yajl_gen_status_ok)
{
enc->error = enif_make_atom(enc->env,
"failed_to_close_empty_map");
return ERROR;
}
return OK;
}
else if(enif_get_list_cell(enc->env, tuple[0], &head, &tail))
{
return enc_map(enc, head, tail);
}
}
}
enc->error = enif_make_tuple(enc->env, 2,
enif_make_atom(enc->env, "badarg"),
term
);
return ERROR;
}
void json_writer::entry_int(int i) { yajl_gen_integer(pimpl->gen, i); }
void json_writer::entry_int(unsigned long long int i) {
yajl_gen_integer(pimpl->gen, i);
}
static int gen_jansson_value(yajl_gen gen, json_t *value) {
json_error_t jerr;
const char *str;
size_t len;
int rc;
int type = json_typeof(value);
switch(type) {
case JSON_OBJECT:
yajl_gen_map_open(gen);
gen_jansson_object(gen,value);
yajl_gen_map_close(gen);
break;
case JSON_ARRAY:
yajl_gen_array_open(gen);
gen_jansson_array(gen,value);
yajl_gen_array_close(gen);
break;
case JSON_STRING:
rc = json_unpack_ex(value, &jerr, 0, "s%", &str,&len);
if(rc != 0) {
rdlog(LOG_ERR,"Couldn't extract string: %s",jerr.text);
return 0;
}
yajl_gen_string(gen, (const unsigned char *)str, len);
break;
case JSON_INTEGER:
{
json_int_t i = json_integer_value(value);
yajl_gen_integer(gen,i);
}
break;
case JSON_REAL:
{
double d = json_number_value(value);
yajl_gen_double(gen,d);
}
break;
case JSON_TRUE:
yajl_gen_bool(gen,1);
break;
case JSON_FALSE:
yajl_gen_bool(gen,0);
break;
case JSON_NULL:
yajl_gen_null(gen);
break;
default:
rdlog(LOG_ERR,"Unkown jansson type %d",type);
break;
};
return 1;
}
/**
* JSON YAJL encode: Encode a list
*
* @param[in,out] handle YAJL generator handle
* @param[in] name Name of @a list (or NULL)
* @param[in] nlen Length of @a name
* @param[in] list IronBee list to encode
*
* @returns IronBee status code
*/
static ib_status_t encode_list(
yajl_gen handle,
const char *name,
size_t nlen,
const ib_list_t *list)
{
ib_status_t rc = IB_OK;
const ib_list_node_t *node;
yajl_gen_status status;
int errors = 0;
/* Encode the name */
if ( (name != NULL) && (nlen != 0) ) {
status = yajl_gen_string(handle, (const unsigned char *)name, nlen);
if (status != yajl_gen_status_ok) {
return IB_EUNKNOWN;
}
}
/* Encode the map start */
status = yajl_gen_map_open(handle);
if (status != yajl_gen_status_ok) {
return IB_EUNKNOWN;
}
IB_LIST_LOOP_CONST(list, node) {
const ib_field_t *field = (const ib_field_t *)node->data;
ib_status_t tmprc;
status = yajl_gen_string(handle,
(const unsigned char *)field->name,
field->nlen);
if (status != yajl_gen_status_ok) {
rc = IB_EUNKNOWN;
++errors;
continue;
}
switch(field->type) {
case IB_FTYPE_LIST:
{
const ib_list_t *list2;
tmprc = ib_field_value(field, ib_ftype_list_out(&list2));
if ( (tmprc != IB_OK) && (rc == IB_OK) ) {
rc = tmprc;
++errors;
}
else {
tmprc = encode_list(handle, NULL, 0, list2);
if ( (tmprc != IB_OK) && (rc == IB_OK) ) {
rc = tmprc;
++errors;
}
}
break;
}
case IB_FTYPE_NUM:
{
ib_num_t num;
tmprc = ib_field_value(field, ib_ftype_num_out(&num));
if ( (tmprc != IB_OK) && (rc == IB_OK) ) {
rc = tmprc;
++errors;
}
else {
status = yajl_gen_integer(handle, num);
if (status != yajl_gen_status_ok) {
if (rc != IB_OK) {
rc = IB_EUNKNOWN;
}
++errors;
}
}
break;
}
case IB_FTYPE_FLOAT:
{
ib_float_t fnum;
tmprc = ib_field_value(field, ib_ftype_float_out(&fnum));
if ( (tmprc != IB_OK) && (rc == IB_OK) ) {
rc = tmprc;
++errors;
}
else {
char buf[float_buf_size+1];
snprintf(buf, float_buf_size, "%#.8Lg", fnum);
status = yajl_gen_number(handle, buf, strlen(buf));
if (status != yajl_gen_status_ok) {
if (rc != IB_OK) {
rc = IB_EUNKNOWN;
}
++errors;
}
}
break;
}
case IB_FTYPE_NULSTR:
{
const char *str;
tmprc = ib_field_value(field, ib_ftype_nulstr_out(&str));
if ( (tmprc != IB_OK) && (rc == IB_OK) ) {
rc = tmprc;
++errors;
}
else {
status = yajl_gen_string(handle,
(unsigned char *)str,
strlen(str));
if (status != yajl_gen_status_ok) {
if (rc != IB_OK) {
rc = IB_EUNKNOWN;
}
++errors;
}
}
break;
}
case IB_FTYPE_BYTESTR:
{
const ib_bytestr_t *bs;
tmprc = ib_field_value(field, ib_ftype_bytestr_out(&bs));
if ( (tmprc != IB_OK) && (rc == IB_OK) ) {
rc = tmprc;
++errors;
}
else {
status = yajl_gen_string(handle,
ib_bytestr_const_ptr(bs),
ib_bytestr_length(bs));
if (status != yajl_gen_status_ok) {
if (rc != IB_OK) {
rc = IB_EUNKNOWN;
}
++errors;
}
}
break;
}
default: /* Just ignore it */
break;
} /* switch(f->type) */
}
/* Encode the map end */
status = yajl_gen_map_close(handle);
if (status != yajl_gen_status_ok) {
return IB_EUNKNOWN;
}
return IB_OK;
}
nx_string_t *nx_logdata_to_json(nx_json_parser_ctx_t *ctx)
{
const unsigned char *json;
size_t jsonlen;
yajl_gen gen;
nx_logdata_field_t *field;
nx_string_t *retval;
char *value;
gen = yajl_gen_alloc(NULL);
yajl_gen_map_open(gen);
for ( field = NX_DLIST_FIRST(&(ctx->logdata->fields));
field != NULL;
field = NX_DLIST_NEXT(field, link) )
{
if ( strcmp(field->key, "raw_event") == 0 )
{
continue;
}
if ( (field->key[0] == '.') || (field->key[0] == '_') )
{
continue;
}
ASSERT(yajl_gen_string(gen, (const unsigned char *) field->key,
strlen(field->key)) == yajl_gen_status_ok);
if ( field->value->defined == FALSE )
{
ASSERT(yajl_gen_null(gen) == yajl_gen_status_ok);
}
else
{
switch ( field->value->type )
{
case NX_VALUE_TYPE_BOOLEAN:
ASSERT(yajl_gen_bool(gen, (int) field->value->boolean) == yajl_gen_status_ok);
break;
case NX_VALUE_TYPE_INTEGER:
ASSERT(yajl_gen_integer(gen, (long long) field->value->integer) == yajl_gen_status_ok);
break;
case NX_VALUE_TYPE_STRING:
ASSERT(yajl_gen_string(gen, (const unsigned char *) field->value->string->buf,
field->value->string->len) == yajl_gen_status_ok);
break;
default:
value = nx_value_to_string(field->value);
ASSERT(yajl_gen_string(gen, (const unsigned char *) value,
strlen(value)) == yajl_gen_status_ok);
free(value);
break;
}
}
}
yajl_gen_map_close(gen);
yajl_gen_get_buf(gen, &json, &jsonlen);
retval = nx_string_create((const char *) json, (int) jsonlen);
yajl_gen_free(gen);
return ( retval );
}
static yajl_gen_status ProcessObject(_YajlEncoder *self, PyObject *object)
{
yajl_gen handle = (yajl_gen)(self->_generator);
yajl_gen_status status = yajl_gen_in_error_state;
PyObject *iterator, *item;
unsigned short int decref = 0;
if (object == Py_None) {
return yajl_gen_null(handle);
}
if (object == Py_True) {
return yajl_gen_bool(handle, 1);
}
if (object == Py_False) {
return yajl_gen_bool(handle, 0);
}
if (PyUnicode_Check(object)) {
object = PyUnicode_AsUTF8String(object);
decref = 1;
}
if (PyString_Check(object)) {
const unsigned char *buffer = NULL;
Py_ssize_t length;
PyString_AsStringAndSize(object, (char **)&buffer, &length);
status = yajl_gen_string(handle, buffer, (unsigned int)(length));
if (decref) {
Py_XDECREF(object);
}
return status;
}
if (PyInt_Check(object)) {
return yajl_gen_integer(handle, PyInt_AsLong(object));
}
if (PyLong_Check(object)) {
return yajl_gen_integer(handle, PyLong_AsLong(object));
}
if (PyFloat_Check(object)) {
return yajl_gen_double(handle, PyFloat_AsDouble(object));
}
if (PyList_Check(object)) {
/*
* Recurse and handle the list
*/
iterator = PyObject_GetIter(object);
if (iterator == NULL)
goto exit;
status = yajl_gen_array_open(handle);
while ((item = PyIter_Next(iterator))) {
status = ProcessObject(self, item);
Py_XDECREF(item);
}
Py_XDECREF(iterator);
status = yajl_gen_array_close(handle);
return status;
}
if (PyDict_Check(object)) {
PyObject *key, *value;
Py_ssize_t position = 0;
status = yajl_gen_map_open(handle);
while (PyDict_Next(object, &position, &key, &value)) {
status = ProcessObject(self, key);
status = ProcessObject(self, value);
}
return yajl_gen_map_close(handle);
}
exit:
return yajl_gen_in_error_state;
}
IoObject *IoYajlGen_pushInteger(IoYajlGen *self, IoObject *locals, IoMessage *m)
{
int i = IoMessage_locals_intArgAt_(m, locals, 0);
yajl_gen_integer(DATA(self), i);
return self;
}
void json_from_bson_long(yajl_gen *g, bson_iterator *it)
{
int64_t value = bson_iterator_long( it );
yajl_gen_integer( *g, value );
}
