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;
}
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;
}
static int
write_string_array_params(struct jsonrpc_request *req, void *ctx)
{
int status = 0;
if (!YAJL_GEN_KO(status = yajl_gen_array_open(req->gen))) {
for (size_t i = 0; i < req->params->u.array.len; i++) {
yajl_val yajl_str = req->params->u.array.values[i];
char *str = YAJL_GET_STRING(yajl_str);
if (YAJL_GEN_KO(status = yajl_gen_string(req->gen,
(unsigned char *)str, strlen(str))))
break;
}
if (status == 0)
status = yajl_gen_array_close(req->gen);
}
return status;
}
static VALUE rb_cArray_ffi_yajl(VALUE self, VALUE rb_yajl_gen, VALUE state) {
yajl_gen_status status;
ID sym_ffi_yajl = rb_intern("ffi_yajl");
long i;
VALUE val;
struct yajl_gen_t *yajl_gen;
Data_Get_Struct(rb_yajl_gen, struct yajl_gen_t, yajl_gen);
CHECK_STATUS(
yajl_gen_array_open(yajl_gen)
);
for(i=0; i<RARRAY_LEN(self); i++) {
val = rb_ary_entry(self, i);
rb_funcall(val, sym_ffi_yajl, 2, rb_yajl_gen, state);
}
CHECK_STATUS(
yajl_gen_array_close(yajl_gen)
);
return Qnil;
}
int
enc_array(Encoder* enc, ERL_NIF_TERM head, ERL_NIF_TERM tail)
{
if(yajl_gen_array_open(enc->handle) != yajl_gen_status_ok)
{
enc->error = enif_make_atom(enc->env, "failed_to_open_array");
return ERROR;
}
do {
if(enc_json(enc, head) != OK) return ERROR;
} while(enif_get_list_cell(enc->env, tail, &head, &tail));
if(yajl_gen_array_close(enc->handle) != yajl_gen_status_ok)
{
enc->error = enif_make_atom(enc->env, "failed_to_close_array");
return ERROR;
}
return OK;
}
void GenerateRequest(yajl_gen g, const char* fn, bool sendCaller, xlw::XlfOper* argv, int argc)
{
yajl_gen_map_open(g);
yajl_gen_string(g, (const unsigned char*) REQ_TYPE_NAME, strlen(REQ_TYPE_NAME));
yajl_gen_string(g, (const unsigned char*) REQ_TYPE_VAL, strlen(REQ_TYPE_VAL));
yajl_gen_string(g, (const unsigned char*) REQ_VER_NAME, strlen(REQ_VER_NAME));
yajl_gen_string(g, (const unsigned char*) REQ_VER_VAL, strlen(REQ_VER_VAL));
if(sendCaller) {
xlw::XlfOper xlRef, xlSheetName;
xlw::XlfExcel::Instance().Call(xlfCaller, (xlw::LPXLFOPER)xlRef, 0);
xlw::XlfExcel::Instance().Call(xlSheetNm, (xlw::LPXLFOPER)xlSheetName, 1, (xlw::LPXLFOPER)xlRef);
if(xlRef.IsSRef()) {
yajl_gen_string(g, (const unsigned char*) REQ_CALLER_NAME, strlen(REQ_CALLER_NAME));
JSONCodec::Encode(g, &xlRef);
}
if( xlSheetName.IsString() ) {
std::string name_ = xlSheetName.AsString();
yajl_gen_string(g, (const unsigned char*) REQ_SHEET_NAME, strlen(REQ_SHEET_NAME));
yajl_gen_string(g, (const unsigned char*) name_.c_str(), name_.size());
}
}
yajl_gen_string(g, (const unsigned char*) REQ_NAME_NAME, strlen(REQ_NAME_NAME));
yajl_gen_string(g, (const unsigned char*) fn, strlen(fn));
yajl_gen_string(g, (const unsigned char*) REQ_ARGS_NAME, strlen(REQ_ARGS_NAME));
yajl_gen_array_open(g);
// Find last non-missing value
while(argc>0) {
if(argv[argc-1].IsMissing())
argc--;
else
break;
}
for(int i = 0; i < argc; i++) {
JSONCodec::Encode(g, argv[i]);
}
yajl_gen_array_close(g);
yajl_gen_map_close(g);
}
static int reformat_start_array(void* ctx) {
ccJSONContext* jc = (ccJSONContext*)ctx;
if(jc->root) {
CCJSONArray* ja = CCJSONArray::create();
bool array = *(jc->flagStack->rbegin());
if(array) {
CCJSONArray* p = (CCJSONArray*)(*(jc->objStack->rbegin()));
p->addArray(ja);
} else {
CCJSONObject* p = (CCJSONObject*)(*(jc->objStack->rbegin()));
p->addArray(jc->key, ja);
}
jc->objStack->push_back(ja);
jc->flagStack->push_back(true);
} else {
jc->root = CCJSONArray::create();
jc->objStack->push_back(jc->root);
jc->flagStack->push_back(true);
}
return yajl_gen_status_ok == yajl_gen_array_open(jc->g);
}
static int reformat_start_array(void * ctx)
{
yajl_gen g = (yajl_gen) ctx;
return yajl_gen_status_ok == yajl_gen_array_open(g);
}
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 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);
}
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
}
int LKStreamTranslator::handle_start_array(void *ctx) {
return yajl_gen_array_open(static_cast<LKStreamTranslator::ctx_t*>(ctx)->gen) == yajl_gen_status_ok;
}
void json_writer::start_array() { yajl_gen_array_open(pimpl->gen); }
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 yajl_encode_part(void * wrapper, VALUE obj, VALUE io) {
VALUE str, outBuff, otherObj;
yajl_encoder_wrapper * w = wrapper;
yajl_gen_status status;
int idx = 0;
const unsigned char * buffer;
const char * cptr;
unsigned int len;
if (io != Qnil || w->on_progress_callback != Qnil) {
status = yajl_gen_get_buf(w->encoder, &buffer, &len);
if (len >= WRITE_BUFSIZE) {
outBuff = rb_str_new((const char *)buffer, len);
if (io != Qnil) {
rb_io_write(io, outBuff);
} else if (w->on_progress_callback != Qnil) {
rb_funcall(w->on_progress_callback, intern_call, 1, outBuff);
}
yajl_gen_clear(w->encoder);
}
}
switch (TYPE(obj)) {
case T_HASH:
status = yajl_gen_map_open(w->encoder);
/* TODO: itterate through keys in the hash */
VALUE keys = rb_funcall(obj, intern_keys, 0);
VALUE entry, keyStr;
for(idx=0; idx<RARRAY_LEN(keys); idx++) {
entry = rb_ary_entry(keys, idx);
keyStr = rb_funcall(entry, intern_to_s, 0); /* key must be a string */
/* the key */
yajl_encode_part(w, keyStr, io);
/* the value */
yajl_encode_part(w, rb_hash_aref(obj, entry), io);
}
status = yajl_gen_map_close(w->encoder);
break;
case T_ARRAY:
status = yajl_gen_array_open(w->encoder);
for(idx=0; idx<RARRAY_LEN(obj); idx++) {
otherObj = rb_ary_entry(obj, idx);
yajl_encode_part(w, otherObj, io);
}
status = yajl_gen_array_close(w->encoder);
break;
case T_NIL:
status = yajl_gen_null(w->encoder);
break;
case T_TRUE:
status = yajl_gen_bool(w->encoder, 1);
break;
case T_FALSE:
status = yajl_gen_bool(w->encoder, 0);
break;
case T_FIXNUM:
case T_FLOAT:
case T_BIGNUM:
str = rb_funcall(obj, intern_to_s, 0);
cptr = RSTRING_PTR(str);
len = RSTRING_LEN(str);
if (memcmp(cptr, "NaN", 3) == 0 || memcmp(cptr, "Infinity", 8) == 0 || memcmp(cptr, "-Infinity", 9) == 0) {
rb_raise(cEncodeError, "'%s' is an invalid number", cptr);
}
status = yajl_gen_number(w->encoder, cptr, len);
break;
case T_STRING:
cptr = RSTRING_PTR(obj);
len = RSTRING_LEN(obj);
status = yajl_gen_string(w->encoder, (const unsigned char *)cptr, len);
break;
default:
if (rb_respond_to(obj, intern_to_json)) {
str = rb_funcall(obj, intern_to_json, 0);
cptr = RSTRING_PTR(str);
len = RSTRING_LEN(str);
status = yajl_gen_number(w->encoder, cptr, len);
} else {
str = rb_funcall(obj, intern_to_s, 0);
cptr = RSTRING_PTR(str);
len = RSTRING_LEN(str);
status = yajl_gen_string(w->encoder, (const unsigned char *)cptr, len);
}
break;
}
}
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;
}
static int reformat_start_array(void * ctx)
{
yajl_gen g = (yajl_gen) ctx;
GEN_AND_RETURN(yajl_gen_array_open(g));
}
static VALUE
memprof_dump(int argc, VALUE *argv, VALUE self)
{
VALUE str;
FILE *out = NULL;
if (!track_objs)
rb_raise(rb_eRuntimeError, "object tracking disabled, call Memprof.start first");
rb_scan_args(argc, argv, "01", &str);
if (RTEST(str)) {
out = fopen(StringValueCStr(str), "w");
if (!out)
rb_raise(rb_eArgError, "unable to open output file");
}
yajl_gen_config conf = { .beautify = 1, .indentString = " " };
yajl_gen gen = yajl_gen_alloc2((yajl_print_t)&json_print, &conf, NULL, (void*)out);
track_objs = 0;
yajl_gen_array_open(gen);
st_foreach(objs, objs_each_dump, (st_data_t)gen);
yajl_gen_array_close(gen);
yajl_gen_free(gen);
if (out)
fclose(out);
track_objs = 1;
return Qnil;
}
static VALUE
memprof_dump_all(int argc, VALUE *argv, VALUE self)
{
char *heaps = *(char**)bin_find_symbol("heaps",0);
int heaps_used = *(int*)bin_find_symbol("heaps_used",0);
#ifndef sizeof__RVALUE
size_t sizeof__RVALUE = bin_type_size("RVALUE");
#endif
#ifndef sizeof__heaps_slot
size_t sizeof__heaps_slot = bin_type_size("heaps_slot");
#endif
#ifndef offset__heaps_slot__limit
int offset__heaps_slot__limit = bin_type_member_offset("heaps_slot", "limit");
#endif
#ifndef offset__heaps_slot__slot
int offset__heaps_slot__slot = bin_type_member_offset("heaps_slot", "slot");
#endif
char *p, *pend;
int i, limit;
if (sizeof__RVALUE == 0 || sizeof__heaps_slot == 0)
rb_raise(eUnsupported, "could not find internal heap");
VALUE str;
FILE *out = NULL;
rb_scan_args(argc, argv, "01", &str);
if (RTEST(str)) {
out = fopen(StringValueCStr(str), "w");
if (!out)
rb_raise(rb_eArgError, "unable to open output file");
}
yajl_gen_config conf = { .beautify = 0, .indentString = " " };
yajl_gen gen = yajl_gen_alloc2((yajl_print_t)&json_print, &conf, NULL, (void*)out);
track_objs = 0;
//yajl_gen_array_open(gen);
for (i=0; i < heaps_used; i++) {
p = *(char**)(heaps + (i * sizeof__heaps_slot) + offset__heaps_slot__slot);
limit = *(int*)(heaps + (i * sizeof__heaps_slot) + offset__heaps_slot__limit);
pend = p + (sizeof__RVALUE * limit);
while (p < pend) {
if (RBASIC(p)->flags) {
obj_dump((VALUE)p, gen);
// XXX ugh
yajl_gen_clear(gen);
yajl_gen_free(gen);
gen = yajl_gen_alloc2((yajl_print_t)&json_print, &conf, NULL, (void*)out);
while(fputc('\n', out ? out : stdout) == EOF);
}
p += sizeof__RVALUE;
}
}
//yajl_gen_array_close(gen);
yajl_gen_clear(gen);
yajl_gen_free(gen);
if (out)
fclose(out);
track_objs = 1;
return Qnil;
}
void
Init_memprof()
{
VALUE memprof = rb_define_module("Memprof");
eUnsupported = rb_define_class_under(memprof, "Unsupported", rb_eStandardError);
rb_define_singleton_method(memprof, "start", memprof_start, 0);
rb_define_singleton_method(memprof, "stop", memprof_stop, 0);
rb_define_singleton_method(memprof, "stats", memprof_stats, -1);
rb_define_singleton_method(memprof, "stats!", memprof_stats_bang, -1);
rb_define_singleton_method(memprof, "track", memprof_track, -1);
rb_define_singleton_method(memprof, "dump", memprof_dump, -1);
rb_define_singleton_method(memprof, "dump_all", memprof_dump_all, -1);
pagesize = getpagesize();
objs = st_init_numtable();
bin_init();
create_tramp_table();
gc_hook = Data_Wrap_Struct(rb_cObject, sourcefile_marker, NULL, NULL);
rb_global_variable(&gc_hook);
ptr_to_rb_mark_table_add_filename = bin_find_symbol("rb_mark_table_add_filename", NULL);
rb_classname = bin_find_symbol("classname", 0);
rb_add_freelist = bin_find_symbol("add_freelist", 0);
insert_tramp("rb_newobj", newobj_tramp);
insert_tramp("add_freelist", freelist_tramp);
if (getenv("MEMPROF"))
track_objs = 1;
return;
}
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);
}
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;
}
static int reformat_start_array(void * ctx)
{
yajl_gen g = (yajl_gen) ctx;
yajl_gen_array_open(g);
return 1;
}
static int lyajl_gen_array_open (lua_State *L) {
luvit_generator_t *generator = generator_get(L, 1);
yajl_gen_array_open(generator->gen);
return 0;
}
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;
}
static int format_alert(yajl_gen g, notification_t const *n) /* {{{ */
{
yajl_gen_array_open(g);
yajl_gen_map_open(g); /* BEGIN alert */
/*
* labels
*/
JSON_ADD(g, "labels");
yajl_gen_map_open(g); /* BEGIN labels */
JSON_ADD(g, "alertname");
if (strncmp(n->plugin, n->type, strlen(n->plugin)) == 0)
JSON_ADDF(g, "collectd_%s", n->type);
else
JSON_ADDF(g, "collectd_%s_%s", n->plugin, n->type);
JSON_ADD(g, "instance");
JSON_ADD(g, n->host);
/* mangling of plugin instance and type instance into labels is copied from
* the Prometheus collectd exporter. */
if (strlen(n->plugin_instance) > 0) {
JSON_ADD(g, n->plugin);
JSON_ADD(g, n->plugin_instance);
}
if (strlen(n->type_instance) > 0) {
if (strlen(n->plugin_instance) > 0)
JSON_ADD(g, "type");
else
JSON_ADD(g, n->plugin);
JSON_ADD(g, n->type_instance);
}
JSON_ADD(g, "severity");
JSON_ADD(g, (n->severity == NOTIF_FAILURE)
? "FAILURE"
: (n->severity == NOTIF_WARNING)
? "WARNING"
: (n->severity == NOTIF_OKAY) ? "OKAY" : "UNKNOWN");
JSON_ADD(g, "service");
JSON_ADD(g, "collectd");
yajl_gen_map_close(g); /* END labels */
/*
* annotations
*/
JSON_ADD(g, "annotations");
yajl_gen_map_open(g); /* BEGIN annotations */
JSON_ADD(g, "summary");
JSON_ADD(g, n->message);
if (format_json_meta(g, n->meta) != 0)
return -1;
yajl_gen_map_close(g); /* END annotations */
JSON_ADD(g, "startsAt");
format_time(g, n->time);
yajl_gen_map_close(g); /* END alert */
yajl_gen_array_close(g);
return 0;
} /* }}} format_alert */
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 int virJSONValueToStringOne(virJSONValuePtr object,
yajl_gen g)
{
int i;
VIR_DEBUG("object=%p type=%d gen=%p", object, object->type, g);
switch (object->type) {
case VIR_JSON_TYPE_OBJECT:
if (yajl_gen_map_open(g) != yajl_gen_status_ok)
return -1;
for (i = 0; i < object->data.object.npairs ; i++) {
if (yajl_gen_string(g,
(unsigned char *)object->data.object.pairs[i].key,
strlen(object->data.object.pairs[i].key))
!= yajl_gen_status_ok)
return -1;
if (virJSONValueToStringOne(object->data.object.pairs[i].value, g) < 0)
return -1;
}
if (yajl_gen_map_close(g) != yajl_gen_status_ok)
return -1;
break;
case VIR_JSON_TYPE_ARRAY:
if (yajl_gen_array_open(g) != yajl_gen_status_ok)
return -1;
for (i = 0; i < object->data.array.nvalues ; i++) {
if (virJSONValueToStringOne(object->data.array.values[i], g) < 0)
return -1;
}
if (yajl_gen_array_close(g) != yajl_gen_status_ok)
return -1;
break;
case VIR_JSON_TYPE_STRING:
if (yajl_gen_string(g, (unsigned char *)object->data.string,
strlen(object->data.string)) != yajl_gen_status_ok)
return -1;
break;
case VIR_JSON_TYPE_NUMBER:
if (yajl_gen_number(g, object->data.number,
strlen(object->data.number)) != yajl_gen_status_ok)
return -1;
break;
case VIR_JSON_TYPE_BOOLEAN:
if (yajl_gen_bool(g, object->data.boolean) != yajl_gen_status_ok)
return -1;
break;
case VIR_JSON_TYPE_NULL:
if (yajl_gen_null(g) != yajl_gen_status_ok)
return -1;
break;
default:
return -1;
}
return 0;
}
void yajl_encode_part(yajl_gen g, VALUE obj, VALUE io, int write_buffer_size) {
size_t len;
int idx = 0;
VALUE keys, entry, str;
const char * cptr;
yajl_gen_status status;
switch (TYPE(obj)) {
case T_HASH:
status = yajl_gen_map_open(g);
yajl_helper_check_gen_status(status);
keys = rb_funcall(obj, intern_keys, 0);
for(idx = 0; idx < RARRAY_LEN(keys); idx++) {
entry = rb_ary_entry(keys, idx);
str = rb_funcall(entry, intern_to_s, 0); /* key must be a string */
/* the key */
yajl_encode_part(g, str, io, write_buffer_size);
/* the value */
yajl_encode_part(g, rb_hash_aref(obj, entry), io, write_buffer_size);
}
status = yajl_gen_map_close(g);
yajl_helper_check_gen_status(status);
break;
case T_ARRAY:
status = yajl_gen_array_open(g);
yajl_helper_check_gen_status(status);
for(idx = 0; idx < RARRAY_LEN(obj); idx++) {
yajl_encode_part(g, rb_ary_entry(obj, idx), io, write_buffer_size);
}
status = yajl_gen_array_close(g);
yajl_helper_check_gen_status(status);
break;
case T_NIL:
status = yajl_gen_null(g);
yajl_helper_check_gen_status(status);
break;
case T_TRUE:
status = yajl_gen_bool(g, 1);
yajl_helper_check_gen_status(status);
break;
case T_FALSE:
status = yajl_gen_bool(g, 0);
yajl_helper_check_gen_status(status);
break;
case T_FIXNUM:
case T_FLOAT:
case T_BIGNUM:
str = rb_funcall(obj, intern_to_s, 0);
cptr = RSTRING_PTR(str);
len = RSTRING_LEN(str);
if (memcmp(cptr, "NaN", 3) == 0 || memcmp(cptr, "Infinity", 8) == 0 || memcmp(cptr, "-Infinity", 9) == 0) {
rb_raise(e_encodeError, "'%s' is an invalid number", cptr);
}
status = yajl_gen_number(g, cptr, len);
yajl_helper_check_gen_status(status);
break;
case T_STRING:
cptr = RSTRING_PTR(obj);
len = RSTRING_LEN(obj);
status = yajl_gen_string(g, (const unsigned char *)cptr, len);
yajl_helper_check_gen_status(status);
break;
default:
if (rb_respond_to(obj, intern_to_json)) {
str = rb_funcall(obj, intern_to_json, 0);
Check_Type(str, T_STRING);
cptr = RSTRING_PTR(str);
len = RSTRING_LEN(str);
status = yajl_gen_number(g, cptr, len);
yajl_helper_check_gen_status(status);
} else {
str = rb_funcall(obj, intern_to_s, 0);
Check_Type(str, T_STRING);
cptr = RSTRING_PTR(str);
len = RSTRING_LEN(str);
status = yajl_gen_string(g, (const unsigned char *)cptr, len);
yajl_helper_check_gen_status(status);
}
break;
}
wankelEncoder_flush(g, io, write_buffer_size);
}
IoObject *IoYajlGen_openArray(IoYajlGen *self, IoObject *locals, IoMessage *m)
{
yajl_gen_array_open(DATA(self));
return self;
}
std::string StatsPoster::ToJson(const GameStats& s) {
// Use yajl to get the string encoding right
#ifdef DEBUG
yajl_gen_config yajl_config = { 1, " " };
#else
yajl_gen_config yajl_config = { 0, NULL };
#endif
yajl_gen g = yajl_gen_alloc(&yajl_config);
yajl_gen_map_open(g);
GenNum(g, "server_id", s.server_id);
GenNum(g, "server_start", s.server_start);
GenNum(g, "gameid", s.gameid);
GenNum(g, "packid_id", s.params.packid.id);
GenString(g, "packid_hash", base::Format::ToHex(s.params.packid.hash,
sizeof(s.params.packid.hash)));
GenString(g, "title", s.info.title());
GenString(g, "filename", s.info.filename());
GenNum(g, "game_speed", s.params.tGameSpeed);
GenNum(g, "min_players", s.info.minplayers());
GenNum(g, "max_players", s.info.maxplayers());
GenNum(g, "start_utc", s.start_utc);
GenNum(g, "end_utc", s.end_utc);
const char *str = "player_stats";
yajl_gen_string(g, (const unsigned char *)str, strlen(str));
yajl_gen_array_open(g);
for (int i = 0; i < s.player_count; i++) {
yajl_gen_map_open(g);
GenString(g, "name", s.player_stats[i].name);
GenNum(g, "pid", s.player_stats[i].pid);
GenString(g, "ip", s.player_stats[i].ip);
GenString(g, "did", s.player_stats[i].did);
str = "winstats";
yajl_gen_string(g, (const unsigned char *)str, strlen(str));
yajl_gen_map_open(g);
GenNum(g, "side_mask", s.player_stats[i].ws.sidm);
GenNum(g, "side_mask_allies", s.player_stats[i].ws.sidmAllies);
GenNum(g, "credits_acquired", s.player_stats[i].ws.cCreditsAcquired);
GenNum(g, "credits_consumed", s.player_stats[i].ws.cCreditsConsumed);
GenNum(g, "enemy_munts_killed",
s.player_stats[i].ws.cEnemyMobileUnitsKilled);
GenNum(g, "enemy_structs_killed",
s.player_stats[i].ws.cEnemyStructuresKilled);
GenNum(g, "munts_lost", s.player_stats[i].ws.cMobileUnitsLost);
GenNum(g, "structs_lost", s.player_stats[i].ws.cStructuresLost);
GenNum(g, "ff", s.player_stats[i].ws.ff);
str = "unit_counts";
yajl_gen_string(g, (const unsigned char *)str, strlen(str));
yajl_gen_array_open(g);
for (int ut = 0; ut < ARRAYSIZE(s.player_stats[i].ws.acut); ut++) {
yajl_gen_integer(g, s.player_stats[i].ws.acut[ut]);
}
yajl_gen_array_close(g);
str = "built_counts";
yajl_gen_string(g, (const unsigned char *)str, strlen(str));
yajl_gen_array_open(g);
for (int ut = 0; ut < ARRAYSIZE(s.player_stats[i].ws.acutBuilt); ut++) {
yajl_gen_integer(g, s.player_stats[i].ws.acutBuilt[ut]);
}
yajl_gen_array_close(g);
yajl_gen_map_close(g);
yajl_gen_map_close(g);
}
yajl_gen_array_close(g);
yajl_gen_map_close(g);
const char *buf;
unsigned int len;
yajl_gen_get_buf(g, (const unsigned char **)&buf, &len);
std::string result(buf);
yajl_gen_free(g);
return result;
}
