static void cd_JSONRequest (struct evhttp_request* request, CDServer* server) { struct evbuffer* buffer = evhttp_request_get_input_buffer(request); char* text = CD_alloc(evbuffer_get_length(buffer) + 1); evbuffer_remove(buffer, text, evbuffer_get_length(buffer)); json_error_t error; json_t* input = json_loads(text, 0, &error); json_t* output = json_object(); printf("%s\n", text); if (evhttp_request_get_command(request) != EVHTTP_REQ_POST) { goto error; } if (input == NULL) { SERR(server, "RPC.JSON: error on line %d: %s", error.line, error.text); goto error; } CD_EventDispatch(server, "RPC.JSON", input, output); done: { char* outString = json_dumps(output, JSON_INDENT(2)); struct evbuffer* outBuffer = evbuffer_new(); evbuffer_add_printf(outBuffer, "%s", outString); evhttp_send_reply(request, HTTP_OK, "OK", outBuffer); evbuffer_free(outBuffer); free(outString); json_delete(output); json_delete(input); CD_free(text); return; } error: { evhttp_send_error(request, HTTP_INTERNAL, "Internal server error"); CD_free(text); if (input) { json_delete(input); } if (output) { json_delete(output); } return; } }
static int dslink_response_send_closed(DSLink *link, json_t *rid) { json_t *top = json_object(); if (!top) { return DSLINK_ALLOC_ERR; } json_t *resps = json_array(); if (!resps) { json_delete(top); return DSLINK_ALLOC_ERR; } json_object_set_new_nocheck(top, "responses", resps); json_t *resp = json_object(); if (!resp) { json_delete(top); return DSLINK_ALLOC_ERR; } json_array_append_new(resps, resp); json_object_set(resp, "rid", rid); json_object_set_new_nocheck(resp, "stream", json_string("closed")); dslink_ws_send_obj(link->_ws, top); json_delete(top); return 0; }
int main(void) { JsonNode *node; (void) chomp; plan_tests(49); ok1(json_find_element(NULL, 0) == NULL); ok1(json_find_member(NULL, "") == NULL); ok1(json_first_child(NULL) == NULL); node = json_mknull(); should_be(node, "null"); json_delete(node); node = json_mkbool(false); should_be(node, "false"); json_delete(node); node = json_mkbool(true); should_be(node, "true"); json_delete(node); test_string(); test_number(); test_array(); test_object(); return exit_status(); }
static int log_failure_fmt_msg(pool *p, const unsigned char *fmt, const char *event_name, char **msg, size_t *msg_len, int flags) { int res; char errstr[256], *json = NULL; void *obj = NULL; obj = json_mkobject(); res = log_failure_mkmsg(flags, p, fmt, obj, log_failure_mkjson); if (!json_check(obj, errstr)) { pr_log_debug(DEBUG3, MOD_LOG_FAILURE_VERSION ": JSON structural problems: %s", errstr); errno = EINVAL; json_delete(obj); return -1; } json = json_encode(obj); pr_trace_msg(trace_channel, 3, "generated JSON payload: %s", json); *msg_len = strlen(json); *msg = palloc(p, *payload_len); memcpy(*payload, json, *payload_len); /* To avoid a memory leak via malloc(3), we have to explicitly call free(3) * on the returned JSON string. Which is why we duplicate it out of the * given memory pool, for use outside of this function. */ free(json); json_delete(obj); return 0; }
static JsonNode *line_to_location(char *line) { JsonNode *json, *o, *j; char *ghash; char tstamp[64], *bp; double lat, lon; long tst; snprintf(tstamp, 21, "%s", line); if ((bp = strchr(line, '{')) == NULL) return (NULL); if ((json = json_decode(bp)) == NULL) { return (NULL); } if ((j = json_find_member(json, "_type")) == NULL) { json_delete(json); return (NULL); } if (j->tag != JSON_STRING || strcmp(j->string_, "location") != 0) { json_delete(json); return (NULL); } o = json_mkobject(); if (json_copy_to_object(o, json, FALSE) == FALSE) { json_delete(o); json_delete(json); return (NULL); } json_delete(json); /* Done with this -- we've copied it. */ lat = lon = 0.0; if ((j = json_find_member(o, "lat")) != NULL) { lat = j->number_; } if ((j = json_find_member(o, "lon")) != NULL) { lon = j->number_; } if ((ghash = geohash_encode(lat, lon, geohash_prec())) != NULL) { json_append_member(o, "ghash", json_mkstring(ghash)); get_geo(o, ghash); free(ghash); } json_append_member(o, "isorcv", json_mkstring(tstamp)); tst = 0L; if ((j = json_find_member(o, "tst")) != NULL) { tst = j->number_; } json_append_member(o, "isotst", json_mkstring(isotime(tst))); return (o); }
int rules_gc(void) { struct rules_t *tmp_rules = NULL; struct rules_values_t *tmp_values = NULL; struct rules_actions_t *tmp_actions = NULL; int i = 0; while(rules) { tmp_rules = rules; FREE(tmp_rules->name); FREE(tmp_rules->rule); for(i=0;i<tmp_rules->nrdevices;i++) { FREE(tmp_rules->devices[i]); } while(tmp_rules->values) { tmp_values = tmp_rules->values; FREE(tmp_values->name); FREE(tmp_values->device); tmp_rules->values = tmp_rules->values->next; FREE(tmp_values); } if(tmp_rules->values != NULL) { FREE(tmp_rules->values); } while(tmp_rules->actions) { tmp_actions = tmp_rules->actions; if(tmp_actions->arguments != NULL) { json_delete(tmp_actions->arguments); } if(tmp_actions->parsedargs != NULL) { json_delete(tmp_actions->parsedargs); } tmp_rules->actions = tmp_rules->actions->next; if(tmp_actions != NULL) { FREE(tmp_actions); } } if(tmp_rules->actions != NULL) { FREE(tmp_rules->actions); } if(tmp_rules->devices != NULL) { FREE(tmp_rules->devices); } rules = rules->next; FREE(tmp_rules); } if(rules != NULL) { FREE(rules); } rules = NULL; logprintf(LOG_DEBUG, "garbage collected config rules library"); return 1; }
static void test_string(void) { JsonNode *str; str = json_mkstring("Hello\tworld!\n\001"); should_be(str, "\"Hello\\tworld!\\n\\u0001\""); json_delete(str); str = json_mkstring("\"\\\b\f\n\r\t"); should_be(str, "\"\\\"\\\\\\b\\f\\n\\r\\t\""); json_delete(str); }
/** * Perform tests on the JSON implementation. * &returns: Success flag. */ bool test_json(void) { bool suc = true; { struct json_t *json; suc &= chkbool(json_parse_str(&json, "12")); if(json != NULL) { unsigned int num; suc &= chkbool(json_getf(json, "u", &num)); suc &= (num == 12); json_delete(json); } suc &= chkbool(json_parse_str(&json, "32")); if(json != NULL) { uint16_t num; suc &= chkbool(json_getf(json, "u16", &num)); suc &= (num == 32); json_delete(json); } suc &= chkbool(json_parse_str(&json, "{a:2,foo:\"bar\",c:{d:12}}")); if(json != NULL) { unsigned int num[2]; const char *str = NULL; suc &= chkbool(json_getf(json, "{a:u,foo:s,c:{d:u$}$}", &num[0], &str, &num[1])); suc &= ((num[0] == 2) && (num[1] == 12) && (str != NULL) && (strcmp(str, "bar") == 0)); json_delete(json); } suc &= chkbool(json_parse_str(&json, "{foo:true,bar:false}")); if(json != NULL) { bool foo, bar; suc &= chkbool(json_getf(json, "{foo:b,bar:b$}", &foo, &bar)); suc &= ((foo == true) && (bar == false)); json_delete(json); } } return suc; }
void dslink_response_send_val(DSLink *link, DSNode *node, uint32_t sid) { if (!node->value_timestamp) { return; } json_t *top = json_object(); if (!top) { return; } json_t *resps = json_array(); if (!resps) { json_delete(top); return; } json_object_set_new_nocheck(top, "responses", resps); json_t *resp = json_object(); if (!resp) { json_delete(top); return; } json_array_append_new(resps, resp); json_object_set_new_nocheck(resp, "rid", json_integer(0)); json_t *updates = json_array(); if (!updates) { json_delete(top); return; } json_object_set_new_nocheck(resp, "updates", updates); json_t *update = json_array(); if (!update) { json_delete(top); return; } json_array_append_new(updates, update); json_array_append_new(update, json_integer(sid)); json_array_append(update, node->value); json_array_append(update, node->value_timestamp); dslink_ws_send_obj(link->_ws, top); json_delete(top); }
void append_card_to_object(JsonNode *obj, char *user, char *device) { char path[BUFSIZ], path1[BUFSIZ], *cardfile = NULL; JsonNode *card; if (!user || !*user) return; snprintf(path, BUFSIZ, "%s/cards/%s/%s/%s-%s.json", STORAGEDIR, user, device, user, device); if (access(path, R_OK) == 0) { cardfile = path; } else { snprintf(path1, BUFSIZ, "%s/cards/%s/%s.json", STORAGEDIR, user, user); if (access(path1, R_OK) == 0) { cardfile = path1; } } card = json_mkobject(); if (cardfile && json_copy_from_file(card, cardfile) == TRUE) { json_copy_to_object(obj, card, FALSE); } json_delete(card); }
static int registry_remove_value_recursive(struct JsonNode *root, const char *key) { logprintf(LOG_STACK, "%s(...)", __FUNCTION__); char *sub = strstr(key, "."); char *buff = MALLOC(strlen(key)+1); strcpy(buff, key); if(sub != NULL) { int pos = sub-key; buff[pos] = '\0'; } struct JsonNode *member = json_find_member(root, buff); if(member != NULL) { if(sub == NULL) { json_remove_from_parent(member); json_delete(member); registry_remove_empty_parent(root); FREE(buff); return 0; } if(member->tag == JSON_OBJECT) { if(sub != NULL) { int pos = sub-key; strcpy(buff, &key[pos+1]); } int ret = registry_remove_value_recursive(member, buff); FREE(buff); return ret; } } FREE(buff); return -1; }
int config_write(int level, const char *media) { logprintf(LOG_STACK, "%s(...)", __FUNCTION__); struct JsonNode *root = json_mkobject(); FILE *fp; sort_list(0); struct config_t *listeners = config; while(listeners) { if(listeners->sync) { struct JsonNode *child = listeners->sync(level, media); if(child != NULL) { json_append_member(root, listeners->name, child); } } listeners = listeners->next; } /* Overwrite config file with proper format */ if(!(fp = fopen(configfile, "w+"))) { logprintf(LOG_ERR, "cannot write config file: %s", configfile); return EXIT_FAILURE; } fseek(fp, 0L, SEEK_SET); char *content = json_stringify(root, "\t"); fwrite(content, sizeof(char), strlen(content), fp); fclose(fp); json_free(content); json_delete(root); return EXIT_SUCCESS; }
static void test_number(void) { JsonNode *num; num = json_mknumber(5678901234.0); should_be(num, "5678901234"); json_delete(num); num = json_mknumber(-5678901234.0); should_be(num, "-5678901234"); json_delete(num); num = json_mknumber(0.0 / 0.0); should_be(num, "null"); json_delete(num); }
SEXP R_fromJSON(SEXP r_str, SEXP simplify, SEXP nullValue, SEXP simplifyWithNames, SEXP encoding, SEXP r_stringFun, SEXP r_str_type) { const char * str = CHAR(STRING_ELT(r_str, 0)); JSONNODE *node; SEXP ans; int nprotect = 0; StringFunctionType str_fun_type = GARBAGE; if(r_stringFun != R_NilValue) { if(TYPEOF(r_stringFun) == CLOSXP) { SEXP e; PROTECT(e = allocVector(LANGSXP, 2)); nprotect++; SETCAR(e, r_stringFun); r_stringFun = e; } str_fun_type = INTEGER(r_str_type)[0]; } else r_stringFun = NULL; node = json_parse(str); ans = processJSONNode(node, json_type(node), INTEGER(simplify)[0], nullValue, LOGICAL(simplifyWithNames)[0], INTEGER(encoding)[0], r_stringFun, str_fun_type); json_delete(node); if(nprotect) UNPROTECT(nprotect); return(ans); }
void SubmitContext::submitBlock(blktemplate_t *blockTemplate, const PrimecoinBlockHeader &header, unsigned dataId) { json_t *jsonBlock = blkmk_submit_jansson(blockTemplate, (unsigned char*)&header, dataId, __builtin_bswap32(header.nonce), header.multiplier, header.multiplier[0]+1); char *request = json_dumps(jsonBlock, JSON_INDENT(2)); json_delete(jsonBlock); _response.clear(); logFormattedWrite(_log, "submit request: %s", request); curl_easy_setopt(curl, CURLOPT_POSTFIELDS, request); if (curl_easy_perform(curl) != CURLE_OK) { logFormattedWrite(_log, "block send error!!!"); } else { logFormattedWrite(_log, "response: %s"); } free(request); }
void *events_clientize(void *param) { logprintf(LOG_STACK, "%s(...)", __FUNCTION__); unsigned int failures = 0; while(loop && failures <= 5) { struct ssdp_list_t *ssdp_list = NULL; int standalone = 0; settings_find_number("standalone", &standalone); if(ssdp_seek(&ssdp_list) == -1 || standalone == 1) { logprintf(LOG_DEBUG, "no pilight ssdp connections found"); char server[16] = "127.0.0.1"; if((sockfd = socket_connect(server, (unsigned short)socket_get_port())) == -1) { logprintf(LOG_DEBUG, "could not connect to pilight-daemon"); failures++; continue; } } else { if((sockfd = socket_connect(ssdp_list->ip, ssdp_list->port)) == -1) { logprintf(LOG_DEBUG, "could not connect to pilight-daemon"); failures++; continue; } } if(ssdp_list) { ssdp_free(ssdp_list); } struct JsonNode *jclient = json_mkobject(); struct JsonNode *joptions = json_mkobject(); json_append_member(jclient, "action", json_mkstring("identify")); json_append_member(joptions, "config", json_mknumber(1, 0)); json_append_member(jclient, "options", joptions); json_append_member(jclient, "media", json_mkstring("all")); char *out = json_stringify(jclient, NULL); socket_write(sockfd, out); json_free(out); json_delete(jclient); if(socket_read(sockfd, &recvBuff, 0) != 0 || strcmp(recvBuff, "{\"status\":\"success\"}") != 0) { failures++; continue; } failures = 0; while(loop) { if(socket_read(sockfd, &recvBuff, 0) != 0) { break; } else { events_queue(recvBuff); } } } if(recvBuff) { FREE(recvBuff); recvBuff = NULL; } socket_close(sockfd); return 0; }
int main(void) { struct json *reply, *item1, *item2, *params; struct jrpc_client *client = &my_client; int ret = jrpc_client_init(client, HOST, PORT); if (ret != 0) { exit(ret); } item1 = json_create_object(); json_add_number_to_object(item1, "A", 3); json_add_number_to_object(item1, "B", 10); item2 = json_create_object(); json_add_number_to_object(item2, "A", 1); json_add_number_to_object(item2, "B", 2); params = json_create_array(); json_add_item_to_object(item1,"S", item2); json_add_item_to_array(params, item1); // jrpc_client_call will free params if ((ret = jrpc_client_call(client, "foo", params, &reply)) != 0) { exit(ret); } printf("%s\n", json_to_string(reply)); json_delete(reply); jrpc_client_close(client); return 0; }
int config_read(void) { logprintf(LOG_STACK, "%s(...)", __FUNCTION__); FILE *fp = NULL; char *content = NULL; size_t bytes = 0; struct JsonNode *root = NULL; struct stat st; /* Read JSON config file */ if(!(fp = fopen(configfile, "rb"))) { logprintf(LOG_ERR, "cannot read config file: %s", configfile); return EXIT_FAILURE; } fstat(fileno(fp), &st); bytes = (size_t)st.st_size; if(!(content = CALLOC(bytes+1, sizeof(char)))) { logprintf(LOG_ERR, "out of memory"); fclose(fp); return EXIT_FAILURE; } if(fread(content, sizeof(char), bytes, fp) == -1) { logprintf(LOG_ERR, "cannot read config file: %s", configfile); } fclose(fp); /* Validate JSON and turn into JSON object */ if(json_validate(content) == false) { logprintf(LOG_ERR, "config is not in a valid json format"); FREE(content); return EXIT_FAILURE; } root = json_decode(content); if(config_parse(root) != EXIT_SUCCESS) { FREE(content); json_delete(root); return EXIT_FAILURE; } json_delete(root); config_write(1, "all"); FREE(content); return EXIT_SUCCESS; }
/** * Gets current time on the device */ void cmd_getrtc() { JSONNODE *n = json_new(JSON_NODE); json_push_back(n, json_new_i("rtc", realtime_get_unixtime())); json_char *jc = json_write_formatted(n); serial_write_string(jc); json_free(jc); json_delete(n); }
int registry_gc(void) { if(registry != NULL) { json_delete(registry); } registry = NULL; logprintf(LOG_DEBUG, "garbage collected config registry library"); return 1; }
/** * hello: a simple "ping" command to check that the * device is responsive */ void cmd_hello(char *line) { JSONNODE *n = json_new(JSON_NODE); json_push_back(n, json_new_a("hello", "Greetings professor Falken")); json_char *jc = json_write_formatted(n); serial_write_string(jc); json_free(jc); json_delete(n); }
void Json::Reset() { json_free(mJsonStr); json_delete(mpRootNode); mpRootNode = json_new(JSON_NODE); mJsonStr = NULL; }
void CSteamProto::OnGotHistoryMessages(const HttpResponse *response, void *arg) { MCONTACT hContact = FindContact((char*)arg); if (!hContact) return; if (!ResponseHttpOk(response)) return; JSONROOT root(response->pData); if (root == NULL) return; JSONNode *node = json_get(root, "response"); JSONNode *messages = json_get(node, "messages"); JSONNode *nmessages = json_as_array(messages); // Self SteamID ptrA steamId(getStringA("SteamID")); for (size_t i = json_size(nmessages); i > 0; i--) { JSONNode *message = json_at(nmessages, i - 1); node = json_get(message, "accountid"); const char *authorSteamId = AccountIdToSteamId(_ttoi64(ptrT(json_as_string(node)))); node = json_get(message, "message"); ptrT text(json_as_string(node)); T2Utf szMessage(text); node = json_get(message, "timestamp"); time_t timestamp = _ttoi64(ptrT(json_as_string(node))); // Ignore already existing messages if (timestamp <= m_lastMessageTS) continue; PROTORECVEVENT recv = { 0 }; recv.timestamp = timestamp; recv.szMessage = szMessage; if (strcmp(steamId, authorSteamId)) { // Received message ProtoChainRecvMsg(hContact, &recv); } else { // Sent message recv.flags = PREF_SENT; Proto_RecvMessage(hContact, &recv); } } json_delete(nmessages); }
/** * Outputs firmware version */ void cmd_version(char *line) { JSONNODE *n = json_new(JSON_NODE); json_push_back(n, json_new_a("version", OS100VERSION)); json_char *jc = json_write_formatted(n); serial_write_string(jc); json_free(jc); json_delete(n); }
void get_geo(JsonNode *o, char *ghash) { JsonNode *geo; if ((geo = gcache_json_get(gc, ghash)) != NULL) { json_copy_to_object(o, geo, FALSE); json_delete(geo); } }
bool Json::Parse(const string& str) { JSONNODE* node = json_parse(str.c_str()); if (node == NULL) return false; JSONNODE_ITERATOR iter = json_begin(node); while (iter != json_end(node)) { json_char* nodeName = json_name(*iter); if(string(nodeName) == "" || json_type(*iter) == JSON_NULL) { json_free(nodeName); break; } if (json_type(*iter) == JSON_NODE) { if(!Parse(nodeName, *iter)) return false; } else if(json_type(*iter) == JSON_ARRAY) { JSONNODE_ITERATOR i = json_begin(*iter); while (i != json_end(*iter)) { if(json_type(*iter) == JSON_NUMBER) { mDataFloatArray[nodeName].push_back(json_as_float(*i)); } else { mDataStrArray[nodeName].push_back(json_as_string(*i)); } i++; } } else if(json_type(*iter) == JSON_NUMBER) { mDataFloat[nodeName] = json_as_float(*iter); } else if(json_type(*iter) == JSON_BOOL) { mDataBool[nodeName] = json_as_bool(*iter); } else if(json_type(*iter) == JSON_STRING) { mDataStr[nodeName] = json_as_string(*iter); } json_free(nodeName); iter++; } json_delete(node); return true; }
/** @internal Serialize to string */ static char *l_pack_json(lua_State *L, int top) { JsonNode *root = l_pack_elem(L, top); if (!root) { return NULL; } char *result = json_encode(root); json_delete(root); return result; }
admJson::~admJson() { int l=cookies.size(); for(int i=0;i<l;i++) { json_delete((JSONNODE*)cookies[i]); } cookie=NULL; cookies.clear(); }
std::string SourceMap::generate_source_map(Context &ctx) { const bool include_sources = ctx.source_map_contents; const std::vector<std::string> includes = ctx.include_links; const std::vector<char*> sources = ctx.sources; JsonNode* json_srcmap = json_mkobject(); json_append_member(json_srcmap, "version", json_mknumber(3)); // pass-through sourceRoot option if (!ctx.source_map_root.empty()) { JsonNode* root = json_mkstring(ctx.source_map_root.c_str()); json_append_member(json_srcmap, "sourceRoot", root); } const char *include = file.c_str(); JsonNode *json_include = json_mkstring(include); json_append_member(json_srcmap, "file", json_include); JsonNode *json_includes = json_mkarray(); for (size_t i = 0; i < source_index.size(); ++i) { const char *include = includes[source_index[i]].c_str(); JsonNode *json_include = json_mkstring(include); json_append_element(json_includes, json_include); } json_append_member(json_srcmap, "sources", json_includes); if (include_sources) { JsonNode *json_contents = json_mkarray(); for (size_t i = 0; i < source_index.size(); ++i) { const char *content = sources[source_index[i]]; JsonNode *json_content = json_mkstring(content); json_append_element(json_contents, json_content); } if (json_contents->children.head) json_append_member(json_srcmap, "sourcesContent", json_contents); } std::string mappings = serialize_mappings(); JsonNode *json_mappings = json_mkstring(mappings.c_str()); json_append_member(json_srcmap, "mappings", json_mappings); JsonNode *json_names = json_mkarray(); // so far we have no implementation for names // no problem as we do not alter any identifiers json_append_member(json_srcmap, "names", json_names); char *str = json_stringify(json_srcmap, "\t"); std::string result = std::string(str); free(str); json_delete(json_srcmap); return result; }
void JSON_CLOSE(sLONG_PTR *pResult, PackagePtr pParams) { C_TEXT json; json.fromParamAtIndex(pParams, 1); JSONNODE *n = _fromHex(json); if(_removeJsonRootFromList(n)){ json_delete(n); } }