/* Build the RDP server from information in the JSON object */ Server * rdp_server_new_from_json (JsonObject * object) { RdpServer * server = g_object_new(RDP_SERVER_TYPE, NULL); if (json_object_has_member(object, JSON_SERVER_NAME)) { JsonNode * node = json_object_get_member(object, JSON_SERVER_NAME); if (JSON_NODE_TYPE(node) == JSON_NODE_VALUE && json_node_get_value_type(node) == G_TYPE_STRING) { const gchar * name = json_node_get_string(node); server->parent.name = g_strdup(name); } } if (json_object_has_member(object, JSON_URI)) { JsonNode * node = json_object_get_member(object, JSON_URI); if (JSON_NODE_TYPE(node) == JSON_NODE_VALUE && json_node_get_value_type(node) == G_TYPE_STRING) { const gchar * uri = json_node_get_string(node); server->parent.uri = g_strdup(uri); } } if (json_object_has_member(object, JSON_USERNAME)) { JsonNode * node = json_object_get_member(object, JSON_USERNAME); if (JSON_NODE_TYPE(node) == JSON_NODE_VALUE && json_node_get_value_type(node) == G_TYPE_STRING) { const gchar * username = json_node_get_string(node); server->username = g_strdup(username); } } if (json_object_has_member(object, JSON_PASSWORD)) { JsonNode * node = json_object_get_member(object, JSON_PASSWORD); if (JSON_NODE_TYPE(node) == JSON_NODE_VALUE && json_node_get_value_type(node) == G_TYPE_STRING) { const gchar * password = json_node_get_string(node); server->password = g_strdup(password); mlock(server->password, strlen(server->password)); } } if (json_object_has_member(object, JSON_DOMAIN)) { JsonNode * node = json_object_get_member(object, JSON_DOMAIN); if (JSON_NODE_TYPE(node) == JSON_NODE_VALUE && json_node_get_value_type(node) == G_TYPE_STRING) { const gchar * domain = json_node_get_string(node); server->domain = g_strdup(domain); } } if (json_object_has_member(object, JSON_DOMAIN_REQ)) { JsonNode * node = json_object_get_member(object, JSON_DOMAIN_REQ); if (JSON_NODE_TYPE(node) == JSON_NODE_VALUE && json_node_get_value_type(node) == G_TYPE_BOOLEAN) { server->domain_required = json_node_get_boolean(node); } } return SERVER(server); }
void network_checking(void) { int fd; http_down("/files.json", "http://lab.rt-thread.org/realboard/lpc4088/files.json"); fd = open("/files.json", O_RDONLY, 0); if (fd >= 0) { int length; char *ptr; length = lseek(fd, 0, SEEK_END); if (length > 0) { lseek(fd, 0, SEEK_SET); ptr = (char*)rt_malloc(length); if (ptr != RT_NULL) { struct json_tree* tree; length = read(fd, ptr, length); tree = json_tree_parse(ptr, length); if (tree != RT_NULL) { int index = 0; struct json_node* node; while (1) { const char *url; const char *local_url; node = json_node_get_array(&(tree->root), index, RT_NULL); if (node == RT_NULL) break; index ++; url = json_node_get_string(node, "url", RT_NULL); local_url = json_node_get_string(node, "local_url", RT_NULL); rt_kprintf("%s=>%s\n", local_url, url); } json_tree_destroy(tree); } rt_free(ptr); } } close(fd); } }
/** * Utility function for turning a json node into a string. */ gchar *glib_jsonrpc_json_to_string(JsonNode *node) { // Simplify for string. Should probably be optional. if (json_node_get_string (node) != NULL) return g_strdup(json_node_get_string (node)); // Serialize response into content_string JsonGenerator *gen = json_generator_new (); gsize len; json_generator_set_root (gen, node); gchar *json_string = json_generator_to_data(gen, &len); g_object_unref (gen); return json_string; }
static gboolean clutter_alpha_parse_custom_node (ClutterScriptable *scriptable, ClutterScript *script, GValue *value, const gchar *name, JsonNode *node) { if (strncmp (name, "function", 8) == 0) { const gchar *func_name = json_node_get_string (node); g_value_init (value, G_TYPE_POINTER); g_value_set_pointer (value, resolve_alpha_func (func_name)); return TRUE; } /* we need to do this because we use gulong in place * of ClutterAnimationMode for ClutterAlpha:mode */ if (strncmp (name, "mode", 4) == 0) { gulong mode; mode = _clutter_script_resolve_animation_mode (node); g_value_init (value, G_TYPE_ULONG); g_value_set_ulong (value, mode); return TRUE; } return FALSE; }
static gboolean parse_emojione_category (JsonNode *node, EmojiData *data) { const gchar *category; GSList *duplicated; if (json_node_get_node_type (node) != JSON_NODE_VALUE) { g_warning ("'category' element is not string"); return FALSE; } category = json_node_get_string (node); if (category == NULL || *category == '\0') return TRUE; duplicated = g_slist_find_custom (data->annotations, category, (GCompareFunc) g_strcmp0); if (duplicated == NULL) { data->annotations = g_slist_prepend (data->annotations, g_strdup (category)); } return TRUE; }
/** * server_new_from_json: * @object: JSON object with server definition * * Looks at the type and then uses a subclassed function to build the * server. * * Return value: A new Server object or NULL if error */ Server * server_new_from_json (JsonObject * object) { g_return_val_if_fail(object != NULL, NULL); if (!json_object_has_member(object, "Protocol")) { return NULL; } JsonNode * proto_node = json_object_get_member(object, "Protocol"); if (JSON_NODE_TYPE(proto_node) != JSON_NODE_VALUE) { return NULL; } if (json_node_get_value_type(proto_node) != G_TYPE_STRING) { return NULL; } const gchar * proto = json_node_get_string(proto_node); Server * newserver = NULL; if (g_strcmp0(proto, "ICA") == 0 || g_strcmp0(proto, "ica") == 0) { newserver = citrix_server_new_from_json(object); } else if (g_strcmp0(proto, "freerdp") == 0 || g_strcmp0(proto, "rdp") == 0 || g_strcmp0(proto, "RDP") == 0 || g_strcmp0(proto, "FreeRDP") == 0) { newserver = rdp_server_new_from_json(object); } else if (g_strcmp0(proto, "x2go") == 0 || g_strcmp0(proto, "X2go") == 0 || g_strcmp0(proto, "X2Go") == 0 || g_strcmp0(proto, "X2GO") == 0 || g_strcmp0(proto, "x2GO") == 0 || g_strcmp0(proto, "x2gO") == 0) { newserver = x2go_server_new_from_json(object); } return newserver; }
static void add_alias_to_listing (GHashTable *listing, CockpitPackage *package, JsonNode *node) { const gchar *value; if (JSON_NODE_HOLDS_VALUE (node) && json_node_get_value_type (node) == G_TYPE_STRING) { value = json_node_get_string (node); if (validate_package (value)) { g_hash_table_replace (listing, (gchar *)value, cockpit_package_ref (package)); g_debug ("%s: package has alias: %s", package->name, value); } else { g_message ("invalid \"alias\" package name: \"%s\"", value); } } else { g_message ("invalid \"alias\" value type: \"%s\"", json_node_type_name (node)); } }
gboolean _rpmostree_jsonutil_object_get_optional_string_member (JsonObject *object, const char *member_name, const char **out_value, GError **error) { gboolean ret = FALSE; JsonNode *node = json_object_get_member (object, member_name); if (node != NULL) { *out_value = json_node_get_string (node); if (!*out_value) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Member '%s' is not a string", member_name); goto out; } } else *out_value = NULL; ret = TRUE; out: return ret; }
/** * json_reader_get_string_value: * @reader: a #JsonReader * * Retrieves the string value of the current position of @reader * * Return value: the string value * * Since: 0.12 */ const gchar * json_reader_get_string_value (JsonReader *reader) { JsonNode *node; g_return_val_if_fail (JSON_IS_READER (reader), NULL); json_reader_return_val_if_error_set (reader, NULL); if (reader->priv->current_node == NULL) { json_reader_set_error (reader, JSON_READER_ERROR_INVALID_NODE, _("No node available at the current position")); return NULL; } node = reader->priv->current_node; if (!JSON_NODE_HOLDS_VALUE (node)) { json_reader_set_error (reader, JSON_READER_ERROR_NO_VALUE, _("The current position holds a '%s' and not a value"), json_node_type_get_name (JSON_NODE_TYPE (node))); return NULL; } if (json_node_get_value_type (node) != G_TYPE_STRING) { json_reader_set_error (reader, JSON_READER_ERROR_INVALID_TYPE, _("The current position does not hold a string type")); return NULL; } return json_node_get_string (reader->priv->current_node); }
trg_response *dispatch_str(TrgClient * tc, gchar * req) { trg_response *response = g_new0(trg_response, 1); GError *decode_error = NULL; JsonNode *result; trg_http_perform(tc, req, response); g_free(req); if (response->status == CURLE_OK) response->obj = trg_deserialize(response, &decode_error); g_free(response->raw); response->raw = NULL; if (response->status != CURLE_OK) return response; if (decode_error) { g_error("JSON decoding error: %s", decode_error->message); g_error_free(decode_error); response->status = FAIL_JSON_DECODE; return response; } result = json_object_get_member(response->obj, FIELD_RESULT); if (!result || g_strcmp0(json_node_get_string(result), FIELD_SUCCESS)) response->status = FAIL_RESPONSE_UNSUCCESSFUL; return response; }
static void router_rule_compile (RouterRule *rule, JsonObject *object) { RouterMatch *match; GList *names, *l; JsonNode *node; gint i; g_assert (rule->matches == NULL); names = json_object_get_members (object); rule->matches = g_new0 (RouterMatch, g_list_length (names) + 1); for (l = names, i = 0; l != NULL; l = g_list_next (l), i++) { match = &rule->matches[i]; match->name = g_strdup (l->data); node = json_object_get_member (object, l->data); /* A glob style string pattern */ if (JSON_NODE_HOLDS_VALUE (node) && json_node_get_value_type (node) == G_TYPE_STRING) match->glob = g_pattern_spec_new (json_node_get_string (node)); /* A null matches anything */ if (!JSON_NODE_HOLDS_NULL (node)) match->node = json_node_copy (node); } /* The last match has a null name */ g_list_free (names); }
/** * json_node_dup_string: * @node: a #JsonNode of type %JSON_NODE_VALUE * * Gets a copy of the string value stored inside a #JsonNode * * Return value: (transfer full): a newly allocated string containing a copy * of the #JsonNode contents. Use g_free() to free the allocated resources */ gchar * json_node_dup_string (JsonNode *node) { g_return_val_if_fail (JSON_NODE_IS_VALID (node), NULL); return g_strdup (json_node_get_string (node)); }
/** * json_node_dup_string: * @node: a #JsonNode of type %JSON_NODE_VALUE * * Gets a copy of the string value stored inside a #JsonNode * * Return value: (transfer full): a newly allocated string containing a copy * of the #JsonNode contents. Use g_free() to free the allocated resources */ gchar * json_node_dup_string (JsonNode *node) { g_return_val_if_fail (node != NULL, NULL); return g_strdup (json_node_get_string (node)); }
gchar *trg_prefs_get_string(TrgPrefs * p, const gchar * key, int flags) { JsonNode *node = trg_prefs_get_value(p, key, JSON_NODE_VALUE, flags); if (node) return g_strdup(json_node_get_string(node)); else return NULL; }
void rm_json_cache_parse_entry(_U JsonArray *array, _U guint index, JsonNode *element_node, RmTrie *file_trie) { if(JSON_NODE_TYPE(element_node) != JSON_NODE_OBJECT) { return; } JsonObject *object = json_node_get_object(element_node); JsonNode *mtime_node = json_object_get_member(object, "mtime"); JsonNode *path_node = json_object_get_member(object, "path"); JsonNode *cksum_node = json_object_get_member(object, "checksum"); JsonNode *type_node = json_object_get_member(object, "type"); if(mtime_node && path_node && cksum_node && type_node) { RmStat stat_buf; const char *path = json_node_get_string(path_node); const char *cksum = json_node_get_string(cksum_node); const char *type = json_node_get_string(type_node); if(g_strcmp0(type, "duplicate_file") && g_strcmp0(type, "unfinished_cksum")) { /* some other file that has a checksum for weird reasons. * This is here to prevent errors like reporting files with * empty checksums as duplicates. * */ return; } if(rm_sys_stat(path, &stat_buf) == -1) { /* file does not appear to exist */ return; } if(json_node_get_int(mtime_node) < rm_sys_stat_mtime_seconds(&stat_buf)) { /* file is newer than stored checksum */ return; } char *cksum_copy = g_strdup(cksum); if(!rm_trie_set_value(file_trie, path, cksum_copy)) { g_free(cksum_copy); } rm_log_debug_line("* Adding cache entry %s (%s)", path, cksum); } }
gint json_node_get_parse_int_member(JsonNode *node, gboolean *success) { switch(json_node_get_value_type(node)) { case G_TYPE_INT64: if(success) *success = TRUE; return json_node_get_int(node); case G_TYPE_STRING: return flist_parse_int(json_node_get_string(node), success); } if(success) *success = FALSE; return 0; }
static gboolean parse_emojione_shortname (JsonNode *node, EmojiData *data) { #if 0 const gchar *shortname; gchar *head, *s; int length; GSList *duplicated; if (json_node_get_node_type (node) != JSON_NODE_VALUE) { g_warning ("'shortname' element is not string"); return FALSE; } /* The format is ':short_name:' */ shortname = json_node_get_string (node); if (shortname == 0 || *shortname == '\0') return TRUE; if (*shortname != ':') { g_warning ("'shortname' format is different: %s", shortname); return FALSE; } length = strlen (shortname); head = g_new0 (gchar, length); strcpy (head, shortname + 1); for (s = head; *s; s++) { if (*s == ':') { *s = '\0'; break; } else if (*s == '_') { *s = ' '; } } if (head == NULL || *head == '\0') { g_warning ("'shortname' format is different: %s", shortname); g_free (head); return FALSE; } duplicated = g_slist_find_custom (data->annotations, head, (GCompareFunc) g_strcmp0); if (duplicated == NULL) { data->annotations = g_slist_prepend (data->annotations, head); } else { g_free (head); } #endif return TRUE; }
void cockpit_package_dump (void) { GHashTable *listing; GHashTable *by_name; GHashTableIter iter; CockpitPackage *package; GList *names, *l; const gchar *prefix; JsonArray *array; guint i; listing = cockpit_package_listing (NULL); by_name = g_hash_table_new (g_str_hash, g_str_equal); g_hash_table_iter_init (&iter, listing); while (g_hash_table_iter_next (&iter, NULL, (gpointer *)&package)) g_hash_table_replace (by_name, package->name, package); names = g_hash_table_get_keys (by_name); names = g_list_sort (names, (GCompareFunc)strcmp); for (l = names; l != NULL; l = g_list_next (l)) { package = g_hash_table_lookup (by_name, l->data); g_print ("%s: %s\n", package->name, package->directory); if (package->checksum) g_print (" checksum: %s\n", package->checksum); if (package->alias) { prefix = " alias: "; if (JSON_NODE_HOLDS_ARRAY (package->alias)) { array = json_node_get_array (package->alias); for (i = 0; i < json_array_get_length (array); i++) { g_print ("%s%s\n", prefix, json_array_get_string_element (array, i)); prefix = " "; } } else { g_print ("%s%s\n", prefix, json_node_get_string (package->alias)); } } } g_list_free (names); g_hash_table_unref (by_name); g_hash_table_unref (listing); }
/** * json_reader_get_string_value: * @reader: a #JsonReader * * Retrieves the string value of the current position of @reader * * Return value: the string value * * Since: 0.12 */ G_CONST_RETURN gchar * json_reader_get_string_value (JsonReader *reader) { g_return_val_if_fail (JSON_IS_READER (reader), NULL); json_reader_return_val_if_error_set (reader, NULL); if (reader->priv->current_node == NULL) return NULL; if (!JSON_NODE_HOLDS_VALUE (reader->priv->current_node)) return NULL; return json_node_get_string (reader->priv->current_node); }
gui_element_p gui_element_create(gui_element_p parent, json_node_p config) { char *name = json_node_get_string(config, ".name"); char *type = json_node_get_string(config, ".type"); if (0 == name || 0 == type) { return 0; } gui_element_p element = (gui_element_p)malloc(sizeof(gui_element_t)); element->name = name; if (strcmp("frame", type) == 0) { element = (gui_element_p)malloc(sizeof(gui_element_t)); gui_element_set_frame(element, config); } else if (strcmp("button", type) == 0) { element = (gui_element_p)malloc(sizeof(gui_element_t)); gui_element_set_frame(element, config); } else { LOGF("Invalid gui element type %s", type); return 0; } }
gboolean fb_process_friend_lists(FacebookAccount *fba, JsonObject *buddy_list) { JsonObject *fl_obj; GList *friend_list_ids, *cur; purple_debug_info("facebook", "processing friend list data\n"); if (!json_object_has_member(buddy_list, "flData")) { purple_debug_info("facebook", "no friend list data\n"); return FALSE; } fl_obj = json_node_get_object(json_object_get_member( buddy_list, "flData")); friend_list_ids = json_object_get_members(fl_obj); for (cur = friend_list_ids; cur != NULL; cur = cur->next) { gchar *id; const gchar *name; JsonObject *data; id = (gchar *) cur->data; data = json_node_get_object(json_object_get_member( fl_obj, id)); name = json_node_get_string(json_object_get_member( data, "n")); if (name) { // Either -1 isnt a valid JSON string or JSON-glib does // this wrong. I'm too tired to tell the difference. if (g_str_equal(id, "_1")) { id = "-1"; } purple_debug_info("facebook", "got friend list %s with id %s\n", name, id); g_hash_table_insert(fba->friend_lists, g_strdup(id), g_strdup(name)); g_hash_table_insert(fba->friend_lists_reverse, g_utf8_strdown(name, -1), g_strdup(id)); } } g_list_free(friend_list_ids); return TRUE; }
/** * json_object_get_string_member: * @object: a #JsonObject * @member_name: the name of the member * * Convenience function that retrieves the string value * stored in @member_name of @object * * See also: json_object_get_member() * * Return value: the string value of the object's member * * Since: 0.8 */ G_CONST_RETURN gchar * json_object_get_string_member (JsonObject *object, const gchar *member_name) { JsonNode *node; g_return_val_if_fail (object != NULL, NULL); g_return_val_if_fail (member_name != NULL, NULL); node = object_get_member_internal (object, member_name); g_return_val_if_fail (node != NULL, NULL); g_return_val_if_fail (JSON_NODE_TYPE (node) == JSON_NODE_VALUE, NULL); return json_node_get_string (node); }
const gchar * json_get_string (JsonNode *node, const gchar *keyName) { JsonObject *obj; JsonNode *key; obj = json_node_get_object (node); if (!obj) return NULL; key = json_object_get_member (obj, keyName); if (!key) return NULL; return json_node_get_string (key); }
static void object_to_headers (JsonObject *object, const gchar *header, JsonNode *node, gpointer user_data) { GHashTable *headers = user_data; const gchar *value = json_node_get_string (node); g_return_if_fail (value != NULL); if (g_ascii_strcasecmp (header, "Content-Length") == 0 || g_ascii_strcasecmp (header, "Connection") == 0) return; g_hash_table_insert (headers, g_strdup (header), g_strdup (value)); }
/** * json_array_get_string_element: * @array: a #JsonArray * @index_: the index of the element to retrieve * * Conveniently retrieves the string value of the element at @index_ * inside @array * * See also: json_array_get_element(), json_node_get_string() * * Return value: the string value; the returned string is owned by * the #JsonArray and should not be modified or freed * * Since: 0.8 */ G_CONST_RETURN gchar * json_array_get_string_element (JsonArray *array, guint index_) { JsonNode *node; g_return_val_if_fail (array != NULL, NULL); g_return_val_if_fail (index_ < array->elements->len, NULL); node = g_ptr_array_index (array->elements, index_); g_return_val_if_fail (node != NULL, NULL); g_return_val_if_fail (JSON_NODE_HOLDS_VALUE (node) || JSON_NODE_HOLDS_NULL (node), NULL); if (JSON_NODE_HOLDS_NULL (node)) return NULL; return json_node_get_string (node); }
static void _iterate_json_object(JsonObject *object, const gchar *member_name, JsonNode *member_node, gpointer user_data) { GHashTable* params = user_data; if (json_node_get_node_type(member_node) != JSON_NODE_VALUE) return; if (json_node_get_value_type(member_node) == G_TYPE_STRING) g_hash_table_insert(params, g_strdup(member_name), g_strdup(json_node_get_string(member_node))); else if (json_node_get_value_type(member_node) == G_TYPE_INT64) g_hash_table_insert(params, g_strdup(member_name), g_strdup_printf("%"G_GINT64_FORMAT, json_node_get_int(member_node))); }
/** * json_object_get_string_member: * @object: a #JsonObject * @member_name: the name of the member * * Convenience function that retrieves the string value * stored in @member_name of @object * * See also: json_object_get_member() * * Return value: the string value of the object's member * * Since: 0.8 */ const gchar * json_object_get_string_member (JsonObject *object, const gchar *member_name) { JsonNode *node; g_return_val_if_fail (object != NULL, NULL); g_return_val_if_fail (member_name != NULL, NULL); node = object_get_member_internal (object, member_name); g_return_val_if_fail (node != NULL, NULL); g_return_val_if_fail (JSON_NODE_HOLDS_VALUE (node) || JSON_NODE_HOLDS_NULL (node), NULL); if (JSON_NODE_HOLDS_NULL (node)) return NULL; return json_node_get_string (node); }
void trg_tree_view_setup_columns(TrgTreeView * tv) { TrgTreeViewPrivate *priv = TRG_TREE_VIEW_GET_PRIVATE(tv); JsonObject *props = trg_prefs_get_tree_view_props(tv); GList *columns, *widths, *cli, *wli; if (!json_object_has_member(props, TRG_PREFS_KEY_TV_COLUMNS) || !json_object_has_member(props, TRG_PREFS_KEY_TV_WIDTHS)) { GList *li; for (li = priv->columns; li; li = g_list_next(li)) { trg_column_description *desc = (trg_column_description *) li->data; if (desc && !(desc->flags & TRG_COLUMN_EXTRA)) trg_tree_view_add_column(tv, desc, -1); } return; } columns = json_array_get_elements(json_object_get_array_member (props, TRG_PREFS_KEY_TV_COLUMNS)); widths = json_array_get_elements(json_object_get_array_member (props, TRG_PREFS_KEY_TV_WIDTHS)); for (cli = columns, wli = widths; cli && wli; cli = g_list_next(cli), wli = g_list_next(wli)) { trg_column_description *desc = trg_tree_view_find_column(tv, json_node_get_string ((JsonNode *) cli-> data)); if (desc) { gint64 width = json_node_get_int((JsonNode *) wli->data); trg_tree_view_add_column(tv, desc, width); } } g_list_free(columns); g_list_free(widths); }
static int output_json_node_value (JsonNode *node, PRN *prn) { GType type = 0; int err = 0; if (null_node(node)) { gretl_errmsg_set("jsonget: got a null node"); return E_DATA; } type = json_node_get_value_type(node); #if 0 fprintf(stderr, "jsonget: node type %s\n", g_type_name(type)); #endif if (!handled_type(type)) { gretl_errmsg_sprintf("jsonget: unhandled object type '%s'", g_type_name(type)); err = E_DATA; } else if (type == G_TYPE_STRING) { const gchar *s = json_node_get_string(node); if (s != NULL) { pputs(prn, s); } else { err = E_DATA; } } else if (type == G_TYPE_DOUBLE) { double x = json_node_get_double(node); pprintf(prn, "%.15g", x); } else { gint64 k = json_node_get_int(node); double x = (double) k; pprintf(prn, "%.15g", x); } return err; }
static void debug_print_json_node (char * msg, JsonNode * node) { g_assert (node != NULL); gchar * buffer; if (json_node_get_node_type (node) == JSON_NODE_VALUE) { buffer = g_strdup ( json_node_get_string (node) ); /* we should check number, boolean too */ } else { JsonGenerator *gen = json_generator_new(); json_generator_set_root (gen, node); buffer = json_generator_to_data (gen,NULL); g_object_unref (gen); } g_message("%s - Json Node of type %d: %s\n",msg, (gint)json_node_get_node_type (node), buffer); g_free (buffer); }