static void test_equal_array()
{
json_t *array1, *array2;
array1 = json_array();
array2 = json_array();
if(!array1 || !array2)
fail("unable to create arrays");
if(!json_equal(array1, array2))
fail("json_equal fails for two empty arrays");
json_array_append_new(array1, json_integer(1));
json_array_append_new(array2, json_integer(1));
json_array_append_new(array1, json_string("foo"));
json_array_append_new(array2, json_string("foo"));
json_array_append_new(array1, json_integer(2));
json_array_append_new(array2, json_integer(2));
if(!json_equal(array1, array2))
fail("json_equal fails for two equal arrays");
json_array_remove(array2, 2);
if(json_equal(array1, array2))
fail("json_equal fails for two inequal arrays");
json_array_append_new(array2, json_integer(3));
if(json_equal(array1, array2))
fail("json_equal fails for two inequal arrays");
json_decref(array1);
json_decref(array2);
}
void JSON::expandArray(int desiredLength)
{
if (!isArray())
{
return;
}
while ((int)json_array_size(_json) < desiredLength) { json_array_append_new(_json, json_null()); }
}
json_ref field_list_to_json_name_array(const w_query_field_list& fieldList) {
auto templ = json_array_of_size(fieldList.size());
for (auto& f : fieldList) {
json_array_append_new(templ, w_string_to_json(f->name));
}
return templ;
}
void ServerState::saveBans() {
DLOG(INFO) << "Saving bans.";
for (timeoutmap_t::iterator i = timeoutList.begin(); i != timeoutList.end(); ) {
if (i->second.end < time(0)) {
timeoutList.erase(i++);
} else {
++i;
}
}
json_t* root = json_object();
json_t* array = json_array();
for (banlist_t::const_iterator i = banList.begin(); i != banList.end(); ++i) {
json_t* ban = json_object();
json_object_set_new_nocheck(ban, "id",
json_integer(i->first)
);
json_object_set_new_nocheck(ban, "character",
json_string_nocheck(i->second.c_str())
);
json_array_append_new(array, ban);
}
json_object_set_new_nocheck(root, "bans", array);
array = json_array();
for (timeoutmap_t::const_iterator i = timeoutList.begin(); i != timeoutList.end(); ++i) {
json_t* timeout = json_object();
json_object_set_new_nocheck(timeout, "id",
json_integer(i->first)
);
json_object_set_new_nocheck(timeout, "end",
json_integer(i->second.end)
);
json_object_set_new_nocheck(timeout, "character",
json_string_nocheck(i->second.character.c_str())
);
json_array_append_new(array, timeout);
}
json_object_set_new_nocheck(root, "timeouts", array);
const char* banstr = json_dumps(root, JSON_INDENT(4));
string contents = banstr;
free((void*) banstr);
json_decref(root);
fsaveFile("./bans.json", contents);
}
static json_t *bunser_array(const char *buf, const char *end,
json_int_t *used, json_error_t *jerr)
{
json_int_t needed;
json_int_t total = 0;
json_int_t i, nelems;
json_t *arrval;
buf++;
total++;
if (!bunser_int(buf, end - buf, &needed, &nelems)) {
if (needed == -1) {
snprintf(jerr->text, sizeof(jerr->text),
"invalid integer encoding 0x%02x for array length. buf=%p\n",
(int)buf[0], buf);
return NULL;
}
*used = needed + total;
snprintf(jerr->text, sizeof(jerr->text),
"invalid array length encoding 0x%02x (needed %d but have %d)",
(int)buf[0], (int)needed, (int)(end - buf));
return NULL;
}
total += needed;
buf += needed;
arrval = json_array();
for (i = 0; i < nelems; i++) {
json_t *item;
needed = 0;
item = bunser(buf, end, &needed, jerr);
total += needed;
buf += needed;
if (!item) {
json_decref(arrval);
*used = total;
return NULL;
}
if (json_array_append_new(arrval, item)) {
json_decref(arrval);
*used = total;
snprintf(jerr->text, sizeof(jerr->text),
"failed to append array item");
return NULL;
}
}
*used = total;
return arrval;
}
/*
* Cria uma mensagem de controle a partir de um ID
* de controle
*/
char * makeJSONControl(int id){
json_t * array = json_array(); // Cria um array JSON
json_t * type_j = json_integer(TYPECONTROL); // Indica que o tipo é mensagem de controle
json_t * controlType_j = json_integer(id); // Indica qual é o ID de controle
// Coloca as informações anteriores na mensagem JSON final
json_array_append_new(array, type_j);
json_array_append_new(array, controlType_j);
// Obtém a mensagem JSON
char* control = json_dumps(array, 0);
// Libera memória
json_decref(array);
// Retorna a mensagem de controle
return control;
}
/*
* Cria uma mensagem JSON a partir de
* uma mensagem de texto
*/
char * makeJSONMessage(char * string){
json_t * array = json_array(); // Cria um array JSON
json_t * type_j = json_integer(TYPEMESSAGE); // Indica que o tipo é mensagem de texto
json_t * messageType_j = json_string(string); // Coloca a mensagem de texto
// Coloca as informações anterior na mensagem JSON final
json_array_append_new(array, type_j);
json_array_append_new(array, messageType_j);
// Obtem a mensagem JSON
char *message = json_dumps(array, 0);
// Libera memória
json_decref(array);
// Retorna a mensagem JSON
return message;
}
/* add a cert item to json array */
static
DWORD
_VmDirAddCertItemToJsonArray(
PVMDIR_CA_CERT pCert,
BOOLEAN bDetail,
json_t *pjCertArray
)
{
DWORD dwError = 0;
json_t *pjCert = NULL;
pjCert = json_object();
if (!pjCert)
{
BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_NO_MEMORY);
}
dwError = json_object_set_new(pjCert, "cn", json_string(pCert->pCN));
BAIL_ON_VMDIR_ERROR(dwError);
dwError = json_object_set_new(
pjCert,
"subjectdn",
json_string(pCert->pSubjectDN));
BAIL_ON_VMDIR_ERROR(dwError);
if (bDetail)
{
dwError = json_object_set_new(
pjCert,
"cert",
json_string(pCert->pCert));
BAIL_ON_VMDIR_ERROR(dwError);
/* crl is optional so set to empty string if null */
dwError = json_object_set_new(
pjCert,
"crl",
json_string(pCert->pCrl ? pCert->pCrl : ""));
BAIL_ON_VMDIR_ERROR(dwError);
}
dwError = json_array_append_new(pjCertArray, pjCert);
BAIL_ON_VMDIR_ERROR(dwError);
cleanup:
return dwError;
error:
if (pjCert)
{
json_decref(pjCert);
}
goto cleanup;
}
json_t *dump_headers(const nghttp2_nv *nva, size_t nvlen) {
json_t *headers;
size_t i;
headers = json_array();
for (i = 0; i < nvlen; ++i) {
json_array_append_new(headers, dump_header(nva[i].name, nva[i].namelen,
nva[i].value, nva[i].valuelen));
}
return headers;
}
void Patch::writePlugins(json_t *jContainer, vector<plugin_t> *plugins, const char *key)
{
json_t *jPlugins = json_array();
for (unsigned j=0; j<plugins->size(); j++) {
json_t *jPlugin = json_object();
plugin_t plugin = plugins->at(j);
json_object_set_new(jPlugin, PATCH_KEY_PLUGIN_PATH, json_string(plugin.path.c_str()));
json_object_set_new(jPlugin, PATCH_KEY_PLUGIN_BYPASS, json_boolean(plugin.bypass));
json_array_append_new(jPlugins, jPlugin);
/* plugin params */
json_t *jPluginParams = json_array();
for (unsigned z=0; z<plugin.params.size(); z++) {
json_array_append_new(jPluginParams, json_real(plugin.params.at(z)));
}
json_object_set_new(jPlugin, PATCH_KEY_PLUGIN_PARAMS, jPluginParams);
}
json_object_set_new(jContainer, key, jPlugins);
}
void node_send_init(void *dummy) {
json_t *plugin_paths = json_array();
json_array_append_new(plugin_paths, json_string(os_bundled_resources_path));
json_t *data = json_object();
json_object_set_new(data, "pluginFolders", plugin_paths);
json_object_set_new(data, "preferencesFolder", json_string(os_preferences_path));
json_object_set_new(data, "version", json_string(LIVERELOAD_VERSION));
node_send("app.init", data);
}
int urn_game_save(const urn_game *game) {
int error = 0;
char str[256];
json_t *json = json_object();
json_t *splits = json_array();
int i;
if (game->title) {
json_object_set_new(json, "title", json_string(game->title));
}
if (game->attempt_count) {
json_object_set_new(json, "attempt_count",
json_integer(game->attempt_count));
}
if (game->world_record) {
urn_time_string_serialized(str, game->world_record);
json_object_set_new(json, "world_record", json_string(str));
}
if (game->start_delay) {
urn_time_string_serialized(str, game->start_delay);
json_object_set_new(json, "start_delay", json_string(str));
}
for (i = 0; i < game->split_count; ++i) {
json_t *split = json_object();
json_object_set_new(split, "title",
json_string(game->split_titles[i]));
urn_time_string_serialized(str, game->split_times[i]);
json_object_set_new(split, "time", json_string(str));
urn_time_string_serialized(str, game->best_splits[i]);
json_object_set_new(split, "best_time", json_string(str));
urn_time_string_serialized(str, game->best_segments[i]);
json_object_set_new(split, "best_segment", json_string(str));
json_array_append_new(splits, split);
}
json_object_set_new(json, "splits", splits);
if (game->theme) {
json_object_set_new(json, "theme", json_string(game->theme));
}
if (game->theme_variant) {
json_object_set_new(json, "theme_variant",
json_string(game->theme_variant));
}
if (game->width) {
json_object_set_new(json, "width", json_integer(game->width));
}
if (game->height) {
json_object_set_new(json, "height", json_integer(game->height));
}
if (!json_dump_file(json, game->path,
JSON_PRESERVE_ORDER | JSON_INDENT(2))) {
error = 1;
}
json_decref(json);
return error;
}
int broker_invoke_create_param(json_t *params,
const char *name, const char *type) {
json_t *param = json_object();
if (broker_invoke_safe_json_set(param, "name", json_string_nocheck(name)) != 0
|| broker_invoke_safe_json_set(param, "type", json_string_nocheck(type)) != 0
|| json_array_append_new(params, param) != 0) {
json_decref(param);
return 1;
}
return 0;
}
/**
* appends a string into the array (the array is ordered and should
* not mess itself)
* @param[in,out] array is an array of strings (may be hashs of filenames
* for instance).
* @param to_append is the string to be appended to the array
*/
void append_string_to_array(json_t *array, gchar *to_append)
{
json_t *string = NULL;
if (array != NULL && to_append != NULL)
{
string = json_string_nocheck((const char *) to_append);
json_array_append_new(array, string);
}
}
/*
* Construct a JSON "structured value" for an iCalendar REQUEST-STATUS.
*/
static json_t *icalreqstattype_as_json_array(struct icalreqstattype stat)
{
json_t *jstat;
char code[22];
icalerror_check_arg_rz((stat.code != ICAL_UNKNOWN_STATUS),"Status");
if (!stat.desc) stat.desc = icalenum_reqstat_desc(stat.code);
jstat = json_array();
snprintf(code, sizeof(code), "%u.%u",
icalenum_reqstat_major(stat.code),
icalenum_reqstat_minor(stat.code));
json_array_append_new(jstat, json_string(code));
json_array_append_new(jstat, json_string(stat.desc));
if (stat.debug) json_array_append_new(jstat, json_string(stat.debug));
return jstat;
}
void ServerState::saveChannels() {
DLOG(INFO) << "Saving channels.";
json_t* root = json_object();
json_t* publicarray = json_array();
json_t* privatearray = json_array();
for (chanptrmap_t::const_iterator i = channelMap.begin(); i != channelMap.end(); ++i) {
ChannelPtr chan = i->second;
if (chan->getType() == CT_PUBLIC) {
json_array_append_new(publicarray, chan->saveChannel());
} else if (chan->getType() == CT_PUBPRIVATE) {
json_array_append_new(privatearray, chan->saveChannel());
}
}
json_object_set_new_nocheck(root, "public", publicarray);
json_object_set_new_nocheck(root, "private", privatearray);
const char* chanstr = json_dumps(root, JSON_INDENT(4));
string contents = chanstr;
free((void*) chanstr);
json_decref(root);
fsaveFile("./channels.json", contents);
}
void ServerState::saveOps() {
DLOG(INFO) << "Saving ops.";
json_t* root = json_array();
for (oplist_t::const_iterator i = opList.begin(); i != opList.end(); ++i) {
json_array_append_new(root, json_string_nocheck(i->c_str()));
}
const char* opstr = json_dumps(root, JSON_INDENT(4));
string contents = opstr;
free((void*) opstr);
json_decref(root);
fsaveFile("./ops.json", contents);
}
static void output_json_txin(json_t *arr, const struct bp_txin *txin)
{
json_t *obj = json_object();
assert(obj != NULL);
bp_json_set_new_int256(obj, "txid", &txin->prevout.hash);
bp_json_set_new_int(obj, "vout", txin->prevout.n);
bp_json_set_new_script(obj, "scriptSig", txin->scriptSig);
bp_json_set_new_int(obj, "sequence", txin->nSequence);
json_array_append_new(arr, obj);
}
nh_bool nhnet_set_option(const char *name, union nh_optvalue value, nh_bool isstr)
{
int ret, i;
json_t *jmsg, *joval, *jobj;
struct nh_option_desc *gameopts, *birthopts, *opt;
struct nh_autopickup_rule *r;
ret = nh_set_option(name, value, isstr);
if (!nhnet_active())
return ret;
if (!api_entry())
return FALSE;
gameopts = nhnet_get_options(GAME_OPTIONS);
birthopts = nhnet_get_options(CURRENT_BIRTH_OPTIONS);
opt = NULL;
for (i = 0; gameopts[i].name && !opt; i++)
if (!strcmp(name, gameopts[i].name))
opt = &gameopts[i];
for (i = 0; birthopts[i].name && !opt; i++)
if (!strcmp(name, birthopts[i].name))
opt = &birthopts[i];
if (opt) {
if (isstr || opt->type == OPTTYPE_STRING)
joval = json_string(value.s);
else if (opt->type == OPTTYPE_INT || opt->type == OPTTYPE_ENUM ||
opt->type == OPTTYPE_BOOL) {
joval = json_integer(value.i);
} else if (opt->type == OPTTYPE_AUTOPICKUP_RULES) {
joval = json_array();
for (i = 0; value.ar && i < value.ar->num_rules; i++) {
r = &value.ar->rules[i];
jobj = json_pack("{ss,si,si,si}", "pattern", r->pattern, "oclass",
r->oclass, "buc", r->buc, "action", r->action);
json_array_append_new(joval, jobj);
}
}
jmsg = json_pack("{ss,so,si}", "name", name, "value", joval, "isstr", isstr);
jmsg = send_receive_msg("set_option", jmsg);
if (json_unpack(jmsg, "{si,so!}", "return", &ret, "option", &jobj) == -1) {
print_error("Bad response in nhnet_set_option");
} else {
free_option_data(opt);
read_json_option(jobj, opt);
}
json_decref(jmsg);
}
api_exit();
return ret;
}
static void JsonAddPacketvars(const Packet *p, json_t *js_vars)
{
if (p == NULL || p->pktvar == NULL) {
return;
}
json_t *js_pktvars = NULL;
PktVar *pv = p->pktvar;
while (pv != NULL) {
if (pv->key || pv->id > 0) {
if (js_pktvars == NULL) {
js_pktvars = json_array();
if (js_pktvars == NULL)
break;
}
json_t *js_pair = json_object();
if (js_pair == NULL) {
break;
}
if (pv->key != NULL) {
uint32_t offset = 0;
uint8_t keybuf[pv->key_len + 1];
PrintStringsToBuffer(keybuf, &offset,
sizeof(keybuf),
pv->key, pv->key_len);
uint32_t len = pv->value_len;
uint8_t printable_buf[len + 1];
offset = 0;
PrintStringsToBuffer(printable_buf, &offset,
sizeof(printable_buf),
pv->value, pv->value_len);
json_object_set_new(js_pair, (char *)keybuf,
json_string((char *)printable_buf));
} else {
const char *varname = VarNameStoreLookupById(pv->id, VAR_TYPE_PKT_VAR);
uint32_t len = pv->value_len;
uint8_t printable_buf[len + 1];
uint32_t offset = 0;
PrintStringsToBuffer(printable_buf, &offset,
sizeof(printable_buf),
pv->value, pv->value_len);
json_object_set_new(js_pair, varname,
json_string((char *)printable_buf));
}
json_array_append_new(js_pktvars, js_pair);
}
pv = pv->next;
}
if (js_pktvars) {
json_object_set_new(js_vars, "pktvars", js_pktvars);
}
}
static json_t *
json_list(const struct nh_listitem *list, int len)
{
int i;
json_t *jarr = json_array();
for (i = 0; i < len; i++)
json_array_append_new(jarr,
json_pack("{si,ss}", "id", list[i].id, "txt",
list[i].caption));
return jarr;
}
static json_t *
json_option(const struct nh_option_desc *option)
{
int i;
json_t *jopt, *joptval, *joptdesc, *jobj;
struct nh_autopickup_rule *r;
switch (option->type) {
case OPTTYPE_BOOL:
joptval = json_integer(option->value.b);
joptdesc = json_object();
break;
case OPTTYPE_INT:
joptval = json_integer(option->value.i);
joptdesc =
json_pack("{si,si}", "max", option->i.max, "min", option->i.min);
break;
case OPTTYPE_ENUM:
joptval = json_integer(option->value.e);
joptdesc = json_list(option->e.choices, option->e.numchoices);
break;
case OPTTYPE_STRING:
joptval = json_string(option->value.s);
joptdesc = json_integer(option->s.maxlen);
break;
case OPTTYPE_AUTOPICKUP_RULES:
joptdesc = json_list(option->a.classes, option->a.numclasses);
joptval = json_array();
for (i = 0; option->value.ar && i < option->value.ar->num_rules; i++) {
r = &option->value.ar->rules[i];
jobj =
json_pack("{ss,si,si,si}", "pattern", r->pattern, "oclass",
r->oclass, "buc", r->buc, "action", r->action);
json_array_append_new(joptval, jobj);
}
break;
default:
joptdesc = json_string("<error: no description for option>");
joptval = json_string("<error>");
break;
}
jopt =
json_pack("{ss,ss,si,so,so}", "name", option->name, "helptxt",
option->helptxt, "type", option->type, "value", joptval,
"desc", joptdesc);
return jopt;
}
void Patch::writeColumns(json_t *jContainer, vector<column_t> *columns)
{
json_t *jColumns = json_array();
for (unsigned i=0; i<columns->size(); i++) {
json_t *jColumn = json_object();
column_t column = columns->at(i);
json_object_set_new(jColumn, PATCH_KEY_COLUMN_INDEX, json_integer(column.index));
json_object_set_new(jColumn, PATCH_KEY_COLUMN_WIDTH, json_integer(column.width));
json_array_append_new(jColumns, jColumn);
}
json_object_set_new(jContainer, PATCH_KEY_COLUMNS, jColumns);
}
static json_t *
json_string_or_array(int nr, char **items)
{
if (nr == 1) {
return json_string(items[0]);
}
json_t *result = json_array();
int i;
for (i = 0; i < nr; ++i) {
json_array_append_new(result, json_string(items[i]));
}
return result;
}
/**
* @param search The search result
*/
static void get_search(sp_search *search)
{
int i;
json_t *json = json_object();
json_t *tracks = json_array();
json_object_set_new(json, "tracks", tracks);
for (i = 0; i < sp_search_num_tracks(search); ++i){
json_array_append_new(tracks, get_track(sp_search_track(search, i)));
}
json_object_set_new_nocheck(json, "query", json_string_nocheck(sp_search_query(search)));
cmd_sendresponse(json, 200);
}
void Patch::writeChannels(json_t *jContainer, vector<channel_t> *channels)
{
json_t *jChannels = json_array();
for (unsigned i=0; i<channels->size(); i++) {
json_t *jChannel = json_object();
channel_t channel = channels->at(i);
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_TYPE, json_integer(channel.type));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_INDEX, json_integer(channel.index));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_COLUMN, json_integer(channel.column));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MUTE, json_integer(channel.mute));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MUTE_S, json_integer(channel.mute_s));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_SOLO, json_integer(channel.solo));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_VOLUME, json_real(channel.volume));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_PAN_LEFT, json_real(channel.panLeft));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_PAN_RIGHT, json_real(channel.panRight));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_IN, json_boolean(channel.midiIn));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_IN_KEYPRESS, json_integer(channel.midiInKeyPress));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_IN_KEYREL, json_integer(channel.midiInKeyRel));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_IN_KILL, json_integer(channel.midiInKill));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_IN_ARM, json_integer(channel.midiInArm));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_IN_VOLUME, json_integer(channel.midiInVolume));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_IN_MUTE, json_integer(channel.midiInMute));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_IN_SOLO, json_integer(channel.midiInSolo));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_OUT_L, json_boolean(channel.midiOutL));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_OUT_L_PLAYING, json_integer(channel.midiOutLplaying));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_OUT_L_MUTE, json_integer(channel.midiOutLmute));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_OUT_L_SOLO, json_integer(channel.midiOutLsolo));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_SAMPLE_PATH, json_string(channel.samplePath.c_str()));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_KEY, json_integer(channel.key));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MODE, json_integer(channel.mode));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_BEGIN, json_integer(channel.begin));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_END, json_integer(channel.end));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_BOOST, json_real(channel.boost));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_REC_ACTIVE, json_integer(channel.recActive));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_PITCH, json_real(channel.pitch));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_IN_READ_ACTIONS, json_integer(channel.midiInReadActions));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_IN_PITCH, json_integer(channel.midiInPitch));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_OUT, json_integer(channel.midiOut));
json_object_set_new(jChannel, PATCH_KEY_CHANNEL_MIDI_OUT_CHAN, json_integer(channel.midiOutChan));
json_array_append_new(jChannels, jChannel);
writeActions(jChannel, &channel.actions);
#ifdef WITH_VST
writePlugins(jChannel, &channel.plugins, PATCH_KEY_CHANNEL_PLUGINS);
#endif
}
json_object_set_new(jContainer, PATCH_KEY_CHANNELS, jChannels);
}
/**
* for the webApp, we print the smoothed values
*/
void print_acceptance_rates(FILE *p_file, struct s_mcmc_calc_data *p, int m_full_iteration)
{
int k;
#if FLAG_JSON
json_t *root;
json_t *j_print = json_array();
#endif
#if FLAG_JSON
json_array_append_new(j_print, json_integer(m_full_iteration));
json_array_append_new(j_print, json_real(p->epsilon));
json_array_append_new(j_print, json_real(p->smoothed_global_acceptance_rate));
#else
fprintf(p_file, "%d,%g,%g", m_full_iteration, p->epsilon, p->global_acceptance_rate);
#endif
/* parameter specific acceptance rates */
if (!OPTION_FULL_UPDATE) {
for(k=0; k< (p->n_acceptance_rates); k++) {
#if FLAG_JSON
json_array_append_new(j_print, json_real(p->smoothed_acceptance_rates[k]));
#else
fprintf(p_file, ",%g", p->acceptance_rates[k]);
#endif
}
}
#if FLAG_JSON
root = json_pack("{s,s,s,o}", "flag", "pmcmc", "msg", j_print);
json_dumpf(root, stdout, JSON_COMPACT); printf("\n");
fflush(stdout);
json_decref(root);
#else
fprintf(p_file, "\n");
#endif
}
json_t * stats_generate(json_t * obj)
{
char * interface = (char *)json_string_value(json_object_get(obj,"interface"));
char * command;
srand(time(NULL));
int r = rand();
json_t * ret=json_array();
char * picname;
command = (char *)calloc(SIZE,sizeof(char));
picname = (char *)calloc(SIZE,sizeof(char));
sprintf(command,"/rom/mnt/cust/etc/vnstatigenerate %s %d",interface,r);
system(command);
sprintf(command,"/rom/mnt/cust/etc/darkstatgenerate %s",interface);
system(command);
//Copying files from darkstat backup
system("rm -rf /etc/statistics/darkstat/files.txt");
sprintf(command,"echo Current > /tmp/statistics/darkstat/files.txt && ls /etc/statistics/darkstat/*_%s.txt|sed 's/\\/etc\\/statistics\\/darkstat\\///g'|sed 's/\_hosts\_.\*.txt//g' >> /tmp/statistics/darkstat/files.txt",interface);
//printf("This is the command: %s\n",command);
system(command);
//
free(command);
//Compression
convert_to_csv(interface);
sprintf(picname,"vnstat_d_%d.png",r);
json_array_append_new(ret,json_string(picname));
sprintf(picname,"vnstat_h_%d.png",r);
json_array_append_new(ret,json_string(picname));
sprintf(picname,"vnstat_m_%d.png",r);
json_array_append_new(ret,json_string(picname));
sprintf(picname,"vnstat_s_%d.png",r);
json_array_append_new(ret,json_string(picname));
sprintf(picname,"vnstat_t_%d.png",r);
json_array_append_new(ret,json_string(picname));
json_object_set(obj,"images",ret);
compress_for_download(interface);
free(picname);
return(ret);
}
json_t *
fields_to_json(int fields)
{
json_t *result = json_array();
int i = 0;
int mask;
for (mask = 1; mask < WATCHMAN_FIELD_END; mask *= 2) {
if (fields & mask) {
json_array_append_new(result, json_string(fields_str[i]));
}
++i;
}
return result;
}
void pilot::JSONFileHandler::startArrayWrite(const char* name, size_t, bool) {
auto array = json_array();
if (json_is_array(_currentEl)) {
// We are in an array, section must be unnamed
Assertion(name == nullptr, "Inside an array there can be no named section!");
json_array_append_new(_currentEl, array);
} else {
Assertion(name != nullptr, "Section outside of arrays must be named!");
json_object_set_new(_currentEl, name, array);
}
_currentEl = array;
_elementStack.push_back(_currentEl);
}
