/** * @brief Special handling of cases related to closing in non-final * situation. * * Closes the name in the middle (first unequal), so it must be executed * after iterating. (Because closing is in reverse order) * * Following situations are possible: * * (X1) * cur: #/# * next: # * -> closing array (only if levels <0, because it might be outside * array with iterating one level deeper) * * (X2) * cur: #/_ * next: # * -> array iteration, but with anon map * * (X3) * cur: # * next: # * -> array iteration, so do not close array * * (X4) * cur: _/# * next: _ * -> closing map, but only if levels <= 0 (means iteration did nothing) * (otherwise iteration already closed it) * * (X5) * cur: _/_ * next: _ * -> closing map (only if levels <= 0, because iteration did not do it) * * (X6) * cur: _ * next: _ * -> map iteration on same level, doing nothing * * @param g to generate to * @param pcur pointer to current name * @param csize size where cur has next level * @param pnext pointer to next name * @param levels how many levels were handled before (see examples * above) */ static void elektraGenCloseFirst(yajl_gen g, const char* pcur, size_t csize, const char * pnext, int levels) { lookahead_t lookahead = elektraLookahead(pcur, csize); #ifdef ELEKTRA_YAJL_VERBOSE printf ("elektraGenCloseFirst %s -> %s, levels: %d, lookahead: %d\n", pcur, pnext, levels, lookahead); #endif if (*pcur == '#' && *pnext == '#') { if (levels <= 0 && lookahead == LOOKAHEAD_ARRAY) { #ifdef ELEKTRA_YAJL_VERBOSE printf("GEN (X1) closing array in array\n"); #endif yajl_gen_array_close(g); } else if (lookahead == LOOKAHEAD_MAP) { #ifdef ELEKTRA_YAJL_VERBOSE printf("GEN (X2) next anon-map\n"); #endif yajl_gen_map_close(g); } else { #ifdef ELEKTRA_YAJL_VERBOSE printf("(X3) array iteration\n"); #endif } } else if (*pcur != '#') { if (levels <= 0 && lookahead == LOOKAHEAD_ARRAY) { #ifdef ELEKTRA_YAJL_VERBOSE printf("GEN (X4) closing array\n"); #endif yajl_gen_array_close(g); } else if (lookahead == LOOKAHEAD_MAP) { #ifdef ELEKTRA_YAJL_VERBOSE printf("GEN (X5) closing map\n"); #endif yajl_gen_map_close(g); } else { #ifdef ELEKTRA_YAJL_VERBOSE printf("(X6) same level iteration\n"); #endif } } }
/** * @brief Close given number of levels of key * * @pre there is some needed special handling at begin at end, * the caller needs to do that * * For the basename of cur nothing needs to be done * (it was either a value or an array entry) * * Then for every level do: * * * (C1) * #/_ * (lookahead says it is a map in the array) * -> close the anonymous map and then the array * * (C2) * _/# * _/___empty_map * (lookahead says it is not a map) * -> don't do anything * * (C3) * # * -> close the array * * (C4) * _ * -> close the map * * * @param g to yield json information * @param cur the key which name is used for closing * @param levels the number of levels to close */ static void elektraGenCloseIterate(yajl_gen g, const Key *cur, int levels) { keyNameReverseIterator curIt = elektraKeyNameGetReverseIterator(cur); // jump last element elektraKeyNameReverseNext(&curIt); for (int i=0; i<levels; ++i) { elektraKeyNameReverseNext(&curIt); lookahead_t lookahead = elektraLookahead(curIt.current, curIt.size); if (curIt.current[0] == '#') { if (lookahead == LOOKAHEAD_MAP) { #ifdef ELEKTRA_YAJL_VERBOSE printf ("GEN (C1) anon map close\n"); #endif yajl_gen_map_close(g); } #ifdef ELEKTRA_YAJL_VERBOSE printf ("GEN (C3) array close\n"); #endif yajl_gen_array_close(g); } else { if (lookahead == LOOKAHEAD_MAP) { #ifdef ELEKTRA_YAJL_VERBOSE printf ("GEN (C4) map close\n"); #endif yajl_gen_map_close(g); } else { #ifdef ELEKTRA_YAJL_VERBOSE printf ("(C2) lookahead not a map: nothing to do\n"); #endif } } } }
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; }
static int js_generator_close(lua_State *L) { lua_Integer type; /* Why doesn't yajl_gen keep track of this!? */ lua_getfenv(L, 1); lua_getfield(L, -1, "stack"); lua_rawgeti(L, -1, lua_objlen(L, -1)); if ( lua_isnil(L, -1) ) { lua_pushfstring(L, "StackUnderflow: Attempt to call close() when no array or object has been opened at %s line %d", __FILE__, __LINE__); lua_error(L); } type = lua_tointeger(L, -1); switch ( type ) { case JS_OPEN_OBJECT: js_generator_assert(L, yajl_gen_map_close(*js_check_generator(L, 1)), __FILE__, __LINE__); break; case JS_OPEN_ARRAY: js_generator_assert(L, yajl_gen_array_close(*js_check_generator(L, 1)), __FILE__, __LINE__); break; default: lua_pushfstring(L, "Unreachable: internal 'stack' contained invalid integer (%d) at %s line %d", type, __FILE__, __LINE__); lua_error(L); } /* delete the top of the "stack": */ lua_pop(L, 1); lua_pushnil(L); lua_rawseti(L, -2, lua_objlen(L, -2)); return 0; }
static int reformat_end_map(void* ctx) { ccJSONContext* jc = (ccJSONContext*)ctx; jc->objStack->pop_back(); jc->flagStack->pop_back(); return yajl_gen_status_ok == yajl_gen_map_close(jc->g); }
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; }
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; }
void galleryd::response::generate(galleryd::request &req, galleryd::queue &q) { yajl_gen_clear(handle_); yajl_gen_map_open(handle_); try { if(req.method == "status") { constexpr const unsigned char key_states[] = {'s', 't', 'a', 't', 'e'}; yajl_gen_string(handle_, key_states, sizeof(key_states)); yajl_gen_array_open(handle_); for(auto state : q.status(req.items, req.category)) yajl_gen_integer(handle_, state); yajl_gen_array_close(handle_); } else if(req.method == "add") { q.add(req.items, req.category); } else if(req.method == "open") { auto path = q.open(req.items, req.category); if(not path.empty()) { path += '/'; path += req.items[0]; if(fork() == 0) { int fd = open("/dev/null", O_WRONLY); dup2(fd, 2); // redirect stderr execl("/usr/bin/geeqie", "/usr/bin/geeqie", "-r", path.c_str(), nullptr); exit(1); // in case execl returns with an error } } else { // TODO error handling } } } catch(const std::exception &e) { constexpr const unsigned char key_error[] = {'e', 'r', 'r', 'o', 'r'}; const char *err = e.what(); const size_t len = strlen(err); yajl_gen_string(handle_, key_error, sizeof(key_error)); yajl_gen_string(handle_, reinterpret_cast<const unsigned char *>(err), len); } yajl_gen_map_close(handle_); }
static yajl_gen_status generate(yajl_gen g, Var v, void *ctx) { struct generate_context *gctx = (struct generate_context *)ctx; switch (v.type) { case TYPE_INT: return yajl_gen_integer(g, v.v.num); case TYPE_FLOAT: return yajl_gen_double(g, *v.v.fnum); case TYPE_OBJ: case TYPE_ERR: { const char *tmp = value_to_literal(v); if (MODE_EMBEDDED_TYPES == gctx->mode) tmp = append_type(tmp, v.type); return yajl_gen_string(g, (const unsigned char *)tmp, strlen(tmp)); } case TYPE_STR: { const char *tmp = v.v.str; size_t len = strlen(tmp); if (MODE_EMBEDDED_TYPES == gctx->mode) if (TYPE_NONE != valid_type(&tmp, &len)) tmp = append_type(tmp, v.type); return yajl_gen_string(g, (const unsigned char *)tmp, strlen(tmp)); } case TYPE_MAP: { struct do_map_closure dmc; dmc.g = g; dmc.gctx = gctx; dmc.status = yajl_gen_status_ok; yajl_gen_map_open(g); if (mapforeach(v, do_map, &dmc)) return dmc.status; yajl_gen_map_close(g); return yajl_gen_status_ok; } case TYPE_LIST: { int i; yajl_gen_status status; yajl_gen_array_open(g); for (i = 1; i <= v.v.list[0].v.num; i++) { status = generate(g, v.v.list[i], ctx); if (yajl_gen_status_ok != status) return status; } yajl_gen_array_close(g); return yajl_gen_status_ok; } default: panic("Unsupported type in generate()"); } return -1; }
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; }
bool JSONGenerator::closeMap() { VALIDATE_STATE(); if (yajl_gen_map_close(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); }
/* encode a hash close */ VALUE gen_map_close(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_close(yajl_gen)) != yajl_gen_status_ok) { rb_funcall(mEncoder2, rb_intern("raise_error_for_status"), 2, INT2FIX(status), rb_str_new2("}")); } return Qnil; }
/** * @brief Close the last element * * Needs less special handling because cur is fully below next. * * Will fully iterate over all elements. * * @param g handle to yield close events * @param cur current key * @param next the last key (the parentKey) */ void elektraGenCloseFinally(yajl_gen g, const Key *cur, const Key *next) { int curLevels = elektraKeyCountLevel(cur); #ifdef ELEKTRA_YAJL_VERBOSE int nextLevels = elektraKeyCountLevel(next); #endif int equalLevels = elektraKeyCountEqualLevel(cur, next); // 1 for last level not to iterate, 1 after equal int levels = curLevels - equalLevels - 1; const char *pcur = keyName(cur); size_t csize = 0; const char *pnext = keyName(next); size_t nsize = 0; for (int i=0; i < equalLevels+1; ++i) { pcur=keyNameGetOneLevel(pcur+csize,&csize); pnext=keyNameGetOneLevel(pnext+nsize, &nsize); } #ifdef ELEKTRA_YAJL_VERBOSE printf ("elektraGenFinally, eq: %d, cur: %s %d, next: %s %d, " "levels: %d\n", equalLevels, pcur, curLevels, pnext, nextLevels, levels); #endif // fixes elektraGenCloseIterate for the special handling of // arrays finally elektraGenCloseLast(g, cur); // now we iterate over the middle part elektraGenCloseIterate(g, cur, levels); // now we look at the first unequal element // this is the very last element we are about to close if (pcur && *pcur == '#') { #ifdef ELEKTRA_YAJL_VERBOSE printf ("array close FINAL\n"); #endif } else { #ifdef ELEKTRA_YAJL_VERBOSE printf ("GEN map close FINAL\n"); #endif yajl_gen_map_close(g); } }
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 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 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 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); }
IoObject *IoYajlGen_closeMap(IoYajlGen *self, IoObject *locals, IoMessage *m) { yajl_gen_map_close(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; }
static void log_logstash_print (yajl_gen g, int severity, cdtime_t timestamp_time) { FILE *fh; _Bool do_close = 0; struct tm timestamp_tm; char timestamp_str[64]; const unsigned char *buf; time_t tt; #if HAVE_YAJL_V2 size_t len; #else unsigned int len; #endif if (yajl_gen_string(g, (u_char *)"@level", strlen("@level")) != yajl_gen_status_ok) goto err; switch (severity) { case LOG_ERR: if (yajl_gen_string(g, (u_char *)"error", strlen("error")) != yajl_gen_status_ok) goto err; break; case LOG_WARNING: if (yajl_gen_string(g, (u_char *)"warning", strlen("warning")) != yajl_gen_status_ok) goto err; break; case LOG_NOTICE: if (yajl_gen_string(g, (u_char *)"notice", strlen("notice")) != yajl_gen_status_ok) goto err; break; case LOG_INFO: if (yajl_gen_string(g, (u_char *)"info", strlen("info")) != yajl_gen_status_ok) goto err; break; case LOG_DEBUG: if (yajl_gen_string(g, (u_char *)"debug", strlen("debug")) != yajl_gen_status_ok) goto err; break; default: if (yajl_gen_string(g, (u_char *)"unknown", strlen("unknown")) != yajl_gen_status_ok) goto err; break; } if (yajl_gen_string(g, (u_char *)"@timestamp", strlen("@timestamp")) != yajl_gen_status_ok) goto err; tt = CDTIME_T_TO_TIME_T (timestamp_time); gmtime_r (&tt, ×tamp_tm); /* * format time as a UTC ISO 8601 compliant string */ strftime (timestamp_str, sizeof (timestamp_str), "%Y-%m-%d %H:%M:%SZ", ×tamp_tm); timestamp_str[sizeof (timestamp_str) - 1] = '\0'; if (yajl_gen_string(g, (u_char *)timestamp_str, strlen(timestamp_str)) != yajl_gen_status_ok) goto err; if (yajl_gen_map_close(g) != yajl_gen_status_ok) goto err; if (yajl_gen_get_buf(g, &buf, &len) != yajl_gen_status_ok) goto err; pthread_mutex_lock (&file_lock); if (log_file == NULL) { fh = fopen (DEFAULT_LOGFILE, "a"); do_close = 1; } else if (strcasecmp(log_file, "stdout") == 0) { fh = stdout; do_close = 0; } else if (strcasecmp(log_file, "stderr") == 0) { fh = stderr; do_close = 0; } else { fh = fopen (log_file, "a"); do_close = 1; } if (fh == NULL) { char errbuf[1024]; fprintf (stderr, "log_logstash plugin: fopen (%s) failed: %s\n", (log_file == NULL) ? DEFAULT_LOGFILE : log_file, sstrerror (errno, errbuf, sizeof (errbuf))); } else { fprintf(fh, "%s\n", buf); if (do_close) { fclose (fh); } else { fflush(fh); } } pthread_mutex_unlock (&file_lock); yajl_gen_free(g); return; err: yajl_gen_free(g); fprintf(stderr, "Could not correctly generate JSON message\n"); return; } /* void log_logstash_print */