// 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);
}
