static gboolean parse_emojione_keywords (JsonNode *node, EmojiData *data) { #if 0 JsonArray *keywords; guint i, length; if (json_node_get_node_type (node) != JSON_NODE_ARRAY) { g_warning ("'keywords' element is not array"); return FALSE; } keywords = json_node_get_array (node); length = json_array_get_length (keywords); for (i = 0; i < length; i++) { const gchar *keyword = json_array_get_string_element (keywords, i); GSList *duplicated = g_slist_find_custom (data->annotations, keyword, (GCompareFunc) g_strcmp0); if (duplicated == NULL) { data->annotations = g_slist_prepend (data->annotations, g_strdup (keyword)); } } #endif return TRUE; }
static gboolean ipcam_event_cover_msg_handler_get_action_impl(IpcamMessageHandler *handler, JsonNode *request, JsonNode **response) { JsonBuilder *builder = json_builder_new(); JsonArray *req_array; int i; req_array = json_object_get_array_member(json_node_get_object(request), "items"); json_builder_begin_object(builder); json_builder_set_member_name(builder, "items"); json_builder_begin_object(builder); for (i = 0; i < json_array_get_length(req_array); i++) { const gchar *name = json_array_get_string_element(req_array, i); if (g_str_equal(name, "region1") || g_str_equal(name, "region2")) { json_builder_set_member_name(builder, name); json_builder_begin_object(builder); ipcam_event_cover_msg_handler_read_param(IPCAM_EVENT_COVER_MSG_HANDLER(handler), builder, name); json_builder_end_object(builder); } } json_builder_end_object(builder); json_builder_end_object(builder); *response = json_builder_get_root(builder); g_object_unref(builder); return TRUE; }
static gboolean parse_emojione_aliases_ascii (JsonNode *node, EmojiData *data) { JsonArray *aliases_ascii; guint i, length; if (json_node_get_node_type (node) != JSON_NODE_ARRAY) { g_warning ("'aliases_ascii' element is not array"); return FALSE; } aliases_ascii = json_node_get_array (node); length = json_array_get_length (aliases_ascii); for (i = 0; i < length; i++) { const gchar *alias = json_array_get_string_element (aliases_ascii, i); GSList *duplicated = g_slist_find_custom (data->annotations, alias, (GCompareFunc) g_strcmp0); if (duplicated == NULL) { data->annotations = g_slist_prepend (data->annotations, g_strdup (alias)); } } return TRUE; }
/** * wbl_string_set_union_dependencies: * @set: (transfer floating): a #WblStringSet * @dependencies: a JSON object mapping property names to arrays of property * names (or to object instances) * * Calculate the transitive union of the dependencies of the elements of an * initial @set and return it as a new #WblStringSet. @dependencies is treated * as a map of property names to dependencies; the function essentially * calculates * output = set ∪ ⋃_{d ϵ output} dependencies(d) * * Complexity: O(S * D) in the size S of @set and number D of @dependencies keys * Returns: the transitive dependency set of @set * Since: 0.2.0 */ WblStringSet * wbl_string_set_union_dependencies (WblStringSet *set, JsonObject *dependencies) { WblStringSet *output = NULL; guint old_output_size; g_return_val_if_fail (_wbl_string_set_is_valid (set), NULL); g_return_val_if_fail (dependencies != NULL, NULL); output = _wbl_string_set_new (); wbl_string_set_ref_sink (set); do { GHashTableIter iter; const gchar *property_name; old_output_size = g_hash_table_size (output->set); g_hash_table_iter_init (&iter, set->set); while (g_hash_table_iter_next (&iter, (gpointer *) &property_name, NULL)) { JsonNode *dependency_value; guint i, len; /* Add the dependency key. */ _wbl_string_set_add (output, property_name); /* See if there are any values associated with the * dependency key. */ dependency_value = json_object_get_member (dependencies, property_name); /* Ignore schema dependencies; we only care about * property dependencies, for which we add all * dependent properties. */ if (dependency_value != NULL && JSON_NODE_HOLDS_ARRAY (dependency_value)) { JsonArray *array; array = json_node_get_array (dependency_value); for (i = 0, len = json_array_get_length (array); i < len; i++) { _wbl_string_set_add (output, json_array_get_string_element (array, i)); } } } } while (old_output_size != g_hash_table_size (output->set)); wbl_string_set_unref (set); output->state |= STATE_IMMUTABLE; return output; }
/* 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 cockpit_package_dump (void) { GHashTable *listing; GHashTable *by_name; GHashTableIter iter; CockpitPackage *package; GList *names, *l; const gchar *prefix; JsonArray *array; guint i; listing = cockpit_package_listing (NULL); by_name = g_hash_table_new (g_str_hash, g_str_equal); g_hash_table_iter_init (&iter, listing); while (g_hash_table_iter_next (&iter, NULL, (gpointer *)&package)) g_hash_table_replace (by_name, package->name, package); names = g_hash_table_get_keys (by_name); names = g_list_sort (names, (GCompareFunc)strcmp); for (l = names; l != NULL; l = g_list_next (l)) { package = g_hash_table_lookup (by_name, l->data); g_print ("%s: %s\n", package->name, package->directory); if (package->checksum) g_print (" checksum: %s\n", package->checksum); if (package->alias) { prefix = " alias: "; if (JSON_NODE_HOLDS_ARRAY (package->alias)) { array = json_node_get_array (package->alias); for (i = 0; i < json_array_get_length (array); i++) { g_print ("%s%s\n", prefix, json_array_get_string_element (array, i)); prefix = " "; } } else { g_print ("%s%s\n", prefix, json_node_get_string (package->alias)); } } } g_list_free (names); g_hash_table_unref (by_name); g_hash_table_unref (listing); }
const char * _rpmostree_jsonutil_array_require_string_element (JsonArray *array, guint i, GError **error) { const char *ret = json_array_get_string_element (array, i); if (!ret) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Element at index %u is not a string", i); return NULL; } return ret; }
GHashTable * _rpmostree_jsonutil_jsarray_strings_to_set (JsonArray *array) { GHashTable *ret = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, g_free); guint i; guint len = json_array_get_length (array); for (i = 0; i < len; i++) { const char *elt = json_array_get_string_element (array, i); g_hash_table_add (ret, g_strdup (elt)); } return ret; }
/** * wbl_string_set_new_from_array_elements: * @array: a JSON array of UTF-8 strings * * Create a new #WblStringSet containing the values of all the elements in * @array, which may be empty. Duplicate elements are ignored. * * It is a programmer error to call this with a #JsonArray which contains * non-UTF-8 elements. * * Returns: (transfer full): a new #WblStringSet * * Since: 0.2.0 */ WblStringSet * wbl_string_set_new_from_array_elements (JsonArray *array) { WblStringSet *set = NULL; guint i, len; set = _wbl_string_set_new (); for (i = 0, len = json_array_get_length (array); i < len; i++) { _wbl_string_set_add (set, json_array_get_string_element (array, i)); } set->state |= STATE_IMMUTABLE; return set; }
static gboolean handle_remove_files_from_package (GFile *yumroot, RpmOstreeRefSack *refsack, JsonArray *removespec, GCancellable *cancellable, GError **error) { gboolean ret = FALSE; const char *pkg = json_array_get_string_element (removespec, 0); guint i, j, npackages; guint len = json_array_get_length (removespec); HyPackage hypkg; _cleanup_hyquery_ HyQuery query = NULL; _cleanup_hypackagelist_ HyPackageList pkglist = NULL; query = hy_query_create (refsack->sack); hy_query_filter (query, HY_PKG_NAME, HY_EQ, pkg); pkglist = hy_query_run (query); npackages = hy_packagelist_count (pkglist); if (npackages == 0) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Unable to find package '%s' specified in remove-files-from", pkg); goto out; } for (j = 0; j < npackages; j++) { _cleanup_hystringarray_ HyStringArray pkg_files = NULL; hypkg = hy_packagelist_get (pkglist, 0); pkg_files = hy_package_get_files (hypkg); for (i = 1; i < len; i++) { const char *remove_regex_pattern = json_array_get_string_element (removespec, i); GRegex *regex; char **strviter; regex = g_regex_new (remove_regex_pattern, G_REGEX_JAVASCRIPT_COMPAT, 0, error); if (!regex) goto out; for (strviter = pkg_files; strviter && strviter[0]; strviter++) { const char *file = *strviter; if (g_regex_match (regex, file, 0, NULL)) { gs_unref_object GFile *child = NULL; if (file[0] == '/') file++; child = g_file_resolve_relative_path (yumroot, file); g_print ("Deleting: %s\n", file); if (!gs_shutil_rm_rf (child, cancellable, error)) goto out; } } } } ret = TRUE; out: return ret; }
/* * Callback function for when a channel receives data from the ipc socket. * Emits the corresponding signal with the reply. */ static gboolean ipc_on_data(GIOChannel *channel, GIOCondition condition, i3ipcConnection *conn) { if (condition != G_IO_IN) return TRUE; GIOStatus status; uint32_t reply_length; uint32_t reply_type; gchar *reply; GError *err = NULL; JsonParser *parser; JsonObject *json_reply; status = ipc_recv_message(channel, &reply_type, &reply_length, &reply, &err); if (status == G_IO_STATUS_EOF) { g_signal_emit(conn, connection_signals[IPC_SHUTDOWN], 0); if (conn->priv->main_loop != NULL) i3ipc_connection_main_quit(conn); return FALSE; } if (err) { g_warning("could not get event reply\n"); g_error_free(err); g_free(reply); return TRUE; } reply[reply_length] = '\0'; parser = json_parser_new(); json_parser_load_from_data(parser, reply, -1, &err); if (err) { g_warning("could not parse event reply json (%s)\n", err->message); g_error_free(err); g_free(reply); g_object_unref(parser); return TRUE; } json_reply = json_node_get_object(json_parser_get_root(parser)); switch (1 << (reply_type & 0x7F)) { case I3IPC_EVENT_WORKSPACE: { i3ipcWorkspaceEvent *e = g_slice_new0(i3ipcWorkspaceEvent); e->change = g_strdup(json_object_get_string_member(json_reply, "change")); if (json_object_has_member(json_reply, "current") && !json_object_get_null_member(json_reply, "current")) e->current = i3ipc_con_new(NULL, json_object_get_object_member(json_reply, "current"), conn); if (json_object_has_member(json_reply, "old") && !json_object_get_null_member(json_reply, "old")) e->old = i3ipc_con_new(NULL, json_object_get_object_member(json_reply, "old"), conn); g_signal_emit(conn, connection_signals[WORKSPACE], g_quark_from_string(e->change), e); break; } case I3IPC_EVENT_OUTPUT: { i3ipcGenericEvent *e = g_slice_new0(i3ipcGenericEvent); e->change = g_strdup(json_object_get_string_member(json_reply, "change")); g_signal_emit(conn, connection_signals[OUTPUT], g_quark_from_string(e->change), e); break; } case I3IPC_EVENT_MODE: { i3ipcGenericEvent *e = g_slice_new0(i3ipcGenericEvent); e->change = g_strdup(json_object_get_string_member(json_reply, "change")); g_signal_emit(conn, connection_signals[MODE], g_quark_from_string(e->change), e); break; } case I3IPC_EVENT_WINDOW: { i3ipcWindowEvent *e = g_slice_new0(i3ipcWindowEvent); e->change = g_strdup(json_object_get_string_member(json_reply, "change")); if (json_object_has_member(json_reply, "container") && !json_object_get_null_member(json_reply, "container")) e->container = i3ipc_con_new(NULL, json_object_get_object_member(json_reply, "container"), conn); g_signal_emit(conn, connection_signals[WINDOW], g_quark_from_string(e->change), e); break; } case I3IPC_EVENT_BARCONFIG_UPDATE: { i3ipcBarconfigUpdateEvent *e = g_slice_new0(i3ipcBarconfigUpdateEvent); e->id = g_strdup(json_object_get_string_member(json_reply, "id")); e->hidden_state = g_strdup(json_object_get_string_member(json_reply, "hidden_state")); e->mode = g_strdup(json_object_get_string_member(json_reply, "mode")); g_signal_emit(conn, connection_signals[BARCONFIG_UPDATE], 0, e); break; } case I3IPC_EVENT_BINDING: { i3ipcBindingEvent *e = g_slice_new0(i3ipcBindingEvent); e->change = g_strdup(json_object_get_string_member(json_reply, "change")); JsonObject *json_binding_info = json_object_get_object_member(json_reply, "binding"); e->binding = g_slice_new0(i3ipcBindingInfo); e->binding->command = g_strdup(json_object_get_string_member(json_binding_info, "command")); e->binding->input_code = json_object_get_int_member(json_binding_info, "input_code"); e->binding->input_type = g_strdup(json_object_get_string_member(json_binding_info, "input_type")); e->binding->symbol = g_strdup(json_object_get_string_member(json_binding_info, "symbol")); JsonArray *mods = json_object_get_array_member(json_binding_info, "mods"); gint mods_len = json_array_get_length(mods); for (int i = 0; i < mods_len; i += 1) { e->binding->mods = g_slist_append(e->binding->mods, g_strdup(json_array_get_string_element(mods, i))); } g_signal_emit(conn, connection_signals[BINDING], g_quark_from_string(e->change), e); break; } default: g_warning("got unknown event\n"); break; } g_object_unref(parser); g_free(reply); return TRUE; }
static gboolean as_app_parse_shell_extension_data (AsbPlugin *plugin, AsApp *app, const gchar *data, gsize len, GError **error) { JsonArray *json_array; JsonNode *json_root; JsonObject *json_obj; const gchar *tmp; g_autoptr(JsonParser) json_parser = NULL; /* parse the data */ json_parser = json_parser_new (); if (!json_parser_load_from_data (json_parser, data, (gssize) len, error)) return FALSE; json_root = json_parser_get_root (json_parser); if (json_root == NULL) { g_set_error_literal (error, ASB_PLUGIN_ERROR, ASB_PLUGIN_ERROR_FAILED, "no root"); return FALSE; } json_obj = json_node_get_object (json_root); if (json_obj == NULL) { g_set_error_literal (error, ASB_PLUGIN_ERROR, ASB_PLUGIN_ERROR_FAILED, "no object"); return FALSE; } as_app_set_kind (app, AS_APP_KIND_SHELL_EXTENSION); as_app_set_comment (app, NULL, "GNOME Shell Extension"); if (asb_context_get_flag (plugin->ctx, ASB_CONTEXT_FLAG_ADD_DEFAULT_ICONS)) { as_app_add_category (AS_APP (app), "Addons"); as_app_add_category (AS_APP (app), "ShellExtensions"); } tmp = json_object_get_string_member (json_obj, "uuid"); if (tmp != NULL) { g_autofree gchar *id = NULL; id = as_utils_appstream_id_build (tmp); as_app_set_id (app, id); as_app_add_metadata (AS_APP (app), "shell-extensions::uuid", tmp); } if (json_object_has_member (json_obj, "gettext-domain")) { tmp = json_object_get_string_member (json_obj, "gettext-domain"); if (tmp != NULL) { g_autoptr(AsTranslation) transaction = NULL; transaction = as_translation_new (); as_translation_set_kind (transaction, AS_TRANSLATION_KIND_GETTEXT); as_translation_set_id (transaction, tmp); as_app_add_translation (app, transaction); } } if (json_object_has_member (json_obj, "name")) { tmp = json_object_get_string_member (json_obj, "name"); if (tmp != NULL) as_app_set_name (app, NULL, tmp); } if (json_object_has_member (json_obj, "description")) { tmp = json_object_get_string_member (json_obj, "description"); if (tmp != NULL) { g_autofree gchar *desc = NULL; desc = as_markup_import (tmp, AS_MARKUP_CONVERT_FORMAT_SIMPLE, error); if (desc == NULL) return FALSE; as_app_set_description (app, NULL, desc); } } if (json_object_has_member (json_obj, "url")) { tmp = json_object_get_string_member (json_obj, "url"); if (tmp != NULL) as_app_add_url (app, AS_URL_KIND_HOMEPAGE, tmp); } if (json_object_has_member (json_obj, "original-authors")) { json_array = json_object_get_array_member (json_obj, "original-authors"); if (json_array != NULL) { tmp = json_array_get_string_element (json_array, 0); as_app_set_developer_name (app, NULL, tmp); } } if (as_app_get_release_default (app) == NULL && json_object_has_member (json_obj, "shell-version")) { json_array = json_object_get_array_member (json_obj, "shell-version"); if (json_array != NULL) { g_autoptr(AsRelease) release = NULL; tmp = json_array_get_string_element (json_array, 0); release = as_release_new (); as_release_set_state (release, AS_RELEASE_STATE_INSTALLED); as_release_set_version (release, tmp); as_app_add_release (app, release); } } /* use a stock icon */ if (asb_context_get_flag (plugin->ctx, ASB_CONTEXT_FLAG_ADD_DEFAULT_ICONS)) { g_autoptr(AsIcon) ic = as_icon_new (); as_icon_set_kind (ic, AS_ICON_KIND_STOCK); as_icon_set_name (ic, "application-x-addon-symbolic"); as_app_add_icon (app, ic); } return TRUE; }
static void pb_got_phone_thread(PushBulletAccount *pba, JsonNode *node, gpointer user_data) { PurpleAccount *account = pba->account; PurpleConnection *pc = pba->pc; JsonObject *rootobj = json_node_get_object(node); JsonObject *data = json_object_get_object_member(rootobj, "data"); JsonArray *thread = json_object_get_array_member(data, "thread"); gint i; guint len; gchar *from = user_data; PurpleConversation *conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, from, account); gint purple_last_message_timestamp = purple_account_get_int(account, "last_message_timestamp", 0); gint newest_phone_message_id = purple_account_get_int(account, "newest_phone_message_id", 0); /* {"id":"652","type":"sms","timestamp":1440484608,"direction":"outgoing","body":"message","status":"sent"}, {"id":"5","type":"mms","timestamp":1440484096,"direction":"incoming","recipient_index":0,"body":"","image_urls":["url1234"]} */ for(i = json_array_get_length(thread); i > 0; i--) { JsonObject *message = json_array_get_object_element(thread, i - 1); gint64 timestamp = json_object_get_int_member(message, "timestamp"); const gchar *direction = json_object_get_string_member(message, "direction"); const gchar *body = json_object_get_string_member(message, "body"); gint id = atoi(json_object_get_string_member(message, "id")); if (timestamp > purple_last_message_timestamp || id > newest_phone_message_id) { gchar *body_html = purple_strdup_withhtml(body); if (direction[0] != 'o') { serv_got_im(pc, from, body_html, PURPLE_MESSAGE_RECV, timestamp); } else { const gchar *guid = json_object_get_string_member(message, "guid"); if (!guid || !g_hash_table_remove(pba->sent_messages_hash, guid)) { if (conv == NULL) { conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, from); } purple_conversation_write(conv, from, body_html, PURPLE_MESSAGE_SEND, timestamp); } } g_free(body_html); if (json_object_has_member(message, "image_urls")) { JsonArray *image_urls = json_object_get_array_member(message, "image_urls"); guint j, image_urls_len; if (conv == NULL) { conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, from); } for(j = 0, image_urls_len = json_array_get_length(image_urls); j < image_urls_len; j++) { const gchar *image_url = json_array_get_string_element(thread, j); pb_download_image_to_conv(image_url, conv); } } purple_account_set_int(account, "last_message_timestamp", MAX(purple_account_get_int(account, "last_message_timestamp", 0), timestamp)); purple_account_set_int(account, "newest_phone_message_id", MAX(purple_account_get_int(account, "newest_phone_message_id", 0), id)); } } g_free(from); }