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;
}
xlw::XlfOper HttpProtocol::Execute(const char* name, bool sendCaller, xlw::XlfOper* args, int argc)
{
REQUEST_CONTEXT context;
context.hEvent = CreateEvent(0, 1, 0, 0);
context.hConnect = WinHttpConnect(hSession, host, urlc.nPort, 0);
int flags = WINHTTP_FLAG_BYPASS_PROXY_CACHE;
if(urlc.nScheme == INTERNET_SCHEME_HTTPS)
flags |= WINHTTP_FLAG_SECURE;
context.hRequest = WinHttpOpenRequest(context.hConnect, L"POST", path, 0, 0, 0,
flags);
context.conf.beautify = 0;
context.conf.indentString = "";
context.g = yajl_gen_alloc(&context.conf, 0);
context.px = xlw::XlfOper();
//context.px->xltype = xltypeNil | xlbitDLLFree;
GenerateRequest(context.g, name, sendCaller, args, argc);
const unsigned char * buf;
unsigned int len = 0;
yajl_gen_get_buf(context.g, &buf, &len);
BOOL res = FALSE;
res = WinHttpSendRequest(context.hRequest, 0, 0, (LPVOID) buf, len, len, (DWORD_PTR) &context);
if(!res) {
const char* err = "#Could not connect to server";
Log::Error(err);
WinHttpCloseHandle(context.hRequest);
WinHttpCloseHandle(context.hConnect);
context.px = xlw::XlfOper(err);
return context.px;
}
// TODO timeout/background
res = WinHttpReceiveResponse(context.hRequest, 0);
if(!res) {
const char* err = "#Error retrieving server response";
Log::Error(err);
WinHttpCloseHandle(context.hRequest);
WinHttpCloseHandle(context.hConnect);
context.px = xlw::XlfOper(err);
return context.px;
}
// Check http response code
DWORD status;
DWORD statusLength = 4;
res = WinHttpQueryHeaders(context.hRequest, WINHTTP_QUERY_STATUS_CODE| WINHTTP_QUERY_FLAG_NUMBER,
NULL, &status, &statusLength, 0);
if(!res || status != 200) {
Log::Error("Status code: %d", status);
const char* err = "#Server returned an error";
WinHttpCloseHandle(context.hRequest);
WinHttpCloseHandle(context.hConnect);
context.px = xlw::XlfOper(err);
return context.px;
}
ReadData(&context);
WinHttpCloseHandle(context.hRequest);
WinHttpCloseHandle(context.hConnect);
yajl_gen_clear(context.g);
yajl_gen_free(context.g);
//context.px->xltype |= xlbitDLLFree;
return context.px;
}
void
ngx_http_tfs_json_destroy(ngx_http_tfs_json_gen_t *tj_gen)
{
if (tj_gen != NULL) {
yajl_gen_free(tj_gen->gen);
}
}
static void json_destroy(struct formatter *fmt)
{
struct json_formatter_data *priv = fmt->priv;
yajl_gen_array_close(priv->yajl);
json_print(fmt->f, priv->yajl);
yajl_gen_free(priv->yajl);
}
static void yajl_encoder_wrapper_free(void * wrapper) {
yajl_encoder_wrapper * w = wrapper;
if (w) {
yajl_gen_free(w->encoder);
free(w);
}
}
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;
}
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;
}
/*
* Format (prometheus/alertmanager v1):
*
* [{
* "labels": {
* "alertname": "collectd_cpu",
* "instance": "host.example.com",
* "severity": "FAILURE",
* "service": "collectd",
* "cpu": "0",
* "type": "wait"
* },
* "annotations": {
* "summary": "...",
* // meta
* },
* "startsAt": <rfc3339 time>,
* "endsAt": <rfc3339 time>, // not used
* }]
*/
int format_json_notification(char *buffer, size_t buffer_size, /* {{{ */
notification_t const *n) {
yajl_gen g;
unsigned char const *out;
#if HAVE_YAJL_V2
size_t unused_out_len;
#else
unsigned int unused_out_len;
#endif
if ((buffer == NULL) || (n == NULL))
return EINVAL;
#if HAVE_YAJL_V2
g = yajl_gen_alloc(NULL);
if (g == NULL)
return -1;
#if COLLECT_DEBUG
yajl_gen_config(g, yajl_gen_beautify, 1);
yajl_gen_config(g, yajl_gen_validate_utf8, 1);
#endif
#else /* !HAVE_YAJL_V2 */
yajl_gen_config conf = {0};
#if COLLECT_DEBUG
conf.beautify = 1;
conf.indentString = " ";
#endif
g = yajl_gen_alloc(&conf, NULL);
if (g == NULL)
return -1;
#endif
if (format_alert(g, n) != 0) {
yajl_gen_clear(g);
yajl_gen_free(g);
return -1;
}
/* copy to output buffer */
yajl_gen_get_buf(g, &out, &unused_out_len);
sstrncpy(buffer, (void *)out, buffer_size);
yajl_gen_clear(g);
yajl_gen_free(g);
return 0;
} /* }}} format_json_notification */
void VertexServer_setupYajl(VertexServer *self)
{
if(self->yajl) yajl_gen_free(self->yajl);
yajl_gen_config config = { 0, "" };
self->yajl = yajl_gen_alloc(&config, NULL);
PDB_setYajl_(self->pdb, self->yajl);
}
void pubnub_atDeinit(struct PubnubAt* nubat)
{
pubnub_deinit(&nubat->nub);
pubnub_req_deinit(&nubat->subReq);
if (nubat->g) {
yajl_gen_free(nubat->g);
nubat->g = NULL;
}
}
rc_ReturnCode_t swi_sms_Register(swi_sms_ReceptionCB_t callback, const char* senderPatternPtr,
const char* messagePatternPtr, swi_sms_regId_t *regIdPtr)
{
rc_ReturnCode_t res;
char *payload;
size_t payloadLen;
const char *senderP, *messageP;
cb_list_t *entry;
yajl_gen gen;
int regId;
if (callback == NULL || regIdPtr == NULL)
return RC_BAD_PARAMETER;
senderP = senderPatternPtr ? senderPatternPtr : "";
messageP = messagePatternPtr ? messagePatternPtr : "";
YAJL_GEN_ALLOC(gen);
yajl_gen_array_open(gen);
YAJL_GEN_STRING(senderP, "sender pattern");
YAJL_GEN_STRING(messageP, "message pattern");
yajl_gen_array_close(gen);
YAJL_GEN_GET_BUF(payload, payloadLen);
res = send_reg_payload(payload, payloadLen, ®Id);
if (res != RC_OK)
goto quit;
pthread_mutex_lock(&handler_lock);
if (!cb_list)
{
cb_list = malloc(sizeof(cb_list_t));
entry = cb_list;
}
else
{
for (entry = cb_list; entry->next; entry = entry->next)
;
entry->next = malloc(sizeof(cb_list_t));
entry = entry->next;
}
entry->regId = regId;
entry->cb = callback;
entry->payload = strndup(payload, payloadLen);
entry->next = NULL;
*regIdPtr = entry;
pthread_mutex_unlock(&handler_lock);
quit:
yajl_gen_clear(gen);
yajl_gen_free(gen);
return res;
}
rc_ReturnCode_t swi_sms_Unregister(swi_sms_regId_t regId)
{
rc_ReturnCode_t res;
char *payload, *respPayload;
size_t payloadLen;
uint32_t respPayloadLen;
cb_list_t *entry, *tmp;
yajl_gen gen;
for (entry = cb_list; entry; entry = entry->next)
if (entry == regId)
break;
if (entry == NULL)
return RC_BAD_PARAMETER;
YAJL_GEN_ALLOC(gen);
YAJL_GEN_INTEGER(entry->regId, "regId");
YAJL_GEN_GET_BUF(payload, payloadLen);
res = emp_send_and_wait_response(EMP_UNREGISTERSMSLISTENER, 0, payload, payloadLen, &respPayload, &respPayloadLen);
yajl_gen_clear(gen);
yajl_gen_free(gen);
if (res != RC_OK)
{
SWI_LOG("SMS", ERROR, "Error while unregister sms, res=%d\n", res);
SWI_LOG("SMS", ERROR, "got error msg=%s\n", respPayload);
goto quit;
}
pthread_mutex_lock(&handler_lock);
if (cb_list == regId)
{
free(cb_list);
cb_list = NULL;
}
else
{
for (entry = cb_list; entry; entry = entry->next)
{
if (entry->next == regId)
{
break;
}
}
tmp = entry->next;
entry->next = tmp->next;
free(tmp->payload);
free(tmp);
}
pthread_mutex_unlock(&handler_lock);
quit:
free(respPayload);
return res;
}
/*
* Document-method: encode
*
* call-seq: encode(obj[, io])
*
* +obj+ is the Ruby object to encode to JSON
*
* +io+ is an optional IO used to stream the encoded JSON string to. If no io
* is specified the resulting JSON string is returned. If io is specified,
* this method returns nil
*/
static VALUE wankelEncoder_encode(int argc, VALUE * argv, VALUE self) {
VALUE obj, io, options;
yajl_gen g;
yajl_alloc_funcs alloc_funcs;
yajl_gen_status status;
int write_buffer_size;
const unsigned char * buffer;
size_t len;
rb_scan_args(argc, argv, "11", &obj, &io);
options = rb_iv_get(self, "@options");
alloc_funcs.malloc = yajl_helper_malloc;
alloc_funcs.realloc = yajl_helper_realloc;
alloc_funcs.free = yajl_helper_free;
g = yajl_gen_alloc(&alloc_funcs);
yajl_gen_configure(g, options);
if (io != Qnil && !rb_respond_to(io, intern_io_write)) {
rb_raise(e_encodeError, "output must be a an IO");
}
write_buffer_size = FIX2INT(rb_hash_aref(options, ID2SYM(rb_intern("write_buffer_size"))));
yajl_encode_part(g, obj, io, write_buffer_size);
// TODO: add terminator here if desired
if (io == Qnil) {
status = yajl_gen_get_buf(g, &buffer, &len);
yajl_helper_check_gen_status(status);
io = rb_str_new((const char *)buffer, len);
rb_enc_associate(io, rb_utf8_encoding());
yajl_gen_clear(g);
yajl_gen_free(g);
return io;
} else {
wankelEncoder_flush(g, io, 1);
yajl_gen_free(g);
return Qnil;
}
return self;
}
static void yajl_encoder_wrapper_free(void * wrapper) {
yajl_encoder_wrapper * w = wrapper;
if (w) {
if (w->indentString) {
free(w->indentString);
}
yajl_gen_free(w->encoder);
free(w);
}
}
static int json_end(struct asfd *asfd)
{
int ret=-1;
if(yajl_map_close_w())
goto end;
ret=write_all(asfd);
end:
yajl_gen_free(yajl);
yajl=NULL;
return ret;
}
void
orderly_write_json(const orderly_alloc_funcs * alloc,
const orderly_json * json,
orderly_buf b,
int pretty)
{
yajl_gen_config cfg = { pretty, NULL };
yajl_gen g = yajl_gen_alloc2(bufAppendCallback, &cfg,
(const yajl_alloc_funcs *) alloc,
(void *) b);
int rv = orderly_write_json2(g, json);
yajl_gen_free(g);
}
rc_ReturnCode_t swi_sms_Send(const char *recipientPtr, const char* messagePtr, swi_sms_Format_t format)
{
rc_ReturnCode_t res;
char *payload, *respPayload;
const char *smsFormat = "";
size_t payloadLen;
uint32_t respPayloadLen;
yajl_gen gen;
if (recipientPtr == NULL || messagePtr == NULL || format < SWI_SMS_7BITS || format > SWI_SMS_UCS2)
return RC_BAD_PARAMETER;
switch(format)
{
case SWI_SMS_7BITS:
smsFormat = "7bits";
break;
case SWI_SMS_8BITS:
smsFormat = "8bits";
break;
case SWI_SMS_UCS2:
smsFormat = "ucs2";
break;
default:
break;
}
YAJL_GEN_ALLOC(gen);
yajl_gen_array_open(gen);
YAJL_GEN_STRING(recipientPtr, "recipientPtr");
YAJL_GEN_STRING(messagePtr, "messagePtr");
YAJL_GEN_STRING(smsFormat, "smsFormat");
yajl_gen_array_close(gen);
YAJL_GEN_GET_BUF(payload, payloadLen);
res = emp_send_and_wait_response(EMP_SENDSMS, 0, payload, payloadLen, &respPayload, &respPayloadLen);
yajl_gen_clear(gen);
yajl_gen_free(gen);
if (res != RC_OK)
{
SWI_LOG("SMS", ERROR, "error while sending sms, res=%d\n", res);
SWI_LOG("SMS", ERROR, "got error msg=%s\n", respPayload);
}
free(respPayload);
return res;
}
void reformat(ErlDrvPort port, char* buf, int len)
{
yajl_handle hand;
/* generator config */
yajl_gen_config conf = { 1, " " };
yajl_gen g;
yajl_status stat;
/* allow comments */
yajl_parser_config cfg = { 1, 1 };
g = yajl_gen_alloc(&conf, NULL);
/* ok. open file. let's read and parse */
hand = yajl_alloc(&callbacks, &cfg, NULL, (void *) g);
/* read file data, pass to parser */
stat = yajl_parse(hand, (unsigned char*) buf, len);
if (stat != yajl_status_ok &&
stat != yajl_status_insufficient_data)
{
char* err = (char*) yajl_get_error(hand, 1, (unsigned char*) buf, len);
int len = strlen(err);
ErlDrvTermData msg[] = {
ERL_DRV_ATOM, driver_mk_atom("error"),
ERL_DRV_BUF2BINARY, (ErlDrvTermData) err, (ErlDrvUInt) len,
ERL_DRV_TUPLE, 2
};
driver_send_term(port, driver_caller(port), msg, sizeof(msg) / sizeof(msg[0]));
} else {
const unsigned char* json;
unsigned int len;
yajl_gen_get_buf(g, &json, &len);
ErlDrvTermData msg[] = {
ERL_DRV_ATOM, driver_mk_atom("ok"),
ERL_DRV_BUF2BINARY, (ErlDrvTermData) json, (ErlDrvUInt) len,
ERL_DRV_TUPLE, 2
};
driver_send_term(port, driver_caller(port), msg, sizeof(msg) / sizeof(msg[0]));
yajl_gen_clear(g);
}
yajl_gen_free(g);
yajl_free(hand);
}
static bool convert(options_t* options) {
FILE* in_file;
if (options->in_filename) {
in_file = fopen(options->in_filename, "rb");
if (in_file == NULL) {
fprintf(stderr, "%s: could not open \"%s\" for reading.\n", options->command, options->in_filename);
return false;
}
} else {
in_file = stdin;
}
if (options->out_filename) {
out_file = fopen(options->out_filename, "wb");
if (out_file == NULL) {
fprintf(stderr, "%s: could not open \"%s\" for writing.\n", options->command, options->out_filename);
if (in_file != stdin)
fclose(in_file);
return false;
}
} else {
out_file = stdout;
}
yajl_gen gen = yajl_gen_alloc(NULL);
if (options->pretty)
yajl_gen_config(gen, yajl_gen_beautify);
if (options->debug)
yajl_gen_config(gen, yajl_gen_allow_non_string_keys);
yajl_gen_config(gen, yajl_gen_print_callback, print, out_file);
mpack_reader_t reader;
mpack_reader_init_stack(&reader);
mpack_reader_set_fill(&reader, fill);
mpack_reader_set_context(&reader, in_file);
bool ret = element(&reader, gen, options, 0);
mpack_error_t error = mpack_reader_destroy(&reader);
yajl_gen_free(gen);
if (out_file != stdout)
fclose(out_file);
if (in_file != stdin)
fclose(in_file);
if (!ret || error != mpack_ok)
fprintf(stderr, "%s: parse error %i\n", options->command, (int)error);
return ret;
}
int main(int argc, char ** argv)
{
yajl_handle hand;
yajl_status stat;
yajl_parser_config cfg = { 1, 1 };
int done = 0;
hand = yajl_alloc(&callbacks, &cfg, NULL, (void *) g);
while (!done) {
rd = fread((void *) fileData, 1, sizeof(fileData) - 1, stdin);
if (rd == 0) {
if (!feof(stdin)) {
fprintf(stderr, "error on file read.\n");
break;
}
done = 1;
}
fileData[rd] = 0;
if (done)
/* parse any remaining buffered data */
stat = yajl_parse_complete(hand);
else
/* read file data, pass to parser */
stat = yajl_parse(hand, fileData, rd);
if (stat != yajl_status_ok &&
stat != yajl_status_insufficient_data)
{
unsigned char * str = yajl_get_error(hand, 1, fileData, rd);
fprintf(stderr, (const char *) str);
yajl_free_error(hand, str);
} else {
const unsigned char * buf;
unsigned int len;
yajl_gen_get_buf(g, &buf, &len);
fwrite(buf, 1, len, stdout);
yajl_gen_clear(g);
}
}
yajl_gen_free(g);
yajl_free(hand);
return 0;
}
IoObject *IoYajlGen_generate(IoYajlGen *self, IoObject *locals, IoMessage *m)
{
const unsigned char *jsonBuffer;
unsigned int jsonBufferLength;
yajl_gen_get_buf(DATA(self), &jsonBuffer, &jsonBufferLength);
IoSeq *out = IOSEQ(jsonBuffer, jsonBufferLength);
yajl_gen_free(DATA(self));
yajl_gen_config config = { 0, "" };
IoObject_setDataPointer_(self, yajl_gen_alloc(&config, NULL));
return out;
}
char *virJSONValueToString(virJSONValuePtr object)
{
yajl_gen g;
const unsigned char *str;
char *ret = NULL;
yajl_size_t len;
# ifndef HAVE_YAJL2
yajl_gen_config conf = { 0, " " }; /* Turns off pretty printing since QEMU can't cope */
# endif
VIR_DEBUG("object=%p", object);
# ifdef HAVE_YAJL2
g = yajl_gen_alloc(NULL);
if (g) {
yajl_gen_config(g, yajl_gen_beautify, 0);
yajl_gen_config(g, yajl_gen_indent_string, " ");
yajl_gen_config(g, yajl_gen_validate_utf8, 1);
}
# else
g = yajl_gen_alloc(&conf, NULL);
# endif
if (!g) {
virJSONError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Unable to create JSON formatter"));
goto cleanup;
}
if (virJSONValueToStringOne(object, g) < 0) {
virReportOOMError();
goto cleanup;
}
if (yajl_gen_get_buf(g, &str, &len) != yajl_gen_status_ok) {
virReportOOMError();
goto cleanup;
}
if (!(ret = strdup((const char *)str)))
virReportOOMError();
cleanup:
yajl_gen_free(g);
VIR_DEBUG("result=%s", NULLSTR(ret));
return ret;
}
char *virJSONValueToString(virJSONValuePtr object,
bool pretty)
{
yajl_gen g;
const unsigned char *str;
char *ret = NULL;
yajl_size_t len;
# ifndef WITH_YAJL2
yajl_gen_config conf = { pretty ? 1 : 0, pretty ? " " : " "};
# endif
VIR_DEBUG("object=%p", object);
# ifdef WITH_YAJL2
g = yajl_gen_alloc(NULL);
if (g) {
yajl_gen_config(g, yajl_gen_beautify, pretty ? 1 : 0);
yajl_gen_config(g, yajl_gen_indent_string, pretty ? " " : " ");
yajl_gen_config(g, yajl_gen_validate_utf8, 1);
}
# else
g = yajl_gen_alloc(&conf, NULL);
# endif
if (!g) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Unable to create JSON formatter"));
goto cleanup;
}
if (virJSONValueToStringOne(object, g) < 0) {
virReportOOMError();
goto cleanup;
}
if (yajl_gen_get_buf(g, &str, &len) != yajl_gen_status_ok) {
virReportOOMError();
goto cleanup;
}
ignore_value(VIR_STRDUP(ret, (const char *)str));
cleanup:
yajl_gen_free(g);
VIR_DEBUG("result=%s", NULLSTR(ret));
return ret;
}
IoObject *IoYajlGen_generate(IoYajlGen *self, IoObject *locals, IoMessage *m)
{
const unsigned char *jsonBuffer;
size_t jsonBufferLength;
yajl_gen_get_buf(DATA(self), &jsonBuffer, &jsonBufferLength);
IoSeq *out = IOSEQ(jsonBuffer, jsonBufferLength);
yajl_gen_free(DATA(self));
yajl_gen yg = yajl_gen_alloc(NULL);
//yajl_gen_config(yg, yajl_gen_beautify, 0);
IoObject_setDataPointer_(self, yg);
return out;
}
void VertexServer_free(VertexServer *self)
{
PDB_free(self->pdb);
HttpServer_free(self->httpServer);
Pool_freeGlobalPool();
CHash_free(self->actions);
CHash_free(self->ops);
if (self->yajl)
{
yajl_gen_free(self->yajl);
}
free(self);
}
static VALUE mEncoder_do_yajl_encode(VALUE self, VALUE obj, VALUE yajl_gen_opts, VALUE json_opts) {
ID sym_ffi_yajl = rb_intern("ffi_yajl");
VALUE sym_yajl_gen_beautify = ID2SYM(rb_intern("yajl_gen_beautify"));
VALUE sym_yajl_gen_validate_utf8 = ID2SYM(rb_intern("yajl_gen_validate_utf8"));
VALUE sym_yajl_gen_indent_string = ID2SYM(rb_intern("yajl_gen_indent_string"));
yajl_gen yajl_gen;
const unsigned char *buf;
size_t len;
VALUE state;
VALUE ret;
VALUE indent_string;
VALUE rb_yajl_gen;
yajl_gen = yajl_gen_alloc(NULL);
if ( rb_hash_aref(yajl_gen_opts, sym_yajl_gen_beautify) == Qtrue ) {
yajl_gen_config(yajl_gen, yajl_gen_beautify, 1);
}
if ( rb_hash_aref(yajl_gen_opts, sym_yajl_gen_validate_utf8) == Qtrue ) {
yajl_gen_config(yajl_gen, yajl_gen_validate_utf8, 1);
}
indent_string = rb_hash_aref(yajl_gen_opts, sym_yajl_gen_indent_string);
if (indent_string != Qnil) {
yajl_gen_config(yajl_gen, yajl_gen_indent_string, RSTRING_PTR(indent_string));
} else {
yajl_gen_config(yajl_gen, yajl_gen_indent_string, " ");
}
state = rb_hash_new();
rb_hash_aset(state, rb_str_new2("processing_key"), Qfalse);
rb_hash_aset(state, rb_str_new2("json_opts"), json_opts);
rb_yajl_gen = Data_Wrap_Struct(cYajl_Gen, NULL, NULL, yajl_gen);
rb_funcall(obj, sym_ffi_yajl, 2, rb_yajl_gen, state);
yajl_gen_get_buf(yajl_gen, &buf, &len);
ret = rb_str_new2((char *)buf);
yajl_gen_free(yajl_gen);
return ret;
}
static package
bf_generate_json(Var arglist, Byte next, void *vdata, Objid progr)
{
yajl_gen g;
yajl_gen_config cfg = { 0, "" };
struct generate_context gctx;
gctx.mode = MODE_COMMON_SUBSET;
const char *buf;
unsigned int len;
Var json;
package pack;
if (1 < arglist.v.list[0].v.num) {
if (!mystrcasecmp(arglist.v.list[2].v.str, "common-subset")) {
gctx.mode = MODE_COMMON_SUBSET;
} else if (!mystrcasecmp(arglist.v.list[2].v.str, "embedded-types")) {
gctx.mode = MODE_EMBEDDED_TYPES;
} else {
free_var(arglist);
return make_error_pack(E_INVARG);
}
}
g = yajl_gen_alloc(&cfg, NULL);
if (yajl_gen_status_ok == generate(g, arglist.v.list[1], &gctx)) {
yajl_gen_get_buf(g, (const unsigned char **)&buf, &len);
json.type = TYPE_STR;
json.v.str = str_dup(buf);
pack = make_var_pack(json);
} else {
pack = make_error_pack(E_INVARG);
}
yajl_gen_clear(g);
yajl_gen_free(g);
free_var(arglist);
return pack;
}
TEST_F(Yajl, yajl_gen) {
for (size_t i = 0; i < kTrialCount; i++) {
yajl_gen g = yajl_gen_alloc(NULL);
yajl_gen_status status = GenVal(g, root_);
if (status != yajl_gen_status_ok) {
std::cout << "gen error: " << status << std::endl;
FAIL();
}
const unsigned char * buf;
size_t len;
status = yajl_gen_get_buf(g, &buf, &len);
ASSERT_EQ(yajl_gen_status_ok, status);
//if (i == 0)
// std::cout << len << std::endl;
yajl_gen_free(g);
}
}
swi_status_t swi_sys_Reboot(const char* reasonPtr)
{
char *payload = NULL;
size_t payloadLen = 0;
swi_status_t res;
yajl_gen gen;
YAJL_GEN_ALLOC(gen);
if (reasonPtr == NULL)
goto emp_send;
YAJL_GEN_STRING(reasonPtr, "reasonPtr");
YAJL_GEN_GET_BUF(payload, payloadLen);
emp_send:
res = emp_send_and_wait_response(EMP_REBOOT, 0, payload, payloadLen, NULL, NULL);
yajl_gen_clear(gen);
yajl_gen_free(gen);
return res;
}
PyObject *_internal_encode(_YajlEncoder *self, PyObject *obj)
{
yajl_gen generator = NULL;
yajl_gen_config genconfig = { 0, NULL};
yajl_gen_status status;
struct StringAndUsedCount sauc;
/* initialize context for our printer function which
* performs low level string appending, using the python
* string implementation as a chunked growth buffer */
sauc.used = 0;
sauc.str = lowLevelStringAlloc(PY_YAJL_CHUNK_SZ);
generator = yajl_gen_alloc2(py_yajl_printer, &genconfig, NULL, (void *) &sauc);
self->_generator = generator;
status = ProcessObject(self, obj);
yajl_gen_free(generator);
self->_generator = NULL;
/* if resize failed inside our printer function we'll have a null sauc.str */
if (!sauc.str) {
PyErr_SetObject(PyExc_ValueError, PyString_FromString("Allocation failure"));
return NULL;
}
if (status != yajl_gen_status_ok) {
PyErr_SetObject(PyExc_ValueError, PyString_FromString("Failed to process"));
Py_XDECREF(sauc.str);
return NULL;
}
/* truncate to used size, and resize will handle the null plugging */
_PyString_Resize(&sauc.str, sauc.used);
return sauc.str;
}
