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; }