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