//native json_object_update(Handle:hObj, Handle:hOther);
static cell_t Native_json_object_update(IPluginContext *pContext, const cell_t *params) {
HandleError err;
HandleSecurity sec;
sec.pOwner = NULL;
sec.pIdentity = myself->GetIdentity();
// Param 1
json_t *object;
Handle_t hndlObject = static_cast<Handle_t>(params[1]);
if ((err=g_pHandleSys->ReadHandle(hndlObject, htJanssonObject, &sec, (void **)&object)) != HandleError_None)
{
return pContext->ThrowNativeError("Invalid <Object> handle %x (error %d)", hndlObject, err);
}
// Param 2
json_t *other;
Handle_t hndlOther = static_cast<Handle_t>(params[2]);
if ((err=g_pHandleSys->ReadHandle(hndlOther, htJanssonObject, &sec, (void **)&other)) != HandleError_None)
{
return pContext->ThrowNativeError("Invalid <Object> handle %x (error %d)", hndlOther, err);
}
bool bSuccess = (json_object_update(object, other) == 0);
return bSuccess;
}
static char *make_json_response_payload (const char *request_payload,
const char *route,
uint32_t userid, uint32_t rolemask)
{
json_t *o = NULL;
json_t *add = NULL;
char *result = NULL;
if (!request_payload || !(o = json_loads (request_payload, 0, NULL))) {
errno = EPROTO;
goto done;
}
if (!(add = json_pack ("{s:s s:i s:i}", "route", route,
"userid", userid,
"rolemask", rolemask))) {
errno = ENOMEM;
goto done;
}
if (json_object_update (o, add) < 0) {
errno = ENOMEM;
goto done;
}
if (!(result = json_dumps (o, 0))) {
errno = ENOMEM;
goto done;
}
done:
json_decref (o);
json_decref (add);
return result;
}
json_t *btAction_toJson(const void *vba)
{
btAction_t *ba = (btAction_t *)vba;
json_t *root;
if (ba == NULL)
return NULL;
root = json_object();
json_object_update(root, btFunction_toJson(ba->function));
json_object_update(root, btEffect_toJson(ba->effect));
json_object_set_new(root, "parameters",
paramList_toJson(ba->pl));
return root;
}
void raceList_toJson(cnvList_t *rl, btstring_t *fname)
{
json_t *root;
root = cnvList_toJsonObject(rl);
cnvList_setToJson(rl, btRace_toJsonArray);
json_object_update(root,cnvList_toJsonArray(rl));
JSON_DUMP(root, fname);
}
static bool
alg_wrap_unw(const jose_hook_alg_t *alg, jose_cfg_t *cfg, const json_t *jwe,
const json_t *rcp, const json_t *jwk, json_t *cek)
{
const json_t *epk = NULL;
json_auto_t *exc = NULL;
json_auto_t *der = NULL;
json_auto_t *hdr = NULL;
const char *wrap = NULL;
hdr = jose_jwe_hdr(jwe, rcp);
epk = json_object_get(hdr, "epk");
if (!hdr || !epk)
return false;
/* If the JWK has a private key, perform the normal exchange. */
if (json_object_get(jwk, "d")) {
const jose_hook_alg_t *ecdh = NULL;
ecdh = jose_hook_alg_find(JOSE_HOOK_ALG_KIND_EXCH, "ECDH");
if (!ecdh)
return false;
exc = ecdh->exch.exc(ecdh, cfg, jwk, epk);
/* Otherwise, allow external exchanges. */
} else if (json_equal(json_object_get(jwk, "crv"),
json_object_get(epk, "crv"))) {
exc = json_deep_copy(jwk);
}
if (!exc)
return false;
der = derive(alg, cfg, hdr, cek, exc);
if (!der)
return false;
wrap = strchr(alg->name, '+');
if (wrap) {
const jose_hook_alg_t *kw = NULL;
kw = jose_hook_alg_find(JOSE_HOOK_ALG_KIND_WRAP, &wrap[1]);
if (!kw)
return false;
return kw->wrap.unw(kw, cfg, jwe, rcp, der, cek);
}
return json_object_update(cek, der) == 0;
}
static int
jcmd_jwk_exc(int argc, char *argv[])
{
jcmd_opt_auto_t opt = {};
json_auto_t *key = NULL;
json_t *tmpl = NULL;
if (!jcmd_opt_parse(argc, argv, cfgs, &opt, prefix))
return EXIT_FAILURE;
if (json_array_size(opt.keys) > 1 && json_array_remove(opt.keys, 0) < 0)
return EXIT_FAILURE;
if (json_array_size(opt.lcl) != 1) {
fprintf(stderr, "Local JWK must be specified exactly once!\n");
return EXIT_FAILURE;
}
if (json_array_size(opt.rem) != 1) {
fprintf(stderr, "Remote JWK must be specified exactly once!\n");
return EXIT_FAILURE;
}
key = jose_jwk_exc(NULL, json_array_get(opt.lcl, 0),
json_array_get(opt.rem, 0));
if (!key) {
fprintf(stderr, "Error performing exchange!\n");
return EXIT_FAILURE;
}
tmpl = json_array_get(opt.keys, json_array_size(opt.keys) - 1);
if (json_object_update(tmpl, key) < 0)
return EXIT_FAILURE;
if (json_dumpf(tmpl, opt.output, JSON_COMPACT | JSON_SORT_KEYS) < 0) {
fprintf(stderr, "Error writing JWK!\n");
return EXIT_FAILURE;
}
if (isatty(fileno(opt.output)))
fprintf(opt.output, "\n");
return EXIT_SUCCESS;
}
static json_t *monster_toJson(const void *vm)
{
json_t *monRoot;
monster_t *m = (monster_t *)vm;
uint32_t i;
monRoot = json_object();
JSON_BTSTRING(monRoot, "singular", m->singular);
JSON_BTSTRING(monRoot, "plural", m->plural);
JSON_BTSTRING(monRoot, "picture", m->picture);
JSON_STRING(monRoot, "pronoun", getPronounString(m->pronoun));
JSON_NUMBER(monRoot, "hpBase", m->hpBase);
JSON_NUMBER(monRoot, "hpRndDie", m->hpRndDie);
JSON_NUMBER(monRoot, "hpRndNDice", m->hpRndNdice);
JSON_NUMBER(monRoot, "reward", m->reward);
JSON_NUMBER(monRoot, "ac", m->baseAC);
JSON_NUMBER(monRoot, "breathSaveLo", m->breathSaveLo);
JSON_NUMBER(monRoot, "breathSaveHi", m->breathSaveHi);
JSON_NUMBER(monRoot, "spellSaveLo", m->spellSaveLo);
JSON_NUMBER(monRoot, "spellSaveHi", m->spellSaveHi);
JSON_NUMBER(monRoot, "toHitLo", m->toHitLo);
JSON_NUMBER(monRoot, "toHitHi", m->toHitHi);
JSON_NUMBER(monRoot, "priorityLo", m->priorityLo);
JSON_NUMBER(monRoot, "priorityHi", m->priorityHi);
JSON_BOOL(monRoot, "rndGroupSize", m->rndGroupSize);
JSON_NUMBER(monRoot, "groupSize", m->groupSize);
JSON_NUMBER(monRoot, "numAttacks", m->numAttacks);
/* XXX PRONOUN Handling */
JSON_BOOL(monRoot, "willAdvance", m->willAdvance);
JSON_NUMBER(monRoot, "distance", m->distance);
JSON_NUMBER(monRoot, "advanceSpeed", m->advSpeed);
JSON_BOOL(monRoot, "isIllusion", m->isIllusion);
json_object_update(monRoot, repel_toJson(&m->repel));
json_object_set_new(monRoot, "attacks", cnvList_toJsonArray(m->attacks));
return monRoot;
}
static json_t *btcity_toJson(const void *vc)
{
btcity_t *btc = (btcity_t *)vc;
json_t *root;
json_t *node;
root = json_object();
JSON_BTSTRING(root, "title", btc->title);
JSON_BTSTRING(root, "guildExitSquare", btc->guildExitSquare);
JSON_BTSTRING(root, "guildExitDir", btc->guildExitDir);
json_object_set_new(root, "squares", cnvList_toJsonObject(btc->sqs));
json_object_set_new(root, "buildings", cnvList_toJsonObject(btc->bls));
node = json_object();
json_object_set_new(node, "items",
cnvList_toJsonArray(btc->day->items));
json_object_set_new(node, "monsters",
cnvList_toJsonArray(btc->day->monsters));
JSON_NUMBER(node, "poisonDamage", btc->day->poisonDmg);
JSON_NUMBER(node, "level", btc->day->level);
if (btc->params)
json_object_update(node, paramList_toJson(btc->params));
json_object_set_new(root, "day", node);
if (btc->night->level) {
node = json_object();
json_object_set_new(node, "items",
cnvList_toJsonArray(btc->night->items));
json_object_set_new(node, "monsters",
cnvList_toJsonArray(btc->night->monsters));
JSON_NUMBER(node, "poisonDamage", btc->night->poisonDmg);
JSON_NUMBER(node, "level", btc->night->level);
json_object_set_new(root, "night", node);
}
return root;
}
static void test_update()
{
json_t *object, *other, *nine, *ten;
object = json_object();
other = json_object();
nine = json_integer(9);
ten = json_integer(10);
if(!object || !other)
fail("unable to create object");
if(!nine || !ten)
fail("unable to create integer");
/* update an empty object with an empty object */
if(json_object_update(object, other))
fail("unable to update an emtpy object with an empty object");
if(json_object_size(object) != 0)
fail("invalid size after update");
if(json_object_size(other) != 0)
fail("invalid size for updater after update");
/* update an empty object with a nonempty object */
if(json_object_set(other, "a", ten) ||
json_object_set(other, "b", ten) ||
json_object_set(other, "c", ten) ||
json_object_set(other, "d", ten) ||
json_object_set(other, "e", ten))
fail("unable to set value");
if(json_object_update(object, other))
fail("unable to update an empty object");
if(json_object_size(object) != 5)
fail("invalid size after update");
if(json_object_get(object, "a") != ten ||
json_object_get(object, "b") != ten ||
json_object_get(object, "c") != ten ||
json_object_get(object, "d") != ten ||
json_object_get(object, "e") != ten)
fail("update works incorrectly");
/* perform the same update again */
if(json_object_update(object, other))
fail("unable to update a non-empty object");
if(json_object_size(object) != 5)
fail("invalid size after update");
if(json_object_get(object, "a") != ten ||
json_object_get(object, "b") != ten ||
json_object_get(object, "c") != ten ||
json_object_get(object, "d") != ten ||
json_object_get(object, "e") != ten)
fail("update works incorrectly");
/* update a nonempty object with a nonempty object with both old
and new keys */
if(json_object_clear(other))
fail("clear failed");
if(json_object_set(other, "a", nine) ||
json_object_set(other, "b", nine) ||
json_object_set(other, "f", nine) ||
json_object_set(other, "g", nine) ||
json_object_set(other, "h", nine))
fail("unable to set value");
if(json_object_update(object, other))
fail("unable to update a nonempty object");
if(json_object_size(object) != 8)
fail("invalid size after update");
if(json_object_get(object, "a") != nine ||
json_object_get(object, "b") != nine ||
json_object_get(object, "f") != nine ||
json_object_get(object, "g") != nine ||
json_object_get(object, "h") != nine)
fail("update works incorrectly");
json_decref(nine);
json_decref(ten);
json_decref(other);
json_decref(object);
}
int handle_response(json_t* response)
{
int retval = 0;
jsonrpc_request_t* req = NULL;
json_t* return_obj = NULL;
json_t* internal = NULL;
char* freeme = NULL;
/* check if json object */
if(!json_is_object(response)){
WARN("jsonrpc response is not an object\n");
return -1;
}
/* check version */
json_t* version = json_object_get(response, "jsonrpc");
if(!version) {
WARN("jsonrpc response does not have a version.\n");
retval = -1;
goto end;
}
const char* version_s = json_string_value(version);
if(!version_s){
WARN("jsonrpc response version is not a string.\n");
retval = -1;
goto end;
}
if (strlen(version_s) != (sizeof(JSONRPC_VERSION)-1)
|| strncmp(version_s, JSONRPC_VERSION, sizeof(JSONRPC_VERSION)-1) != 0) {
WARN("jsonrpc response version is not %s. version: %s\n",
JSONRPC_VERSION, version_s);
retval = -1;
goto end;
}
/* check for an id */
json_t* _id = json_object_get(response, "id");
if(!_id) {
WARN("jsonrpc response does not have an id.\n");
retval = -1;
goto end;
}
int id = json_integer_value(_id);
if (!(req = pop_request(id))) {
/* don't fail the server for an unrecognized id */
retval = 0;
goto end;
}
return_obj = json_object();
json_t* error = json_object_get(response, "error");
// if the error value is null, we don't care
bool _error = error && (json_typeof(error) != JSON_NULL);
json_t* result = json_object_get(response, "result");
if(_error) {
json_object_set(return_obj, "error", error);
}
if(result) {
json_object_set(return_obj, "result", result);
}
if ((!result && !_error) || (result && _error)) {
WARN("bad response\n");
internal = internal_error(JRPC_ERR_BAD_RESP, req->payload);
json_object_update(return_obj, internal);
if(internal) json_decref(internal);
}
pv_value_t val;
if(jsontoval(&val, &freeme, return_obj)<0) {
fail_request(
JRPC_ERR_TO_VAL,
req,
"Failed to convert response json to pv\n");
retval = -1;
goto end;
}
char* error_s = NULL;
if(send_to_script(&val, req->cmd)>=0) {
goto free_and_end;
}
if(_error) {
// get code from error
json_t* _code = json_object_get(error, "code");
if(_code) {
int code = json_integer_value(_code);
// check if code is in global_retry_ranges
retry_range_t* tmpr;
for(tmpr = global_retry_ranges;
tmpr != NULL;
tmpr = tmpr->next) {
if((tmpr->start < tmpr->end
&& tmpr->start <= code && code <= tmpr->end)
|| (tmpr->end < tmpr->start
&& tmpr->end <= code && code <= tmpr->start)
|| (tmpr->start == tmpr->end && tmpr->start == code)) {
if(schedule_retry(req)==0) {
goto end;
}
break;
}
}
}
error_s = json_dumps(error, JSON_COMPACT);
if(error_s) {
WARN("Request received an error: \n%s\n", error_s);
free(error_s);
} else {
fail_request(
JRPC_ERR_BAD_RESP,
req,
"Could not convert 'error' response to string");
retval = -1;
goto end;
}
}
free_and_end:
free_req_cmd(req->cmd);
free_request(req);
end:
if(freeme) free(freeme);
if(return_obj) json_decref(return_obj);
return retval;
}
static bool
alg_wrap_wrp(const jose_hook_alg_t *alg, jose_cfg_t *cfg, json_t *jwe,
json_t *rcp, const json_t *jwk, json_t *cek)
{
const jose_hook_alg_t *ecdh = NULL;
json_auto_t *exc = NULL;
json_auto_t *hdr = NULL;
json_auto_t *epk = NULL;
json_auto_t *der = NULL;
const char *wrap = NULL;
json_t *h = NULL;
if (json_object_get(cek, "k")) {
if (strcmp(alg->name, "ECDH-ES") == 0)
return false;
} else if (!jose_jwk_gen(cfg, cek)) {
return false;
}
hdr = jose_jwe_hdr(jwe, rcp);
if (!hdr)
return false;
h = json_object_get(rcp, "header");
if (!h && json_object_set_new(rcp, "header", h = json_object()) == -1)
return false;
epk = json_pack("{s:s,s:O}", "kty", "EC", "crv",
json_object_get(jwk, "crv"));
if (!epk)
return false;
if (!jose_jwk_gen(cfg, epk))
return false;
ecdh = jose_hook_alg_find(JOSE_HOOK_ALG_KIND_EXCH, "ECDH");
if (!ecdh)
return false;
exc = ecdh->exch.exc(ecdh, cfg, epk, jwk);
if (!exc)
return false;
if (!jose_jwk_pub(cfg, epk))
return false;
if (json_object_set(h, "epk", epk) == -1)
return false;
der = derive(alg, cfg, hdr, cek, exc);
if (!der)
return false;
wrap = strchr(alg->name, '+');
if (wrap) {
const jose_hook_alg_t *kw = NULL;
kw = jose_hook_alg_find(JOSE_HOOK_ALG_KIND_WRAP, &wrap[1]);
if (!kw)
return false;
return kw->wrap.wrp(kw, cfg, jwe, rcp, der, cek);
}
if (json_object_update(cek, der) < 0)
return false;
return add_entity(jwe, rcp, "recipients", "header", "encrypted_key", NULL);
}
bool TrafficNetwork::saveToFile(const string out_prefix, bool newWeek){
bool everythingOK = true;
int metric = KPH; //save in KPH such that it can be used by external tool (and be human readable)
std::vector<long> nIds;
long crtId;
char crtType;
string out_fileName = (out_prefix+"_roads_stats.json");
json_t *root = NULL;
if(firstSaved){
if(fileName != ""){
json_error_t error;
root = json_load_file(fileName.c_str(), 0, &error);
if(!root){
std::cout<<std::endl<<"WARNING: while opening "<<fileName<<" at line "<<error.line<<" - "<<error.text<<std::endl;
root= NULL;
}
if(!json_is_object(root)){
std::cout<<std::endl<<"WARNING: input file "<<fileName<<" has not the correct structure - expected root to be an object"<<std::endl;
json_decref(root);
root = NULL;
}
if(!root){
std::cout<<"File "<<fileName<<" could not be using during saving process"<<std::endl<<"\t --> reverting to saving network based on stored data (possibility for loss of positional infos)"<<std::endl;
}
}
if(!root){
root = json_object();
if ( root ) {
json_object_set_new(root, "metric" ,json_integer(metric));
json_t *_nodes = json_array();
json_t *_roads = json_array();
for(NodeVec::iterator it= nodes.begin() ; it!=nodes.end(); ++it){
json_t * _node = json_object();
crtId = (*it)->getId();
crtType = (*it)->getType();
json_object_set_new(_node,"id",json_integer(crtId));
json_object_set_new(_node,"type",json_integer(crtType));
json_array_append_new(_nodes,_node);
nIds = (*it)->getNeighborsId();
for(std::vector<long>::iterator jt = nIds.begin(); jt != nIds.end(); ++jt){
Road r = *((*it)->roadTo(*jt));
json_t * _road = json_object();
json_object_set_new(_road,"name",json_string(r.getName().c_str()));
json_object_set_new(_road,"startId",json_integer(crtId));
json_object_set_new(_road,"endId",json_integer(r.getEndPoint()->getId()));
json_object_set_new(_road,"speedLimit",json_integer(r.getSpeedLimit()*3.6)); //x3.6 to go from MPS to KPH
json_object_set_new(_road,"length",json_real(r.getLength()/1000)); // /1000 to go from M to K
json_object_set_new(_road,"nbBands",json_integer(r.getNbBands()));
json_array_append_new(_roads,_road);
}
}
json_object_set_new(root, "nodes" ,_nodes);
json_object_set_new(root, "roads" ,_roads);
}else{
std::cout<<"ERROR: Could not create 'root' during saving process"<<std::endl;
return false;
}
}
}else{
json_error_t error;
root = json_load_file(out_fileName.c_str(), 0, &error);
if(!root){
std::cout<<std::endl<<"ERROR: while opening "<<out_fileName<<" at line "<<error.line<<" - "<<error.text<<std::endl;
root= NULL;
return false;
}
if(!json_is_object(root)){
std::cout<<std::endl<<"ERROR: input file "<<fileName<<" has not the correct structure - expected root to be an object"<<std::endl;
json_decref(root);
root = NULL;
return false;
}
}
json_t *roadsInfos;
if(monitered){
bool first = false;
if(firstSaved){
roadsInfos = json_array();
int nbRoads = json_array_size(json_object_get(root,"roads"));
for(int i = 0; i < nbRoads; i++){
json_array_append_new(roadsInfos,json_object());
}
json_object_set(root,"roadsInfos",roadsInfos);
json_object_set_new(root,"timePrecision",json_integer(TIME_PRECISION));
json_object_set_new(root,"time_index",json_integer(0));
json_object_set_new(root,"driversCount_index",json_integer(1));
firstSaved = false;
first = true;
}else
roadsInfos = json_object_get(root,"roadsInfos");
json_t *infos;
for(NodeVec::iterator it= nodes.begin() ; it!=nodes.end(); ++it){
nIds = (*it)->getNeighborsId();
for(std::vector<long>::iterator jt = nIds.begin(); jt != nIds.end(); ++jt){
Road* r = ((*it)->roadTo(*jt));
infos = r->getMonitor()->getInfos();
if(first){
json_object_update(json_array_get(roadsInfos,r->getId()),infos);
}else{
json_array_extend(json_object_get(json_array_get(roadsInfos,r->getId()),"data"),json_object_get(infos,"data"));
}
r->getMonitor()->resetInfos(newWeek);
json_object_clear(infos);
json_decref(infos);
}
}
}
//actually save
if(!(json_dump_file(root,out_fileName.c_str(),JSON_COMPACT) == 0)){
//if(!(json_dump_file(root,out_fileName.c_str(),JSON_INDENT(2)) == 0)){ //<== to have pretty JSON file
everythingOK = false;
std::cout<< "Could not open file : "<<out_fileName << " to write down network "<< name <<std::endl;
}
if(monitered){
json_array_clear(roadsInfos);
}
json_object_clear(root);
json_decref(root);
if(newWeek){
firstSaved = true;
}
return everythingOK;
}
int ast_json_object_update(struct ast_json *object, struct ast_json *other)
{
return json_object_update((json_t *)object, (json_t *)other);
}
int json_path_set(json_t *json, const char *path, json_t *value,
unsigned int append)
{
static const char array_open = '[';
static const char object_delim = '.';
static const char *path_delims = ".[";
static const char *array_close = "]";
json_t *cursor, *parent = NULL;
char *token, *buf = NULL, *peek, delim = '\0';
const char *expect;
int index_saved = -1;
if (!json || !path || !value) {
ERR("invalid arguments\n");
goto fail;
} else {
buf = jsonp_strdup(path);
}
peek = buf;
token = buf;
cursor = json;
expect = path_delims;
if (*token == array_open) {
expect = array_close;
token++;
}
while (peek && *peek && cursor)
{
char *last_peek = peek;
peek = strpbrk(last_peek, expect);
if (peek) {
if (!token && peek != last_peek) {
ERR("unexpected trailing chars in JSON path at pos %zu\n",
last_peek - buf);
goto fail;
}
delim = *peek;
*peek++ = '\0';
} else { // end of path
if (expect == path_delims) {
break;
} else {
ERR("missing ']' at pos %zu\n", peek - buf);
goto fail;
}
}
if (expect == path_delims) {
if (token) {
if (token[0] == '\0') {
ERR("empty token at pos %zu\n", peek - buf);
goto fail;
}
parent = cursor;
cursor = json_object_get(parent, token);
if (!cursor) {
if (!json_is_object(parent)) {
ERR("object expected at pos %zu\n", peek - buf);
goto fail;
}
if (delim == object_delim) {
cursor = json_object();
json_object_set_new(parent, token, cursor);
} else {
ERR("new array is not allowed at pos %zu\n", peek - buf);
goto fail;
}
}
}
expect = (delim == array_open ? array_close : path_delims);
token = peek;
} else if (expect == array_close) {
char *endptr;
size_t index;
parent = cursor;
if (!json_is_array(parent)) {
ERR("array expected at pos %zu\n", peek - buf);
goto fail;
}
index = strtol(token, &endptr, 0);
if (*endptr) {
ERR("invalid array index at pos %zu\n", peek - buf);
goto fail;
}
cursor = json_array_get(parent, index);
if (!cursor) {
ERR("array index out of bound at pos %zu\n", peek - buf);
goto fail;
}
index_saved = index;
token = NULL;
expect = path_delims;
} else {
ERR("fatal JSON error at pos %zu\n", peek - buf);
goto fail;
}
}
if (token && append) {
if(strlen(token) > 0) {
json_t* tmp = json_object_get(cursor, token);
if(json_is_array(tmp)) {
json_array_append(tmp, value);
json_object_set(cursor, token, tmp);
} else if(json_is_object(tmp) && json_is_object(value) ) {
json_object_update(tmp, value);
json_object_set(cursor, token, tmp);
} else {
ERR("JSON array or object expected at pos %zu\n", peek - buf);
goto fail;
}
} else if(json_is_array(cursor)) {
json_array_append(cursor, value);
} else if(json_is_object(cursor) && json_is_object(value)) {
json_object_update(cursor, value);
} else {
ERR("JSON array or object expected at pos %zu\n", peek - buf);
goto fail;
}
} else if (token && strlen(token) != 0 ) {
if (json_is_object(cursor)) {
json_object_set(cursor, token, value);
} else {
ERR("JSON object expected at pos %zu\n", peek - buf);
goto fail;
}
cursor = json_object_get(cursor, token);
} else if (index_saved != -1 && json_is_array(parent)) {
json_array_set(parent, index_saved, value);
cursor = json_array_get(parent, index_saved);
} else {
ERR("invalid JSON path at pos %zu\n", peek - buf);
goto fail;
}
json_decref(value);
jsonp_free(buf);
return 0;
fail:
json_decref(value);
jsonp_free(buf);
return -1;
}
int la_codec_object_update(la_codec_value_t *object, la_codec_value_t *other)
{
return json_object_update((json_t *) object, (json_t *) other);
}
