// Parse a json object, a json object stripped of {} or an json array // stripped of [] into a JsonNode. JsonNode *glib_jsonrpc_json_string_to_json_node(const gchar *str) { JsonParser *parser = json_parser_new(); GError *error; // First try to parse the string if (!json_parser_load_from_data(parser, str, -1, &error)) { // Wrap it in a { } pair and try again. g_error_free(error); error = NULL; GString *j_str = g_string_new(""); g_string_append_printf(j_str, "{%s}", str); // Try parsing it as an object if (!json_parser_load_from_data(parser, j_str->str, -1, &error)) { // Still fail, try to parse it as an array g_string_free(j_str, TRUE); g_string_append_printf(j_str, "[%s]", str); if (!json_parser_load_from_data(parser, j_str->str, -1, &error)) { // That's it, we give up. g_object_unref(parser); return NULL; } } } JsonNode *node = json_node_copy(json_parser_get_root(parser)); g_object_unref(parser); return node; }
static gboolean parse_reviews (GsPlugin *plugin, JsonParser *parser, GsApp *app, GCancellable *cancellable, GError **error) { GsAuth *auth; JsonArray *array; const gchar *consumer_key = NULL; guint i; auth = gs_plugin_get_auth_by_id (plugin, "ubuntuone"); if (auth != NULL) consumer_key = gs_auth_get_metadata_item (auth, "consumer-key"); if (!JSON_NODE_HOLDS_ARRAY (json_parser_get_root (parser))) return FALSE; array = json_node_get_array (json_parser_get_root (parser)); for (i = 0; i < json_array_get_length (array); i++) { g_autoptr(AsReview) review = NULL; /* Read in from JSON... (skip bad entries) */ review = as_review_new (); if (parse_review (review, consumer_key, json_array_get_element (array, i))) gs_app_add_review (app, review); } return TRUE; }
static GHashTable* toHashTable(std::string msg) { g_print("toHashTable\n"); JsonParser *parser; GError *error = NULL; parser = json_parser_new (); GHashTable *map = g_hash_table_new(g_str_hash, g_str_equal); if (json_parser_load_from_data (parser, msg.c_str(), -1, &error)) { JsonNode *root; JsonObject *object; g_assert (NULL != json_parser_get_root (parser)); root = json_parser_get_root (parser); if (JSON_NODE_TYPE (root) == JSON_NODE_OBJECT) { object = json_node_get_object (root); g_assert (object != NULL); json_object_foreach_member(object, parseMembers, map); } } else { g_error_free (error); } g_object_unref (parser); return map; }
static void on_message (FridaScript * script, const gchar * message, GBytes * data, gpointer user_data) { JsonParser * parser; JsonObject * root; const gchar * type; parser = json_parser_new (); json_parser_load_from_data (parser, message, -1, NULL); root = json_node_get_object (json_parser_get_root (parser)); type = json_object_get_string_member (root, "type"); if (strcmp (type, "log") == 0) { const gchar * log_message; log_message = json_object_get_string_member (root, "payload"); g_print ("%s\n", log_message); } else { g_print ("on_message: %s\n", message); } g_object_unref (parser); }
static GType json_op_register_type_for_file (GTypeModule *type_module, const gchar *filepath) { GType ret = 0; GError *error = NULL; JsonParser *parser = json_parser_new(); const gboolean success = json_parser_load_from_file(parser, filepath, &error); if (success) { JsonNode *root_node = json_node_copy (json_parser_get_root (parser)); JsonObject *root = json_node_get_object (root_node); const gchar *name; gchar *type_name; g_assert(root_node); name = metadata_get_property(root, "name"); type_name = (name) ? component2gtypename(name) : component2gtypename(filepath); ret = json_op_register_type(type_module, type_name, root); g_free(type_name); } // g_object_unref(parser); return ret; }
static void pb_process_frame(PushBulletAccount *pba, const gchar *frame) { JsonParser *parser = json_parser_new(); JsonNode *root; purple_debug_info("pushbullet", "got frame data: %s\n", frame); if (!json_parser_load_from_data(parser, frame, -1, NULL)) { purple_debug_error("pushbullet", "Error parsing response: %s\n", frame); return; } root = json_parser_get_root(parser); if (root != NULL) { JsonObject *message = json_node_get_object(root); const gchar *type = json_object_get_string_member(message, "type"); if (purple_strequal(type, "tickle")) { pb_get_everything_since(pba, purple_account_get_int(pba->account, "last_message_timestamp", 0)); } else if (purple_strequal(type, "push")) { JsonObject *push = json_object_get_object_member(message, "push"); //{"type":"push","targets":["stream","android","ios"],"push":{"guid":"purple6e94d282","type":"messaging_extension_reply","package_name":"com.pushbullet.android","target_device_iden":"uffvytgsjAoIRwhIL6","conversation_iden":"+6421478252","message":"test2"}} //{"type":"push","targets":["stream"],"push":{"type":"sms_changed"}} type = json_object_get_string_member(push, "type"); if (purple_strequal(type, "sms_changed")) { pb_get_phone_threads(pba, NULL); } } } g_object_unref(parser); }
gboolean twitter_user_list_load_from_data (TwitterUserList *user_list, const gchar *buffer, GError **error) { JsonParser *parser; GError *parse_error; gboolean retval = TRUE; g_return_val_if_fail (TWITTER_IS_USER_LIST (user_list), FALSE); g_return_val_if_fail (buffer != NULL, FALSE); twitter_user_list_clean (user_list); parser = json_parser_new (); parse_error = NULL; json_parser_load_from_data (parser, buffer, -1, &parse_error); if (parse_error) { g_set_error (error, TWITTER_ERROR, TWITTER_ERROR_PARSE_ERROR, "Parse error (%s)", parse_error->message); g_error_free (parse_error); retval = FALSE; } else twitter_user_list_build (user_list, json_parser_get_root (parser)); g_object_unref (parser); return retval; }
static JsonNode * postal_http_parse_body (SoupMessage *message, GError **error) { JsonParser *p; JsonNode *ret; g_assert(SOUP_IS_MESSAGE(message)); p = json_parser_new(); if (!json_parser_load_from_data(p, message->request_body->data, message->request_body->length, error)) { g_object_unref(p); return NULL; } if ((ret = json_parser_get_root(p))) { ret = json_node_copy(ret); } g_object_unref(p); if (!ret) { g_set_error(error, postal_json_error_quark(), 0, "Missing JSON payload."); } return ret; }
static void on_web_socket_message(SoupWebsocketConnection *ws, SoupWebsocketDataType type, GBytes *message, void *user_data) { const gchar *data; gsize len; data = g_bytes_get_data (message, &len); imgflo_debug("RECV: %.*s\n", (int)len, data); JsonParser *parser = json_parser_new(); gboolean success = json_parser_load_from_data(parser, data, len, NULL); if (success) { JsonNode *r = json_parser_get_root(parser); g_assert(JSON_NODE_HOLDS_OBJECT(r)); JsonObject *root = json_node_get_object(r); const gchar *protocol = json_object_get_string_member(root, "protocol"); const gchar *command = json_object_get_string_member(root, "command"); JsonNode *pnode = json_object_get_member(root, "payload"); JsonObject *payload = JSON_NODE_HOLDS_OBJECT(pnode) ? json_object_get_object_member(root, "payload") : NULL; UiConnection *ui = (UiConnection *)user_data; ui_connection_handle_message(ui, protocol, command, payload, ws); } else { imgflo_warning("Unable to parse WebSocket message as JSON"); } g_object_unref(parser); }
static JsonNode * node_from_call (RestProxyCall *call, JsonParser *parser) { JsonNode *root; GError *error; gboolean ret = FALSE; if (call == NULL) return NULL; if (!SOUP_STATUS_IS_SUCCESSFUL (rest_proxy_call_get_status_code (call))) { g_message ("Error from MySpace: %s (%d)", rest_proxy_call_get_status_message (call), rest_proxy_call_get_status_code (call)); return NULL; } ret = json_parser_load_from_data (parser, rest_proxy_call_get_payload (call), rest_proxy_call_get_payload_length (call), &error); root = json_parser_get_root (parser); if (root == NULL) { g_message ("Error from MySpace: %s", rest_proxy_call_get_payload (call)); return NULL; } return root; }
/* grl.lua.json.string_to_table * * @json_str: (string) A Json object as a string. * * @return: All json content as a table. */ static gint grl_json_parse_string (lua_State *L) { JsonParser *parser = NULL; JsonReader *reader = NULL; const gchar *json_str = NULL; GError *err = NULL; luaL_argcheck (L, lua_isstring (L, 1), 1, "json string expected"); json_str = lua_tostring (L, 1); parser = json_parser_new (); if (!json_parser_load_from_data (parser, json_str, -1, &err)) { GRL_DEBUG ("Can't parse json string: '%s'", err->message); g_error_free (err); g_object_unref (parser); return 0; } reader = json_reader_new (json_parser_get_root (parser)); /* The return of recursive function will be a table with all * json content in it */ lua_pushnil (L); build_table_from_json_reader (L, reader); g_object_unref (reader); g_object_unref (parser); return 1; }
gchar * get_value (gchar *data, gchar *key) { JsonParser *parser = json_parser_new (); JsonReader *reader = json_reader_new (NULL); GError *error = NULL; gchar *val = NULL; json_parser_load_from_data (parser, data, -1, &error); if (error) { g_error_free (error); goto out; } json_reader_set_root (reader, json_parser_get_root (parser)); if (!json_reader_is_object (reader)) { goto out; } json_reader_read_member (reader, key); val = g_strdup (json_reader_get_string_value (reader)); json_reader_end_member (reader); out: g_object_unref (parser); g_object_unref (reader); return val; }
static void process_results (RBPodcastSearchITunes *search, JsonParser *parser) { JsonObject *container; JsonArray *results; guint i; container = json_node_get_object (json_parser_get_root (parser)); results = json_node_get_array (json_object_get_member (container, "results")); for (i = 0; i < json_array_get_length (results); i++) { JsonObject *feed; RBPodcastChannel *channel; feed = json_array_get_object_element (results, i); /* check wrapperType==track, kind==podcast ? */ channel = g_new0 (RBPodcastChannel, 1); channel->url = g_strdup (json_object_get_string_member (feed, "collectionViewUrl")); channel->title = g_strdup (json_object_get_string_member (feed, "collectionName")); channel->author = g_strdup (json_object_get_string_member (feed, "artistName")); channel->img = g_strdup (json_object_get_string_member (feed, "artworkUrl100")); /* 100? */ channel->is_opml = FALSE; channel->num_posts = json_object_get_int_member (feed, "trackCount"); rb_debug ("got result %s (%s)", channel->title, channel->url); rb_podcast_search_result (RB_PODCAST_SEARCH (search), channel); rb_podcast_parse_channel_free (channel); } }
static JsonObject *gphoto_parse_response(dt_gphoto_context_t *ctx, GString *response) { GError *error = NULL; gboolean ret = json_parser_load_from_data(ctx->json_parser, response->str, response->len, &error); if(ret) { JsonNode *root = json_parser_get_root(ctx->json_parser); // we should always have a dict g_return_val_if_fail((json_node_get_node_type(root) == JSON_NODE_OBJECT), NULL); JsonObject *rootdict = json_node_get_object(root); if(json_object_has_member(rootdict, "error")) { JsonObject *errorstruct = json_object_get_object_member(rootdict, "error"); g_return_val_if_fail((errorstruct != NULL), NULL); const gchar *errormessage = json_object_get_string_member(errorstruct, "message"); g_return_val_if_fail((errormessage != NULL), NULL); g_string_assign(ctx->errmsg, errormessage); return NULL; } return rootdict; } else // not a json response, can be the upload-token { ctx->response = g_string_new(response->str); return NULL; } }
/** * gfbgraph_connectable_default_parse_connected_data: * @self: a #GFBGraphConnectable. * @payload: a const #gchar with the response string from the Facebook Graph API. * @error: (allow-none): a #GError or %NULL. * * In most cases, #GFBGraphConnectable implementers can use this function in order to parse * the response when a gfbgraph_node_get_connection_nodes() is executed and the * gfbgraph_connectable_parse_connected_data() was called. * * Normally, Facebook Graph API returns the connections in the same way, using JSON objects, * with a root object called "data". * * Returns: (element-type GFBGraphNode) (transfer full): a newly-allocated #GList of #GFBGraphNode with the same #GType as @self. **/ GList* gfbgraph_connectable_default_parse_connected_data (GFBGraphConnectable *self, const gchar *payload, GError **error) { GList *nodes_list = NULL; JsonParser *jparser; GType node_type; node_type = G_OBJECT_TYPE (self); jparser = json_parser_new (); if (json_parser_load_from_data (jparser, payload, -1, error)) { JsonNode *root_jnode; JsonObject *main_jobject; JsonArray *nodes_jarray; int i = 0; root_jnode = json_parser_get_root (jparser); main_jobject = json_node_get_object (root_jnode); nodes_jarray = json_object_get_array_member (main_jobject, "data"); for (i = 0; i < json_array_get_length (nodes_jarray); i++) { JsonNode *jnode; GFBGraphNode *node; jnode = json_array_get_element (nodes_jarray, i); node = GFBGRAPH_NODE (json_gobject_deserialize (node_type, jnode)); nodes_list = g_list_append (nodes_list, node); } } g_clear_object (&jparser); return nodes_list; }
/*! * Convert a JSON file into a tree of nodes. * * \param[out] node Tree representation of \p filename. * \param filename Absolute path to JSON file to parse. * * \return \c true on success, else \c false. */ bool clr_oci_json_parse (GNode** node, const gchar* filename) { bool result = false; GError* error = NULL; JsonParser* parser = NULL; JsonNode *root = NULL; if ((!node) || (!filename) || (!(*filename))) { return false; } parser = json_parser_new(); if (! json_parser_load_from_file(parser, filename, &error)) { g_debug("unable to parse '%s'", filename); if (error) { g_debug("Error parsing '%s': %s", filename, error->message); g_error_free(error); } goto exit; } root = json_parser_get_root (parser); if (! root) { goto exit; } *node = g_node_new(g_strdup(filename)); clr_oci_json_parse_aux(root, *node, false); result = true; exit: g_object_unref(parser); return result; }
TwitterUserList * twitter_user_list_new_from_data (const gchar *buffer) { TwitterUserList *retval; JsonParser *parser; GError *parse_error; g_return_val_if_fail (buffer != NULL, NULL); retval = twitter_user_list_new (); parser = json_parser_new (); parse_error = NULL; json_parser_load_from_data (parser, buffer, -1, &parse_error); if (parse_error) { g_warning ("Unable to parse data into a user list: %s", parse_error->message); g_error_free (parse_error); } else twitter_user_list_build (retval, json_parser_get_root (parser)); g_object_unref (parser); return retval; }
void twitter_status_load_from_data (TwitterStatus *status, const gchar *buffer) { JsonParser *parser; GError *parse_error; g_return_if_fail (TWITTER_IS_STATUS (status)); g_return_if_fail (buffer != NULL); twitter_status_clean (status); parser = json_parser_new (); parse_error = NULL; json_parser_load_from_data (parser, buffer, -1, &parse_error); if (parse_error) { g_warning ("Unable to parse data into a status: %s", parse_error->message); g_error_free (parse_error); } else twitter_status_build (status, json_parser_get_root (parser)); g_object_unref (parser); }
int inputTransform(JsonParser *parser, Graph *graph) { JsonNode *root; JsonReader *reader; int num_nodes, num_edges; int i; root = json_parser_get_root(parser); reader = json_reader_new(root); // Is the graph directed ? json_reader_read_member(reader, "oriented") if(json_reader_get_boolean_value(reader)) { graph->directed = DIRECTED; } else { graph->directed = NOT_DIRECTED; } json_reader_end_member(reader); // Get the nodes json_reader_read_member(reader, "nodes"); if(json_reader_is_array(reader)) { // Allocate the memory for the nodes, and for the edges num_nodes = json_reader_count_elements(reader); graph->nodes = malloc(num_nodes * sizeof(Node)); graph->edges = malloc(num_nodes * sizeof(Edge *)); for(i=0; i < num_nodes; i++) { graph->edges[i] = malloc(num_nodes * sizeof(Edge)); } for(i=0; i < num_nodes; i++) { json_reader_read_element(reader, i); readNode(json_reader_get_value(reader), graph); json_reader_end_element(reader); } } json_reader_end_member(reader); // Get the edges json_reader_read_member(reader, "edges"); if(json_reader_is_array(reader)) { for(i=0; i < num_edges; i++) { json_reader_read_element(reader, i); reader(json_reader_get_value(reader), graph); json_reader_end_element(reader); } } json_reader_end_member(reader); return EXIT_SUCCESS; }
//Constructor. GobjectImplStringTopNode::GobjectImplStringTopNode(std::string const & jsonstring):mParser(),mRoot(0) { GobjectImplError lerror; //Resource managed place for storing our error state. json_parser_load_from_data (mParser,jsonstring.c_str(),jsonstring.size(),lerror.errorp()); if (lerror.error()) { throw jsonme::ParseError(lerror.error()->message); } mRoot=new GobjectImplNode(json_parser_get_root(mParser)); //Wrap the root node. }
/*! * Read the expected QMP welcome message. * * \param socket \c GSocket to use. * * \return \c true on success, else \c false. */ static gboolean clr_oci_qmp_check_welcome (GSocket *socket) { GError *error = NULL; JsonParser *parser = NULL; JsonReader *reader = NULL; GSList *msgs = NULL; gsize msg_count = 0; gboolean ret; GString *msg = NULL; g_assert (socket); ret = clr_oci_qmp_msg_recv (socket, 1, &msgs, &msg_count); if (! ret) { goto out; } msg = g_slist_nth_data (msgs, 0); g_assert (msg); parser = json_parser_new (); reader = json_reader_new (NULL); ret = json_parser_load_from_data (parser, msg->str, (gssize)msg->len, &error); if (! ret) { g_critical ("failed to parse json: %s", error->message); g_error_free (error); goto out; } json_reader_set_root (reader, json_parser_get_root (parser)); /* FIXME: perform more checks on the data received */ ret = json_reader_read_member (reader, "QMP"); if (! ret) { g_critical ("unexpected json data"); json_reader_end_member (reader); goto out; } json_reader_end_member (reader); out: if (reader) { g_object_unref (reader); } if (parser) { g_object_unref (parser); } if (msgs) { clr_oci_net_msgs_free_all (msgs); } g_debug ("handled qmp welcome"); return true; }
/*! * Check a QMP "execute" response message. * * \param result Response from server. * \param bytes Size of \p result. * \param expect_empty \c true if the result is expected to be an * empty json message, else \c false. * * \warning FIXME: no validation performed on non-empty QMP messages yet. * * \return \c true on success, else \c false. */ static gboolean clr_oci_qmp_check_result (const char *result, gsize bytes, gboolean expect_empty) { gboolean ret; JsonParser *parser = NULL; JsonReader *reader = NULL; GError *error = NULL; gint count = 0; g_assert (result); parser = json_parser_new (); reader = json_reader_new (NULL); ret = json_parser_load_from_data (parser, result, (gssize)bytes, &error); if (! ret) { g_critical ("failed to check qmp response: %s", error->message); g_error_free (error); goto out; } json_reader_set_root (reader, json_parser_get_root (parser)); ret = json_reader_read_member (reader, "return"); if (! ret) { goto out; } ret = json_reader_is_object (reader); if (! ret) { goto out; } count = json_reader_count_members (reader); if (count && expect_empty) { g_critical ("expected empty object denoting success, " "but found %d members", count); goto out; } ret = true; out: if (reader) { json_reader_end_member (reader); g_object_unref (reader); } if (parser) { g_object_unref (parser); } return ret; }
static void got_token_cb (SoupSession *session, SoupMessage *msg, gpointer user_data) { /* parses the authentication token from the response */ RBAudioscrobblerAccount *account; JsonParser *parser; account = RB_AUDIOSCROBBLER_ACCOUNT (user_data); parser = json_parser_new (); if (msg->response_body->data != NULL && json_parser_load_from_data (parser, msg->response_body->data, msg->response_body->length, NULL)) { JsonObject *root_object; root_object = json_node_get_object (json_parser_get_root (parser)); if (json_object_has_member (root_object, "token")) { char *url; account->priv->auth_token = g_strdup (json_object_get_string_member (root_object, "token")); rb_debug ("granted auth token \"%s\"", account->priv->auth_token); /* send the user to the web page using the token */ url = g_strdup_printf ("%s?api_key=%s&token=%s", rb_audioscrobbler_service_get_auth_url (account->priv->service), rb_audioscrobbler_service_get_api_key (account->priv->service), account->priv->auth_token); rb_debug ("sending user to %s", url); gtk_show_uri (NULL, url, GDK_CURRENT_TIME, NULL); /* add timeout which will ask for session key */ account->priv->session_key_timeout_id = g_timeout_add_seconds (SESSION_KEY_REQUEST_TIMEOUT, request_session_key_timeout_cb, account); g_free (url); } else { rb_debug ("error retrieving auth token: %s", json_object_get_string_member (root_object, "message")); /* go back to being logged out */ rb_audioscrobbler_account_logout (account); } } else { /* treat as connection error */ rb_debug ("empty or invalid response retrieving auth token. treating as connection error"); cancel_session (account); account->priv->login_status = RB_AUDIOSCROBBLER_ACCOUNT_LOGIN_STATUS_CONNECTION_ERROR; g_signal_emit (account, rb_audioscrobbler_account_signals[LOGIN_STATUS_CHANGED], 0, account->priv->login_status); } g_object_unref (parser); }
gsweb_t json_parse_gsweb() { JsonParser *parser; JsonNode *root; JsonReader *reader; GError *error; int array_size = 0; const char * tmp; gsweb_t ret; memset(&ret, 0, sizeof(ret)); g_type_init(); parser = json_parser_new(); error = NULL; json_parser_load_from_file(parser, GTMPFILE, &error); if (error) { g_error_free(error); g_object_unref(parser); ret.success = 2; return ret; } root = json_parser_get_root(parser); reader = json_reader_new(root); json_reader_read_member (reader, "responseData"); json_reader_read_member (reader, "results"); array_size = json_reader_count_elements(reader); if (array_size > 0) { json_reader_read_element (reader, 0); json_reader_read_member (reader, "unescapedUrl"); tmp = json_reader_get_string_value (reader); strncpy(ret.url, tmp, (strlen(tmp) < BUFF_SIZE)?strlen(tmp):BUFF_SIZE); json_reader_end_member (reader); json_reader_read_member (reader, "titleNoFormatting"); tmp = json_reader_get_string_value (reader); strncpy(ret.title, tmp, (strlen(tmp) < BUFF_SIZE)?strlen(tmp):BUFF_SIZE); json_reader_end_member (reader); json_reader_read_member (reader, "content"); tmp = json_reader_get_string_value (reader); strncpy(ret.content, tmp, (strlen(tmp) < BUFF_SIZE)?strlen(tmp):BUFF_SIZE); json_reader_end_member (reader); json_reader_end_element (reader); ret.success = 0; } else ret.success = 1; json_reader_end_member (reader); json_reader_end_member (reader); g_object_unref(parser); g_object_unref(reader); return ret; }
/* Called by RPC transport. */ gchar* searpc_server_call_function (const char *svc_name, gchar *func, gsize len, gsize *ret_len) { SearpcService *service; JsonParser *parser; JsonNode *root; JsonArray *array; gchar* ret; GError *error = NULL; #ifdef PROFILE struct timeval start, end, intv; gettimeofday(&start, NULL); #endif service = g_hash_table_lookup (service_table, svc_name); if (!service) { char buf[256]; snprintf (buf, 255, "cannot find service %s.", svc_name); return error_to_json (501, buf, ret_len); } parser = json_parser_new (); if (!json_parser_load_from_data (parser, func, len, &error)) { char buf[512]; snprintf (buf, 511, "failed to parse RPC call: %s\n", error->message); g_object_unref (parser); return error_to_json (511, buf, ret_len); } root = json_parser_get_root (parser); array = json_node_get_array (root); const char *fname = json_array_get_string_element(array, 0); FuncItem *fitem = g_hash_table_lookup(service->func_table, fname); if (!fitem) { char buf[256]; snprintf (buf, 255, "cannot find function %s.", fname); g_object_unref (parser); return error_to_json (500, buf, ret_len); } ret = fitem->marshal->mfunc (fitem->func, array, ret_len); #ifdef PROFILE gettimeofday(&end, NULL); timersub(&end, &start, &intv); g_debug ("[searpc] Time spend in call %s: %ds %dus\n", fname, intv.tv_sec, intv.tv_usec); #endif g_object_unref (parser); return ret; }
void ggp_edisc_xfer_ticket_changed(PurpleConnection *gc, const char *data) { ggp_edisc_session_data *sdata = ggp_edisc_get_sdata(gc); PurpleXfer *xfer; JsonParser *parser; JsonObject *ticket; const gchar *ticket_id, *send_status; ggp_edisc_xfer_ack_status ack_status; gboolean is_completed; g_return_if_fail(sdata != NULL); parser = ggp_json_parse(data); ticket = json_node_get_object(json_parser_get_root(parser)); ticket_id = json_object_get_string_member(ticket, "id"); ack_status = ggp_edisc_xfer_parse_ack_status( json_object_get_string_member(ticket, "ack_status")); send_status = json_object_get_string_member(ticket, "send_status"); if (ticket_id == NULL) ticket_id = ""; xfer = g_hash_table_lookup(sdata->xfers_initialized, ticket_id); if (xfer == NULL) { purple_debug_misc("gg", "ggp_edisc_event_ticket_changed: " "ticket %s not found, updating it...\n", purple_debug_is_unsafe() ? ticket_id : ""); ggp_edisc_xfer_recv_ticket_got(gc, ticket_id); g_object_unref(parser); return; } is_completed = FALSE; if (g_strcmp0("in_progress", send_status) == 0) { /* do nothing */ } else if (g_strcmp0("completed", send_status) == 0) { is_completed = TRUE; } else if (g_strcmp0("expired", send_status) == 0) ggp_edisc_xfer_error(xfer, _("File transfer expired.")); else { purple_debug_warning("gg", "ggp_edisc_event_ticket_changed: " "unknown send_status=%s\n", send_status); g_object_unref(parser); return; } g_object_unref(parser); if (purple_xfer_get_xfer_type(xfer) == PURPLE_XFER_TYPE_RECEIVE) { if (is_completed) ggp_edisc_xfer_recv_ticket_completed(xfer); } else { if (ack_status != GGP_EDISC_XFER_ACK_STATUS_UNKNOWN) ggp_edisc_xfer_send_ticket_changed(gc, xfer, ack_status == GGP_EDISC_XFER_ACK_STATUS_ALLOWED); } }
static void list_command_completed (gpointer data) { FrCommandUnarchiver *unar_comm = FR_COMMAND_UNARCHIVER (data); JsonParser *parser; GError *error = NULL; parser = json_parser_new (); if (json_parser_load_from_stream (parser, unar_comm->stream, NULL, &error)) { JsonObject *root; root = json_node_get_object (json_parser_get_root (parser)); if (json_object_get_int_member (root, "lsarFormatVersion") == LSAR_SUPPORTED_FORMAT) { JsonArray *content; int i; content = json_object_get_array_member (root, "lsarContents"); for (i = 0; i < json_array_get_length (content); i++) { JsonObject *entry; FileData *fdata; const char *filename; entry = json_array_get_object_element (content, i); fdata = file_data_new (); fdata->size = json_object_get_int_member (entry, "XADFileSize"); fdata->modified = mktime_from_string (json_object_get_string_member (entry, "XADLastModificationDate")); if (json_object_has_member (entry, "XADIsEncrypted")) fdata->encrypted = json_object_get_int_member (entry, "XADIsEncrypted") == 1; filename = json_object_get_string_member (entry, "XADFileName"); if (*filename == '/') { fdata->full_path = g_strdup (filename); fdata->original_path = fdata->full_path; } else { fdata->full_path = g_strconcat ("/", filename, NULL); fdata->original_path = fdata->full_path + 1; } fdata->link = NULL; if (json_object_has_member (entry, "XADIsDirectory")) fdata->dir = json_object_get_int_member (entry, "XADIsDirectory") == 1; if (fdata->dir) fdata->name = _g_path_get_dir_name (fdata->full_path); else fdata->name = g_strdup (_g_path_get_basename (fdata->full_path)); fdata->path = _g_path_remove_level (fdata->full_path); fr_archive_add_file (FR_ARCHIVE (unar_comm), fdata); } } } g_object_unref (parser); }
static void onTaskReadyCallback(GObject * source, GAsyncResult * res, gpointer userData) { GError *err = NULL; //WlDictQuery *query=WL_DICT_QUERY(source); TaskData *td = g_task_get_task_data(G_TASK(res)); gchar *responseBody = g_task_propagate_pointer(G_TASK(res), &err); if (err) { /* Error */ if (td->cb) td->cb(td->from, td->to, td->src, NULL, td->cbData, err); return; } JsonParser *parser = json_parser_new(); if (!json_parser_load_from_data(parser, responseBody, -1, &err)) { if (td->cb) td->cb(td->from, td->to, td->src, NULL, td->cbData, err); g_message("%s", responseBody); return; } JsonNode *rootNode = json_parser_get_root(parser); JsonObject *rootObj = json_node_get_object(rootNode); const gchar *from = json_object_get_string_member(rootObj, "from"); const gchar *to = json_object_get_string_member(rootObj, "to"); if (json_object_has_member(rootObj, "error_code")) { /* 查询出错 */ const gchar *error_msg = json_object_get_string_member(rootObj, "error_msg"); const gchar *error_code = json_object_get_string_member(rootObj, "error_code"); if (td->cb) { GError *error = g_error_new(G_IO_ERROR, atoi(error_code), "%s", error_msg); td->cb(wl_dict_lang_get_enum(from), wl_dict_lang_get_enum(to), json_object_get_string_member(rootObj, "query"), NULL, td->cbData, error); g_error_free(error); } g_object_unref(parser); return; } JsonArray *results = json_object_get_array_member(rootObj, "trans_result"); gint i, len = json_array_get_length(results); for (i = 0; i < len; i++) { JsonObject *resEle = json_array_get_object_element(results, i); const gchar *src = json_object_get_string_member(resEle, "src"); const gchar *dst = json_object_get_string_member(resEle, "dst"); if (td->cb) td->cb(wl_dict_lang_get_enum(from), wl_dict_lang_get_enum(to), src, dst, td->cbData, NULL); } g_object_unref(parser); }
void trg_prefs_load(TrgPrefs * p) { TrgPrefsPrivate *priv = p->priv; JsonParser *parser = json_parser_new(); JsonNode *root; guint n_profiles; JsonArray *profiles; gboolean parsed = json_parser_load_from_file(parser, priv->file, NULL); if (!parsed) { trg_prefs_empty_init(p); g_object_unref(parser); return; } root = json_parser_get_root(parser); if (root) { priv->user = json_node_copy(root); priv->userObj = json_node_get_object(priv->user); } g_object_unref(parser); if (!root) { trg_prefs_empty_init(p); return; } if (!json_object_has_member(priv->userObj, TRG_PREFS_KEY_PROFILES)) { profiles = json_array_new(); json_object_set_array_member(priv->userObj, TRG_PREFS_KEY_PROFILES, profiles); } else { profiles = json_object_get_array_member(priv->userObj, TRG_PREFS_KEY_PROFILES); } n_profiles = json_array_get_length(profiles); if (n_profiles < 1) { priv->profile = trg_prefs_new_profile_object(); json_array_add_object_element(profiles, priv->profile); trg_prefs_set_int(p, TRG_PREFS_KEY_PROFILE_ID, 0, TRG_PREFS_GLOBAL); } else { gint profile_id = trg_prefs_get_int(p, TRG_PREFS_KEY_PROFILE_ID, TRG_PREFS_GLOBAL); if (profile_id >= n_profiles) trg_prefs_set_int(p, TRG_PREFS_KEY_PROFILE_ID, profile_id = 0, TRG_PREFS_GLOBAL); priv->profile = json_array_get_object_element(profiles, profile_id); } }
/* This function is synchronous! Blocking once at startup seems pretty * reasonable and allows us to avoid any complexity re. races */ static void mex_queue_model_load (MexQueueModel *model) { JsonParser *parser; gchar *filename; GError *error = NULL; JsonNode *root; JsonArray *array; gint i = 0; filename = _queue_file_name (); if (!g_file_test (filename, G_FILE_TEST_EXISTS)) { g_free (filename); return; } parser = json_parser_new (); if (!json_parser_load_from_file (parser, filename, &error)) { g_warning (G_STRLOC ": error populating from file: %s", error->message); g_clear_error (&error); goto out; } root = json_parser_get_root (parser); if (!JSON_NODE_HOLDS_ARRAY (root)) { g_warning (G_STRLOC ": JSON data not of expected format!"); goto out; } array = json_node_get_array (root); for (i = 0; i < json_array_get_length (array); i++) { MexContent *content; JsonNode *node; node = json_array_get_element (array, i); content = (MexContent *)json_gobject_deserialize (MEX_TYPE_PROGRAM, node); mex_model_add_content (MEX_MODEL (model), content); } out: g_free (filename); g_object_unref (parser); }