static void
get_properties_cb_4 (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
NMBluezDevice *self = NM_BLUEZ_DEVICE (user_data);
NMBluezDevicePrivate *priv = NM_BLUEZ_DEVICE_GET_PRIVATE (self);
GError *err = NULL;
GVariant *v_properties, *v_dict;
GVariantType *v_type;
v_properties = g_dbus_proxy_call_finish (priv->proxy, res, &err);
if (!v_properties) {
nm_log_warn (LOGD_BT, "bluez[%s] error getting device properties: %s",
priv->path, err && err->message ? err->message : "(unknown)");
g_error_free (err);
g_signal_emit (self, signals[INITIALIZED], 0, FALSE);
goto END;
}
v_type = g_variant_type_new ("(a{sv})");
if (g_variant_is_of_type (v_properties, v_type)) {
v_dict = g_variant_get_child_value (v_properties, 0);
_set_properties (self, v_dict);
g_variant_unref (v_dict);
} else {
nm_log_warn (LOGD_BT, "bluez[%s] GetProperties returns unexpected result of type %s", priv->path, g_variant_get_type_string (v_properties));
}
g_variant_type_free (v_type);
g_variant_unref (v_properties);
/* Check if any connections match this device */
load_connections (self);
priv->initialized = TRUE;
g_signal_emit (self, signals[INITIALIZED], 0, TRUE);
check_emit_usable (self);
END:
g_object_unref (self);
}
static gboolean
ide_language_defaults_migrate (GKeyFile *key_file,
gint current_version,
gint new_version,
GError **error)
{
gchar **groups;
gsize i;
g_assert (key_file);
g_assert (current_version >= 0);
g_assert (current_version >= 0);
g_assert (new_version > current_version);
groups = g_key_file_get_groups (key_file, NULL);
for (i = 0; groups [i]; i++)
{
const gchar *group = groups [i];
g_autoptr(GSettings) settings = NULL;
g_autofree gchar *lang_path = NULL;
gchar **keys;
gsize j;
g_assert (group != NULL);
if (g_str_equal (group, "global"))
continue;
lang_path = g_strdup_printf (PATH_BASE"%s/", group);
g_assert(lang_path);
settings = g_settings_new_with_path (SCHEMA_ID, lang_path);
g_assert (G_IS_SETTINGS (settings));
keys = g_key_file_get_keys (key_file, group, NULL, NULL);
g_assert (keys);
for (j = 0; keys [j]; j++)
{
const gchar *key = keys [j];
g_autoptr(GVariant) default_value = NULL;
g_assert (key);
default_value = g_settings_get_default_value (settings, key);
g_assert (default_value);
/*
* For all of the variant types we support, check to see if the value
* is matching the default schema value. If so, update the key to the
* new override value.
*
* This will not overwrite any change settings for files that the
* user has previously loaded, but will for others. Overriding things
* we have overriden gets pretty nasty, since we change things out
* from under the user.
*
* That may change in the future, but not today.
*/
if (g_variant_is_of_type (default_value, G_VARIANT_TYPE_STRING))
{
g_autofree gchar *current_str = NULL;
g_autofree gchar *override_str = NULL;
const gchar *default_str;
default_str = g_variant_get_string (default_value, NULL);
current_str = g_settings_get_string (settings, key);
override_str = g_key_file_get_string (key_file, group, key, NULL);
if (0 == g_strcmp0 (default_str, current_str))
g_settings_set_string (settings, key, override_str);
}
else if (g_variant_is_of_type (default_value, G_VARIANT_TYPE_BOOLEAN))
{
gboolean current_bool;
gboolean override_bool;
gboolean default_bool;
default_bool = g_variant_get_boolean (default_value);
current_bool = g_settings_get_boolean (settings, key);
override_bool = g_key_file_get_boolean (key_file, group, key, NULL);
if (default_bool != current_bool)
g_settings_set_boolean (settings, key, override_bool);
}
else if (g_variant_is_of_type (default_value, G_VARIANT_TYPE_INT32))
{
gint32 current_int32;
gint32 override_int32;
gint32 default_int32;
default_int32 = g_variant_get_int32 (default_value);
current_int32 = g_settings_get_int (settings, key);
override_int32 = g_key_file_get_integer (key_file, group, key, NULL);
if (default_int32 != current_int32)
g_settings_set_int (settings, key, override_int32);
}
else
{
g_error ("Teach me about variant type: %s",
g_variant_get_type_string (default_value));
g_assert_not_reached ();
}
}
}
return TRUE;
}
static int _icd_state_value_from_gvariant(OCRepPayload *repr, GVariantIter *iter)
{
int ret;
char *key;
GVariant *var;
const char *str_value;
OCRepPayload *repr_value;
struct icd_state_list_s value_list = {0};
while (g_variant_iter_loop(iter, "{sv}", &key, &var)) {
if (g_variant_is_of_type(var, G_VARIANT_TYPE_BOOLEAN)) {
OCRepPayloadSetPropBool(repr, key, g_variant_get_boolean(var));
} else if (g_variant_is_of_type(var, G_VARIANT_TYPE_INT32)) {
OCRepPayloadSetPropInt(repr, key, g_variant_get_int32(var));
} else if (g_variant_is_of_type(var, G_VARIANT_TYPE_DOUBLE)) {
OCRepPayloadSetPropDouble(repr, key, g_variant_get_double(var));
} else if (g_variant_is_of_type(var, G_VARIANT_TYPE_STRING)) {
str_value = g_variant_get_string(var, NULL);
if (NULL == str_value) {
ERR("g_variant_get_string() Fail");
_icd_payload_state_list_destroy(&value_list);
return IOTCON_ERROR_OUT_OF_MEMORY;
}
if (IC_STR_EQUAL == strcmp(IC_STR_NULL, str_value))
OCRepPayloadSetNull(repr, key);
else
OCRepPayloadSetPropString(repr, key, str_value);
} else if (g_variant_is_of_type(var, G_VARIANT_TYPE("ay"))) {
OCByteString byte_value;
byte_value.bytes = (uint8_t*)g_variant_get_data(var);
byte_value.len = g_variant_get_size(var);
OCRepPayloadSetPropByteString(repr, key, byte_value);
} else if (g_variant_is_of_type(var, G_VARIANT_TYPE("a{sv}"))) {
GVariantIter state_iter;
repr_value = OCRepPayloadCreate();
g_variant_iter_init(&state_iter, var);
ret = _icd_state_value_from_gvariant(repr_value, &state_iter);
if (IOTCON_ERROR_NONE != ret) {
ERR("_icd_state_value_from_gvariant() Fail(%d)", ret);
_icd_payload_state_list_destroy(&value_list);
OCRepPayloadDestroy(repr_value);
return ret;
}
OCRepPayloadSetPropObjectAsOwner(repr, key, repr_value);
} else if (g_variant_is_of_type(var, G_VARIANT_TYPE_ARRAY)) {
memset(&value_list, 0, sizeof(struct icd_state_list_s));
ret = _icd_state_list_from_gvariant(var, &value_list, 0);
if (IOTCON_ERROR_NONE != ret) {
ERR("_icd_state_list_from_gvariant() Fail(%d)", ret);
_icd_payload_state_list_destroy(&value_list);
return ret;
}
ret = _icd_state_array_from_list(repr, &value_list, key);
if (IOTCON_ERROR_NONE != ret) {
ERR("_icd_state_array_from_list() Fail(%d)", ret);
_icd_payload_state_list_destroy(&value_list);
return ret;
}
} else {
ERR("Invalid type(%s)", g_variant_get_type_string(var));
return IOTCON_ERROR_INVALID_TYPE;
}
}
return IOTCON_ERROR_NONE;
}
static gboolean
dconf_dbus_from_gv (DBusMessageIter *iter,
GVariant *value,
GError **error)
{
switch (g_variant_get_type_class (value))
{
case G_VARIANT_CLASS_BOOLEAN:
{
dbus_bool_t v = g_variant_get_boolean (value);
dbus_message_iter_append_basic (iter, DBUS_TYPE_BOOLEAN, &v);
break;
}
case G_VARIANT_CLASS_BYTE:
{
guint8 v = g_variant_get_byte (value);
dbus_message_iter_append_basic (iter, DBUS_TYPE_BYTE, &v);
break;
}
case G_VARIANT_CLASS_INT16:
{
gint16 v = g_variant_get_int16 (value);
dbus_message_iter_append_basic (iter, DBUS_TYPE_INT16, &v);
break;
}
case G_VARIANT_CLASS_UINT16:
{
guint16 v = g_variant_get_uint16 (value);
dbus_message_iter_append_basic (iter, DBUS_TYPE_UINT16, &v);
break;
}
case G_VARIANT_CLASS_INT32:
{
gint32 v = g_variant_get_int32 (value);
dbus_message_iter_append_basic (iter, DBUS_TYPE_INT32, &v);
break;
}
case G_VARIANT_CLASS_UINT32:
{
guint32 v = g_variant_get_uint32 (value);
dbus_message_iter_append_basic (iter, DBUS_TYPE_UINT32, &v);
break;
}
case G_VARIANT_CLASS_INT64:
{
gint64 v = g_variant_get_int64 (value);
dbus_message_iter_append_basic (iter, DBUS_TYPE_INT64, &v);
break;
}
case G_VARIANT_CLASS_UINT64:
{
guint64 v = g_variant_get_uint64 (value);
dbus_message_iter_append_basic (iter, DBUS_TYPE_UINT64, &v);
break;
}
case G_VARIANT_CLASS_DOUBLE:
{
gdouble v = g_variant_get_double (value);
dbus_message_iter_append_basic (iter, DBUS_TYPE_DOUBLE, &v);
break;
}
case G_VARIANT_CLASS_STRING:
{
const gchar *v = g_variant_get_string (value, NULL);
dbus_message_iter_append_basic (iter, DBUS_TYPE_STRING, &v);
break;
}
case G_VARIANT_CLASS_OBJECT_PATH:
{
const gchar *v = g_variant_get_string (value, NULL);
dbus_message_iter_append_basic (iter, DBUS_TYPE_OBJECT_PATH, &v);
break;
}
case G_VARIANT_CLASS_SIGNATURE:
{
const gchar *v = g_variant_get_string (value, NULL);
dbus_message_iter_append_basic (iter, DBUS_TYPE_SIGNATURE, &v);
break;
}
case G_VARIANT_CLASS_VARIANT:
{
DBusMessageIter sub;
GVariant *child;
child = g_variant_get_child_value (value, 0);
dbus_message_iter_open_container (iter, DBUS_TYPE_VARIANT,
g_variant_get_type_string (child),
&sub);
if (!dconf_dbus_from_gv (&sub, child, error))
{
g_variant_unref (child);
goto fail;
}
dbus_message_iter_close_container (iter, &sub);
g_variant_unref (child);
break;
}
case G_VARIANT_CLASS_ARRAY:
{
DBusMessageIter dbus_iter;
const gchar *type_string;
GVariantIter gv_iter;
GVariant *item;
type_string = g_variant_get_type_string (value);
type_string++; /* skip the 'a' */
dbus_message_iter_open_container (iter, DBUS_TYPE_ARRAY,
type_string, &dbus_iter);
g_variant_iter_init (&gv_iter, value);
while ((item = g_variant_iter_next_value (&gv_iter)))
{
if (!dconf_dbus_from_gv (&dbus_iter, item, error))
{
goto fail;
}
}
dbus_message_iter_close_container (iter, &dbus_iter);
break;
}
case G_VARIANT_CLASS_TUPLE:
{
DBusMessageIter dbus_iter;
GVariantIter gv_iter;
GVariant *item;
dbus_message_iter_open_container (iter, DBUS_TYPE_STRUCT,
NULL, &dbus_iter);
g_variant_iter_init (&gv_iter, value);
while ((item = g_variant_iter_next_value (&gv_iter)))
{
if (!dconf_dbus_from_gv (&dbus_iter, item, error))
goto fail;
}
dbus_message_iter_close_container (iter, &dbus_iter);
break;
}
case G_VARIANT_CLASS_DICT_ENTRY:
{
DBusMessageIter dbus_iter;
GVariant *key, *val;
dbus_message_iter_open_container (iter, DBUS_TYPE_DICT_ENTRY,
NULL, &dbus_iter);
key = g_variant_get_child_value (value, 0);
if (!dconf_dbus_from_gv (&dbus_iter, key, error))
{
g_variant_unref (key);
goto fail;
}
g_variant_unref (key);
val = g_variant_get_child_value (value, 1);
if (!dconf_dbus_from_gv (&dbus_iter, val, error))
{
g_variant_unref (val);
goto fail;
}
g_variant_unref (val);
dbus_message_iter_close_container (iter, &dbus_iter);
break;
}
default:
g_set_error (error,
G_DBUS_ERROR,
G_DBUS_ERROR_CONVERSION_FAILED,
_("Error serializing GVariant with type-string `%s' to a D-Bus message"),
g_variant_get_type_string (value));
goto fail;
}
return TRUE;
fail:
return FALSE;
}
gboolean
systemd_unit_exec(svc_action_t * op, gboolean synchronous)
{
char *unit = NULL;
GError *error = NULL;
gboolean pass = FALSE;
GVariant *_ret = NULL;
const char *action = op->action;
char *name = systemd_service_name(op->agent);
op->rc = PCMK_EXECRA_UNKNOWN_ERROR;
CRM_ASSERT(systemd_init());
crm_debug("Performing %ssynchronous %s op on systemd unit %s named '%s'",
synchronous ? "" : "a", op->action, op->agent, op->rsc);
if (safe_str_eq(op->action, "meta-data")) {
op->stdout_data = systemd_unit_metadata(op->agent);
op->rc = PCMK_EXECRA_OK;
goto cleanup;
}
pass = systemd_unit_by_name(systemd_proxy, op->agent, &unit, NULL, &error);
if (error || pass == FALSE) {
crm_debug("Could not obtain unit named '%s': %s", op->agent,
error ? error->message : "unknown");
if (error && strstr(error->message, "systemd1.NoSuchUnit")) {
op->rc = PCMK_EXECRA_NOT_INSTALLED;
}
g_error_free(error);
goto cleanup;
}
if (safe_str_eq(op->action, "monitor") || safe_str_eq(action, "status")) {
char *state = systemd_unit_property(unit, BUS_NAME ".Unit", "ActiveState");
if (g_strcmp0(state, "active") == 0) {
op->rc = PCMK_EXECRA_OK;
} else {
op->rc = PCMK_EXECRA_NOT_RUNNING;
}
free(state);
goto cleanup;
} else if (g_strcmp0(action, "start") == 0) {
action = "StartUnit";
} else if (g_strcmp0(action, "stop") == 0) {
action = "StopUnit";
} else if (g_strcmp0(action, "restart") == 0) {
action = "RestartUnit";
} else {
op->rc = PCMK_EXECRA_UNIMPLEMENT_FEATURE;
goto cleanup;
}
crm_debug("Calling %s for %s: %s", action, op->rsc, unit);
if (synchronous == FALSE) {
g_dbus_proxy_call(systemd_proxy, action, g_variant_new("(ss)", name, "replace"),
G_DBUS_CALL_FLAGS_NONE, op->timeout, NULL, systemd_unit_exec_done, op);
free(unit);
free(name);
return TRUE;
}
_ret = g_dbus_proxy_call_sync(systemd_proxy, action, g_variant_new("(ss)", name, "replace"),
G_DBUS_CALL_FLAGS_NONE, op->timeout, NULL, &error);
if (error) {
/* ignore "already started" or "not running" errors */
if (safe_str_eq(op->action, "stop")
&& strstr(error->message, "systemd1.InvalidName")) {
crm_trace("Masking Stop failure for %s: unknown services are stopped", op->rsc);
op->rc = PCMK_EXECRA_OK;
} else {
crm_err("Could not issue %s for %s: %s (%s)", action, op->rsc, error->message, unit);
}
g_error_free(error);
} else if(g_variant_is_of_type (_ret, G_VARIANT_TYPE("(o)"))) {
char *path = NULL;
g_variant_get(_ret, "(o)", &path);
crm_info("Call to %s passed: type '%s' %s", op->action, g_variant_get_type_string(_ret),
path);
op->rc = PCMK_EXECRA_OK;
} else {
crm_err("Call to %s passed but return type was '%s' not '(o)'", op->action, g_variant_get_type_string(_ret));
op->rc = PCMK_EXECRA_OK;
}
cleanup:
free(unit);
free(name);
if (_ret) {
g_variant_unref(_ret);
}
if (synchronous == FALSE) {
operation_finalize(op);
return TRUE;
}
return op->rc == PCMK_EXECRA_OK;
}
gboolean
eas_gdbus_call_finish (struct eas_gdbus_client *client, GAsyncResult *result,
guint cancel_serial, const gchar *out_params,
va_list *ap, GError **error)
{
GDBusMessage *reply;
gchar *out_params_type = (gchar *) out_params;
gboolean success = FALSE;
GVariant *v;
reply = g_dbus_connection_send_message_with_reply_finish(client->connection,
result, error);
if (cancel_serial) {
GDBusMessage *message;
message = g_dbus_message_new_method_call (EAS_SERVICE_NAME,
EAS_SERVICE_COMMON_OBJECT_PATH,
EAS_SERVICE_COMMON_INTERFACE,
"cancel_request");
g_dbus_message_set_body (message,
g_variant_new ("(su)",
client->account_uid,
cancel_serial));
g_dbus_connection_send_message (client->connection,
message,
G_DBUS_SEND_MESSAGE_FLAGS_NONE,
NULL, NULL);
g_object_unref (message);
}
if (!reply)
return FALSE;
/* g_variant_is_of_type() will fail to match a DBus return
of (sas) with a format string of (s^as), where the ^ is
required to make it convert to a strv instead of something
more complicated. So we remove all ^ characters from the
string that we show to g_variant_is_of_type(). Ick. */
if (out_params && strchr (out_params, '^')) {
gchar *x, *y;
out_params_type = g_strdup (out_params);
x = y = strchr (out_params_type, '^');
y++;
while (*y) {
if (*y == '^')
y++;
else
*(x++) = *(y++);
}
*x = 0;
}
switch (g_dbus_message_get_message_type (reply)) {
case G_DBUS_MESSAGE_TYPE_METHOD_RETURN:
/* An empty (successful) response will give a NULL GVariant here */
v = g_dbus_message_get_body (reply);
if (!out_params) {
if (v)
goto inval;
else {
success = TRUE;
break;
}
}
if (!g_variant_is_of_type (v, G_VARIANT_TYPE (out_params_type))) {
inval:
g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
"ActiveSync DBus call returned invalid response type %s",
v?g_variant_get_type_string (v):"()");
goto out;
g_object_unref (reply);
}
g_variant_get_va (v, out_params, NULL, ap);
success = TRUE;
break;
case G_DBUS_MESSAGE_TYPE_ERROR:
g_dbus_message_to_gerror (reply, error);
break;
default:
g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
"EAS DBus call returned weird message type %d",
g_dbus_message_get_message_type (reply));
break;
}
out:
if (out_params_type != out_params)
g_free (out_params_type);
g_object_unref (reply);
return success;
}
static void
ide_langserv_symbol_resolver_find_references_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
IdeLangservClient *client = (IdeLangservClient *)object;
g_autoptr(GTask) task = user_data;
g_autoptr(GVariant) reply = NULL;
g_autoptr(GPtrArray) references = NULL;
g_autoptr(GError) error = NULL;
IdeLangservSymbolResolver *self;
GVariant *locationv;
GVariantIter iter;
IDE_ENTRY;
g_assert (IDE_IS_LANGSERV_CLIENT (client));
g_assert (G_IS_ASYNC_RESULT (result));
g_assert (G_IS_TASK (task));
self = g_task_get_source_object (task);
if (!ide_langserv_client_call_finish (client, result, &reply, &error))
{
g_task_return_error (task, g_steal_pointer (&error));
IDE_EXIT;
}
if (!g_variant_is_of_type (reply, G_VARIANT_TYPE ("av")))
{
g_task_return_new_error (task,
G_IO_ERROR,
G_IO_ERROR_INVALID_DATA,
"Invalid reply type from peer: %s",
g_variant_get_type_string (reply));
IDE_EXIT;
}
references = g_ptr_array_new_with_free_func ((GDestroyNotify)ide_source_range_unref);
g_variant_iter_init (&iter, reply);
while (g_variant_iter_loop (&iter, "v", &locationv))
{
g_autoptr(IdeSourceLocation) begin_loc = NULL;
g_autoptr(IdeSourceLocation) end_loc = NULL;
g_autoptr(IdeSourceRange) range = NULL;
g_autoptr(IdeFile) ifile = NULL;
const gchar *uri = NULL;
GFile *gfile;
gboolean success;
struct {
gint64 line;
gint64 line_offset;
} begin, end;
success = JSONRPC_MESSAGE_PARSE (locationv,
"uri", JSONRPC_MESSAGE_GET_STRING (&uri),
"range", "{",
"start", "{",
"line", JSONRPC_MESSAGE_GET_INT64 (&begin.line),
"character", JSONRPC_MESSAGE_GET_INT64 (&begin.line_offset),
"}",
"end", "{",
"line", JSONRPC_MESSAGE_GET_INT64 (&end.line),
"character", JSONRPC_MESSAGE_GET_INT64 (&end.line_offset),
"}",
"}"
);
if (!success)
{
g_task_return_new_error (task,
G_IO_ERROR,
G_IO_ERROR_INVALID_DATA,
"Failed to parse location object");
IDE_EXIT;
}
gfile = g_file_new_for_uri (uri);
ifile = ide_file_new (ide_object_get_context (IDE_OBJECT (self)), gfile);
begin_loc = ide_source_location_new (ifile, begin.line, begin.line_offset, 0);
end_loc = ide_source_location_new (ifile, end.line, end.line_offset, 0);
range = ide_source_range_new (begin_loc, end_loc);
g_ptr_array_add (references, g_steal_pointer (&range));
}
g_task_return_pointer (task, g_steal_pointer (&references), (GDestroyNotify)g_ptr_array_unref);
IDE_EXIT;
}
static gboolean
gs_plugin_steam_update_store_app (GsPlugin *plugin,
AsStore *store,
GHashTable *app,
GError **error)
{
const gchar *name;
GVariant *tmp;
guint32 gameid;
gchar *app_id;
g_autofree gchar *cache_basename = NULL;
g_autofree gchar *cache_fn = NULL;
g_autofree gchar *gameid_str = NULL;
g_autofree gchar *html = NULL;
g_autofree gchar *uri = NULL;
g_autoptr(AsApp) item = NULL;
/* this is the key */
tmp = g_hash_table_lookup (app, "gameid");
if (tmp == NULL)
return TRUE;
gameid = g_variant_get_uint32 (tmp);
/* valve use the name as the application ID, not the gameid */
tmp = g_hash_table_lookup (app, "name");
if (tmp == NULL)
return TRUE;
name = g_variant_get_string (tmp, NULL);
app_id = g_strdup_printf ("%s.desktop", name);
/* already exists */
if (as_store_get_app_by_id (store, app_id) != NULL) {
g_debug ("already exists %" G_GUINT32_FORMAT ", skipping", gameid);
return TRUE;
}
/* create application with the gameid as the key */
g_debug ("parsing steam %" G_GUINT32_FORMAT, gameid);
item = as_app_new ();
as_app_set_kind (item, AS_APP_KIND_DESKTOP);
as_app_set_project_license (item, "Steam");
as_app_set_id (item, app_id);
as_app_set_name (item, NULL, name);
as_app_add_category (item, "Game");
as_app_add_kudo_kind (item, AS_KUDO_KIND_MODERN_TOOLKIT);
as_app_set_comment (item, NULL, "Available on Steam");
/* this is for the GNOME Software plugin */
gameid_str = g_strdup_printf ("%" G_GUINT32_FORMAT, gameid);
as_app_add_metadata (item, "X-Steam-GameID", gameid_str);
as_app_add_metadata (item, "GnomeSoftware::Plugin", "steam");
/* ban certains apps based on the name */
if (g_strstr_len (name, -1, "Dedicated Server") != NULL)
as_app_add_veto (item, "Dedicated Server");
/* oslist */
tmp = g_hash_table_lookup (app, "oslist");
if (tmp == NULL) {
as_app_add_veto (item, "No operating systems listed");
} else if (g_strstr_len (g_variant_get_string (tmp, NULL), -1, "linux") == NULL) {
as_app_add_veto (item, "No Linux support");
}
/* url: homepage */
tmp = g_hash_table_lookup (app, "homepage");
if (tmp != NULL)
as_app_add_url (item, AS_URL_KIND_HOMEPAGE, g_variant_get_string (tmp, NULL));
/* developer name */
tmp = g_hash_table_lookup (app, "developer");
if (tmp != NULL)
as_app_set_developer_name (item, NULL, g_variant_get_string (tmp, NULL));
/* type */
tmp = g_hash_table_lookup (app, "type");
if (tmp != NULL) {
const gchar *kind = g_variant_get_string (tmp, NULL);
if (g_strcmp0 (kind, "DLC") == 0 ||
g_strcmp0 (kind, "Config") == 0 ||
g_strcmp0 (kind, "Tool") == 0)
as_app_add_veto (item, "type is %s", kind);
}
/* don't bother saving apps with failures */
if (as_app_get_vetos(item)->len > 0)
return TRUE;
/* icons */
tmp = g_hash_table_lookup (app, "clienticns");
if (tmp != NULL) {
g_autoptr(GError) error_local = NULL;
g_autofree gchar *ic_uri = NULL;
ic_uri = g_strdup_printf ("https://steamcdn-a.akamaihd.net/steamcommunity/public/images/apps/%" G_GUINT32_FORMAT "/%s.icns",
gameid, g_variant_get_string (tmp, NULL));
if (!gs_plugin_steam_download_icon (plugin, item, ic_uri, &error_local)) {
g_warning ("Failed to parse clienticns: %s",
error_local->message);
}
}
/* try clienticon */
if (as_app_get_icons(item)->len == 0) {
tmp = g_hash_table_lookup (app, "clienticon");
if (tmp != NULL) {
g_autoptr(GError) error_local = NULL;
g_autofree gchar *ic_uri = NULL;
ic_uri = g_strdup_printf ("http://cdn.akamai.steamstatic.com/steamcommunity/public/images/apps/%" G_GUINT32_FORMAT "/%s.ico",
gameid, g_variant_get_string (tmp, NULL));
if (!gs_plugin_steam_download_icon (plugin, item, ic_uri, &error_local)) {
g_warning ("Failed to parse clienticon: %s",
error_local->message);
}
}
}
/* fall back to a resized logo */
if (as_app_get_icons(item)->len == 0) {
tmp = g_hash_table_lookup (app, "logo");
if (tmp != NULL) {
AsIcon *icon = NULL;
g_autofree gchar *ic_uri = NULL;
ic_uri = g_strdup_printf ("http://cdn.akamai.steamstatic.com/steamcommunity/public/images/apps/%" G_GUINT32_FORMAT "/%s.jpg",
gameid, g_variant_get_string (tmp, NULL));
icon = as_icon_new ();
as_icon_set_kind (icon, AS_ICON_KIND_REMOTE);
as_icon_set_url (icon, ic_uri);
as_app_add_icon (item, icon);
}
}
/* size */
tmp = g_hash_table_lookup (app, "maxsize");
if (tmp != NULL) {
/* string when over 16Gb... :/ */
if (g_strcmp0 (g_variant_get_type_string (tmp), "u") == 0) {
g_autofree gchar *val = NULL;
val = g_strdup_printf ("%" G_GUINT32_FORMAT,
g_variant_get_uint32 (tmp));
as_app_add_metadata (item, "X-Steam-Size", val);
} else {
as_app_add_metadata (item, "X-Steam-Size",
g_variant_get_string (tmp, NULL));
}
}
/* download page from the store */
cache_basename = g_strdup_printf ("%s.html", gameid_str);
cache_fn = gs_utils_get_cache_filename ("steam",
cache_basename,
GS_UTILS_CACHE_FLAG_WRITEABLE,
error);
if (cache_fn == NULL)
return FALSE;
if (!g_file_test (cache_fn, G_FILE_TEST_EXISTS)) {
g_autoptr(GsApp) app_dl = gs_app_new (gs_plugin_get_name (plugin));
uri = g_strdup_printf ("http://store.steampowered.com/app/%s/", gameid_str);
if (!gs_plugin_download_file (plugin,
app_dl,
uri,
cache_fn,
NULL, /* GCancellable */
error))
return FALSE;
}
/* get screenshots and descriptions */
if (!g_file_get_contents (cache_fn, &html, NULL, error)) {
gs_utils_error_convert_gio (error);
return FALSE;
}
if (!gs_plugin_steam_update_screenshots (item, html, error))
return FALSE;
if (!gs_plugin_steam_update_description (item, html, error))
return FALSE;
/* add */
as_store_add_app (store, item);
return TRUE;
}
/**
* fwupd_result_from_kv:
**/
static void
fwupd_result_from_kv (FwupdResult *result, const gchar *key, GVariant *value)
{
if (g_strcmp0 (key, FWUPD_RESULT_KEY_DEVICE_FLAGS) == 0) {
fwupd_result_set_device_flags (result, g_variant_get_uint64 (value));
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_DEVICE_CREATED) == 0) {
fwupd_result_set_device_created (result, g_variant_get_uint64 (value));
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_DEVICE_MODIFIED) == 0) {
fwupd_result_set_device_modified (result, g_variant_get_uint64 (value));
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_GUID) == 0) {
fwupd_result_set_guid (result, g_variant_get_string (value, NULL));
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_DEVICE_NAME) == 0) {
fwupd_result_set_device_name (result, g_variant_get_string (value, NULL));
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_DEVICE_VENDOR) == 0) {
fwupd_result_set_device_vendor (result, g_variant_get_string (value, NULL));
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_UPDATE_TRUST_FLAGS) == 0) {
fwupd_result_set_update_trust_flags (result, g_variant_get_uint64 (value));
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_UPDATE_ID) == 0) {
fwupd_result_set_update_id (result, g_variant_get_string (value, NULL));
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_DEVICE_DESCRIPTION) == 0) {
fwupd_result_set_device_description (result, g_variant_get_string (value, NULL));
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_UPDATE_FILENAME) == 0) {
fwupd_result_set_update_filename (result, g_variant_get_string (value, NULL));
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_DEVICE_CHECKSUM) == 0) {
fwupd_result_set_device_checksum (result, g_variant_get_string (value, NULL));
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_DEVICE_CHECKSUM_KIND) == 0) {
fwupd_result_set_device_checksum_kind (result, g_variant_get_uint32 (value));
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_UPDATE_LICENSE) == 0) {
fwupd_result_set_update_license (result, g_variant_get_string (value, NULL));
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_UPDATE_NAME) == 0) {
fwupd_result_set_update_name (result, g_variant_get_string (value, NULL));
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_UPDATE_ERROR) == 0) {
fwupd_result_set_update_error (result, g_variant_get_string (value, NULL));
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_UPDATE_STATE) == 0) {
/* old daemon version and new client */
if (g_strcmp0 (g_variant_get_type_string (value), "s") == 0) {
FwupdUpdateState tmp;
tmp = fwupd_update_state_from_string (g_variant_get_string (value, NULL));
fwupd_result_set_update_state (result, tmp);
} else {
fwupd_result_set_update_state (result, g_variant_get_uint32 (value));
}
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_DEVICE_PROVIDER) == 0) {
fwupd_result_set_device_provider (result, g_variant_get_string (value, NULL));
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_UPDATE_SIZE) == 0) {
fwupd_result_set_update_size (result, g_variant_get_uint64 (value));
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_UPDATE_SUMMARY) == 0) {
fwupd_result_set_update_summary (result, g_variant_get_string (value, NULL));
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_UPDATE_DESCRIPTION) == 0) {
fwupd_result_set_update_description (result, g_variant_get_string (value, NULL));
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_UPDATE_CHECKSUM) == 0) {
fwupd_result_set_update_checksum (result, g_variant_get_string (value, NULL));
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_UPDATE_CHECKSUM_KIND) == 0) {
fwupd_result_set_update_checksum_kind (result, g_variant_get_uint32 (value));
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_UPDATE_URI) == 0) {
fwupd_result_set_update_uri (result, g_variant_get_string (value, NULL));
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_UPDATE_HOMEPAGE) == 0) {
fwupd_result_set_update_homepage (result, g_variant_get_string (value, NULL));
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_UPDATE_VERSION) == 0) {
fwupd_result_set_update_version (result, g_variant_get_string (value, NULL));
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_UPDATE_VENDOR) == 0) {
fwupd_result_set_update_vendor (result, g_variant_get_string (value, NULL));
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_DEVICE_VERSION) == 0) {
fwupd_result_set_device_version (result, g_variant_get_string (value, NULL));
return;
}
if (g_strcmp0 (key, FWUPD_RESULT_KEY_DEVICE_VERSION_LOWEST) == 0) {
fwupd_result_set_device_version_lowest (result, g_variant_get_string (value, NULL));
return;
}
}
void AbstractDBusInterface::handleMyMethodCall(GDBusConnection *connection,
const gchar *sender,
const gchar *object_path,
const gchar *interface_name,
const gchar *method_name,
GVariant *parameters,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
std::string method = method_name;
AbstractDBusInterface* iface = static_cast<AbstractDBusInterface*>(user_data);
if(DebugOut::getDebugThreshhold() >= 6)
{
DebugOut(6)<<"DBus method call from: "<<sender<< " pid: " <<getPid(sender)<< " interface: "<<interface_name<<" method: "<<method<<endl;
DebugOut(6)<<"DBus method call path: "<<object_path<<endl;
}
g_assert(iface);
if(std::string(interface_name) == "org.freedesktop.DBus.Properties")
{
if(method == "Get")
{
gchar* propertyName = nullptr;
gchar* ifaceName = nullptr;
g_variant_get(parameters, "(ss)", &ifaceName, &propertyName);
DebugOut(6) << "Parameter signature: " << g_variant_get_type_string(parameters) << endl;
// DebugOut(6) << "Get property " << propertyName << " for interface " << ifaceName << endl;
GError* error = nullptr;
auto value = AbstractDBusInterface::getProperty(connection, sender, object_path, ifaceName, propertyName, &error, iface);
amb::make_super(error);
if(!value)
{
g_dbus_method_invocation_return_dbus_error(invocation, std::string(std::string(ifaceName)+".PropertyNotFound").c_str(), "Property not found in interface");
}
g_dbus_method_invocation_return_value(invocation, g_variant_new("(v)", value));
return;
}
else if(method == "GetAll")
{
gchar* ifaceName = nullptr;
g_variant_get(parameters, "(s)", &ifaceName);
GVariantBuilder builder;
g_variant_builder_init(&builder, G_VARIANT_TYPE("a{sv}"));
auto propertyMap = iface->getProperties();
for(auto itr : propertyMap)
{
auto prop = itr.second;
GError* error = nullptr;
auto value = AbstractDBusInterface::getProperty(connection, sender, object_path, ifaceName, prop->name().c_str(), &error, iface);
amb::make_super(error);
g_variant_builder_add(&builder, "{sv}", prop->name().c_str(), g_variant_new("v", value));
//sequence
auto sequence = AbstractDBusInterface::getProperty(connection, sender, object_path, ifaceName, std::string(prop->name()+"Sequence").c_str(), &error, iface);
g_variant_builder_add(&builder, "{sv}", std::string(prop->name()+"Sequence").c_str(), g_variant_new("v", sequence));
auto quality = AbstractDBusInterface::getProperty(connection, sender, object_path, ifaceName, std::string(prop->name()+"ValueQuality").c_str(), &error, iface);
g_variant_builder_add(&builder, "{sv}", std::string(prop->name()+"ValueQuality").c_str(), g_variant_new("v", quality));
auto freq = AbstractDBusInterface::getProperty(connection, sender, object_path, ifaceName, std::string(prop->name()+"UpdateFrequency").c_str(), &error, iface);
g_variant_builder_add(&builder, "{sv}", std::string(prop->name()+"UpdateFrequency").c_str(), g_variant_new("v", freq));
}
auto time = AbstractDBusInterface::getProperty(connection, sender, object_path, ifaceName, "Time", nullptr, iface);
auto zone = AbstractDBusInterface::getProperty(connection, sender, object_path, ifaceName, "Zone", nullptr, iface);
g_variant_builder_add(&builder, "{sv}", "Time", g_variant_new("v", time));
g_variant_builder_add(&builder, "{sv}", "Zone", g_variant_new("v", zone));
g_dbus_method_invocation_return_value(invocation, g_variant_new("(a{sv})", &builder));
return;
}
else if(method == "Set")
{
gchar* ifaceName = nullptr;
gchar* propName = nullptr;
GVariant* value;
g_variant_get(parameters, "(ssv)", &ifaceName, &propName, &value);
AbstractDBusInterface::setProperty(connection, sender, object_path, ifaceName, propName, value, nullptr, iface,
[&invocation, &ifaceName](bool success, AsyncPropertyReply::Error error) {
if(success)
{
g_dbus_method_invocation_return_value(invocation, nullptr);
}
else
{
g_dbus_method_invocation_return_dbus_error(invocation, ifaceName, AsyncPropertyReply::errorToStr(error).c_str());
}
});
return;
}
}
else if(method == "GetHistory")
{
double beginTime = 0;
double endTime = 0;
g_variant_get(parameters, "(dd)", &beginTime, &endTime);
auto propertyMap = iface->getProperties();
PropertyList propertyList;
for(auto itr = propertyMap.begin(); itr != propertyMap.end(); itr++)
{
VariantType* prop = (*itr).second;
if(!contains(propertyList, prop->ambPropertyName()))
propertyList.push_back(prop->ambPropertyName());
}
std::string ifaceName = iface->interfaceName();
AsyncRangePropertyRequest request;
request.properties = propertyList;
request.timeBegin = beginTime;
request.timeEnd = endTime;
request.zone = iface->zone();
//request.sourceUuid = iface->source();
request.completed = [&invocation,&ifaceName](AsyncRangePropertyReply* r)
{
auto reply = amb::make_unique(r);
if(!reply->success)
{
stringstream str;
str<<"Error during request: "<<AsyncPropertyReply::errorToStr(reply->error);
ifaceName += ".Error";
g_dbus_method_invocation_return_dbus_error(invocation, ifaceName.c_str(), str.str().c_str());
return;
}
if(!reply->values.size())
{
ifaceName += ".Error";
g_dbus_method_invocation_return_dbus_error(invocation, ifaceName.c_str(), "No results");
return;
}
GVariantBuilder builder;
g_variant_builder_init(&builder, G_VARIANT_TYPE("a{svd}"));
for(auto itr = reply->values.begin(); itr != reply->values.end(); itr++)
{
AbstractPropertyType* value = *itr;
g_variant_builder_add(&builder, "{svd}", value->name.c_str(), g_variant_ref(value->toVariant()),value->timestamp);
}
g_dbus_method_invocation_return_value(invocation,g_variant_new("(a{svd})",&builder));
};
iface->re->getRangePropertyAsync(request);
return;
}
g_dbus_method_invocation_return_error(invocation,G_DBUS_ERROR,G_DBUS_ERROR_UNKNOWN_METHOD, "Unknown method.");
}
