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