//native json_object_set(Handle:hObj, const String:sKey[], Handle:hValue); static cell_t Native_json_object_set(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 char *key; pContext->LocalToString(params[2], &key); // Param 3 json_t *value; Handle_t hndlValue = static_cast<Handle_t>(params[3]); if ((err=g_pHandleSys->ReadHandle(hndlValue, htJanssonObject, &sec, (void **)&value)) != HandleError_None) { return pContext->ThrowNativeError("Invalid <Object> handle %x (error %d)", hndlValue, err); } return (json_object_set_nocheck(object, key, value) == 0); }
// Called to initialize your node structure. void init(DSLink *link) { json_t *messageValue = dslink_json_get_config(link, "message"); if (messageValue) { log_info("Message = %s\n", json_string_value(messageValue)); } DSNode *superRoot = link->responder->super_root; DSNode *stringValueNode = dslink_node_create(superRoot, "string", "node"); dslink_node_set_meta(link, stringValueNode, "$type", json_string("string")); dslink_node_set_meta(link, stringValueNode, "$writable", json_string("write")); dslink_node_update_value_new(link, stringValueNode, json_string("Hello World!")); dslink_node_add_child(link, stringValueNode); responder_init_replicator(link, superRoot); responder_init_rng(link, superRoot); responder_init_invoke(link, superRoot); responder_init_serialization(link, superRoot); // add link data json_t * linkData = json_object(); json_object_set_nocheck(linkData, "test", json_true()); link->link_data = linkData; log_info("Initialized!\n"); }
static json_t *parse_dict(stream_t *stream, size_t flags, json_error_t *error) { int c; char *key; json_t *value; json_t *object = json_object(); if(!object) return NULL; c = stream_getc(stream); assert(c == 'd'); while (1) { c = stream_peek(stream); if (c == EOF) { error_set(error, stream, "unterminated dictionary"); goto error; } if (c == 'e') break; key = parse_string(stream, flags, error); if (!key) goto error; if(flags & JSON_REJECT_DUPLICATES) { if(json_object_get(object, key)) { jsonp_free(key); error_set(error, stream, "duplicate object key"); goto error; } } value = parse_value(stream, flags, error); if (!value) { jsonp_free(key); goto error; } if(json_object_set_nocheck(object, key, value)) { jsonp_free(key); json_decref(value); goto error; } json_decref(value); jsonp_free(key); } stream_getc(stream); return object; error: json_decref(object); return NULL; }
void cfg_set_global(const char *name, json_t *val) { pthread_rwlock_wrlock(&cfg_lock); if (!global_cfg) { global_cfg = json_object(); } json_object_set_nocheck(global_cfg, name, val); pthread_rwlock_unlock(&cfg_lock); }
void cfg_set_arg(const char *name, json_t *val) { pthread_rwlock_wrlock(&cfg_lock); if (!arg_cfg) { arg_cfg = json_object(); } json_object_set_nocheck(arg_cfg, name, val); pthread_rwlock_unlock(&cfg_lock); }
static void test_set_nocheck() { json_t *object, *string; object = json_object(); string = json_string("bar"); if(!object) fail("unable to create object"); if(!string) fail("unable to create string"); if(json_object_set_nocheck(object, "foo", string)) fail("json_object_set_nocheck failed"); if(json_object_get(object, "foo") != string) fail("json_object_get after json_object_set_nocheck failed"); /* invalid UTF-8 in key */ if(json_object_set_nocheck(object, "a\xefz", string)) fail("json_object_set_nocheck failed for invalid UTF-8"); if(json_object_get(object, "a\xefz") != string) fail("json_object_get after json_object_set_nocheck failed"); if(json_object_set_new_nocheck(object, "bax", json_integer(123))) fail("json_object_set_new_nocheck failed"); if(json_integer_value(json_object_get(object, "bax")) != 123) fail("json_object_get after json_object_set_new_nocheck failed"); /* invalid UTF-8 in key */ if(json_object_set_new_nocheck(object, "asdf\xfe", json_integer(321))) fail("json_object_set_new_nocheck failed for invalid UTF-8"); if(json_integer_value(json_object_get(object, "asdf\xfe")) != 321) fail("json_object_get after json_object_set_new_nocheck failed"); json_decref(string); json_decref(object); }
int json_object_update_missing(json_t *object, json_t *other) { const char *key; json_t *value; if(!json_is_object(object) || !json_is_object(other)) return -1; json_object_foreach(other, key, value) { if(!json_object_get(object, key)) json_object_set_nocheck(object, key, value); } return 0; }
int json_object_update(json_t *object, json_t *other) { void *iter; if(!json_is_object(object) || !json_is_object(other)) return -1; iter = json_object_iter(other); while(iter) { const char *key; json_t *value; key = json_object_iter_key(iter); value = json_object_iter_value(iter); if(json_object_set_nocheck(object, key, value)) return -1; iter = json_object_iter_next(other, iter); } return 0; }
static json_t *json_object_copy(json_t *object) { json_t *result; void *iter; result = json_object(); if(!result) return NULL; iter = json_object_iter(object); while(iter) { const char *key; json_t *value; key = json_object_iter_key(iter); value = json_object_iter_value(iter); json_object_set_nocheck(result, key, value); iter = json_object_iter_next(object, iter); } return result; }
static json_t *parse_object(lex_t *lex, size_t flags, json_error_t *error) { json_t *object = json_object(); if(!object) return NULL; lex_scan(lex, error); if(lex->token == '}') return object; while(1) { char *key; json_t *value; if(lex->token != TOKEN_STRING) { error_set(error, lex, "string or '}' expected"); goto error; } key = lex_steal_string(lex); if(!key) return NULL; if(flags & JSON_REJECT_DUPLICATES) { if(json_object_get(object, key)) { jsonp_free(key); error_set(error, lex, "duplicate object key"); goto error; } } lex_scan(lex, error); if(lex->token != ':') { jsonp_free(key); error_set(error, lex, "':' expected"); goto error; } lex_scan(lex, error); value = parse_value(lex, flags, error); if(!value) { jsonp_free(key); goto error; } if(json_object_set_nocheck(object, key, value)) { jsonp_free(key); json_decref(value); goto error; } json_decref(value); jsonp_free(key); lex_scan(lex, error); if(lex->token != ',') break; lex_scan(lex, error); } if(lex->token != '}') { error_set(error, lex, "'}' expected"); goto error; } return object; error: json_decref(object); return NULL; }
struct watchman_trigger_command *w_build_trigger_from_def( w_root_t *root, json_t *trig, char **errmsg) { struct watchman_trigger_command *cmd; json_t *ele, *query, *relative_root; json_int_t jint; const char *name = NULL; cmd = calloc(1, sizeof(*cmd)); if (!cmd) { *errmsg = strdup("no memory"); return NULL; } cmd->definition = trig; json_incref(cmd->definition); query = json_pack("{s:O}", "expression", json_object_get(cmd->definition, "expression")); relative_root = json_object_get(cmd->definition, "relative_root"); if (relative_root) { json_object_set_nocheck(query, "relative_root", relative_root); } cmd->query = w_query_parse(root, query, errmsg); json_decref(query); if (!cmd->query) { w_trigger_command_free(cmd); return NULL; } json_unpack(trig, "{s:s}", "name", &name); if (!name) { *errmsg = strdup("invalid or missing name"); w_trigger_command_free(cmd); return NULL; } cmd->triggername = w_string_new(name); cmd->command = json_object_get(trig, "command"); if (cmd->command) { json_incref(cmd->command); } if (!cmd->command || !json_is_array(cmd->command) || !json_array_size(cmd->command)) { *errmsg = strdup("invalid command array"); w_trigger_command_free(cmd); return NULL; } json_unpack(trig, "{s:b}", "append_files", &cmd->append_files); ele = json_object_get(trig, "stdin"); if (!ele) { cmd->stdin_style = input_dev_null; } else if (json_is_array(ele)) { cmd->stdin_style = input_json; if (!parse_field_list(ele, &cmd->field_list, errmsg)) { w_trigger_command_free(cmd); return NULL; } } else if (json_is_string(ele)) { const char *str = json_string_value(ele); if (!strcmp(str, "/dev/null")) { cmd->stdin_style = input_dev_null; } else if (!strcmp(str, "NAME_PER_LINE")) { cmd->stdin_style = input_name_list; } else { ignore_result(asprintf(errmsg, "invalid stdin value %s", str)); w_trigger_command_free(cmd); return NULL; } } else { *errmsg = strdup("invalid value for stdin"); w_trigger_command_free(cmd); return NULL; } jint = 0; // unlimited unless specified json_unpack(trig, "{s:I}", "max_files_stdin", &jint); if (jint < 0) { *errmsg = strdup("max_files_stdin must be >= 0"); w_trigger_command_free(cmd); return NULL; } cmd->max_files_stdin = (uint32_t)jint; json_unpack(trig, "{s:s}", "stdout", &cmd->stdout_name); json_unpack(trig, "{s:s}", "stderr", &cmd->stderr_name); if (!parse_redirection(&cmd->stdout_name, &cmd->stdout_flags, "stdout", errmsg)) { w_trigger_command_free(cmd); return NULL; } if (!parse_redirection(&cmd->stderr_name, &cmd->stderr_flags, "stderr", errmsg)) { w_trigger_command_free(cmd); return NULL; } // Copy current environment cmd->envht = w_envp_make_ht(); // Set some standard vars w_envp_set(cmd->envht, "WATCHMAN_ROOT", root->root_path); w_envp_set_cstring(cmd->envht, "WATCHMAN_SOCK", get_sock_name()); w_envp_set(cmd->envht, "WATCHMAN_TRIGGER", cmd->triggername); return cmd; }
static json_t *parse_object(lex_t *lex, json_error_t *error) { json_t *object = json_object(); if(!object) return NULL; lex_scan(lex, error); if(lex->token == '}') return object; while(1) { char *key; json_t *value; if(lex->token != TOKEN_STRING) { error_set(error, lex, "string or '}' expected"); goto error; } key = lex_steal_string(lex); if(!key) return NULL; lex_scan(lex, error); if(lex->token != ':') { free(key); error_set(error, lex, "':' expected"); goto error; } lex_scan(lex, error); value = parse_value(lex, error); if(!value) { free(key); goto error; } if(json_object_set_nocheck(object, key, value)) { free(key); json_decref(value); goto error; } json_decref(value); free(key); lex_scan(lex, error); if(lex->token != ',') break; lex_scan(lex, error); } if(lex->token != '}') { error_set(error, lex, "'}' expected"); goto error; } return object; error: json_decref(object); return NULL; }
json_t *broker_handshake_handle_conn(Broker *broker, const char *dsId, const char *token, json_t *handshake) { if (dslink_map_contains(&broker->client_connecting, (void *) dsId)) { ref_t *ref = dslink_map_remove_get(&broker->client_connecting, (void *) dsId); RemoteDSLink *link = ref->data; dslink_map_remove(&broker->client_connecting, (void *) link->name); broker_remote_dslink_free(link); dslink_free(link); dslink_decref(ref); } RemoteDSLink *link = dslink_calloc(1, sizeof(RemoteDSLink)); json_t *resp = json_object(); if (!(link && resp)) { goto fail; } if (broker_remote_dslink_init(link) != 0) { goto fail; } link->broker = broker; link->auth = dslink_calloc(1, sizeof(RemoteAuth)); if (!link->auth) { goto fail; } if (dslink_handshake_generate_key_pair(&link->auth->tempKey) != 0) { log_err("Failed to create temporary key for DSLink\n"); goto fail; } { json_t *jsonPubKey = json_object_get(handshake, "publicKey"); if (!jsonPubKey) { goto fail; } const char *tmp = json_string_value(jsonPubKey); if (!tmp) { goto fail; } tmp = dslink_strdup(tmp); if (!tmp) { goto fail; } link->auth->pubKey = tmp; } char tempKey[90]; size_t tempKeyLen = 0; if (dslink_handshake_encode_pub_key(&link->auth->tempKey, tempKey, sizeof(tempKey), &tempKeyLen) != 0) { goto fail; } if (generate_salt((unsigned char *) link->auth->salt, sizeof(link->auth->salt)) != 0) { goto fail; } json_object_set_new_nocheck(resp, "wsUri", json_string_nocheck("/ws")); json_object_set_new_nocheck(resp, "tempKey", json_string_nocheck(tempKey)); json_object_set_new_nocheck(resp, "salt", json_string_nocheck(link->auth->salt)); if (json_boolean_value(json_object_get(handshake, "isResponder"))) { link->isResponder = 1; } if (json_boolean_value(json_object_get(handshake, "isRequester"))) { link->isRequester = 1; } json_t *linkData = json_object_get(handshake, "linkData"); if (json_is_object(linkData)) { json_incref(linkData); link->linkData = linkData; } { char buf[512] = {0}; snprintf(buf, sizeof(buf), "/downstream/"); char *name = buf + sizeof("/downstream/")-1; size_t dsIdLen = strlen(dsId); if (dsIdLen < 44) { goto fail; } size_t nameLen = dsIdLen - 43; if (dsId[nameLen - 1] == '-') { nameLen--; } int nodeExists = 0; // find a valid name from broker->client_names memcpy(name, dsId, nameLen); while (1) { ref_t *ref = dslink_map_get(&broker->client_connecting, name); if (ref) { RemoteDSLink *l = ref->data; if (l && l->dsId && strcmp(l->dsId->data, dsId) == 0) { dslink_map_remove(&broker->client_connecting, name); broker_remote_dslink_free(l); break; } else { name[nameLen] = dsId[nameLen]; nameLen++; } } ref = dslink_map_get(broker->downstream->children, (void *) name); if (ref == NULL) { break; } if (!((DownstreamNode *) ref->data)->dsId || strcmp(dsId, ((DownstreamNode *) ref->data)->dsId->data) == 0) { nodeExists = 1; break; } name[nameLen] = dsId[nameLen]; nameLen++; } if (!nodeExists && broker_enable_token) { if (!token) { log_err("Failed to connet, need token\n"); goto fail; } BrokerNode* tokenNode = get_token_node(token, dsId); if (tokenNode) { DownstreamNode *node = broker_init_downstream_node(broker->downstream, name); if (json_is_true(json_object_get(node->meta, "$$managed"))) { json_object_set_new_nocheck(node->meta, "$$token", json_string_nocheck(tokenNode->name)); } node->dsId = dslink_str_ref(dsId); if (broker->downstream->list_stream) { update_list_child(broker->downstream, broker->downstream->list_stream, link->name); } json_t *group = json_object_get(tokenNode->meta, "$$group"); if (json_is_string(group)) { json_object_set_nocheck(node->meta, "$$group", group); } token_used(tokenNode); broker_downstream_nodes_changed(broker); } else { log_err("Invalid token: %s\n", token); goto fail; } } json_object_set_new_nocheck(resp, "path", json_string_nocheck(buf)); link->path = dslink_strdup(buf); if (!link->path) { goto fail; } link->name = link->path + sizeof("/downstream/") - 1; // add to connecting map with the name if (dslink_map_set(&broker->client_connecting, dslink_ref((void *) link->name, NULL), dslink_ref(link, NULL)) != 0) { dslink_free((void *) link->path); goto fail; } } { ref_t *tmp = dslink_ref(dslink_strdup(dsId), dslink_free); if (!tmp) { goto fail; } // add to connecting map with dsId if (dslink_map_set(&broker->client_connecting, tmp, dslink_ref(link, NULL)) != 0) { dslink_free(tmp); goto fail; } } return resp; fail: if (link) { broker_remote_dslink_free(link); dslink_free((void *) link->path); dslink_free(link); } DSLINK_CHECKED_EXEC(json_decref, resp); return NULL; }
int la_codec_object_set_nocheck(la_codec_value_t *object, const char *key, la_codec_value_t *value) { return json_object_set_nocheck((json_t *) object, key, (json_t *) value); }