gchar *torrent_get_full_path(JsonObject * obj) { const gchar *location = json_object_get_string_member(obj, FIELD_DOWNLOAD_DIR); const gchar *name = json_object_get_string_member(obj, FIELD_NAME); return g_strdup_printf("%s/%s", location, name); }
static void _picasa_web_service_get_access_token_ready_cb (SoupSession *session, SoupMessage *msg, gpointer user_data) { PicasaWebService *self = user_data; GSimpleAsyncResult *result; GError *error = NULL; JsonNode *node; result = _web_service_get_result (WEB_SERVICE (self)); if (picasa_web_utils_parse_json_response (msg, &node, &error)) { JsonObject *obj; OAuthAccount *account; obj = json_node_get_object (node); account = web_service_get_current_account (WEB_SERVICE (self)); if (account != NULL) g_object_set (account, "token", json_object_get_string_member (obj, "access_token"), NULL); else _g_strset (&self->priv->access_token, json_object_get_string_member (obj, "access_token")); } else g_simple_async_result_set_from_error (result, error); g_simple_async_result_complete_in_idle (result); }
static void gml_gtk_widget_create_rect (ClutterActor *parent, JsonObject *obj) { GList *l = NULL; GList *p = NULL; ClutterColor color = { 0x00, 0x00, 0x00, 0xff }; ClutterActor *rect = clutter_rectangle_new (); l = json_object_get_members (obj); for (p = l; p; p = p->next) { if (!strcmp (p->data, "width")) { clutter_actor_set_width (rect, (float)json_object_get_int_member (obj, p->data)); } else if (!strcmp (p->data, "height")) { clutter_actor_set_height (rect, (float)json_object_get_int_member (obj, p->data)); } else if (!strcmp (p->data, "x")) { clutter_actor_set_x (rect, (float)json_object_get_int_member (obj, p->data)); } else if (!strcmp (p->data, "y")) { clutter_actor_set_y (rect, (float)json_object_get_int_member (obj, p->data)); } else if (!strcmp (p->data, "color")) { clutter_color_from_string (&(color), json_object_get_string_member (obj, p->data)); clutter_rectangle_set_color (CLUTTER_RECTANGLE (rect), &color); } else if (!strcmp (p->data, "border.width")) { clutter_rectangle_set_border_width (CLUTTER_RECTANGLE (rect), json_object_get_int_member (obj, p->data)); } else if (!strcmp (p->data, "border.color")) { clutter_color_from_string (&(color), json_object_get_string_member (obj, p->data)); clutter_rectangle_set_border_color (CLUTTER_RECTANGLE (rect), &color); } } clutter_container_add_actor (CLUTTER_CONTAINER (parent), rect); }
static dt_gphoto_album_t *_json_new_album(JsonObject *obj) { // handle on writable albums (in Google Photo only albums created by the API are writeable via the API) if(json_object_has_member(obj, "isWriteable")) if(json_object_get_boolean_member(obj, "isWriteable")) { dt_gphoto_album_t *album = gphoto_album_init(); if(album == NULL) goto error; const char *id = json_object_get_string_member(obj, "id"); const char *name = json_object_get_string_member(obj, "title"); const int size = json_object_has_member(obj, "mediaItemsCount") ? json_object_get_int_member(obj, "mediaItemsCount") : 0; if(id == NULL || name == NULL) { gphoto_album_destroy(album); goto error; } album->id = g_strdup(id); album->name = g_strdup(name); album->size = size; return album; } error: return NULL; }
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); }
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); }
// Check if an app is graphical by checking if it uses a known GUI interface. // This doesn't necessarily mean that every binary uses this interfaces, but is probably true. // https://bugs.launchpad.net/bugs/1595023 static gboolean is_graphical (GsApp *app, GCancellable *cancellable) { g_autoptr(JsonObject) result = NULL; JsonArray *plugs; guint i; g_autoptr(GError) error = NULL; result = gs_snapd_get_interfaces (NULL, NULL, cancellable, &error); if (result == NULL) { g_warning ("Failed to check interfaces: %s", error->message); return FALSE; } plugs = json_object_get_array_member (result, "plugs"); for (i = 0; i < json_array_get_length (plugs); i++) { JsonObject *plug = json_array_get_object_element (plugs, i); const gchar *interface; // Only looks at the plugs for this snap if (g_strcmp0 (json_object_get_string_member (plug, "snap"), gs_app_get_id (app)) != 0) continue; interface = json_object_get_string_member (plug, "interface"); if (interface == NULL) continue; if (g_strcmp0 (interface, "unity7") == 0 || g_strcmp0 (interface, "x11") == 0 || g_strcmp0 (interface, "mir") == 0) return TRUE; } return FALSE; }
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); }
END_TEST START_TEST (test_cometd_new_publish_message) { cometd_conn_set_client_id(g_instance->conn, "testid"); const char* expected_channel = "/baz/bar"; JsonNode* node = cometd_json_str2node("{ \"hey\": \"now\" }"); JsonNode* message = cometd_new_publish_message(g_instance, expected_channel, node); JsonObject* obj = json_node_get_object(message); const gchar* actual_channel = json_object_get_string_member(obj, COMETD_MSG_CHANNEL_FIELD); ck_assert_str_eq(expected_channel, actual_channel); JsonObject* data = json_object_get_object_member(obj, COMETD_MSG_DATA_FIELD); const char* value = json_object_get_string_member(data, "hey"); ck_assert_str_eq("now", value); json_node_free(message); json_node_free(node); }
static void skypeweb_got_self_details(SkypeWebAccount *sa, JsonNode *node, gpointer user_data) { JsonObject *userobj; const gchar *old_alias; const gchar *displayname = NULL; const gchar *username; if (node == NULL || json_node_get_node_type(node) != JSON_NODE_OBJECT) return; userobj = json_node_get_object(node); username = json_object_get_string_member(userobj, "username"); g_free(sa->username); sa->username = g_strdup(username); old_alias = purple_account_get_private_alias(sa->account); if (!old_alias || !*old_alias) { if (json_object_has_member(userobj, "displayname")) displayname = json_object_get_string_member(userobj, "displayname"); if (!displayname || g_str_equal(displayname, username)) displayname = json_object_get_string_member(userobj, "firstname"); if (displayname) purple_account_set_private_alias(sa->account, displayname); } if (!PURPLE_CONNECTION_IS_CONNECTED(sa->pc)) { skypeweb_do_all_the_things(sa); } }
static void skypeweb_got_authrequests(SkypeWebAccount *sa, JsonNode *node, gpointer user_data) { JsonArray *requests; guint index, length; time_t latest_timestamp = 0; requests = json_node_get_array(node); length = json_array_get_length(requests); for(index = 0; index < length; index++) { JsonObject *request = json_array_get_object_element(requests, index); const gchar *event_time_iso = json_object_get_string_member(request, "event_time_iso"); const gchar *sender = json_object_get_string_member(request, "sender"); const gchar *greeting = json_object_get_string_member(request, "greeting"); time_t event_timestamp = purple_str_to_time(event_time_iso, TRUE, NULL, NULL, NULL); latest_timestamp = MAX(latest_timestamp, event_timestamp); if (sa->last_authrequest && event_timestamp <= sa->last_authrequest) continue; purple_account_request_authorization( sa->account, sender, NULL, NULL, greeting, FALSE, skypeweb_auth_accept_cb, skypeweb_auth_reject_cb, purple_buddy_new(sa->account, sender, NULL)); } sa->last_authrequest = latest_timestamp; }
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); } }
pulseaudio_config * parse_audio_configuration (JsonObject * json_object) { pulseaudio_config * configuration = NULL; gchar * server_name = NULL, * mode = NULL; if (! json_object) { g_error("JSON object must not be NULL."); } if (! ( server_name = (gchar *) json_object_get_string_member(json_object, SERVER_KEY) )) { g_error("Missing server name in configuration."); } configuration = (pulseaudio_config *) g_malloc( sizeof(pulseaudio_config) ); if (( mode = (gchar *) json_object_get_string_member( json_object, AUDIO_MODE_KEY ) )) { if (strcmp("push", mode) == 0) { configuration->mode = PULSEAUDIO_MODE_PUSH; configuration->source = PA_INVALID_INDEX; } else if (strcmp("pull", mode) == 0) { configuration->mode = PULSEAUDIO_MODE_PULL; configuration->source = json_object_get_int_member( json_object, SOURCE_KEY ); } else { g_error("Invalid audio mode for server '%s'", server_name); } } else { g_error("Missing audio mode for server '%s'", server_name); } configuration->sink = json_object_get_int_member( json_object, SINK_KEY ); return configuration; }
static guint install_properties(JsonOpClass *json_op_class) { GObjectClass *object_class = G_OBJECT_CLASS (json_op_class); JsonObject *root = json_op_class->json_root; guint prop = 1; // Exported ports if (json_object_has_member(root, "inports")) { JsonObject *inports = json_object_get_object_member(root, "inports"); GList *inport_names = json_object_get_members(inports); GList *l; for (l = inport_names; l != NULL; l = l->next) { const gchar *name = l->data; JsonObject *conn = json_object_get_object_member(inports, name); const gchar *proc = json_object_get_string_member(conn, "process"); const gchar *port = json_object_get_string_member(conn, "port"); JsonObject *processes = json_object_get_object_member(root, "processes"); JsonObject *p = json_object_get_object_member(processes, proc); const gchar *component = json_object_get_string_member(p, "component"); { GParamSpec *target_spec = NULL; gchar *opname = component2geglop(component); // HACK: should avoid instantiating node to determine prop GeglNode *n = gegl_node_new(); g_assert(n); gegl_node_set(n, "operation", opname, NULL); target_spec = gegl_node_find_property(n, port); if (target_spec) { GParamSpec *spec = copy_param_spec(target_spec, name); PropertyTarget *t = property_target_new(g_strdup(proc), g_strdup(port)); g_hash_table_insert(json_op_class->properties, GINT_TO_POINTER(prop), t); g_object_class_install_property (object_class, prop, spec); prop++; } g_object_unref(n); g_free(opname); } } g_list_free(inport_names); } /* if (json_object_has_member(root, "outports")) { JsonObject *outports = json_object_get_object_member(root, "outports"); GList *outport_names = json_object_get_members(outports); for (int i=0; i<g_list_length(outport_names); i++) { const gchar *name = g_list_nth_data(outport_names, i); JsonObject *conn = json_object_get_object_member(outports, name); const gchar *proc = json_object_get_string_member(conn, "process"); const gchar *port = json_object_get_string_member(conn, "port"); graph_add_port(self, GraphOutPort, name, proc, port); } } */ return prop-1; }
void cb_user_identity_parse (CbUserIdentity *id, JsonObject *user_obj) { id->id = json_object_get_int_member (user_obj, "id"); id->screen_name = g_strdup (json_object_get_string_member (user_obj, "screen_name")); id->user_name = cb_utils_escape_ampersands (json_object_get_string_member (user_obj, "name")); id->verified = json_object_get_boolean_member (user_obj, "verified"); }
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); }
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); }
/** * @see https://developers.facebook.com/docs/reference/api/user/ * @return basic informations about the account */ static FBAccountInfo *fb_get_account_info(FBContext *ctx) { JsonObject *obj = fb_query_get(ctx, "me", NULL); g_return_val_if_fail((obj != NULL), NULL); const gchar *user_name = json_object_get_string_member(obj, "username"); const gchar *user_id = json_object_get_string_member(obj, "id"); g_return_val_if_fail(user_name != NULL && user_id != NULL, NULL); FBAccountInfo *accountinfo = fb_account_info_init(); accountinfo->id = g_strdup(user_id); accountinfo->username = g_strdup(user_name); accountinfo->token = g_strdup(ctx->token); return accountinfo; }
static void load_account_info_fill(gchar *key, gchar *value, GSList **accountlist) { FBAccountInfo *info = fb_account_info_init(); info->id = g_strdup(key); JsonParser *parser = json_parser_new(); json_parser_load_from_data(parser, value, strlen(value), NULL); JsonNode *root = json_parser_get_root(parser); JsonObject *obj = json_node_get_object(root); info->token = g_strdup(json_object_get_string_member(obj, "token")); info->username = g_strdup(json_object_get_string_member(obj, "username")); *accountlist = g_slist_prepend(*accountlist, info); g_object_unref(parser); }
/* FIXME: an error exit at field i leaves fields [0..i) modified. */ bool format_from_json( void *dest, JsonObject *obj, const struct field_desc *fields, size_t num_fields, GError **err_p) { for(size_t i=0; i < num_fields; i++) { const char *name = fields[i].name; JsonNode *node = json_object_get_member(obj, name); if(node == NULL) { /* not present. skip. */ continue; } bool null_ok = islower(fields[i].type), is_null = json_node_is_null(node); if(!null_ok && is_null) { g_set_error(err_p, 0, 0, "%s: field `%s' is null, but not allowed to", __func__, name); return false; } void *ptr = dest + fields[i].offset; switch(tolower(fields[i].type)) { case 'i': *(uint64_t *)ptr = is_null ? 0 : json_object_get_int_member(obj, name); break; case 'b': *(bool *)ptr = is_null ? false : json_object_get_boolean_member(obj, name); break; case 's': g_free(*(char **)ptr); *(char **)ptr = is_null ? NULL : g_strdup(json_object_get_string_member(obj, name)); break; case 't': { GDateTime **dt_p = ptr; if(*dt_p != NULL) { g_date_time_unref(*dt_p); *dt_p = NULL; } *dt_p = parse_datetime(json_object_get_string_member(obj, name)); break; } default: assert(false); } } return true; }
void cb_mini_tweet_parse (CbMiniTweet *t, JsonObject *obj) { GDateTime *time; JsonObject *extended_object; const char *tweet_text; if (json_object_has_member (obj, "extended_tweet")) extended_object = json_object_get_object_member (obj, "extended_tweet"); else extended_object = obj; time = cb_utils_parse_date (json_object_get_string_member (obj, "created_at")); t->id = json_object_get_int_member (obj, "id"); if (json_object_has_member (extended_object, "full_text")) tweet_text = json_object_get_string_member (extended_object, "full_text"); else tweet_text = json_object_get_string_member (extended_object, "text"); if (json_object_has_member (extended_object, "display_text_range")) { /* We only remove the prefix */ guint start = (guint)json_array_get_int_element ( json_object_get_array_member (extended_object, "display_text_range"), 0); guint i; const char *p = tweet_text; /* Skip ahead */ for (i = 0; i < start; i ++) p = g_utf8_next_char (p); t->text = g_strdup (p); t->display_range_start = start; } else { t->text = g_strdup (tweet_text); t->display_range_start= 0; } t->created_at = g_date_time_to_unix (time); cb_user_identity_parse (&t->author, json_object_get_object_member (obj, "user")); g_date_time_unref (time); }
/** * Returns a cometd_advice pointer that should be free'd by the caller. * Returns NULL if advice cannot be found. * * See also: http://svn.cometd.com/trunk/bayeux/bayeux.html#toc_32 */ cometd_advice* cometd_msg_advice(JsonNode* node) { g_return_val_if_fail(JSON_NODE_HOLDS_OBJECT (node), NULL); JsonObject* obj = json_node_get_object(node); cometd_advice* advice = NULL; JsonObject* advice_obj = NULL; if (json_object_has_member(obj, COMETD_MSG_ADVICE_FIELD)) advice_obj = json_object_get_object_member(obj, COMETD_MSG_ADVICE_FIELD); if (!advice_obj) return NULL; const char* reconnect = json_object_get_string_member(advice_obj, "reconnect"); const guint64 interval = json_object_get_int_member(advice_obj, "interval"); if (reconnect || interval) { advice = cometd_advice_new(); advice->interval = interval; if (strcmp("none", reconnect) == 0) { advice->reconnect = COMETD_RECONNECT_NONE; } else if (strcmp("handshake", reconnect) == 0) { advice->reconnect = COMETD_RECONNECT_HANDSHAKE; } else if (strcmp("retry", reconnect) == 0) { advice->reconnect = COMETD_RECONNECT_RETRY; } } return advice; }
static void handle_network_message(UiConnection *self, const gchar *command, JsonObject *payload, SoupWebsocketConnection *ws) { g_return_if_fail(payload); Network *network = NULL; { const gchar *graph_id = json_object_get_string_member(payload, "graph"); network = (graph_id) ? g_hash_table_lookup(self->network_map, graph_id) : NULL; } g_return_if_fail(network); if (g_strcmp0(command, "start") == 0) { // FIXME: response should be done in callback monitoring network state changes // TODO: send timestamp, graph id JsonObject *info = json_object_new(); send_response(ws, "network", "started", info); g_print("\tNetwork START\n"); network_set_running(network, TRUE); } else if (g_strcmp0(command, "stop") == 0) { // FIXME: response should be done in callback monitoring network state changes // TODO: send timestamp, graph id JsonObject *info = json_object_new(); send_response(ws, "network", "stopped", info); g_print("\tNetwork STOP\n"); network_set_running(network, FALSE); } else { g_printerr("Unhandled message on protocol 'network', command='%s'", command); } }
static void handle_network_message(UiConnection *self, const gchar *command, JsonObject *payload, SoupWebsocketConnection *ws) { g_return_if_fail(payload); const gchar *graph_id = json_object_get_string_member(payload, "graph"); Network *network = (graph_id) ? g_hash_table_lookup(self->network_map, graph_id) : NULL; g_return_if_fail(network); if (g_strcmp0(command, "start") == 0) { imgflo_info("\tNetwork START\n"); network_set_running(network, TRUE); } else if (g_strcmp0(command, "stop") == 0) { imgflo_info("\tNetwork STOP\n"); network_set_running(network, FALSE); } else if (g_strcmp0(command, "edges") == 0) { // TODO: update subscriptions send_response(ws, "network", "edges", payload); } else if (g_strcmp0(command, "getstatus") == 0) { JsonObject *info = json_object_new(); json_object_set_string_member(info, "graph", graph_id); json_object_set_boolean_member(info, "running", network_is_processing(network)); json_object_set_boolean_member(info, "started", network->running); send_response(ws, "network", "status", info); } else if (g_strcmp0(command, "debug") == 0) { // Ignored, not implemented } else { imgflo_warning("Unhandled message on protocol 'network', command='%s'", command); } }
/** * @see https://developers.facebook.com/docs/reference/api/album/ * @return the id of the uploaded photo */ static const gchar *fb_upload_photo_to_album(FBContext *ctx, gchar *albumid, gchar *fpath, gchar *description) { GString *method = g_string_new(albumid); g_string_append(method, "/photos"); GHashTable *files = g_hash_table_new((GHashFunc)g_str_hash, (GEqualFunc)g_str_equal); g_hash_table_insert(files, "source", fpath); GHashTable *args = NULL; if (description != NULL) { args = g_hash_table_new((GHashFunc)g_str_hash, (GEqualFunc)g_str_equal); g_hash_table_insert(args, "message", description); } JsonObject *ref = fb_query_post(ctx, method->str, args, files); g_string_free(method, TRUE); g_hash_table_destroy(files); if (args != NULL) { g_hash_table_destroy(args); } if (ref == NULL) return NULL; return json_object_get_string_member(ref, "id"); }
/** * @see https://developers.facebook.com/docs/reference/api/user/ * @return the id of the newly reacted */ static const gchar *fb_create_album(FBContext *ctx, gchar *name, gchar *summary, FBAlbumPrivacyPolicy privacy) { GHashTable *args = g_hash_table_new((GHashFunc)g_str_hash, (GEqualFunc)g_str_equal); g_hash_table_insert(args, "name", name); if (summary != NULL) g_hash_table_insert(args, "message", summary); switch (privacy) { case FBALBUM_PRIVACY_EVERYONE: g_hash_table_insert(args, "privacy", "{\"value\":\"EVERYONE\"}"); break; case FBALBUM_PRIVACY_ALL_FRIENDS: g_hash_table_insert(args, "privacy", "{\"value\":\"ALL_FRIENDS\"}"); break; case FBALBUM_PRIVACY_FRIENDS_OF_FRIENDS: g_hash_table_insert(args, "privacy", "{\"value\":\"FRIENDS_OF_FRIENDS\"}"); break; case FBALBUM_PRIVACY_SELF: g_hash_table_insert(args, "privacy", "{\"value\":\"SELF\"}"); break; default: goto error; break; } JsonObject *ref = fb_query_post(ctx, "me/albums", args, NULL); if (ref == NULL) goto error; g_hash_table_destroy(args); return json_object_get_string_member(ref, "id"); error: g_hash_table_destroy(args); return NULL; }
static gboolean catch_space_load_from_json (CatchResource *resource, JsonNode *node, GError **error) { CatchSpace *space = (CatchSpace *)resource; JsonObject *obj; ENTRY; g_return_val_if_fail(CATCH_IS_SPACE(space), FALSE); g_return_val_if_fail(node != NULL, FALSE); if (CATCH_RESOURCE_CLASS(catch_space_parent_class)->load_from_json) { if (!CATCH_RESOURCE_CLASS(catch_space_parent_class)-> load_from_json(resource, node, error)) { RETURN(FALSE); } } if (JSON_NODE_HOLDS_OBJECT(node) && (obj = json_node_get_object(node))) { if (json_object_has_member(obj, "name") && JSON_NODE_HOLDS_VALUE(json_object_get_member(obj, "name"))) { catch_space_set_name(CATCH_SPACE(resource), json_object_get_string_member(obj, "name")); } } RETURN(TRUE); }
BuilderSource * builder_source_from_json (JsonNode *node) { JsonObject *object = json_node_get_object (node); const gchar *type; type = json_object_get_string_member (object, "type"); if (type == NULL) g_warning ("Missing source type"); else if (strcmp (type, "archive") == 0) return (BuilderSource *) json_gobject_deserialize (BUILDER_TYPE_SOURCE_ARCHIVE, node); else if (strcmp (type, "file") == 0) return (BuilderSource *) json_gobject_deserialize (BUILDER_TYPE_SOURCE_FILE, node); else if (strcmp (type, "script") == 0) return (BuilderSource *) json_gobject_deserialize (BUILDER_TYPE_SOURCE_SCRIPT, node); else if (strcmp (type, "shell") == 0) return (BuilderSource *) json_gobject_deserialize (BUILDER_TYPE_SOURCE_SHELL, node); else if (strcmp (type, "patch") == 0) return (BuilderSource *) json_gobject_deserialize (BUILDER_TYPE_SOURCE_PATCH, node); else if (strcmp (type, "git") == 0) return (BuilderSource *) json_gobject_deserialize (BUILDER_TYPE_SOURCE_GIT, node); else if (strcmp (type, "bzr") == 0) return (BuilderSource *) json_gobject_deserialize (BUILDER_TYPE_SOURCE_BZR, node); else g_warning ("Unknown source type %s", type); return NULL; }
server_configuration * parse_server_configuration ( JsonObject * json_object ) { server_configuration * configuration = NULL; if (json_object == NULL) { g_error("JSON object must not be NULL."); } configuration = (server_configuration *) g_malloc( sizeof(server_configuration) ); if (! ( configuration->server = g_strdup( json_object_get_string_member(json_object, SERVER_KEY) ) )) { g_error("Missing server name in configuraiton."); } configuration->device_configuration = parse_device_configuration( json_object ); configuration->audio_configuration = parse_audio_configuration( json_object ); return configuration; }