static yajl_gen_status
generate_key(yajl_gen g, Var v, void *ctx)
{
struct generate_context *gctx = (struct generate_context *)ctx;
switch (v.type) {
case TYPE_OBJ:
case TYPE_INT:
case TYPE_FLOAT:
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));
}
default:
panic("Unsupported type in generate_key()");
}
return yajl_gen_keys_must_be_strings;
}
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;
}
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::addPair(const std::string& key, const std::string& value)
{
VALIDATE_STATE();
if (yajl_gen_string(mState->mGen, (const unsigned char *)key.c_str(), key.length()) != yajl_gen_status_ok) {
return false;
} else if (yajl_gen_string(mState->mGen, (const unsigned char *)value.c_str(), value.length()) != yajl_gen_status_ok) {
return false;
}
return true;
}
void write(const std::string &s)
{
status = yajl_gen_string(g, YAJL_STR(s), YAJL_STR_SIZE(s));
THROW_EXC_IF_FAILED(status == yajl_gen_status_ok,
"YAJL generator failed, error code: %u, data: %s",
status, s.c_str());
}
static int reformat_map_key(void* ctx, const unsigned char* stringVal, size_t stringLen) {
ccJSONContext* jc = (ccJSONContext*)ctx;
memcpy(jc->key, stringVal, stringLen * sizeof(unsigned char));
jc->key[stringLen] = 0;
return yajl_gen_status_ok == yajl_gen_string(jc->g, stringVal, stringLen);
}
static int reformat_map_key(void * ctx, const unsigned char * stringVal,
unsigned int stringLen)
{
yajl_gen g = (yajl_gen) ctx;
yajl_gen_string(g, stringVal, stringLen);
return 1;
}
void json_from_bson_string(yajl_gen *g, bson_iterator *it)
{
const char* value = bson_iterator_string( it );
int length = bson_iterator_string_len( it );
yajl_gen_string( *g, (unsigned char*)value, length - 1 );
}
static int
write_string(struct jsonrpc_request *req, void *ctx)
{
const unsigned char *str = (unsigned char *)ctx;
return yajl_gen_string(req->gen, str, strlen((const char *)str));
}
// Converts MessagePack bin/ext bytes to JSON base64 string
static bool base64(mpack_reader_t* reader, yajl_gen gen, options_t* options, uint32_t len, char* output, char* p, bool prefix) {
if (prefix) {
memcpy(p, b64_str, strlen(b64_str));
p += strlen(b64_str);
}
base64_encodestate state;
base64_init_encodestate(&state);
while (len > 0) {
char buf[4096];
uint32_t count = (len < sizeof(buf)) ? len : sizeof(buf);
len -= count;
mpack_read_bytes(reader, buf, count);
if (mpack_reader_error(reader) != mpack_ok) {
fprintf(stderr, "%s: error reading base64 bytes\n", options->command);
return false;
}
p += base64_encode_block(buf, (int)count, p, &state);
}
p += base64_encode_blockend(p, &state);
bool ret = yajl_gen_string(gen, (const unsigned char*)output, p - output) == yajl_gen_status_ok;
return ret;
}
static int lyajl_gen_string (lua_State *L) {
size_t len;
const char *value;
luvit_generator_t *generator = generator_get(L, 1);
value = luaL_checklstring(L, 2, &len);
yajl_gen_string(generator->gen, (const unsigned char*)value, len);
return 0;
}
yajl_gen_status
yajl_gen_cstr(yajl_gen gen, const char * str)
{
if (!str || str[0] == 0)
return yajl_gen_null(gen);
else
return yajl_gen_string(gen, (unsigned char *)str, strlen(str));
}
static int json_add_string(yajl_gen g, char const *str) /* {{{ */
{
if (str == NULL)
return (int)yajl_gen_null(g);
return (int)yajl_gen_string(g, (unsigned char const *)str,
(unsigned int)strlen(str));
} /* }}} int json_add_string */
static int reformat_string(void * ctx, const unsigned char * stringVal,
size_t stringLen)
{
yajl_gen g = (yajl_gen) ctx;
int ret = (yajl_gen_status_ok == yajl_gen_string(g, stringVal, stringLen));
std::cout << "String: " << stringVal << std::endl;
return ret;
}
static VALUE rb_cString_ffi_yajl(VALUE self, VALUE rb_yajl_gen, VALUE state) {
yajl_gen_status status;
struct yajl_gen_t *yajl_gen;
Data_Get_Struct(rb_yajl_gen, struct yajl_gen_t, yajl_gen);
CHECK_STATUS(
yajl_gen_string(yajl_gen, (unsigned char *)RSTRING_PTR(self), RSTRING_LEN(self))
);
return Qnil;
}
static int js_generator_string(lua_State *L) {
size_t len;
const unsigned char* str = (const unsigned char*)luaL_checklstring(L, 2, &len);
js_generator_assert(L,
yajl_gen_string(*js_check_generator(L, 1),
str, len),
__FILE__, __LINE__);
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;
}
IoObject *IoYajlGen_pushString(IoYajlGen *self, IoObject *locals, IoMessage *m)
{
IoSeq *s = IoMessage_locals_seqArgAt_(m, locals, 0);
yajl_gen_string(DATA(self),
(const unsigned char *)IOSYMBOL_BYTES(s),
IOSYMBOL_LENGTH(s));
return self;
}
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;
}
/* encode a c-string as a yajl string */
VALUE gen_cstring(VALUE rb_yajl_gen, char *cptr, int len) {
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_string(yajl_gen, (unsigned char *)cptr, len)) != yajl_gen_status_ok) {
rb_funcall(mEncoder2, rb_intern("raise_error_for_status"), 2, INT2FIX(status), rb_str_new(cptr, len));
}
return Qnil;
}
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_cSymbol_ffi_yajl(VALUE self, VALUE rb_yajl_gen, VALUE state) {
yajl_gen_status status;
ID sym_to_s = rb_intern("to_s");
VALUE str = rb_funcall(self, sym_to_s, 0);
char *cptr = RSTRING_PTR(str);
int len = RSTRING_LEN(str);
struct yajl_gen_t *yajl_gen;
Data_Get_Struct(rb_yajl_gen, struct yajl_gen_t, yajl_gen);
CHECK_STATUS(
yajl_gen_string(yajl_gen, (unsigned char *)cptr, len)
);
return Qnil;
}
veBool pubnub_atPublishN(struct PubnubAt* nubat, char const *buf, size_t buf_len)
{
struct PubnubRequest *nubreq;
u8 const *json;
size_t json_len;
/* allocate request */
if (!nubat->g) {
nubat->g = yajl_gen_alloc(NULL);
if (!nubat->g)
return veFalse;
}
nubreq = (struct PubnubRequest *) ve_malloc(sizeof(struct PubnubRequest));
if (!nubreq) {
/* reuse the nubat->q next time */
return veFalse;
}
pubnub_req_init(&nubat->nub, nubreq, 512, 512);
/* build json data.. */
if (yajl_gen_string(nubat->g, (u8*) buf, buf_len) != yajl_gen_status_ok) {
ve_error("json: not a valid string");
goto error;
}
if (yajl_gen_get_buf(nubat->g, &json, &json_len) != yajl_gen_status_ok) {
ve_error("json: could not get buf");
return veFalse;
}
/* sent it */
if (pubnub_publish(nubreq, (char*) json, publish_callback) != RET_OK) {
ve_error("could not pubnub_publish");
goto error;
}
yajl_gen_clear(nubat->g); /* empty buffers */
yajl_gen_free(nubat->g);
nubat->g = NULL;
return veTrue;
error:
pubnub_req_deinit(nubreq);
ve_free(nubreq);
yajl_gen_free(nubat->g);
nubat->g = NULL;
return veFalse;
}
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);
}
bool
JSONGenerator::addPair(const std::string& key, const int value)
{
VALIDATE_STATE();
std::stringstream stream;
stream << value;
std::string str = stream.str();
if (yajl_gen_string(mState->mGen, (const unsigned char *)key.c_str(), key.length()) != yajl_gen_status_ok) {
return false;
} else if (yajl_gen_number(mState->mGen, str.c_str(), str.length()) != yajl_gen_status_ok) {
return false;
}
return true;
}
int
enc_key(Encoder* enc, ERL_NIF_TERM key)
{
char buf[512];
ErlNifBinary bin;
if(enif_is_atom(enc->env, key))
{
if(!enif_get_atom_compat(enc->env, key, buf, 512))
{
enc->error = enif_make_atom(enc->env, "failed_getting_atom_key");
return ERROR;
}
if(yajl_gen_string(enc->handle, (unsigned char*) buf, strlen(buf))
!= yajl_gen_status_ok)
{
enc->error = enif_make_atom(enc->env, "failed_writing_atom_key");
return ERROR;
}
return OK;
}
else if(enif_inspect_iolist_as_binary(enc->env, key, &bin))
{
if(yajl_gen_string(enc->handle, bin.data, bin.size) != yajl_gen_status_ok)
{
enc->error = enif_make_atom(enc->env, "failed_writing_binary_key");
return ERROR;
}
return OK;
}
enc->error = enif_make_tuple(enc->env, 2,
enif_make_atom(enc->env, "badkey"),
key
);
return ERROR;
}
// Reads MessagePack string bytes and outputs a JSON string
static bool string(mpack_reader_t* reader, yajl_gen gen, options_t* options, uint32_t len) {
char* str = (char*)malloc(len);
mpack_read_bytes(reader, str, len);
if (mpack_reader_error(reader) != mpack_ok) {
fprintf(stderr, "%s: error reading string bytes\n", options->command);
free(str);
return false;
}
mpack_done_str(reader);
yajl_gen_status status = yajl_gen_string(gen, (const unsigned char*)str, len);
free(str);
return status == yajl_gen_status_ok;
}
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 );
}
