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