/* 得到策略信息 */ struct policymsg get_policy_json (char *jsonfile) { struct policymsg policyinfo; int i, size; void *iter; json_t *object; json_t *iter_values; json_error_t error; object = json_object (); /* 读取策略 */ object = json_load_file (jsonfile, 0, &error); policyinfo.size = json_object_size (object); #if 0 //size = json_object_size (object); //printf("size=%d\n", size); /* 取出object中的值 */ //struct policy iter_get_value(json_t *object) char *result; result = json_dumps (object, JSON_PRESERVE_ORDER); printf ("result=%s\n", result); /* 判断读取的jansson类型 */ printf ("判断是什么类型\n"); my_json_type (object); printf ("result_size = %d\n", strlen (result)); #endif //printf("得到策略值\n"); iter = json_object_iter (object); i = 0; while (1) { strcpy (policyinfo.keyword[i], json_object_iter_key (iter)); iter_values = json_object_iter_value (iter); strcpy (policyinfo.keycount[i], json_string_value (iter_values)); //printf("values[%d]=%s\n", i,json_string_value(iter_values[i])); if ((iter = json_object_iter_next (object, iter)) == NULL) { //printf("iterate end\n"); break; } i++; } #if 0 iter = json_object_iter_at (object, "b"); if (iter) { iter_keys[i] = json_object_iter_key (iter); iter_values[i] = json_object_iter_value (iter); printf ("values[%d]=%s\n", i, json_string_value (iter_values[i])); } #endif json_decref (object); return policyinfo; }
int parseLS(const char *response, hdfsFileInfo **fileStats, int *numOfEntries) { int ret = 0; json_error_t error; size_t flags = 0; json_t *jobj, *value; const char *key; void *iter = NULL; if (!response || response[0] == '\0' || !fileStats) { return EIO; } jobj = json_loads(response, flags, &error); if (!jobj) { fprintf(stderr, "error while parsing json: on line %d: %s\n", error.line, error.text); return EIO; } iter = json_object_iter(jobj); key = json_object_iter_key(iter); value = json_object_iter_value(iter); if (json_typeof(value) == JSON_OBJECT) { if (!strcmp(key, "RemoteException")) { struct jsonException *exception = parseJsonException(value); if (exception) { ret = printJsonException(exception, PRINT_EXC_ALL, "Calling WEBHDFS GETFILESTATUS"); } else { ret = EIO; } } else if (!strcmp(key, "FileStatuses")) { iter = json_object_iter(value); value = json_object_iter_value(iter); if (json_is_array(value)) { ret = parseJsonArrayForFileStatuses(value, fileStats, numOfEntries); } else { ret = EIO; } } else { ret = EIO; } } else { ret = EIO; } json_decref(jobj); return ret; }
static int bser_object(json_t *obj, json_dump_callback_t dump, void *data) { size_t n; json_t *val; const char *key; void *iter; if (dump(&bser_object_hdr, sizeof(bser_object_hdr), data)) { return -1; } n = json_object_size(obj); if (bser_int(n, dump, data)) { return -1; } iter = json_object_iter(obj); while (iter) { key = json_object_iter_key(iter); val = json_object_iter_value(iter); if (bser_string(key, dump, data)) { return -1; } if (w_bser_dump(val, dump, data)) { return -1; } iter = json_object_iter_next(obj, iter); } return 0; }
/** * Parse the exception information which is presented in JSON * * @param content Exception information in JSON * @return jsonException for printing out */ static struct jsonException *parseException(const char *content) { json_error_t error; size_t flags = 0; const char *key = NULL; json_t *value; json_t *jobj; struct jsonException *exception = NULL; if (!content) { return NULL; } jobj = json_loads(content, flags, &error); if (!jobj) { fprintf(stderr, "JSon parsing error: on line %d: %s\n", error.line, error.text); return NULL; } void *iter = json_object_iter(jobj); while(iter) { key = json_object_iter_key(iter); value = json_object_iter_value(iter); if (!strcmp(key, "RemoteException") && json_typeof(value) == JSON_OBJECT) { exception = parseJsonException(value); break; } iter = json_object_iter_next(jobj, iter); } json_decref(jobj); return exception; }
//native Handle:json_object_iter_value(Handle:hIter, String:sValueBuffer[], maxlength); static cell_t Native_json_object_iter_value(IPluginContext *pContext, const cell_t *params) { HandleError err; HandleSecurity sec; sec.pOwner = NULL; sec.pIdentity = myself->GetIdentity(); // Param 1 void *iter; Handle_t hndlIterator = static_cast<Handle_t>(params[1]); if ((err=g_pHandleSys->ReadHandle(hndlIterator, htJanssonIterator, &sec, (void **)&iter)) != HandleError_None) { pContext->ThrowNativeError("Invalid <JSON Iterator> handle %x (error %d)", hndlIterator, err); return BAD_HANDLE; } json_t *result = json_object_iter_value(iter); // Return if(result == NULL) { return BAD_HANDLE; } Handle_t hndlResult = g_pHandleSys->CreateHandle(htJanssonObject, result, pContext->GetIdentity(), myself->GetIdentity(), NULL); if(hndlResult == BAD_HANDLE) { pContext->ThrowNativeError("Could not create handle for iterator element."); return BAD_HANDLE; } // result is a borrowed reference, we don't know what will happen with it // so we increase the reference counter, which enforces the developer to // CloseHandle() it. json_incref(result); return hndlResult; }
static json_t *OutputStats2Json(json_t *js, const char *key) { void *iter; const char *dot = index(key, '.'); if (dot == NULL) return NULL; size_t predot_len = (dot - key) + 1; char s[predot_len]; strlcpy(s, key, predot_len); iter = json_object_iter_at(js, s); const char *s2 = index(dot+1, '.'); json_t *value = json_object_iter_value(iter); if (value == NULL) { value = json_object(); json_object_set_new(js, s, value); } if (s2 != NULL) { return OutputStats2Json(value, &key[dot-key+1]); } return value; }
/** Parse the exception information from JSON */ static struct jsonException *parseJsonException(json_t *jobj) { const char *key = NULL; json_t *value = NULL; struct jsonException *exception = NULL; void *iter = NULL; exception = calloc(1, sizeof(*exception)); if (!exception) { return NULL; } iter = json_object_iter(jobj); while (iter) { key = json_object_iter_key(iter); value = json_object_iter_value(iter); if (!strcmp(key, "exception")) { exception->exception = json_string_value(value); } else if (!strcmp(key, "javaClassName")) { exception->javaClassName = json_string_value(value); } else if (!strcmp(key, "message")) { exception->message = json_string_value(value); } iter = json_object_iter_next(jobj, iter); } return exception; }
static int json_object_equal(json_t *object1, json_t *object2) { void *iter; if(json_object_size(object1) != json_object_size(object2)) return 0; iter = json_object_iter(object1); while(iter) { const char *key; json_t *value1, *value2; key = json_object_iter_key(iter); value1 = json_object_iter_value(iter); value2 = json_object_get(object2, key); if(!json_equal(value1, value2)) return 0; iter = json_object_iter_next(object1, iter); } return 1; }
static json_t *object_data_to_json(const json_t *typedesc, const qeocore_data_t *data) { json_t *json_data = NULL; json_t *properties = json_object_get(typedesc, KEY_PROPERTIES); if ((NULL != properties) && (json_is_object(properties))) { json_data = json_object(); const char *prop_name = NULL; json_t *prop_value = NULL; void *iter = json_object_iter(properties); while (iter) { // Get type name and value prop_name = json_object_iter_key(iter); prop_value = json_object_iter_value(iter); json_t *value = member_data_to_json(prop_value, data); if (NULL != value) { json_object_set_new(json_data, prop_name, value); } else { json_decref(json_data); json_data = NULL; break; } iter = json_object_iter_next(properties, iter); } } return json_data; }
int main (void) { json_t *root, *value, *persona; json_error_t err; const char *key; void *iter; root = json_load_file("prueba.json", 0, &err); if (root == NULL) { perror("Error: "); fprintf(stderr, "Jansson error: %s %d %d\n", err.text, err.column, err.line); return EXIT_FAILURE; } persona = json_object_get(root, "persona"); if (persona == NULL) return EXIT_FAILURE; iter = json_object_iter(persona); while (iter) { key = json_object_iter_key(iter); value = json_object_iter_value(iter); printf ("key del objeto %s\n", key); iter = json_object_iter_next(persona, iter); } json_decref(root); return EXIT_SUCCESS; }
void BinWriter::writeMemberInfo(json_t *jminfo) { int iname = poolJString(json_object_get(jminfo, "name")); int isource = -1; int ilinenumber = -1; json_t *jsource = json_object_get(jminfo, "source"); if (jsource && json_is_string(jsource)) { isource = poolString(json_string_value(jsource)); ilinenumber = (int)json_integer_value(json_object_get(jminfo, "line")); } bytes.writeInt(iname); bytes.writeInt((int)json_integer_value(json_object_get(jminfo, "ordinal"))); bytes.writeInt(isource); bytes.writeInt(ilinenumber); json_t *meta_object = json_object_get(jminfo, "metainfo"); size_t meta_object_size = json_object_size(meta_object); // write the size of the object bytes.writeInt((int)meta_object_size); void *iter = json_object_iter(meta_object); size_t count = 0; while (iter) { // write the name to the pool table bytes.writeInt(poolString(json_object_iter_key(iter))); json_t *metaArray = json_object_iter_value(iter); // write the length of the meta array bytes.writeInt((int)json_array_size(metaArray)); for (UTsize i = 0; i < json_array_size(metaArray); i++) { json_t *keyArray = json_array_get(metaArray, i); // write the length of the key array bytes.writeInt((int)json_array_size(keyArray)); for (UTsize j = 0; j < json_array_size(keyArray); j++) { bytes.writeInt(poolString(json_string_value(json_array_get(keyArray, j)))); } } iter = json_object_iter_next(meta_object, iter); count++; } lmAssert(meta_object_size == count, "json object size mismatch"); }
GObject *json_gobject_deserialize (GType gtype, json_t *object) { GObjectClass *klass; GObject *ret; guint n_members, i; json_t *head, *member; const char *member_name; GArray *construct_params; klass = g_type_class_ref (gtype); n_members = json_object_size (object); construct_params = g_array_sized_new (FALSE, FALSE, sizeof (GParameter), n_members); head = json_object_iter (object); for (member=head; member; member=json_object_iter_next (object, member)) { GParamSpec *pspec; GParameter param = { NULL, }; const char *member_name = json_object_iter_key (member); json_t *val = json_object_iter_value(member); pspec = g_object_class_find_property (klass, member_name); if (!pspec) continue; if (pspec->flags & G_PARAM_CONSTRUCT_ONLY) continue; if (!(pspec->flags & G_PARAM_WRITABLE)) continue; g_value_init(¶m.value, G_PARAM_SPEC_VALUE_TYPE (pspec)); if (json_deserialize_pspec (¶m.value, pspec, val)) { param.name = g_strdup (pspec->name); g_array_append_val (construct_params, param); } else g_warning ("Failed to deserialize \"%s\" property of type \"%s\" for an object of type \"%s\"", pspec->name, g_type_name (G_VALUE_TYPE (¶m.value)), g_type_name (gtype)); } ret = g_object_newv (gtype, construct_params->len, (GParameter *) construct_params->data); for (i=0; i!= construct_params->len; ++i) { GParameter *param = &g_array_index (construct_params, GParameter, i); g_free ((gchar *) param->name); g_value_unset (¶m->value); } g_array_free(construct_params, TRUE); g_type_class_unref(klass); return ret; }
Value NDKHelper::getValueFromJson(json_t *obj) { if (obj == NULL) { return Value::Null; } if (json_is_object(obj)) { ValueMap valueMap; const char *key; json_t *value; void *iter = json_object_iter(obj); while (iter) { key = json_object_iter_key(iter); value = json_object_iter_value(iter); valueMap[key] = NDKHelper::getValueFromJson(value); iter = json_object_iter_next(obj, iter); } return Value(valueMap); } else if (json_is_array(obj)) { ValueVector valueVector; size_t sizeArray = json_array_size(obj); for (unsigned int i = 0; i < sizeArray; i++) { valueVector.push_back(NDKHelper::getValueFromJson(json_array_get(obj, i))); } return Value(valueVector); } else if (json_is_boolean(obj)) { if (json_is_true(obj)) { return Value(true); } else { return Value(false); } } else if (json_is_integer(obj)) { int value = (int) json_integer_value(obj); return Value(value); } else if (json_is_real(obj)) { double value = json_real_value(obj); return Value(value); } else if (json_is_string(obj)) { std::string value = json_string_value(obj); return Value(value); } return Value::Null; }
/** * Retrieve file status from the JSON object * * @param jobj JSON object for parsing, which contains * file status information * @param fileStat hdfsFileInfo handle to hold file status information * @return 0 on success */ static int parseJsonForFileStatus(json_t *jobj, hdfsFileInfo *fileStat) { const char *key, *tempstr; json_t *value; void *iter = NULL; iter = json_object_iter(jobj); while (iter) { key = json_object_iter_key(iter); value = json_object_iter_value(iter); if (!strcmp(key, "accessTime")) { // json field contains time in milliseconds, // hdfsFileInfo is counted in seconds fileStat->mLastAccess = json_integer_value(value) / 1000; } else if (!strcmp(key, "blockSize")) { fileStat->mBlockSize = json_integer_value(value); } else if (!strcmp(key, "length")) { fileStat->mSize = json_integer_value(value); } else if (!strcmp(key, "modificationTime")) { fileStat->mLastMod = json_integer_value(value) / 1000; } else if (!strcmp(key, "replication")) { fileStat->mReplication = json_integer_value(value); } else if (!strcmp(key, "group")) { fileStat->mGroup = strdup(json_string_value(value)); if (!fileStat->mGroup) { return ENOMEM; } } else if (!strcmp(key, "owner")) { fileStat->mOwner = strdup(json_string_value(value)); if (!fileStat->mOwner) { return ENOMEM; } } else if (!strcmp(key, "pathSuffix")) { fileStat->mName = strdup(json_string_value(value)); if (!fileStat->mName) { return ENOMEM; } } else if (!strcmp(key, "permission")) { tempstr = json_string_value(value); fileStat->mPermissions = (short) strtol(tempstr, NULL, 8); } else if (!strcmp(key, "type")) { tempstr = json_string_value(value); if (!strcmp(tempstr, "DIRECTORY")) { fileStat->mKind = kObjectKindDirectory; } else { fileStat->mKind = kObjectKindFile; } } // Go to the next key-value pair in the json object iter = json_object_iter_next(jobj, iter); } return 0; }
struct samba3_user *getsamba3users(void) { struct samba3_user *list, *current; int count, entry_count; json_t *json; json_error_t error; const char *key; json_t *iterator, *entry, *value; char username[64],password[64]; int type; // first create dummy entry list = getsamba3user("", "", 0); current = list; //json = json_loads( "[{\"user\":\"peter\",\"pass\":\"test\"},{\"user\":\"chris\",\"pass\":\"test\"}]", &error ); json = json_loads( nvram_default_get( "samba3_users", "[]"), 0, &error); if( !json ) { fprintf( stderr, "[JASON] ERROR\n"); } else { entry_count = json_array_size(json); for( count = 0; count < entry_count; count++ ) { entry = json_array_get( json, count ); iterator = json_object_iter(entry); // reset username[0] = 0; password[0] = 0; while(iterator) { key = json_object_iter_key(iterator); value = json_object_iter_value(iterator); /* use key and value ... */ if( !strcmp( key, "user" ) ) { strncpy( username, json_string_value( value ),sizeof(username)-1); } else if( !strcmp( key, "pass" ) ) { strncpy( password, json_string_value( value ),sizeof(password)-1); } else if( !strcmp( key, "type" ) ) { type = json_integer_value( value ); } iterator = json_object_iter_next(entry, iterator); } if( username[0] != 0 ) { current->next = getsamba3user(username, password, type); current = current->next; } } json_array_clear(json); } return list; }
AlgorithmConfig jsonToAlgorithmConfig(/*const*/ json_t* jsonAlgorithmConfig) const { JanssonUtil::assertJsonType(jsonAlgorithmConfig, JSON_OBJECT); std::map<std::string,std::string> params; void* iter = json_object_iter(jsonAlgorithmConfig); // can't have const because of this call while (iter) { std::string name = std::string(json_object_iter_key(iter)); std::string val = fromJsonString(json_object_iter_value(iter)); params[name]=val; iter = json_object_iter_next(jsonAlgorithmConfig,iter); } return AlgorithmConfig(params); }
/* * see if a the Require value matches with a set of provided claims */ static apr_byte_t oidc_authz_match_claim(request_rec *r, const char * const attr_spec, const json_t * const claims) { const char *key; json_t *val; /* if we don't have any claims, they can never match any Require claim primitive */ if (claims == NULL) return FALSE; /* loop over all of the user claims */ void *iter = json_object_iter((json_t*) claims); while (iter) { key = json_object_iter_key(iter); val = json_object_iter_value(iter); oidc_debug(r, "evaluating key \"%s\"", (const char * ) key); const char *attr_c = (const char *) key; const char *spec_c = attr_spec; /* walk both strings until we get to the end of either or we find a differing character */ while ((*attr_c) && (*spec_c) && (*attr_c) == (*spec_c)) { attr_c++; spec_c++; } /* The match is a success if we walked the whole claim name and the attr_spec is at a colon. */ if (!(*attr_c) && (*spec_c) == ':') { /* skip the colon */ spec_c++; if (oidc_authz_match_value(r, spec_c, val, key) == TRUE) return TRUE; /* a tilde denotes a string PCRE match */ } else if (!(*attr_c) && (*spec_c) == '~') { /* skip the tilde */ spec_c++; if (oidc_authz_match_expression(r, spec_c, val) == TRUE) return TRUE; } iter = json_object_iter_next((json_t *) claims, iter); } return FALSE; }
int parseGFS(const char *response, hdfsFileInfo *fileStat, int printError) { int ret = 0, printFlag; json_error_t error; size_t flags = 0; json_t *jobj, *value; const char *key; void *iter = NULL; if (!response || !fileStat) { return EIO; } jobj = json_loads(response, flags, &error); if (!jobj) { fprintf(stderr, "error while parsing json: on line %d: %s\n", error.line, error.text); return EIO; } iter = json_object_iter(jobj); key = json_object_iter_key(iter); value = json_object_iter_value(iter); if (json_typeof(value) == JSON_OBJECT) { if (!strcmp(key, "RemoteException")) { struct jsonException *exception = parseJsonException(value); if (exception) { if (printError) { printFlag = PRINT_EXC_ALL; } else { printFlag = NOPRINT_EXC_FILE_NOT_FOUND | NOPRINT_EXC_ACCESS_CONTROL | NOPRINT_EXC_PARENT_NOT_DIRECTORY; } ret = printJsonException(exception, printFlag, "Calling WEBHDFS GETFILESTATUS"); } else { ret = EIO; } } else if (!strcmp(key, "FileStatus")) { ret = parseJsonForFileStatus(value, fileStat); } else { ret = EIO; } } else { ret = EIO; } json_decref(jobj); return ret; }
struct dlna_share *getdlnashares(void) { struct dlna_share *list, *current; int count, entry_count; json_t *json; json_error_t error; const char *key; json_t *iterator, *entry, *value; char mp[64], types; // first create dummy entry list = getdlnashare("", 0); current = list; // json = json_loads( "[{\"mp\":\"/jffs\",\"label\":\"testshare\",\"perms\":\"rw\",\"public\":0},{\"mp\":\"/mnt\",\"label\":\"othertest\",\"perms\":\"ro\",\"public\":1},{\"label\":\"blah\"}]", &error ); json = json_loads(nvram_default_get("dlna_shares", "[]"), 0, &error); if (!json) { fprintf(stderr, "[JASON] ERROR\n"); } else { entry_count = json_array_size(json); for (count = 0; count < entry_count; count++) { entry = json_array_get(json, count); iterator = json_object_iter(entry); // reset mp[0] = 0; types = 0; while (iterator) { key = json_object_iter_key(iterator); value = json_object_iter_value(iterator); /* use key and value ... */ if (!strcmp(key, "mp")) { strncpy(mp, json_string_value(value), sizeof(mp) - 1); } else if (!strcmp(key, "types")) { types = json_integer_value(value); } iterator = json_object_iter_next(entry, iterator); } if (mp[0] != 0) { current->next = getdlnashare(mp, types); current = current->next; } } json_array_clear(json); } return list; }
static size_t DoJsonEach(KonohaContext *kctx, struct JsonBuf *jsonbuf, void *thunk, void (*doEach)(KonohaContext *, const char *, struct JsonBuf *, void *)) { size_t count = 0; struct JsonBuf eachbuf = {}; void *iter = json_object_iter(jsonbuf->jsonobj); while(iter != NULL) { const char *key = json_object_iter_key(iter); json_t *value = json_object_iter_value(iter); SetJsonBuf(&eachbuf, value); doEach(kctx, key, &eachbuf, thunk); count++; iter = json_object_iter_next(jsonbuf->jsonobj, iter); } FreeJson(kctx, &eachbuf); return count; }
//----------------------------------------------------------------// void _jsonObjectToLua ( lua_State* L, json_t* json ) { assert ( json->type == JSON_OBJECT ); lua_newtable ( L ); void* iter = json_object_iter ( json ); for ( ; iter; iter = json_object_iter_next ( json, iter )) { cc8* key = json_object_iter_key ( iter ); json_t* value = json_object_iter_value ( iter ); _jsonToLua ( L, value ); lua_setfield ( L, -2, key ); } }
ScriptProps::ScriptProps(Script& script, json_t* detail, const vector<string>& spec_props) throw(Exception): EnumExpandable(script, detail, spec_props) { if (!finished()) return; json_t* after_enum_expand = EnumExpandable::expand_context; void* it = json_object_iter(after_enum_expand); while ( it) { const char* pnm = json_object_iter_key(it); json_t* v = json_object_iter_value(it); Property* pobj = new Property(*this, pnm, v); props[pnm].reset(pobj); it = json_object_iter_next(after_enum_expand, it); } }
void oidc_session_set_filtered_claims(request_rec *r, oidc_session_t *z, const char *session_key, const char *claims) { oidc_cfg *c = ap_get_module_config(r->server->module_config, &auth_openidc_module); const char *name; json_t *src = NULL, *dst = NULL, *value = NULL; void *iter = NULL; apr_byte_t is_allowed; if (oidc_util_decode_json_object(r, claims, &src) == FALSE) return; dst = json_object(); iter = json_object_iter(src); while (iter) { is_allowed = TRUE; name = json_object_iter_key(iter); value = json_object_iter_value(iter); if ((c->black_listed_claims != NULL) && (apr_hash_get(c->black_listed_claims, name, APR_HASH_KEY_STRING) != NULL)) { oidc_debug(r, "removing blacklisted claim [%s]: '%s'", session_key, name); is_allowed = FALSE; } if ((is_allowed == TRUE) && (c->white_listed_claims != NULL) && (apr_hash_get(c->white_listed_claims, name, APR_HASH_KEY_STRING) == NULL)) { oidc_debug(r, "removing non-whitelisted claim [%s]: '%s'", session_key, name); is_allowed = FALSE; } if (is_allowed == TRUE) json_object_set(dst, name, value); iter = json_object_iter_next(src, iter); } char *filtered_claims = oidc_util_encode_json_object(r, dst, JSON_COMPACT); json_decref(dst); json_decref(src); oidc_session_set(r, z, session_key, filtered_claims); }
symbols_t* drakvuf_get_symbols_from_rekall(const char *rekall_profile) { symbols_t *ret = g_malloc0(sizeof(symbols_t)); json_error_t error; json_t *root = json_load_file(rekall_profile, 0, &error); if (!root) { PRINT_DEBUG("Rekall profile error on line %d: %s\n", error.line, error.text); goto err_exit; } if (!json_is_object(root)) { PRINT_DEBUG("Rekall profile: root is not an objet\n"); goto err_exit; } json_t *functions = json_object_get(root, "$FUNCTIONS"); ret->count = json_object_size(functions); PRINT_DEBUG("The Rekall profile defines %lu functions\n", ret->count); ret->symbols = g_malloc0(sizeof(struct symbol) * ret->count); const char *key; json_t *value; void *iter = json_object_iter(functions); int i = 0; while (iter) { key = json_object_iter_key(iter); value = json_object_iter_value(iter); ret->symbols[i].name = strdup(key); ret->symbols[i].rva = json_integer_value(value); /* use key and value ... */ iter = json_object_iter_next(functions, iter); i++; } return ret; err_exit: free(ret); return NULL; }
ScriptProps::ScriptProps(Script& script, json_t* detail, const char* enum_apply_tag) throw (Exception): EnumExpandable(script, detail, enum_apply_tag) { if ( !finished() ) { return; } json_t* after_enum_expand = EnumExpandable::expand_context; void* it = json_object_iter(after_enum_expand); while ( it) { const char* pnm = json_object_iter_key(it); json_t* v = json_object_iter_value(it); Property* pobj = new Property(*this, pnm, v); props.insert( make_pair(string(pnm), std::tr1::shared_ptr<Property>(pobj)) ) ; it = json_object_iter_next(after_enum_expand, it); } }
void ScriptProps::expand_enum(const char* ename, const char* sname, const char* param_tag, const json_t* value) throw (Exception) { EnumExpandable::expand_enum(ename,sname, param_tag, value); if ( !finished() ) { return; } json_t* after_enum_expand = EnumExpandable::expand_context; void* it = json_object_iter(after_enum_expand); while ( it) { const char* pnm = json_object_iter_key(it); json_t* v = json_object_iter_value(it); Property* pobj = new Property(*this, pnm, v); props.insert( make_pair(string(pnm), std::tr1::shared_ptr<Property>(pobj)) ) ; it = json_object_iter_next(after_enum_expand, it); } }
int printKeyValJsonObj( json_t *keyValObj ) { void *iter; const char *key; json_t *value; printf( "keys: Value Object\n {\n" ); iter = json_object_iter( keyValObj ); while ( iter ) { json_type myType; char valueStr[NAME_LEN]; key = json_object_iter_key( iter ); value = json_object_iter_value( iter ); myType = json_typeof( value ); switch ( myType ) { case JSON_STRING: snprintf( valueStr, NAME_LEN, "%s", json_string_value( value ) ); break; case JSON_INTEGER: snprintf( valueStr, NAME_LEN, "%d", ( int ) json_integer_value( value ) ); break; case JSON_REAL: snprintf( valueStr, NAME_LEN, "%f", ( float ) json_real_value( value ) ); break; case JSON_TRUE: snprintf( valueStr, NAME_LEN, "TRUE" ); break; case JSON_FALSE: snprintf( valueStr, NAME_LEN, "FALSE" ); break; default: snprintf( valueStr, NAME_LEN, "Unknown json_type: %d", myType ); } printf( " %s: %s\n", key, valueStr ); iter = json_object_iter_next( keyValObj, iter ); } printf( " }\n" ); return 0; }
int cellophane_handshake(WsHandler * ws_handler) { json_error_t json_err; json_t *json_ret; json_t *value; json_t *transport; void *iter; char * res; char *key; size_t index; fprintf(stderr, "sending web request \n"); res = cellophane_do_web_request(ws_handler); if (res == NULL || strcmp(res,"") == 0){ return 0; } cellophane_print_log(ws_handler,LOG_INFO,DEBUG_DIAGNOSTIC, "Curl Response : %s", res); json_ret = json_loads(res, 0, &json_err); if(json_ret == NULL){ cellophane_print_log(ws_handler,LOG_ERROR,DEBUG_NONE, "Could not decode trasnport JSON: %d: %s\n", json_err.line, json_err.text); return 0; } free(res); cellophane_print_log(ws_handler,LOG_INFO,DEBUG_DIAGNOSTIC,"Json parsed succesfully"); iter = json_object_iter(json_ret); while(iter){ key = json_object_iter_key(iter); value = json_object_iter_value(iter); if(strcmp(key, "sid") == 0){ ws_handler->session.sid = strdup(json_string_value(value)); cellophane_print_log(ws_handler,LOG_INFO,DEBUG_DETAILED,"Session id : %s", ws_handler->session.sid); }else if(strcmp(key, "upgrades") == 0){ index = json_array_size(value); if(index > 0){ ws_handler->session.supported_transports = (char **) malloc(index * sizeof(char*)); json_array_foreach(value, index, transport){ ws_handler->session.supported_transports[index] = strdup(json_string_value(transport)); } }
static size_t write_object(json_t* json, stream_t* stream) { uint8_t tag = BSER_TAG_OBJECT; size_t bytes = 0; assert(json_is_object(json)); if (stream->write(stream, &tag, SIZE_U8) == SIZE_U8) { size_t total_bytes = SIZE_U8; json_t* length_node = json_integer(json_object_size(json)); size_t integer_length = write_integer(length_node, stream); total_bytes += integer_length; json_decref(length_node); if (integer_length > 0) { size_t val_bytes = 1; void *iter = json_object_iter(json); while (iter != NULL && val_bytes > 0) { val_bytes = 0; json_t* key_node = json_string(json_object_iter_key(iter)); size_t key_bytes = write_string(key_node, stream); total_bytes += key_bytes; json_decref(key_node); if (key_bytes > 0) { json_t* value = json_object_iter_value(iter); val_bytes = write_json(value, stream); total_bytes += val_bytes; } iter = json_object_iter_next(json, iter); } if (iter == NULL) { bytes = total_bytes; } } } return bytes; }
QMap<QString, QVariant> mapFromJSON(json_t *json, json_error_t *error) { QMap<QString, QVariant> dict; void *member; const char *key; json_t *value; for (member = json_object_iter(json); member; member = json_object_iter_next(json, member)) { key = json_object_iter_key(member); value = json_object_iter_value(member); QString k = QString::fromUtf8(key); QVariant v; // json_is_object(const json_t *json) // json_is_array(const json_t *json) // json_is_string(const json_t *json) // json_is_integer(const json_t *json) // json_is_real(const json_t *json) // json_is_true(const json_t *json) // json_is_false(const json_t *json) // json_is_null(const json_t *json) if (json_is_object(value)) { v = mapFromJSON(json, NULL); } else if (json_is_array(value)) { v = listFromJSON(value); } else if (json_is_string(value)) { v = QString::fromUtf8(json_string_value(value)); } else if (json_is_integer(value)) { v = json_integer_value(value); } else if (json_is_real(value)) { v = json_real_value(value); } else if (json_is_boolean(value)) { v = json_is_true(value); } if (v.isValid()) { dict[k] = v; } } return dict; }