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;
}
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;
}
gboolean
log_save(gchar *filename)
{
gzFile gzfp = NULL;
FILE *fp = NULL;
gchar *ext;
gboolean compression;
yajl_gen gen;
const guchar *json_string;
size_t json_length;
gint wrote;
ext = strrchr(filename, '.');
compression = (ext && !g_ascii_strcasecmp(ext, ".gz"));
if(compression)
gzfp = gzopen(filename, "wb");
else
fp = fopen(filename, "w");
if(!gzfp && !fp)
{
ui_dialog(ui.window,
GTK_MESSAGE_ERROR,
"Error",
"Unable to save a file:\n%s", filename);
return FALSE;
}
gen = yajl_gen_alloc(NULL);
//yajl_gen_config(gen, yajl_gen_beautify, 1);
yajl_gen_map_open(gen);
gtk_tree_model_foreach(GTK_TREE_MODEL(ui.model->store), log_save_foreach, gen);
yajl_gen_map_close(gen);
yajl_gen_get_buf(gen, &json_string, &json_length);
if(compression)
{
wrote = gzwrite(gzfp, json_string, json_length);
gzclose(gzfp);
}
else
{
wrote = fwrite(json_string, sizeof(gchar), json_length, fp);
fclose(fp);
}
yajl_gen_free(gen);
if(json_length != wrote)
{
ui_dialog(ui.window,
GTK_MESSAGE_ERROR,
"Error",
"Unable to save a file:\n%s\n\nWrote only %d of %d uncompressed bytes.",
filename, wrote, json_length);
return FALSE;
}
return TRUE;
}
JsonMapWriter(yajl_gen gen):
JsonWriter(gen)
{
status = yajl_gen_map_open(g);
THROW_EXC_IF_FAILED(status == yajl_gen_status_ok,
"YAJL generator failed, error code: %u", status);
}
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_);
}
yajl_gen_status GenVal(yajl_gen g, yajl_val v) {
yajl_gen_status status;
switch (v->type) {
case yajl_t_string: return yajl_gen_string(g, (unsigned char*)v->u.string, strlen(v->u.string));
case yajl_t_number:
{
char buffer[100];
char *num = buffer;
size_t len;
//if (YAJL_IS_INTEGER(v)) // buggy
if (v->u.number.flags & YAJL_NUMBER_INT_VALID)
len = sprintf(num, "%lld", YAJL_GET_INTEGER(v));
//else if (YAJL_IS_DOUBLE(v)) // buggy
else if (v->u.number.flags & YAJL_NUMBER_DOUBLE_VALID)
len = sprintf(num, "%g", YAJL_GET_DOUBLE(v));
else {
num = YAJL_GET_NUMBER(v);
len = strlen(buffer);
}
return yajl_gen_number(g, num, len);
}
case yajl_t_object:
status = yajl_gen_map_open(g);
if (status != yajl_gen_status_ok)
return status;
for (size_t i = 0; i < v->u.object.len; i++) {
status = yajl_gen_string(g, (unsigned char *)v->u.object.keys[i], strlen(v->u.object.keys[i]));
if (status != yajl_gen_status_ok)
return status;
status = GenVal(g, v->u.object.values[i]);
if (status != yajl_gen_status_ok)
return status;
}
return yajl_gen_map_close(g);
case yajl_t_array:
status = yajl_gen_array_open(g);
if (status != yajl_gen_status_ok)
return status;
for (size_t i = 0; i < v->u.array.len; i++) {
status = GenVal(g, v->u.array.values[i]);
if (status != yajl_gen_status_ok)
return status;
}
return yajl_gen_array_close(g);
case yajl_t_true: return yajl_gen_bool(g, 1);
case yajl_t_false: return yajl_gen_bool(g, 0);
case yajl_t_null: return yajl_gen_null(g);
case yajl_t_any: break;
}
return yajl_gen_in_error_state;
}
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;
}
bool
JSONGenerator::openMap()
{
VALIDATE_STATE();
if (yajl_gen_map_open(mState->mGen) != yajl_gen_status_ok) {
return false;
}
return true;
}
void class_to_json(yajl_gen gen, struct class_t c)
{
const char* id_field = "id";
const char* name_field = "name";
yajl_gen_map_open(gen);
json_insert_int(gen, id_field, c.id);
json_insert_str(gen, name_field, c.name);
yajl_gen_map_close(gen);
}
static int js_generator_open_object(lua_State *L) {
js_generator_assert(L,
yajl_gen_map_open(*js_check_generator(L, 1)),
__FILE__, __LINE__);
/* Why doesn't yajl_gen keep track of this!? */
lua_getfenv(L, 1);
lua_getfield(L, -1, "stack");
lua_pushinteger(L, JS_OPEN_OBJECT);
lua_rawseti(L, -2, lua_objlen(L, -2) + 1);
return 0;
}
/* encode hash open */
VALUE gen_map_open(VALUE rb_yajl_gen) {
yajl_gen_status status;
struct yajl_gen_t *yajl_gen;
Data_Get_Struct(rb_yajl_gen, struct yajl_gen_t, yajl_gen);
if ((status = yajl_gen_map_open(yajl_gen)) != yajl_gen_status_ok) {
rb_funcall(mEncoder2, rb_intern("raise_error_for_status"), 2, INT2FIX(status), rb_str_new2("{"));
}
return Qnil;
}
void race_to_json(yajl_gen gen, struct race_t race)
{
/* Field names */
const char* id_field = "id";
const char* name_field = "name";
const char* sprite_sheet_field = "sprite_sheet";
const char* sprite_height_field = "sprite_height";
yajl_gen_map_open(gen);
json_insert_int(gen, id_field, race.id);
json_insert_str(gen, name_field, race.name);
json_insert_str(gen, sprite_sheet_field, race.sprite_sheet);
json_insert_int(gen, sprite_height_field, race.sprite_height);
yajl_gen_map_close(gen);
}
void json_from_bson_object(yajl_gen *g, bson_iterator *it)
{
yajl_gen_map_open( *g );
while( bson_iterator_next( it ) )
{
bson_type t = bson_iterator_type( it );
const char* key = bson_iterator_key( it );
yajl_gen_string( *g, (const unsigned char*)key, strlen(key) );
json_from_bson_type( t, g, it );
}
yajl_gen_map_close( *g );
}
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;
}
int PNode_op_object(PNode *self, Datum *d)
{
PQuery *q = PNode_startQuery(self);
Datum *k;
yajl_gen_map_open(self->yajl);
while (k = PQuery_key(q))
{
yajl_gen_datum(self->yajl, k);
yajl_gen_datum(self->yajl, PNode_value(self));
PQuery_enumerate(q);
}
yajl_gen_map_close(self->yajl);
if(d) 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;
}
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;
}
int
enc_map(Encoder* enc, ERL_NIF_TERM head, ERL_NIF_TERM tail)
{
int arity;
const ERL_NIF_TERM* tuple;
if(yajl_gen_map_open(enc->handle) != yajl_gen_status_ok)
{
enc->error = enif_make_atom(enc->env, "failed_to_open_map");
return ERROR;
}
do {
if(!enif_get_tuple(enc->env, head, &arity, &tuple))
{
enc->error = enif_make_tuple(enc->env, 2,
enif_make_atom(enc->env, "badarg"),
head
);
return ERROR;
}
if(arity != 2)
{
enc->error = enif_make_tuple(enc->env, 2,
enif_make_atom(enc->env, "badarity"),
head
);
return ERROR;
}
if(enc_key(enc, tuple[0]) != OK) return ERROR;
if(enc_json(enc, tuple[1]) != OK) return ERROR;
} while(enif_get_list_cell(enc->env, tail, &head, &tail));
if(yajl_gen_map_close(enc->handle) != yajl_gen_status_ok)
{
enc->error = enif_make_atom(enc->env, "failed_to_close_map");
return ERROR;
}
return OK;
}
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);
}
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 VALUE rb_cHash_ffi_yajl(VALUE self, VALUE rb_yajl_gen, VALUE state) {
yajl_gen_status status;
VALUE extra;
struct yajl_gen_t *yajl_gen;
Data_Get_Struct(rb_yajl_gen, struct yajl_gen_t, yajl_gen);
extra = rb_hash_new(); /* FIXME: reduce garbage */
rb_hash_aset(extra, rb_str_new2("yajl_gen"), rb_yajl_gen);
rb_hash_aset(extra, rb_str_new2("state"), state);
CHECK_STATUS(
yajl_gen_map_open(yajl_gen)
);
rb_hash_foreach(self, rb_cHash_ffi_yajl_callback, extra);
CHECK_STATUS(
yajl_gen_map_close(yajl_gen)
);
return Qnil;
}
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;
}
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);
}
static int reformat_start_map(void* ctx) {
ccJSONContext* jc = (ccJSONContext*)ctx;
if(jc->root) {
CCJSONObject* jo = CCJSONObject::create();
bool array = *(jc->flagStack->rbegin());
if(array) {
CCJSONArray* p = (CCJSONArray*)(*(jc->objStack->rbegin()));
p->addObject(jo);
} else {
CCJSONObject* p = (CCJSONObject*)(*(jc->objStack->rbegin()));
p->addObject(jc->key, jo);
}
jc->objStack->push_back(jo);
jc->flagStack->push_back(false);
} else {
jc->root = CCJSONObject::create();
jc->objStack->push_back(jc->root);
jc->flagStack->push_back(false);
}
return yajl_gen_status_ok == yajl_gen_map_open(jc->g);
}
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;
}
IoObject *IoYajlGen_openMap(IoYajlGen *self, IoObject *locals, IoMessage *m)
{
yajl_gen_map_open(DATA(self));
return self;
}
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 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;
}
void
rb_journalist_socket_send(int count, const char *event, ...)
{
pthread_mutex_lock(&sock_mutex);
yajl_gen_map_open(gen);
yajl_gen_string(gen, (const unsigned char *)"event", 5);
yajl_gen_string(gen, (const unsigned char *)event, strlen(event));
if(count > 0) {
va_list arguments;
va_start(arguments, event);
char buf[32];
const char *key;
int type;
size_t length;
char *string;
int integer;
uint64_t uint64;
int i;
for(i = 0; i < count; i++) {
key = va_arg(arguments, char *);
type = va_arg(arguments, int);
yajl_gen_string(gen, (const unsigned char *)key, strlen(key));
switch(type) {
case 's':
string = va_arg(arguments, char *);
length = strlen(string);
yajl_gen_string(gen, (const unsigned char *)string, length);
break;
case 'i':
integer = va_arg(arguments, int);
sprintf(buf, "%d", integer);
length = strlen(buf);
yajl_gen_number(gen, buf, length);
break;
case 'b':
yajl_gen_bool(gen, va_arg(arguments, int));
break;
case 't':
uint64 = va_arg(arguments, uint64_t);
sprintf(buf, "%" PRIu64, uint64);
length = strlen(buf);
yajl_gen_number(gen, buf, length);
break;
}
}
va_end(arguments);
}
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;
}
